@yanzc/claude-pro 0.4.6 → 0.5.1

package/src/ui/screen.js

@@ -13,8 +13,23 @@
 // 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.
+//
+// Fullscreen (setFull), as Claude Code's fullscreen rendering: the program draws on the terminal's alternate
+// screen like vim, the input box fixed on the last rows, the conversation in the rows above it. The terminal's own
+// scrollback is not used: the conversation is kept here (history) and scrolled here, with the mouse wheel (mouse
+// reporting on, see mouseFilter), PgUp/PgDn and ctrl+Home/End. Scrolled up, new output does not move the view and a
+// "Jump to bottom" bar counts what arrived. Each draw writes only the rows that changed since the last one.
+//
+// Pinned to the bottom. As in Claude Code the input box sits on the last rows of the window, also when the
+// output so far does not fill it: blank rows at the top of the live region fill the space between the last
+// output and the box. New output takes their place first and only then scrolls. This needs to know where on the
+// screen the live region starts: at start-up the terminal is asked (queryCursorRow), after a repaint or a clear
+// it is known. `pinned` is how many rows the live region reaches down to the bottom of the screen (null: not
+// known, and nothing is pinned until it is). Closing removes the blank rows, so that the shell (or the process
+// of a restart) goes on right below the output.
 
-import { ESC, wrapLine, termWidth, truncate } from './ansi.js';
+import { PassThrough } from 'node:stream';
+import { ESC, wrapLine, termWidth, truncate, stringWidth } from './ansi.js';
 
 const SYNC_START = '\x1b[?2026h';
 const SYNC_END = '\x1b[?2026l';
@@ -23,6 +38,65 @@ const RESIZE_QUIET_MS = 80; // repaint once the size has not changed for this lo
 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;
+const FULL_KEEP = 20_000; // fullscreen: lines of the conversation kept to scroll back through
+const ALT_ON = '\x1b[?1049h\x1b[?1000h\x1b[?1006h'; // the alternate screen, and mouse buttons and wheel reported (SGR)
+const ALT_OFF = '\x1b[?1000l\x1b[?1006l\x1b[?1049l';
+const MOUSE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+
+// The keys of `stdin` without the mouse reports in it (SGR: ESC [ < b ; x ; y M/m), which go to
+// `onMouse({button, x, y, release})` instead: a stream to read keys from. A report split between two chunks is
+// put together; the rest passes through as it came.
+export function mouseFilter(stdin, onMouse) {
+  const out = new PassThrough();
+  let pending = '';
+  let timer = null;
+  const pass = (text) => { if (text) out.write(text); };
+  stdin.on('data', (d) => {
+    clearTimeout(timer);
+    let text = pending + (typeof d === 'string' ? d : d.toString('utf8'));
+    pending = '';
+    text = text.replace(MOUSE, (_, b, x, y, kind) => {
+      try { onMouse({ button: Number(b), x: Number(x), y: Number(y), release: kind === 'm' }); } catch { /* the listener's problem */ }
+      return '';
+    });
+    const partial = /\x1b\[<[\d;]*$/.exec(text);
+    if (partial) {
+      pending = partial[0];
+      text = text.slice(0, partial.index);
+      timer = setTimeout(() => { const p = pending; pending = ''; pass(p); }, 50); // not a report after all
+    }
+    pass(text);
+  });
+  return out;
+}
+const CPR = /\x1b\[(\d+);(\d+)R/; // the terminal's answer to DSR 6: row;column
+
+// Ask the terminal where the cursor is (DSR 6): resolves with its row (1-based), or null when it does not answer
+// within `timeout`. Run before anything else reads `stdin`, with the terminal in raw mode; what else arrives
+// meanwhile (keys typed during start-up) is put back for the key reader.
+export function queryCursorRow(stdin, out, timeout = 300) {
+  return new Promise((resolve) => {
+    let buf = Buffer.alloc(0);
+    let timer = null;
+    const done = (row) => {
+      clearTimeout(timer);
+      stdin.off('data', onData);
+      stdin.pause();
+      const m = CPR.exec(buf.toString('latin1')); // latin1: one character a byte, so the index is a byte index
+      const rest = m ? Buffer.concat([buf.subarray(0, m.index), buf.subarray(m.index + m[0].length)]) : buf;
+      if (rest.length) stdin.unshift(rest);
+      resolve(row);
+    };
+    const onData = (d) => {
+      buf = Buffer.concat([buf, Buffer.isBuffer(d) ? d : Buffer.from(String(d), 'utf8')]);
+      const m = CPR.exec(buf.toString('latin1'));
+      if (m) done(Number(m[1]));
+    };
+    timer = setTimeout(() => done(null), timeout);
+    stdin.on('data', onData);
+    try { out.write('\x1b[6n'); } catch { done(null); }
+  });
+}
 
 // How many rows a static line takes when the terminal wraps it at `cols`.
 function rowsOf(line, cols) {
@@ -42,8 +116,18 @@ export function cleanTitle(text) {
 }
 
 export class Screen {
-  constructor(out = process.stdout) {
+  // pin: keep the live region on the last rows of the screen (see the top of this file).
+  constructor(out = process.stdout, { pin = true } = {}) {
     this.out = out;
+    this.pin = pin;
+    this.pinned = null; // rows from the top of the live region to the bottom of the screen; null: not known
+    this.full = false; // fullscreen: see the top of this file
+    this.scroll = 0; // fullscreen: rows the view is scrolled up from the end of the conversation (0: following it)
+    this.unseen = 0; // fullscreen: rows that arrived while scrolled up
+    this.frame = []; // fullscreen: the rows on screen, as last written
+    this.wrapped = []; // fullscreen: history[i] wrapped to wrapCols - 1, made when first needed
+    this.wrapCols = 0;
+    this.lastArea = 0; // fullscreen: rows the conversation had on screen at the last draw
     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
@@ -52,6 +136,7 @@ export class Screen {
     this.resizeTimer = null;
     this.resizeSince = 0;
     this.closed = false;
+    this.onLog = null;
     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
@@ -86,8 +171,122 @@ export class Screen {
 
   setLive(fn) { this.renderLive = fn; this.schedule(); }
 
-  // Append lines (strings, may contain \n) to the static log.
+  // ------------------------------------------------------------ fullscreen
+
+  // Go to (true) or leave the alternate screen. Leaving puts the newest output back on the normal screen, so that
+  // the classic renderer goes on below it.
+  setFull(on) {
+    if (on === this.full || this.closed) return;
+    if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
+    this.takeStatic();
+    if (on) {
+      this.out.write('\r' + ESC.up(this.cursorRow) + ESC.clearDown); // the live region off the normal screen
+      this.cursorRow = 0;
+      this.full = true;
+      this.scroll = 0;
+      this.unseen = 0;
+      this.frame = [];
+      this.out.write(ALT_ON + '\x1b[2J');
+      this.draw();
+      return;
+    }
+    this.full = false;
+    this.frame = [];
+    this.out.write(ALT_OFF + ESC.showCursor);
+    const tail = this.history.slice(-Math.max(1, this.height - 1));
+    if (tail.length) this.out.write(tail.map((l) => l + '\x1b[0m').join('\r\n') + '\r\n');
+    this.cursorRow = 0;
+    this.pinned = null;
+    this.flush();
+  }
+
+  wrappedAt(i, cols) {
+    if (this.wrapCols !== cols) { this.wrapped = []; this.wrapCols = cols; }
+    return (this.wrapped[i] ??= wrapLine(this.history[i], Math.max(1, cols - 1)));
+  }
+
+  // Rows of the whole conversation at this width (for the scrolling to stop at its top).
+  totalRows(cols) {
+    let n = 0;
+    for (let i = 0; i < this.history.length; i++) n += this.wrappedAt(i, cols).length;
+    return n;
+  }
+
+  // `rows` rows of the conversation, ending `this.scroll` rows above its end; padded below when it is shorter.
+  view(rows, cols) {
+    const need = rows + this.scroll;
+    const got = [];
+    for (let i = this.history.length - 1; i >= 0 && got.length < need; i--) got.unshift(...this.wrappedAt(i, cols));
+    const end = Math.max(0, got.length - this.scroll);
+    const shown = got.slice(Math.max(0, end - rows), end);
+    while (shown.length < rows) shown.push('');
+    return shown;
+  }
+
+  // Scroll the conversation up (`rows` > 0) or down. 'top' and 'bottom' go to its ends.
+  scrollBy(rows) {
+    if (!this.full) return;
+    this.takeStatic();
+    const cols = this.width;
+    const max = Math.max(0, this.totalRows(cols) - this.lastArea);
+    const to = rows === 'top' ? max : rows === 'bottom' ? 0 : Math.max(0, Math.min(max, this.scroll + rows));
+    if (to === this.scroll) return;
+    this.scroll = to;
+    if (!to) this.unseen = 0;
+    this.draw();
+  }
+
+  get scrolledUp() { return this.full && this.scroll > 0; }
+
+  // The bar over the last row of the conversation while it is scrolled up.
+  jumpBar(cols) {
+    const label = ` Jump to bottom (ctrl+End) ↓${this.unseen ? ` · ${this.unseen} new line${this.unseen === 1 ? '' : 's'}` : ''} `;
+    const pad = Math.max(0, Math.floor((cols - 1 - stringWidth(label)) / 2));
+    return ' '.repeat(pad) + '\x1b[7m' + label + '\x1b[27m';
+  }
+
+  // Draw the screen: the conversation above, the live region on the last rows, the cursor in the input box.
+  draw({ full = false } = {}) {
+    if (this.closed || !this.full) return;
+    if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
+    const cols = this.width;
+    const screenRows = Math.max(1, this.out.rows || this.height);
+    const layout = this.layoutLive(cols);
+    const area = Math.max(0, screenRows - layout.rows.length);
+    this.lastArea = area;
+    const top = this.view(area, cols);
+    if (this.scroll > 0 && area > 0) top[area - 1] = this.jumpBar(cols);
+    const frame = [...top, ...layout.rows];
+    let buf = SYNC_START + ESC.hideCursor + this.titleUpdate();
+    if (full) { buf += '\x1b[2J'; this.frame = []; }
+    frame.forEach((row, i) => {
+      if (this.frame[i] !== row) buf += `\x1b[${i + 1};1H` + row + '\x1b[0m\x1b[K';
+    });
+    if (frame.length < this.frame.length) buf += `\x1b[${frame.length + 1};1H` + ESC.clearDown;
+    this.frame = frame;
+    if (layout.cursorRow !== null) buf += `\x1b[${area + layout.cursorRow + 1};${layout.cursorCol + 1}H` + ESC.showCursor;
+    buf += SYNC_END;
+    this.out.write(buf);
+  }
+
+  // The live region starts on screen row `row` (1-based, as the terminal reports it): from now on it fills the
+  // screen down to its last row.
+  pinFrom(row) {
+    if (!this.pin || !Number.isFinite(row) || row < 1) return;
+    this.pinned = Math.max(0, this.height - row + 1);
+  }
+
+  // Blank rows before the live region's own rows so that it reaches the bottom of the screen, `above` rows of
+  // output being written first.
+  gapFor(above, liveRows) {
+    if (!this.pin || this.pinned === null) return 0;
+    return Math.max(0, Math.min(this.pinned, this.height) - above - liveRows);
+  }
+
+  // Append lines (strings, may contain \n) to the static log. `onLog(items)` is told about each call (the remote
+  // control mirrors what the terminal prints).
   log(...items) {
+    if (this.onLog) { try { this.onLog(items); } catch { /* the listener's problem */ } }
     for (const item of items) {
       if (Array.isArray(item)) this.staticQueue.push(...item);
       else this.staticQueue.push(String(item));
@@ -105,8 +304,21 @@ export class Screen {
     if (!this.staticQueue.length) return [];
     const lines = this.staticQueue.join('\n').split(/\r?\n/);
     this.staticQueue = [];
+    const first = this.history.length;
     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);
+    if (this.full && this.scroll > 0) {
+      // keep showing what is shown: the view moves up with the conversation
+      let rows = 0;
+      for (let i = first; i < this.history.length; i++) rows += this.wrappedAt(i, this.width).length;
+      this.scroll += rows;
+      this.unseen += rows;
+    }
+    const keep = this.full ? FULL_KEEP : HISTORY_KEEP;
+    if (this.history.length > keep * (this.full ? 1.25 : 2)) {
+      const drop = this.history.length - keep;
+      this.history.splice(0, drop);
+      this.wrapped.splice(0, drop);
+    }
     return lines;
   }
 
@@ -178,6 +390,14 @@ export class Screen {
   // What was on screen above our output (a short session: the shell that started us) is overwritten.
   repaint() {
     if (this.closed) return;
+    if (this.full) {
+      clearTimeout(this.resizeTimer);
+      this.resizeTimer = null;
+      this.resizeSince = 0;
+      this.takeStatic();
+      this.draw({ full: true });
+      return;
+    }
     if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
     clearTimeout(this.resizeTimer);
     this.resizeTimer = null;
@@ -196,6 +416,13 @@ export class Screen {
     }
     // 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.
+    if (this.pin) {
+      const used = tail.reduce((n, line) => n + rowsOf(line, cols), 0);
+      this.pinned = screenRows;
+      const gap = this.gapFor(used, layout.rows.length);
+      layout.rows.unshift(...Array(gap).fill(''));
+      if (layout.cursorRow !== null) layout.cursorRow += gap;
+    }
     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');
@@ -203,11 +430,13 @@ export class Screen {
     buf += this.settleCursor(layout);
     buf += SYNC_END;
     this.out.write(buf);
+    if (this.pinned !== null) this.pinned = layout.rows.length;
   }
 
   flush() {
     if (this.closed) return;
     if (this.resizing) return; // the repaint after the resize writes everything that is waiting
+    if (this.full) { this.takeStatic(); this.draw(); return; }
     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;
@@ -217,10 +446,17 @@ export class Screen {
       buf += lines.map((l) => l + '\x1b[0m').join('\r\n') + '\r\n';
     }
     const layout = this.layoutLive(cols);
+    const gap = this.gapFor(lines.reduce((n, line) => n + rowsOf(line, cols), 0), layout.rows.length);
+    if (gap) {
+      layout.rows.unshift(...Array(gap).fill(''));
+      if (layout.cursorRow !== null) layout.cursorRow += gap;
+    }
     buf += layout.rows.map((r) => r + '\x1b[0m').join('\r\n');
     buf += this.settleCursor(layout);
     buf += SYNC_END;
     this.out.write(buf);
+    // the region now ends on the last row of the screen (it did before, or the output scrolled it there)
+    if (this.pinned !== null) this.pinned = layout.rows.length;
   }
 
   // Erase the live region (used before exiting or handing the terminal to a child).
@@ -229,12 +465,23 @@ export class Screen {
     if (this.scheduled) { clearTimeout(this.scheduled); this.scheduled = null; }
     this.out.write('\r' + ESC.up(this.cursorRow) + ESC.clearDown + ESC.showCursor);
     this.cursorRow = 0;
+    this.pinned = null; // whatever is written now (a child process) moves the cursor where we cannot see
   }
 
   clearScreen() {
+    if (this.full) {
+      this.history = [];
+      this.wrapped = [];
+      this.scroll = 0;
+      this.unseen = 0;
+      this.staticQueue = [];
+      this.draw({ full: true });
+      return;
+    }
     this.out.write(ESC.clearScreen);
     this.cursorRow = 0;
     this.history = [];
+    if (this.pin) this.pinned = this.height; // from the top row
     this.flush();
   }
 
@@ -244,7 +491,14 @@ export class Screen {
     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.pinned = null; // no blank rows left behind: the shell, or the next process, goes on right below the output
+    if (this.full) {
+      this.takeStatic();
+      this.full = false;
+      this.out.write(ALT_OFF); // the shell's screen comes back as it was
+    } else {
+      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

package/src/utils/downloads.js

@@ -0,0 +1,83 @@
+// Files that other sessions send this one (/sendfile, MessagePeer's files) land in the user's Downloads folder:
+// on Windows the folder the shell knows as Downloads (it can have been moved), else ~/Downloads (or what
+// xdg-user-dir says). CLAUDE_PRO_DOWNLOAD_DIR replaces it.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+export const MAX_SEND_BYTES = 5 * 1024 ** 3; // a file; the gateway takes no more
+export const MAX_SEND_FILES = 20; // a message
+
+const DOWNLOADS_GUID = '{374DE290-123F-4565-9164-39C4925E467B}';
+const PS_DOWNLOADS = `
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+$p = (Get-ItemProperty -Path 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders' -Name '${DOWNLOADS_GUID}' -ErrorAction Stop).'${DOWNLOADS_GUID}'
+[Console]::Out.Write($p)
+`;
+
+function output(cmd, args) {
+  return new Promise((resolve) => {
+    let out = '';
+    let child;
+    try {
+      child = spawn(cmd, args, { windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch {
+      resolve('');
+      return;
+    }
+    const timer = setTimeout(() => child.kill(), 10_000);
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (d) => { out += d; });
+    child.on('error', () => { clearTimeout(timer); resolve(''); });
+    child.on('close', (code) => { clearTimeout(timer); resolve(code === 0 ? out.trim() : ''); });
+  });
+}
+
+let cached = null;
+
+export function downloadsDir(env = process.env) {
+  if (env.CLAUDE_PRO_DOWNLOAD_DIR) return Promise.resolve(path.resolve(env.CLAUDE_PRO_DOWNLOAD_DIR));
+  cached ??= (async () => {
+    const home = os.homedir();
+    let dir = '';
+    if (process.platform === 'win32') {
+      dir = await output('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', Buffer.from(PS_DOWNLOADS, 'utf16le').toString('base64')]);
+    } else if (process.platform !== 'darwin') {
+      dir = await output('xdg-user-dir', ['DOWNLOAD']);
+      if (path.resolve(dir || home) === path.resolve(home)) dir = ''; // xdg's answer when it has none
+    }
+    return dir && path.isAbsolute(dir) ? dir : path.join(home, 'Downloads');
+  })();
+  return cached;
+}
+
+const RESERVED = /^(con|prn|aux|nul|com\d|lpt\d)$/i;
+
+// A name a file can be saved under, on any system, from the name another computer gave it.
+export function safeFileName(name) {
+  let base = String(name || '').split(/[\\/]/).pop();
+  base = base.replace(/[\u0000-\u001f\u007f<>:"|?*]/g, '_').replace(/[. ]+$/g, '').trim();
+  if (!base || base === '.' || base === '..') base = 'file';
+  const ext = path.extname(base);
+  if (RESERVED.test(base.slice(0, base.length - ext.length))) base = `_${base}`;
+  if (base.length > 200) base = base.slice(0, 200 - ext.length) + ext;
+  return base;
+}
+
+// The files to send, checked: [{path, name, size}], or throws with what is wrong with which.
+export function filesToSend(paths) {
+  if (!paths.length) throw new Error('No file to send.');
+  if (paths.length > MAX_SEND_FILES) throw new Error(`At most ${MAX_SEND_FILES} files at a time (${paths.length} given).`);
+  return paths.map((p) => {
+    let st;
+    try { st = fs.statSync(p); } catch { throw new Error(`File not found: ${p}`); }
+    if (st.isDirectory()) throw new Error(`${p} is a folder: send the files in it (or zip it first).`);
+    if (!st.isFile()) throw new Error(`Not a file: ${p}`);
+    if (st.size > MAX_SEND_BYTES) throw new Error(`${path.basename(p)} is ${formatBytes(st.size)}: at most ${formatBytes(MAX_SEND_BYTES)} a file.`);
+    return { path: p, name: path.basename(p), size: st.size };
+  });
+}
+
+export const formatBytes = (n) => (n >= 1024 ** 3 ? `${(n / 1024 ** 3).toFixed(1)} GB` : n >= 1048576 ? `${(n / 1048576).toFixed(1)} MB` : n >= 1024 ? `${Math.round(n / 1024)} KB` : `${n} B`);

package/src/utils/images.js

@@ -0,0 +1,175 @@
+// Images for the model. The API refuses an image wider or taller than 8000 px, and in a request that carries many
+// images (a long session that looked at screenshots) one beyond 2000 px. It scales anything whose long edge is over
+// 1568 px down to that anyway, so images are scaled here to fit 1568 px before they go into the conversation:
+// the model loses nothing it would have seen, and the conversation never carries an image that a later request
+// is refused for. There is no image library: Windows scales with System.Drawing (PowerShell), macOS with sips,
+// elsewhere ImageMagick when it is installed.
+
+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_EDGE = 1568;
+const API_MAX_EDGE = 2000; // what a request with many images accepts: sent as it is when it cannot be scaled
+export const MAX_IMAGE_BYTES = 3_750_000; // ~5MB once base64 encoded
+
+// {width, height} from the header of a PNG, JPEG, GIF or WebP; null for anything else.
+export function imageSize(buf) {
+  if (!buf || buf.length < 10) return null;
+  if (buf.length >= 24 && buf.readUInt32BE(0) === 0x89504e47) return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+  if (buf.toString('latin1', 0, 3) === 'GIF') return { width: buf.readUInt16LE(6), height: buf.readUInt16LE(8) };
+  if (buf.length >= 30 && buf.toString('latin1', 0, 4) === 'RIFF' && buf.toString('latin1', 8, 12) === 'WEBP') {
+    const kind = buf.toString('latin1', 12, 16);
+    if (kind === 'VP8 ') return { width: buf.readUInt16LE(26) & 0x3fff, height: buf.readUInt16LE(28) & 0x3fff };
+    if (kind === 'VP8L') { const b = buf.readUInt32LE(21); return { width: (b & 0x3fff) + 1, height: ((b >>> 14) & 0x3fff) + 1 }; }
+    if (kind === 'VP8X') return { width: 1 + buf.readUIntLE(24, 3), height: 1 + buf.readUIntLE(27, 3) };
+    return null;
+  }
+  if (buf[0] === 0xff && buf[1] === 0xd8) {
+    let i = 2;
+    while (i + 9 < buf.length) {
+      if (buf[i] !== 0xff) { i++; continue; }
+      const marker = buf[i + 1];
+      if (marker === 0xff) { i++; continue; }
+      if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd8)) { i += 2; continue; }
+      if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+        return { width: buf.readUInt16BE(i + 7), height: buf.readUInt16BE(i + 5) };
+      }
+      i += 2 + buf.readUInt16BE(i + 2);
+    }
+  }
+  return null;
+}
+
+function run(cmd, args, { env, timeout = 30_000 } = {}) {
+  return new Promise((resolve) => {
+    let out = '';
+    let child;
+    try {
+      child = spawn(cmd, args, { env: { ...process.env, ...env }, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch {
+      resolve({ code: -1, out: '' });
+      return;
+    }
+    const timer = setTimeout(() => child.kill(), timeout);
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', () => {});
+    child.on('error', () => { clearTimeout(timer); resolve({ code: -1, out }); });
+    child.on('close', (code) => { clearTimeout(timer); resolve({ code, out: out.trim() }); });
+  });
+}
+
+const PS_SCALE = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Drawing
+$img = [System.Drawing.Image]::FromFile($env:CLAUDE_PRO_IMG_IN)
+$max = [int]$env:CLAUDE_PRO_IMG_MAX
+$scale = [Math]::Min(1.0, $max / [Math]::Max($img.Width, $img.Height))
+$w = [Math]::Max(1, [int][Math]::Round($img.Width * $scale)); $h = [Math]::Max(1, [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()
+$out = $env:CLAUDE_PRO_IMG_OUT
+$format = 'png'
+if ($env:CLAUDE_PRO_IMG_JPEG -ne '1') { $bmp.Save($out, [System.Drawing.Imaging.ImageFormat]::Png) }
+if ($env:CLAUDE_PRO_IMG_JPEG -eq '1' -or (Get-Item $out).Length -gt [int]$env:CLAUDE_PRO_IMG_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
+  $bmp.Save($out, $codec, $params)
+  $format = 'jpeg'
+}
+$bmp.Dispose()
+Write-Output "IMG $format"
+`;
+
+// The image file `input` scaled to fit `max` px into a new file: {buffer, media_type}, or null when nothing here
+// can scale images.
+async function scaleFile(input, { max, jpeg }) {
+  const out = path.join(os.tmpdir(), `claude-pro-img-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  try {
+    if (process.platform === 'win32') {
+      const r = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', Buffer.from(PS_SCALE, 'utf16le').toString('base64')], {
+        env: { CLAUDE_PRO_IMG_IN: input, CLAUDE_PRO_IMG_OUT: out, CLAUDE_PRO_IMG_MAX: String(max), CLAUDE_PRO_IMG_JPEG: jpeg ? '1' : '', CLAUDE_PRO_IMG_BYTES: String(MAX_IMAGE_BYTES) },
+      });
+      const m = /IMG (png|jpeg)/.exec(r.out);
+      if (r.code !== 0 || !m) return null;
+      return { buffer: fs.readFileSync(out), media_type: `image/${m[1]}` };
+    }
+    const target = `${out}.${jpeg ? 'jpg' : 'png'}`;
+    const tries = process.platform === 'darwin'
+      ? [['sips', ['-Z', String(max), '-s', 'format', jpeg ? 'jpeg' : 'png', input, '--out', target]]]
+      : [['magick', [input, '-resize', `${max}x${max}>`, target]], ['convert', [input, '-resize', `${max}x${max}>`, target]]];
+    for (const [cmd, args] of tries) {
+      const r = await run(cmd, args);
+      if (r.code === 0 && fs.existsSync(target)) {
+        try { return { buffer: fs.readFileSync(target), media_type: jpeg ? 'image/jpeg' : 'image/png' }; } finally { fs.rm(target, { force: true }, () => {}); }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    fs.rm(out, { force: true }, () => {});
+  }
+}
+
+// The image as the model should get it. `data` is base64. Returns {data, media_type, width, height, from} where
+// `from` is the size it had when it was scaled (null when it is sent as it is), or {error} when it is too large
+// and cannot be scaled here.
+export async function fitImage({ data, media_type }) {
+  const buf = Buffer.from(data, 'base64');
+  const size = imageSize(buf);
+  const keep = { data, media_type, width: size?.width ?? null, height: size?.height ?? null, from: null };
+  if (!size) return keep; // not a format it knows: the API will say what it thinks of it
+  const edge = Math.max(size.width, size.height);
+  if (edge <= MAX_IMAGE_EDGE && buf.length <= MAX_IMAGE_BYTES) return keep;
+  const ext = { 'image/png': '.png', 'image/jpeg': '.jpg', 'image/gif': '.gif', 'image/webp': '.webp' }[media_type] || '.img';
+  const input = path.join(os.tmpdir(), `claude-pro-img-in-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`);
+  let scaled = null;
+  try {
+    fs.writeFileSync(input, buf);
+    scaled = await scaleFile(input, { max: Math.min(edge, MAX_IMAGE_EDGE), jpeg: media_type === 'image/jpeg' });
+  } catch { /* scaled stays null */ } finally {
+    fs.rm(input, { force: true }, () => {});
+  }
+  const got = scaled && imageSize(scaled.buffer);
+  if (got && Math.max(got.width, got.height) <= API_MAX_EDGE && scaled.buffer.length <= MAX_IMAGE_BYTES) {
+    return { data: scaled.buffer.toString('base64'), media_type: scaled.media_type, width: got.width, height: got.height, from: size };
+  }
+  if (edge <= API_MAX_EDGE && buf.length <= MAX_IMAGE_BYTES) return keep;
+  return { error: `the image is ${size.width}×${size.height} px${buf.length > MAX_IMAGE_BYTES ? ` and ${(buf.length / 1e6).toFixed(1)}MB` : ''}, more than the API accepts (${API_MAX_EDGE} px a side when a conversation has many images), and it could not be scaled down here` };
+}
+
+// Every base64 image block in `blocks` (content blocks, tool_result blocks with content inside, or messages)
+// fitted in place, so that the conversation that holds them changes too. Returns how many were changed; an
+// image that cannot be fitted becomes a text block that says so.
+export async function fitImagesIn(blocks) {
+  let changed = 0;
+  const visit = async (list) => {
+    if (!Array.isArray(list)) return;
+    for (const b of list) {
+      if (!b || typeof b !== 'object') continue;
+      if (b.role && Array.isArray(b.content)) { await visit(b.content); continue; }
+      if (b.type === 'tool_result' && Array.isArray(b.content)) { await visit(b.content); continue; }
+      if (b.type !== 'image' || b.source?.type !== 'base64' || typeof b.source.data !== 'string') continue;
+      const fit = await fitImage(b.source);
+      if (fit.error) {
+        const mark = b.cache_control;
+        for (const k of Object.keys(b)) delete b[k];
+        Object.assign(b, { type: 'text', text: `[image left out: ${fit.error}]` }, mark ? { cache_control: mark } : {});
+        changed++;
+      } else if (fit.from) {
+        b.source = { type: 'base64', media_type: fit.media_type, data: fit.data };
+        changed++;
+      }
+    }
+  };
+  await visit(blocks);
+  return changed;
+}