@abacus-ai/cli 2.0.0-canary.1 → 2.0.0-canary.11

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

@@ -1,132 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,283 +0,0 @@
-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;
-  }
-}