RunCommand.cs

using System.CommandLine;
using DeveloperCli.Installation;
using DeveloperCli.Utilities;
using Spectre.Console;

namespace DeveloperCli.Commands;

/// <summary>
///     Command to manage Aspire AppHost lifecycle - start, stop, and monitor the application host.
/// </summary>
public class RunCommand : Command
{
    private const int AspirePort = 9001;
    private const int DashboardPort = 9097;
    private const int ResourceServicePort = 9098;

    public RunCommand() : base("run", "Runs Aspire AppHost (use --watch for hot reload)")
    {
        var watchOption = new Option<bool>("--watch", "-w") { Description = "Enable watch mode for hot reload" };
        var forceOption = new Option<bool>("--force") { Description = "Force start a fresh Aspire AppHost instance, stopping any existing one" };
        var stopOption = new Option<bool>("--stop") { Description = "Stop any running Aspire AppHost instance without starting a new one" };
        var attachOption = new Option<bool>("--attach", "-a") { Description = "Keep the CLI process attached to the Aspire process" };
        var detachOption = new Option<bool>("--detach", "-d") { Description = "Run the Aspire process in detached mode (background)" };
        var publicUrlOption = new Option<string?>("--public-url") { Description = "Set the PUBLIC_URL environment variable for the app (e.g., https://example.ngrok-free.app)" };

        Options.Add(watchOption);
        Options.Add(forceOption);
        Options.Add(stopOption);
        Options.Add(attachOption);
        Options.Add(detachOption);
        Options.Add(publicUrlOption);

        SetAction(parseResult => Execute(
                parseResult.GetValue(watchOption),
                parseResult.GetValue(forceOption),
                parseResult.GetValue(stopOption),
                parseResult.GetValue(attachOption),
                parseResult.GetValue(detachOption),
                parseResult.GetValue(publicUrlOption)
            )
        );
    }

    private static void Execute(bool watch, bool force, bool stop, bool attach, bool detach, string? publicUrl)
    {
        Prerequisite.Ensure(Prerequisite.Dotnet, Prerequisite.Node, Prerequisite.Docker);

        var isRunning = IsAspireRunning();

        if (stop)
        {
            StopAspire();
            return;
        }

        // Validate that either --attach or --detach is specified (but not both)
        if (attach == detach)
        {
            AnsiConsole.MarkupLine("[red]You must specify either --attach (-a) or --detach (-d) mode.[/]");
            Environment.Exit(1);
        }

        if (isRunning)
        {
            if (!force)
            {
                AnsiConsole.MarkupLine($"[yellow]Aspire AppHost is already running on port {AspirePort}. Use --force to force a fresh start or --stop to stop it.[/]");
                Environment.Exit(1);
            }

            StopAspire();
        }

        StartAspireAppHost(watch, attach, publicUrl);
    }

    private static bool IsAspireRunning()
    {
        // Check the main Aspire port
        if (Configuration.IsWindows)
        {
            // Windows: Check all Aspire ports
            var aspirePortsToCheck = new[] { AspirePort, DashboardPort, ResourceServicePort };
            foreach (var port in aspirePortsToCheck)
            {
                var portCheckCommand = $"""powershell -Command "Get-NetTCPConnection -LocalPort {port} -State Listen -ErrorAction SilentlyContinue" """;
                var result = ProcessHelper.StartProcess(portCheckCommand, redirectOutput: true, exitOnError: false);

                if (!string.IsNullOrWhiteSpace(result))
                {
                    return true;
                }
            }
        }
        else
        {
            // macOS/Linux: Original logic - only check main port
            var portCheckCommand = $"lsof -i :{AspirePort} -sTCP:LISTEN -t";
            var result = ProcessHelper.StartProcess(portCheckCommand, redirectOutput: true, exitOnError: false);
            if (!string.IsNullOrWhiteSpace(result))
            {
                return true;
            }
        }

        // Also check if there are any dotnet processes running AppHost (both run and watch modes)
        if (Configuration.IsWindows)
        {
            // Check if any dotnet.exe processes are running with AppHost in the command line
            var appHostProcesses = ProcessHelper.StartProcess("""powershell -Command "Get-Process dotnet -ErrorAction SilentlyContinue | Where-Object {$_.CommandLine -like '*AppHost*'} | Select-Object Id" """, redirectOutput: true, exitOnError: false);
            return !string.IsNullOrWhiteSpace(appHostProcesses) && appHostProcesses.Contains("Id");
        }
        else
        {
            var appHostProcesses = ProcessHelper.StartProcess("pgrep -f dotnet.*AppHost", redirectOutput: true, exitOnError: false);
            return !string.IsNullOrWhiteSpace(appHostProcesses);
        }
    }

    private static void StopAspire()
    {
        AnsiConsole.MarkupLine("[blue]Stopping Aspire AppHost and all related services...[/]");

        if (Configuration.IsWindows)
        {
            // Kill all dotnet and rsbuild-node processes on ports 9000-9999
            var netstatOutput = ProcessHelper.StartProcess("""cmd /c "netstat -ano | findstr LISTENING" """, redirectOutput: true, exitOnError: false);
            if (!string.IsNullOrWhiteSpace(netstatOutput))
            {
                var processedPids = new HashSet<string>();

                foreach (var line in netstatOutput.Split('\n', StringSplitOptions.RemoveEmptyEntries))
                {
                    var parts = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
                    if (parts.Length < 5) continue;

                    var address = parts[1];
                    var portIndex = address.LastIndexOf(':');
                    if (portIndex == -1) continue;

                    if (!int.TryParse(address[(portIndex + 1)..], out var port) || port < 9000 || port > 9999) continue;

                    var pid = parts[^1];
                    if (!processedPids.Add(pid)) continue;

                    var processName = ProcessHelper.StartProcess($"""wmic process where ProcessId={pid} get Name /format:list""", redirectOutput: true, exitOnError: false);

                    if (processName.Contains("dotnet", StringComparison.OrdinalIgnoreCase) ||
                        processName.Contains("rsbuild-node", StringComparison.OrdinalIgnoreCase))
                    {
                        ProcessHelper.StartProcess($"taskkill /F /PID {pid}", redirectOutput: true, exitOnError: false);
                    }
                }
            }

            // Kill specific Aspire-related processes
            var processesToKill = new[] { "Aspire.Dashboard", "dcp", "dcpproc" };
            foreach (var processName in processesToKill)
            {
                ProcessHelper.StartProcess($"taskkill /F /IM {processName}.exe", redirectOutput: true, exitOnError: false);
            }
        }
        else
        {
            // Kill all processes on ports 9000-9999 that belong to our application
            var pidsOutput = ProcessHelper.StartProcess("lsof -i :9000-9999 -sTCP:LISTEN -t", redirectOutput: true, exitOnError: false);
            if (!string.IsNullOrWhiteSpace(pidsOutput))
            {
                foreach (var pid in pidsOutput.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
                {
                    // Use full command line (args) since comm= truncates names on Linux
                    var commandLine = ProcessHelper.StartProcess($"ps -p {pid} -o args=", redirectOutput: true, exitOnError: false).Trim();
                    if (string.IsNullOrWhiteSpace(commandLine)) continue;

                    if (commandLine.Contains(Configuration.SourceCodeFolder, StringComparison.OrdinalIgnoreCase))
                    {
                        ProcessHelper.StartProcess($"kill -9 {pid}", redirectOutput: true, exitOnError: false);
                    }
                }
            }
        }

        // Wait a moment for processes to terminate
        Thread.Sleep(TimeSpan.FromSeconds(2));

        AnsiConsole.MarkupLine("[green]Aspire AppHost stopped successfully.[/]");
    }

    private static void StartAspireAppHost(bool watch, bool attach, string? publicUrl)
    {
        var mode = watch ? "watch" : "run";
        AnsiConsole.MarkupLine($"[blue]Starting Aspire AppHost in {mode} mode ({(attach ? "attached" : "detached")})...[/]");

        if (publicUrl is not null)
        {
            AnsiConsole.MarkupLine($"[blue]Using PUBLIC_URL: {publicUrl}[/]");

            // Check if this is an ngrok URL and start ngrok if needed
            if (publicUrl.Contains(".ngrok-free.app", StringComparison.OrdinalIgnoreCase) ||
                publicUrl.Contains(".ngrok.io", StringComparison.OrdinalIgnoreCase))
            {
                StartNgrokIfNeeded(publicUrl);
            }
        }

        var appHostProjectPath = Path.Combine(Configuration.ApplicationFolder, "AppHost", "AppHost.csproj");
        var command = watch
            ? $"dotnet watch --non-interactive --project {appHostProjectPath}"
            : $"dotnet run --project {appHostProjectPath}";

        if (!attach && Configuration.IsWindows)
        {
            // For Windows in detached mode, use "start" command to truly detach
            var detachedCommand = $"cmd /c start \"Aspire AppHost\" /min {command}";
            ProcessHelper.StartProcess(
                publicUrl is not null ? $"{detachedCommand} --environment PUBLIC_URL={publicUrl}" : detachedCommand,
                Configuration.ApplicationFolder,
                waitForExit: false
            );

            // Give it a moment to start
            Thread.Sleep(2000);
            AnsiConsole.MarkupLine("[green]Aspire AppHost started in detached mode.[/]");
        }
        else
        {
            // Attached mode or non-Windows
            if (publicUrl is not null)
            {
                ProcessHelper.StartProcess(command, Configuration.ApplicationFolder, waitForExit: attach, environmentVariables: ("PUBLIC_URL", publicUrl));
            }
            else
            {
                ProcessHelper.StartProcess(command, Configuration.ApplicationFolder, waitForExit: attach);
            }
        }
    }

    private static void StartNgrokIfNeeded(string publicUrl)
    {
        // First check if ngrok is installed
        var ngrokVersion = ProcessHelper.StartProcess("ngrok version", redirectOutput: true, exitOnError: false);
        if (!ngrokVersion.Contains("ngrok version", StringComparison.OrdinalIgnoreCase))
        {
            AnsiConsole.MarkupLine("[yellow]Ngrok is not installed. Please install ngrok from https://ngrok.com/download[/]");
            AnsiConsole.MarkupLine("[yellow]Continuing without ngrok tunnel...[/]");
            return;
        }

        // Extract the subdomain from the URL
        var uri = new Uri(publicUrl);
        var subdomain = uri.Host.Split('.')[0];

        // Check if ngrok is already running
        bool isNgrokRunning;

        if (Configuration.IsWindows)
        {
            var ngrokProcesses = ProcessHelper.StartProcess("""tasklist /FI "IMAGENAME eq ngrok.exe" """, redirectOutput: true, exitOnError: false);
            isNgrokRunning = ngrokProcesses.Contains("ngrok.exe");
        }
        else
        {
            var ngrokProcesses = ProcessHelper.StartProcess("pgrep -f ngrok", redirectOutput: true, exitOnError: false);
            isNgrokRunning = !string.IsNullOrEmpty(ngrokProcesses);
        }

        if (isNgrokRunning)
        {
            AnsiConsole.MarkupLine("[yellow]Ngrok is already running.[/]");
            return;
        }

        AnsiConsole.MarkupLine("[blue]Starting ngrok tunnel...[/]");

        // Start ngrok in detached mode
        var ngrokCommand = $"ngrok http --url={subdomain}.ngrok-free.app https://localhost:9000";

        // Use shell to handle backgrounding properly on macOS/Linux
        ProcessHelper.StartProcess(
            Configuration.IsWindows ? $"start /B {ngrokCommand}" : $"sh -c \"{ngrokCommand} > /dev/null 2>&1 &\"",
            waitForExit: false
        );

        AnsiConsole.MarkupLine("[green]Ngrok tunnel started successfully.[/]");
    }
}