@yanzc/claude-pro 0.0.0-stage → 0.4.1

package/src/ui/screen.js

@@ -0,0 +1,259 @@
+// Terminal screen manager. Output is split into:
+//   - a static log that scrolls up normally (finished messages, tool results), and
+//   - a live region at the bottom (streaming text, spinner, input box, dialogs) that is
+//     erased and redrawn in place.
+// Every live line is pre-wrapped to (columns - 1) so we always know how many rows it uses.
+//
+// Resizing. A terminal re-flows what is on screen when its width changes: a live row that was
+// 99 columns wide becomes two rows at 80, and where the cursor ends up afterwards differs between
+// terminals (and between a terminal and the ConPTY that Windows puts in front of it). Finding the top
+// of the live region again by moving the cursor up a computed number of rows is therefore a guess,
+// and a wrong guess leaves half of the old input box on screen. So once the resizing has paused, the
+// whole viewport is written again from its top-left corner (see repaint), the last static lines taken
+// from memory and the live region below them, which needs no knowledge of where the cursor was.
+// Nothing is drawn while the size is still changing: a redraw made between two re-flows works from a
+// screen that is about to change again.
+
+import { ESC, wrapLine, termWidth, truncate } from './ansi.js';
+
+const SYNC_START = '\x1b[?2026h';
+const SYNC_END = '\x1b[?2026l';
+
+const RESIZE_QUIET_MS = 80; // repaint once the size has not changed for this long ...
+const RESIZE_MAX_WAIT_MS = 300; // ... or at the latest this long after it started changing
+const HISTORY_KEEP = 600; // static lines remembered for repainting (a screen shows far fewer)
+const HISTORY_LINE_CHARS = 20_000;
+
+// How many rows a static line takes when the terminal wraps it at `cols`.
+function rowsOf(line, cols) {
+  return wrapLine(line, cols).length;
+}
+
+const TITLE_MAX_WIDTH = 100;
+const TITLE_PUSH = '\x1b[22;0t'; // xterm title stack: remember the title the shell had ...
+const TITLE_POP = '\x1b[23;0t'; // ... and bring it back (terminals without a stack ignore both)
+
+// Text that is safe inside an OSC title: no control characters (one could end the sequence early and
+// run on as escape codes), single spaces, not too long.
+export function cleanTitle(text) {
+  // eslint-disable-next-line no-control-regex
+  const flat = String(text ?? '').replace(/[\u0000-\u001f\u007f-\u009f]+/g, ' ').replace(/\s+/g, ' ').trim();
+  return truncate(flat, TITLE_MAX_WIDTH).replace(/\x1b\[0m$/, '');
+}
+
+export class Screen {
+  constructor(out = process.stdout) {
+    this.out = out;
+    this.cursorRow = 0; // row of the terminal cursor, relative to the top of the live region
+    this.staticQueue = [];
+    this.history = []; // the most recent static lines, for repainting after a resize
+    this.renderLive = () => ({ lines: [] });
+    this.scheduled = null;
+    this.resizeTimer = null;
+    this.resizeSince = 0;
+    this.closed = false;
+    this.titleProvider = null; // () => the terminal title (tab label) to show now
+    this.title = null; // what was last sent
+    this.titleInherited = false; // the process before this one in the session already saved the shell's title
+    this.exitTitle = '';
+    out.on('resize', () => this.onResize());
+  }
+
+  // Keep the terminal's title (the label of its tab or window) following `provider()`. `exitTitle` is what
+  // it shows once we are gone and the shell is back, for terminals that cannot restore the previous one.
+  setTitle(provider, exitTitle = '', { inherited = false } = {}) {
+    this.titleProvider = provider;
+    this.exitTitle = exitTitle;
+    this.titleInherited = inherited;
+    this.schedule();
+  }
+
+  // The escape sequence that brings the title up to date: nothing when it has not changed.
+  titleUpdate() {
+    if (!this.titleProvider) return '';
+    let text;
+    try { text = cleanTitle(this.titleProvider()); } catch { return ''; }
+    if (!text || text === this.title) return '';
+    const first = this.title === null && !this.titleInherited;
+    this.title = text;
+    return (first ? TITLE_PUSH : '') + `\x1b]0;${text}\x07`;
+  }
+
+  get width() { return Math.max(20, this.out.columns || termWidth()); }
+  get height() { return Math.max(10, this.out.rows || 30); }
+  // True from a size change until the repaint that follows it.
+  get resizing() { return this.resizeTimer !== null; }
+
+  setLive(fn) { this.renderLive = fn; this.schedule(); }
+
+  // Append lines (strings, may contain \n) to the static log.
+  log(...items) {
+    for (const item of items) {
+      if (Array.isArray(item)) this.staticQueue.push(...item);
+      else this.staticQueue.push(String(item));
+    }
+    this.flush();
+  }
+
+  schedule() {
+    if (this.scheduled || this.closed) return;
+    this.scheduled = setTimeout(() => { this.scheduled = null; this.flush(); }, 16);
+  }
+
+  // Take the queued static output as lines, remembering them for a later repaint.
+  takeStatic() {
+    if (!this.staticQueue.length) return [];
+    const lines = this.staticQueue.join('\n').split(/\r?\n/);
+    this.staticQueue = [];
+    for (const line of lines) this.history.push(line.length > HISTORY_LINE_CHARS ? line.slice(0, HISTORY_LINE_CHARS) : line);
+    if (this.history.length > HISTORY_KEEP * 2) this.history.splice(0, this.history.length - HISTORY_KEEP);
+    return lines;
+  }
+
+  // The live region as rows (pre-wrapped to cols-1, capped to fit the viewport) and where the cursor goes.
+  layoutLive(cols) {
+    let live;
+    try {
+      live = this.renderLive(cols) || {};
+    } catch (e) {
+      live = { lines: [`\x1b[31mrender error: ${e.message}\x1b[0m`] };
+    }
+    const { lines = [], cursor = null } = live;
+    const rows = [];
+    let cursorRow = null, cursorCol = 0;
+    lines.forEach((line, i) => {
+      const wrapped = wrapLine(line, cols - 1);
+      if (cursor && cursor.row === i) {
+        const col = cursor.col;
+        const extra = Math.floor(col / (cols - 1));
+        cursorRow = rows.length + Math.min(extra, wrapped.length - 1);
+        cursorCol = col - extra * (cols - 1);
+      }
+      rows.push(...wrapped);
+    });
+    // Cap to the terminal height so there is always a way back to the top.
+    const maxRows = Math.max(1, Math.min(this.height, this.out.rows || this.height) - 1);
+    if (rows.length > maxRows) {
+      const dropped = rows.length - maxRows;
+      rows.splice(0, dropped);
+      if (cursorRow !== null) cursorRow = Math.max(0, cursorRow - dropped);
+    }
+    return { rows, cursorRow, cursorCol };
+  }
+
+  // Escape sequence that leaves the cursor where the user types, and the bookkeeping for the next redraw.
+  settleCursor({ rows, cursorRow, cursorCol }) {
+    const last = Math.max(0, rows.length - 1);
+    let buf = '';
+    if (cursorRow !== null && rows.length) {
+      buf = ESC.up(last - cursorRow) + '\r' + ESC.right(cursorCol) + ESC.showCursor;
+      this.cursorRow = cursorRow;
+    } else {
+      this.cursorRow = last;
+    }
+    return buf;
+  }
+
+  onResize() {
+    if (this.closed) return;
+    const now = Date.now();
+    if (!this.resizeSince) this.resizeSince = now;
+    clearTimeout(this.resizeTimer);
+    const wait = Math.max(0, Math.min(RESIZE_QUIET_MS, this.resizeSince + RESIZE_MAX_WAIT_MS - now));
+    this.resizeTimer = setTimeout(() => this.settleResize(), wait);
+  }
+
+  settleResize() {
+    this.resizeTimer = null;
+    this.resizeSince = 0;
+    this.repaint();
+  }
+
+  // Write the whole viewport again after a resize: the newest static lines that fit, then the live region,
+  // so that the last row of the live region is the last row of the screen (when there is enough output to
+  // fill it). Absolute positioning only, no cursor-relative moves: a relative move computed for one width
+  // lands in the wrong place when the terminal has already re-flowed to another, which is exactly what
+  // happens when the size keeps changing.
+  //
+  // What was on screen above our output (a short session: the shell that started us) is overwritten.
+  repaint() {
+    if (this.closed) return;
+    if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
+    clearTimeout(this.resizeTimer);
+    this.resizeTimer = null;
+    this.resizeSince = 0;
+    const cols = this.width;
+    const screenRows = Math.max(1, this.out.rows || this.height);
+    this.takeStatic();
+    const layout = this.layoutLive(cols);
+    const room = Math.max(0, screenRows - layout.rows.length);
+    const tail = [];
+    for (let used = 0, i = this.history.length - 1; i >= 0; i--) {
+      const n = rowsOf(this.history[i], cols);
+      if (used + n > room) break;
+      tail.unshift(this.history[i]);
+      used += n;
+    }
+    // Every row is overwritten (EL clears what the new text does not cover) and what is left below is
+    // erased, so no old text survives, wherever the terminal put it when it re-flowed.
+    const all = [...tail, ...layout.rows];
+    let buf = SYNC_START + ESC.hideCursor + this.titleUpdate() + '\x1b[H';
+    buf += all.map((row) => row + '\x1b[0m\x1b[K').join('\r\n');
+    buf += ESC.clearDown;
+    buf += this.settleCursor(layout);
+    buf += SYNC_END;
+    this.out.write(buf);
+  }
+
+  flush() {
+    if (this.closed) return;
+    if (this.resizing) return; // the repaint after the resize writes everything that is waiting
+    if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
+    const cols = this.width;
+    let buf = SYNC_START + ESC.hideCursor + this.titleUpdate() + '\r' + ESC.up(this.cursorRow) + ESC.clearDown;
+    const lines = this.takeStatic();
+    if (lines.length) {
+      // Explicit CRLF: not every terminal translates a bare LF into CR+LF.
+      buf += lines.map((l) => l + '\x1b[0m').join('\r\n') + '\r\n';
+    }
+    const layout = this.layoutLive(cols);
+    buf += layout.rows.map((r) => r + '\x1b[0m').join('\r\n');
+    buf += this.settleCursor(layout);
+    buf += SYNC_END;
+    this.out.write(buf);
+  }
+
+  // Erase the live region (used before exiting or handing the terminal to a child).
+  clearLive() {
+    if (this.resizing) this.repaint();
+    if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
+    this.out.write('\r' + ESC.up(this.cursorRow) + ESC.clearDown + ESC.showCursor);
+    this.cursorRow = 0;
+  }
+
+  clearScreen() {
+    this.out.write(ESC.clearScreen);
+    this.cursorRow = 0;
+    this.history = [];
+    this.flush();
+  }
+
+  // Print any pending output, then remove the live region (input box etc.) for good.
+  // `keepTitle`: another process takes the terminal over at once (a restart), so the tab keeps its title.
+  close({ keepTitle = false } = {}) {
+    if (this.closed) return;
+    if (this.resizing) this.repaint(); // the cursor is not where the last draw left it: put things in order first
+    this.renderLive = () => ({ lines: [] });
+    this.flush();
+    this.closed = true;
+    clearTimeout(this.resizeTimer);
+    // Give the tab back its old label: a terminal with a title stack restores it, and one without is
+    // left with a neutral one rather than a title that still looks like a program that is running.
+    let restore = '';
+    if (this.title !== null && !keepTitle) {
+      const neutral = cleanTitle(this.exitTitle);
+      restore = (neutral ? `\x1b]0;${neutral}\x07` : '') + TITLE_POP;
+    }
+    this.out.write(restore + ESC.showCursor);
+  }
+}

package/src/updater.js

@@ -0,0 +1,93 @@
+// Auto-update, as in Claude Code: an interactive session installed with `npm i -g claude-pro` looks for a newer
+// version on the npm registry (at most once every few hours), installs it in the background, and the session
+// then loads it with a restart once it is idle (the conversation carries over). A git checkout (the
+// development copy) is never touched. Off with CLAUDE_PRO_AUTO_UPDATE=0 or DISABLE_AUTOUPDATER=1.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import https from 'node:https';
+import { spawn } from 'node:child_process';
+import { CONFIG_DIR, INSTALL_DIR, VERSION } from './config.js';
+
+// The name on npm (scoped: npm refused plain `claude-pro` as too close to another package's name).
+export const PACKAGE_NAME = JSON.parse(fs.readFileSync(path.join(INSTALL_DIR, 'package.json'), 'utf8')).name;
+const STATE_FILE = path.join(CONFIG_DIR, 'update-check.json');
+const CHECK_EVERY_MS = 6 * 3600_000;
+
+export function autoUpdateEnabled(env = process.env) {
+  if (/^(1|true|yes)$/i.test(env.DISABLE_AUTOUPDATER || '')) return false;
+  return !/^(0|false|no|off)$/i.test(env.CLAUDE_PRO_AUTO_UPDATE || '');
+}
+
+// The node_modules directory a package is installed in: one level up, or two for a scoped (@scope/name) package.
+export function modulesDir(dir = INSTALL_DIR) {
+  const up = path.dirname(dir);
+  return path.basename(up).startsWith('@') ? path.dirname(up) : up;
+}
+
+// Installed by npm (a package in some node_modules), not run from a source checkout.
+export function installedByNpm(dir = INSTALL_DIR) {
+  return path.basename(modulesDir(dir)) === 'node_modules' && !fs.existsSync(path.join(dir, '.git')) && !/[\\/]_npx[\\/]/.test(dir);
+}
+
+// 1.2.10 > 1.2.9; a prerelease (1.3.0-beta) is never taken for newer.
+export function isNewer(latest, current) {
+  if (!/^\d+\.\d+\.\d+$/.test(String(latest))) return false;
+  const a = latest.split('.').map(Number);
+  const b = String(current).split('-')[0].split('.').map(Number);
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > (b[i] || 0);
+  return false;
+}
+
+function readState() { try { return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch { return {}; } }
+function writeState(s) { try { fs.mkdirSync(CONFIG_DIR, { recursive: true }); fs.writeFileSync(STATE_FILE, JSON.stringify(s)); } catch { /* ignore */ } }
+
+export function latestVersion({ timeoutMs = 10_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME.replace('/', '%2f')}/latest`, { headers: { accept: 'application/json' }, timeout: timeoutMs }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (d) => { body += d; });
+      res.on('end', () => {
+        if (res.statusCode !== 200) return reject(new Error(`npm registry: HTTP ${res.statusCode}`));
+        try { resolve(JSON.parse(body).version); } catch (e) { reject(e); }
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('npm registry did not answer')));
+    req.on('error', reject);
+  });
+}
+
+function runNpm(args, { timeoutMs = 300_000 } = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(process.platform === 'win32' ? 'npm.cmd' : 'npm', args, { shell: process.platform === 'win32', windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', (d) => { out += d; });
+    const timer = setTimeout(() => child.kill(), timeoutMs);
+    child.on('error', (e) => { clearTimeout(timer); resolve({ ok: false, output: e.message }); });
+    child.on('close', (code) => { clearTimeout(timer); resolve({ ok: code === 0, output: out.trim() }); });
+  });
+}
+
+// Look for a newer version and install it. Resolves with {status: 'disabled'|'dev'|'skipped'|'current'|'updated'|'failed', version, error}.
+// `force`: check now, whatever the last check was (the /update command).
+export async function checkForUpdate({ force = false, env = process.env, onInstalling } = {}) {
+  if (!force && !autoUpdateEnabled(env)) return { status: 'disabled' };
+  if (!installedByNpm()) return { status: 'dev' };
+  const state = readState();
+  if (!force && state.checkedAt && Date.now() - state.checkedAt < CHECK_EVERY_MS) return { status: 'skipped' };
+  writeState({ ...state, checkedAt: Date.now() });
+  const latest = await latestVersion();
+  if (!isNewer(latest, VERSION)) return { status: 'current', version: latest };
+  // Only a global install is updated by `npm i -g`: one in a project's node_modules belongs to that project.
+  const root = await runNpm(['root', '-g'], { timeoutMs: 30_000 });
+  if (!root.ok || path.resolve(root.output.split(/\r?\n/).pop()) !== path.resolve(modulesDir())) {
+    return { status: 'failed', version: latest, error: `this copy (${INSTALL_DIR}) is not the global npm install; update it with npm yourself` };
+  }
+  onInstalling?.(latest);
+  const r = await runNpm(['install', '-g', `${PACKAGE_NAME}@${latest}`]);
+  if (!r.ok) return { status: 'failed', version: latest, error: r.output.split('\n').slice(-5).join('\n') };
+  writeState({ checkedAt: Date.now(), installed: latest });
+  return { status: 'updated', version: latest };
+}

package/src/utils/clipboard.js

@@ -0,0 +1,197 @@
+// Read an image from the system clipboard (alt+v / ctrl+v in the prompt), like Claude Code.
+// Windows: PowerShell + System.Windows.Forms; macOS: osascript; Linux: wl-paste / xclip.
+// Large images are scaled so the long edge is at most 1568px (the API's recommended size).
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+export const MAX_IMAGE_BYTES = 3_750_000; // ~5MB once base64 encoded
+const IMAGE_EXT = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp' };
+
+function run(cmd, args, { env, timeout = 15_000 } = {}) {
+  return new Promise((resolve) => {
+    let out = '', err = '';
+    let child;
+    try {
+      child = spawn(cmd, args, { env: { ...process.env, ...env }, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (e) {
+      resolve({ code: -1, out: '', err: e.message });
+      return;
+    }
+    const timer = setTimeout(() => child.kill(), timeout);
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', (d) => { err += d; });
+    child.on('error', (e) => { clearTimeout(timer); resolve({ code: -1, out, err: e.message }); });
+    child.on('close', (code) => { clearTimeout(timer); resolve({ code, out: out.trim(), err: err.trim() }); });
+  });
+}
+
+// Prints "IMG <format> <w>x<h>" after writing $env:CLAUDE_PRO_IMG_OUT, or "FILE <path>" when the
+// clipboard holds a copied image file. Exit code 2 = no image. CLAUDE_PRO_IMG_SOURCE (a file) replaces
+// the clipboard as input, which the tests use so they don't clobber the real clipboard.
+const PS_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$out = $env:CLAUDE_PRO_IMG_OUT
+$img = $null
+if ($env:CLAUDE_PRO_IMG_SOURCE) {
+  $img = [System.Drawing.Image]::FromFile($env:CLAUDE_PRO_IMG_SOURCE)
+} elseif ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+  $img = [System.Windows.Forms.Clipboard]::GetImage()
+} elseif ([System.Windows.Forms.Clipboard]::ContainsFileDropList()) {
+  foreach ($f in [System.Windows.Forms.Clipboard]::GetFileDropList()) {
+    if ($f -match '\\.(png|jpe?g|gif|webp|bmp)$') { Write-Output "FILE $f"; exit 0 }
+  }
+}
+if ($img -eq $null) { exit 2 }
+$max = 1568
+$scale = [Math]::Min(1.0, $max / [Math]::Max($img.Width, $img.Height))
+if ($scale -lt 1.0) {
+  $w = [int][Math]::Round($img.Width * $scale); $h = [int][Math]::Round($img.Height * $scale)
+  $bmp = New-Object System.Drawing.Bitmap $w, $h
+  $g = [System.Drawing.Graphics]::FromImage($bmp)
+  $g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
+  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::HighQuality
+  $g.PixelOffsetMode = [System.Drawing.Drawing2D.PixelOffsetMode]::HighQuality
+  $g.DrawImage($img, 0, 0, $w, $h)
+  $g.Dispose(); $img.Dispose(); $img = $bmp
+}
+$img.Save($out, [System.Drawing.Imaging.ImageFormat]::Png)
+$format = 'png'
+if ((Get-Item $out).Length -gt ${MAX_IMAGE_BYTES}) {
+  $codec = [System.Drawing.Imaging.ImageCodecInfo]::GetImageEncoders() | Where-Object { $_.MimeType -eq 'image/jpeg' }
+  $params = New-Object System.Drawing.Imaging.EncoderParameters 1
+  $params.Param[0] = New-Object System.Drawing.Imaging.EncoderParameter ([System.Drawing.Imaging.Encoder]::Quality), 85L
+  $img.Save($out, $codec, $params)
+  $format = 'jpeg'
+}
+Write-Output ("IMG " + $format + " " + $img.Width + "x" + $img.Height)
+`;
+
+// Turn a file on disk into an image block, or return an error string.
+export function imageFromFile(file) {
+  const media = IMAGE_EXT[path.extname(file).toLowerCase()];
+  if (!media) return { error: `Not a supported image type: ${path.basename(file)}` };
+  let st;
+  try { st = fs.statSync(file); } catch { return { error: `File not found: ${file}` }; }
+  if (!st.isFile()) return { error: `Not a file: ${file}` };
+  if (st.size > MAX_IMAGE_BYTES) return { error: `Image is too large (${(st.size / 1e6).toFixed(1)}MB, max 3.7MB)` };
+  return { image: { media_type: media, data: fs.readFileSync(file).toString('base64'), bytes: st.size, source: file } };
+}
+
+async function readWindows(source) {
+  const outFile = path.join(os.tmpdir(), `claude-pro-clipboard-${process.pid}-${Date.now()}.img`);
+  const encoded = Buffer.from(PS_SCRIPT, 'utf16le').toString('base64');
+  const r = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-STA', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded], {
+    env: { CLAUDE_PRO_IMG_OUT: outFile, CLAUDE_PRO_IMG_SOURCE: source || '' },
+  });
+  try {
+    if (r.code === 2) return { error: null };
+    if (r.code !== 0) return { error: `Could not read the clipboard: ${(r.err || r.out || `exit ${r.code}`).split('\n')[0]}` };
+    if (r.out.startsWith('FILE ')) return imageFromFile(r.out.slice(5).trim());
+    const m = /^IMG (\w+) (\d+)x(\d+)/m.exec(r.out);
+    if (!m) return { error: `Unexpected clipboard reader output: ${r.out.slice(0, 200)}` };
+    const buf = fs.readFileSync(outFile);
+    return { image: { media_type: `image/${m[1]}`, data: buf.toString('base64'), bytes: buf.length, width: +m[2], height: +m[3] } };
+  } finally {
+    fs.rm(outFile, { force: true }, () => {});
+  }
+}
+
+async function readMac() {
+  const outFile = path.join(os.tmpdir(), `claude-pro-clipboard-${process.pid}-${Date.now()}.png`);
+  const r = await run('osascript', [
+    '-e', `set f to (open for access POSIX file "${outFile}" with write permission)`,
+    '-e', 'try', '-e', 'write (the clipboard as «class PNGf») to f', '-e', 'end try', '-e', 'close access f',
+  ]);
+  try {
+    const size = fs.existsSync(outFile) ? fs.statSync(outFile).size : 0;
+    if (r.code !== 0 || size === 0) return { error: null };
+    return imageFromFile(outFile);
+  } finally {
+    fs.rm(outFile, { force: true }, () => {});
+  }
+}
+
+async function readLinux() {
+  for (const [cmd, args] of [['wl-paste', ['--type', 'image/png']], ['xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o']]]) {
+    const r = await new Promise((resolve) => {
+      const chunks = [];
+      const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+      // A clipboard owner that never answers must not leave the reader hanging.
+      const timer = setTimeout(() => child.kill(), 5000);
+      child.stdout.on('data', (d) => chunks.push(d));
+      child.on('error', () => { clearTimeout(timer); resolve(null); });
+      child.on('close', (code) => { clearTimeout(timer); resolve(code === 0 ? Buffer.concat(chunks) : null); });
+    });
+    if (r?.length) {
+      if (r.length > MAX_IMAGE_BYTES) return { error: 'Image is too large (max 3.7MB)' };
+      return { image: { media_type: 'image/png', data: r.toString('base64'), bytes: r.length } };
+    }
+  }
+  return { error: null };
+}
+
+// Returns {image} on success, {error: string} on failure, or {error: null} when the clipboard has no image.
+export async function readClipboardImage({ source } = {}) {
+  if (process.platform === 'win32') return readWindows(source);
+  if (process.platform === 'darwin') return readMac();
+  return readLinux();
+}
+
+// Watch the clipboard and call `onCopy(chars)` when something new is put on it, so that the program can say
+// "copied" after the user copies text selected in the terminal (the terminal itself does not tell the program).
+// Windows only: one long-lived PowerShell that polls the clipboard's sequence number, which is cheap, and leaves
+// when this process is gone. Returns {close()}; elsewhere it never calls back.
+const WATCH_SCRIPT = `
+$ErrorActionPreference = 'SilentlyContinue'
+Add-Type -Namespace ClaudePro -Name Clip -MemberDefinition '[DllImport("user32.dll")] public static extern uint GetClipboardSequenceNumber();'
+$parent = [int]$env:CLAUDE_PRO_PARENT_PID
+$last = [ClaudePro.Clip]::GetClipboardSequenceNumber()
+$n = 0
+while ($true) {
+  Start-Sleep -Milliseconds 250
+  $seq = [ClaudePro.Clip]::GetClipboardSequenceNumber()
+  if ($seq -ne $last) {
+    $last = $seq
+    Start-Sleep -Milliseconds 50
+    $text = Get-Clipboard -Raw
+    $len = if ($text) { $text.Length } else { 0 }
+    [Console]::Out.WriteLine("COPY $len")
+    [Console]::Out.Flush()
+  }
+  $n++
+  if ($n % 8 -eq 0) { try { [void][System.Diagnostics.Process]::GetProcessById($parent) } catch { exit } }
+}
+`;
+
+export function watchClipboard(onCopy) {
+  if (process.platform !== 'win32') return { close() {} };
+  let child;
+  try {
+    const encoded = Buffer.from(WATCH_SCRIPT, 'utf16le').toString('base64'); // "-Command -" runs a loop line by line, which breaks it
+    child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], {
+      env: { ...process.env, CLAUDE_PRO_PARENT_PID: String(process.pid) }, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    return { close() {} };
+  }
+  child.on('error', () => {});
+  let buf = '';
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', (d) => {
+    buf += d;
+    let i;
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const m = /^COPY (\d+)/.exec(buf.slice(0, i).trim());
+      buf = buf.slice(i + 1);
+      if (m) { try { onCopy(Number(m[1])); } catch { /* the callback's problem */ } }
+    }
+  });
+  child.unref();
+  child.stdout.unref?.();
+  return { close() { try { child.kill(); } catch { /* gone already */ } } };
+}

package/src/utils/diff.js

@@ -0,0 +1,95 @@
+// Line diff (Myers O(ND)) and hunk construction for displaying edits.
+
+export function diffLines(a, b) {
+  const n = a.length, m = b.length;
+  const max = n + m;
+  if (max === 0) return [];
+  // Guard against pathological sizes: fall back to delete-all / insert-all.
+  if (n * m > 25_000_000) {
+    return [...a.map((line) => ({ op: '-', line })), ...b.map((line) => ({ op: '+', line }))];
+  }
+  const v = new Int32Array(2 * max + 2);
+  const trace = [];
+  const off = max + 1;
+  let found = false;
+  for (let d = 0; d <= max && !found; d++) {
+    trace.push(v.slice());
+    for (let k = -d; k <= d; k += 2) {
+      let x;
+      if (k === -d || (k !== d && v[off + k - 1] < v[off + k + 1])) x = v[off + k + 1];
+      else x = v[off + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && a[x] === b[y]) { x++; y++; }
+      v[off + k] = x;
+      if (x >= n && y >= m) { found = true; break; }
+    }
+  }
+  // Backtrack.
+  const ops = [];
+  let x = n, y = m;
+  for (let d = trace.length - 1; d >= 0; d--) {
+    const vv = trace[d];
+    const k = x - y;
+    let prevK;
+    if (k === -d || (k !== d && vv[off + k - 1] < vv[off + k + 1])) prevK = k + 1;
+    else prevK = k - 1;
+    const prevX = vv[off + prevK];
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) { ops.push({ op: ' ', line: a[x - 1] }); x--; y--; }
+    if (d > 0) {
+      if (x === prevX) ops.push({ op: '+', line: b[y - 1] });
+      else ops.push({ op: '-', line: a[x - 1] });
+    }
+    x = prevX; y = prevY;
+  }
+  return ops.reverse();
+}
+
+// Build hunks with line numbers. Returns [{oldStart, newStart, lines:[{op, line, oldNo, newNo}]}]
+export function makeHunks(ops, context = 3, oldOffset = 0, newOffset = 0) {
+  let oldNo = oldOffset, newNo = newOffset;
+  const numbered = ops.map((o) => {
+    const r = { ...o, oldNo: null, newNo: null };
+    if (o.op !== '+') r.oldNo = ++oldNo;
+    if (o.op !== '-') r.newNo = ++newNo;
+    return r;
+  });
+  const hunks = [];
+  let cur = null;
+  let lastChange = -Infinity;
+  for (let i = 0; i < numbered.length; i++) {
+    if (numbered[i].op === ' ') continue;
+    const start = Math.max(0, i - context);
+    if (cur && start <= lastChange + context + 1) {
+      for (let j = lastChange + 1; j <= i; j++) cur.lines.push(numbered[j]);
+    } else {
+      if (cur) {
+        for (let j = lastChange + 1; j <= Math.min(numbered.length - 1, lastChange + context); j++) cur.lines.push(numbered[j]);
+        hunks.push(cur);
+      }
+      cur = { lines: numbered.slice(start, i + 1) };
+    }
+    lastChange = i;
+  }
+  if (cur) {
+    for (let j = lastChange + 1; j <= Math.min(numbered.length - 1, lastChange + context); j++) cur.lines.push(numbered[j]);
+    hunks.push(cur);
+  }
+  return hunks;
+}
+
+export function countChanges(ops) {
+  let added = 0, removed = 0;
+  for (const o of ops) {
+    if (o.op === '+') added++;
+    else if (o.op === '-') removed++;
+  }
+  return { added, removed };
+}
+
+export function splitLines(text) {
+  if (text === '') return [];
+  const lines = text.replace(/\r\n/g, '\n').split('\n');
+  if (lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}

package/src/utils/paths.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import os from 'node:os';
+
+const isWin = process.platform === 'win32';
+
+// Resolve a path the model gave us. Accepts absolute, relative (to cwd), ~, and on Windows
+// also Git-Bash style paths such as /d/foo/bar or /c/Users/...
+export function resolvePath(p, cwd) {
+  if (!p) return cwd;
+  p = String(p).trim();
+  if (p === '~' || p.startsWith('~/') || p.startsWith('~\\')) p = path.join(os.homedir(), p.slice(1));
+  if (isWin) {
+    const m = /^\/([a-zA-Z])(\/.*)?$/.exec(p);
+    if (m) p = `${m[1].toUpperCase()}:${(m[2] || '/').replace(/\//g, '\\')}`;
+  }
+  return path.resolve(cwd, p);
+}
+
+// Short path for display: relative to cwd when inside it.
+export function displayPath(p, cwd) {
+  if (!p) return '';
+  const rel = path.relative(cwd, p);
+  if (!rel) return '.';
+  if (!rel.startsWith('..') && !path.isAbsolute(rel)) return rel;
+  const home = os.homedir();
+  if (p.startsWith(home)) return '~' + p.slice(home.length);
+  return p;
+}
+
+export function isInside(child, parent) {
+  const rel = path.relative(parent, child);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+export function samePath(a, b) {
+  return isWin ? path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase() : path.resolve(a) === path.resolve(b);
+}