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

package/src/providers/api-client.tsx

@@ -0,0 +1,43 @@
+import { AbacusClient } from "@codellm/api";
+import { AuthManager } from "@codellm/auth";
+import { createContext, memo, use, useMemo, useState } from "react";
+
+export interface ApiClientContextValue {
+  apiClient: AbacusClient;
+  authManager: AuthManager;
+  authExpired: boolean;
+  setAuthExpired: (expired: boolean) => void;
+  clearAuthExpired: () => void;
+}
+
+export const ApiClientContext = createContext<ApiClientContextValue | null>(null);
+
+export const useApiClient = () => {
+  const ctx = use(ApiClientContext);
+  if (!ctx) throw new Error("useApiClient must be used within ApiClientProvider");
+  return ctx;
+};
+
+export const ApiClientProvider = memo(
+  ({
+    children,
+    client,
+    authManager,
+  }: React.PropsWithChildren<{
+    client: AbacusClient;
+    authManager: AuthManager;
+  }>) => {
+    const [authExpired, setAuthExpired] = useState(false);
+
+    const clearAuthExpired = () => setAuthExpired(false);
+
+    const value = useMemo(
+      () => ({ apiClient: client, authManager, authExpired, setAuthExpired, clearAuthExpired }),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [authExpired, client, authManager],
+    );
+
+    return <ApiClientContext.Provider value={value}>{children}</ApiClientContext.Provider>;
+  },
+);
+ApiClientProvider.displayName = "ApiClientProvider";

package/src/services/logger.ts

@@ -0,0 +1,85 @@
+import { product } from "@codellm/product";
+import { appendFileSync, mkdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+export interface Logger {
+  error(message: string | Error, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  debug(...message: unknown[]): void;
+  trace(message: string, ...args: unknown[]): void;
+}
+
+const LOG_DIR = path.join(homedir(), product.configDirName, product.logsDirName);
+const LOG_FILE = path.join(LOG_DIR, "cli.log");
+
+let dirEnsured = false;
+
+function ensureLogDir(): void {
+  if (dirEnsured) {
+    return;
+  }
+  try {
+    if (!existsSync(LOG_DIR)) {
+      mkdirSync(LOG_DIR, { recursive: true });
+    }
+    dirEnsured = true;
+  } catch {
+    // Silently fail — logging should never crash the app
+  }
+}
+
+function formatArgs(args: unknown[]): string {
+  if (args.length === 0) {
+    return "";
+  }
+  return (
+    " " +
+    args
+      .map((a) => {
+        if (typeof a === "string") {
+          return a;
+        }
+        try {
+          return JSON.stringify(a);
+        } catch {
+          return String(a);
+        }
+      })
+      .join(" ")
+  );
+}
+
+function write(level: string, message: unknown, args: unknown[]): void {
+  ensureLogDir();
+  const timestamp = new Date().toISOString();
+  const msg =
+    message instanceof Error
+      ? `${message.message}${message.stack ? "\n" + message.stack : ""}`
+      : String(message);
+  const line = `[${timestamp}] [${level}] ${msg}${formatArgs(args)}\n`;
+  try {
+    appendFileSync(LOG_FILE, line);
+  } catch {
+    // Silently fail
+  }
+}
+
+export const logger: Logger = {
+  error(message: string | Error, ...args: unknown[]) {
+    write("ERROR", message, args);
+  },
+  warn(message: string, ...args: unknown[]) {
+    write("WARN", message, args);
+  },
+  info(message: string, ...args: unknown[]) {
+    write("INFO", message, args);
+  },
+  debug(...message: unknown[]) {
+    write("DEBUG", message[0] ?? "", message.slice(1));
+  },
+  trace(message: string, ...args: unknown[]) {
+    write("TRACE", message, args);
+  },
+};

package/src/terminal/detection.ts

@@ -0,0 +1,187 @@
+import process from "node:process";
+
+import type { TerminalType } from "./types.js";
+
+const JETBRAIN_IDES = [
+  "pycharm",
+  "intellij",
+  "webstorm",
+  "phpstorm",
+  "rubymine",
+  "clion",
+  "goland",
+  "rider",
+  "datagrip",
+  "appcode",
+  "dataspell",
+  "aqua",
+  "gateway",
+  "fleet",
+  "jetbrains",
+  "androidstudio",
+];
+
+export function getTerminal(logger?: { debug?: (message: string) => void }): TerminalType {
+  if (process.env.CURSOR_TRACE_ID) {
+    logger?.debug?.("Detected Cursor terminal via CURSOR_TRACE_ID");
+    return "cursor";
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("/.cursor-server/")) {
+    logger?.debug?.("Detected Cursor terminal via VSCODE_GIT_ASKPASS_MAIN");
+    return "cursor";
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("/.windsurf-server/")) {
+    logger?.debug?.("Detected Windsurf terminal");
+    return "windsurf";
+  }
+
+  const BUNDLE_ID = process.env.__CFBundleIdentifier?.toLowerCase();
+  if (BUNDLE_ID?.includes("vscodium")) {
+    return "codium";
+  }
+  if (BUNDLE_ID?.includes("windsurf")) {
+    return "windsurf";
+  }
+  if (BUNDLE_ID?.includes("com.google.android.studio")) {
+    return "androidstudio";
+  }
+  if (BUNDLE_ID) {
+    for (const IDE of JETBRAIN_IDES) {
+      if (BUNDLE_ID.includes(IDE)) {
+        return IDE;
+      }
+    }
+  }
+
+  if (process.env.VisualStudioVersion) {
+    return "visualstudio";
+  }
+  if (process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm") {
+    return "pycharm";
+  }
+  if (process.env.TERM === "xterm-ghostty") {
+    return "ghostty";
+  }
+  if (process.env.TERM?.includes("kitty")) {
+    return "kitty";
+  }
+  if (process.env.WEZTERM_PANE) {
+    return "WezTerm";
+  }
+  if (process.env.ITERM_SESSION_ID) {
+    return "iTerm.app";
+  }
+  if (process.env.TERM_PROGRAM === "Apple_Terminal") {
+    return "Apple_Terminal";
+  }
+  if (process.env.TERM_PROGRAM) {
+    return process.env.TERM_PROGRAM;
+  }
+  if (process.env.STY) {
+    return "screen";
+  }
+  if (process.env.KONSOLE_VERSION) {
+    return "konsole";
+  }
+  if (process.env.GNOME_TERMINAL_SERVICE) {
+    return "gnome-terminal";
+  }
+  if (process.env.XTERM_VERSION) {
+    return "xterm";
+  }
+  if (process.env.VTE_VERSION) {
+    return "vte-based";
+  }
+  if (process.env.TERMINATOR_UUID) {
+    return "terminator";
+  }
+  if (process.env.KITTY_WINDOW_ID) {
+    return "kitty";
+  }
+  if (process.env.ALACRITTY_LOG) {
+    return "alacritty";
+  }
+  if (process.env.TILIX_ID) {
+    return "tilix";
+  }
+  if (process.env.WT_SESSION) {
+    return "windows-terminal";
+  }
+  if (process.env.SESSIONNAME && process.env.TERM === "cygwin") {
+    return "cygwin";
+  }
+  if (process.env.MSYSTEM) {
+    return process.env.MSYSTEM.toLowerCase();
+  }
+  if (process.env.ConEmuANSI || process.env.ConEmuPID || process.env.ConEmuTask) {
+    return "conemu";
+  }
+  if (process.env.WSL_DISTRO_NAME) {
+    return `wsl-${process.env.WSL_DISTRO_NAME}`;
+  }
+  if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY) {
+    return "ssh-session";
+  }
+  if (process.env.TERM) {
+    const ENV_TERM = process.env.TERM;
+    if (ENV_TERM.includes("alacritty")) {
+      return "alacritty";
+    }
+    if (ENV_TERM.includes("rxvt")) {
+      return "rxvt";
+    }
+    if (ENV_TERM.includes("termite")) {
+      return "termite";
+    }
+    return process.env.TERM;
+  }
+  if (!process.stdout.isTTY) {
+    logger?.debug?.("Non-interactive terminal detected");
+    return "non-interactive";
+  }
+  logger?.debug?.("Could not detect terminal type");
+  return null;
+}
+
+export function isTerminalSetupSupported(): boolean {
+  const terminal = getTerminal();
+  if (process.platform === "darwin") {
+    return [
+      "iTerm.app",
+      "Apple_Terminal",
+      "vscode",
+      "cursor",
+      "windsurf",
+      "ghostty",
+      "WezTerm",
+    ].includes(terminal ?? "");
+  }
+  return ["vscode", "cursor", "windsurf", "ghostty", "WezTerm", "kitty"].includes(terminal ?? "");
+}
+
+export function getPasteKeyInstruction(): string {
+  if (process.platform === "darwin") return "Cmd+V";
+  if (process.platform === "win32") return "Ctrl+V";
+  return "Ctrl+Shift+V"; // Linux xterm/VTE convention
+}
+
+export function getNewlineInstructions(): string {
+  const terminal = getTerminal();
+
+  switch (terminal) {
+    case "Apple_Terminal":
+      return "Option+Enter";
+    case "cursor":
+    case "windsurf":
+    case "vscode":
+    case "codium":
+    case "iTerm.app":
+    case "ghostty":
+    case "WezTerm":
+    case "kitty":
+    case "alacritty":
+      return "Shift+Enter";
+    default:
+      return "backslash (\\) + Enter";
+  }
+}

package/src/terminal/exit.ts

@@ -0,0 +1,279 @@
+import type { Writable } from "node:stream";
+
+import process from "node:process";
+
+interface ExitHookOptions {
+  wait?: number;
+  streams?: Writable[];
+  logger?: {
+    debug?: (message: string, meta?: any) => void;
+  };
+}
+
+type ExitCallback = (exitCode: number) => void | Promise<void>;
+
+const asyncCallbacks = new Set<[ExitCallback, number]>();
+const syncCallbacks = new Set<ExitCallback>();
+const streamsToDrain = new Set<Writable>();
+
+let isExiting = false;
+let isRegistered = false;
+let originalExit: ((code?: number) => never) | null = null;
+let firstExitCode: number | undefined;
+
+async function drainStreams(streams: Writable[]): Promise<void> {
+  const drainPromises = streams.map((stream) => {
+    return new Promise<void>((resolve) => {
+      const writableLength =
+        "writableLength" in stream ? (stream as { writableLength: number }).writableLength : 0;
+      const bufferSize =
+        "bufferSize" in stream ? (stream as { bufferSize: number }).bufferSize : writableLength;
+
+      if (bufferSize === 0) {
+        resolve();
+        return;
+      }
+
+      const originalWrite = stream.write.bind(stream);
+      let isDrained = false;
+
+      const checkDrain = () => {
+        const currentLength =
+          "writableLength" in stream ? (stream as { writableLength: number }).writableLength : 0;
+        const currentBufferSize =
+          "bufferSize" in stream ? (stream as { bufferSize: number }).bufferSize : currentLength;
+
+        if (currentBufferSize === 0 && !isDrained) {
+          isDrained = true;
+          stream.write = originalWrite;
+          resolve();
+        }
+      };
+
+      stream.once("drain", checkDrain);
+
+      stream.write("", "utf-8", () => {
+        checkDrain();
+      });
+
+      stream.write = function () {
+        return false;
+      };
+    });
+  });
+
+  await Promise.all(drainPromises);
+}
+
+async function executeExit(
+  shouldManuallyExit: boolean,
+  isSynchronous: boolean,
+  signal: number,
+  logger?: { debug?: (message: string, meta?: any) => void },
+): Promise<void> {
+  if (isExiting) {
+    return;
+  }
+
+  logger?.debug?.("Executing exit handlers", {
+    shouldManuallyExit,
+    isSynchronous,
+    signal,
+    asyncCallbacks: asyncCallbacks.size,
+    syncCallbacks: syncCallbacks.size,
+  });
+
+  isExiting = true;
+
+  if (asyncCallbacks.size > 0 && isSynchronous) {
+    console.error(
+      [
+        "SYNCHRONOUS TERMINATION NOTICE:",
+        "When explicitly exiting the process via process.exit or via a parent process,",
+        "asynchronous tasks in your exitHooks will not run. Either remove these tasks,",
+        "use gracefulExit() instead of process.exit(), or ensure your parent process",
+        "sends a SIGINT to the process running this code.",
+      ].join(" "),
+    );
+  }
+
+  let exitCode = 0;
+
+  if (signal > 0) {
+    exitCode = 128 + signal;
+  } else if (firstExitCode !== undefined) {
+    exitCode = firstExitCode;
+  } else if (typeof process.exitCode === "number" || typeof process.exitCode === "string") {
+    exitCode = Number(process.exitCode);
+  }
+
+  const done = (force = false) => {
+    if (force || shouldManuallyExit) {
+      if (originalExit) {
+        originalExit.call(process, exitCode);
+      } else {
+        process.exit(exitCode);
+      }
+    }
+  };
+
+  for (const callback of syncCallbacks) {
+    try {
+      void callback(exitCode);
+    } catch (error) {
+      console.error("Error in synchronous exit hook:", error);
+    }
+  }
+
+  if (isSynchronous) {
+    done();
+    return;
+  }
+
+  const promises: Promise<void>[] = [];
+  let maxWait = 0;
+
+  for (const [callback, wait] of asyncCallbacks) {
+    maxWait = Math.max(maxWait, wait);
+    promises.push(
+      Promise.resolve(callback(exitCode)).catch((error) => {
+        console.error("Error in asynchronous exit hook:", error);
+      }),
+    );
+  }
+
+  const streams = Array.from(streamsToDrain);
+  if (streams.length > 0) {
+    promises.push(drainStreams(streams));
+  }
+
+  const asyncTimer = setTimeout(() => {
+    done(true);
+  }, maxWait);
+
+  try {
+    await Promise.all(promises);
+    clearTimeout(asyncTimer);
+    done();
+  } catch (error) {
+    clearTimeout(asyncTimer);
+    console.error("Error during exit cleanup:", error);
+    done(true);
+  }
+}
+
+function registerExitHandlers(): void {
+  if (isRegistered) {
+    return;
+  }
+
+  isRegistered = true;
+
+  process.once("beforeExit", () => {
+    void executeExit(true, false, -128);
+  });
+
+  process.once("SIGINT", () => {
+    void executeExit(true, false, 2);
+  });
+
+  process.once("SIGTERM", () => {
+    void executeExit(true, false, 15);
+  });
+
+  process.once("exit", () => {
+    void executeExit(false, true, 0);
+  });
+
+  process.on("message", (message) => {
+    if (message === "shutdown") {
+      void executeExit(true, true, -128);
+    }
+  });
+
+  if (!originalExit) {
+    originalExit = process.exit.bind(process) as (code?: number) => never;
+
+    const exitHandler = function (code?: number) {
+      if (firstExitCode === undefined) {
+        firstExitCode = code ?? 0;
+      }
+
+      if (asyncCallbacks.size === 0 && streamsToDrain.size === 0) {
+        if (originalExit) {
+          originalExit(code ?? 0);
+          return;
+        }
+        process.exit(code ?? 0);
+      }
+
+      executeExit(true, false, -128).catch((error) => {
+        console.error("Error during exit:", error);
+        if (originalExit) {
+          originalExit(1);
+        } else {
+          process.exit(1);
+        }
+      });
+    };
+
+    process.exit = exitHandler as typeof process.exit;
+  }
+}
+
+export function onExit(callback: ExitCallback, options?: ExitHookOptions): () => void {
+  if (typeof callback !== "function") {
+    throw new TypeError("callback must be a function");
+  }
+
+  if (isExiting) {
+    throw new Error("Cannot install exit hook while exit handlers are running");
+  }
+
+  options?.logger?.debug?.("Registering exit hook", {
+    wait: options?.wait,
+    hasStreams: options?.streams !== undefined,
+  });
+
+  registerExitHandlers();
+
+  const wait = options?.wait ?? 0;
+  const streams = options?.streams ?? [process.stdout, process.stderr];
+
+  if (wait > 0) {
+    const callbackConfig: [ExitCallback, number] = [callback, wait];
+    asyncCallbacks.add(callbackConfig);
+
+    for (const stream of streams) {
+      streamsToDrain.add(stream);
+    }
+
+    return () => {
+      asyncCallbacks.delete(callbackConfig);
+      for (const stream of streams) {
+        streamsToDrain.delete(stream);
+      }
+    };
+  }
+
+  syncCallbacks.add(callback);
+
+  return () => {
+    syncCallbacks.delete(callback);
+  };
+}
+
+export function gracefulExit(signal?: number): void {
+  if (signal !== undefined) {
+    process.exitCode = signal;
+  }
+
+  void executeExit(true, false, -128);
+}
+
+export function releaseExit(): void {
+  if (originalExit) {
+    process.exit = originalExit;
+    originalExit = null;
+  }
+}

package/src/terminal/notification.ts

@@ -0,0 +1,83 @@
+import process from "node:process";
+
+import { ANSI, osc9, osc777, osc99 } from "../lib/ansi.js";
+import { getTerminal } from "./detection.js";
+
+export interface NotificationOptions {
+  title?: string;
+  message: string;
+  sound?: boolean;
+}
+
+function writeToTerminal(data: string): void {
+  if (process.stdout.isTTY) {
+    process.stdout.write(data);
+  }
+}
+
+function notifyIterm2(title: string, message: string): void {
+  const fullMessage = title ? `${title}:\n${message}` : message;
+  writeToTerminal(osc9(fullMessage));
+}
+
+function notifyKitty(title: string, message: string): void {
+  writeToTerminal(osc99(title, message));
+}
+
+function notifyGhostty(title: string, message: string): void {
+  writeToTerminal(osc777(title, message));
+}
+
+function notifyWindows(_title: string, _message: string): void {
+  // Windows notifications via PowerShell - simplified version
+  // Full implementation would require executing PowerShell script
+  // For now, just ring the bell
+  writeToTerminal(ANSI.BEL);
+}
+
+export async function notify(options: NotificationOptions): Promise<void> {
+  const { title = "Abacus.AI", message } = options;
+  const terminal = getTerminal();
+
+  switch (terminal) {
+    case "iTerm.app":
+      notifyIterm2(title, message);
+      break;
+    case "kitty":
+      notifyKitty(title, message);
+      break;
+    case "ghostty":
+      notifyGhostty(title, message);
+      break;
+    case "WezTerm":
+      notifyIterm2(title, message);
+      break;
+    default:
+      if (process.platform === "win32") {
+        notifyWindows(title, message);
+      }
+      break;
+  }
+}
+
+export async function notifyAction(
+  message: string,
+  options?: Omit<NotificationOptions, "message">,
+): Promise<void> {
+  await notify({
+    ...options,
+    message,
+    title: options?.title ?? "Action Required",
+  });
+}
+
+export async function notifyComplete(
+  message: string,
+  options?: Omit<NotificationOptions, "message">,
+): Promise<void> {
+  await notify({
+    ...options,
+    message,
+    title: options?.title ?? "Task Complete",
+  });
+}