talon-agent 3.35.0 → 3.37.0

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,12 @@
 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";
+import { log, logWarn } from "../../../util/log.js";
 
 export function chatRoutes(
   host: RouteHost,
@@ -87,27 +91,56 @@ 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 });
+      const startedAt = Date.now();
+      try {
+        const attachment = await h.upload(filename, contentType, req);
+        // Uploads are the one client action whose failure used to be visible
+        // only in the app: the route answered in JSON and logged nothing, so
+        // "attaching a file doesn't work — check the logs" had nothing to
+        // read. Both outcomes are logged now, with the size and duration
+        // that distinguish a rejected upload from a dropped connection.
+        log(
+          "native",
+          `upload ok: ${attachment.name} (${attachment.size} bytes, ${attachment.mimeType}) in ${Date.now() - startedAt}ms`,
+        );
+        // `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;
+        logWarn(
+          "native",
+          `upload failed (${status}) for ${filename} after ${Date.now() - startedAt}ms: ${error}`,
+        );
+        json(res, status, { ok: false, error });
+      }
     },
     "GET /media": ({ res, url }) =>
       host.serveMedia(res, url.searchParams.get("id") ?? ""),

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

@@ -1,6 +1,9 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Readable } from "node:stream";
+import type { AttachmentRef } from "./params.js";
 import type {
   BackendOption,
+  ClientAttachment,
   BridgeEvent,
   BridgeStatus,
   ClientChat,
@@ -18,7 +21,13 @@ import type {
 import type { ConfigSnapshot } from "../settings.js";
 
 /** Optional attachment references carried alongside a sent message. */
-type SendOptions = {
+export type SendOptions = {
+  /**
+   * Every file attached to the message, as the client's references to its
+   * own uploads. `imagePath` and `attachmentPath` below are the single-file
+   * shape older clients send; the handler folds them into the same list.
+   */
+  attachments?: AttachmentRef[];
   /** Relative bridge path to render inline (e.g. `/media?id=…`). */
   imagePath?: string;
   /** Absolute on-disk path handed to the model so it can read the file. */
@@ -41,12 +50,16 @@ export type BridgeServerHandlers = {
   search(query: string, chatId?: string): SearchResult[];
   /** Fire-and-forget: streams its results back through `broadcast`. */
   send(id: string, text: string, opts?: SendOptions): void;
-  /** Persist an uploaded image and return its render path + on-disk path. */
+  /**
+   * Stream an uploaded file to disk and return its wire description. The body
+   * is consumed as it arrives (never buffered whole), so the size ceiling is
+   * disk, not memory.
+   */
   upload(
     filename: string,
     contentType: string,
-    bytes: Buffer,
-  ): Promise<{ imagePath: string; path: string }>;
+    body: Readable,
+  ): Promise<ClientAttachment>;
   listModels(
     id?: string,
   ):
@@ -139,7 +152,6 @@ export type RouteHost = {
   fingerprint: () => string | null;
   json: (res: ServerResponse, code: number, body: unknown) => void;
   readJson: (req: IncomingMessage) => Promise<Record<string, unknown>>;
-  readRaw: (req: IncomingMessage, max: number) => Promise<Buffer>;
   corsHeaders: () => Record<string, string>;
   streamFile: (
     res: ServerResponse,

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

@@ -27,3 +27,24 @@ export function asPositiveInt(v: string | null): number | undefined {
   const n = Number(v);
   return Number.isInteger(n) && n > 0 ? n : undefined;
 }
+
+/** A client's reference to a file it already uploaded. */
+export type AttachmentRef = { url?: string; path?: string };
+
+/**
+ * Coerce the `attachments` array on a `/send` body to reference shape. Only
+ * the identifying fields are read: name, size and type are whatever the
+ * daemon recorded when it wrote the file, never what the client claims now.
+ */
+export function asAttachmentRefs(v: unknown): AttachmentRef[] {
+  if (!Array.isArray(v)) return [];
+  const refs: AttachmentRef[] = [];
+  for (const item of v) {
+    if (typeof item !== "object" || item === null) continue;
+    const row = item as Record<string, unknown>;
+    const url = asString(row.url);
+    const path = asString(row.path);
+    if (url || path) refs.push({ url, path });
+  }
+  return refs;
+}

package/src/frontend/native/runtime.ts

@@ -12,7 +12,12 @@ import type { TalonConfig } from "../../util/config.js";
 import type { Gateway } from "../../core/engine/gateway.js";
 import { getMeshService, type MeshService } from "../../core/mesh/index.js";
 import { NativeChats } from "./chats.js";
-import type { BridgeEvent, ClientToolCall, ContextInfo } from "./protocol.js";
+import type {
+  BridgeEvent,
+  ClientAttachment,
+  ClientToolCall,
+  ContextInfo,
+} from "./protocol.js";
 
 /** One tool call observed during a running turn, kept for mid-turn replay. */
 export type LiveToolEntry = {
@@ -21,11 +26,10 @@ export type LiveToolEntry = {
   done?: boolean;
 };
 
-/** A chat's single queued follow-up, with its attachment paths intact. */
+/** A chat's single queued follow-up, with its attachments intact. */
 export type QueuedEntry = {
   text: string;
-  imagePath?: string;
-  attachmentPath?: string;
+  attachments: ClientAttachment[];
 };
 
 export type NativeRuntime = {
@@ -51,6 +55,13 @@ export type NativeRuntime = {
    * frontends behave).
    */
   readonly media: Map<string, string>;
+  /**
+   * Uploads this daemon run has accepted, keyed by their media id. `/send`
+   * resolves a client's attachment references through here rather than
+   * trusting the paths in the request body, so a message can only ever point
+   * the model at a file this daemon itself wrote to the uploads dir.
+   */
+  readonly uploads: Map<string, ClientAttachment>;
   /**
    * Live context-window fill per chat, refreshed at the end of each turn.
    * Cached (not computed inline) so the sync `toClientChat` projection stays
@@ -99,6 +110,7 @@ export function createNativeRuntime(
     chats: new NativeChats(),
     mesh: getMeshService(),
     media: new Map(),
+    uploads: new Map(),
     contextByChat: new Map(),
     liveTurns: new Map(),
     queuedByChat: new Map(),

package/src/frontend/native/server.ts

@@ -24,9 +24,9 @@ import { createServer as createTlsServer } from "node:https";
 import { createHash, timingSafeEqual } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
-import { extname } from "node:path";
 import { log, logError, logDebug, logWarn } from "../../util/log.js";
 import { formatFingerprint, type BridgeTlsIdentity } from "./tls.js";
+import { contentTypeFor } from "./media.js";
 import { type BridgeEvent } from "./protocol.js";
 import { buildRoutes } from "./routes/index.js";
 import type { BridgeServerHandlers, RouteHost } from "./routes/host.js";
@@ -38,7 +38,7 @@ import {
   type RouteHandler,
 } from "./routes/table.js";
 
-export type { BridgeServerHandlers } from "./routes/host.js";
+export type { BridgeServerHandlers, SendOptions } from "./routes/host.js";
 export { BRIDGE_ROUTE_AUTH, type BridgeRouteKey } from "./routes/table.js";
 
 const SSE_PING_MS = 25_000;
@@ -352,7 +352,6 @@ export class BridgeServer {
       fingerprint: () => this.getFingerprint(),
       json: (res, code, body) => this.json(res, code, body),
       readJson: (req) => this.readJson(req),
-      readRaw: (req, max) => this.readRaw(req, max),
       corsHeaders: () => this.corsHeaders(),
       streamFile: (res, file) => this.streamFile(res, file),
       serveMedia: (res, id) => this.serveMedia(res, id),
@@ -591,17 +590,6 @@ export class BridgeServer {
   }
 
   /** Read a raw request body (binary-safe) up to `max` bytes. */
-  private async readRaw(req: IncomingMessage, max: number): Promise<Buffer> {
-    const chunks: Buffer[] = [];
-    let total = 0;
-    for await (const chunk of req) {
-      total += (chunk as Buffer).length;
-      if (total > max) throw new Error("Upload too large");
-      chunks.push(chunk as Buffer);
-    }
-    return Buffer.concat(chunks);
-  }
-
   private async readJson(
     req: IncomingMessage,
   ): Promise<Record<string, unknown>> {
@@ -621,24 +609,3 @@ export class BridgeServer {
     return parsed as Record<string, unknown>;
   }
 }
-
-/** Minimal image content-type map for the media endpoint. */
-function contentTypeFor(filePath: string): string {
-  switch (extname(filePath).toLowerCase()) {
-    case ".png":
-      return "image/png";
-    case ".jpg":
-    case ".jpeg":
-      return "image/jpeg";
-    case ".gif":
-      return "image/gif";
-    case ".webp":
-      return "image/webp";
-    case ".bmp":
-      return "image/bmp";
-    case ".svg":
-      return "image/svg+xml";
-    default:
-      return "application/octet-stream";
-  }
-}