eve-hub 0.14.8 → 0.14.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.14.10
+
+### Patch Changes
+
+- Image sizes: `displaySize` gives an image's shown size, after a JPEG's EXIF orientation.
+
+## 0.14.9
+
+### Patch Changes
+
+- `post_message` finds links with a markdown parser instead of a regex. A sandbox path in code (a fence or an inline span) stays as written, a label with brackets (nested or escaped) keeps its link, a `#…` fragment stays on the rewritten link, a `%20` in the path is decoded, and a reference definition's target is rewritten too. The 700-character cap and the `![]()` refusal read the same links, so an image written inside code is no longer refused.
+
 ## 0.14.8
 
 ### Patch Changes

package/hub-upload.d.ts

@@ -11,7 +11,7 @@ export type Uploaded = {
 };
 export declare const hostedHub: () => boolean;
 export declare const IMAGE_FILE: RegExp;
-/** A markdown link target that names a sandbox file: an absolute path, or one under the home directory. */
+/** A markdown link target that names a sandbox file: an absolute path (not a `//host` one), or one under the home directory. */
 export declare const isSandboxPath: (target: string) => boolean;
 export declare function readSandboxFile(sandbox: SandboxFiles, path: string): Promise<Uint8Array>;
 export declare function uploadBytes(bytes: Uint8Array, name: string, what: string): Promise<Uploaded>;

package/hub-upload.js

@@ -8,8 +8,8 @@ import { pathToFileURL } from "node:url";
 import { registryFetch } from "./registry-fetch.mjs";
 export const hostedHub = () => Boolean(process.env.VERCEL || process.env.HUB_TOKEN);
 export const IMAGE_FILE = /\.(png|jpe?g|gif|webp|heic)$/i;
-/** A markdown link target that names a sandbox file: an absolute path, or one under the home directory. */
-export const isSandboxPath = (target) => /^(\/|\$HOME\/|~\/)/.test(target);
+/** A markdown link target that names a sandbox file: an absolute path (not a `//host` one), or one under the home directory. */
+export const isSandboxPath = (target) => /^(\/(?!\/)|\$HOME\/|~\/)/.test(target);
 // The sandbox resolves `~/`; `$HOME/` is the same place spelled as the shell does.
 const sandboxPath = (path) => path.replace(/^\$HOME\//, "~/");
 export async function readSandboxFile(sandbox, path) {

package/image-limits.d.mts

@@ -2,4 +2,5 @@ export const MAX_BYTES: number;
 export const MODEL_MAX_EDGE: number;
 export function sniffImage(bytes: Uint8Array): string | null;
 export function imageSize(bytes: Uint8Array, mediaType: string): { width: number; height: number } | null;
+export function displaySize(bytes: Uint8Array, mediaType: string): { width: number; height: number } | null;
 export function modelUnsafe(bytes: Uint8Array): string | null;

package/image-limits.mjs

@@ -45,6 +45,41 @@ export function imageSize(bytes, mediaType) {
   return null;
 }
 
+// The size the image is shown at: a JPEG whose EXIF orientation turns it a quarter (5 to 8) is drawn with its sides swapped, as
+// AppKit and browsers draw it. imageSize is the stored frame, which is what a model provider's limits apply to.
+export function displaySize(bytes, mediaType) {
+  const size = imageSize(bytes, mediaType);
+  if (!size || mediaType !== "image/jpeg") return size;
+  const o = jpegOrientation(bytes);
+  return o >= 5 && o <= 8 ? { width: size.height, height: size.width } : size;
+}
+
+// The EXIF orientation (1 to 8) in a JPEG's APP1 segment; 1 when it has none.
+function jpegOrientation(bytes) {
+  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let i = 2;
+  while (i + 4 <= bytes.length && bytes[i] === 0xff) {
+    const marker = bytes[i + 1];
+    if (marker === 0xda || marker === 0xd9) return 1;
+    const len = v.getUint16(i + 2);
+    const start = i + 4, end = Math.min(i + 2 + len, bytes.length);
+    if (marker === 0xe1 && end - start >= 14 && String.fromCharCode(...bytes.subarray(start, start + 4)) === "Exif" && bytes[start + 4] === 0 && bytes[start + 5] === 0) {
+      const tiff = start + 6, little = bytes[tiff] === 0x49;
+      const u16 = (o) => v.getUint16(o, little), u32 = (o) => v.getUint32(o, little);
+      const ifd = tiff + u32(tiff + 4);
+      if (ifd + 2 > end) return 1;
+      const n = u16(ifd);
+      for (let e = 0; e < n && ifd + 2 + e * 12 + 12 <= end; e++) {
+        const at = ifd + 2 + e * 12;
+        if (u16(at) === 0x0112) return u16(at + 8);
+      }
+      return 1;
+    }
+    i += 2 + len;
+  }
+  return 1;
+}
+
 // Why a model provider would reject these bytes as an image part, or null if
 // it takes them: an unknown format, a size we can't read, a side over 8000px,
 // or more than MAX_BYTES. Checked before any file part is emitted.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.14.8",
+  "version": "0.14.10",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",
@@ -41,6 +41,7 @@
     "ai": "^7.0.137",
     "jose": "^6.2.3",
     "jsonc-parser": "3.3.1",
+    "mdast-util-from-markdown": "^2.1.0",
     "omggif": "1.0.10",
     "smol-toml": "^1.9.1",
     "tree-sitter-bash": "0.25.1",

package/tools/post_message.d.ts

@@ -3,7 +3,7 @@ export declare const MAX_CHARS = 700;
 export declare const postLength: (text: string) => number;
 /** The error for a text the thread shouldn't carry, or null. */
 export declare function textError(text: string): string | null;
-/** The text with each sandbox-path link target replaced by where the human's app opens it. */
+/** The text with each sandbox-path link target replaced by where the human's app opens it; a `#…` fragment stays on it. Each file is opened once. */
 export declare function rewriteDocLinks(text: string, open: (path: string) => Promise<string>): Promise<string>;
 declare const _default: import("eve/tools").ToolDefinition<{
     threadId?: string | undefined;

package/tools/post_message.js

@@ -1,4 +1,5 @@
 import { defineTool } from "eve/tools";
+import { fromMarkdown } from "mdast-util-from-markdown";
 import { z } from "zod";
 import { documentUrl, hostedHub, isSandboxPath, uploadBytes, uploadFile } from "../hub-upload.js";
 import { registryFetch } from "../registry-fetch.mjs";
@@ -23,30 +24,64 @@ import { registryFetch } from "../registry-fetch.mjs";
 // move), the text is its summary, `metadata` its PR and sha. The hub keeps the
 // latest one per bot and thread for the workspace state and the Dash.
 export const MAX_CHARS = 700;
-const LINK = /\[([^\]]*)\]\(([^)\s]+)\)/g;
-const IMAGE_SYNTAX = /!\[[^\]]*\]\([^)]*\)/;
 const SCREENSHOT = "screenshot";
+// The markdown parser finds the links and where each destination starts, so a path in code is never read as a
+// link and brackets in a label (nested or escaped) never cut it.
+function destinations(text) {
+    const spans = new Map();
+    function enter(token) {
+        spans.set(this.stack.at(-1), token);
+    }
+    const tree = fromMarkdown(text, { mdastExtensions: [{ enter: { resource: enter, definitionDestination: enter } }] });
+    const found = [];
+    const visit = (node) => {
+        const span = spans.get(node);
+        if (span && node.url !== undefined && (node.type === "link" || node.type === "image" || node.type === "definition")) {
+            const to = node.type === "definition" ? node.position.end.offset : span.end.offset;
+            found.push({ kind: node.type, from: span.start.offset, to, url: node.url, title: node.title });
+        }
+        node.children?.forEach(visit);
+    };
+    visit(tree);
+    return found;
+}
 /** The characters the cap counts: the text without its links' targets. */
-export const postLength = (text) => text.replace(LINK, (_, label) => `[${label}]()`).length;
+export const postLength = (text) => destinations(text).reduce((n, d) => n - (d.to - d.from) + (d.kind === "definition" ? 0 : "()".length), text.length);
 /** The error for a text the thread shouldn't carry, or null. */
 export function textError(text) {
-    if (IMAGE_SYNTAX.test(text))
+    if (destinations(text).some((d) => d.kind === "image"))
         return "Images don't go in the text: pass the file's sandbox path in `images` and it shows inline";
     if (postLength(text) > MAX_CHARS)
         return "Too long: move the detail into a doc and link it";
     return null;
 }
-/** The text with each sandbox-path link target replaced by where the human's app opens it. */
+const PATH_AND_FRAGMENT = /^([^?#]*)(?:\?[^#]*)?(#.*)?$/;
+/** The text with each sandbox-path link target replaced by where the human's app opens it; a `#…` fragment stays on it. Each file is opened once. */
 export async function rewriteDocLinks(text, open) {
-    const links = [...text.matchAll(LINK)].filter((m) => isSandboxPath(m[2]));
-    const urls = await Promise.all(links.map((m) => open(m[2])));
-    let out = "", at = 0;
-    links.forEach((m, i) => {
-        const start = m.index + m[0].length - m[2].length - 1;
-        out += text.slice(at, start) + urls[i];
-        at = start + m[2].length;
+    const links = destinations(text).flatMap((d) => {
+        const [, path, fragment = ""] = PATH_AND_FRAGMENT.exec(d.url);
+        return d.kind !== "image" && isSandboxPath(path) ? [{ ...d, file: decode(path), fragment }] : [];
     });
-    return out + text.slice(at);
+    if (!links.length)
+        return text;
+    const files = [...new Set(links.map((l) => l.file))];
+    const opened = new Map(await Promise.all(files.map(async (file) => [file, await open(file)])));
+    let out = text;
+    for (const l of links.sort((a, b) => b.from - a.from)) {
+        const url = `${opened.get(l.file)}${l.fragment}`;
+        const target = /[\s()<>]/.test(url) ? `<${url}>` : url;
+        const title = l.title == null ? "" : ` "${l.title.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+        out = `${out.slice(0, l.from)}${l.kind === "definition" ? `${target}${title}` : `(${target}${title})`}${out.slice(l.to)}`;
+    }
+    return out;
+}
+function decode(path) {
+    try {
+        return decodeURIComponent(path);
+    }
+    catch {
+        return path;
+    }
 }
 async function screenshot(sessionId) {
     if (hostedHub())