talon-agent 3.34.1 → 3.36.0

package/src/frontend/native/handlers.ts

@@ -18,7 +18,12 @@ import {
 } from "./extensions.js";
 import { historyPage, searchHistory } from "./history.js";
 import { readLogEntries } from "./logs.js";
-import { mediaUrl, registerMedia, saveUpload } from "./media.js";
+import {
+  describeAttachment,
+  MAX_UPLOAD_BYTES,
+  resolveUpload,
+  saveUploadStream,
+} from "./media.js";
 import {
   effortLevels,
   listBackends,
@@ -30,11 +35,40 @@ import {
 import { setQueued } from "./queue.js";
 import { resetChat } from "./reset.js";
 import type { NativeRuntime } from "./runtime.js";
-import type { BridgeServerHandlers } from "./server.js";
+import type { BridgeServerHandlers, SendOptions } from "./server.js";
+import type { ClientAttachment } from "./protocol.js";
 import { configSnapshot, applyConfigUpdate } from "./settings.js";
 import { bridgeStatus, broadcastStatus } from "./status.js";
 import { interruptTurn, isBusy, liveTurnEvents, startTurn } from "./turn.js";
 
+/**
+ * Turn a `/send` body's attachment references into the records this daemon
+ * minted at upload time. Both wire shapes land here: the `attachments` list
+ * multi-file clients send, and the `imagePath`/`attachmentPath` pair older
+ * single-image clients send. References the daemon cannot account for are
+ * dropped — a message can only ever point the model at a file the daemon
+ * itself wrote to its uploads dir.
+ */
+function resolveAttachments(
+  runtime: NativeRuntime,
+  opts: SendOptions | undefined,
+): ClientAttachment[] {
+  const refs = [...(opts?.attachments ?? [])];
+  if (!refs.length && (opts?.imagePath || opts?.attachmentPath)) {
+    refs.push({ url: opts.imagePath, path: opts.attachmentPath });
+  }
+  const resolved: ClientAttachment[] = [];
+  for (const ref of refs) {
+    const found = resolveUpload(runtime, ref);
+    // Same file referenced twice (a re-send of a queued message, say) stays
+    // one attachment.
+    if (found && !resolved.some((a) => a.path === found.path)) {
+      resolved.push(found);
+    }
+  }
+  return resolved;
+}
+
 export function buildBridgeHandlers(
   runtime: NativeRuntime,
 ): BridgeServerHandlers {
@@ -49,29 +83,44 @@ export function buildBridgeHandlers(
     search: (query, chatId) => searchHistory(runtime, query, chatId),
     send: (id, text, opts) => {
       const entry = chats.get(id) ?? chats.ensure(id);
+      // Resolve the client's references into the records this daemon minted
+      // at upload time — dropping anything it can't account for.
+      const attachments = resolveAttachments(runtime, opts);
       // A turn is already running for this chat — don't interrupt it. Park the
       // message as the single queued follow-up (synced to every client); it
       // auto-sends when the running turn ends. `isBusy` reads `liveTurns`,
       // which `runTurn` sets synchronously, so even a rapid second /send from
       // any client is caught here rather than starting a concurrent turn.
       if (isBusy(runtime, entry.id)) {
-        setQueued(runtime, entry.id, {
-          text,
-          imagePath: opts?.imagePath,
-          attachmentPath: opts?.attachmentPath,
-        });
+        setQueued(runtime, entry.id, { text, attachments });
         return;
       }
-      startTurn(runtime, entry, text, opts);
+      startTurn(runtime, entry, text, { attachments });
     },
     queueMessage: (id, text) => {
-      // Edit/replace the queued follow-up (text-only). Empty clears it.
+      // Edit/replace the queued follow-up's text, keeping whatever files were
+      // queued with it. Empty text cancels the whole follow-up, attachments
+      // included — the client's queue editor offers no other way to drop it.
       const entry = chats.get(id);
-      if (entry) setQueued(runtime, entry.id, { text });
+      if (!entry) return;
+      const attachments = text.trim()
+        ? (runtime.queuedByChat.get(entry.id)?.attachments ?? [])
+        : [];
+      setQueued(runtime, entry.id, { text, attachments });
     },
-    upload: async (filename, _contentType, bytes) => {
-      const path = await saveUpload(runtime, filename, bytes);
-      return { imagePath: mediaUrl(registerMedia(runtime, path)), path };
+    upload: async (filename, contentType, body) => {
+      const saved = await saveUploadStream(
+        runtime,
+        filename,
+        body,
+        MAX_UPLOAD_BYTES,
+      );
+      return describeAttachment(runtime, {
+        path: saved.path,
+        name: filename,
+        size: saved.size,
+        contentType,
+      });
     },
     listModels: (chatId) => listModels(runtime, chatId),
     setModel: (id, model) => setModel(runtime, id, model),

package/src/frontend/native/history.ts

@@ -3,18 +3,21 @@
  * (attached images get a fresh /media URL, assistant rows their turn meta).
  */
 
+import { basename } from "node:path";
 import {
   getRecentHistory,
   getHistoryBefore,
   searchHistoryMessages,
   type HistoryMessage,
+  type MessageAttachment,
 } from "../../storage/history.js";
 import { isDeliveryTool } from "../../core/tools/index.js";
 import type { ChatEntry } from "./chats.js";
 import { refreshContext } from "./context.js";
-import { mediaUrl, registerMedia } from "./media.js";
+import { contentTypeFor, rehydrateAttachment } from "./media.js";
 import {
   historyToClientMessage,
+  type ClientAttachment,
   type ClientMessage,
   type SearchResult,
 } from "./protocol.js";
@@ -29,11 +32,32 @@ function hydrateHistoryRow(
   row: HistoryMessage,
 ): ClientMessage {
   const msg = historyToClientMessage(row, chatId);
-  // Re-hydrate an attached image: re-register its on-disk path into
-  // the media map and hand back a fresh /media URL so the image shows
-  // in reloaded history (survives restarts as long as the file exists).
-  if (row.mediaType === "photo" && row.filePath) {
-    msg.imagePath = mediaUrl(registerMedia(runtime, row.filePath));
+  // Re-hydrate attached files: media ids are per-daemon-run, so each stored
+  // attachment is re-registered and handed a fresh /media URL. Rows written
+  // before multi-file attachments carry only mediaType + filePath, which is
+  // projected into the same one-element list so every client renders history
+  // the same way regardless of when it was recorded.
+  const stored: ClientAttachment[] = row.attachments?.length
+    ? row.attachments.map((a: MessageAttachment) =>
+        rehydrateAttachment(runtime, { ...a, url: "" }),
+      )
+    : row.filePath &&
+        (row.mediaType === "photo" || row.mediaType === "document")
+      ? [
+          rehydrateAttachment(runtime, {
+            path: row.filePath,
+            name: basename(row.filePath),
+            size: 0,
+            mimeType: contentTypeFor(row.filePath),
+            image: row.mediaType === "photo",
+            url: "",
+          }),
+        ]
+      : [];
+  if (stored.length) {
+    msg.attachments = stored;
+    const firstImage = stored.find((a) => a.image);
+    if (firstImage) msg.imagePath = firstImage.url;
   }
   // Re-hydrate turn meta (tool timeline + stats) for assistant rows.
   if (msg.role === "assistant") {

package/src/frontend/native/media.ts

@@ -1,13 +1,25 @@
 /**
  * Media handling — the id → path registry the `/media` route serves from,
- * and the uploads directory client attachments land in.
+ * the uploads directory client attachments land in, and the MIME table both
+ * the upload path and the `/media` route classify files with.
  */
 
-import { mkdir, writeFile } from "node:fs/promises";
-import { basename, join } from "node:path";
+import { createWriteStream, type WriteStream } from "node:fs";
+import { mkdir, unlink } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import type { Readable } from "node:stream";
 import { dirs } from "../../util/paths.js";
+import type { ClientAttachment } from "./protocol.js";
 import type { NativeRuntime } from "./runtime.js";
 
+/**
+ * Upload ceiling. Bodies stream straight to disk, so this bounds what a
+ * client may park in the uploads dir rather than what has to fit in memory —
+ * high enough for the archives and media people actually attach.
+ */
+export const MAX_UPLOAD_BYTES = 512 * 1024 * 1024;
+
 /** Register a file for serving and return its short media id. */
 export function registerMedia(
   runtime: NativeRuntime,
@@ -24,20 +36,264 @@ export function mediaUrl(mediaId: string): string {
 }
 
 /**
- * Persist an uploaded attachment to the workspace uploads dir under a safe,
- * unique name, and return its absolute path (handed to the model to read).
+ * Extension → MIME. Deliberately small: the types a companion client is
+ * likely to attach (images it renders inline, archives, documents, code,
+ * audio/video), with `application/octet-stream` for everything else — which
+ * is a correct answer for a download, just not a descriptive one.
+ */
+const MIME_BY_EXT: Record<string, string> = {
+  // Images (the set `isImageType` renders inline).
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".svg": "image/svg+xml",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  // Archives.
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tgz": "application/gzip",
+  ".bz2": "application/x-bzip2",
+  ".xz": "application/x-xz",
+  ".zst": "application/zstd",
+  ".tar": "application/x-tar",
+  ".7z": "application/x-7z-compressed",
+  ".rar": "application/vnd.rar",
+  // Documents.
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx":
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx":
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".odt": "application/vnd.oasis.opendocument.text",
+  ".rtf": "application/rtf",
+  ".epub": "application/epub+zip",
+  // Text + code.
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".tsv": "text/tab-separated-values",
+  ".log": "text/plain",
+  ".json": "application/json",
+  ".jsonl": "application/x-ndjson",
+  ".xml": "application/xml",
+  ".yaml": "application/yaml",
+  ".yml": "application/yaml",
+  ".toml": "application/toml",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".ts": "text/x-typescript",
+  ".tsx": "text/x-typescript",
+  ".py": "text/x-python",
+  ".rs": "text/x-rust",
+  ".go": "text/x-go",
+  ".java": "text/x-java",
+  ".c": "text/x-c",
+  ".h": "text/x-c",
+  ".cpp": "text/x-c++",
+  ".sh": "application/x-sh",
+  ".sql": "application/sql",
+  ".patch": "text/x-diff",
+  ".diff": "text/x-diff",
+  // Audio / video.
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".opus": "audio/opus",
+  ".flac": "audio/flac",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".mkv": "video/x-matroska",
+  ".avi": "video/x-msvideo",
+  // Fonts.
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+};
+
+/** Best-effort MIME type for a path, by extension. */
+export function contentTypeFor(filePath: string): string {
+  return (
+    MIME_BY_EXT[extname(filePath).toLowerCase()] ?? "application/octet-stream"
+  );
+}
+
+/** Whether a MIME type is one clients render inline as an image. */
+export function isImageType(mimeType: string): boolean {
+  // SVG is an image by type but a script host by nature — clients render it
+  // through the same <img> path, so keep it inline-able; the bytes are only
+  // ever served back to the authenticated client that uploaded them.
+  return mimeType.startsWith("image/");
+}
+
+/**
+ * Sanitise an uploaded file name to a single safe path segment. Strips any
+ * directory component (`../`, absolute paths, Windows separators) and any
+ * character outside a conservative allowlist, so an upload can never escape
+ * the uploads dir no matter what the client sends.
+ */
+export function safeUploadName(filename: string): string {
+  const base = basename(filename.replace(/\\/g, "/"));
+  const safe = base.replace(/[^\w.-]+/g, "_").replace(/^\.+/, "");
+  return safe || "upload";
+}
+
+/** The absolute path an upload with this name lands at (unique per call). */
+function uploadDest(runtime: NativeRuntime, filename: string): string {
+  return join(
+    dirs.uploads,
+    `${Date.now()}-${runtime.nextId().toString(36)}-${safeUploadName(filename)}`,
+  );
+}
+
+/**
+ * Stream an upload body straight to the uploads dir — never buffering the
+ * whole file in memory, so a multi-hundred-megabyte archive costs a socket
+ * and a file handle rather than the heap. Aborts (and cleans up the partial
+ * file) as soon as `maxBytes` is exceeded.
  */
-export async function saveUpload(
+export async function saveUploadStream(
   runtime: NativeRuntime,
   filename: string,
-  bytes: Buffer,
-): Promise<string> {
+  body: Readable,
+  maxBytes: number,
+): Promise<{ path: string; size: number }> {
   await mkdir(dirs.uploads, { recursive: true });
-  const safe = basename(filename).replace(/[^\w.-]+/g, "_") || "upload";
-  const dest = join(
-    dirs.uploads,
-    `${Date.now()}-${runtime.nextId().toString(36)}-${safe}`,
-  );
-  await writeFile(dest, bytes);
-  return dest;
+  const dest = uploadDest(runtime, filename);
+  const sink = createWriteStream(dest);
+  let size = 0;
+  let tooLarge = false;
+  try {
+    await pipeline(
+      body,
+      async function* (source: AsyncIterable<Buffer>) {
+        for await (const chunk of source) {
+          size += chunk.length;
+          if (size > maxBytes) {
+            tooLarge = true;
+            throw new Error(
+              `Upload exceeds the ${Math.floor(maxBytes / (1024 * 1024))} MB limit`,
+            );
+          }
+          yield chunk;
+        }
+      },
+      sink,
+    );
+  } catch (err) {
+    // Wait for the sink to actually close before removing the partial file:
+    // the pipeline can reject before the fd exists, and an unlink that races
+    // it leaves the file on disk once the open finally lands.
+    await closed(sink);
+    await unlink(dest).catch(() => {});
+    if (tooLarge) throw err;
+    throw new Error(
+      `Upload failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+  if (size === 0) {
+    await closed(sink);
+    await unlink(dest).catch(() => {});
+    throw new Error("Empty upload");
+  }
+  return { path: dest, size };
+}
+
+/** Resolve once a write stream is closed, destroying it if it still is not. */
+function closed(sink: WriteStream): Promise<void> {
+  return new Promise((resolve) => {
+    if (sink.closed) return resolve();
+    sink.once("close", () => resolve());
+    sink.destroy();
+  });
+}
+
+/**
+ * Register a saved upload for serving and project it to its wire shape. The
+ * declared content type wins when it is specific; otherwise the extension
+ * decides, so a client that sends `application/octet-stream` for everything
+ * still gets a usefully typed attachment back.
+ */
+export function describeAttachment(
+  runtime: NativeRuntime,
+  file: { path: string; name: string; size: number; contentType?: string },
+): ClientAttachment {
+  const declared = (file.contentType ?? "").split(";")[0]?.trim().toLowerCase();
+  const mimeType =
+    declared && declared !== "application/octet-stream"
+      ? declared
+      : contentTypeFor(file.name || file.path);
+  const mediaId = registerMedia(runtime, file.path);
+  const attachment: ClientAttachment = {
+    path: file.path,
+    name: safeUploadName(file.name || basename(file.path)),
+    size: file.size,
+    mimeType,
+    url: mediaUrl(mediaId),
+    image: isImageType(mimeType),
+  };
+  // Remember it by media id: `/send` resolves the client's references through
+  // this registry instead of trusting paths off the wire.
+  runtime.uploads.set(mediaId, attachment);
+  return attachment;
+}
+
+/** The media id inside a `/media?id=…` reference, or undefined. */
+export function mediaIdFrom(url: string | undefined): string | undefined {
+  if (!url) return undefined;
+  const match = /[?&]id=([^&]+)/.exec(url);
+  return match?.[1] ? decodeURIComponent(match[1]) : undefined;
+}
+
+/**
+ * Resolve one attachment reference from a client into the record this daemon
+ * minted at upload time. Unknown ids resolve to undefined — a client cannot
+ * name a file the daemon did not write to its own uploads dir.
+ */
+export function resolveUpload(
+  runtime: NativeRuntime,
+  ref: { url?: string; path?: string } | undefined,
+): ClientAttachment | undefined {
+  if (!ref) return undefined;
+  const byId = mediaIdFrom(ref.url);
+  if (byId) {
+    const known = runtime.uploads.get(byId);
+    if (known) return known;
+  }
+  // Legacy single-file clients send only the on-disk path back. Match it
+  // against what was uploaded this run rather than accepting it outright.
+  if (ref.path) {
+    for (const entry of runtime.uploads.values()) {
+      if (entry.path === ref.path) return entry;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Re-describe an attachment persisted in history: the stored record already
+ * has the name/size/type, it just needs a fresh media id (ids are per-daemon
+ * run) so the bytes are fetchable again after a restart.
+ */
+export function rehydrateAttachment(
+  runtime: NativeRuntime,
+  stored: ClientAttachment,
+): ClientAttachment {
+  return { ...stored, url: mediaUrl(registerMedia(runtime, stored.path)) };
 }

package/src/frontend/native/protocol.ts

@@ -52,6 +52,31 @@ export type ClientToolCall = {
   output?: string;
 };
 
+/**
+ * One file attached to a message — an image, an archive, a document, or
+ * anything else the user dropped on the composer. Additive in v1: older
+ * clients that only know `imagePath` keep rendering the first image.
+ *
+ * `path` is the absolute on-disk location in the daemon's uploads dir; it is
+ * what the model is pointed at so it can read the file itself. `url` is the
+ * relative bridge path a client fetches the bytes from (`/media?id=…`),
+ * resolved against its own base URL + token.
+ */
+export type ClientAttachment = {
+  /** Absolute path on the daemon host (handed to the model). */
+  path: string;
+  /** Original file name, for display. */
+  name: string;
+  /** Size in bytes. */
+  size: number;
+  /** Best-effort MIME type, `application/octet-stream` when unknown. */
+  mimeType: string;
+  /** Relative bridge path the bytes are served from (`/media?id=…`). */
+  url: string;
+  /** True when the client should render this inline as an image. */
+  image: boolean;
+};
+
 /** A single rendered message in a conversation. */
 export type ClientMessage = {
   id: string;
@@ -68,6 +93,12 @@ export type ClientMessage = {
    * Present on photo messages the bot sends; `text` carries any caption.
    */
   imagePath?: string;
+  /**
+   * Every file attached to this message, in the order the user staged them.
+   * `imagePath` stays in sync with the first image here so clients written
+   * against the single-image shape keep working unchanged.
+   */
+  attachments?: ClientAttachment[];
   /** Tools that ran during this assistant turn (history hydration). */
   tools?: ClientToolCall[];
   /** Turn stats attached once the turn ended (history hydration). */
@@ -109,8 +140,10 @@ export type ContextInfo = {
  */
 export type QueuedMessage = {
   text: string;
-  /** True when an image/file is attached to the queued send. */
+  /** True when one or more files are attached to the queued send. */
   hasAttachment: boolean;
+  /** How many files are attached (additive; older clients read the flag). */
+  attachmentCount?: number;
 };
 
 /** A conversation in the sidebar. */

package/src/frontend/native/queue.ts

@@ -9,7 +9,7 @@ import type { NativeRuntime, QueuedEntry } from "./runtime.js";
 
 /**
  * Set (or replace) a chat's queued follow-up and sync it to every client via
- * chat_updated. Empty text with no attachment clears the queue.
+ * chat_updated. Empty text with no attachments clears the queue.
  */
 export function setQueued(
   runtime: NativeRuntime,
@@ -19,14 +19,11 @@ export function setQueued(
   const entry = runtime.chats.get(chatId);
   if (!entry) return;
   const text = next.text.trim();
-  if (!text && !next.attachmentPath) {
+  const attachments = next.attachments;
+  if (!text && attachments.length === 0) {
     if (!runtime.queuedByChat.delete(chatId)) return;
   } else {
-    runtime.queuedByChat.set(chatId, {
-      text,
-      imagePath: next.imagePath,
-      attachmentPath: next.attachmentPath,
-    });
+    runtime.queuedByChat.set(chatId, { text, attachments });
   }
   broadcastChatUpdated(runtime, entry);
 }

package/src/frontend/native/routes/chats.ts

@@ -1,8 +1,11 @@
 import type { RouteHost } from "./host.js";
 import type { BridgeRoutes } from "./table.js";
-import { asPositiveInt, asString, deviceIdParam } from "./params.js";
-
-const MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+import {
+  asAttachmentRefs,
+  asPositiveInt,
+  asString,
+  deviceIdParam,
+} from "./params.js";
 
 export function chatRoutes(
   host: RouteHost,
@@ -87,27 +90,42 @@ export function chatRoutes(
       const body = await readJson(req);
       const id = asString(body.chatId) ?? "";
       const text = asString(body.text) ?? "";
+      // Multi-file clients send `attachments`; the single-image shape older
+      // clients send is folded into the same list by the handler.
+      const attachments = asAttachmentRefs(body.attachments);
       const imagePath = asString(body.imagePath);
       const attachmentPath = asString(body.attachmentPath);
-      // Text may be empty when an image is attached; require one or the
-      // other.
-      if (!id || (!text.trim() && !attachmentPath))
+      const hasAttachment =
+        attachments.length > 0 || Boolean(attachmentPath || imagePath);
+      // Text may be empty when a file is attached; require one or the other.
+      if (!id || (!text.trim() && !hasAttachment))
         return json(res, 400, {
           ok: false,
           error: "chatId and text (or an attachment) required",
         });
-      h.send(id, text, { imagePath, attachmentPath });
+      h.send(id, text, { attachments, imagePath, attachmentPath });
       json(res, 202, { ok: true });
     },
     "POST /upload": async ({ req, res, url }) => {
       const filename = url.searchParams.get("filename") ?? "upload";
       const contentType =
         req.headers["content-type"] ?? "application/octet-stream";
-      const bytes = await host.readRaw(req, MAX_UPLOAD_BYTES);
-      if (!bytes.length)
-        return json(res, 400, { ok: false, error: "Empty upload" });
-      const result = await h.upload(filename, contentType, bytes);
-      json(res, 200, { ok: true, ...result });
+      try {
+        const attachment = await h.upload(filename, contentType, req);
+        // `imagePath` mirrors the URL for clients written against the
+        // single-image upload response.
+        json(res, 200, { ok: true, ...attachment, imagePath: attachment.url });
+      } catch (err) {
+        // The client can only act on this if it knows why: too large (pick a
+        // smaller file), empty (nothing was read), or a server-side failure.
+        const error = err instanceof Error ? err.message : String(err);
+        const status = /limit/i.test(error)
+          ? 413
+          : /empty/i.test(error)
+            ? 400
+            : 500;
+        json(res, status, { ok: false, error });
+      }
     },
     "GET /media": ({ res, url }) =>
       host.serveMedia(res, url.searchParams.get("id") ?? ""),