Add CLI flag to disable interactive console/REPL mode

[NotMyself]

Summary

The preview command (and potentially interactive command) launches an interactive REPL console that requires a valid console handle. This prevents running the preview server in non-interactive contexts such as:

• CI/CD pipelines
• Background processes
• IDE integrations (e.g., Claude Code, VS Code tasks)
• Containerized environments
• Any automated tooling

Current Behavior

When running dotnet run -- preview, the server starts successfully but then fails with:

[INFO] Preview server listening at http://localhost:5080
[INFO] Type Ctrl-C or "Exit()" to exit and "Help()" for global methods and properties
> Error: The handle is invalid.

This happens because the REPL attempts to interact with stdin/stdout handles that aren't available in non-interactive contexts.

Proposed Solution

Add a CLI flag such as --no-interactive or --headless to disable the REPL while keeping the preview server running:

dotnet run -- preview --no-interactive

This would allow the preview server to run in daemon/background mode without requiring console interaction.

Alternatives Considered

• Using serve command separately (requires two-step build then serve)
• Spawning in a new terminal window (platform-specific workaround)
• Piping empty stdin (doesn't reliably work)

Environment

• Statiq.Web 1.0.0
• .NET 8.0
• Windows 11 (but issue likely affects all platforms in non-interactive contexts)

[NotMyself]

Root Cause Analysis

After analyzing the source code, here's what's happening:

Call Chain

PreviewCommand (Statiq.Web)
    └── extends InteractiveCommand (Statiq.Framework)
            └── creates ConsoleListener unconditionally
                    └── uses Console APIs that require valid handles

The Problem

ConsoleListener.cs:29-35 - The constructor has a partial guard:

if (!Console.IsInputRedirected)
{
    Console.TreatControlCAsInput = true;  // ← FAILS HERE
    Task.Run(ReadAsync);
}

ConsoleListener.cs:45-208 - The ReadAsync method uses console APIs that require valid handles:

• Console.KeyAvailable
• Console.ReadKey(true)
• Console.CursorLeft, Console.CursorTop
• Console.SetCursorPosition()
• Console.BufferWidth

InteractiveCommand.cs:58 - Creates ConsoleListener unconditionally.

Why !Console.IsInputRedirected isn't enough

That check only catches explicit stdin redirection (like echo "" | dotnet run). It does not detect:

• Processes spawned without a console (CreateNoWindow)
• Containers without a TTY
• IDE task runners / background processes
• SSH sessions without PTY allocation

---

What the REPL Provides

The REPL is a C# scripting environment (Roslyn-based) for debugging:

Properties: Engine, Services, OutputPages, Outputs, Settings, FileSystem, Pipelines

Methods: Execute() (trigger rebuild), Exit()/Quit(), Help(), ResetCache() (preview only)

This is a developer debugging tool for inspecting engine state - not essential for running a preview server. The watch/reload functionality works independently of the REPL.

---

Additional Benefit: Log File Redirection

With --no-interactive, output redirection would finally work:

dotnet run -- preview --no-interactive > preview.log 2>&1

Currently this fails because REPL operations like Console.CursorLeft, Console.SetCursorPosition(), and Console.BufferWidth require a real terminal even when stdout is redirected.

The existing --log-file flag also fails for the same reason:

# Currently fails due to REPL
dotnet run -- preview --log-file preview.log

# Would work with --no-interactive
dotnet run -- preview --no-interactive --log-file preview.log

---

Suggested Fix

1. Add flag to PipelinesCommandSettings.cs:

[CommandOption("--no-interactive")]
[Description("Disables the interactive REPL. For CI/CD, containers, or headless environments.")]
public bool NoInteractive { get; set; }

2. Modify InteractiveCommand.ExecuteEngineAsync():

bool interactiveMode = !commandSettings.NoInteractive && IsConsoleAvailable();

ConsoleListener consoleListener = interactiveMode 
    ? new ConsoleListener(...) 
    : null;

// ... after initial execution ...

if (interactiveMode)
{
    // existing REPL loop
}
else
{
    // Non-interactive: wait for SIGINT/SIGTERM
    logger.LogInformation("Running in non-interactive mode. Press Ctrl+C to exit.");
    try { await Task.Delay(Timeout.Infinite, _cancellationTokenSource.Token); }
    catch (OperationCanceledException) { }
}

3. Add helper method:

private static bool IsConsoleAvailable()
{
    try
    {
        _ = Console.KeyAvailable;  // Throws if no console
        return true;
    }
    catch { return false; }
}

This gives users explicit control while maintaining backward compatibility.