@tiens.nguyen/gu-cli 1.0.752 → 1.0.753

package/gonext_agent_chat.py

@@ -7125,21 +7125,69 @@ def _take_image_markers(messages, images_dir=None):
     return found
 
 
+# WHAT CLAUDE WILL TAKE (task #285). smolagents re-encodes every image as PNG, base64, before
+# sending (smolagents.utils.encode_image_base64) — so a 4 MB JPEG photo can become a PNG over the
+# 5 MB per-image limit, and then Claude rejects the WHOLE request, not just the image. Claude
+# also scales anything with a long edge over 1568 px down to that (and rejects > 8000 px), so
+# shrinking first sends the same picture Claude would see, in fewer bytes.
+_IMAGE_MAX_EDGE = 1568
+_IMAGE_MAX_B64 = 5 * 1024 * 1024  # measured on the base64 string — the stricter reading
+
+
+def _png_b64_len(im) -> int:
+    import io
+    buf = io.BytesIO()
+    im.save(buf, format="PNG")
+    return (len(buf.getvalue()) + 2) // 3 * 4
+
+
+def _prepare_image(path):
+    """Open `path` and return a PIL image Claude will accept, or raise ValueError(reason)."""
+    from PIL import Image
+    try:
+        with Image.open(path) as src:
+            src.load()  # a truncated or non-image file fails here, not later in the request
+            im = src.copy()
+    except Image.DecompressionBombError:
+        raise ValueError("too many pixels to open safely") from None
+    except Exception as e:  # noqa: BLE001
+        raise ValueError(f"not a readable image ({type(e).__name__})") from None
+    # Colour modes PNG cannot hold, or holds oddly: CMYK photos, 16-bit, float, palette.
+    if im.mode == "P":
+        im = im.convert("RGBA" if "transparency" in im.info else "RGB")
+    elif im.mode not in ("RGB", "RGBA", "L", "LA"):
+        im = im.convert("RGBA" if "A" in im.mode else "RGB")
+    if max(im.size) > _IMAGE_MAX_EDGE:
+        im.thumbnail((_IMAGE_MAX_EDGE, _IMAGE_MAX_EDGE), Image.LANCZOS)
+    while _png_b64_len(im) > _IMAGE_MAX_B64:
+        if max(im.size) <= 256:
+            raise ValueError("still over 5 MB after shrinking")
+        im = im.resize((max(1, im.width * 3 // 4), max(1, im.height * 3 // 4)), Image.LANCZOS)
+    return im
+
+
 def _load_turn_images(refs):
-    """[(label, path)] → PIL images, skipping any that will not open."""
-    out = []
+    """[(label, path)] → (PIL images ready for Claude, [(label, reason)] for the ones that failed)."""
+    out, failed = [], []
     try:
-        from PIL import Image
+        import PIL  # noqa: F401
     except Exception:  # noqa: BLE001
-        return out
+        return out, [(label, "image support (Pillow) is not installed") for label, _ in refs]
     for label, path in refs:
         try:
-            with Image.open(path) as im:
-                im.load()
-                out.append(im.copy())
-        except Exception as e:  # noqa: BLE001
-            _log(f"image {label}: could not open ({type(e).__name__})")
-    return out
+            out.append(_prepare_image(path))
+        except ValueError as e:
+            failed.append((label, str(e)))
+            _log(f"image {label}: not attached — {e}")
+    return out, failed
+
+
+def _label_failed_images(text, failed):
+    """Say which images did not make it, where the model reads their labels — a bare
+    "[Image #1]" with nothing attached invites the model to guess what it shows."""
+    for label, reason in failed:
+        text = text.replace(label, f"{label} (could not be opened: {reason})")
+    return text
 
 
 def run_agent_chat(cfg):
@@ -12807,9 +12855,14 @@ def run_agent_chat(cfg):
         _turn_images = []
         if _turn_image_refs:
             if _is_anthropic_url(coding_base_url):
-                _turn_images = _load_turn_images(_turn_image_refs)
-                _log(f"attached {len(_turn_images)} image(s) to the question")
-                _emit({"type": "step", "text": f"Sending {len(_turn_images)} image(s) with the question"})
+                _turn_images, _img_failed = _load_turn_images(_turn_image_refs)
+                task_with_hint = _label_failed_images(task_with_hint, _img_failed)
+                _log(f"attached {len(_turn_images)} image(s) to the question"
+                     + (f", {len(_img_failed)} could not be opened" if _img_failed else ""))
+                if _turn_images:
+                    _emit({"type": "step", "text": f"Sending {len(_turn_images)} image(s) with the question"})
+                for _lbl, _why in _img_failed:
+                    _emit({"type": "step", "text": f"⚠ {_lbl} not sent — {_why}"})
             else:
                 task_with_hint += ("\n\n(The user pasted " + ", ".join(l for l, _ in _turn_image_refs)
                                    + " but this coding model is not sent images — say so if the "

package/image-paste.mjs

@@ -20,13 +20,47 @@
  *     most reliable way; Windows Terminal quotes a path with spaces.
  */
 import { spawnSync } from "node:child_process";
-import { chmodSync, copyFileSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, existsSync, mkdirSync, openSync, readSync, rmSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import path, { extname, join } from "node:path";
+import path, { join } from "node:path";
 
 export const IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
-/** Anthropic's limit per image. A bigger one would fail the whole request. */
-export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+/**
+ * The largest file gu takes at paste time. NOT Claude's 5 MB limit: the agent shrinks every image
+ * to what Claude accepts before sending (task #285), so a 12 MB photo is fine. This only stops a
+ * file far too big to be a screenshot from being copied around.
+ */
+export const MAX_IMAGE_BYTES = 30 * 1024 * 1024;
+
+/**
+ * What the file's first bytes say it is — "png" | "jpeg" | "gif" | "webp" | "" (task #285). The
+ * EXTENSION is only a name: a renamed text file, or a screenshot still being written, has the
+ * right one and is not an image.
+ */
+export function imageKind(bytes) {
+  const b = Buffer.from(bytes ?? []);
+  if (b.length >= 8 && b.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return "png";
+  if (b.length >= 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return "jpeg";
+  if (b.length >= 6 && /^GIF8[79]a$/.test(b.subarray(0, 6).toString("latin1"))) return "gif";
+  if (b.length >= 12 && b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP") return "webp";
+  return "";
+}
+
+function fileImageKind(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    const buf = Buffer.alloc(12);
+    const n = readSync(fd, buf, 0, 12, 0);
+    return imageKind(buf.subarray(0, n));
+  } catch {
+    return "";
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+const NOT_AN_IMAGE = "that file is not an image (png, jpg, gif or webp)";
 
 export const imagesDir = (home = homedir()) => join(home, ".gonext", "images");
 
@@ -97,13 +131,15 @@ export function storeImageFile(src, { home = homedir() } = {}) {
     return { error: `cannot read ${src}` };
   }
   if (size > MAX_IMAGE_BYTES) return { error: tooBig(size) };
-  const dest = newImagePath(extname(src).toLowerCase() === ".jpeg" ? ".jpg" : extname(src).toLowerCase(), home);
+  const kind = fileImageKind(src);
+  if (!kind) return { error: NOT_AN_IMAGE };
+  const dest = newImagePath(kind === "jpeg" ? ".jpg" : `.${kind}`, home);
   copyFileSync(src, dest);
   chmodSync(dest, 0o600);
   return { path: dest };
 }
 
-const tooBig = (n) => `the image is ${(n / 1048576).toFixed(1)} MB — Claude accepts up to 5 MB`;
+const tooBig = (n) => `the image is ${(n / 1048576).toFixed(1)} MB — gu takes up to ${MAX_IMAGE_BYTES / 1048576} MB`;
 
 /** The command that writes the clipboard's image to `dest` as PNG, per platform (null = none). */
 export function clipboardImageCommand(dest, platform = process.platform) {
@@ -148,8 +184,19 @@ export function clipboardImageToFile({ home = homedir(), platform = process.plat
   } catch {
     /* nothing written */
   }
-  if (r?.status !== 0 || size === 0) return { none: true };
-  if (size > MAX_IMAGE_BYTES) return { error: tooBig(size) };
+  if (r?.status !== 0 || size === 0) {
+    rmSync(dest, { force: true });
+    return { none: true };
+  }
+  if (size > MAX_IMAGE_BYTES) {
+    rmSync(dest, { force: true });
+    return { error: tooBig(size) };
+  }
+  // A file copied in Explorer is copied as-is, so it can be anything with an image's name.
+  if (!fileImageKind(dest)) {
+    rmSync(dest, { force: true });
+    return { error: "the clipboard's file is not an image (png, jpg, gif or webp)" };
+  }
   chmodSync(dest, 0o600);
   return { path: dest };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.752",
+  "version": "1.0.753",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",

package/scripts/image-paste-check.mjs

@@ -62,7 +62,7 @@ const snippet = [
   "spec = importlib.util.spec_from_file_location('a', sys.argv[1]); a = importlib.util.module_from_spec(spec); spec.loader.exec_module(a)",
   "msgs = [{'role': 'user', 'content': 'look [Image #1: ' + sys.argv[2] + '] and [Image #2: ' + sys.argv[3] + ']'}]",
   "refs = a._take_image_markers(msgs)",
-  "imgs = a._load_turn_images(refs)",
+  "imgs, failed = a._load_turn_images(refs)",
   "print(json.dumps({'refs': refs, 'text': msgs[0]['content'], 'opened': len(imgs)}))",
 ].join("\n");
 const r = spawnSync(py.cmd, [...py.args, "-c", snippet, join(WORKER, "gonext_agent_chat.py"), stored.path ?? "", shot], {