@blockrun/franklin 3.25.0 → 3.25.2

package/dist/ui/app.js

@@ -19,6 +19,7 @@ import { estimateCost } from '../pricing.js';
 import { formatTokens, shortModelName } from '../stats/format.js';
 import { mouse, forceDisableMouseTracking } from './mouse.js';
 import { resolveAskUserAnswer } from './ask-user-answer.js';
+import { looksLikeImagePasteStub } from './paste-heuristics.js';
 // ─── Full-width input box ──────────────────────────────────────────────────
 const BRACKETED_PASTE_START = '[200~';
 const BRACKETED_PASTE_END = '[201~';
@@ -445,37 +446,59 @@ function PromptTextInput({ value, onChange, onSubmit, placeholder = '', focus =
             const buffered = pasteBufferRef.current;
             pasteBufferRef.current = '';
             pasteActiveRef.current = false;
-            // Image-paste detection: terminals deliver Cmd+V as a bracketed paste,
-            // but image bytes don't ride that stream — Terminal/iTerm2 just fire an
-            // empty (or whitespace-only) bracketed paste, while the actual image
-            // sits in the system clipboard. So when the buffered text is empty we
-            // probe the clipboard before falling through to plain text handling.
-            // (No race vs. real paste content: pasted text always populates the
-            // buffer before END arrives, so non-empty buffer = certainly text.)
-            if (buffered.trim().length === 0) {
-                // Clipboard probe + optional resize are async; the input handler
-                // returns now and updateValue happens once the Promise resolves.
-                // Capture the cursor offset so the block goes where the user pasted,
-                // even if they moved the cursor in the meantime.
-                const insertAt = currentCursorOffset;
+            // Image-paste detection. Cmd+V on a clipboard image arrives as an empty
+            // bracketed paste on macOS Terminal/iTerm2; several Linux terminals
+            // instead emit a filename, a `file://` URI, or the raw image header
+            // alongside it (3.25.0 only probed on an empty buffer, so those Linux
+            // shapes silently dropped the image — fixed in #77). We probe the system
+            // clipboard for an image only when the buffer *looks* like one of those
+            // stubs; genuine text is inserted synchronously below so the common
+            // paste path never waits on the async osascript / xclip / wl-paste
+            // shell-out (30-100 ms, but a cold spawn can be more).
+            const insertAt = currentCursorOffset;
+            const insertPastedText = (buf, baseOffset) => {
+                if (buf.length === 0)
+                    return;
+                const lineCount = buf.split('\n').length;
+                const textToInsert = lineCount >= PASTE_COLLAPSE_LINE_THRESHOLD
+                    ? encodePasteBlock(buf)
+                    : buf;
+                const cur = valueRef.current;
+                const at = Math.min(baseOffset, cur.length);
+                updateValue(cur.slice(0, at) + textToInsert + cur.slice(at), at + textToInsert.length);
+            };
+            if (looksLikeImagePasteStub(buffered)) {
+                // The probe is async; the handler returns now and updateValue happens
+                // when the Promise resolves. insertAt (captured above) pins the result
+                // to where the user pasted even if the cursor moved meanwhile.
                 tryReadClipboardImage().then((img) => {
-                    let injected;
-                    if (img && 'path' in img)
-                        injected = encodeImageBlock(img.path);
-                    else if (img && 'error' in img)
-                        injected = `[Image rejected: ${img.error}] `;
-                    else
-                        return; // no image on clipboard — nothing to do
-                    const cur = valueRef.current;
-                    const at = Math.min(insertAt, cur.length);
-                    updateValue(cur.slice(0, at) + injected + cur.slice(at), at + injected.length);
-                }).catch(() => { });
+                    if (img && 'path' in img) {
+                        // Image wins — drop the bracketed-paste buffer (the terminal stub).
+                        const injected = encodeImageBlock(img.path);
+                        const cur = valueRef.current;
+                        const at = Math.min(insertAt, cur.length);
+                        updateValue(cur.slice(0, at) + injected + cur.slice(at), at + injected.length);
+                        return;
+                    }
+                    if (img && 'error' in img) {
+                        const injected = `[Image rejected: ${img.error}] `;
+                        const cur = valueRef.current;
+                        const at = Math.min(insertAt, cur.length);
+                        updateValue(cur.slice(0, at) + injected + cur.slice(at), at + injected.length);
+                        return;
+                    }
+                    // No image after all — the stub was literal text (e.g. a lone
+                    // "photo.png" the user actually typed). Insert it as text.
+                    insertPastedText(buffered, insertAt);
+                }).catch(() => {
+                    // Probe failed unexpectedly — don't lose the paste; insert as text.
+                    insertPastedText(buffered, insertAt);
+                });
                 return;
             }
-            const lineCount = buffered.split('\n').length;
-            text = lineCount >= PASTE_COLLAPSE_LINE_THRESHOLD
-                ? encodePasteBlock(buffered)
-                : buffered;
+            // Genuine text paste — insert synchronously, no clipboard probe.
+            insertPastedText(buffered, currentCursorOffset);
+            return;
         }
         if (!text) {
             if (hasPasteEnd)

package/dist/ui/paste-heuristics.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure heuristics for the bracketed-paste handler in app.tsx, split out so they
+ * can be unit-tested without pulling in Ink/React.
+ */
+/**
+ * Does a bracketed-paste buffer look like a terminal's stand-in for an image
+ * paste rather than genuine pasted text?
+ *
+ * Cmd+V on a clipboard image yields an *empty* buffer on macOS Terminal/iTerm2,
+ * but several Linux terminals instead emit a filename, a `file://` URI, or the
+ * raw image header alongside the paste. Those shapes — and only those — warrant
+ * the (async, 30-100 ms) clipboard probe in app.tsx. Substantial text returns
+ * `false` so it can be inserted synchronously, keeping the common paste path
+ * instant instead of waiting on an osascript / xclip / wl-paste shell-out.
+ *
+ * False positives are harmless: a literal text paste of "photo.png" probes the
+ * clipboard, finds no image, and falls through to the text path anyway.
+ */
+export declare function looksLikeImagePasteStub(buffered: string): boolean;

package/dist/ui/paste-heuristics.js

@@ -0,0 +1,40 @@
+/**
+ * Pure heuristics for the bracketed-paste handler in app.tsx, split out so they
+ * can be unit-tested without pulling in Ink/React.
+ */
+// Image filenames a terminal might substitute for a pasted image. Anchored, so
+// only a string that *is* such a path matches — not prose that mentions one.
+const IMAGE_FILE_EXT = /\.(png|jpe?g|gif|webp|bmp|tiff?|heic|heif|avif)$/i;
+/**
+ * Does a bracketed-paste buffer look like a terminal's stand-in for an image
+ * paste rather than genuine pasted text?
+ *
+ * Cmd+V on a clipboard image yields an *empty* buffer on macOS Terminal/iTerm2,
+ * but several Linux terminals instead emit a filename, a `file://` URI, or the
+ * raw image header alongside the paste. Those shapes — and only those — warrant
+ * the (async, 30-100 ms) clipboard probe in app.tsx. Substantial text returns
+ * `false` so it can be inserted synchronously, keeping the common paste path
+ * instant instead of waiting on an osascript / xclip / wl-paste shell-out.
+ *
+ * False positives are harmless: a literal text paste of "photo.png" probes the
+ * clipboard, finds no image, and falls through to the text path anyway.
+ */
+export function looksLikeImagePasteStub(buffered) {
+    // macOS image paste: empty / whitespace-only bracketed paste.
+    if (buffered.trim().length === 0)
+        return true;
+    // Raw binary the terminal dumped (e.g. PNG's \x1a, or bytes that failed
+    // UTF-8 decoding into U+FFFD). Genuine text never carries control chars
+    // other than tab / newline / carriage return.
+    if (/[\x00-\x08\x0b\x0c\x0e-\x1f�]/.test(buffered))
+        return true;
+    // A single-line file reference the terminal sent instead of the image bytes.
+    const trimmed = buffered.trim();
+    if (!trimmed.includes('\n')) {
+        if (/^file:\/\//i.test(trimmed))
+            return true; // file:// URI
+        if (IMAGE_FILE_EXT.test(trimmed))
+            return true; // bare filename / path
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.25.0",
+  "version": "3.25.2",
   "description": "Franklin Agent — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {