rovecode 0.3.2 → 0.4.0-beta.2

package/src/tui/attach.ts

@@ -1,127 +0,0 @@
-/** Port #34 TUI wiring for image input: `/attach` stages image parts for the next user message,
- *  user turns echo (and replay) with image chips, and the stage survives a session switch.
- *
- *  The stage is the SessionStore's own (stageAttachments / stagedAttachments): the store folds it
- *  into the NEXT role:"user" entry that lands in append() — the run's goal message when idle
- *  (loop.ts userMsg), the queued steer when the loop drains it mid-run (loop.ts steering drain) —
- *  so the ONE agentLoop (ADR-003) needs no attach change and the TUI keeps no second copy of the
- *  list. Consequences, documented rather than hidden:
- *  - a steer queued BEFORE /attach is the next user entry and takes the images instead; if the
- *    run ends before any steer is drained, the images ride on the next run's goal message and the
- *    steer text follows it in the same request — nothing is ever dropped;
- *  - /sessions, /resume and a root /rewind replace the store INSTANCE: switchSession carries the
- *    stage across with a visible note (carryOverAttachments); same-store /new and /rewind move
- *    only the leaf, so the stage stays put;
- *  - no image-only messages: the editor drops empty input (pi-renderer.ts onSubmit), so text is
- *    required and every attach note says so — no "(see attached image)" text is invented on the
- *    user's behalf.
- *  Vision check at attach time (catalog.supportsImages on the current mode's model): false → warn
- *  (wire-messages.ts will send a text placeholder), undefined → info (unknown model: sent as-is,
- *  the provider may reject). Paths resolve against the runtime cwd; the loader sniffs magic bytes
- *  (core/images.ts), never the extension. */
-
-import { resolve } from "node:path";
-import { checkImageCount, describeImage, imageChip, imageFromBytes, loadImageAttachment, MAX_IMAGES_PER_MESSAGE } from "../core/images.ts";
-import { clipboardImageName, readClipboardImage } from "./clipboard-image.ts";
-import type { SessionStore } from "../core/session.ts";
-import type { ImagePart, MessagePart } from "../core/types.ts";
-import { supportsImages } from "../providers/catalog.ts";
-import type { Renderer, SlashCommand } from "./renderer.ts";
-
-/** The TUI_COMMANDS entry (/help, palette, custom-command reserved names). */
-export const ATTACH_COMMAND: SlashCommand = {
-  name: "attach",
-  description: "Attach an image to your next message (text required): /attach <path> · /attach = list · /attach clear · or drag an image file onto the terminal",
-};
-
-export interface AttachCtx {
-  renderer: Renderer;
-  /** runtime cwd — relative paths resolve against it */
-  cwd: string;
-  /** the ACTIVE store, read live (/sessions and a root /rewind swap it) */
-  store(): SessionStore;
-  /** the current mode's model — the vision check */
-  modelRef(): { provider: string; model: string };
-}
-
-const plural = (n: number): string => `${n} image${n === 1 ? "" : "s"}`;
-
-/** `/attach <path>` stages one image · `/attach` lists the stage · `/attach clear` empties it.
- *  Never throws: a bad file, an oversize image or the 9th image is a note, nothing staged. */
-export function cmdAttach(ctx: AttachCtx, arg: string): void {
-  const { renderer } = ctx;
-  const store = ctx.store();
-  const staged = store.stagedAttachments;
-  if (arg === "") {
-    renderer.addSystemNote(staged.length === 0
-      ? "no images attached — /attach <path>"
-      : `attached (${staged.length}/${MAX_IMAGES_PER_MESSAGE}):\n${staged.map((p, i) => `${i + 1}. ${describeImage(p)}`).join("\n")}`);
-    return;
-  }
-  if (arg === "clear") {
-    store.stageAttachments([]);
-    renderer.addSystemNote(staged.length === 0 ? "no images attached" : `attachments cleared (${plural(staged.length)} removed)`);
-    return;
-  }
-  const path = arg.replace(/^(["'])(.*)\1$/, "$2"); // a quoted path keeps its spaces
-  const loaded = loadImageAttachment(resolve(ctx.cwd, path));
-  if ("error" in loaded) { renderer.addSystemNote(loaded.error, "error"); return; }
-  const over = checkImageCount(staged.length + 1);
-  if (over !== undefined) { renderer.addSystemNote(over, "error"); return; }
-  store.stageAttachments([...staged, loaded]); // replaces the stage; folds into the next user entry
-  renderer.addSystemNote(`attached ${describeImage(loaded)} (${staged.length + 1}/${MAX_IMAGES_PER_MESSAGE}) — type your message and press Enter to send it`);
-  const ref = ctx.modelRef();
-  const vision = supportsImages(ref);
-  if (vision === false) renderer.addSystemNote(`model ${ref.provider}/${ref.model} has no image input — it will be sent as a text placeholder`, "warn");
-  else if (vision === undefined) renderer.addSystemNote(`unknown model ${ref.provider}/${ref.model}; image sent as-is (provider may reject)`);
-}
-
-/** `/paste` — the clipboard image as an attachment (⌃v in the sextant surface lands here). */
-export const PASTE_COMMAND: SlashCommand = {
-  name: "paste",
-  description: "attach the image on the clipboard (⌃v)",
-};
-
-/** Stage the image currently on the system clipboard. Berkay: "gorsel gonderebilme olayini yapalim" —
- *  /attach <path> existed, but the thing everyone tries first is copying a screenshot and pressing ⌃v,
- *  and a terminal delivers only TEXT pastes, so that did nothing. tui/clipboard-image.ts asks the OS.
- *  Same rules as /attach: magic-byte sniff, size cap, the 8-image cap, the vision note; never throws.
- *  `read` is injectable (tests never touch a real clipboard). */
-export function cmdPasteImage(ctx: AttachCtx, read: () => Uint8Array | null = () => readClipboardImage(), name = clipboardImageName()): void {
-  const { renderer } = ctx;
-  const bytes = read();
-  if (bytes === null) { renderer.addSystemNote("no image on the clipboard — copy a screenshot or picture first, or /attach <path>"); return; }
-  const loaded = imageFromBytes(bytes, { name });
-  if ("error" in loaded) { renderer.addSystemNote(loaded.error, "error"); return; }
-  const store = ctx.store();
-  const staged = store.stagedAttachments;
-  const over = checkImageCount(staged.length + 1);
-  if (over !== undefined) { renderer.addSystemNote(over, "error"); return; }
-  store.stageAttachments([...staged, loaded]);
-  renderer.addSystemNote(`attached ${describeImage(loaded)} from the clipboard (${staged.length + 1}/${MAX_IMAGES_PER_MESSAGE}) — type your message and press Enter to send it`);
-  const ref = ctx.modelRef();
-  const vision = supportsImages(ref);
-  if (vision === false) renderer.addSystemNote(`model ${ref.provider}/${ref.model} has no image input — it will be sent as a text placeholder`, "warn");
-}
-
-/** Transcript line for a user turn: the text, then one chip per image on a second line; an
- *  image-only turn is just its chips; "" when there is nothing to show. Used by the submit echo
- *  (with the stage about to fold) and by replay (with the persisted parts). */
-export function userTurnLine(text: string, parts: readonly MessagePart[]): string {
-  const chips = parts.filter((p): p is ImagePart => p.kind === "image").map(imageChip).join(" ");
-  return text && chips ? `${text}\n${chips}` : text || chips;
-}
-
-/** Suffix for the busy-submit note: what the queued steer will carry when the loop drains it. */
-export function queuedAttachNote(store: SessionStore): string {
-  const n = store.stagedAttachments.length;
-  return n === 0 ? "" : ` — ${plural(n)} attached to your queued message`;
-}
-
-/** After a store swap (/sessions, /resume, root /rewind): re-stage the images the OLD instance held
- *  on the new one and say so — the switch must never lose them silently. */
-export function carryOverAttachments(ctx: AttachCtx, pending: readonly ImagePart[]): void {
-  if (pending.length === 0) return;
-  ctx.store().stageAttachments(pending);
-  ctx.renderer.addSystemNote(`${plural(pending.length)} still attached — carried over to this session, rides on your next message`);
-}

package/src/tui/boot-notes.ts

@@ -1,41 +0,0 @@
-/** Boot-note extraction port: everything runTui says before the first prompt, in its original order.
- *  Adapted from aion's boot-notes.ts, retaining rovecode's voice and runtime channels. Memory migration,
- *  trust, workspace-root and agent-definition notes already ride plugins.onWarning: do not emit them twice.
- *  No boot work or update fetch here; only the renderer and the runtime's buffered/live note listeners. */
-import type { Runtime } from "../cli/runtime.ts";
-import { resumedLine, welcomeCard } from "../core/voice.ts";
-import { summarizePlugins } from "../plugins/index.ts";
-import type { Renderer } from "./renderer.ts";
-
-export interface BootNotesCtx {
-  renderer: Pick<Renderer, "addSystemNote">;
-  rt: Pick<Runtime, "cwd" | "stream" | "noProviderReason" | "skillStore" | "mcp" | "providers" | "hooks" | "plugins" | "onRouterNote">;
-  yolo: boolean;
-  modelRef: { provider: string; model: string };
-  mode: "plan" | "act";
-  version: string;
-  width: number;
-  /** Undefined on a fresh boot; the active store's id on a resumed boot. */
-  sessionId: string | undefined;
-  bootWarn: string | undefined;
-  commandWarnings: readonly string[];
-}
-
-export function emitBootNotes({ renderer, rt, yolo, modelRef, mode, version, width, sessionId, bootWarn, commandWarnings }: BootNotesCtx): void {
-  const connected = rt.stream && rt.noProviderReason() === null ? modelRef : null;
-  if (sessionId !== undefined) renderer.addSystemNote(resumedLine(sessionId, rt.cwd, yolo));
-  else {
-    // Count only what this runtime accepted, not untrusted/unfilled MCP entries or inactive plugins.
-    const loaded = { skills: rt.skillStore.list().length, plugins: rt.plugins.found.filter((p) => p.status === "active").length, mcp: rt.mcp?.serverNames().length ?? 0 };
-    renderer.addSystemNote(welcomeCard({ connected, cwd: rt.cwd, yolo, mode, version, loaded, width }));
-  }
-  if (bootWarn) renderer.addSystemNote(bootWarn); // a fact, not a fault (the original info tone)
-  for (const w of commandWarnings) renderer.addSystemNote(w, "warn");
-  for (const w of rt.providers.warnings()) renderer.addSystemNote(`providers: ${w}`, "warn");
-  rt.hooks.onWarning((w) => renderer.addSystemNote(`hooks: ${w}`, "warn"));
-  rt.plugins.onWarning((w) => renderer.addSystemNote(w, "warn"));
-  const pluginLine = summarizePlugins(rt.plugins.found);
-  if (pluginLine !== null) renderer.addSystemNote(pluginLine);
-  // Retry notices arrive during backoff; the run's final drain then has nothing left to print.
-  rt.onRouterNote((n) => renderer.addSystemNote(n, "warn"));
-}

package/src/tui/builtin-prompts.ts

@@ -1,59 +0,0 @@
-/** Built-in prompt commands (port #53): slash commands whose whole effect is a prompt the ONE agent
- *  loop runs — today `/init`, which asks the agent to analyse the repo and write (or improve)
- *  AGENTS.md. They expand exactly where custom commands do: the TUI submits the rendered prompt as a
- *  plain user turn (context-cmds.ts) and `rovecode run "/init"` renders it headlessly through
- *  commands.ts expandSlashPrompt, which consults this table BEFORE the custom-command files (a
- *  built-in beats a same-named custom command, as in the TUI). No renderer, store or loop import
- *  here — both the TUI and the headless path can depend on this module without a cycle.
- *
- *  Pattern reference only, no code ported: gemini-cli @ 0bd1d43 packages/cli/src/ui/commands/
- *  initCommand.ts (the command checks whether the context file exists in the target dir and turns
- *  into a submitted prompt, :33-49) and packages/core/src/commands/init.ts performInit (:9-57 — a
- *  guided analysis prompt: explore, read the README, pick up to ~10 key files, identify the project
- *  type, then write the file). Deviation: gemini refuses when its file already exists ("No changes
- *  were made", :10-17); rovecode asks for targeted improvements instead, and the write itself goes
- *  through the ordinary edit/write approval seam — the command never touches the file. */
-
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-
-/** The file the agent writes — the project-context file cli/boot-context.ts harvests (port #8). */
-export const INIT_TARGET = "AGENTS.md";
-
-/** `/init` — the analysis prompt; the variant depends on whether `<cwd>/AGENTS.md` exists. */
-export function initPrompt(cwd: string): string {
-  const exists = existsSync(join(cwd, INIT_TARGET));
-  const head = exists
-    ? `${INIT_TARGET} already exists in this project. Analyse the repository, read the current ${INIT_TARGET}, and propose TARGETED improvements to it: fix what is stale or wrong, add what a future agent session would need and cannot infer quickly, remove nothing that is still true. Apply the changes with the edit tool (small anchored edits, never a wholesale rewrite) and finish with a short list of what changed and why.`
-    : `Analyse this repository and write an ${INIT_TARGET} file at the project root: the instructional context a future agent session reads first.`;
-  return `${head}
-
-Analysis:
-1. List the top-level files and directories for an overview. Read the README (README.md or similar) first if there is one.
-2. Read the files that matter most, up to about ten, letting each discovery guide the next: build/package manifests (package.json, pyproject.toml, Cargo.toml, go.mod, Makefile, …), the main entry points, existing agent or contributor guides (AGENTS.md, CLAUDE.md, CONTRIBUTING.md), CI config.
-3. Decide whether this is a code project or something else (documentation, notes, data).
-
-${INIT_TARGET} content — concise, factual, only what you verified in the files:
-- Project overview: purpose, main technologies, architecture in a few sentences.
-- Build, run and test: the exact commands, inferred from the manifests and scripts you read; mark anything you could not confirm with a TODO instead of guessing.
-- Conventions: code style, testing practice, layout rules, review or contribution rules the files reveal.
-- For a non-code directory: what it holds, the key files and how the contents are meant to be used.
-
-${exists ? `Edit ${INIT_TARGET} in place; do not create a second file.` : `Write the complete file with the write tool as well-formatted Markdown; do not touch other files.`} Keep it under about 150 lines.`;
-}
-
-/** Built-in prompt commands by name → their renderer. `arg` is the remainder of the line (unused by
- *  /init, which takes no arguments — kept in the signature so a later built-in can accept some). */
-export const BUILTIN_PROMPTS: Readonly<Record<string, (cwd: string, arg: string) => string>> = {
-  init: (cwd) => initPrompt(cwd),
-};
-
-/** `"/name args"` → the rendered built-in prompt, or undefined when the line names no built-in
- *  prompt command (a custom command, another built-in, plain text). Case-insensitive like custom
- *  command names. */
-export function expandBuiltinSlash(prompt: string, cwd: string): string | undefined {
-  const m = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(prompt.trim());
-  if (!m) return undefined;
-  const render = Object.hasOwn(BUILTIN_PROMPTS, m[1]!.toLowerCase()) ? BUILTIN_PROMPTS[m[1]!.toLowerCase()] : undefined;
-  return render ? render(cwd, (m[2] ?? "").trim()) : undefined;
-}

package/src/tui/checkpoints-cmd.ts

@@ -1,70 +0,0 @@
-/** TUI surface for shadow-git checkpoints (port #11, cline): /checkpoints lists the
- *  session's snapshots in a pickOne overlay; /restore <ref> [files|conversation|both]
- *  replays cline's three restore modes. Conversation/both restores branch the session
- *  tree to the checkpoint's recorded entryId (port #2 leaf machinery) — the CALLER
- *  owns the store, so branching + replay run through the injected ctx. */
-
-import type { RestoreMode } from "../coding/checkpoints.ts";
-import type { Checkpoints } from "../coding/checkpoints.ts";
-import type { Renderer } from "./renderer.ts";
-
-export interface CheckpointCmdCtx {
-  renderer: Renderer;
-  busy(): boolean;
-  /** active session id (checkpoints are per-session) */
-  sessionId(): string;
-  checkpointsFor(sessionId: string): Promise<Checkpoints | null>;
-  /** branch the ACTIVE session store to entryId; false when the entry is unknown */
-  branchTo(entryId: string): boolean;
-  /** re-render transcript + usage after a conversation restore */
-  replayAndRefresh(): void;
-}
-
-const MODES: readonly RestoreMode[] = ["files", "conversation", "both"];
-
-/** /checkpoints — list snapshots newest-first in the overlay; picking one prefills nothing
- *  and just prints the /restore hint (restore is deliberately an explicit second step). */
-export async function cmdCheckpoints(ctx: CheckpointCmdCtx): Promise<void> {
-  if (ctx.busy()) { ctx.renderer.addSystemNote("finish or interrupt the run first (Esc)", "warn"); return; }
-  const cp = await ctx.checkpointsFor(ctx.sessionId());
-  if (!cp) { ctx.renderer.addSystemNote("checkpoints unavailable (git missing or ROVECODE_NO_CHECKPOINTS=1)", "warn"); return; }
-  const log = cp.list();
-  if (log.length === 0) { ctx.renderer.addSystemNote("no checkpoints yet — snapshots land after each mutating tool call"); return; }
-  const items = [...log].reverse().slice(0, 20).map((c, i) => ({
-    value: c.hash,
-    label: `#${log.length - i} ${c.label} · ${c.hash.slice(0, 8)}`,
-    description: `${new Date(c.createdAt).toLocaleString()}${c.entryId ? " · conversation anchor" : ""}`,
-  }));
-  const picked = await ctx.renderer.pickOne(items, "checkpoints (Enter = show restore hint, Esc = close)");
-  ctx.replayAndRefresh(); // clear the overlay title note
-  if (picked) ctx.renderer.addSystemNote(`restore with: /restore ${picked.slice(0, 8)} [files|conversation|both]`);
-}
-
-/** /restore <hash-prefix> [mode] — files (workspace only), conversation (session branch
- *  only), or both. Cline's three modes, checkpoint-restore semantics. */
-export async function cmdRestore(ctx: CheckpointCmdCtx, arg: string): Promise<void> {
-  if (ctx.busy()) { ctx.renderer.addSystemNote("finish or interrupt the run first (Esc)", "warn"); return; }
-  const [ref, modeArg] = arg.split(/\s+/);
-  if (!ref) { ctx.renderer.addSystemNote("usage: /restore <checkpoint> [files|conversation|both] — list with /checkpoints", "warn"); return; }
-  const mode = (modeArg || "files") as RestoreMode;
-  if (!MODES.includes(mode)) { ctx.renderer.addSystemNote(`unknown restore mode "${modeArg}" (files|conversation|both)`, "warn"); return; }
-  const cp = await ctx.checkpointsFor(ctx.sessionId());
-  if (!cp) { ctx.renderer.addSystemNote("checkpoints unavailable (git missing or ROVECODE_NO_CHECKPOINTS=1)", "warn"); return; }
-  // dedupe candidates BY HASH (identical content re-snapshotted shares one): counting
-  // entries made even the full 40-char hash "match 2 checkpoints" forever. Latest entry
-  // per hash wins, mirroring the module's own pick.
-  const match = [...new Map(cp.list().filter((c) => c.hash.startsWith(ref)).map((c) => [c.hash, c])).values()];
-  if (match.length !== 1) {
-    ctx.renderer.addSystemNote(match.length === 0 ? `no checkpoint matching "${ref}"` : `"${ref}" matches ${match.length} checkpoints — be more specific`, "warn");
-    return;
-  }
-  const res = await cp.restore(match[0]!.hash, mode);
-  if (!res.ok) { ctx.renderer.addSystemNote(`restore failed: ${res.error}`, "error"); return; }
-  let convNote = "";
-  if (mode === "conversation" || mode === "both") {
-    if (res.entryId && ctx.branchTo(res.entryId)) { ctx.replayAndRefresh(); convNote = " · conversation branched to the checkpoint's turn"; }
-    else convNote = " · conversation anchor unavailable in this session tree (files unaffected by that)";
-  }
-  const fileNote = mode === "conversation" ? "" : "workspace rolled back";
-  ctx.renderer.addSystemNote(`restored ${res.checkpoint.hash.slice(0, 8)} (${mode}) — ${fileNote}${convNote}; snapshots keep history`);
-}

package/src/tui/clipboard-image.ts

@@ -1,81 +0,0 @@
-/** Read an IMAGE from the system clipboard (⌃v / `/paste`).
- *
- *  A terminal only ever hands a program TEXT from the clipboard (bracketed paste). When the clipboard
- *  holds an image — a screenshot, a copied picture — the terminal sends nothing useful, and users who
- *  press ⌃v expecting the image to land (every chat app taught them that) get silence. So the surface
- *  asks the OS itself, through the one tool each platform has for it, and converts to PNG:
- *    win32  PowerShell + System.Windows.Forms.Clipboard.GetImage()  → PNG → base64 on stdout
- *    darwin osascript `the clipboard as «class PNGf»`                → hex («data PNGf…»)
- *    linux  wl-paste -t image/png, else xclip -selection clipboard -t image/png -o
- *
- *  The command runner is injected so tests never touch a real clipboard; every failure (no image on
- *  the clipboard, tool missing, odd output) is `null`, never a throw — the caller says "no image on the
- *  clipboard" and moves on. Nothing here writes a file: the bytes go straight to core/images.ts
- *  imageFromBytes, which sniffs the magic bytes and enforces the size cap like any other attachment. */
-
-import { spawnSync } from "node:child_process";
-
-export interface ClipboardRunner {
-  /** run a command, return stdout decoded as `encoding` (utf8 for text tools, latin1 when the tool
-   *  prints raw image bytes — utf8 decoding would corrupt them), or null when it failed / is missing */
-  (cmd: string, args: readonly string[], encoding?: "utf8" | "latin1"): string | null;
-}
-
-const TIMEOUT_MS = 5_000;
-const MAX_OUT = 64 * 1024 * 1024; // a 5 MiB image is ~7 MiB of base64; leave room, never unbounded
-
-/** child_process.spawnSync under the contract above: non-zero exit, signal, timeout or ENOENT → null */
-export const spawnRunner: ClipboardRunner = (cmd, args, encoding = "utf8") => {
-  try {
-    const r = spawnSync(cmd, args, { encoding, timeout: TIMEOUT_MS, maxBuffer: MAX_OUT, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
-    if (r.error || r.status !== 0 || r.signal) return null;
-    return r.stdout;
-  } catch { return null; }
-};
-
-/** PowerShell: the image as PNG base64, or nothing when the clipboard holds no image */
-const PS_SCRIPT = [
-  "Add-Type -AssemblyName System.Windows.Forms,System.Drawing",
-  "$i = [System.Windows.Forms.Clipboard]::GetImage()",
-  "if ($i -eq $null) { exit 3 }",
-  "$ms = New-Object System.IO.MemoryStream",
-  "$i.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)",
-  "[Console]::Out.Write([Convert]::ToBase64String($ms.ToArray()))",
-].join("; ");
-
-function fromBase64(s: string | null): Uint8Array | null {
-  const t = s?.trim() ?? "";
-  if (t.length < 16 || !/^[A-Za-z0-9+/=\r\n]+$/.test(t)) return null;
-  try { return new Uint8Array(Buffer.from(t.replace(/\s+/g, ""), "base64")); } catch { return null; }
-}
-
-/** osascript prints `«data PNGf89504E47…»`; take the hex between the marker and the closing » */
-function fromAppleScriptHex(s: string | null): Uint8Array | null {
-  const m = /«data PNGf([0-9A-Fa-f]+)»/.exec(s ?? "");
-  if (!m || m[1]!.length < 32 || m[1]!.length % 2 !== 0) return null;
-  return new Uint8Array(Buffer.from(m[1]!, "hex"));
-}
-
-/** The clipboard image as raw bytes (PNG on win32/darwin, whatever the tool yields on linux — the
- *  magic-byte sniff downstream decides), or null when there is none. `platform` defaults to the process's. */
-export function readClipboardImage(run: ClipboardRunner = spawnRunner, platform: NodeJS.Platform = process.platform): Uint8Array | null {
-  if (platform === "win32") {
-    return fromBase64(run("powershell", ["-NoProfile", "-NonInteractive", "-STA", "-Command", PS_SCRIPT]));
-  }
-  if (platform === "darwin") {
-    return fromAppleScriptHex(run("osascript", ["-e", "the clipboard as «class PNGf»"]));
-  }
-  // linux and the rest: wayland first, then X11; both print the raw PNG, which the runner returns as a
-  // utf8 string — decode it back to bytes with latin1 so no byte is altered
-  for (const [cmd, args] of [["wl-paste", ["-t", "image/png"]], ["xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]]] as const) {
-    const out = run(cmd, args, "latin1");
-    if (out !== null && out.length > 8) return new Uint8Array(Buffer.from(out, "latin1"));
-  }
-  return null;
-}
-
-/** what a pasted image is called in the transcript chip and the sidecar name: clipboard-HHMMSS.png */
-export function clipboardImageName(now: Date = new Date()): string {
-  const p = (n: number): string => String(n).padStart(2, "0");
-  return `clipboard-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}.png`;
-}

package/src/tui/clipboard.ts

@@ -1,78 +0,0 @@
-/** System clipboard writer for `/copy` (port #53). ONE candidate chain per platform family, tried in
- *  order until one succeeds; the process spawner is injectable so tests pin the order with a fake and
- *  the only real-process test is the Windows round-trip (clipboard.test.ts, skipped elsewhere).
- *    win32       powershell — `Set-Clipboard` fed the text on stdin, decoded as UTF-8 explicitly
- *                ([Console]::InputEncoding, else the OEM code page garbles non-ASCII; verified: a string
- *                with accents, an em dash, a check mark and CJK reads back byte-identical via
- *                `Get-Clipboard -Raw`). clip.exe is NOT in the chain: its stdin decoding is code-page
- *                dependent and was not proven.
- *    everything  pbcopy (macOS) → wl-copy (Wayland) → xclip -selection clipboard → xsel --clipboard --input
- *    else        — one chain for every non-Windows platform: a tool the host lacks fails to spawn
- *                (ENOENT) and the chain simply moves on, so macOS stops at pbcopy and Linux skips it
- *  A missing binary, a non-zero exit and a spawn error all mean "next candidate"; when the chain is
- *  exhausted the result says which tools were tried. Never throws.
- *
- *  Pattern reference only, no code ported: gemini-cli @ 0bd1d43 packages/cli/src/ui/commands/
- *  copyCommand.ts (the last model message's text parts joined, "no output" / "no text" notes, :24-68).
- *  gemini hands the write to the `clipboardy` package behind an OSC-52 attempt
- *  (ui/utils/commandUtils.ts:256-283); the explicit tool chain, the stdin-fed PowerShell form and the
- *  injectable spawner are rovecode's. */
-
-export interface SpawnOutcome { ok: boolean; detail?: string }
-
-/** Run `argv` with `input` on stdin; resolve ok on exit 0. Rejections are treated as failures. */
-export type ClipboardSpawn = (argv: readonly string[], input: string) => Promise<SpawnOutcome>;
-
-export interface ClipboardOptions {
-  platform?: NodeJS.Platform;
-  spawn?: ClipboardSpawn;
-}
-
-export type ClipboardResult =
-  | { ok: true; tool: string }
-  | { ok: false; tried: string[]; detail?: string };
-
-/** Windows: read ALL of stdin as UTF-8 (the default console input encoding is the OEM code page)
- *  and hand it to Set-Clipboard verbatim — no trailing newline added, no line splitting. */
-export const WIN_SET_CLIPBOARD = "[Console]::InputEncoding=[Text.Encoding]::UTF8; $t=[Console]::In.ReadToEnd(); Set-Clipboard -Value $t";
-
-/** The candidates for a platform, in the order they are tried (header): PowerShell alone on Windows,
- *  the pbcopy → wl-copy → xclip → xsel chain everywhere else. */
-export function clipboardChain(platform: NodeJS.Platform): readonly (readonly string[])[] {
-  if (platform === "win32") return [["powershell", "-NoProfile", "-NonInteractive", "-Command", WIN_SET_CLIPBOARD]];
-  return [["pbcopy"], ["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
-}
-
-/** Default spawner: Bun.spawn with the text piped to stdin. A missing binary throws synchronously
- *  (ENOENT) — caught here and reported as a failed candidate, like a non-zero exit. */
-export const bunClipboardSpawn: ClipboardSpawn = async (argv, input) => {
-  try {
-    const proc = Bun.spawn([...argv], { stdin: "pipe", stdout: "ignore", stderr: "pipe" });
-    proc.stdin.write(input);
-    await proc.stdin.end();
-    const code = await proc.exited;
-    if (code === 0) return { ok: true };
-    const err = (await new Response(proc.stderr).text()).trim().split("\n")[0] ?? "";
-    return { ok: false, detail: `exit ${code}${err ? `: ${err.slice(0, 120)}` : ""}` };
-  } catch (e) {
-    return { ok: false, detail: e instanceof Error ? e.message : String(e) };
-  }
-};
-
-/** Copy `text` to the system clipboard through the platform's chain. Empty text is refused up
- *  front (nothing is spawned): a blank clipboard write is never what /copy meant. */
-export async function copyToClipboard(text: string, opts: ClipboardOptions = {}): Promise<ClipboardResult> {
-  const spawn = opts.spawn ?? bunClipboardSpawn;
-  const tried: string[] = [];
-  if (text.length === 0) return { ok: false, tried, detail: "nothing to copy (empty text)" };
-  let detail: string | undefined;
-  for (const argv of clipboardChain(opts.platform ?? process.platform)) {
-    const tool = argv[0]!;
-    tried.push(tool);
-    let out: SpawnOutcome;
-    try { out = await spawn(argv, text); } catch (e) { out = { ok: false, detail: e instanceof Error ? e.message : String(e) }; }
-    if (out.ok) return { ok: true, tool };
-    detail = out.detail;
-  }
-  return { ok: false, tried, ...(detail !== undefined ? { detail } : {}) };
-}