feat(cli): add headless mode for non-TTY environments

[SupremaLex]

Problem

scell -d (and scell ls / stop / cleanup) crash with No such device or address (os error 6) when stdout is not a TTY:

$ scell -d /path/to/project
Error:
   0: No such device or address (os error 6)

This makes shell-cell unusable from CI, scripts, agents (e.g. Claude Code), nohup, container init systems — any environment without an interactive terminal. The --detach flag specifically advertises a non-interactive use case, yet was the most prominently broken path.

Why -d didn't work

src/cli/run/mod.rs calls Terminal::new() before the detach branch:

pub async fn run(...) -> Result<()> {
    let buildkit = BuildKitD::start().await?;
    let mut terminal = Terminal::new()?;   // ← always runs, even when detached
    let res = App::run(&buildkit, ..., detach, ..., &mut terminal).await;
    ratatui::try_restore()?;
    res
}

Terminal::new() enables crossterm raw mode (tcsetattr + ioctl on stdout fd). The kernel returns ENXIO when the fd isn't a real TTY, so Terminal::new() aborts before any detach logic runs.

The same pattern exists in ls/mod.rs, stop/mod.rs, and cleanup/mod.rs — all unconditionally initialise the TUI even though their work (listing/stopping/removing containers) is naturally plain text. So 4 of 5 subcommands were headless-unusable; only init worked (it never touched Terminal).

A latent panic in src/cli/run/app/preparing/ui.rs:45 compounded the problem under script-wrapped PTYs:

let area_width = area_width.saturating_sub(5);
line.chars().chunks(area_width)   // itertools panics on chunks(0)

When the render area is ≤5 cols (or 0, which can happen when terminal width can't be detected), the app panics with assertion failed: size != 0.

Why it works now

1. Auto-detect non-TTY via std::io::IsTerminal on stdout in Cli::exec_inner. Non-TTY stdout implicitly enables --headless; --headless implicitly enables --detach for run (an interactive shell session still needs a TTY).
2. Explicit --headless flag for forcing headless mode even on a TTY (useful for scripted invocations).
3. run::run skips Terminal::new() when detached, dispatching to a new App::run_headless() that reuses the existing PreparingState — same tokio task, same channels — but drains build logs to stderr instead of rendering them. Business logic is shared with the TUI path; only the sink differs.
4. PreparingState::prepare propagates UserError through tx in detach mode instead of hanging on future::pending() forever. TUI behaviour preserved when interactive.
5. ls / stop / cleanup gain headless.rs siblings that call the same BuildKitD::{list,stop,cleanup}_* methods used by the TUI state machines and print plain text:
   • ls: tab-aligned table (NAME STATUS TARGET LOCATION FLAGS).
   • stop: stopped <name> per success / error: failed to stop <name>: <err> per failure / stopped N, failed M summary, non-zero exit on any failure.
   • cleanup: removed container/image <name> per item / same error+summary format / non-zero exit on any failure.
6. chunks(area_width.saturating_sub(5).max(1)) clamps the preparing UI splitter so the latent size != 0 panic can't fire on tiny terminals.

Routing summary:

stdout	flag	run behaviour
TTY	none	TUI + attach interactive shell (unchanged)
TTY	-d	TUI + detach (unchanged)
TTY	--headless	headless, implicit detach
non-TTY	any	auto-headless, implicit detach

subcommand	TTY	non-TTY
init	plain text (unchanged)	plain text (unchanged)
ls	TUI	plain-text table
stop	TUI	line-per-action summary
cleanup	TUI	line-per-action summary
run	TUI	auto-headless build, container stays up

Verified

• cargo build --release — clean
• cargo clippy --all-targets --release — clean (strict pedantic config kept)
• cargo test -- --test-threads 1 — 107 / 107 passed
• Manual smoke from a non-TTY shell:

  $ scell <path>           # auto-detach, builds, container hangs
  $ scell ls               # plain table
  $ scell stop             # stopped <name> + summary
  $ scell cleanup --all    # removed container/image lines + summary
  

🤖 Generated with Claude Code