@yanzc/claude-pro 0.4.5 → 0.5.0

package/src/ui/screen.js

@@ -52,6 +52,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 +87,10 @@ export class Screen {
 
   setLive(fn) { this.renderLive = fn; this.schedule(); }
 
-  // Append lines (strings, may contain \n) to the static log.
+  // 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));

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;
+}