@wwwyo/pi-vim 0.0.0-stage → 0.14.2

package/clipboard-mirror.ts

@@ -0,0 +1,449 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const PI_NATIVE_CLIPBOARD_TIMEOUT_MS = 5000;
+const CLIPBOARD_WRITE_TIMEOUT_MS = PI_NATIVE_CLIPBOARD_TIMEOUT_MS + 500;
+const CLIPBOARD_SPAWN_FAILURE_LIMIT = 3;
+const CLIPBOARD_READ_TIMEOUT_MS = 750;
+const CLIPBOARD_READ_MAX_BUFFER_BYTES = 1024 * 1024;
+
+export type ClipboardWriteFn = (
+  text: string,
+  signal: AbortSignal,
+) => Promise<void>;
+export type ClipboardReadFn = () => string | null;
+type ClipboardProcess = ReturnType<typeof spawn>;
+
+type ClipboardCircuitBreaker = {
+  consecutiveEnvironmentFailures: number;
+  disabled: boolean;
+};
+
+const processClipboardCircuitBreaker: ClipboardCircuitBreaker = {
+  consecutiveEnvironmentFailures: 0,
+  disabled: false,
+};
+
+function resetClipboardCircuitBreaker(): void {
+  processClipboardCircuitBreaker.consecutiveEnvironmentFailures = 0;
+  processClipboardCircuitBreaker.disabled = false;
+}
+
+class ClipboardSpawnError extends Error {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options);
+    this.name = "ClipboardSpawnError";
+  }
+}
+
+type SpawnErrnoLike = Error & { code?: unknown; syscall?: unknown };
+
+function isNodeSpawnErrno(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+
+  const candidate = error as SpawnErrnoLike;
+  return (
+    typeof candidate.code === "string" &&
+    candidate.code.length > 0 &&
+    typeof candidate.syscall === "string" &&
+    candidate.syscall.startsWith("spawn")
+  );
+}
+
+function isClipboardEnvironmentFailure(error: unknown): boolean {
+  return error instanceof ClipboardSpawnError || isNodeSpawnErrno(error);
+}
+
+function tryResolvePiCodingAgentModuleUrl(): string | undefined {
+  try {
+    return import.meta.resolve("@earendil-works/pi-coding-agent");
+  } catch {
+    try {
+      const cliPath = process.argv[1];
+      if (!cliPath || !existsSync(cliPath)) return undefined;
+
+      let distDir = dirname(realpathSync(cliPath));
+      if (basename(distDir) === "bundle") distDir = dirname(distDir);
+      const modulePath = join(distDir, "index.js");
+
+      if (
+        basename(distDir) === "dist" &&
+        basename(dirname(distDir)) === "pi-coding-agent" &&
+        existsSync(modulePath)
+      ) {
+        return pathToFileURL(modulePath).href;
+      }
+    } catch {
+      // Compiled runtimes may expose virtual entrypoints through existsSync()
+      // that cannot be resolved through the host filesystem.
+    }
+    return undefined;
+  }
+}
+
+const CLIPBOARD_HELPER_COPY_FAILED_EXIT_CODE = 2;
+
+type ClipboardHelperSources = {
+  read: string;
+  write: string;
+};
+
+let clipboardHelperSources: ClipboardHelperSources | null | undefined;
+
+export function buildClipboardWriteHelperSource(moduleUrl: string): string {
+  return `
+import { copyToClipboard } from ${JSON.stringify(moduleUrl)};
+
+const chunks = [];
+for await (const chunk of process.stdin) {
+  chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+}
+
+try {
+  await Promise.resolve(copyToClipboard(Buffer.concat(chunks).toString("utf8")));
+} catch {
+  process.exitCode = ${CLIPBOARD_HELPER_COPY_FAILED_EXIT_CODE};
+}
+`;
+}
+
+export function buildClipboardReadHelperSource(moduleUrl: string): string {
+  return `
+import { createRequire } from "node:module";
+
+const require = createRequire(${JSON.stringify(moduleUrl)});
+const clipboard = require("@mariozechner/clipboard");
+if (!await clipboard.hasText()) {
+  process.exit(0);
+}
+const text = await clipboard.getText();
+if (typeof text === "string") {
+  process.stdout.write(text);
+}
+`;
+}
+
+function getClipboardHelperSources(): ClipboardHelperSources | null {
+  if (clipboardHelperSources !== undefined) return clipboardHelperSources;
+
+  const moduleUrl = tryResolvePiCodingAgentModuleUrl();
+  clipboardHelperSources = moduleUrl
+    ? {
+        read: buildClipboardReadHelperSource(moduleUrl),
+        write: buildClipboardWriteHelperSource(moduleUrl),
+      }
+    : null;
+  return clipboardHelperSources;
+}
+
+export function readClipboardInChildProcess(): string | null {
+  const helperSources = getClipboardHelperSources();
+  if (!helperSources) return null;
+
+  try {
+    const result = spawnSync(
+      process.execPath,
+      ["--input-type=module", "-e", helperSources.read],
+      {
+        encoding: "utf8",
+        maxBuffer: CLIPBOARD_READ_MAX_BUFFER_BYTES,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: CLIPBOARD_READ_TIMEOUT_MS,
+        windowsHide: true,
+      },
+    );
+
+    if (result.error || result.status !== 0 || result.signal) return null;
+    return result.stdout ?? "";
+  } catch {
+    return null;
+  }
+}
+
+function createClipboardAbortError(message: string): Error {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+
+function getAbortError(signal: AbortSignal): Error {
+  return signal.reason instanceof Error
+    ? signal.reason
+    : createClipboardAbortError("clipboard write aborted");
+}
+
+function killClipboardProcess(child: ClipboardProcess): void {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  try {
+    child.kill("SIGKILL");
+  } catch {
+    return;
+  }
+}
+
+export function writeClipboardInChildProcess(
+  text: string,
+  signal: AbortSignal,
+): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    if (signal.aborted) {
+      reject(getAbortError(signal));
+      return;
+    }
+
+    const helperSources = getClipboardHelperSources();
+    if (!helperSources) {
+      reject(new ClipboardSpawnError("clipboard helper module unavailable"));
+      return;
+    }
+
+    let child: ClipboardProcess | null = null;
+    let settled = false;
+    const stdoutChunks: Buffer[] = [];
+
+    function finish(error?: unknown): void {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    }
+
+    function onAbort(): void {
+      if (child) {
+        killClipboardProcess(child);
+      }
+      finish(getAbortError(signal));
+    }
+
+    try {
+      child = spawn(
+        process.execPath,
+        ["--input-type=module", "-e", helperSources.write],
+        {
+          stdio: ["pipe", "pipe", "ignore"],
+          windowsHide: true,
+        },
+      );
+    } catch (error) {
+      finish(
+        new ClipboardSpawnError("clipboard helper spawn failed", {
+          cause: error,
+        }),
+      );
+      return;
+    }
+
+    signal.addEventListener("abort", onAbort, { once: true });
+
+    child.stdout?.on("data", (chunk: Buffer | string) => {
+      stdoutChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    child.stdout?.on("error", (error) => {
+      finish(error);
+    });
+
+    child.once("error", (error) => {
+      finish(
+        new ClipboardSpawnError("clipboard helper spawn failed", {
+          cause: error,
+        }),
+      );
+    });
+
+    child.once("close", (code) => {
+      if (settled) return;
+
+      if (signal.aborted) {
+        finish(getAbortError(signal));
+        return;
+      }
+
+      if (code === 0) {
+        try {
+          for (const chunk of stdoutChunks) {
+            process.stdout.write(chunk);
+          }
+        } catch (error) {
+          finish(error);
+          return;
+        }
+        finish();
+        return;
+      }
+
+      // Exit code 2 means the helper ran but the copy itself failed; that is
+      // a clipboard-backend failure, not an environment failure, so it must
+      // not count toward the spawn circuit breaker.
+      if (code === CLIPBOARD_HELPER_COPY_FAILED_EXIT_CODE) {
+        finish(new Error("clipboard helper reported a failed copy"));
+        return;
+      }
+
+      finish(
+        new ClipboardSpawnError(
+          `clipboard helper failed with exit code ${code ?? "null"}`,
+        ),
+      );
+    });
+
+    if (!child.stdin) {
+      killClipboardProcess(child);
+      finish(new ClipboardSpawnError("clipboard helper stdin unavailable"));
+      return;
+    }
+
+    child.stdin.on("error", (error: NodeJS.ErrnoException) => {
+      if (signal.aborted) {
+        finish(getAbortError(signal));
+        return;
+      }
+
+      if (error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED") {
+        return;
+      }
+
+      finish(error);
+    });
+
+    try {
+      child.stdin.end(text);
+    } catch (error) {
+      finish(error);
+    }
+  });
+}
+
+export class ClipboardMirror {
+  private activeController: AbortController | null = null;
+  private activeText: string | null = null;
+  private draining = false;
+  private pendingText: string | null = null;
+  private lastWriteFailedFlag = false;
+
+  constructor(
+    private writeFn: ClipboardWriteFn,
+    private timeoutMs: number = CLIPBOARD_WRITE_TIMEOUT_MS,
+    private readonly circuitBreaker: ClipboardCircuitBreaker = processClipboardCircuitBreaker,
+  ) {}
+
+  setWriteFn(writeFn: ClipboardWriteFn): void {
+    this.activeController?.abort(
+      createClipboardAbortError("clipboard writer replaced"),
+    );
+    this.writeFn = writeFn;
+    // Deliberately keep lastWriteFailedFlag: swapping the writer does not
+    // change whether the OS clipboard is stale relative to the register;
+    // only a landed mirror write clears the flag.
+    resetClipboardCircuitBreaker();
+  }
+
+  setTimeoutMs(timeoutMs: number): void {
+    this.timeoutMs = Math.max(0, timeoutMs);
+  }
+
+  hasPendingWrite(): boolean {
+    return (
+      this.activeText !== null || this.pendingText !== null || this.draining
+    );
+  }
+
+  lastWriteFailed(): boolean {
+    return this.lastWriteFailedFlag;
+  }
+
+  mirror(text: string): void {
+    if (this.circuitBreaker.disabled) {
+      this.lastWriteFailedFlag = true;
+      return;
+    }
+
+    this.pendingText = text;
+
+    if (!this.draining) {
+      void this.drain();
+    }
+  }
+
+  private async drain(): Promise<void> {
+    if (this.draining) return;
+    this.draining = true;
+
+    try {
+      while (this.pendingText !== null && !this.circuitBreaker.disabled) {
+        const text = this.pendingText;
+        this.pendingText = null;
+        const controller = new AbortController();
+        this.activeController = controller;
+        this.activeText = text;
+
+        try {
+          await this.writeWithTimeout(text, controller);
+          this.circuitBreaker.consecutiveEnvironmentFailures = 0;
+          this.lastWriteFailedFlag = false;
+        } catch (error) {
+          this.recordWriteFailure(error);
+        } finally {
+          if (this.activeController === controller) {
+            this.activeController = null;
+          }
+          this.activeText = null;
+        }
+      }
+
+      if (this.circuitBreaker.disabled && this.pendingText !== null) {
+        this.pendingText = null;
+        this.lastWriteFailedFlag = true;
+      }
+    } finally {
+      this.draining = false;
+      if (this.pendingText !== null && !this.circuitBreaker.disabled) {
+        void this.drain();
+      }
+    }
+  }
+
+  private recordWriteFailure(error: unknown): void {
+    this.lastWriteFailedFlag = true;
+    if (!isClipboardEnvironmentFailure(error)) {
+      this.circuitBreaker.consecutiveEnvironmentFailures = 0;
+      return;
+    }
+
+    this.circuitBreaker.consecutiveEnvironmentFailures += 1;
+    if (
+      this.circuitBreaker.consecutiveEnvironmentFailures >=
+      CLIPBOARD_SPAWN_FAILURE_LIMIT
+    ) {
+      this.circuitBreaker.disabled = true;
+      this.pendingText = null;
+    }
+  }
+
+  private async writeWithTimeout(
+    text: string,
+    controller: AbortController,
+  ): Promise<void> {
+    const timeoutError = createClipboardAbortError("clipboard write timed out");
+    const timeoutId = setTimeout(() => {
+      controller.abort(timeoutError);
+    }, this.timeoutMs);
+
+    try {
+      await this.writeFn(text, controller.signal);
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw getAbortError(controller.signal);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+}

package/clipboard-policy.ts

@@ -0,0 +1,23 @@
+export type ClipboardMirrorPolicy = "all" | "yank" | "never";
+export type RegisterWriteSource = "mutation" | "yank";
+export const DEFAULT_CLIPBOARD_MIRROR_POLICY: ClipboardMirrorPolicy = "all";
+
+function fmt(v: unknown) {
+  const type = v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+  try {
+    return `${JSON.stringify(v) ?? type} (type ${type})`;
+  } catch {
+    return `(type ${type})`;
+  }
+}
+
+export function resolveClipboardMirrorPolicy(value: unknown) {
+  if (value === undefined) return { policy: DEFAULT_CLIPBOARD_MIRROR_POLICY };
+  const p = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (p === "all" || p === "yank" || p === "never")
+    return { policy: p as ClipboardMirrorPolicy };
+  return {
+    policy: DEFAULT_CLIPBOARD_MIRROR_POLICY,
+    warning: `Invalid piVim.clipboardMirror ${fmt(value)}; expected all, yank, never.`,
+  };
+}

package/cursor-shape.ts

@@ -0,0 +1,138 @@
+import { CURSOR_MARKER } from "@earendil-works/pi-tui";
+
+const SOFTWARE_CURSOR_START = "\x1b[7m";
+const SOFTWARE_CURSOR_RESETS = ["\x1b[0m", "\x1b[27m"] as const;
+export const INSERT_CURSOR_SHAPE = "\x1b[5 q";
+export const BLOCK_CURSOR_SHAPE = "\x1b[1 q";
+const RESET_CURSOR_SHAPE = "\x1b[0 q";
+const SHOW_HARDWARE_CURSOR = "\x1b[?25h";
+
+export type CursorShapeSequence =
+  | typeof INSERT_CURSOR_SHAPE
+  | typeof BLOCK_CURSOR_SHAPE
+  | typeof RESET_CURSOR_SHAPE
+  | typeof SHOW_HARDWARE_CURSOR;
+
+export type CursorShapeRuntime = {
+  writeCursorShape: (sequence: CursorShapeSequence) => void;
+  setShowHardwareCursor: (show: boolean) => void;
+  getShowHardwareCursor?: () => boolean | undefined;
+};
+
+export type CursorShapeCleanup = (event?: { reason?: string }) => void;
+
+type CursorShapeTuiCandidate = {
+  terminal?: { write?: unknown };
+  setShowHardwareCursor?: unknown;
+  getShowHardwareCursor?: unknown;
+};
+
+export function getCursorShapeRuntime(tui: unknown): CursorShapeRuntime | null {
+  if (typeof tui !== "object" || tui === null) return null;
+
+  const candidate = tui as CursorShapeTuiCandidate;
+  const terminal = candidate.terminal;
+  if (typeof terminal !== "object" || terminal === null) return null;
+
+  const write = terminal.write;
+  const setShowHardwareCursor = candidate.setShowHardwareCursor;
+  if (
+    typeof write !== "function" ||
+    typeof setShowHardwareCursor !== "function"
+  ) {
+    return null;
+  }
+
+  const runtime: CursorShapeRuntime = {
+    writeCursorShape(sequence: CursorShapeSequence): void {
+      write.call(terminal, sequence);
+    },
+    setShowHardwareCursor(show: boolean): void {
+      setShowHardwareCursor.call(candidate, show);
+    },
+  };
+
+  if (typeof candidate.getShowHardwareCursor === "function") {
+    const getShowHardwareCursor = candidate.getShowHardwareCursor;
+    runtime.getShowHardwareCursor = () => {
+      const value = getShowHardwareCursor.call(candidate);
+      return typeof value === "boolean" ? value : undefined;
+    };
+  }
+
+  return runtime;
+}
+
+export function enableCursorShapeSupport(
+  tui: unknown,
+): CursorShapeCleanup | null {
+  const runtime = getCursorShapeRuntime(tui);
+  if (!runtime) return null;
+
+  const previousShowHardwareCursor = runtime.getShowHardwareCursor?.();
+  runtime.setShowHardwareCursor(true);
+
+  return (event) => {
+    runtime.writeCursorShape(RESET_CURSOR_SHAPE);
+    if (event?.reason === "quit") {
+      runtime.writeCursorShape(SHOW_HARDWARE_CURSOR);
+    } else if (previousShowHardwareCursor !== undefined) {
+      runtime.setShowHardwareCursor(previousShowHardwareCursor);
+    }
+  };
+}
+
+function findSoftwareCursorReset(
+  line: string,
+  startIndex: number,
+): { index: number; sequence: (typeof SOFTWARE_CURSOR_RESETS)[number] } | null {
+  let firstReset: {
+    index: number;
+    sequence: (typeof SOFTWARE_CURSOR_RESETS)[number];
+  } | null = null;
+
+  for (const sequence of SOFTWARE_CURSOR_RESETS) {
+    const index = line.indexOf(sequence, startIndex);
+    if (index === -1) continue;
+    if (!firstReset || index < firstReset.index) {
+      firstReset = { index, sequence };
+    }
+  }
+
+  return firstReset;
+}
+
+export function stripSoftwareCursorAfterMarker(line: string): string {
+  const markerIndex = line.indexOf(CURSOR_MARKER);
+  if (markerIndex === -1) return line;
+
+  const searchStart = markerIndex + CURSOR_MARKER.length;
+  const cursorStart = line.indexOf(SOFTWARE_CURSOR_START, searchStart);
+  if (cursorStart === -1) return line;
+
+  const cursorContentStart = cursorStart + SOFTWARE_CURSOR_START.length;
+  const reset = findSoftwareCursorReset(line, cursorContentStart);
+  if (!reset) return line;
+
+  return (
+    line.slice(0, cursorStart) +
+    line.slice(cursorContentStart, reset.index) +
+    line.slice(reset.index + reset.sequence.length)
+  );
+}
+
+export function hasPromptCursorMarker(lines: string[]): boolean {
+  return lines.some((line) => line.includes(CURSOR_MARKER));
+}
+
+export function stripSoftwareCursorWhenHardwareCursorIsUsed(
+  lines: string[],
+): void {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line?.includes(CURSOR_MARKER)) continue;
+
+    lines[i] = stripSoftwareCursorAfterMarker(line);
+    return;
+  }
+}