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

package/src/terminal/progress.ts

@@ -0,0 +1,201 @@
+import process from "node:process";
+
+import type { TerminalType } from "./types.js";
+
+import {
+  osc9Progress,
+  osc1337ProgressClear,
+  osc1337ProgressPercent,
+  osc1337ProgressState,
+} from "../lib/ansi.js";
+import { getTerminal } from "./detection.js";
+
+export interface ProgressBarOptions {
+  label?: string;
+  total?: number;
+  current?: number;
+  percentage?: number;
+  state?: "default" | "error" | "warning" | "indeterminate";
+}
+
+/**
+ * Terminals that support the OSC 9;4 progress bar standard or iTerm2's proprietary sequences.
+ */
+const TERMINALS_WITH_PROGRESS: TerminalType[] = [
+  "conemu",
+  "ghostty",
+  "windows-terminal",
+  "WezTerm",
+  "iTerm.app",
+];
+
+let hideTimeoutId: ReturnType<typeof setTimeout> | null = null;
+
+function supportsProgress(terminal: TerminalType): boolean {
+  if (!terminal) {
+    return false;
+  }
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+
+  // Explicitly check our known list
+  if (TERMINALS_WITH_PROGRESS.includes(terminal)) {
+    return true;
+  }
+
+  // Handle case-insensitive or partial matches for safety
+  const term = terminal.toLowerCase();
+  const supported =
+    term.includes("iterm") ||
+    term.includes("ghostty") ||
+    term.includes("wezterm") ||
+    term.includes("conemu");
+  return supported;
+}
+
+function writeToTerminal(data: string): void {
+  process.stdout.write(data);
+}
+
+function getOscState(state: "default" | "error" | "warning" | "indeterminate"): 0 | 1 | 2 | 3 | 4 {
+  switch (state) {
+    case "indeterminate":
+      return 3;
+    case "error":
+      return 2;
+    case "warning":
+      return 4;
+    case "default":
+    default:
+      return 1;
+  }
+}
+
+function clearHideTimeout(): void {
+  if (hideTimeoutId) {
+    clearTimeout(hideTimeoutId);
+    hideTimeoutId = null;
+  }
+}
+
+function scheduleHide(): void {
+  clearHideTimeout();
+  hideTimeoutId = setTimeout(() => {
+    hideProgressImmediate();
+  }, 500);
+}
+
+function hideProgressImmediate(): void {
+  const terminal = getTerminal();
+  if (!supportsProgress(terminal)) {
+    return;
+  }
+
+  // Emit hide sequence for OSC 9;4
+  writeToTerminal(osc9Progress(0));
+
+  // For iTerm2, also emit the clear sequence
+  if (terminal?.toLowerCase().includes("iterm")) {
+    writeToTerminal(osc1337ProgressClear());
+  }
+}
+
+export function showProgress(options: ProgressBarOptions): void;
+export function showProgress<T>(promise: Promise<T>, options?: TrackProgressOptions): Promise<T>;
+export function showProgress<T>(
+  optionsOrPromise: ProgressBarOptions | Promise<T>,
+  trackOptions?: TrackProgressOptions,
+): void | Promise<T> {
+  if (optionsOrPromise instanceof Promise) {
+    return trackProgress(optionsOrPromise, trackOptions);
+  }
+
+  const options = optionsOrPromise;
+  const terminal = getTerminal();
+
+  if (!supportsProgress(terminal)) {
+    return;
+  }
+
+  clearHideTimeout();
+
+  let percentage = 0;
+  if (options.percentage !== undefined) {
+    percentage = options.percentage;
+  } else if (options.total !== undefined && options.current !== undefined && options.total > 0) {
+    percentage = (options.current / options.total) * 100;
+  }
+
+  const state = options.state ?? "default";
+  const oscState = getOscState(state);
+
+  // Broadcast OSC 9;4 as the primary standard (iTerm2 3.5+, Ghostty, ConEmu, WezTerm)
+  writeToTerminal(osc9Progress(oscState, percentage));
+
+  // Additional proprietary sequences for iTerm2 compatibility
+  if (terminal?.toLowerCase().includes("iterm")) {
+    if (state === "indeterminate") {
+      writeToTerminal(osc1337ProgressState(2));
+    } else {
+      writeToTerminal(osc1337ProgressPercent(percentage, options.label));
+      if (percentage >= 100) {
+        writeToTerminal(osc1337ProgressState(1));
+      }
+    }
+  }
+
+  if (state === "error" || percentage >= 100) {
+    scheduleHide();
+  }
+}
+
+export function hideProgress(): void {
+  clearHideTimeout();
+  hideProgressImmediate();
+}
+
+export function updateProgress(options: ProgressBarOptions): void {
+  showProgress(options);
+}
+
+export function completeProgress(label?: string): void {
+  showProgress({ percentage: 100, label });
+  hideProgress();
+  if (process.stdout.isTTY) {
+    process.stdout.write("\n");
+  }
+}
+
+export interface TrackProgressOptions {
+  label?: string;
+  hideOnComplete?: boolean;
+}
+
+export async function trackProgress<T>(
+  promise: Promise<T>,
+  options?: TrackProgressOptions,
+): Promise<T> {
+  const { label, hideOnComplete = true } = options ?? {};
+
+  showProgress({ state: "indeterminate", label });
+
+  try {
+    const result = await promise;
+    showProgress({ percentage: 100, state: "default", label });
+
+    if (hideOnComplete) {
+      scheduleHide();
+    }
+
+    return result;
+  } catch (error) {
+    showProgress({ percentage: 100, state: "error", label });
+
+    if (hideOnComplete) {
+      scheduleHide();
+    }
+
+    throw error;
+  }
+}