talon-agent 1.12.0 → 1.34.0

package/src/app.ts

@@ -0,0 +1,278 @@
+/**
+ * Talon — agentic AI harness.
+ * Composition root: loads config, creates frontend + backend, wires dispatcher.
+ *
+ * Frontends (Telegram, Terminal) and backends (Claude, OpenCode)
+ * are loaded dynamically — only the selected platform's dependencies are required.
+ */
+
+import { getFrontends } from "./util/config.js";
+import { startUploadCleanup, stopUploadCleanup } from "./util/workspace.js";
+import { flushDatabase } from "./storage/db.js";
+import { getActiveCount } from "./core/engine/dispatcher.js";
+import { startPulseTimer, stopPulseTimer } from "./core/background/pulse.js";
+import {
+  startHeartbeatTimer,
+  stopHeartbeatTimer,
+  awaitCurrentRun as awaitHeartbeat,
+} from "./core/background/heartbeat/index.js";
+import {
+  startCronTimer,
+  stopCronTimer,
+  runStartupCatchup,
+} from "./core/background/cron.js";
+import { shutdownTriggers } from "./core/background/triggers/index.js";
+import { startWatchdog, stopWatchdog } from "./util/watchdog.js";
+import { log, logError, logWarn } from "./util/log.js";
+import { bootstrap, initBackendAndDispatcher } from "./bootstrap.js";
+import { Gateway } from "./core/engine/gateway.js";
+import type { Frontend } from "./bootstrap.js";
+
+// ── Bootstrap ────────────────────────────────────────────────────────────────
+
+import {
+  writePidRecord,
+  removePidRecordIfOwnedBy,
+} from "./core/daemon/pidfile.js";
+
+const { config } = await bootstrap();
+
+// Record this process as the daemon. The gateway port is appended once
+// the gateway binds (it may fall back from the default on EADDRINUSE).
+const bootedAt = new Date().toISOString();
+writePidRecord({ pid: process.pid, startedAt: bootedAt });
+
+// ── Create gateway + frontend ─────────────────────────────────────────────────
+
+const gateway = new Gateway("daemon");
+gateway.onStarted((port) =>
+  writePidRecord({ pid: process.pid, port, startedAt: bootedAt }),
+);
+gateway.onShutdownRequest((reason) => void gracefulShutdown(reason));
+
+const configuredFrontends = [
+  ...new Set(getFrontends(config)),
+] as Frontend["name"][];
+
+async function createFrontend(name: Frontend["name"]): Promise<Frontend> {
+  switch (name) {
+    case "terminal": {
+      const { createTerminalFrontend } =
+        await import("./frontend/terminal/index.js");
+      return createTerminalFrontend(config, gateway);
+    }
+    case "teams": {
+      const { createTeamsFrontend } = await import("./frontend/teams/index.js");
+      return createTeamsFrontend(config, gateway);
+    }
+    case "discord": {
+      const { createDiscordFrontend } =
+        await import("./frontend/discord/index.js");
+      return createDiscordFrontend(config, gateway);
+    }
+    case "native": {
+      const { createNativeFrontend } =
+        await import("./frontend/native/index.js");
+      return createNativeFrontend(config, gateway);
+    }
+    case "telegram":
+    default: {
+      const { createTelegramFrontend } =
+        await import("./frontend/telegram/index.js");
+      return createTelegramFrontend(config, gateway);
+    }
+  }
+}
+
+const frontends: Frontend[] = [];
+for (const name of configuredFrontends) {
+  const frontend = await createFrontend(name);
+  frontends.push(frontend);
+  log("bot", `Frontend: ${name[0].toUpperCase()}${name.slice(1)}`);
+}
+
+// ── Create backend + wire dispatcher ─────────────────────────────────────────
+
+const { backend } = await initBackendAndDispatcher(config, frontends);
+gateway.backend = backend;
+
+// Subscribe the gateway to chat-role rebinds so `/model`, `/settings`,
+// shared-action dispatch, etc. all see the new backend the moment a
+// rebind resolves. Heartbeat / dream / per-chat-override rebinds don't
+// touch the gateway field — those roles run from their own getBackend
+// providers (dispatcher routes per chat).
+const { onBackendChange, roleHolder } =
+  await import("./core/engine/backend-controller/index.js");
+const CHAT_ROLE_HOLDER = roleHolder("chat");
+onBackendChange((holder, newBackend, info) => {
+  if (holder !== CHAT_ROLE_HOLDER) return;
+  gateway.backend = newBackend;
+  log("bot", `Gateway backend reference updated → ${info.label}`);
+});
+
+// ── Graceful shutdown ────────────────────────────────────────────────────────
+
+let shuttingDown = false;
+
+const SHUTDOWN_TIMEOUT_MS = 15_000;
+const DRAIN_TIMEOUT_MS = 5_000;
+
+/**
+ * One best-effort teardown step. A failing subsystem (a frontend that
+ * won't stop, a plugin that throws in destroy, a dynamic import that
+ * fails mid-shutdown) must not abort the rest of the sequence — the
+ * WAL checkpoint and pidfile removal below have to run regardless.
+ */
+async function shutdownStep(name: string, fn: () => unknown): Promise<void> {
+  try {
+    await fn();
+  } catch (err) {
+    logError("shutdown", `${name} failed`, err);
+  }
+}
+
+async function gracefulShutdown(signal: string): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log("shutdown", `${signal} received, shutting down gracefully...`);
+
+  const forceTimer = setTimeout(() => {
+    logError("shutdown", "Timeout exceeded, forcing exit");
+    process.exit(1);
+  }, SHUTDOWN_TIMEOUT_MS);
+  forceTimer.unref();
+
+  // Drain in-flight queries: poll instead of a fixed sleep, so an idle
+  // daemon exits immediately and a busy one gets the full budget.
+  if (getActiveCount() > 0) {
+    log(
+      "shutdown",
+      `Waiting for ${getActiveCount()} in-flight queries to drain...`,
+    );
+    const deadline = Date.now() + DRAIN_TIMEOUT_MS;
+    while (getActiveCount() > 0 && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 250));
+    }
+    const remaining = getActiveCount();
+    if (remaining > 0) {
+      logWarn(
+        "shutdown",
+        `Drain timed out with ${remaining} queries still in flight`,
+      );
+    }
+  }
+
+  await shutdownStep("frontends", () =>
+    Promise.allSettled(frontends.map((frontend) => frontend.stop())),
+  );
+  if (config.backend === "opencode") {
+    await shutdownStep("opencode server", async () => {
+      const { stopOpenCodeServer } =
+        await import("./backend/opencode/index.js");
+      stopOpenCodeServer();
+    });
+  }
+  // Destroy plugins (cleanup resources)
+  if (config.plugins.length > 0) {
+    await shutdownStep("plugins", async () => {
+      const { destroyPlugins } = await import("./core/plugin/index.js");
+      await destroyPlugins();
+    });
+  }
+  await shutdownStep("pulse timer", stopPulseTimer);
+  await shutdownStep("heartbeat", async () => {
+    stopHeartbeatTimer();
+    await awaitHeartbeat();
+  });
+  await shutdownStep("cron timer", stopCronTimer);
+  await shutdownStep("triggers", shutdownTriggers);
+  await shutdownStep("watchdog", stopWatchdog);
+  await shutdownStep("upload cleanup", stopUploadCleanup);
+  await shutdownStep("mcp hub", async () => {
+    const { shutdownHub } = await import("./core/mcp-hub/index.js");
+    await shutdownHub();
+  });
+  flushDatabase();
+  // Guarded removal: after a /restart handoff the successor has already
+  // written its own pid here — deleting unconditionally would orphan it
+  // (the bug that made `talon restart` spawn duplicate daemons).
+  removePidRecordIfOwnedBy(process.pid);
+  log("shutdown", "State saved");
+  process.exit(0);
+}
+
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+
+process.on("uncaughtException", (err) => {
+  // EPIPE errors from network sockets (e.g. Telegram MTProto) are transient —
+  // gramjs will reconnect; crashing the process here is wrong.
+  if ((err as NodeJS.ErrnoException).code === "EPIPE") {
+    logWarn("bot", `Suppressed transient EPIPE error: ${err.message}`);
+    return;
+  }
+  logError("bot", "Uncaught exception", err);
+  flushDatabase();
+  // Same pid-guarded removal as the graceful path — a crashed daemon
+  // must not leave a record that makes `talon status` chase a dead or
+  // recycled pid.
+  removePidRecordIfOwnedBy(process.pid);
+  process.exit(1);
+});
+
+process.on("unhandledRejection", (reason) => {
+  logWarn(
+    "bot",
+    `Unhandled rejection: ${reason instanceof Error ? reason.message : reason}`,
+  );
+});
+
+// ── Start ────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  await Promise.all(frontends.map((frontend) => frontend.init()));
+  log("bot", "Starting Talon...");
+
+  if (config.pulse) startPulseTimer(config.pulseIntervalMs);
+  if (config.heartbeat) startHeartbeatTimer(config.heartbeatIntervalMinutes);
+  startWatchdog(config.workspace);
+  startUploadCleanup(config.workspace);
+
+  const terminalFrontends = frontends.filter(
+    (frontend) => frontend.name === "terminal",
+  );
+  const blockingFrontends = frontends.filter(
+    (frontend) => frontend.name !== "terminal",
+  );
+  if (terminalFrontends.length > 0 && frontends.length > 1) {
+    log(
+      "bot",
+      "Terminal frontend shares stdin with the other frontends; it will run alongside them without blocking startup.",
+    );
+  }
+  await Promise.all(blockingFrontends.map((frontend) => frontend.start()));
+  for (const frontend of terminalFrontends) {
+    void frontend
+      .start()
+      .catch((err) =>
+        logError("bot", `Terminal frontend start failed: ${String(err)}`),
+      );
+  }
+
+  // Replay any runs that came due while Talon was down (per-job catch-up
+  // policy; default skip = fast no-op), THEN start the live cron tick. Kicking
+  // catch-up off first gives it the ~60s head start to take each replayed job's
+  // in-flight lock before the first scheduled tick, so a replay can't race a
+  // scheduled run. Fire-and-forget so a slow replay never blocks startup.
+  runStartupCatchup().catch((err) =>
+    logError("cron", "startup catch-up failed", err),
+  );
+  startCronTimer();
+}
+
+main().catch((err) => {
+  logError("bot", "Fatal startup error", err);
+  flushDatabase();
+  removePidRecordIfOwnedBy(process.pid);
+  process.exit(1);
+});

package/src/backend/claude-sdk/constants.ts

@@ -1,23 +1,35 @@
 /**
  * Claude SDK backend constants — thinking effort, streaming, and
- * chat-specific tool restrictions.
+ * chat-specific tool whitelist.
  *
- * Core disallowed-tool lists live in core/constants.ts (backend-agnostic).
+ * Core whitelist lives in core/constants.ts (kept separate so the chat
+ * additions live next to the rest of the chat-handler config).
  */
 
 import {
-  DISALLOWED_TOOLS_CORE,
-  DISALLOWED_TOOLS_BACKGROUND,
+  ALLOWED_TOOLS_CORE,
+  ALLOWED_TOOLS_BACKGROUND,
 } from "../../core/constants.js";
 
 // Re-export so existing backend imports keep working
-export { DISALLOWED_TOOLS_CORE, DISALLOWED_TOOLS_BACKGROUND };
+export { ALLOWED_TOOLS_CORE, ALLOWED_TOOLS_BACKGROUND };
 
-/** Disallowed tools for the main chat handler (core + web tools replaced by Brave MCP). */
-export const DISALLOWED_TOOLS_CHAT = [
-  ...DISALLOWED_TOOLS_CORE,
-  "WebSearch",
-  "WebFetch",
+/**
+ * Whitelist of built-in tools available to the main chat handler.
+ *
+ * Chat gets two extras on top of the core whitelist:
+ * - `Agent`: sub-agent dispatch (Explore / Plan / etc.). Useful for
+ *   focused subtasks like code-review or codebase audits; the heartbeat
+ *   path keeps it out because nested agents complicate orphan tracking.
+ * - `Skill`: required for `/skill` commands and other skill-driven flows.
+ *   The SDK auto-includes Skill when `skills` are passed via options, but
+ *   we list it explicitly so the tool surface is unambiguous from a single
+ *   constants file.
+ */
+export const ALLOWED_TOOLS_CHAT = [
+  ...ALLOWED_TOOLS_CORE,
+  "Agent",
+  "Skill",
 ] as const;
 
 // ── Thinking / effort configuration ────────────────────────────────────────

package/src/backend/claude-sdk/factory.ts

@@ -4,31 +4,44 @@
  *
  * Unlike Kilo/OpenCode (which run a local HTTP server), the Claude SDK
  * spawns a per-query subprocess. So this factory also wires the
- * `refreshMcpServers` hot-swap path used by plugin reload + the
- * `evictOrphanSubprocesses` cleanup helper.
+ * `tools.refreshTools` hot-swap path used by plugin reload + the
+ * `background.evictOrphanSubprocesses` cleanup helper.
+ *
+ * Returns a composed `Backend` with capability slots for chat,
+ * background, models, sessions, tools, and control.
  */
 
-import { registerBackend } from "../registry.js";
-import type { BackendFactory } from "../registry.js";
-import type { QueryBackend } from "../../core/types.js";
+import { registerBackend } from "../../core/agent-runtime/backend-registry.js";
+import type { BackendFactory } from "../../core/agent-runtime/backend-registry.js";
 import { log } from "../../util/log.js";
-import { getPluginMcpServers } from "../../core/plugin.js";
+import {
+  composeBackend,
+  type ChatBackend,
+  type BackgroundRunner,
+  type ModelCatalog,
+  type SessionBackend,
+  type SystemControl,
+  type ToolRuntime,
+} from "../../core/agent-runtime/capabilities.js";
 
 import {
   initAgent as initClaudeAgent,
   updateSystemPrompt as claudeUpdateSystemPrompt,
-  handleMessage as claudeHandleMessage,
   warmSession as claudeWarmSession,
   getActiveQuery,
   buildMcpServers,
+  buildPluginMcpServers,
   runOneShotAgent as claudeRunOneShotAgent,
   evictOrphanSubprocesses as claudeEvictOrphanSubprocesses,
 } from "./index.js";
+import {
+  runChatTurn as claudeRunChatTurn,
+  interruptChatTurn as claudeInterruptChatTurn,
+} from "./handler.js";
+import { waitForMcpServersReady } from "./mcp-ready.js";
 
 import * as modelProvider from "./model-provider.js";
 
-// ── Factory ────────────────────────────────────────────────────────────────
-
 const claudeSdkFactory: BackendFactory = {
   // The config schema uses `"claude"` for backward compatibility with
   // talon.json files predating the registry. Matching the id here means
@@ -40,12 +53,24 @@ const claudeSdkFactory: BackendFactory = {
     await initClaudeAgent(config, ctx.getBridgePort);
     log("bot", "Backend: Claude SDK (@anthropic-ai/claude-agent-sdk)");
 
-    const backend: QueryBackend = {
-      query: (params) => claudeHandleMessage(params),
-      warmSession: (chatId) => claudeWarmSession(chatId),
-      updateSystemPrompt: (prompt) => claudeUpdateSystemPrompt(prompt),
-      resolveModel: (q) => modelProvider.resolveModel(q),
-      getModelInfo: (id) => modelProvider.getModelInfo(id),
+    const chat: ChatBackend = {
+      runChatTurn: (params) => claudeRunChatTurn(params),
+      interruptChatTurn: (chatId) => claudeInterruptChatTurn(chatId),
+    };
+
+    const background: BackgroundRunner = {
+      runOneShotAgent: (p) => claudeRunOneShotAgent(p),
+      evictOrphanSubprocesses: (label) => claudeEvictOrphanSubprocesses(label),
+    };
+
+    const models: ModelCatalog = {
+      resolveModelInfo: (q) => modelProvider.resolveModel(q),
+      // Claude SDK ships a canonical `"default"` alias the runtime
+      // resolves to the recommended model. Returning it keeps reset
+      // + backend-switch on "Default (recommended)" rather than
+      // freezing a specific id that may go stale across SDK upgrades.
+      getDefaultModelId: () => "default",
+      getRawModelInfo: (id) => modelProvider.getModelInfo(id),
       getSettingsPresentation: (m, options) =>
         modelProvider.getSettingsPresentation(m, options),
       getProviders: () => modelProvider.getProviders(),
@@ -53,25 +78,57 @@ const claudeSdkFactory: BackendFactory = {
         modelProvider.getProviderModels(p, pg, ps),
       formatModelError: (q, r) => modelProvider.formatModelError(q, r),
       listModels: (f) => modelProvider.listModels(f),
-      backendLabel: "Anthropic",
-      refreshMcpServers: async (chatId) => {
+    };
+
+    // Claude SDK's per-turn subprocess model has no shared session
+    // state to reset; `warmSession` is the only useful hook. The
+    // dispatcher's `/reset` clears Talon's stored session id via
+    // `storage/sessions.ts:resetSession` regardless.
+    const sessions: SessionBackend = {
+      warmSession: (chatId) => claudeWarmSession(chatId),
+    };
+
+    const tools: ToolRuntime = {
+      refreshTools: async (chatId) => {
         const qi = getActiveQuery(chatId);
         if (!qi) return null;
         // Two-phase teardown: remove all MCP servers first so each
         // subprocess receives an OS-agnostic shutdown via stdio, then
         // install the fresh set.
         await qi.setMcpServers({});
-        const bridgeUrl = `http://127.0.0.1:${ctx.getBridgePort()}`;
         const freshServers = {
           ...buildMcpServers(chatId),
-          ...getPluginMcpServers(bridgeUrl, chatId),
+          ...buildPluginMcpServers(chatId),
         };
-        return qi.setMcpServers(freshServers);
+        const result = await qi.setMcpServers(freshServers);
+        // setMcpServers resolves on REGISTER, not CONNECT — MCP startup is
+        // non-blocking. A stdio server that dials a slow remote (e.g. the
+        // playwright plugin connecting to the Camoufox websocket) is still
+        // 'pending' at this point and its tools are absent from the live
+        // registry, so the turn would proceed with mcp__playwright-tools__*
+        // stuck "connecting" until the next refresh. Wait (bounded) for the
+        // newly-added servers to finish connecting before returning.
+        await waitForMcpServersReady(qi, result.added);
+        return result;
       },
-      runOneShotAgent: (p) => claudeRunOneShotAgent(p),
-      evictOrphanSubprocesses: (label) => claudeEvictOrphanSubprocesses(label),
     };
 
+    const control: SystemControl = {
+      updateSystemPrompt: (prompt) => claudeUpdateSystemPrompt(prompt),
+    };
+
+    const backend = composeBackend({
+      id: "claude",
+      label: "Anthropic",
+      cacheMetrics: "readwrite",
+      chat,
+      background,
+      models,
+      sessions,
+      tools,
+      control,
+    });
+
     return { backend };
   },
 };