talon-agent 3.22.1 → 3.23.1

package/bin/talon.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
-import("tsx").then(() => import("../src/cli.ts")).catch((err) => {
-  console.error("Failed to start Talon:", err.message);
-  process.exit(1);
-});
+(process.versions.bun ? Promise.resolve() : import("tsx"))
+  .then(() => import("../src/cli.ts"))
+  .catch((err) => {
+    console.error("Failed to start Talon:", err.message);
+    process.exit(1);
+  });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.22.1",
+  "version": "3.23.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -55,10 +55,13 @@
     "tsconfig.json"
   ],
   "scripts": {
-    "start": "tsx src/index.ts",
-    "cli": "tsx src/cli.ts",
-    "setup": "tsx src/cli.ts setup",
-    "dev": "tsx --watch src/index.ts",
+    "start": "bun src/index.ts",
+    "start:node": "tsx src/index.ts",
+    "cli": "bun src/cli.ts",
+    "cli:node": "tsx src/cli.ts",
+    "setup": "bun src/cli.ts setup",
+    "dev": "bun --watch src/index.ts",
+    "dev:node": "tsx --watch src/index.ts",
     "test": "vitest run",
     "test:ci": "vitest run --reporter=verbose --reporter=json --outputFile=test-results.json",
     "test:functional": "vitest run --reporter=verbose --reporter=json --outputFile=functional-results.json src/__tests__/package.functional.test.ts src/__tests__/tool-functional.test.ts src/__tests__/mcp-launcher.test.ts src/__tests__/mcp-launcher-functional.test.ts src/__tests__/integration/sdk-stub.test.ts src/__tests__/integration/talon-functional.test.ts",

package/src/backend/codex/discovery.ts

@@ -90,7 +90,14 @@ interface CodexCacheFile {
 
 /** Where the Codex CLI writes its model cache. Exported for tests. */
 export function getCodexCachePath(): string {
-  return join(homedir(), ".codex", "models_cache.json");
+  // Honor CODEX_HOME like token-usage.ts and plan-usage.ts do — the CLI
+  // itself relocates with it, so a pinned deployment would otherwise
+  // read a cache the CLI never writes. (Also what lets tests fake the
+  // path under bun, whose os.homedir() ignores $HOME.)
+  const home = process.env.CODEX_HOME?.trim();
+  return home && home.length > 0
+    ? join(home, "models_cache.json")
+    : join(homedir(), ".codex", "models_cache.json");
 }
 
 /** Default soft timeout when callers await an in-flight discovery. */

package/src/core/daemon/control.ts

@@ -14,6 +14,7 @@
 
 import { spawn } from "node:child_process";
 import { dirname, resolve } from "node:path";
+import { isBunRuntime } from "../../util/runtime.js";
 import {
   readPidRecord,
   writePidRecord,
@@ -93,13 +94,18 @@ export async function startDaemon(opts: {
   // Compiled binaries: re-invoke `process.execPath` with no extra args.
   // The binary's own entrypoint (src/index.ts, embedded) handles the
   // server startup the same way a tsx run would.
+  //
+  // Bun source runs need no loader at all — bun executes the TS entry
+  // directly, so a bun-launched CLI spawns a bun daemon.
   const spawnCmd = process.execPath;
   const spawnArgs = isBunBinary
     ? []
-    : [
-        resolve(opts.pkgRoot, "node_modules", "tsx", "dist", "cli.mjs"),
-        resolve(opts.pkgRoot, "src", "index.ts"),
-      ];
+    : isBunRuntime()
+      ? [resolve(opts.pkgRoot, "src", "index.ts")]
+      : [
+          resolve(opts.pkgRoot, "node_modules", "tsx", "dist", "cli.mjs"),
+          resolve(opts.pkgRoot, "src", "index.ts"),
+        ];
   const spawnCwd = isBunBinary ? dirname(process.execPath) : opts.pkgRoot;
 
   let child;

package/src/core/engine/gateway.ts

@@ -596,16 +596,28 @@ export class Gateway {
         resolve();
         return;
       }
-      this.server.close(() => {
+      const server = this.server;
+      const settle = (): void => {
         this.server = null;
         this.port = 0;
         resolve();
+      };
+      // Bun's closeAllConnections() (≤1.3.x) doesn't sever live SSE
+      // streams, so close()'s callback can never fire there and stop()
+      // would hang shutdown (and every test teardown). Resolve on a
+      // deadline either way: by then no new connections are accepted,
+      // and the process this runs in is exiting anyway.
+      const deadline = setTimeout(settle, 2_000);
+      deadline.unref?.();
+      server.close(() => {
+        clearTimeout(deadline);
+        settle();
       });
       // `close()` only stops NEW connections; MCP hub sessions hold
       // long-lived SSE streams that would keep the close callback from
       // ever firing. Terminate them — everything on this server is
       // localhost request/response or SSE, safe to drop at stop time.
-      this.server.closeAllConnections();
+      server.closeAllConnections();
     });
   }
 }

package/src/core/plugin/mcp.ts

@@ -6,6 +6,7 @@
 
 import { resolve } from "node:path";
 import { wrapMcpServer } from "../../util/mcp-launcher.js";
+import { isBunRuntime } from "../../util/runtime.js";
 import { registry, reloadState } from "./registry.js";
 import type { McpServerConfig } from "./types.js";
 
@@ -60,11 +61,16 @@ export function getPluginMcpServers(
         env: baseEnv,
       });
     } else if (plugin.mcpServerPath) {
-      // Existing Node/tsx pattern
+      // TS server entry: bun runs it directly; node needs the tsx loader.
       servers[`${plugin.name}-tools`] = wrapMcpServer({
-        command: process.platform === "win32" ? "npx" : "node",
-        args:
-          process.platform === "win32"
+        command: isBunRuntime()
+          ? process.execPath
+          : process.platform === "win32"
+            ? "npx"
+            : "node",
+        args: isBunRuntime()
+          ? [plugin.mcpServerPath]
+          : process.platform === "win32"
             ? ["tsx", plugin.mcpServerPath]
             : ["--import", tsxPath, plugin.mcpServerPath],
         env: baseEnv,

package/src/core/tools/bridge.ts

@@ -6,6 +6,7 @@
  */
 
 import { Agent, fetch as undiciFetch } from "undici";
+import { isBunRuntime } from "../../util/runtime.js";
 import type { BridgeFunction } from "./types.js";
 
 /** Default wall-clock budget for a bridge action. */
@@ -95,8 +96,13 @@ export function createBridge(
       json(): Promise<unknown>;
     };
     try {
+      // Bun has no 300s header watchdog and aliases the npm undici
+      // module to its own internals (so the Agent knobs do nothing
+      // there anyway) — its global fetch serves long-haul calls fine,
+      // governed by the AbortSignal alone. The undici detour is a
+      // Node-only workaround.
       resp =
-        timeoutMs > BUILTIN_FETCH_HEADERS_CEILING_MS
+        timeoutMs > BUILTIN_FETCH_HEADERS_CEILING_MS && !isBunRuntime()
           ? await undiciFetch(`${bridgeUrl}/action`, {
               ...init,
               dispatcher: dispatcher(),

package/src/core/tools/mcp-env.ts

@@ -18,6 +18,7 @@
 
 import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { isBunRuntime } from "../../util/runtime.js";
 
 // ── Env-var names (shared constants, not stringly-typed call sites) ────────
 
@@ -76,6 +77,11 @@ export function buildTalonMcpEnv(
  */
 export function talonMcpServerCommand(): string[] {
   const here = dirname(fileURLToPath(import.meta.url));
+  // Bun executes the TS entry natively — no loader, and use the running
+  // bun binary itself so the child matches the daemon's runtime.
+  if (isBunRuntime()) {
+    return [process.execPath, resolve(here, "mcp-server.ts")];
+  }
   const tsxImport = pathToFileURL(
     resolve(here, "../../../node_modules/tsx/dist/esm/index.mjs"),
   ).href;

package/src/frontend/native/index.ts

@@ -16,6 +16,7 @@
  */
 
 import type { TalonConfig } from "../../util/config.js";
+import { isBunRuntime } from "../../util/runtime.js";
 import type { ContextManager } from "../../core/types.js";
 import type { Gateway } from "../../core/engine/gateway.js";
 import { mkdir, writeFile } from "node:fs/promises";
@@ -983,11 +984,13 @@ export function createNativeFrontend(
     const cmd = process.execPath;
     const args = isBunBinary
       ? ["restart"]
-      : [
-          resolve(PKG_ROOT, "node_modules", "tsx", "dist", "cli.mjs"),
-          resolve(PKG_ROOT, "src", "cli.ts"),
-          "restart",
-        ];
+      : isBunRuntime()
+        ? [resolve(PKG_ROOT, "src", "cli.ts"), "restart"]
+        : [
+            resolve(PKG_ROOT, "node_modules", "tsx", "dist", "cli.mjs"),
+            resolve(PKG_ROOT, "src", "cli.ts"),
+            "restart",
+          ];
     const cwd = isBunBinary ? dirname(process.execPath) : PKG_ROOT;
     const child = spawn(cmd, args, {
       cwd,

package/src/util/runtime.ts

@@ -0,0 +1,20 @@
+/**
+ * Runtime detection for source runs.
+ *
+ * Talon source runs work on two runtimes: Node (which needs the tsx
+ * CLI/loader to execute `.ts` entrypoints) and Bun (which executes
+ * TypeScript natively). Every place that re-invokes a TS entrypoint in
+ * a child process — the daemon spawn, the restart handoff, MCP server
+ * commands — branches on this instead of hardcoding the tsx recipe, so
+ * `bun src/cli.ts start` yields a bun daemon with bun children while
+ * node+tsx runs stay byte-identical to before.
+ *
+ * Bun-COMPILED binaries are a third shape detected separately (argv[1]
+ * points into the embedded virtual fs) — see the existing `$bunfs`
+ * checks at the spawn sites and in `util/mcp-launcher.ts`.
+ */
+
+/** True when the current process is executing under the Bun runtime. */
+export function isBunRuntime(): boolean {
+  return typeof process.versions.bun === "string";
+}