talon-agent 3.33.3 → 3.34.0

package/src/core/engine/gateway.ts

@@ -8,11 +8,7 @@
  * No platform-specific imports — frontends register their handler at startup.
  */
 
-import {
-  createServer,
-  type IncomingMessage,
-  type ServerResponse,
-} from "node:http";
+import { createServer } from "node:http";
 import pRetry, { AbortError } from "p-retry";
 import { classify } from "../errors.js";
 import { getActiveCount } from "./dispatcher.js";
@@ -26,14 +22,13 @@ import {
   isChatFreeAction,
 } from "./gateway-actions/index.js";
 import { registerCrossSendTarget } from "./gateway-actions/cross-send.js";
+import { getHubSessionCount } from "../mcp-hub/index.js";
 import {
-  handleHubRequest,
-  getHubSessionCount,
-  HUB_PATH_PREFIX,
-} from "../mcp-hub/index.js";
+  dispatchGatewayRoute,
+  listenWithRetry,
+  type GatewayRouteHost,
+} from "./gateway-routes.js";
 import { handlePluginAction } from "../plugin/index.js";
-import { bus } from "../bus/index.js";
-import { taskTable } from "../tasks/index.js";
 import type { FrontendActionHandler } from "../types.js";
 import { BOT_MESSAGE_ACTIONS, noteBotMessage } from "../soul/taps.js";
 import type { Backend } from "../agent-runtime/capabilities.js";
@@ -362,236 +357,69 @@ export class Gateway {
 
   async start(port = 19876): Promise<number> {
     if (this.server) return this.port;
-
-    const httpServer = createServer(
-      async (req: IncomingMessage, res: ServerResponse) => {
-        if (req.method === "GET" && req.url === "/health") {
-          const w = getHealthStatus();
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(
-            JSON.stringify({
-              // Identity fields — daemon discovery matches on these to
-              // distinguish a Talon daemon from chat sessions and
-              // unrelated localhost services.
-              app: "talon",
-              mode: this.mode,
-              pid: process.pid,
-              port: this.port,
-              startedAt: this.startedAt,
-              ok: w.healthy,
-              uptime: Math.round(process.uptime()),
-              memory: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
-              bridge: {
-                activeChats: this.loom.activeContextCount(),
-                threads: this.loom.size(),
-                hubSessions: getHubSessionCount(),
-              },
-              queue: getActiveCount(),
-              sessions: getActiveSessionCount(),
-              messages: w.totalMessagesProcessed,
-              errors: w.recentErrorCount,
-              lastActivity:
-                w.msSinceLastMessage < 60000
-                  ? "just now"
-                  : `${Math.round(w.msSinceLastMessage / 60000)}m ago`,
-            }),
-          );
-          return;
-        }
-
-        if (req.method === "POST" && req.url === "/shutdown") {
-          // Graceful stop for `talon stop`/`talon restart`. Bound to
-          // 127.0.0.1 like everything else here. Respond before
-          // triggering so the client isn't cut off mid-request; the
-          // shutdown path takes seconds, so the reply flushes safely.
-          if (!this.shutdownHandler) {
-            res.writeHead(501, { "Content-Type": "application/json" });
-            res.end(
-              JSON.stringify({
-                ok: false,
-                error: "Shutdown not supported by this process",
-              }),
-            );
-            return;
-          }
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: true }));
-          const handler = this.shutdownHandler;
-          setImmediate(() => handler("gateway /shutdown"));
-          return;
-        }
-
-        if (req.method === "GET" && req.url?.startsWith("/events/recent")) {
-          // Bus tail — recent events, optionally after a cursor. Read by
-          // `talon events`. Same 127.0.0.1 trust boundary as /action.
-          const url = new URL(req.url, "http://gateway");
-          const since = Number(url.searchParams.get("since") ?? "0");
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(
-            JSON.stringify({
-              ok: true,
-              events: bus.recent(
-                Number.isInteger(since) && since > 0 ? since : 0,
-              ),
-            }),
-          );
-          return;
-        }
-
-        if (req.method === "GET" && req.url === "/tasks") {
-          // The task table — every live/recent unit of agent work. Read by
-          // `talon ps`. Same 127.0.0.1 trust boundary as /action.
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: true, tasks: taskTable.list() }));
-          return;
-        }
-
-        if (req.method === "POST" && req.url === "/tasks/kill") {
-          // Abort one killable task by id — the transport for `talon kill`.
-          const chunks: Buffer[] = [];
-          for await (const chunk of req) chunks.push(chunk as Buffer);
-          let id: unknown;
-          try {
-            const body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
-            id = (body as { id?: unknown }).id;
-          } catch {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: false, error: "Invalid JSON" }));
-            return;
-          }
-          if (typeof id !== "number" || !Number.isInteger(id)) {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(
-              JSON.stringify({ ok: false, error: "id must be an integer" }),
-            );
-            return;
-          }
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(taskTable.kill(id)));
-          return;
-        }
-
-        if (req.method === "POST" && req.url === "/plugins/reload") {
-          // Hot-reload plugins from config — the transport for
-          // `talon plugin install/enable/disable`, which has no chat
-          // context and so cannot use the reload_plugins action. Same
-          // 127.0.0.1 trust boundary as /action.
-          try {
-            const { performPluginReload } =
-              await import("./gateway-actions/plugins.js");
-            const { names } = await performPluginReload(this.backend);
-            log("gateway", `/plugins/reload: ${names.length} plugins loaded`);
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: true, loaded: names }));
-          } catch (err) {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(
-              JSON.stringify({
-                ok: false,
-                error: `Plugin reload failed: ${err instanceof Error ? err.message : err}`,
-              }),
-            );
-          }
-          return;
-        }
-
-        if (req.url?.startsWith(HUB_PATH_PREFIX)) {
-          // MCP hub — daemon-hosted MCP-over-HTTP endpoints for every
-          // backend (see core/mcp-hub). Same 127.0.0.1 trust boundary
-          // as /action.
-          await handleHubRequest(req, res, `http://127.0.0.1:${this.port}`);
-          return;
-        }
-
-        if (req.method !== "POST" || req.url !== "/action") {
-          res.writeHead(404);
-          res.end("Not found");
-          return;
-        }
-
-        try {
-          const chunks: Buffer[] = [];
-          for await (const chunk of req) chunks.push(chunk as Buffer);
-          let body: Record<string, unknown>;
-          try {
-            body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
-          } catch {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: false, error: "Invalid JSON" }));
-            return;
-          }
-          const result = await this.handleAction(body);
-          const json = JSON.stringify(result);
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(json);
-        } catch (err) {
-          if (res.headersSent) return;
-          // Log full error (incl. stack via logError's structured `stack`
-          // field) on the server; return a generic message to the client so
-          // we don't leak implementation details.
-          // CodeQL: js/stack-trace-exposure (alert #4).
-          logError(
-            "gateway",
-            `Unhandled error on ${req.method} ${req.url}`,
-            err,
-          );
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(
-            JSON.stringify({ ok: false, error: "Internal server error" }),
-          );
-        }
+    const host: GatewayRouteHost = {
+      healthSnapshot: () => this.healthSnapshot(),
+      requestShutdown: () => {
+        const handler = this.shutdownHandler;
+        if (!handler) return false;
+        setImmediate(() => handler("gateway /shutdown"));
+        return true;
       },
+      reloadPlugins: async () => {
+        const { performPluginReload } =
+          await import("./gateway-actions/plugins.js");
+        return (await performPluginReload(this.backend)).names;
+      },
+      hubOrigin: () => `http://127.0.0.1:${this.port}`,
+      handleAction: (body) => this.handleAction(body),
+    };
+    const httpServer = createServer(
+      (req, res) => void dispatchGatewayRoute(req, res, host),
     );
+    const bound = await listenWithRetry(httpServer, port);
+    this.server = httpServer;
+    this.port = bound;
+    log("gateway", `Action gateway on :${this.port}`);
+    for (const cb of this.startedListeners.splice(0)) {
+      try {
+        cb(this.port);
+      } catch (err) {
+        logError("gateway", "onStarted listener failed", err);
+      }
+    }
+    return this.port;
+  }
 
-    return new Promise<number>((resolve, reject) => {
-      let attempt = 0;
-      const tryPort = (p: number) => {
-        httpServer.once("error", (err: NodeJS.ErrnoException) => {
-          if (err.code === "EADDRINUSE" && attempt < 5) {
-            attempt++;
-            httpServer.removeAllListeners("error");
-            // The failed listen() left its one-shot 'listening' success
-            // callback registered (Node attaches it via once('listening')).
-            // Drop it before retrying — otherwise every stale callback also
-            // fires when a later port finally binds, running the startup body
-            // (and logging "Action gateway on :…") once per attempted port.
-            httpServer.removeAllListeners("listening");
-            tryPort(p + 1);
-          } else {
-            reject(err);
-          }
-        });
-        httpServer.listen(p, "127.0.0.1", () => {
-          this.server = httpServer;
-          // When the caller asks for port 0 the OS assigns a random free
-          // port — read the actual port off the listening socket instead
-          // of saving the requested 0.
-          const addr = httpServer.address();
-          this.port =
-            typeof addr === "object" && addr !== null
-              ? (addr as { port: number }).port
-              : p;
-          log("gateway", `Action gateway on :${this.port}`);
-          // Replace the one-shot startup error listener with a persistent
-          // handler. Without this, once the `once("error")` from port-binding
-          // fires (and auto-removes itself), any subsequent server-level error
-          // has no listener and crashes the process via uncaught 'error' event.
-          httpServer.removeAllListeners("error");
-          httpServer.on("error", (err) =>
-            logError("gateway", "HTTP server error", err),
-          );
-          for (const cb of this.startedListeners.splice(0)) {
-            try {
-              cb(this.port);
-            } catch (err) {
-              logError("gateway", "onStarted listener failed", err);
-            }
-          }
-          resolve(this.port);
-        });
-      };
-      tryPort(port);
-    });
+  /**
+   * The /health body. Identity fields first — daemon discovery matches on
+   * them to tell a Talon daemon from chat sessions and unrelated localhost
+   * services — then live counters.
+   */
+  private healthSnapshot(): Record<string, unknown> {
+    const w = getHealthStatus();
+    return {
+      app: "talon",
+      mode: this.mode,
+      pid: process.pid,
+      port: this.port,
+      startedAt: this.startedAt,
+      ok: w.healthy,
+      uptime: Math.round(process.uptime()),
+      memory: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+      bridge: {
+        activeChats: this.loom.activeContextCount(),
+        threads: this.loom.size(),
+        hubSessions: getHubSessionCount(),
+      },
+      queue: getActiveCount(),
+      sessions: getActiveSessionCount(),
+      messages: w.totalMessagesProcessed,
+      errors: w.recentErrorCount,
+      lastActivity:
+        w.msSinceLastMessage < 60000
+          ? "just now"
+          : `${Math.round(w.msSinceLastMessage / 60000)}m ago`,
+    };
   }
 
   async stop(): Promise<void> {

package/src/core/vfs/mounts/files.ts

@@ -20,134 +20,147 @@ import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import type { VfsMount, VfsResult, VfsStat } from "../types.js";
 import { VFS_MAX_READ_BYTES, vfsError, vfsOk } from "../types.js";
 
-export function createFileMount(options: {
+type FileMountOptions = {
   root: string;
   description: string;
   writable: boolean;
-}): VfsMount {
-  const root = resolve(options.root);
+};
 
-  /** Absolute path for `rel`, or undefined when it would escape the root. */
-  function realPath(rel: string): string | undefined {
-    const abs = resolve(root, ...rel.split("/"));
-    const offset = relative(root, abs);
-    if (
-      offset.startsWith(`..${sep}`) ||
-      offset === ".." ||
-      isAbsolute(offset)
-    ) {
-      return undefined;
-    }
-    return abs;
+/** Absolute path for `rel` under `root`, or undefined when it would escape. */
+function realPath(root: string, rel: string): string | undefined {
+  const abs = resolve(root, ...rel.split("/"));
+  const offset = relative(root, abs);
+  if (offset.startsWith(`..${sep}`) || offset === ".." || isAbsolute(offset)) {
+    return undefined;
   }
+  return abs;
+}
 
-  function statAt(rel: string, abs: string): VfsResult<VfsStat> {
-    try {
-      const stats = statSync(abs);
-      const name = rel === "" ? "" : rel.split("/").at(-1)!;
-      return vfsOk({
-        path: rel,
-        name,
-        kind: stats.isDirectory() ? ("dir" as const) : ("file" as const),
-        ...(stats.isFile() ? { size: stats.size } : {}),
-        modifiedAt: Math.floor(stats.mtimeMs),
-        writable: options.writable,
-        osPath: abs,
-      });
-    } catch {
-      return vfsError("not-found");
-    }
+function statAt(
+  rel: string,
+  abs: string,
+  writable: boolean,
+): VfsResult<VfsStat> {
+  try {
+    const stats = statSync(abs);
+    const name = rel === "" ? "" : rel.split("/").at(-1)!;
+    return vfsOk({
+      path: rel,
+      name,
+      kind: stats.isDirectory() ? ("dir" as const) : ("file" as const),
+      ...(stats.isFile() ? { size: stats.size } : {}),
+      modifiedAt: Math.floor(stats.mtimeMs),
+      writable,
+      osPath: abs,
+    });
+  } catch {
+    return vfsError("not-found");
   }
+}
 
-  return {
-    description: options.description,
-    writable: options.writable,
-    osRoot: root,
+function statMount(
+  root: string,
+  writable: boolean,
+  rel: string,
+): VfsResult<VfsStat> {
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  if (rel === "" && !existsSync(abs)) {
+    return vfsOk({ path: "", name: "", kind: "dir", writable, osPath: abs });
+  }
+  return statAt(rel, abs, writable);
+}
 
-    stat(rel) {
-      const abs = realPath(rel);
-      if (!abs) return vfsError("invalid-path");
-      if (rel === "" && !existsSync(abs)) {
-        return vfsOk({
-          path: "",
-          name: "",
-          kind: "dir",
-          writable: options.writable,
-          osPath: abs,
-        });
-      }
-      return statAt(rel, abs);
-    },
+function listMount(
+  root: string,
+  writable: boolean,
+  rel: string,
+): VfsResult<VfsStat[]> {
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  if (rel === "" && !existsSync(abs)) return vfsOk([]);
+  let stats;
+  try {
+    stats = statSync(abs);
+  } catch {
+    return vfsError("not-found");
+  }
+  if (!stats.isDirectory()) return vfsError("not-a-directory");
+  const entries = readdirSync(abs, { withFileTypes: true })
+    .map((entry) => {
+      const childRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
+      const child = statAt(childRel, resolve(abs, entry.name), writable);
+      return child.ok ? child.value : undefined;
+    })
+    .filter((entry): entry is VfsStat => entry !== undefined)
+    .sort(
+      (a, b) =>
+        Number(a.kind === "file") - Number(b.kind === "file") ||
+        a.name.localeCompare(b.name),
+    );
+  return vfsOk(entries);
+}
 
-    list(rel) {
-      const abs = realPath(rel);
-      if (!abs) return vfsError("invalid-path");
-      if (rel === "" && !existsSync(abs)) return vfsOk([]);
-      let stats;
-      try {
-        stats = statSync(abs);
-      } catch {
-        return vfsError("not-found");
-      }
-      if (!stats.isDirectory()) return vfsError("not-a-directory");
-      const entries = readdirSync(abs, { withFileTypes: true })
-        .map((entry) => {
-          const childRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
-          const child = statAt(childRel, resolve(abs, entry.name));
-          return child.ok ? child.value : undefined;
-        })
-        .filter((entry): entry is VfsStat => entry !== undefined)
-        .sort(
-          (a, b) =>
-            Number(a.kind === "file") - Number(b.kind === "file") ||
-            a.name.localeCompare(b.name),
-        );
-      return vfsOk(entries);
-    },
+function readMount(root: string, rel: string): VfsResult<string> {
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  let stats;
+  try {
+    stats = statSync(abs);
+  } catch {
+    return vfsError("not-found");
+  }
+  if (stats.isDirectory()) return vfsError("is-a-directory");
+  if (stats.size > VFS_MAX_READ_BYTES) {
+    return vfsError(
+      "too-large",
+      `${stats.size} bytes (cap ${VFS_MAX_READ_BYTES}) — on disk at ${abs}`,
+    );
+  }
+  const buffer = readFileSync(abs);
+  if (buffer.includes(0)) {
+    return vfsError("binary-file", "Content contains null bytes");
+  }
+  return vfsOk(buffer.toString("utf-8"));
+}
 
-    read(rel) {
-      const abs = realPath(rel);
-      if (!abs) return vfsError("invalid-path");
-      let stats;
-      try {
-        stats = statSync(abs);
-      } catch {
-        return vfsError("not-found");
-      }
-      if (stats.isDirectory()) return vfsError("is-a-directory");
-      if (stats.size > VFS_MAX_READ_BYTES) {
-        return vfsError(
-          "too-large",
-          `${stats.size} bytes (cap ${VFS_MAX_READ_BYTES}) — on disk at ${abs}`,
-        );
-      }
-      const buffer = readFileSync(abs);
-      if (buffer.includes(0)) {
-        return vfsError("binary-file", "Content contains null bytes");
-      }
-      return vfsOk(buffer.toString("utf-8"));
-    },
+function writeMount(
+  root: string,
+  rel: string,
+  content: string,
+): VfsResult<VfsStat> {
+  if (rel === "") return vfsError("is-a-directory");
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  if (existsSync(abs) && statSync(abs).isDirectory()) {
+    return vfsError("is-a-directory");
+  }
+  try {
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, content, "utf-8");
+  } catch (err) {
+    return vfsError(
+      "io-error",
+      err instanceof Error ? err.message : String(err),
+    );
+  }
+  return statAt(rel, abs, true);
+}
 
-    ...(options.writable
+export function createFileMount(options: FileMountOptions): VfsMount {
+  const root = resolve(options.root);
+  const { writable } = options;
+  return {
+    description: options.description,
+    writable,
+    osRoot: root,
+    stat: (rel) => statMount(root, writable, rel),
+    list: (rel) => listMount(root, writable, rel),
+    read: (rel) => readMount(root, rel),
+    ...(writable
       ? {
-          write(rel: string, content: string): VfsResult<VfsStat> {
-            if (rel === "") return vfsError("is-a-directory");
-            const abs = realPath(rel);
-            if (!abs) return vfsError("invalid-path");
-            if (existsSync(abs) && statSync(abs).isDirectory()) {
-              return vfsError("is-a-directory");
-            }
-            try {
-              mkdirSync(dirname(abs), { recursive: true });
-              writeFileSync(abs, content, "utf-8");
-            } catch (err) {
-              return vfsError(
-                "io-error",
-                err instanceof Error ? err.message : String(err),
-              );
-            }
-            return statAt(rel, abs);
-          },
+          write: (rel: string, content: string) =>
+            writeMount(root, rel, content),
         }
       : {}),
   };

package/src/core/weaver/shuttle.ts

@@ -29,6 +29,18 @@ import {
 
 export type EventSink = (event: AgentEvent) => void | Promise<void>;
 
+/**
+ * Wall-clock the shuttle observes while carrying one stream: when the
+ * first event arrived (`undefined` if the stream ended empty) and how many
+ * ms were spent awaiting the frontend's sink in total.
+ */
+export type ShuttleTiming = {
+  firstEventAt?: number;
+  deliveryMs: number;
+};
+
+export const startShuttleTiming = (): ShuttleTiming => ({ deliveryMs: 0 });
+
 /**
  * Pump the stream to completion. Returns the `completed` event's
  * result (if the backend emitted one); throws `AgentRunError` when the
@@ -37,16 +49,31 @@ export type EventSink = (event: AgentEvent) => void | Promise<void>;
 export async function carryTurnEvents(
   stream: AsyncIterable<AgentEvent>,
   onEvent?: EventSink,
+  timing?: ShuttleTiming,
 ): Promise<AgentResult | undefined> {
   let agentResult: AgentResult | undefined;
+  const sink: EventSink | undefined =
+    onEvent && timing
+      ? async (event) => {
+          const t0 = Date.now();
+          try {
+            await onEvent(event);
+          } finally {
+            timing.deliveryMs += Date.now() - t0;
+          }
+        }
+      : onEvent;
   for await (const event of stream) {
+    if (timing && timing.firstEventAt === undefined) {
+      timing.firstEventAt = Date.now();
+    }
     if (event.type === "completed") {
       agentResult = event.result;
     }
 
     if (event.type === "assistant_message" && event.deliveryAck) {
       try {
-        await onEvent?.(event);
+        await sink?.(event);
         event.deliveryAck.resolve();
       } catch (err) {
         event.deliveryAck.reject(err);
@@ -54,7 +81,7 @@ export async function carryTurnEvents(
       continue;
     }
 
-    await onEvent?.(event);
+    await sink?.(event);
     if (event.type === "error") {
       throw new AgentRunError(event.error);
     }