pi-paster 0.1.5 → 0.2.0

package/src/clipboard.ts

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { detectImageMimeType, dimensionsForImage } from "./image-utils.ts";
@@ -14,8 +14,78 @@ export type ClipboardImageResult =
     };
 
 export function readClipboardImage(maxBytes = MAX_IMAGE_BYTES): ClipboardImageResult {
-  if (process.platform !== "darwin") return { ok: false, reason: "unsupported-platform" };
-  return readMacOSClipboardImage(maxBytes);
+  if (process.platform === "darwin") return readMacOSClipboardImage(maxBytes);
+  if (process.platform === "win32") return readWindowsClipboardImage(maxBytes);
+  if (process.platform === "linux" && isWSL()) return readWindowsClipboardImage(maxBytes);
+  return { ok: false, reason: "unsupported-platform" };
+}
+
+function isWSL(): boolean {
+  try {
+    return /microsoft|wsl/i.test(readFileSync("/proc/version", "utf8"));
+  } catch {
+    return false;
+  }
+}
+
+function resolvePowerShell(): string | null {
+  if (process.platform === "win32") return "powershell.exe";
+  const candidates = [
+    "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe",
+    "/mnt/c/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe",
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return "powershell.exe";
+}
+
+function readWindowsClipboardImage(maxBytes: number): ClipboardImageResult {
+  const exe = resolvePowerShell();
+  if (!exe) return { ok: false, reason: "unsupported-platform" };
+
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    "Add-Type -AssemblyName System.Windows.Forms | Out-Null",
+    "Add-Type -AssemblyName System.Drawing | Out-Null",
+    "$img = [System.Windows.Forms.Clipboard]::GetImage()",
+    "if ($img -eq $null) { exit 2 }",
+    "$ms = New-Object System.IO.MemoryStream",
+    "$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)",
+    "[Console]::Out.Write([Convert]::ToBase64String($ms.ToArray()))",
+  ].join("; ");
+
+  try {
+    const result = spawnSync(exe, ["-NoProfile", "-NonInteractive", "-STA", "-Command", script], {
+      timeout: 5000,
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    if (result.status === 2) return { ok: false, reason: "empty" };
+    if (result.status !== 0) return { ok: false, reason: "read-error" };
+
+    const data = (result.stdout || "").trim();
+    if (!data) return { ok: false, reason: "empty" };
+
+    const bytes = Buffer.from(data, "base64");
+    if (bytes.length === 0) return { ok: false, reason: "empty" };
+    if (bytes.length > maxBytes) return { ok: false, reason: "too-large" };
+
+    const mimeType = detectImageMimeType(bytes);
+    if (!mimeType) return { ok: false, reason: "unsupported" };
+
+    return {
+      ok: true,
+      image: {
+        originalPath: "clipboard.png",
+        mimeType,
+        data,
+        dimensions: dimensionsForImage(data, mimeType),
+      },
+    };
+  } catch {
+    return { ok: false, reason: "read-error" };
+  }
 }
 
 function readMacOSClipboardImage(maxBytes: number): ClipboardImageResult {

package/src/editor.ts

@@ -1,6 +1,6 @@
 import { CustomEditor, type KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
-import { replaceImagePathsInText } from "./image-utils.ts";
+import { describeReject, replaceImagePathsInText } from "./image-utils.ts";
 import type { AttachmentStore } from "./store.ts";
 import type { ImageAttachment } from "./types.ts";
 
@@ -189,13 +189,7 @@ export class PasterEditor extends CustomEditor {
     return replaceImagePathsInText(text, {
       cwd: this.pasterOptions.cwd,
       store: this.pasterOptions.store,
-      onReject: (result) => {
-        if (result.reason === "too-large") {
-          this.pasterOptions.notify(
-            `paster: image is over 10 MB and was not attached: ${result.path}`,
-          );
-        }
-      },
+      onReject: (result) => describeReject(result, this.pasterOptions.notify),
     });
   }
 

package/src/image-utils.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
+import { platform } from "node:process";
 import { getImageDimensions } from "@earendil-works/pi-tui";
 import type { AttachmentStore } from "./store.ts";
 import {
@@ -10,14 +11,18 @@ import {
   type PasterImageContent,
   type SupportedImageMimeType,
 } from "./types.ts";
+import { optimizeImageBytes } from "./optimize-image.ts";
 
 interface PathToken {
   raw: string;
   value: string;
   start: number;
   end: number;
+  bare: boolean;
 }
 
+const MAX_BARE_PATH_EXTENSIONS = 8;
+
 export function detectImageMimeType(bytes: Uint8Array): SupportedImageMimeType | undefined {
   if (
     bytes.length >= 8 &&
@@ -62,9 +67,62 @@ export function detectImageMimeType(bytes: Uint8Array): SupportedImageMimeType |
   return undefined;
 }
 
+const WINDOWS_DRIVE_PATH = /^([a-zA-Z]):[\\/](.*)$/;
+
+export function isWindowsDrivePath(value: string): boolean {
+  return WINDOWS_DRIVE_PATH.test(value);
+}
+
+export function isWindowsUncPath(value: string): boolean {
+  return value.startsWith("\\\\") && value.length > 2;
+}
+
+export function isWindowsLikePath(value: string): boolean {
+  return isWindowsDrivePath(value) || isWindowsUncPath(value);
+}
+
+let cachedIsWsl: boolean | undefined;
+export function isWsl(): boolean {
+  if (cachedIsWsl !== undefined) return cachedIsWsl;
+  if (platform !== "linux") {
+    cachedIsWsl = false;
+    return cachedIsWsl;
+  }
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
+    cachedIsWsl = true;
+    return cachedIsWsl;
+  }
+  try {
+    const release = readFileSync("/proc/version", "utf8");
+    cachedIsWsl = /microsoft|wsl/i.test(release);
+  } catch {
+    cachedIsWsl = false;
+  }
+  return cachedIsWsl;
+}
+
+export function windowsToWslPath(windowsPath: string): string {
+  const driveMatch = WINDOWS_DRIVE_PATH.exec(windowsPath);
+  if (driveMatch) {
+    const drive = driveMatch[1]!.toLowerCase();
+    const rest = driveMatch[2]!.replace(/\\/g, "/");
+    return rest.length > 0 ? `/mnt/${drive}/${rest}` : `/mnt/${drive}`;
+  }
+  if (isWindowsUncPath(windowsPath)) {
+    // \\server\share\path -> //wsl.localhost-style not generally translatable; pass through.
+    return windowsPath.replace(/\\/g, "/");
+  }
+  return windowsPath;
+}
+
 export function resolveImagePath(input: string, cwd: string): string {
   if (input === "~") return homedir();
   if (input.startsWith("~/")) return resolve(homedir(), input.slice(2));
+  if (isWindowsLikePath(input)) {
+    if (platform === "win32") return input;
+    if (isWsl()) return windowsToWslPath(input);
+    return input;
+  }
   if (isAbsolute(input)) return input;
   return resolve(cwd, input);
 }
@@ -88,10 +146,26 @@ function isPathLike(value: string): boolean {
     value.startsWith("~/") ||
     value === "~" ||
     value.startsWith("./") ||
-    value.startsWith("../")
+    value.startsWith("../") ||
+    isWindowsLikePath(value)
   );
 }
 
+function startsWithWindowsPath(text: string, index: number): boolean {
+  if (
+    index + 2 < text.length &&
+    /[a-zA-Z]/.test(text[index]!) &&
+    text[index + 1] === ":" &&
+    (text[index + 2] === "\\" || text[index + 2] === "/")
+  ) {
+    return true;
+  }
+  if (index + 1 < text.length && text[index] === "\\" && text[index + 1] === "\\") {
+    return true;
+  }
+  return false;
+}
+
 export function tokenizePathLikeText(text: string): PathToken[] {
   const tokens: PathToken[] = [];
   let index = 0;
@@ -107,11 +181,12 @@ export function tokenizePathLikeText(text: string): PathToken[] {
     if (char === "'" || char === '"') {
       const quote = char;
       index++;
+      const windowsMode = startsWithWindowsPath(text, index);
       let value = "";
       let closed = false;
       while (index < text.length) {
         const current = text[index]!;
-        if (current === "\\" && quote === '"' && index + 1 < text.length) {
+        if (!windowsMode && current === "\\" && quote === '"' && index + 1 < text.length) {
           value += text[index + 1]!;
           index += 2;
           continue;
@@ -125,15 +200,16 @@ export function tokenizePathLikeText(text: string): PathToken[] {
         index++;
       }
       if (closed && isPathLike(value))
-        tokens.push({ raw: text.slice(start, index), value, start, end: index });
+        tokens.push({ raw: text.slice(start, index), value, start, end: index, bare: false });
       continue;
     }
 
+    const windowsMode = startsWithWindowsPath(text, index);
     let rawValue = "";
     while (index < text.length) {
       const current = text[index]!;
       if (/\s/.test(current)) break;
-      if (current === "\\" && index + 1 < text.length) {
+      if (!windowsMode && current === "\\" && index + 1 < text.length) {
         rawValue += current + text[index + 1]!;
         index += 2;
         continue;
@@ -141,13 +217,57 @@ export function tokenizePathLikeText(text: string): PathToken[] {
       rawValue += current;
       index++;
     }
-    const value = shellUnescape(rawValue);
-    if (isPathLike(value)) tokens.push({ raw: rawValue, value, start, end: index });
+    const value = windowsMode ? rawValue : shellUnescape(rawValue);
+    if (isPathLike(value)) tokens.push({ raw: rawValue, value, start, end: index, bare: true });
   }
 
   return tokens;
 }
 
+function tryExtendBareToken(
+  text: string,
+  token: PathToken,
+  attempt: (path: string) => LoadImageResult,
+): { value: string; end: number; result: LoadImageResult } {
+  let value = token.value;
+  let end = token.end;
+  let lastResult = attempt(value);
+  if (lastResult.ok || lastResult.reason === "too-large" || !token.bare) {
+    return { value, end, result: lastResult };
+  }
+
+  let scan = end;
+  for (let i = 0; i < MAX_BARE_PATH_EXTENSIONS; i++) {
+    let wsEnd = scan;
+    while (wsEnd < text.length) {
+      const ch = text[wsEnd]!;
+      if (ch === "\n" || ch === "\r") break;
+      if (!/\s/.test(ch)) break;
+      wsEnd++;
+    }
+    if (wsEnd === scan) break;
+
+    let wordEnd = wsEnd;
+    while (wordEnd < text.length && !/\s/.test(text[wordEnd]!)) wordEnd++;
+    if (wordEnd === wsEnd) break;
+
+    const nextWord = shellUnescape(text.slice(wsEnd, wordEnd));
+    if (isPathLike(nextWord)) break;
+
+    const extendedValue = value + text.slice(scan, wsEnd) + nextWord;
+    const candidate = attempt(extendedValue);
+    scan = wordEnd;
+    if (candidate.ok || candidate.reason === "too-large") {
+      return { value: extendedValue, end: wordEnd, result: candidate };
+    }
+    value = extendedValue;
+    end = wordEnd;
+    lastResult = candidate;
+  }
+
+  return { value, end, result: lastResult };
+}
+
 export function dimensionsForImage(data: string, mimeType: SupportedImageMimeType) {
   return getImageDimensions(data, mimeType) ?? undefined;
 }
@@ -202,16 +322,18 @@ export function replaceImagePathsInText(
   const loadImage = options.loadImage ?? loadImageFromPath;
 
   for (const token of tokens) {
-    const result = loadImage(token.value, options.cwd);
-    if (!result.ok) {
-      options.onReject?.(result);
+    if (token.start < cursor) continue;
+
+    const extended = tryExtendBareToken(text, token, (path) => loadImage(path, options.cwd));
+    if (!extended.result.ok) {
+      if (extended.result.reason === "too-large") options.onReject?.(extended.result);
       continue;
     }
 
-    const attachment = options.store.add(result.image);
+    const attachment = options.store.add(extended.result.image);
     accepted.push(attachment);
     output += text.slice(cursor, token.start) + attachment.placeholder;
-    cursor = token.end;
+    cursor = extended.end;
     replaced++;
   }
 
@@ -234,3 +356,62 @@ export function imagesForText(
     })),
   ];
 }
+
+/**
+ * Async variant of imagesForText that runs each attachment through the
+ * Anthropic-aware image optimizer (resize to 8000px cap, JPEG ladder to stay
+ * under the 5 MB / 32 MB request caps). Optimization is cached on the
+ * attachment so the cost is paid once per image, not per submit.
+ *
+ * Used by paster's `input` handler; safe to await on the hot path because
+ * sharp is only invoked when the image is actually over the limits.
+ */
+export async function imagesForTextOptimized(
+  store: AttachmentStore,
+  text: string,
+  existing: PasterImageContent[] = [],
+): Promise<PasterImageContent[]> {
+  const attachments = store.matchingPlaceholders(text);
+  const optimized: PasterImageContent[] = [];
+  for (const attachment of attachments) {
+    if (!attachment.optimized) {
+      try {
+        const input = Buffer.from(attachment.data, "base64");
+        const result = await optimizeImageBytes(input, attachment.mimeType);
+        if (result.changed) {
+          attachment.data = result.data;
+          attachment.mimeType = result.mimeType;
+          if (result.finalDim) {
+            attachment.dimensions = {
+              widthPx: result.finalDim.width,
+              heightPx: result.finalDim.height,
+            };
+          }
+        }
+        attachment.optimized = true;
+        attachment.originalBytes = result.originalBytes;
+        attachment.finalBytes = result.finalBytes;
+        attachment.optimizeActions = result.actions;
+      } catch {
+        // optimization is best-effort; fall through with the original bytes
+        attachment.optimized = true;
+      }
+    }
+    optimized.push({
+      type: "image",
+      mimeType: attachment.mimeType,
+      data: attachment.data,
+    });
+  }
+  return [...existing, ...optimized];
+}
+
+export function describeReject(
+  result: Exclude<LoadImageResult, { ok: true }>,
+  notify?: (message: string) => void,
+): void {
+  if (!notify) return;
+  if (result.reason === "too-large") {
+    notify(`paster: image is too large and was not attached: ${result.path}`);
+  }
+}

package/src/index.ts

@@ -2,13 +2,14 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { readClipboardImage } from "./clipboard.ts";
 import { type PasterConfig, resolvePasterConfig } from "./config.ts";
 import { PasterEditor } from "./editor.ts";
-import { imagesForText } from "./image-utils.ts";
+import { imagesForTextOptimized } from "./image-utils.ts";
 import { CursorImagePreviewWidget, ImagePreviewMessage } from "./preview.ts";
 import { AttachmentStore } from "./store.ts";
 import { createImagePasteTerminalInputHandler } from "./terminal-input.ts";
 import type { ImageAttachment, PasterPreviewDetails } from "./types.ts";
 
 export * from "./clipboard.ts";
+export * from "./optimize-image.ts";
 export * from "./config.ts";
 export * from "./editor.ts";
 export * from "./image-utils.ts";
@@ -111,15 +112,16 @@ export default function paster(pi: ExtensionAPI, config: PasterConfig = {}): voi
   });
 
   function previewMessage(attachments: ImageAttachment[]) {
+    const placeholders = attachments.map((attachment) => attachment.placeholder);
     return {
       customType: "paster-preview",
-      content: "",
+      content: `(attachment preview: ${placeholders.join(", ")})`,
       display: true,
-      details: { placeholders: attachments.map((attachment) => attachment.placeholder) },
+      details: { placeholders },
     };
   }
 
-  pi.on("input", (event, ctx) => {
+  pi.on("input", async (event, ctx) => {
     if (event.source === "extension") return { action: "continue" as const };
     if (ctx.hasUI) {
       activeEditor?.clearCursorPreview();
@@ -136,10 +138,15 @@ export default function paster(pi: ExtensionAPI, config: PasterConfig = {}): voi
       pi.sendMessage(previewMessage(attachments), { deliverAs: "followUp" });
     }
 
+    // Optimize images on-submit so we never exceed Anthropic's 5 MB/image or
+    // 32 MB/request caps. Per-attachment caching means each image is only
+    // resized/recompressed once across the whole session.
+    const images = await imagesForTextOptimized(store, event.text, event.images);
+
     return {
       action: "transform" as const,
       text: event.text,
-      images: imagesForText(store, event.text, event.images),
+      images,
     };
   });
 

package/src/optimize-image.ts

@@ -0,0 +1,209 @@
+/**
+ * Image optimizer for pi-paster.
+ *
+ * Anthropic Messages API hard limits:
+ *   - 5 MB per image (base64-decoded)
+ *   - 8000 px on any dimension
+ *   - 32 MB per request total
+ *
+ * Claude internally downsamples every input image so the long edge is
+ *   - 1568 px for most models
+ *   - 2576 px for Opus 4.7
+ * which means: any client-side downscale at or above ~2600 px is lossless
+ * from the model's point of view. We resize (aspect-preserving) instead of
+ * cropping so no visual information is thrown away.
+ *
+ * Strategy applied in order:
+ *   1. If width or height > 8000 px → resize so the long edge is 8000 px.
+ *   2. If decoded bytes > 5 MB → re-encode as JPEG q=95, then 90/85/80/70/60.
+ *   3. If still > 5 MB → progressively shrink the long edge to 6000 → 4000
+ *      → 3000 → 2000 px, re-running JPEG quality ladder each step.
+ *
+ * `sharp` is loaded lazily so the extension can still ship if the native
+ * binding is unavailable (we just skip optimization with a log line).
+ */
+import type { SupportedImageMimeType } from "./types.ts";
+import { ANTHROPIC_MAX_DIMENSION, ANTHROPIC_MAX_IMAGE_BYTES } from "./types.ts";
+
+type Sharp = (input?: Buffer) => SharpInstance;
+interface SharpInstance {
+  metadata(): Promise<{ width?: number; height?: number; format?: string }>;
+  resize(opts: {
+    width?: number;
+    height?: number;
+    fit?: string;
+    withoutEnlargement?: boolean;
+  }): SharpInstance;
+  jpeg(opts: { quality: number; mozjpeg?: boolean }): SharpInstance;
+  png(opts?: { quality?: number; compressionLevel?: number }): SharpInstance;
+  toBuffer(): Promise<Buffer>;
+}
+
+let _sharp: Sharp | null | undefined;
+async function getSharp(): Promise<Sharp | null> {
+  if (_sharp !== undefined) return _sharp;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mod: any = await import("sharp");
+    const fn = (typeof mod === "function" ? mod : mod?.default) as Sharp | undefined;
+    _sharp = typeof fn === "function" ? fn : null;
+  } catch {
+    _sharp = null;
+  }
+  return _sharp;
+}
+
+export interface OptimizeResult {
+  data: string; // base64
+  mimeType: SupportedImageMimeType;
+  originalBytes: number;
+  finalBytes: number;
+  originalDim?: { width: number; height: number };
+  finalDim?: { width: number; height: number };
+  actions: string[];
+  changed: boolean;
+}
+
+const SHRINK_LADDER = [6000, 4000, 3000, 2000];
+const JPEG_QUALITY_LADDER = [95, 90, 85, 80, 70, 60];
+
+export async function optimizeImageBytes(
+  input: Buffer,
+  mime: SupportedImageMimeType,
+): Promise<OptimizeResult> {
+  const originalBytes = input.length;
+  const noop = (): OptimizeResult => ({
+    data: input.toString("base64"),
+    mimeType: mime,
+    originalBytes,
+    finalBytes: originalBytes,
+    actions: [],
+    changed: false,
+  });
+
+  // Fast path: already under both limits.
+  if (originalBytes <= ANTHROPIC_MAX_IMAGE_BYTES) {
+    // Still need dimension check, but cheap to skip sharp if image is small.
+    if (originalBytes <= 256 * 1024) return noop();
+  }
+
+  const sharp = await getSharp();
+  if (!sharp) return noop(); // sharp missing — fall back silently.
+
+  const meta = await sharp(input).metadata();
+  const origW = meta.width ?? 0;
+  const origH = meta.height ?? 0;
+  if (!origW || !origH) return noop();
+
+  const actions: string[] = [];
+  const originalDim = { width: origW, height: origH };
+
+  // Step 1: respect 8000 px dimension cap (resize, do not crop).
+  let workBuf = input;
+  let workW = origW;
+  let workH = origH;
+  if (workW > ANTHROPIC_MAX_DIMENSION || workH > ANTHROPIC_MAX_DIMENSION) {
+    workBuf = await sharp(workBuf)
+      .resize({
+        width: workW >= workH ? ANTHROPIC_MAX_DIMENSION : undefined,
+        height: workH > workW ? ANTHROPIC_MAX_DIMENSION : undefined,
+        fit: "inside",
+        withoutEnlargement: true,
+      })
+      .toBuffer();
+    const m = await sharp(workBuf).metadata();
+    workW = m.width ?? workW;
+    workH = m.height ?? workH;
+    actions.push(`resize to ${workW}x${workH} (8000px cap)`);
+  }
+
+  // Step 2: bytes within limit? done.
+  if (workBuf.length <= ANTHROPIC_MAX_IMAGE_BYTES && actions.length === 0) return noop();
+  if (workBuf.length <= ANTHROPIC_MAX_IMAGE_BYTES) {
+    return {
+      data: workBuf.toString("base64"),
+      mimeType: mime,
+      originalBytes,
+      finalBytes: workBuf.length,
+      originalDim,
+      finalDim: { width: workW, height: workH },
+      actions,
+      changed: true,
+    };
+  }
+
+  // Step 3: JPEG quality ladder.
+  let outMime: SupportedImageMimeType = "image/jpeg";
+  let attempt = workBuf;
+  for (const q of JPEG_QUALITY_LADDER) {
+    attempt = await sharp(workBuf).jpeg({ quality: q, mozjpeg: true }).toBuffer();
+    if (attempt.length <= ANTHROPIC_MAX_IMAGE_BYTES) {
+      actions.push(`jpeg q=${q} → ${formatBytes(attempt.length)}`);
+      return {
+        data: attempt.toString("base64"),
+        mimeType: outMime,
+        originalBytes,
+        finalBytes: attempt.length,
+        originalDim,
+        finalDim: { width: workW, height: workH },
+        actions,
+        changed: true,
+      };
+    }
+  }
+  actions.push(`jpeg q=60 still ${formatBytes(attempt.length)} — shrinking`);
+
+  // Step 4: shrink the long edge and retry quality ladder each step.
+  for (const longEdge of SHRINK_LADDER) {
+    if (Math.max(workW, workH) <= longEdge) continue;
+    const resized = await sharp(workBuf)
+      .resize({
+        width: workW >= workH ? longEdge : undefined,
+        height: workH > workW ? longEdge : undefined,
+        fit: "inside",
+        withoutEnlargement: true,
+      })
+      .toBuffer();
+    const m = await sharp(resized).metadata();
+    const newW = m.width ?? workW;
+    const newH = m.height ?? workH;
+    for (const q of JPEG_QUALITY_LADDER) {
+      attempt = await sharp(resized).jpeg({ quality: q, mozjpeg: true }).toBuffer();
+      if (attempt.length <= ANTHROPIC_MAX_IMAGE_BYTES) {
+        actions.push(`resize ${newW}x${newH} + jpeg q=${q} → ${formatBytes(attempt.length)}`);
+        return {
+          data: attempt.toString("base64"),
+          mimeType: outMime,
+          originalBytes,
+          finalBytes: attempt.length,
+          originalDim,
+          finalDim: { width: newW, height: newH },
+          actions,
+          changed: true,
+        };
+      }
+    }
+    workBuf = resized;
+    workW = newW;
+    workH = newH;
+  }
+
+  // Give up — return last attempt anyway; pi will at least try.
+  actions.push(`final ${formatBytes(attempt.length)} — over limit`);
+  return {
+    data: attempt.toString("base64"),
+    mimeType: outMime,
+    originalBytes,
+    finalBytes: attempt.length,
+    originalDim,
+    finalDim: { width: workW, height: workH },
+    actions,
+    changed: true,
+  };
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(0)}KB`;
+  return `${bytes}B`;
+}

package/src/preview.ts

@@ -37,10 +37,11 @@ export class ImagePreviewMessage implements Component {
 
   render(width: number): string[] {
     const lines: string[] = [];
+    const safeWidth = Math.max(1, width);
     for (let index = 0; index < this.attachments.length; index++) {
       const attachment = this.attachments[index]!;
-      lines.push(formatAttachmentLine(attachment, width, this.theme.fallbackColor));
-      lines.push(...this.images[index]!.render(width));
+      lines.push(formatAttachmentLine(attachment, safeWidth, this.theme.fallbackColor));
+      lines.push(...this.images[index]!.render(safeWidth));
     }
     return lines;
   }