pi-paster 0.1.4 → 0.2.0

package/dist/index.d.mts

@@ -23,6 +23,8 @@ declare function resolvePasterConfig(config?: PasterConfig): ResolvedPasterConfi
 //#region src/types.d.ts
 declare const EXTENSION_NAME = "paster";
 declare const MAX_IMAGE_BYTES: number;
+declare const ANTHROPIC_MAX_DIMENSION = 8000;
+declare const ANTHROPIC_MAX_IMAGE_BYTES: number;
 type SupportedImageMimeType = "image/png" | "image/jpeg" | "image/webp" | "image/gif";
 interface ImageAttachment {
   id: number;
@@ -32,6 +34,14 @@ interface ImageAttachment {
   data: string;
   dimensions?: ImageDimensions;
   createdAt: number;
+  /** True once optimizeImageBytes has run on this attachment. */
+  optimized?: boolean;
+  /** Original (pre-optimization) base64 size in bytes — informational. */
+  originalBytes?: number;
+  /** Final (post-optimization) base64 size in bytes — informational. */
+  finalBytes?: number;
+  /** Human-readable trail of optimization actions applied, if any. */
+  optimizeActions?: string[];
 }
 interface LoadedImage {
   originalPath: string;
@@ -66,6 +76,25 @@ type ClipboardImageResult = {
 };
 declare function readClipboardImage(maxBytes?: number): ClipboardImageResult;
 //#endregion
+//#region src/optimize-image.d.ts
+interface OptimizeResult {
+  data: string;
+  mimeType: SupportedImageMimeType;
+  originalBytes: number;
+  finalBytes: number;
+  originalDim?: {
+    width: number;
+    height: number;
+  };
+  finalDim?: {
+    width: number;
+    height: number;
+  };
+  actions: string[];
+  changed: boolean;
+}
+declare function optimizeImageBytes(input: Buffer, mime: SupportedImageMimeType): Promise<OptimizeResult>;
+//#endregion
 //#region src/store.d.ts
 declare class AttachmentStore {
   private nextId;
@@ -110,8 +139,14 @@ interface PathToken {
   value: string;
   start: number;
   end: number;
+  bare: boolean;
 }
 declare function detectImageMimeType(bytes: Uint8Array): SupportedImageMimeType | undefined;
+declare function isWindowsDrivePath(value: string): boolean;
+declare function isWindowsUncPath(value: string): boolean;
+declare function isWindowsLikePath(value: string): boolean;
+declare function isWsl(): boolean;
+declare function windowsToWslPath(windowsPath: string): string;
 declare function resolveImagePath(input: string, cwd: string): string;
 declare function shellUnescape(input: string): string;
 declare function tokenizePathLikeText(text: string): PathToken[];
@@ -130,6 +165,19 @@ declare function replaceImagePathsInText(text: string, options: {
   accepted: ImageAttachment[];
 };
 declare function imagesForText(store: AttachmentStore, text: string, existing?: PasterImageContent[]): PasterImageContent[];
+/**
+ * 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.
+ */
+declare function imagesForTextOptimized(store: AttachmentStore, text: string, existing?: PasterImageContent[]): Promise<PasterImageContent[]>;
+declare function describeReject(result: Exclude<LoadImageResult, {
+  ok: true;
+}>, notify?: (message: string) => void): void;
 //#endregion
 //#region src/preview.d.ts
 declare class ImagePreviewMessage implements Component {
@@ -174,4 +222,4 @@ declare function createImagePasteTerminalInputHandler(options: {
 declare function createPaster(config?: PasterConfig): (pi: ExtensionAPI) => void;
 declare function paster(pi: ExtensionAPI, config?: PasterConfig): void;
 //#endregion
-export { AttachmentStore, ClipboardImageResult, CursorImagePreviewWidget, DEFAULT_PASTER_CONFIG, EXTENSION_NAME, ImageAttachment, ImagePreviewMessage, LoadImageResult, LoadedImage, MAX_IMAGE_BYTES, PASTE_END, PASTE_START, PasterConfig, PasterEditor, PasterImageContent, PasterPreviewDetails, ResolvedPasterConfig, SupportedImageMimeType, TerminalInputResult, createImagePasteTerminalInputHandler, createPaster, paster as default, detectImageMimeType, dimensionsForImage, imagesForText, loadImageFromPath, readClipboardImage, replaceImagePathsInText, resolveImagePath, resolvePasterConfig, shellUnescape, tokenizePathLikeText };
+export { ANTHROPIC_MAX_DIMENSION, ANTHROPIC_MAX_IMAGE_BYTES, AttachmentStore, ClipboardImageResult, CursorImagePreviewWidget, DEFAULT_PASTER_CONFIG, EXTENSION_NAME, ImageAttachment, ImagePreviewMessage, LoadImageResult, LoadedImage, MAX_IMAGE_BYTES, OptimizeResult, PASTE_END, PASTE_START, PasterConfig, PasterEditor, PasterImageContent, PasterPreviewDetails, ResolvedPasterConfig, SupportedImageMimeType, TerminalInputResult, createImagePasteTerminalInputHandler, createPaster, paster as default, describeReject, detectImageMimeType, dimensionsForImage, imagesForText, imagesForTextOptimized, isWindowsDrivePath, isWindowsLikePath, isWindowsUncPath, isWsl, loadImageFromPath, optimizeImageBytes, readClipboardImage, replaceImagePathsInText, resolveImagePath, resolvePasterConfig, shellUnescape, tokenizePathLikeText, windowsToWslPath };

package/dist/index.mjs

@@ -3,22 +3,233 @@ import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { Image, getCellDimensions, getImageDimensions, truncateToWidth } from "@earendil-works/pi-tui";
+import { platform } from "node:process";
+import { Image, getCellDimensions, getImageDimensions, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 //#region src/types.ts
 const EXTENSION_NAME = "paster";
-const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_IMAGE_BYTES = 64 * 1024 * 1024;
+const ANTHROPIC_MAX_DIMENSION = 8e3;
+const ANTHROPIC_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+//#endregion
+//#region src/optimize-image.ts
+let _sharp;
+async function getSharp() {
+	if (_sharp !== void 0) return _sharp;
+	try {
+		const mod = await import("sharp");
+		const fn = typeof mod === "function" ? mod : mod?.default;
+		_sharp = typeof fn === "function" ? fn : null;
+	} catch {
+		_sharp = null;
+	}
+	return _sharp;
+}
+const SHRINK_LADDER = [
+	6e3,
+	4e3,
+	3e3,
+	2e3
+];
+const JPEG_QUALITY_LADDER = [
+	95,
+	90,
+	85,
+	80,
+	70,
+	60
+];
+async function optimizeImageBytes(input, mime) {
+	const originalBytes = input.length;
+	const noop = () => ({
+		data: input.toString("base64"),
+		mimeType: mime,
+		originalBytes,
+		finalBytes: originalBytes,
+		actions: [],
+		changed: false
+	});
+	if (originalBytes <= 5242880) {
+		if (originalBytes <= 256 * 1024) return noop();
+	}
+	const sharp = await getSharp();
+	if (!sharp) return noop();
+	const meta = await sharp(input).metadata();
+	const origW = meta.width ?? 0;
+	const origH = meta.height ?? 0;
+	if (!origW || !origH) return noop();
+	const actions = [];
+	const originalDim = {
+		width: origW,
+		height: origH
+	};
+	let workBuf = input;
+	let workW = origW;
+	let workH = origH;
+	if (workW > 8e3 || workH > 8e3) {
+		workBuf = await sharp(workBuf).resize({
+			width: workW >= workH ? ANTHROPIC_MAX_DIMENSION : void 0,
+			height: workH > workW ? ANTHROPIC_MAX_DIMENSION : void 0,
+			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)`);
+	}
+	if (workBuf.length <= 5242880 && actions.length === 0) return noop();
+	if (workBuf.length <= 5242880) return {
+		data: workBuf.toString("base64"),
+		mimeType: mime,
+		originalBytes,
+		finalBytes: workBuf.length,
+		originalDim,
+		finalDim: {
+			width: workW,
+			height: workH
+		},
+		actions,
+		changed: true
+	};
+	let outMime = "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 <= 5242880) {
+			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`);
+	for (const longEdge of SHRINK_LADDER) {
+		if (Math.max(workW, workH) <= longEdge) continue;
+		const resized = await sharp(workBuf).resize({
+			width: workW >= workH ? longEdge : void 0,
+			height: workH > workW ? longEdge : void 0,
+			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 <= 5242880) {
+				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;
+	}
+	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) {
+	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+	if (bytes >= 1024) return `${(bytes / 1024).toFixed(0)}KB`;
+	return `${bytes}B`;
+}
 //#endregion
 //#region src/image-utils.ts
+const MAX_BARE_PATH_EXTENSIONS = 8;
 function detectImageMimeType(bytes) {
 	if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) return "image/png";
 	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
 	if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) return "image/gif";
 	if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
 }
+const WINDOWS_DRIVE_PATH = /^([a-zA-Z]):[\\/](.*)$/;
+function isWindowsDrivePath(value) {
+	return WINDOWS_DRIVE_PATH.test(value);
+}
+function isWindowsUncPath(value) {
+	return value.startsWith("\\\\") && value.length > 2;
+}
+function isWindowsLikePath(value) {
+	return isWindowsDrivePath(value) || isWindowsUncPath(value);
+}
+let cachedIsWsl;
+function isWsl() {
+	if (cachedIsWsl !== void 0) 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;
+}
+function windowsToWslPath(windowsPath) {
+	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)) return windowsPath.replace(/\\/g, "/");
+	return windowsPath;
+}
 function resolveImagePath(input, cwd) {
 	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);
 }
@@ -32,7 +243,12 @@ function shellUnescape(input) {
 	return result;
 }
 function isPathLike(value) {
-	return value.startsWith("/") || value.startsWith("~/") || value === "~" || value.startsWith("./") || value.startsWith("../");
+	return value.startsWith("/") || value.startsWith("~/") || value === "~" || value.startsWith("./") || value.startsWith("../") || isWindowsLikePath(value);
+}
+function startsWithWindowsPath(text, index) {
+	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;
 }
 function tokenizePathLikeText(text) {
 	const tokens = [];
@@ -47,11 +263,12 @@ function tokenizePathLikeText(text) {
 		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;
@@ -68,15 +285,17 @@ function tokenizePathLikeText(text) {
 				raw: text.slice(start, index),
 				value,
 				start,
-				end: index
+				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;
@@ -84,16 +303,59 @@ function tokenizePathLikeText(text) {
 			rawValue += current;
 			index++;
 		}
-		const value = shellUnescape(rawValue);
+		const value = windowsMode ? rawValue : shellUnescape(rawValue);
 		if (isPathLike(value)) tokens.push({
 			raw: rawValue,
 			value,
 			start,
-			end: index
+			end: index,
+			bare: true
 		});
 	}
 	return tokens;
 }
+function tryExtendBareToken(text, token, attempt) {
+	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
+	};
+}
 function dimensionsForImage(data, mimeType) {
 	return getImageDimensions(data, mimeType) ?? void 0;
 }
@@ -154,15 +416,16 @@ function replaceImagePathsInText(text, options) {
 	const accepted = [];
 	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++;
 	}
 	if (replaced === 0) return {
@@ -184,14 +447,141 @@ function imagesForText(store, text, existing = []) {
 		data: attachment.data
 	}))];
 }
+/**
+* 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.
+*/
+async function imagesForTextOptimized(store, text, existing = []) {
+	const attachments = store.matchingPlaceholders(text);
+	const optimized = [];
+	for (const attachment of attachments) {
+		if (!attachment.optimized) try {
+			const result = await optimizeImageBytes(Buffer.from(attachment.data, "base64"), 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 {
+			attachment.optimized = true;
+		}
+		optimized.push({
+			type: "image",
+			mimeType: attachment.mimeType,
+			data: attachment.data
+		});
+	}
+	return [...existing, ...optimized];
+}
+function describeReject(result, notify) {
+	if (!notify) return;
+	if (result.reason === "too-large") notify(`paster: image is too large and was not attached: ${result.path}`);
+}
 //#endregion
 //#region src/clipboard.ts
 function readClipboardImage(maxBytes = MAX_IMAGE_BYTES) {
-	if (process.platform !== "darwin") return {
+	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() {
+	try {
+		return /microsoft|wsl/i.test(readFileSync("/proc/version", "utf8"));
+	} catch {
+		return false;
+	}
+}
+function resolvePowerShell() {
+	if (process.platform === "win32") return "powershell.exe";
+	for (const c of ["/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe", "/mnt/c/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe"]) if (existsSync(c)) return c;
+	return "powershell.exe";
+}
+function readWindowsClipboardImage(maxBytes) {
+	const exe = resolvePowerShell();
+	if (!exe) return {
 		ok: false,
 		reason: "unsupported-platform"
 	};
-	return readMacOSClipboardImage(maxBytes);
+	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: 5e3,
+			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) {
 	for (const attempt of [{
@@ -393,9 +783,7 @@ var PasterEditor = class 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)
 		});
 	}
 	updateCursorPreview() {
@@ -408,6 +796,11 @@ var PasterEditor = class extends CustomEditor {
 };
 //#endregion
 //#region src/preview.ts
+function formatAttachmentLine(attachment, width, style) {
+	const maxWidth = Math.max(1, width);
+	const line = style(`Attached ${attachment.placeholder} ${attachment.originalPath}`);
+	return visibleWidth(line) > maxWidth ? truncateToWidth(line, maxWidth, "") : line;
+}
 var ImagePreviewMessage = class {
 	images;
 	constructor(attachments, theme) {
@@ -421,10 +814,11 @@ var ImagePreviewMessage = class {
 	}
 	render(width) {
 		const lines = [];
+		const safeWidth = Math.max(1, width);
 		for (let index = 0; index < this.attachments.length; index++) {
 			const attachment = this.attachments[index];
-			lines.push(this.theme.fallbackColor(`Attached ${attachment.placeholder} ${attachment.originalPath}`));
-			lines.push(...this.images[index].render(width));
+			lines.push(formatAttachmentLine(attachment, safeWidth, this.theme.fallbackColor));
+			lines.push(...this.images[index].render(safeWidth));
 		}
 		return lines;
 	}
@@ -448,8 +842,7 @@ var CursorImagePreviewWidget = class {
 		this.image.invalidate();
 	}
 	headerLine(width) {
-		const title = `Attached ${this.attachment.placeholder} ${this.attachment.originalPath}`;
-		return this.theme.title(truncateToWidth(title, Math.max(1, width), ""));
+		return formatAttachmentLine(this.attachment, width, this.theme.title);
 	}
 	createImage(attachment, maxWidthCells = 60) {
 		return new Image(attachment.data, attachment.mimeType, { fallbackColor: this.theme.accent }, {
@@ -508,9 +901,7 @@ function createImagePasteTerminalInputHandler(options) {
 		cwd: options.cwd,
 		store: options.store,
 		loadImage: options.loadImage,
-		onReject: (result) => {
-			if (result.reason === "too-large") options.notify?.(`paster: image is over 10 MB and was not attached: ${result.path}`);
-		}
+		onReject: (result) => describeReject(result, options.notify)
 	});
 	return (data) => {
 		let prefix = "";
@@ -607,29 +998,35 @@ function paster(pi, config = {}) {
 		}
 		store.clear();
 	});
-	pi.on("input", (event, ctx) => {
+	function previewMessage(attachments) {
+		const placeholders = attachments.map((attachment) => attachment.placeholder);
+		return {
+			customType: "paster-preview",
+			content: `(attachment preview: ${placeholders.join(", ")})`,
+			display: true,
+			details: { placeholders }
+		};
+	}
+	pi.on("input", async (event, ctx) => {
 		if (event.source === "extension") return { action: "continue" };
 		if (ctx.hasUI) activeEditor?.clearCursorPreview();
 		const attachments = store.matchingPlaceholders(event.text);
 		if (attachments.length === 0) return { action: "continue" };
-		pendingPreview = attachments;
+		if (ctx.isIdle()) pendingPreview = attachments;
+		else pi.sendMessage(previewMessage(attachments), { deliverAs: "followUp" });
+		const images = await imagesForTextOptimized(store, event.text, event.images);
 		return {
 			action: "transform",
 			text: event.text,
-			images: imagesForText(store, event.text, event.images)
+			images
 		};
 	});
 	pi.on("before_agent_start", () => {
 		if (pendingPreview.length === 0) return;
-		const placeholders = pendingPreview.map((attachment) => attachment.placeholder);
+		const message = previewMessage(pendingPreview);
 		pendingPreview = [];
-		return { message: {
-			customType: "paster-preview",
-			content: "",
-			display: true,
-			details: { placeholders }
-		} };
+		return { message };
 	});
 }
 //#endregion
-export { AttachmentStore, CursorImagePreviewWidget, DEFAULT_PASTER_CONFIG, EXTENSION_NAME, ImagePreviewMessage, MAX_IMAGE_BYTES, PASTE_END, PASTE_START, PasterEditor, createImagePasteTerminalInputHandler, createPaster, paster as default, detectImageMimeType, dimensionsForImage, imagesForText, loadImageFromPath, readClipboardImage, replaceImagePathsInText, resolveImagePath, resolvePasterConfig, shellUnescape, tokenizePathLikeText };
+export { ANTHROPIC_MAX_DIMENSION, ANTHROPIC_MAX_IMAGE_BYTES, AttachmentStore, CursorImagePreviewWidget, DEFAULT_PASTER_CONFIG, EXTENSION_NAME, ImagePreviewMessage, MAX_IMAGE_BYTES, PASTE_END, PASTE_START, PasterEditor, createImagePasteTerminalInputHandler, createPaster, paster as default, describeReject, detectImageMimeType, dimensionsForImage, imagesForText, imagesForTextOptimized, isWindowsDrivePath, isWindowsLikePath, isWindowsUncPath, isWsl, loadImageFromPath, optimizeImageBytes, readClipboardImage, replaceImagePathsInText, resolveImagePath, resolvePasterConfig, shellUnescape, tokenizePathLikeText, windowsToWslPath };