talon-agent 3.36.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.36.0",
+  "version": "4.0.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/core/plugin/mcp.ts

@@ -5,6 +5,7 @@
  */
 
 import { resolve } from "node:path";
+import { logWarn } from "../../util/log.js";
 import { wrapMcpServer } from "../../util/mcp-launcher.js";
 import { isBunRuntime } from "../../util/runtime.js";
 import { registry, reloadState } from "./registry.js";
@@ -51,6 +52,18 @@ export function getPluginMcpServers(
   for (const { plugin, envVars } of registry.all) {
     // Skip plugins not in the allow-list when filtering
     if (only !== undefined && !only.includes(plugin.name)) continue;
+
+    // Let the plugin re-materialize on-disk state the child will read. Runs
+    // on every build so a deleted file heals within a turn; never fatal.
+    try {
+      if (plugin.mcpServer || plugin.mcpServerPath) plugin.prepareMcpSpawn?.();
+    } catch (err) {
+      logWarn(
+        "plugin",
+        `${plugin.name}: prepareMcpSpawn failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
     const baseEnv = buildBridgeEnv(bridgeUrl, chatId, envVars);
 
     if (plugin.mcpServer) {

package/src/core/plugin/registry.ts

@@ -119,6 +119,17 @@ export const _deps = {
     // dynamic import() rejects bare drive-letter paths (e.g. C:\...).
     // Leave node: specifiers, relative paths, and URLs unchanged.
     const isAbsFilePath = /^[a-zA-Z]:[/\\]/.test(path) || path.startsWith("/");
-    return import(isAbsFilePath ? pathToFileURL(path).href : path);
+    if (!isAbsFilePath) return import(path);
+
+    // Cache-bust with the reload timestamp. ESM caches modules by resolved
+    // URL forever, so without a changing query a hot reload re-imports the
+    // *old* module object and the plugin's own source edits are invisible
+    // until a full restart — silently, since the stale module still loads
+    // fine (observed 2026-09-16: a rewritten plugin kept reporting its
+    // previous version through three reloads). The timestamp only moves per
+    // reload, so every module in one load cycle shares a key.
+    const url = pathToFileURL(path);
+    url.searchParams.set("talonReloadAt", reloadState.lastReloadAt);
+    return import(url.href);
   },
 };

package/src/core/plugin/types.ts

@@ -85,6 +85,18 @@ export interface TalonPlugin {
     readonly args: readonly string[];
   };
 
+  /**
+   * Materialize anything the MCP child needs on disk before it is spawned.
+   *
+   * MCP children are spawned lazily and respawned on demand for the lifetime
+   * of the daemon, so state written once at load time can go missing long
+   * before the last spawn. This hook runs every time the MCP server map is
+   * built, making such state self-healing instead of broken-until-restart.
+   * Must be synchronous, cheap, and idempotent; throwing is swallowed and
+   * logged (a failed prepare must not take the whole server map down).
+   */
+  prepareMcpSpawn?(): void;
+
   /**
    * Map plugin config to env vars for the MCP subprocess and action handlers.
    * Called once at load time. Values are set on process.env for the main

package/src/core/weaver/typing-loop.ts

@@ -10,6 +10,16 @@ import { logWarn } from "../../util/log.js";
 /** Platforms expire typing indicators after ~5s; refresh under that. */
 const TYPING_REFRESH_MS = 4000;
 
+/**
+ * Consecutive failures after which the loop gives up for the rest of the
+ * turn. A chat that has gone away (deleted, kicked, migrated) fails every
+ * single refresh, and a long turn then logs one warning every 4 seconds for
+ * a cosmetic indicator — 55 of them in 30 seconds on 2026-09-15, all
+ * "sendChatAction failed (400: chat not found)". Three strikes is enough to
+ * tell a transient blip from a chat that is simply gone.
+ */
+const MAX_CONSECUTIVE_FAILURES = 3;
+
 export type SendTyping = (
   numericChatId: number,
   stringId?: string,
@@ -22,15 +32,36 @@ export function startTypingLoop(
   stringId: string,
   intervalMs = TYPING_REFRESH_MS,
 ): () => void {
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let consecutiveFailures = 0;
+
+  const stop = () => {
+    if (timer !== undefined) clearInterval(timer);
+    timer = undefined;
+  };
+
   const send = (label: string) => {
-    sendTyping(numericChatId, stringId).catch((err: unknown) => {
-      logWarn(
-        "dispatcher",
-        `${label} failed: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    });
+    sendTyping(numericChatId, stringId).then(
+      () => {
+        consecutiveFailures = 0;
+      },
+      (err: unknown) => {
+        consecutiveFailures++;
+        const reason = err instanceof Error ? err.message : String(err);
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          stop();
+          logWarn(
+            "dispatcher",
+            `${label} failed ${consecutiveFailures}x in a row — no typing indicator for the rest of this turn: ${reason}`,
+          );
+          return;
+        }
+        logWarn("dispatcher", `${label} failed: ${reason}`);
+      },
+    );
   };
+
   send("sendTyping");
-  const timer = setInterval(() => send("sendTyping interval"), intervalMs);
-  return () => clearInterval(timer);
+  timer = setInterval(() => send("sendTyping interval"), intervalMs);
+  return stop;
 }

package/src/frontend/native/handlers.ts

@@ -39,6 +39,7 @@ 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 { logWarn } from "../../util/log.js";
 import { interruptTurn, isBusy, liveTurnEvents, startTurn } from "./turn.js";
 
 /**
@@ -58,14 +59,30 @@ function resolveAttachments(
     refs.push({ url: opts.imagePath, path: opts.attachmentPath });
   }
   const resolved: ClientAttachment[] = [];
+  const dropped: string[] = [];
   for (const ref of refs) {
     const found = resolveUpload(runtime, ref);
+    if (!found) {
+      dropped.push(ref.url ?? ref.path ?? "(empty reference)");
+      continue;
+    }
     // Same file referenced twice (a re-send of a queued message, say) stays
     // one attachment.
-    if (found && !resolved.some((a) => a.path === found.path)) {
+    if (!resolved.some((a) => a.path === found.path)) {
       resolved.push(found);
     }
   }
+  // A dropped reference is how "I attached a file and the agent never saw it"
+  // happens, and it used to be entirely silent. The usual cause is a media id
+  // minted by a previous daemon run — `runtime.uploads` is per-run, so a
+  // client that staged a file before a restart and sent it after points at
+  // nothing.
+  if (dropped.length) {
+    logWarn(
+      "native",
+      `dropped ${dropped.length} unknown attachment reference(s) from /send: ${dropped.join(", ")} — re-upload the file (ids do not survive a daemon restart)`,
+    );
+  }
   return resolved;
 }
 

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

@@ -6,6 +6,7 @@ import {
   asString,
   deviceIdParam,
 } from "./params.js";
+import { log, logWarn } from "../../../util/log.js";
 
 export function chatRoutes(
   host: RouteHost,
@@ -110,8 +111,18 @@ export function chatRoutes(
       const filename = url.searchParams.get("filename") ?? "upload";
       const contentType =
         req.headers["content-type"] ?? "application/octet-stream";
+      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 });
@@ -124,6 +135,10 @@ export function chatRoutes(
           : /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 });
       }
     },

package/src/plugins/playwright/index.ts

@@ -30,10 +30,10 @@
  * other.
  */
 
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { tmpdir } from "node:os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import type { TalonPlugin } from "../../core/plugin/types.js";
+import { files } from "../../util/paths.js";
 import { log } from "../../util/log.js";
 
 export function createPlaywrightPlugin(config: {
@@ -66,6 +66,11 @@ export function createPlaywrightPlugin(config: {
 
   const args: string[] = [];
 
+  // Endpoint mode writes a config file the MCP child reads at every spawn;
+  // `writeMcpConfig` is re-run before each spawn via `prepareMcpSpawn` so a
+  // deleted config heals instead of failing every browser tool until restart.
+  let writeMcpConfig: (() => void) | undefined;
+
   if (endpoint) {
     // Connect to the existing browser (e.g. the Camoufox websocket server)
     // via a generated MCP config file: `browser.remoteEndpoint` is the
@@ -79,11 +84,12 @@ export function createPlaywrightPlugin(config: {
         remoteEndpoint: endpoint,
       },
     };
-    const configPath = join(
-      tmpdir(),
-      `talon-playwright-mcp-${process.pid}.json`,
-    );
-    writeFileSync(configPath, JSON.stringify(mcpConfig));
+    const configPath = files.playwrightMcpConfig;
+    writeMcpConfig = () => {
+      mkdirSync(dirname(configPath), { recursive: true });
+      writeFileSync(configPath, JSON.stringify(mcpConfig));
+    };
+    writeMcpConfig();
     args.push("--config", configPath);
   } else {
     args.push("--no-sandbox");
@@ -107,6 +113,10 @@ export function createPlaywrightPlugin(config: {
       args: [mcpBin, ...args],
     },
 
+    prepareMcpSpawn() {
+      writeMcpConfig?.();
+    },
+
     validateConfig() {
       const errors: string[] = [];
 

package/src/util/paths.ts

@@ -162,4 +162,15 @@ export const files = {
    * for what the data means.
    */
   codexOauthIncompat: resolve(TALON_ROOT, "data", "codex-oauth-incompat.json"),
+  /**
+   * Generated @playwright/mcp config (endpoint mode): ~/.talon/data/playwright-mcp.json
+   *
+   * Deliberately NOT in os.tmpdir(): the MCP child re-reads this file on every
+   * spawn, hours or days after the daemon wrote it, and a /tmp sweeper
+   * deleting it takes every browser tool down until the daemon restarts
+   * (2026-09-15: an hourly disk cleaner removed 676 `/tmp/talon-*` entries,
+   * and browser tools failed with ENOENT for the next 24h). The name is
+   * pid-free so each run overwrites the last instead of orphaning a file.
+   */
+  playwrightMcpConfig: resolve(TALON_ROOT, "data", "playwright-mcp.json"),
 } as const;