@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/components/composer/modes/bash-handler.tsx

@@ -0,0 +1,132 @@
+import { useCallback, useEffect, useRef, useState, type ReactElement } from "react";
+
+import { BashHandlerState, BashRenderer, CommandHistoryItem } from "./bash-renderer.js";
+import { ModeRenderProps } from "./types.js";
+
+export type BashHandlerApi = {
+  submitCommand: (command: string) => void;
+  renderer: (props: ModeRenderProps) => ReactElement;
+  navigateHistory: (direction: "up" | "down") => string | null;
+  getActivity: () => "idle" | "pending" | "error";
+};
+
+// Maximum number of commands to keep in history to prevent unbounded growth
+const MAX_COMMAND_HISTORY = 1000;
+const MAX_INPUT_HISTORY = 1000;
+
+export function useBashHandler(): BashHandlerApi {
+  const [state, setState] = useState<BashHandlerState>({
+    submittedCommand: null,
+    runId: 0,
+    output: "",
+    isRunning: false,
+  });
+
+  const [commandHistoryItems, setCommandHistoryItems] = useState<CommandHistoryItem[]>([]);
+  const [inputHistory, setInputHistory] = useState<string[]>([]);
+  const [historyIndex, setHistoryIndex] = useState<number>(-1);
+  const shellHistoryLoaded = useRef(false);
+
+  useEffect(() => {
+    if (shellHistoryLoaded.current) return;
+    shellHistoryLoaded.current = true;
+    // @ts-expect-error — shell-history ships no type declarations
+    import("shell-history")
+      .then((mod: { shellHistory?: () => string[]; default?: () => string[] }) => {
+        const fn = mod.shellHistory ?? mod.default;
+        const history: string[] = typeof fn === "function" ? fn() : [];
+        setInputHistory(history.slice(-MAX_INPUT_HISTORY));
+      })
+      .catch(() => {});
+  }, []);
+
+  const submitCommand: BashHandlerApi["submitCommand"] = useCallback((command: string) => {
+    const trimmedCommand = command.trim();
+    if (!trimmedCommand) return;
+
+    // Add to input history for up/down navigation, dedup consecutive identical commands (like HISTCONTROL=ignoredups)
+    setInputHistory((prev) => {
+      if (prev.length > 0 && prev[prev.length - 1] === trimmedCommand) {
+        return prev;
+      }
+      const updated = [...prev, trimmedCommand];
+      return updated.slice(-MAX_INPUT_HISTORY);
+    });
+    setHistoryIndex(-1);
+
+    // Incrementing runId will trigger BashRenderer's useEffect to cancel any previous command
+    setState((prev) => ({
+      submittedCommand: trimmedCommand,
+      runId: prev.runId + 1,
+      output: "",
+      isRunning: true,
+    }));
+  }, []);
+
+  const onCommandComplete = useCallback((output: string) => {
+    // Move the completed command to history, keeping only the most recent MAX_COMMAND_HISTORY items
+    setState((prev) => {
+      if (prev.submittedCommand) {
+        setCommandHistoryItems((history) => {
+          const updated = [...history, { command: prev.submittedCommand!, output }];
+          return updated.slice(-MAX_COMMAND_HISTORY);
+        });
+      }
+
+      // Clear the current command and return to idle
+      return {
+        submittedCommand: null,
+        runId: prev.runId,
+        output: "",
+        isRunning: false,
+      };
+    });
+  }, []);
+
+  const renderer: BashHandlerApi["renderer"] = useCallback(
+    (props: ModeRenderProps) => {
+      return (
+        <BashRenderer
+          state={state}
+          setState={setState}
+          onCommandComplete={onCommandComplete}
+          commandHistory={commandHistoryItems}
+          currentPrompt={props.prompt}
+          availableHeight={props.availableHeight}
+        />
+      );
+    },
+    [state, onCommandComplete, commandHistoryItems],
+  );
+
+  const navigateHistory: BashHandlerApi["navigateHistory"] = useCallback(
+    (direction: "up" | "down") => {
+      if (inputHistory.length === 0) return null;
+
+      let newIndex = historyIndex;
+      if (direction === "up") {
+        // Navigate to previous command, but don't go below index 0 (stays at first command)
+        newIndex = historyIndex === -1 ? inputHistory.length - 1 : Math.max(0, historyIndex - 1);
+      } else {
+        newIndex = historyIndex === -1 ? -1 : historyIndex + 1;
+        if (newIndex >= inputHistory.length) {
+          newIndex = -1;
+        }
+      }
+
+      setHistoryIndex(newIndex);
+      return newIndex === -1 ? "" : inputHistory[newIndex];
+    },
+    [inputHistory, historyIndex],
+  );
+
+  return {
+    submitCommand,
+    renderer,
+    navigateHistory,
+    getActivity: (): "idle" | "pending" | "error" => {
+      if (state.isRunning) return "pending";
+      return "idle";
+    },
+  };
+}

package/src/components/composer/modes/bash-renderer.tsx

@@ -0,0 +1,175 @@
+import { View } from "@codellm/jar";
+import { useEffect, useMemo, useRef } from "react";
+
+import { stripDangerousSequences } from "../../../lib/text-utils.js";
+import { BashRunner } from "../bash-runner.js";
+import { getPersistentShell } from "../persistent-shell.js";
+
+export type BashHandlerState = {
+  submittedCommand: string | null;
+  runId: number;
+  output: string;
+  isRunning: boolean;
+};
+
+export type CommandHistoryItem = {
+  command: string;
+  output: string;
+};
+
+export type BashRendererProps = {
+  state: BashHandlerState;
+  setState: React.Dispatch<React.SetStateAction<BashHandlerState>>;
+  onCommandComplete: (output: string) => void;
+  commandHistory: CommandHistoryItem[];
+  currentPrompt: string;
+  availableHeight: number;
+};
+
+export function BashRenderer({
+  state,
+  setState,
+  onCommandComplete,
+  commandHistory,
+  currentPrompt,
+  availableHeight,
+}: BashRendererProps) {
+  const { submittedCommand, runId } = state;
+  const normalized = useMemo(() => submittedCommand?.trim() || "", [submittedCommand]);
+  const lastRunIdRef = useRef<number>(-1);
+  // Use AbortController for better cancellation handling
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  useEffect(() => {
+    if (!normalized) return;
+    if (runId === lastRunIdRef.current) return;
+    lastRunIdRef.current = runId;
+
+    // Cancel any previous command execution
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+
+    // Create new AbortController for this command
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+
+    setState((prev) => ({ ...prev, isRunning: true, output: "" }));
+    runBash({
+      command: normalized,
+      setOutput: (output: string) => {
+        setState((prev) => ({ ...prev, output }));
+      },
+      signal: abortController.signal,
+    })
+      .then((output) => {
+        // Only process result if not cancelled
+        if (!abortController.signal.aborted) {
+          setState((prev) => ({ ...prev, isRunning: false }));
+          // Call onCommandComplete even when output is empty to signal completion
+          // If output is undefined, it means the command was cancelled, so don't call onCommandComplete
+          if (output !== undefined) {
+            onCommandComplete(output);
+          }
+        }
+      })
+      .catch((_error) => {
+        // Only process error if not cancelled
+        if (!abortController.signal.aborted) {
+          setState((prev) => ({ ...prev, isRunning: false }));
+          // Pass empty string for errors (not undefined, to distinguish from cancellation)
+          onCommandComplete("");
+        }
+      });
+
+    return () => {
+      // Cancel command execution on cleanup
+      abortController.abort();
+      abortControllerRef.current = null;
+    };
+  }, [normalized, runId, setState, onCommandComplete]);
+
+  const isTyping = currentPrompt.trim().length > 0;
+
+  const historyToShow = submittedCommand ? 2 : 3;
+  const displayHistory = commandHistory.slice(-historyToShow);
+  const historyStartIndex = Math.max(0, commandHistory.length - historyToShow);
+
+  const totalCommands = displayHistory.length + (submittedCommand ? 1 : 0);
+
+  const availableForOutput = Math.max(1, availableHeight - totalCommands);
+
+  const maxLinesPerCommand =
+    totalCommands > 0 ? Math.max(3, Math.floor(availableForOutput / totalCommands)) : 10;
+
+  const shouldTruncate = isTyping || availableHeight < 15 || totalCommands > 1;
+
+  return (
+    <View flexDirection="column">
+      {displayHistory.map((item, index) => {
+        // Use the original index from the full commandHistory array to ensure uniqueness
+        // This prevents key conflicts when the slice changes
+        const originalIndex = historyStartIndex + index;
+        return (
+          <BashRunner
+            key={`history-${originalIndex}`}
+            output={item.output}
+            command={item.command}
+            truncate={shouldTruncate}
+            maxLines={maxLinesPerCommand}
+          />
+        );
+      })}
+      {submittedCommand && (
+        <BashRunner
+          key={`submitted-${runId}`}
+          output={state.output}
+          command={normalized || submittedCommand}
+          truncate={shouldTruncate}
+          maxLines={maxLinesPerCommand}
+        />
+      )}
+    </View>
+  );
+}
+
+type RunProps = {
+  command: string;
+  setOutput: (output: string) => void;
+  signal: AbortSignal;
+};
+
+async function runBash({ command, setOutput, signal }: RunProps): Promise<string | undefined> {
+  const shell = getPersistentShell();
+  const { stream, exit } = await shell.executeCommand(command);
+
+  let commandOutput = "";
+  try {
+    for await (const chunk of stream) {
+      // Check for cancellation at the start of each iteration
+      if (signal.aborted) {
+        return undefined;
+      }
+      // Strip dangerous ANSI sequences but preserve colors (claude.js pattern)
+      commandOutput += stripDangerousSequences(chunk.data);
+      // Only update output if not cancelled
+      if (!signal.aborted) {
+        setOutput(commandOutput);
+      }
+    }
+
+    // Check cancellation before waiting for exit
+    if (signal.aborted) {
+      return undefined;
+    }
+
+    await exit;
+    return commandOutput;
+  } catch (error) {
+    // If cancelled, return undefined; otherwise rethrow
+    if (signal.aborted) {
+      return undefined;
+    }
+    throw error;
+  }
+}

package/src/components/composer/modes/default-handlers.tsx

@@ -0,0 +1,33 @@
+import { AgentModeIndicator } from "../agent-mode-indicator.js";
+import { FileMentionPicker } from "../file-mention-picker.js";
+import { Help } from "../help.js";
+import { ComposerMode } from "../types.js";
+import { ModeHandler } from "./types.js";
+
+export function createPromptHandler(): ModeHandler {
+  return {
+    mode: ComposerMode.Prompt,
+    render: ({ prompt: _prompt, hints, availableHeight }) => {
+      return <AgentModeIndicator hints={hints} availableHeight={availableHeight} />;
+    },
+  };
+}
+
+export function createHelpHandler(): ModeHandler {
+  return {
+    mode: ComposerMode.Help,
+    render: ({ availableHeight }) => <Help availableHeight={availableHeight} />,
+  };
+}
+
+export function createFilesHandler(onExit: () => void): ModeHandler {
+  return {
+    mode: ComposerMode.Files,
+    render: ({ prompt: _prompt, availableHeight }) => (
+      <FileMentionPicker onAccept={onExit} onCancel={onExit} availableHeight={availableHeight} />
+    ),
+    shouldPreventDefault: (_input, key) => {
+      return key.upArrow || key.downArrow || key.escape || key.return || key.tab;
+    },
+  };
+}

package/src/components/composer/modes/index.ts

@@ -0,0 +1,41 @@
+import { useMemo } from "react";
+
+import { useCommandHandler } from "../commands/handler.js";
+import { ComposerMode } from "../types.js";
+import { useBashHandler } from "./bash-handler.js";
+import { createPromptHandler, createHelpHandler, createFilesHandler } from "./default-handlers.js";
+import { ModeHandler } from "./types.js";
+
+export function useModeHandlers(onExitFilesMode: () => void, clearBuffer: () => void) {
+  const bashHandler = useBashHandler();
+  const commandHandler = useCommandHandler(clearBuffer);
+
+  const handlers = useMemo(() => {
+    const bashModeHandler: ModeHandler = {
+      mode: ComposerMode.Bash,
+      render: bashHandler.renderer,
+      onSubmit: bashHandler.submitCommand,
+    };
+
+    const commandModeHandler: ModeHandler = {
+      mode: ComposerMode.Command,
+      render: commandHandler.renderer,
+      onSubmit: commandHandler.executeCommand,
+      shouldPreventDefault: commandHandler.shouldPreventDefault,
+    };
+
+    return new Map<ComposerMode, ModeHandler>([
+      [ComposerMode.Prompt, createPromptHandler()],
+      [ComposerMode.Help, createHelpHandler()],
+      [ComposerMode.Bash, bashModeHandler],
+      [ComposerMode.Command, commandModeHandler],
+      [ComposerMode.Files, createFilesHandler(onExitFilesMode)],
+    ]);
+  }, [bashHandler, commandHandler, onExitFilesMode]);
+
+  return {
+    handlers,
+    getActivity: bashHandler.getActivity,
+    bashNavigateHistory: bashHandler.navigateHistory,
+  };
+}

package/src/components/composer/modes/types.ts

@@ -0,0 +1,21 @@
+import type { Key } from "@codellm/jar";
+
+import { ReactNode } from "react";
+
+import type { InterruptHints } from "../../../hooks/use-interrupt-manager.js";
+
+import { ComposerMode } from "../types.js";
+
+export interface ModeHandler {
+  mode: ComposerMode;
+  render: (props: ModeRenderProps) => ReactNode;
+  onSubmit?: (value: string) => void;
+  shouldPreventDefault?: (input: string, key: Key) => boolean;
+}
+
+export interface ModeRenderProps {
+  prompt: string;
+  onExit: () => void;
+  hints?: InterruptHints;
+  availableHeight: number;
+}

package/src/components/composer/persistent-shell.ts

@@ -0,0 +1,283 @@
+import { spawn, ChildProcess } from "node:child_process";
+import * as os from "node:os";
+
+export type StreamChunk = { type: "stdout" | "stderr"; data: string };
+
+// Constants from claude.js patterns
+const GRACEFUL_SHUTDOWN_DELAY_MS = 5000;
+
+// Signals to forward to child processes (claude.js lines 3290-3294)
+const FORWARDED_SIGNALS: NodeJS.Signals[] = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
+
+function getShellCommand(): { command: string; args: string[]; env: Record<string, string> } {
+  const platform = os.platform();
+
+  // Filter out undefined values from process.env
+  const baseEnv: Record<string, string> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined) {
+      baseEnv[key] = value;
+    }
+  }
+
+  if (platform === "win32") {
+    // Windows: Use PowerShell or cmd
+    return {
+      command: process.env.COMSPEC || "cmd.exe",
+      args: [],
+      env: baseEnv,
+    };
+  } else {
+    // Unix-like systems (macOS, Linux)
+    const shell = process.env.SHELL || "/bin/bash";
+    return {
+      command: shell,
+      args: [],
+      env: {
+        ...baseEnv,
+        BASH_SILENCE_DEPRECATION_WARNING: "1", // Silence macOS zsh warning
+        PS1: "", // Disable prompt for bash
+      },
+    };
+  }
+}
+
+export class PersistentShell {
+  private shell: ChildProcess | null = null;
+  private readonly queue: StreamChunk[] = [];
+  private notify: (() => void) | null = null;
+  private isProcessing = false;
+  private destroyed = false;
+  private readonly isWindows: boolean;
+  private readonly signalHandlers = new Map<NodeJS.Signals, (...args: any[]) => void>();
+
+  constructor() {
+    this.isWindows = os.platform() === "win32";
+    this.startShell();
+    this.setupSignalForwarding();
+  }
+
+  /**
+   * Setup signal forwarding to shell process (claude.js pattern).
+   * Forwards SIGUSR1, SIGUSR2, SIGTERM, SIGINT, SIGHUP to child.
+   */
+  private setupSignalForwarding(): void {
+    for (const signal of FORWARDED_SIGNALS) {
+      const handler = () => {
+        if (this.shell && !this.shell.killed && this.shell.exitCode === null) {
+          try {
+            this.shell.kill(signal);
+          } catch {
+            // Ignore errors when forwarding signals
+          }
+        }
+      };
+      this.signalHandlers.set(signal, handler);
+      process.on(signal, handler);
+    }
+  }
+
+  /**
+   * Remove signal handlers during cleanup.
+   */
+  private removeSignalHandlers(): void {
+    for (const [signal, handler] of this.signalHandlers) {
+      process.removeListener(signal, handler);
+    }
+    this.signalHandlers.clear();
+  }
+
+  private startShell(): void {
+    if (this.shell || this.destroyed) {
+      return;
+    }
+
+    const { command, args, env } = getShellCommand();
+
+    // Start a persistent shell session
+    this.shell = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+      cwd: process.cwd(),
+      shell: false, // Don't spawn through another shell
+    });
+
+    if (this.shell.stdin) {
+      // Suppress EPIPE errors — these occur when the shell dies and we try to write
+      this.shell.stdin.on("error", (err: NodeJS.ErrnoException) => {
+        if (err.code !== "EPIPE") {
+          throw err;
+        }
+      });
+    }
+
+    if (this.shell.stdout) {
+      this.shell.stdout.on("data", (chunk: Buffer) => {
+        const data = chunk.toString("utf8");
+        this.queue.push({ type: "stdout", data });
+        if (this.notify) {
+          const n = this.notify;
+          this.notify = null;
+          n();
+        }
+      });
+    }
+
+    if (this.shell.stderr) {
+      this.shell.stderr.on("data", (chunk: Buffer) => {
+        const data = chunk.toString("utf8");
+        // Filter out common shell warnings/deprecation messages
+        const shouldIgnore =
+          data.includes("no job control in this shell") ||
+          data.includes("The default interactive shell is now zsh") ||
+          data.includes("To update your account to use zsh") ||
+          data.includes("please run `chsh -s /bin/zsh`") ||
+          data.includes("For more details, please visit");
+
+        if (!shouldIgnore) {
+          this.queue.push({ type: "stderr", data });
+          if (this.notify) {
+            const n = this.notify;
+            this.notify = null;
+            n();
+          }
+        }
+      });
+    }
+
+    this.shell.on("exit", () => {
+      this.shell = null;
+      // Restart shell if it exits
+      this.startShell();
+    });
+  }
+
+  public async executeCommand(command: string): Promise<{
+    stream: AsyncGenerator<StreamChunk, void, void>;
+    exit: Promise<number>;
+  }> {
+    if (!this.shell || !this.shell.stdin) {
+      throw new Error("Shell not initialized");
+    }
+
+    // Clear any pending output from previous commands
+    this.queue.length = 0;
+
+    const uniqueMarker = `__CMD_END_${Date.now()}_${Math.random().toString(36).substring(7)}__`;
+
+    // Platform-specific command formatting
+    let commandWithMarker: string;
+    if (this.isWindows) {
+      // Windows cmd.exe or PowerShell
+      commandWithMarker = `${command}\necho ${uniqueMarker}\n`;
+    } else {
+      // Unix-like systems (bash, zsh, etc.)
+      commandWithMarker = `${command}\necho "${uniqueMarker}"\n`;
+    }
+
+    this.shell.stdin.write(commandWithMarker);
+    this.isProcessing = true;
+
+    const stream = this.createStream(uniqueMarker);
+    const exit = this.createExitPromise(uniqueMarker);
+
+    return { stream, exit };
+  }
+
+  private async *createStream(marker: string): AsyncGenerator<StreamChunk, void, void> {
+    while (true) {
+      while (this.queue.length > 0) {
+        const item = this.queue.shift();
+        if (!item) {
+          continue;
+        }
+
+        // Check if this chunk contains the marker
+        if (item.data.includes(marker)) {
+          // Remove the marker from the output
+          const cleanedData = item.data.replace(marker, "").replace(/\n$/, "");
+          if (cleanedData) {
+            yield { type: item.type, data: cleanedData };
+          }
+          this.isProcessing = false;
+          return;
+        }
+
+        yield item;
+      }
+
+      if (!this.isProcessing) {
+        return;
+      }
+
+      await new Promise<void>((resolve) => {
+        this.notify = resolve;
+      });
+    }
+  }
+
+  private async createExitPromise(_marker: string): Promise<number> {
+    // Wait for the marker to appear in the output
+    while (this.isProcessing) {
+      await new Promise<void>((resolve) => setTimeout(resolve, 100));
+    }
+    return 0; // Assume success for now
+  }
+
+  /**
+   * Gracefully kill the shell process (claude.js pattern).
+   * Sends SIGTERM first, then SIGKILL after timeout.
+   */
+  private killProcessGracefully(process: ChildProcess): void {
+    try {
+      process.kill("SIGTERM");
+
+      const killTimeout = setTimeout(() => {
+        if (process && !process.killed) {
+          process.kill("SIGKILL");
+        }
+      }, GRACEFUL_SHUTDOWN_DELAY_MS);
+
+      // Unref so timer doesn't keep process alive
+      if (killTimeout.unref) {
+        killTimeout.unref();
+      }
+    } catch {
+      // Ignore errors when killing process
+    }
+  }
+
+  public destroy(): void {
+    this.destroyed = true;
+    // Remove signal handlers first
+    this.removeSignalHandlers();
+
+    if (this.shell) {
+      // Suppress EPIPE errors from stdin after the shell is killed
+      this.shell.stdin?.on("error", (err: NodeJS.ErrnoException) => {
+        if (err.code !== "EPIPE") {
+          throw err;
+        }
+      });
+      this.killProcessGracefully(this.shell);
+      this.shell = null;
+    }
+  }
+}
+
+// Singleton instance
+let shellInstance: PersistentShell | null = null;
+
+export function getPersistentShell(): PersistentShell {
+  if (!shellInstance) {
+    shellInstance = new PersistentShell();
+  }
+  return shellInstance;
+}
+
+export function destroyPersistentShell(): void {
+  if (shellInstance) {
+    shellInstance.destroy();
+    shellInstance = null;
+  }
+}