pi-paster 0.1.4 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-paster",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Pi extension that turns pasted image paths into first-class image attachments.",
   "keywords": [
     "image-attachments",
@@ -50,11 +50,14 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },
+  "optionalDependencies": {
+    "sharp": "^0.34.0"
+  },
   "packageManager": "pnpm@11.1.2",
   "pi": {
     "extensions": [
       "./src/index.ts"
     ],
-    "image": "https://unpkg.com/pi-paster@0.1.4/docs/preview.png"
+    "image": "https://unpkg.com/pi-paster@0.2.0/docs/preview.png"
   }
 }

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";
@@ -110,7 +111,17 @@ export default function paster(pi: ExtensionAPI, config: PasterConfig = {}): voi
     store.clear();
   });
 
-  pi.on("input", (event, ctx) => {
+  function previewMessage(attachments: ImageAttachment[]) {
+    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" as const };
     if (ctx.hasUI) {
       activeEditor?.clearCursorPreview();
@@ -118,26 +129,31 @@ export default function paster(pi: ExtensionAPI, config: PasterConfig = {}): voi
 
     const attachments = store.matchingPlaceholders(event.text);
     if (attachments.length === 0) return { action: "continue" as const };
-    pendingPreview = attachments;
+
+    if (ctx.isIdle()) {
+      pendingPreview = attachments;
+    } else {
+      // Queued steer/follow-up messages do not fire before_agent_start when they are
+      // later delivered by the running agent, so enqueue the preview alongside them now.
+      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,
     };
   });
 
   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 };
   });
 }