letmecook 0.0.15 → 0.0.17

package/src/ui/background-warning.ts

@@ -0,0 +1,196 @@
+import {
+  type CliRenderer,
+  TextRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  type KeyEvent,
+} from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import { showFooter, hideFooter } from "./common/footer";
+import { isEscape } from "./common/keyboard";
+import type { BackgroundProcess } from "../process-registry";
+
+export type QuitWarningChoice = "continue" | "kill" | "cancel";
+
+export function showQuitWarning(
+  renderer: CliRenderer,
+  processes: BackgroundProcess[],
+): Promise<QuitWarningChoice> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Background processes running");
+
+    const warning = new TextRenderable(renderer, {
+      id: "warning",
+      content: `${processes.length} background process${processes.length > 1 ? "es" : ""} still running:`,
+      fg: "#f59e0b",
+      marginBottom: 1,
+    });
+    content.add(warning);
+
+    // List the running processes
+    processes.forEach((proc, i) => {
+      const processInfo = new TextRenderable(renderer, {
+        id: `process-${i}`,
+        content: `  • ${proc.description}`,
+        fg: "#94a3b8",
+      });
+      content.add(processInfo);
+    });
+
+    const question = new TextRenderable(renderer, {
+      id: "question",
+      content: "What would you like to do?",
+      fg: "#e2e8f0",
+      marginTop: 1,
+    });
+    content.add(question);
+
+    const select = new SelectRenderable(renderer, {
+      id: "quit-warning-select",
+      width: 38,
+      height: 3,
+      options: [
+        { name: "Keep running & quit", description: "", value: "continue" },
+        { name: "Kill all & quit", description: "", value: "kill" },
+        { name: "Cancel", description: "", value: "cancel" },
+      ],
+      showDescription: false,
+      backgroundColor: "transparent",
+      focusedBackgroundColor: "transparent",
+      selectedBackgroundColor: "#334155",
+      textColor: "#e2e8f0",
+      selectedTextColor: "#38bdf8",
+      marginTop: 1,
+    });
+    content.add(select);
+
+    select.focus();
+
+    const handleSelect = (_index: number, option: { value: string }) => {
+      cleanup();
+      resolve(option.value as QuitWarningChoice);
+    };
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (isEscape(key)) {
+        cleanup();
+        resolve("cancel");
+      }
+    };
+
+    const cleanup = () => {
+      select.off(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+      renderer.keyInput.off("keypress", handleKeypress);
+      select.blur();
+      hideFooter(renderer);
+      clearLayout(renderer);
+    };
+
+    showFooter(renderer, content, {
+      navigate: true,
+      select: true,
+      back: true,
+    });
+
+    select.on(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}
+
+export type SessionStartWarningChoice = "continue" | "cancel";
+
+export function showSessionStartWarning(
+  renderer: CliRenderer,
+  processes: BackgroundProcess[],
+): Promise<SessionStartWarningChoice> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Background processes detected");
+
+    const warning = new TextRenderable(renderer, {
+      id: "warning",
+      content: `${processes.length} background process${processes.length > 1 ? "es" : ""} still running for this session:`,
+      fg: "#f59e0b",
+      marginBottom: 1,
+    });
+    content.add(warning);
+
+    // List the running processes
+    processes.forEach((proc, i) => {
+      const processInfo = new TextRenderable(renderer, {
+        id: `process-${i}`,
+        content: `  • ${proc.description}`,
+        fg: "#94a3b8",
+      });
+      content.add(processInfo);
+    });
+
+    const note = new TextRenderable(renderer, {
+      id: "note",
+      content: "Some repositories may not be fully cloned yet.",
+      fg: "#94a3b8",
+      marginTop: 1,
+    });
+    content.add(note);
+
+    const question = new TextRenderable(renderer, {
+      id: "question",
+      content: "Continue with session?",
+      fg: "#e2e8f0",
+      marginTop: 1,
+    });
+    content.add(question);
+
+    const select = new SelectRenderable(renderer, {
+      id: "session-warning-select",
+      width: 38,
+      height: 2,
+      options: [
+        { name: "Continue anyway", description: "", value: "continue" },
+        { name: "Cancel", description: "", value: "cancel" },
+      ],
+      showDescription: false,
+      backgroundColor: "transparent",
+      focusedBackgroundColor: "transparent",
+      selectedBackgroundColor: "#334155",
+      textColor: "#e2e8f0",
+      selectedTextColor: "#38bdf8",
+      marginTop: 1,
+    });
+    content.add(select);
+
+    select.focus();
+
+    const handleSelect = (_index: number, option: { value: string }) => {
+      cleanup();
+      resolve(option.value as SessionStartWarningChoice);
+    };
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (isEscape(key)) {
+        cleanup();
+        resolve("cancel");
+      }
+    };
+
+    const cleanup = () => {
+      select.off(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+      renderer.keyInput.off("keypress", handleKeypress);
+      select.blur();
+      hideFooter(renderer);
+      clearLayout(renderer);
+    };
+
+    showFooter(renderer, content, {
+      navigate: true,
+      select: true,
+      back: true,
+    });
+
+    select.on(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}

package/src/ui/common/command-runner.ts

@@ -1,6 +1,9 @@
-import { type CliRenderer, TextRenderable } from "@opentui/core";
+import { type CliRenderer, TextRenderable, type Renderable, type KeyEvent } from "@opentui/core";
 import { createBaseLayout, clearLayout } from "../renderer";
-import { readProcessOutputWithBuffer } from "../../utils/stream";
+import { readProcessOutputWithControl } from "../../utils/stream";
+import { showFooter, hideFooter } from "./footer";
+import { isAbort, isSkip, isBackground } from "./keyboard";
+import { registerBackgroundProcess } from "../../process-registry";
 
 export interface CommandTask {
   label: string; // "Cloning microsoft/playwright"
@@ -13,14 +16,21 @@ export interface CommandRunnerOptions {
   tasks: CommandTask[]; // Array of commands to run
   showOutput?: boolean; // Show last N lines (default: true)
   outputLines?: number; // How many lines to show (default: 5)
+  allowAbort?: boolean; // Show 'a' Abort
+  allowSkip?: boolean; // Show 's' Skip (multi-task only)
+  allowBackground?: boolean; // Show 'b' Background
+  sessionName?: string; // Session name for tracking backgrounded processes
 }
 
+export type TaskOutcome = "completed" | "error" | "aborted" | "skipped" | "backgrounded";
+
 export interface CommandResult {
   task: CommandTask;
   success: boolean;
   exitCode: number;
   output: string[];
   error?: string;
+  outcome: TaskOutcome;
 }
 
 let taskTexts: TextRenderable[] = [];
@@ -28,7 +38,16 @@ let currentCommandText: TextRenderable | null = null;
 let outputText: TextRenderable | null = null;
 let tasksLabel: TextRenderable | null = null;
 
-function getStatusIcon(status: "pending" | "running" | "done" | "error"): {
+export type TaskStatus =
+  | "pending"
+  | "running"
+  | "done"
+  | "error"
+  | "aborted"
+  | "skipped"
+  | "backgrounded";
+
+function getStatusIcon(status: TaskStatus): {
   icon: string;
   color: string;
 } {
@@ -39,6 +58,12 @@ function getStatusIcon(status: "pending" | "running" | "done" | "error"): {
       return { icon: "[~]", color: "#fbbf24" };
     case "error":
       return { icon: "[✗]", color: "#ef4444" };
+    case "aborted":
+      return { icon: "[X]", color: "#ef4444" };
+    case "skipped":
+      return { icon: "[>]", color: "#f59e0b" };
+    case "backgrounded":
+      return { icon: "[~]", color: "#38bdf8" };
     case "pending":
     default:
       return { icon: "[ ]", color: "#94a3b8" };
@@ -49,7 +74,8 @@ export function showCommandRunner(
   renderer: CliRenderer,
   options: CommandRunnerOptions,
 ): {
-  taskStatuses: Array<{ task: CommandTask; status: "pending" | "running" | "done" | "error" }>;
+  taskStatuses: Array<{ task: CommandTask; status: TaskStatus }>;
+  content: Renderable;
 } {
   clearLayout(renderer);
   taskTexts = [];
@@ -106,12 +132,12 @@ export function showCommandRunner(
     content.add(outputText);
   }
 
-  return { taskStatuses };
+  return { taskStatuses, content };
 }
 
 export function updateCommandRunner(
   renderer: CliRenderer,
-  taskStatuses: Array<{ task: CommandTask; status: "pending" | "running" | "done" | "error" }>,
+  taskStatuses: Array<{ task: CommandTask; status: TaskStatus }>,
   currentTaskIndex?: number,
   outputLines?: string[],
 ): void {
@@ -143,6 +169,7 @@ export function updateCommandRunner(
 }
 
 export function hideCommandRunner(renderer: CliRenderer): void {
+  hideFooter(renderer);
   clearLayout(renderer);
   taskTexts = [];
   currentCommandText = null;
@@ -150,94 +177,265 @@ export function hideCommandRunner(renderer: CliRenderer): void {
   tasksLabel = null;
 }
 
+type ControlAction = "abort" | "skip" | "background" | null;
+
 export async function runCommands(
   renderer: CliRenderer,
   options: CommandRunnerOptions,
 ): Promise<CommandResult[]> {
-  const { tasks, showOutput = true, outputLines = 5 } = options;
-
-  const { taskStatuses } = showCommandRunner(renderer, options);
+  const {
+    tasks,
+    showOutput = true,
+    outputLines = 5,
+    allowAbort = false,
+    allowSkip = false,
+    allowBackground = false,
+    sessionName,
+  } = options;
+
+  const { taskStatuses, content } = showCommandRunner(renderer, options);
   const results: CommandResult[] = [];
 
-  for (let i = 0; i < tasks.length; i++) {
-    const task = tasks[i];
-    const taskState = taskStatuses[i];
+  // Track control state
+  let controlAction: ControlAction = null;
+  let abortAll = false;
+  let currentProc: ReturnType<typeof Bun.spawn> | null = null;
+  let backgroundResolve: (() => void) | null = null;
 
-    if (!task || !taskState) continue;
+  // Build footer hints
+  const footerHints: string[] = [];
+  if (allowAbort) {
+    footerHints.push(tasks.length > 1 ? "a Abort All" : "a Abort");
+  }
+  if (allowSkip && tasks.length > 1) {
+    footerHints.push("s Skip");
+  }
+  if (allowBackground) {
+    footerHints.push("b Background");
+  }
 
-    // Update status to running
-    taskState.status = "running";
-    updateCommandRunner(renderer, taskStatuses, i, []);
+  // Show footer with control options
+  if (footerHints.length > 0) {
+    showFooter(renderer, content, {
+      navigate: false,
+      select: false,
+      back: false,
+      custom: footerHints,
+    });
+    renderer.requestRender();
+  }
 
-    try {
-      const proc = Bun.spawn(task.command, {
-        cwd: task.cwd,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
+  // Set up keyboard listener
+  const keyHandler = (key: KeyEvent) => {
+    if (allowAbort && isAbort(key)) {
+      controlAction = "abort";
+      abortAll = true;
+      if (currentProc) {
+        currentProc.kill("SIGTERM");
+      }
+    } else if (allowSkip && tasks.length > 1 && isSkip(key)) {
+      controlAction = "skip";
+      if (currentProc) {
+        currentProc.kill("SIGTERM");
+      }
+    } else if (allowBackground && isBackground(key)) {
+      controlAction = "background";
+      // Don't kill - just detach, but signal to move on
+      if (backgroundResolve) {
+        backgroundResolve();
+        backgroundResolve = null;
+      }
+    }
+  };
 
-      let outputBuffer: string[] = [];
+  // Subscribe to keyboard events via renderer's keyInput
+  if (footerHints.length > 0) {
+    renderer.keyInput.on("keypress", keyHandler);
+  }
 
-      const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
-        maxBufferLines: outputLines,
-        onBufferUpdate: (buffer) => {
-          outputBuffer = buffer;
-          if (showOutput) {
-            updateCommandRunner(renderer, taskStatuses, i, buffer);
-          }
-        },
-      });
+  try {
+    for (let i = 0; i < tasks.length; i++) {
+      const task = tasks[i];
+      const taskState = taskStatuses[i];
 
-      const exitCode = await proc.exited;
+      if (!task || !taskState) continue;
 
-      if (success && exitCode === 0) {
-        taskState.status = "done";
+      // If abort all was triggered, mark remaining tasks as aborted
+      if (abortAll) {
+        taskState.status = "aborted";
         results.push({
           task,
-          success: true,
-          exitCode: 0,
-          output: outputBuffer.length > 0 ? outputBuffer : output,
+          success: false,
+          exitCode: -1,
+          output: [],
+          outcome: "aborted",
+        });
+        updateCommandRunner(renderer, taskStatuses, i, []);
+        continue;
+      }
+
+      // Reset control action for this task
+      controlAction = null;
+
+      // Update status to running
+      taskState.status = "running";
+      updateCommandRunner(renderer, taskStatuses, i, []);
+
+      try {
+        const proc = Bun.spawn(task.command, {
+          cwd: task.cwd,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        currentProc = proc;
+
+        let outputBuffer: string[] = [];
+
+        // Create a promise that resolves when background is requested
+        const backgroundPromise = new Promise<"background">((resolve) => {
+          backgroundResolve = () => resolve("background");
+        });
+
+        // Race between normal completion and background request
+        const streamPromise = readProcessOutputWithControl(proc, {
+          maxBufferLines: outputLines,
+          onBufferUpdate: (buffer) => {
+            outputBuffer = buffer;
+            if (showOutput) {
+              updateCommandRunner(renderer, taskStatuses, i, buffer);
+            }
+          },
+          shouldStop: () => controlAction !== null && controlAction !== "background",
         });
-      } else {
+
+        const raceResult = await Promise.race([
+          streamPromise.then((r) => ({ type: "stream" as const, ...r })),
+          backgroundPromise.then(() => ({ type: "background" as const })),
+        ]);
+
+        backgroundResolve = null;
+        currentProc = null;
+
+        // Extract stream result or create default for background
+        const { success, output, fullOutput, wasInterrupted } =
+          raceResult.type === "stream"
+            ? raceResult
+            : { success: true, output: outputBuffer, fullOutput: "", wasInterrupted: false };
+
+        // Handle control actions
+        if (controlAction === "abort" || abortAll) {
+          taskState.status = "aborted";
+          results.push({
+            task,
+            success: false,
+            exitCode: -1,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            outcome: "aborted",
+          });
+          // abortAll is already set, remaining tasks will be marked as aborted
+        } else if (controlAction === "skip") {
+          taskState.status = "skipped";
+          results.push({
+            task,
+            success: false,
+            exitCode: -1,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            outcome: "skipped",
+          });
+        } else if (controlAction === "background") {
+          taskState.status = "backgrounded";
+
+          // Register the background process for tracking
+          if (proc.pid && sessionName) {
+            await registerBackgroundProcess(
+              proc.pid,
+              task.command.join(" "),
+              task.label,
+              sessionName,
+            );
+          }
+
+          results.push({
+            task,
+            success: true, // Consider backgrounded as success for flow purposes
+            exitCode: 0,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            outcome: "backgrounded",
+          });
+        } else if (wasInterrupted) {
+          // Was interrupted but no specific action (shouldn't happen)
+          taskState.status = "error";
+          results.push({
+            task,
+            success: false,
+            exitCode: -1,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            error: "Command was interrupted",
+            outcome: "error",
+          });
+        } else {
+          // Normal completion
+          const exitCode = await proc.exited;
+
+          if (success && exitCode === 0) {
+            taskState.status = "done";
+            results.push({
+              task,
+              success: true,
+              exitCode: 0,
+              output: outputBuffer.length > 0 ? outputBuffer : output,
+              outcome: "completed",
+            });
+          } else {
+            taskState.status = "error";
+            const errorMsg = fullOutput.trim() || `Command exited with code ${exitCode}`;
+            results.push({
+              task,
+              success: false,
+              exitCode,
+              output: outputBuffer.length > 0 ? outputBuffer : output,
+              error: errorMsg,
+              outcome: "error",
+            });
+          }
+        }
+
+        // Final update with last output
+        if (showOutput) {
+          updateCommandRunner(
+            renderer,
+            taskStatuses,
+            i,
+            outputBuffer.length > 0 ? outputBuffer : output,
+          );
+        } else {
+          updateCommandRunner(renderer, taskStatuses, i);
+        }
+      } catch (error) {
+        currentProc = null;
         taskState.status = "error";
-        const errorMsg = fullOutput.trim() || `Command exited with code ${exitCode}`;
+        const errorMsg = error instanceof Error ? error.message : String(error);
         results.push({
           task,
           success: false,
-          exitCode,
-          output: outputBuffer.length > 0 ? outputBuffer : output,
+          exitCode: 1,
+          output: [],
           error: errorMsg,
+          outcome: "error",
         });
-      }
 
-      // Final update with last output
-      if (showOutput) {
-        updateCommandRunner(
-          renderer,
-          taskStatuses,
-          i,
-          outputBuffer.length > 0 ? outputBuffer : output,
-        );
-      } else {
-        updateCommandRunner(renderer, taskStatuses, i);
-      }
-    } catch (error) {
-      taskState.status = "error";
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      results.push({
-        task,
-        success: false,
-        exitCode: 1,
-        output: [],
-        error: errorMsg,
-      });
-
-      if (showOutput) {
-        updateCommandRunner(renderer, taskStatuses, i, [errorMsg]);
-      } else {
-        updateCommandRunner(renderer, taskStatuses, i);
+        if (showOutput) {
+          updateCommandRunner(renderer, taskStatuses, i, [errorMsg]);
+        } else {
+          updateCommandRunner(renderer, taskStatuses, i);
+        }
       }
     }
+  } finally {
+    // Clean up keyboard listener
+    if (footerHints.length > 0) {
+      renderer.keyInput.off("keypress", keyHandler);
+    }
   }
 
   // Clear current command indicator when done
@@ -245,5 +443,8 @@ export async function runCommands(
     currentCommandText.content = "";
   }
 
+  // Hide footer
+  hideFooter(renderer);
+
   return results;
 }

package/src/ui/common/keyboard.ts

@@ -31,6 +31,11 @@ export const KEYBOARD = {
   // Text input shortcuts
   BACKSPACE: "backspace",
   CTRL_D: "d", // Ctrl+D (handled via ctrl modifier)
+
+  // Command control shortcuts
+  ABORT: "a",
+  SKIP: "s",
+  BACKGROUND: "b",
 } as const;
 
 /**
@@ -93,3 +98,24 @@ export function isNavigation(key: KeyEvent): boolean {
     key.name === KEYBOARD.RIGHT
   );
 }
+
+/**
+ * Check if a key event is Abort (a)
+ */
+export function isAbort(key: Pick<KeyEvent, "name">): boolean {
+  return key.name === KEYBOARD.ABORT;
+}
+
+/**
+ * Check if a key event is Skip (s)
+ */
+export function isSkip(key: Pick<KeyEvent, "name">): boolean {
+  return key.name === KEYBOARD.SKIP;
+}
+
+/**
+ * Check if a key event is Background (b)
+ */
+export function isBackground(key: Pick<KeyEvent, "name">): boolean {
+  return key.name === KEYBOARD.BACKGROUND;
+}

package/src/ui/common/repo-formatter.ts

@@ -16,9 +16,8 @@ export function formatRepoList(repos: RepoSpec[], options: RepoFormatterOptions
 
       if (showMarkers) {
         const branchMarker = repo.branch ? ` (${repo.branch})` : "";
-        const roMarker = repo.readOnly ? " [RO]" : "";
-        const latestMarker = repo.latest ? " [Latest]" : "";
-        text += `${branchMarker}${roMarker}${latestMarker}`;
+        const refMarker = repo.reference ? " [Ref]" : "";
+        text += `${branchMarker}${refMarker}`;
       }
 
       return text;
@@ -33,12 +32,8 @@ export function formatRepoString(repo: RepoSpec): string {
     parts.push(`(${repo.branch})`);
   }
 
-  if (repo.readOnly) {
-    parts.push("[RO]");
-  }
-
-  if (repo.latest) {
-    parts.push("[Latest]");
+  if (repo.reference) {
+    parts.push("[Ref]");
   }
 
   return parts.join(" ");