talon-agent 5.18.2 → 5.19.1

package/src/core/mesh/transfers/device-files.ts

@@ -15,8 +15,6 @@
  */
 
 import { randomUUID } from "node:crypto";
-import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
@@ -29,6 +27,7 @@ import {
   type MeshToolResult,
 } from "../tool-surface.js";
 import {
+  hashFile,
   normalizeGoarch,
   platformToGoos,
   type NodeBinaryResolver,
@@ -70,8 +69,8 @@ const FILE_CHUNK_BYTES = 1024 * 1024;
  * and never throws, and the command result it would have posted afterwards
  * is never posted. The dispatch timeout is the only thing that ends that
  * wait — and since turns serialize per chat, the whole chat's message loop
- * queues behind it. A flat hour therefore takes a chat offline for an hour
- * over one dropped TCP connection.
+ * queues behind it. A flat budget sized for the largest transfer would
+ * take a chat offline that long over one dropped TCP connection.
  *
  * So the budget is sized to the payload instead: a fixed grace for the
  * handshake and device-side setup, plus the body at a deliberately
@@ -83,9 +82,8 @@ const STREAM_TRANSFER_FLOOR_BYTES_PER_SEC = 32 * 1024;
 /**
  * Ceiling, so a payload large enough to out-scale the formula still can't
  * block a chat indefinitely. Deliberately well above what a big transfer
- * over a slow link needs — the common wedge is a SMALL transfer that used
- * to inherit the same budget as a huge one, and that case now resolves in
- * about a minute.
+ * over a slow link needs — the common wedge is a SMALL transfer, and its
+ * budget runs out in about a minute.
  */
 const STREAM_TRANSFER_MAX_MS = 30 * 60 * 1000;
 
@@ -745,19 +743,3 @@ function transferRate(bytes: number, startedAtMs: number): string {
   const seconds = Math.max((Date.now() - startedAtMs) / 1000, 0.001);
   return `${formatBytes(bytes / seconds)}/s over ${seconds < 10 ? seconds.toFixed(1) : Math.round(seconds)}s`;
 }
-
-/** Stream a file through SHA-256 without loading it into memory (APKs are big
- *  and Buffer has a hard ceiling). Returns the hex digest and byte size. */
-async function hashFile(
-  path: string,
-): Promise<{ sha256: string; size: number }> {
-  const { size } = await stat(path);
-  const hash = createHash("sha256");
-  await new Promise<void>((resolve, reject) => {
-    createReadStream(path)
-      .on("data", (chunk) => hash.update(chunk))
-      .on("end", () => resolve())
-      .on("error", reject);
-  });
-  return { sha256: hash.digest("hex"), size };
-}

package/src/core/mesh/transfers/transfers.ts

@@ -55,6 +55,8 @@ type Transfer = {
     resolve: (bytes: number) => void;
     reject: (err: Error) => void;
   };
+  /** pull only — tears down the upload once its HTTP leg is streaming. */
+  abort?: AbortController;
 };
 
 export class TransferStore {
@@ -104,12 +106,19 @@ export class TransferStore {
     return { token };
   }
 
-  /** Drop a token (transfer arrangement failed before the HTTP leg). */
+  /**
+   * Drop a token — the arrangement failed, or the daemon gave up waiting.
+   * An upload already streaming is aborted too: otherwise a peer that
+   * stalls mid-body holds the request (and its temp file) open until the
+   * bridge's whole-request deadline, and one that finishes late renames a
+   * file into place after the caller was told the pull failed.
+   */
   cancel(token: string): void {
     const t = this.transfers.get(token);
     if (t?.uploadDone && !t.consumed) {
       t.uploadDone.reject(new Error("transfer cancelled"));
     }
+    t?.abort?.abort(new Error("transfer cancelled"));
     this.transfers.delete(token);
   }
 
@@ -129,11 +138,16 @@ export class TransferStore {
     if (!t)
       return { ok: false, error: "Unknown or already-used transfer token." };
     const tmp = `${t.localPath}.part-${randomBytes(4).toString("hex")}`;
+    const abort = new AbortController();
+    t.abort = abort;
     try {
       await mkdir(dirname(t.localPath), { recursive: true });
       let bytes = 0;
       body.on("data", (d: Buffer) => (bytes += d.length));
-      await pipeline(body, createWriteStream(tmp, { mode: 0o600 }));
+      await pipeline(body, createWriteStream(tmp, { mode: 0o600 }), {
+        signal: abort.signal,
+      });
+      abort.signal.throwIfAborted();
       await rename(tmp, t.localPath);
       this.transfers.delete(token);
       t.uploadDone?.resolve(bytes);
@@ -162,7 +176,6 @@ export class TransferStore {
       if (!s.isFile()) throw new Error("not a file");
       return { path: t.localPath, size: s.size };
     } catch {
-      this.transfers.delete(token);
       return null;
     } finally {
       // Single-use either way; the device retries by re-arranging.

package/src/core/models/active-model.ts

@@ -60,10 +60,7 @@
  * have their stored override returned verbatim — no way to validate.
  */
 
-import {
-  getChatModelForBackend,
-  getChatSettings,
-} from "../../storage/chat-settings.js";
+import { getChatModelForBackend } from "../../storage/chat-settings.js";
 import type { Backend } from "../agent-runtime/capabilities.js";
 import {
   isBackendId,
@@ -82,7 +79,7 @@ import { logWarn } from "../../util/log.js";
  * (default)" vs "Model: X (override)" vs "No model selected" without
  * second-guessing the chain.
  */
-export type ActiveModelSource =
+type ActiveModelSource =
   | "override-valid"
   | "override-invalid-fallback"
   | "backend-canonical"
@@ -311,25 +308,6 @@ async function safeBackendDefault(backend: Backend): Promise<string | null> {
   }
 }
 
-/**
- * Convenience: same as `resolveActiveModelForChat` but returns just
- * the model id (or `null`). Use when the source tag isn't needed.
- */
-export async function getActiveModelForChat(
-  chatId: string,
-  backend: Backend | null,
-  backendId: string | null,
-  config: TalonConfig,
-): Promise<string | null> {
-  const { model } = await resolveActiveModelForChat(
-    chatId,
-    backend,
-    backendId,
-    config,
-  );
-  return model;
-}
-
 // ── ref enrichment ──────────────────────────────────────────────────────────
 
 /**
@@ -412,34 +390,3 @@ function mapCacheSupport(backend: Backend | null): CacheSupport {
       return "none";
   }
 }
-
-/**
- * Human-readable label for the source — used in toast wording so the
- * user sees *why* the resolved model is what it is. Keeps the wording
- * centralised so the UI stays consistent across frontends.
- */
-export function describeActiveModelSource(source: ActiveModelSource): string {
-  switch (source) {
-    case "override-valid":
-      return "your pick";
-    case "override-invalid-fallback":
-      return "previous pick invalid — falling back to default";
-    case "backend-canonical":
-      return "backend default";
-    case "config-backend-defaults":
-      return "configured default";
-    case "config-legacy-global":
-      return "global default";
-    case "none":
-      return "no model selected";
-  }
-}
-
-/** Read-only helper to surface the `modelByBackend` map for a chat
- *  (e.g. for /status rendering). Returns a shallow copy. */
-export function getModelByBackendSnapshot(
-  chatId: string,
-): Record<string, string> {
-  const settings = getChatSettings(chatId);
-  return { ...settings.modelByBackend };
-}

package/src/core/plugin/actions.ts

@@ -14,6 +14,22 @@
 import { logError } from "../../util/log.js";
 import type { ActionResult } from "../types.js";
 import { registry } from "./registry.js";
+import type { TalonPlugin } from "./types.js";
+
+/** Run a plugin that has `handleAction`; a throw becomes an error result. */
+async function runAction(
+  plugin: TalonPlugin,
+  body: Record<string, unknown>,
+  chatId: string,
+): Promise<ActionResult | null> {
+  try {
+    return await plugin.handleAction!(body, chatId);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    logError("plugin", `${plugin.name} action error: ${detail}`);
+    return { ok: false, error: `Plugin ${plugin.name}: ${detail}` };
+  }
+}
 
 export async function handlePluginAction(
   body: Record<string, unknown>,
@@ -21,19 +37,8 @@ export async function handlePluginAction(
 ): Promise<ActionResult | null> {
   for (const { plugin } of registry.all) {
     if (!plugin.handleAction) continue;
-    try {
-      const result = await plugin.handleAction(body, chatId);
-      if (result) return result;
-    } catch (err) {
-      logError(
-        "plugin",
-        `${plugin.name} action error: ${err instanceof Error ? err.message : err}`,
-      );
-      return {
-        ok: false,
-        error: `Plugin ${plugin.name}: ${err instanceof Error ? err.message : err}`,
-      };
-    }
+    const result = await runAction(plugin, body, chatId);
+    if (result) return result;
   }
   return null;
 }
@@ -56,11 +61,5 @@ export async function handlePluginActionIn(
 ): Promise<ActionResult | null> {
   const entry = registry.all.find(({ plugin }) => plugin.name === name);
   if (!entry?.plugin.handleAction) return null;
-  try {
-    return await entry.plugin.handleAction(body, chatId);
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    logError("plugin", `${name} action error: ${detail}`);
-    return { ok: false, error: `Plugin ${name}: ${detail}` };
-  }
+  return runAction(entry.plugin, body, chatId);
 }

package/src/core/plugin/builtins.ts

@@ -4,7 +4,10 @@
  */
 
 import { log, logError, logWarn } from "../../util/log.js";
+import { raiseAlert, resolveAlert } from "../frontend-runtime/alerts.js";
+import { faultText } from "../engine/fault-text.js";
 import type { TalonConfig } from "../config/index.js";
+import type { TalonPlugin } from "./types.js";
 import { registry, reloadState } from "./registry.js";
 import type { ProvisionOutcome } from "./provision.js";
 import { NATIVE_RUNTIMES, type NativePluginId } from "./native-runtimes.js";
@@ -37,6 +40,7 @@ function reportProvision(
   if (outcome.status === "failed" && outcome.error) {
     logError(pluginName, `provision failed: ${outcome.error}`);
   }
+  alertOnProvision(pluginName, outcome.status, outcome.error);
   const background = outcome.background;
   if (background) {
     // Tracked so the post-update report waits for it to settle (its
@@ -56,6 +60,27 @@ function reportProvision(
   }
 }
 
+/**
+ * A native runtime that could not be provisioned leaves its plugin down
+ * until a human looks (disk, network, a broken toolchain) — alert on the
+ * failed pass, clear once a later pass leaves it usable.
+ */
+function alertOnProvision(
+  pluginName: NativePluginId,
+  status: ProvisionOutcome["status"] | "threw",
+  error: unknown,
+): void {
+  const key = `provision.${pluginName}`;
+  if (status === "failed" || status === "threw") {
+    raiseAlert(
+      key,
+      `Installing the ${pluginName} runtime failed: ${faultText(error ?? "no detail")}. The ${pluginName} plugin will not work until it is fixed (see \`talon doctor\`).`,
+    );
+  } else if (status === "ready" || status === "degraded") {
+    resolveAlert(key, `The ${pluginName} runtime is installed and usable.`);
+  }
+}
+
 /**
  * Provision every enabled native runtime (see native-runtimes.ts) and
  * return the outcomes so plugin construction can read what it got
@@ -77,136 +102,109 @@ async function provisionNativeRuntimes(
         runtime.id,
         `provision: ${err instanceof Error ? err.message : err}`,
       );
+      alertOnProvision(runtime.id, "threw", err);
     }
   }
   return outcomes;
 }
 
+/**
+ * Register one built-in plugin from its config section and run its init.
+ * A plugin that fails to build or init is logged, never fatal.
+ */
+async function loadBuiltin(
+  label: string,
+  section: object,
+  initTimeoutMs: number,
+  build: () => Promise<TalonPlugin>,
+): Promise<void> {
+  try {
+    const loaded = registerPlugin(
+      await build(),
+      section as Record<string, unknown>,
+    );
+    if (loaded) {
+      await initPluginWithTimeout(
+        loaded.plugin,
+        loaded.config,
+        initTimeoutMs,
+        `${label} init`,
+        `${label} init`,
+      );
+    }
+  } catch (err) {
+    logError(
+      "plugin",
+      `${label} init: ${err instanceof Error ? err.message : err}`,
+    );
+    raiseAlert(
+      `plugin.${label.toLowerCase()}`,
+      `Built-in plugin ${label} failed to load: ${faultText(err)}. Its tools are unavailable until the next reload or restart.`,
+    );
+  }
+}
+
 /**
  * Load built-in plugins (GitHub, MemPalace, mem0, Playwright) based on config flags.
- * Shared by both bootstrap and hot-reload to avoid duplication.
+ * Shared by both bootstrap and hot-reload.
  */
 export async function loadBuiltinPlugins(config: TalonConfig): Promise<void> {
   const provisioned = await provisionNativeRuntimes(config);
 
   const github = config.github;
   if (github?.enabled) {
-    try {
+    await loadBuiltin("GitHub", github, 15_000, async () => {
       const { createGitHubPlugin } =
         await import("../../plugins/github/index.js");
-      const gh = createGitHubPlugin({
+      return createGitHubPlugin({
         token: github.token,
         imageTag: github.imageTag,
       });
-      const ghConfig = github as unknown as Record<string, unknown>;
-      const loaded = registerPlugin(gh, ghConfig);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          15_000,
-          "GitHub init",
-          "GitHub init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `GitHub init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 
   const mempalace = config.mempalace;
   if (mempalace?.enabled) {
-    try {
+    await loadBuiltin("MemPalace", mempalace, 30_000, async () => {
       const { createMempalacePlugin } =
         await import("../../plugins/mempalace/index.js");
       const { resolveMempalacePaths } =
         await import("../../plugins/mempalace/provision.js");
       const { pythonPath, palacePath } = resolveMempalacePaths(mempalace);
-      const mp = createMempalacePlugin({
+      return createMempalacePlugin({
         pythonPath,
         palacePath,
         entityLanguages: mempalace.entityLanguages,
         verbose: mempalace.verbose,
         installedVersion: provisioned.get("mempalace")?.version,
       });
-      const mpConfig = mempalace as unknown as Record<string, unknown>;
-      const loaded = registerPlugin(mp, mpConfig);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          30_000,
-          "MemPalace init",
-          "MemPalace init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `MemPalace init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 
   const mem0 = config.mem0;
   if (mem0?.enabled) {
-    try {
+    await loadBuiltin("mem0", mem0, 15_000, async () => {
       const { createMem0Plugin } = await import("../../plugins/mem0/index.js");
-      const m0 = createMem0Plugin({
+      return createMem0Plugin({
         apiKey: mem0.apiKey,
         host: mem0.host,
         userId: mem0.userId,
       });
-      const m0Config = mem0 as unknown as Record<string, unknown>;
-      const loaded = registerPlugin(m0, m0Config);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          15_000,
-          "mem0 init",
-          "mem0 init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `mem0 init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 
   const playwright = config.playwright;
   if (playwright?.enabled) {
-    try {
+    await loadBuiltin("Playwright", playwright, 15_000, async () => {
       const { createPlaywrightPlugin } =
         await import("../../plugins/playwright/index.js");
-      const pwConfig = playwright as unknown as Record<string, unknown>;
-      const pw = createPlaywrightPlugin({
+      return createPlaywrightPlugin({
         browser: playwright.browser,
         headless: playwright.headless,
         endpoint: playwright.endpoint,
         endpointFile: playwright.endpointFile,
       });
-      const loaded = registerPlugin(pw, pwConfig);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          15_000,
-          "Playwright init",
-          "Playwright init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `Playwright init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 }
 
@@ -217,9 +215,9 @@ export async function loadBuiltinPlugins(config: TalonConfig): Promise<void> {
  *
  * Throws on config parse/validation failure so the gateway can report an error.
  *
- * Does NOT restart the main process, Claude session, or bot connection. Active
- * conversations continue uninterrupted — new MCP servers spawn automatically
- * on the next tool call.
+ * Does NOT restart the main process, backend session, or bot connection.
+ * Active conversations continue uninterrupted — new MCP servers spawn
+ * automatically on the next tool call.
  */
 export async function reloadPlugins(
   activeFrontends?: string[],
@@ -229,30 +227,22 @@ export async function reloadPlugins(
   const { loadConfig, getFrontends } = await import("../config/index.js");
   const config = loadConfig();
 
-  // Derive frontends from config if not explicitly provided
   const frontends = activeFrontends ?? getFrontends(config);
 
-  // Bump reload timestamp so every MCP subprocess env differs from the previous
-  // load — the Claude SDK will see a changed env and spawn fresh subprocesses,
-  // picking up any source-file changes without a full Talon restart.
+  // New cache-bust key: the re-import below must load edited plugin source.
   reloadState.lastReloadAt = new Date().toISOString();
 
-  // Config is valid — safe to destroy current plugins now
   log("plugin", "Hot-reload: destroying current plugins...");
   await registry.destroyAndClear();
 
-  // Re-load external plugins
   if (config.plugins.length > 0) {
     await loadPlugins(config.plugins, frontends);
   }
-
-  // Re-load built-in plugins using shared helper
   await loadBuiltinPlugins(config);
 
   // Retire the hub's MCP children: the next tool call (any chat) spawns
   // fresh processes from the reloaded registry, while in-flight calls
-  // drain on the old ones (stdio-era behaviour was per-turn respawn via
-  // the TALON_RELOAD_AT env bump; the hub owns lifecycles directly).
+  // drain on the old ones.
   const { reloadHubChildren } = await import("../mcp-hub/index.js");
   reloadHubChildren();
 

package/src/core/plugin/index.ts

@@ -7,10 +7,7 @@
  *   - `loader`   — load/validate/register plugins, init hooks, query helpers
  *   - `builtins` — built-in plugin loading + hot-reload
  *   - `actions`  — gateway-action routing through plugins
- *   - `mcp`      — MCP server config assembly for the Claude Agent SDK
- *
- * Re-exports the same public surface the old single-file module exposed,
- * including the `_deps` test seam.
+ *   - `mcp`      — MCP server spec assembly for the hub
  */
 
 export { _deps } from "./registry.js";