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

package/src/lib/__tests__/vim-buffer-actions.test.ts

@@ -0,0 +1,154 @@
+// @vitest-environment node
+
+import { describe, expect, it } from "vitest";
+
+import type { TextBufferState } from "../text-buffer.js";
+
+import { handleVimAction, assumeExhaustive } from "../vim-buffer-actions.js";
+
+describe.concurrent("vim-buffer-actions", () => {
+  const createState = (
+    lines: string[] = ["hello world"],
+    cursorRow = 0,
+    cursorCol = 0,
+  ): TextBufferState => ({
+    lines,
+    cursorRow,
+    cursorCol,
+    preferredCol: null,
+    undoStack: [],
+    redoStack: [],
+    clipboard: null,
+    selectionAnchor: null,
+    viewportWidth: 80,
+    viewportHeight: 24,
+    visualLayout: {
+      visualLines: lines,
+      logicalToVisualMap: lines.map((_, i) => [[i, 0]]),
+      visualToLogicalMap: lines.map((_, i) => [i, 0]),
+    },
+  });
+
+  describe.concurrent("assumeExhaustive", () => {
+    it("should be a function", () => {
+      expect(typeof assumeExhaustive).toBe("function");
+    });
+
+    it("should not throw when called", () => {
+      expect(() => assumeExhaustive(null as never)).not.toThrow();
+    });
+  });
+
+  describe.concurrent("handleVimAction", () => {
+    it("should handle vim_move_left", () => {
+      const state = createState(["hello"], 0, 5);
+      const newState = handleVimAction(state, { type: "vim_move_left", payload: { count: 1 } });
+      expect(newState.cursorCol).toBe(4);
+    });
+
+    it("should handle vim_move_right", () => {
+      const state = createState(["hello"], 0, 0);
+      const newState = handleVimAction(state, { type: "vim_move_right", payload: { count: 1 } });
+      expect(newState.cursorCol).toBe(1);
+    });
+
+    it("should handle vim_move_to_line_start", () => {
+      const state = createState(["hello world"], 0, 5);
+      const newState = handleVimAction(state, { type: "vim_move_to_line_start" });
+      expect(newState.cursorCol).toBe(0);
+    });
+
+    it("should handle vim_move_to_line_end", () => {
+      // TODO: IMPROVEMENT - Test should verify exact position. For "hello" (5 chars),
+      // cursor should be at position 4 (last character), not just > 0.
+      // Current implementation: lineLength > 0 ? lineLength - 1 : 0
+      const state = createState(["hello"], 0, 0);
+      const newState = handleVimAction(state, { type: "vim_move_to_line_end" });
+      expect(newState.cursorCol).toBeGreaterThan(0);
+    });
+
+    it("should handle vim_move_to_first_nonwhitespace", () => {
+      const state = createState(["   hello"], 0, 0);
+      const newState = handleVimAction(state, { type: "vim_move_to_first_nonwhitespace" });
+      expect(newState.cursorCol).toBe(3);
+    });
+
+    it("should handle vim_move_to_first_line", () => {
+      const state = createState(["line1", "line2", "line3"], 2, 0);
+      const newState = handleVimAction(state, { type: "vim_move_to_first_line" });
+      expect(newState.cursorRow).toBe(0);
+    });
+
+    it("should handle vim_move_to_last_line", () => {
+      const state = createState(["line1", "line2", "line3"], 0, 0);
+      const newState = handleVimAction(state, { type: "vim_move_to_last_line" });
+      expect(newState.cursorRow).toBe(2);
+    });
+
+    it("should handle vim_move_to_line", () => {
+      // TODO: CLARIFICATION - The API is confusing: lineNumber is 1-indexed (user-facing)
+      // but internally converted to 0-indexed. Consider documenting this clearly or
+      // using a more explicit parameter name like `lineNumberOneIndexed`.
+      // Current behavior: lineNumber 2 -> row index 1 (second line)
+      const state = createState(["line1", "line2", "line3"], 0, 0);
+      const newState = handleVimAction(state, {
+        type: "vim_move_to_line",
+        payload: { lineNumber: 2 },
+      });
+      expect(newState.cursorRow).toBe(1); // 0-indexed
+    });
+
+    it("should handle vim_delete_char", () => {
+      const state = createState(["hello"], 0, 2);
+      const newState = handleVimAction(state, { type: "vim_delete_char", payload: { count: 1 } });
+      expect(newState.lines[0].length).toBeLessThan(state.lines[0].length);
+    });
+
+    it("should handle vim_move_word_forward", () => {
+      const state = createState(["hello world test"], 0, 0);
+      const newState = handleVimAction(state, {
+        type: "vim_move_word_forward",
+        payload: { count: 1 },
+      });
+      expect(newState.cursorCol).toBeGreaterThan(0);
+    });
+
+    it("should handle vim_move_word_backward", () => {
+      const state = createState(["hello world"], 0, 11);
+      const newState = handleVimAction(state, {
+        type: "vim_move_word_backward",
+        payload: { count: 1 },
+      });
+      expect(newState.cursorCol).toBeLessThan(11);
+    });
+
+    it("should handle vim_delete_word_forward", () => {
+      const state = createState(["hello world"], 0, 0);
+      const newState = handleVimAction(state, {
+        type: "vim_delete_word_forward",
+        payload: { count: 1 },
+      });
+      expect(newState.lines[0]).not.toContain("hello");
+    });
+
+    it("should handle vim_delete_to_end_of_line", () => {
+      const state = createState(["hello world"], 0, 5);
+      const newState = handleVimAction(state, { type: "vim_delete_to_end_of_line" });
+      expect(newState.lines[0]).toBe("hello");
+    });
+
+    it("should handle vim_open_line_below", () => {
+      const state = createState(["line1"], 0, 5);
+      const newState = handleVimAction(state, { type: "vim_open_line_below" });
+      expect(newState.lines.length).toBe(2);
+      expect(newState.cursorRow).toBe(1);
+    });
+
+    it("should handle vim_open_line_above", () => {
+      const state = createState(["line1"], 0, 5);
+      const newState = handleVimAction(state, { type: "vim_open_line_above" });
+      expect(newState.lines.length).toBe(2);
+      expect(newState.cursorRow).toBe(0);
+    });
+  });
+});

package/src/lib/ansi.ts

@@ -0,0 +1,150 @@
+export enum ANSI {
+  ESC = "\x1b",
+  BEL = "\x07",
+  ST = "\x1b\\",
+  ENABLE_FOCUS_REPORTING = `${ANSI.ESC}[?1004h`,
+  DISABLE_FOCUS_REPORTING = `${ANSI.ESC}[?1004l`,
+  FOCUS_IN = `${ANSI.ESC}[I`,
+  FOCUS_OUT = `${ANSI.ESC}[O`,
+  SHOW_CURSOR = `${ANSI.ESC}[?25h`,
+  HIDE_CURSOR = `${ANSI.ESC}[?25l`,
+  SET_TITLE = `${ANSI.ESC}]2;`,
+  RESET_SGR = `${ANSI.ESC}[0m`,
+  SOFT_RESET = `${ANSI.ESC}[!p`,
+  HARD_RESET = `${ANSI.ESC}c`,
+  ENABLE_BRACKETED_PASTE = `${ANSI.ESC}[?2004h`,
+  DISABLE_BRACKETED_PASTE = `${ANSI.ESC}[?2004l`,
+  PASTE_MODE_PREFIX = `${ANSI.ESC}[200~`,
+  PASTE_MODE_SUFFIX = `${ANSI.ESC}[201~`,
+  DIM = `${ANSI.ESC}[2m`,
+  BOLD = `${ANSI.ESC}[1m`,
+  RESET_BOLD = `${ANSI.ESC}[22m`,
+  ITALIC = `${ANSI.ESC}[3m`,
+  RESET_ITALIC = `${ANSI.ESC}[23m`,
+  STRIKETHROUGH = `${ANSI.ESC}[9m`,
+  RESET_STRIKETHROUGH = `${ANSI.ESC}[29m`,
+  UNDERLINE = `${ANSI.ESC}[4m`,
+  RESET_UNDERLINE = `${ANSI.ESC}[24m`,
+}
+
+/**
+ * OSC 9 - iTerm2 notification
+ * Format: ESC ] 9 ; message BEL
+ */
+export function osc9(message: string): string {
+  return `${ANSI.ESC}]9;\n\n${message}${ANSI.BEL}`;
+}
+
+/**
+ * OSC 777 - Ghostty/urxvt notification
+ * Format: ESC ] 777 ; notify ; title ; body BEL
+ */
+export function osc777(title: string, body: string): string {
+  return `${ANSI.ESC}]777;notify;${title};${body}${ANSI.BEL}`;
+}
+
+/**
+ * OSC 99 - Kitty desktop notification
+ * Format: ESC ] 99 ; metadata ; payload ST
+ */
+export function osc99(title: string, body: string): string {
+  const notificationId = Math.floor(Math.random() * 10000);
+  const titlePart = `${ANSI.ESC}]99;i=${notificationId}:d=0:p=title;${title}${ANSI.ST}`;
+  const bodyPart = `${ANSI.ESC}]99;i=${notificationId}:p=body;${body}${ANSI.ST}`;
+  const donePart = `${ANSI.ESC}]99;i=${notificationId}:d=1:a=focus;${ANSI.ST}`;
+  return titlePart + bodyPart + donePart;
+}
+
+export type ProgressState = 0 | 1 | 2 | 3 | 4;
+
+/**
+ * OSC 9;4 - Progress bar (ConEmu/Ghostty/iTerm2 style)
+ * Format: ESC ] 9 ; 4 ; state ; progress [BEL/ST]
+ * @param state - 0 (hide), 1 (default), 2 (error), 3 (indeterminate), 4 (warning)
+ * @param progress - Progress percentage (0-100), required when state is 1, 2, or 4
+ */
+export function osc9Progress(state: ProgressState, progress?: number): string {
+  const p = progress !== undefined ? Math.max(0, Math.min(100, Math.round(progress))) : 0;
+  const payload = `9;4;${state};${p}`;
+  // Emit both terminators for maximum compatibility (iTerm2 prefers BEL, Ghostty prefers ST)
+  return `${ANSI.ESC}]${payload}${ANSI.BEL}${ANSI.ESC}]${payload}${ANSI.ST}`;
+}
+
+/**
+ * OSC 1337 - iTerm2 Progress indicator
+ */
+function sanitizeItermValue(value: string): string {
+  return value
+    .replaceAll("\x1b", "")
+    .replaceAll("\x07", "")
+    .replaceAll("\n", " ")
+    .replaceAll("\r", " ")
+    .replaceAll(";", ":")
+    .trim()
+    .slice(0, 120);
+}
+
+function itermOsc(payload: string): string {
+  // Emit both terminators for maximum compatibility: BEL and ST.
+  return `${ANSI.ESC}]${payload}${ANSI.BEL}${ANSI.ESC}]${payload}${ANSI.ST}`;
+}
+
+export function osc1337ProgressClear(): string {
+  return itermOsc("1337;Progress=");
+}
+
+export function osc1337ProgressState(state: 0 | 1 | 2): string {
+  return itermOsc(`1337;Progress=${state}`);
+}
+
+export function osc1337ProgressPercent(percent: number, message?: string): string {
+  const progressValue = Math.max(0, Math.min(100, Math.round(percent)));
+  const msg = message ? sanitizeItermValue(message) : "";
+
+  if (msg) {
+    return (
+      itermOsc(`1337;Progress=${progressValue};${msg}`) +
+      itermOsc(`1337;Progress=message=${msg};percent=${progressValue}`)
+    );
+  }
+
+  return itermOsc(`1337;Progress=${progressValue}`);
+}
+
+/**
+ * Creates a regex pattern that matches ANSI escape sequences
+ * @param options.onlyFirst - If true, matches only the first occurrence
+ * @returns Regular expression for matching ANSI sequences
+ */
+export function ansiRegex({ onlyFirst = false } = {}): RegExp {
+  // Valid string terminator sequences are BEL, ESC\, and 0x9c
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+
+  // OSC sequences only: ESC ] ... ST (non-greedy until the first ST)
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+
+  // CSI and related: ESC/C1, optional intermediates, optional params (supports ; and :) then final byte
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+
+  const pattern = `${osc}|${csi}`;
+
+  return new RegExp(pattern, onlyFirst ? undefined : "g");
+}
+
+const stripAnsiRegex = ansiRegex();
+
+/**
+ * Strip ANSI escape codes from a string
+ * @param string - The string to strip ANSI codes from
+ * @returns The string with ANSI codes removed
+ */
+export function stripAnsi(string: string): string {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+
+  // Even though the regex is global, we don't need to reset the `.lastIndex`
+  // because unlike `.exec()` and `.test()`, `.replace()` does it automatically
+  // and doing it manually has a performance penalty.
+  return string.replace(stripAnsiRegex, "");
+}

package/src/lib/cli-push-server.ts

@@ -0,0 +1,112 @@
+import type { SocketServer } from "@codellm/comms";
+
+import { cliContract, createSocketServer } from "@codellm/comms";
+import { product } from "@codellm/product";
+import { implement } from "@orpc/server";
+import { StandardRPCHandler } from "@orpc/server/standard";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface EditorState {
+  file: string | undefined;
+  startLine: number | undefined;
+  endLine: number | undefined;
+}
+
+export type ToolDecisionValue = "accept" | "reject" | "allowAlways";
+
+export class CliPushServer {
+  private socketServer: SocketServer | undefined;
+  readonly socketPath: string;
+  private editorState: EditorState = {
+    file: undefined,
+    startLine: undefined,
+    endLine: undefined,
+  };
+  private onEditorStateCallback: ((state: EditorState) => void) | null = null;
+  private pendingDecisions = new Map<
+    string,
+    { resolve: (d: ToolDecisionValue) => void; cleanup: () => void }
+  >();
+
+  constructor() {
+    const socketDir = path.join(os.homedir(), product.configDirName, "cli");
+    this.socketPath = path.join(socketDir, `${process.pid}.sock`);
+  }
+
+  getEditorState(): EditorState {
+    return { ...this.editorState };
+  }
+
+  onEditorChange(callback: (state: EditorState) => void): void {
+    this.onEditorStateCallback = callback;
+  }
+
+  waitForDecision(toolId: string, signal?: AbortSignal): Promise<ToolDecisionValue> {
+    return new Promise<ToolDecisionValue>((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new Error("Aborted"));
+        return;
+      }
+
+      const cleanup = () => {
+        signal?.removeEventListener("abort", onAbort);
+        this.pendingDecisions.delete(toolId);
+      };
+      const onAbort = () => {
+        cleanup();
+        reject(new Error("Aborted"));
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+
+      this.pendingDecisions.set(toolId, {
+        resolve: (d) => {
+          cleanup();
+          resolve(d);
+        },
+        cleanup,
+      });
+    });
+  }
+
+  async start(): Promise<void> {
+    const socketDir = path.dirname(this.socketPath);
+    if (!fs.existsSync(socketDir)) {
+      fs.mkdirSync(socketDir, { recursive: true });
+    }
+
+    const cc = implement(cliContract);
+
+    type EditorStateInput = { file: string | null; startLine?: number; endLine?: number };
+    type ToolDecisionInput = { toolId: string; decision: "accept" | "reject" | "allowAlways" };
+
+    const router = cc.router({
+      editorStateChanged: cc.editorStateChanged.handler(
+        async ({ input }: { input: EditorStateInput }) => {
+          this.editorState = {
+            file: input.file ?? undefined,
+            startLine: input.startLine,
+            endLine: input.endLine,
+          };
+          this.onEditorStateCallback?.(this.editorState);
+          return { ok: true };
+        },
+      ),
+      toolDecision: cc.toolDecision.handler(async ({ input }: { input: ToolDecisionInput }) => {
+        const pending = this.pendingDecisions.get(input.toolId);
+        if (pending) pending.resolve(input.decision);
+        return { ok: true };
+      }),
+    });
+
+    this.socketServer = await createSocketServer(this.socketPath, new StandardRPCHandler(router));
+  }
+
+  dispose(): void {
+    for (const [, entry] of this.pendingDecisions) entry.cleanup();
+    this.pendingDecisions.clear();
+    this.socketServer?.dispose();
+    this.socketServer = undefined;
+  }
+}

package/src/lib/cli.ts

@@ -0,0 +1,44 @@
+import { spawn } from "child_process";
+
+export async function* runCli(command: string, args: string[]): AsyncGenerator<string> {
+  const proc = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    cwd: process.cwd(),
+  });
+
+  const streams = [proc.stdout, proc.stderr];
+
+  const readers = streams.map((stream) => stream[Symbol.asyncIterator]());
+
+  try {
+    while (true) {
+      const results = await Promise.all(readers.map((reader) => reader.next()));
+      let doneCount = 0;
+      for (let i = 0; i < results.length; i++) {
+        const { value, done } = results[i];
+        if (done) {
+          doneCount++;
+          continue;
+        }
+        if (value) {
+          yield value.toString();
+        }
+      }
+      if (doneCount === readers.length) {
+        break;
+      }
+    }
+  } finally {
+    // Attempt graceful shutdown
+    proc.kill("SIGTERM");
+
+    const timeout = setTimeout(() => {
+      // Force termination if still running
+      if (!proc.killed) {
+        proc.kill("SIGKILL");
+      }
+    }, 5000);
+
+    proc.on("close", () => clearTimeout(timeout));
+  }
+}

package/src/lib/clipboard.ts

@@ -0,0 +1,226 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// ── macOS screenshot detection ────────────────────────────────────────────
+
+const MACOS_TEMP_SCREENSHOT_PATTERN =
+  /\/var\/folders\/.*\/T\/TemporaryItems\/.*screencaptureui.*\//i;
+const SCREENSHOTS_DIR = ".abacusai/screenshots";
+
+export function isMacOSTempScreenshot(filePath: string): boolean {
+  return MACOS_TEMP_SCREENSHOT_PATTERN.test(filePath);
+}
+
+export function copyTempScreenshotToProject(tempPath: string): string | null {
+  try {
+    const unescaped = tempPath.replace(/\\ /g, " ");
+    const cleaned = stripFileProtocol(unescaped);
+
+    if (!existsSync(cleaned)) {
+      return null;
+    }
+
+    const screenshotsDir = path.resolve(process.cwd(), SCREENSHOTS_DIR);
+    if (!existsSync(screenshotsDir)) {
+      mkdirSync(screenshotsDir, { recursive: true });
+    }
+
+    const filename = path.basename(cleaned);
+    const destPath = path.join(screenshotsDir, filename);
+
+    copyFileSync(cleaned, destPath);
+    return destPath;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Strips the file:// protocol prefix from a path if present.
+ * Also percent-decodes URI-encoded characters (e.g. %20 → space).
+ */
+export function stripFileProtocol(text: string): string {
+  if (text.startsWith("file://")) {
+    try {
+      return decodeURIComponent(text.slice("file://".length));
+    } catch {
+      return text.slice("file://".length);
+    }
+  }
+  return text;
+}
+
+// ── Linux clipboard tool detection ───────────────────────────────────────
+
+let linuxClipboardTool: "wl-paste" | "xclip" | null | undefined;
+
+function detectLinuxClipboardTool(): "wl-paste" | "xclip" | null {
+  if (linuxClipboardTool !== undefined) return linuxClipboardTool;
+  try {
+    execFileSync("which", ["wl-paste"], { stdio: "ignore" });
+    linuxClipboardTool = "wl-paste";
+    return "wl-paste";
+  } catch {
+    // not found
+  }
+  try {
+    execFileSync("which", ["xclip"], { stdio: "ignore" });
+    linuxClipboardTool = "xclip";
+    return "xclip";
+  } catch {
+    // not found
+  }
+  linuxClipboardTool = null;
+  return null;
+}
+
+// ── Clipboard image detection ─────────────────────────────────────────────
+
+export async function clipboardHasImage(): Promise<boolean> {
+  try {
+    if (process.platform === "darwin") {
+      const result = execFileSync("osascript", ["-e", "clipboard info"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+      return /PNGf|JPEG|TIFF|GIF/i.test(result);
+    }
+    if (process.platform === "win32") {
+      const result = execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Clipboard]::ContainsImage()",
+        ],
+        { encoding: "utf8", timeout: 2000 },
+      );
+      return result.trim().toLowerCase() === "true";
+    }
+    // Linux
+    const tool = detectLinuxClipboardTool();
+    if (tool === "wl-paste") {
+      const result = execFileSync("wl-paste", ["--list-types"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+      return result.includes("image/");
+    }
+    if (tool === "xclip") {
+      const result = execFileSync("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+      return result.includes("image/");
+    }
+  } catch {
+    // ignore — clipboard tools may not be available
+  }
+  return false;
+}
+
+// ── Save clipboard image to disk ──────────────────────────────────────────
+
+export async function saveClipboardImage(cwd: string): Promise<string | null> {
+  try {
+    const screenshotsDir = path.resolve(cwd, SCREENSHOTS_DIR);
+    if (!existsSync(screenshotsDir)) {
+      mkdirSync(screenshotsDir, { recursive: true });
+    }
+
+    const timestamp = Date.now();
+    const destPath = path.join(screenshotsDir, `clipboard-${timestamp}.png`);
+
+    if (process.platform === "darwin") {
+      // Try PNG first, then JPEG
+      const script = `
+        set destFile to "${destPath}"
+        try
+          set imgData to (clipboard info for «class PNGf»)
+          set fileRef to open for access POSIX file destFile with write permission
+          set eof of fileRef to 0
+          write (clipboard as «class PNGf») to fileRef
+          close access fileRef
+        on error
+          try
+            set imgData to (clipboard info for «class JPEG»)
+            set fileRef to open for access POSIX file destFile with write permission
+            set eof of fileRef to 0
+            write (clipboard as «class JPEG») to fileRef
+            close access fileRef
+          end try
+        end try
+      `;
+      execFileSync("osascript", ["-e", script], { timeout: 5000 });
+    } else if (process.platform === "win32") {
+      execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          `Add-Type -Assembly System.Windows.Forms; [System.Windows.Forms.Clipboard]::GetImage().Save("${destPath}", [System.Drawing.Imaging.ImageFormat]::Png)`,
+        ],
+        { timeout: 5000 },
+      );
+    } else {
+      const tool = detectLinuxClipboardTool();
+      if (tool === "wl-paste") {
+        const imgData = execFileSync("wl-paste", ["--no-newline", "--type", "image/png"], {
+          timeout: 5000,
+        });
+        writeFileSync(destPath, imgData);
+      } else if (tool === "xclip") {
+        const imgData = execFileSync(
+          "xclip",
+          ["-selection", "clipboard", "-t", "image/png", "-o"],
+          { timeout: 5000 },
+        );
+        writeFileSync(destPath, imgData);
+      } else {
+        return null;
+      }
+    }
+
+    // Verify file exists and has content (prevents empty-file false positives)
+    try {
+      const stat = statSync(destPath);
+      if (stat.size === 0) return null;
+    } catch {
+      return null;
+    }
+
+    return destPath;
+  } catch {
+    return null;
+  }
+}
+
+// ── Read clipboard text ───────────────────────────────────────────────────
+
+export async function readClipboardText(): Promise<string | null> {
+  try {
+    if (process.platform === "darwin") {
+      return execFileSync("pbpaste", { encoding: "utf8", timeout: 2000 });
+    }
+    if (process.platform === "win32") {
+      return execFileSync("powershell", ["-NoProfile", "-Command", "Get-Clipboard"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+    }
+    const tool = detectLinuxClipboardTool();
+    if (tool === "wl-paste") {
+      return execFileSync("wl-paste", ["--no-newline"], { encoding: "utf8", timeout: 2000 });
+    }
+    if (tool === "xclip") {
+      return execFileSync("xclip", ["-selection", "clipboard", "-o"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}