talon-agent 5.3.0 → 5.4.1

package/src/cli/setup.ts

@@ -6,6 +6,8 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { printBanner, loadConfig, saveConfig, type Config } from "./config.js";
+import { binaryOnPath } from "../util/binary-on-path.js";
+import { detectAgyAuth } from "../backend/agy/auth.js";
 
 /** Strip spaces, "+", brackets and dashes from a phone number. */
 const bareDigits = (raw: string) => raw.replace(/[\s+()-]/g, "");
@@ -393,6 +395,10 @@ async function askBackend(config: Config): Promise<Config["backend"]> {
           value: "codex",
           label: `Codex     ${pc.dim("— OpenAI Codex CLI (@openai/codex)")}`,
         },
+        {
+          value: "agy",
+          label: `Antigravity ${pc.dim("— Google Antigravity CLI (agy, subscription OAuth)")}`,
+        },
         {
           value: "openai-agents",
           label: `OpenAI Agents ${pc.dim("— @openai/agents (OpenAI or any OpenAI-compatible endpoint)")}`,
@@ -405,6 +411,7 @@ async function askBackend(config: Config): Promise<Config["backend"]> {
 type BackendAnswers = Pick<
   SetupAnswers,
   | "claudeBinary"
+  | "agyBinary"
   | "codexApiKey"
   | "openaiApiKey"
   | "openaiBaseUrl"
@@ -434,6 +441,44 @@ async function askCodexBackend(config: Config): Promise<BackendAnswers> {
   return { codexApiKey: trimmedOrUndefined(codexApiKey) };
 }
 
+/**
+ * Antigravity has no API key to collect — it authenticates through a
+ * consumer Google OAuth flow run once interactively, cached under
+ * `~/.gemini/antigravity-cli/`. All the wizard can usefully do is
+ * point at the binary and say where the login happens.
+ */
+async function askAgyBackend(config: Config): Promise<BackendAnswers> {
+  const binary = await askOrExit(
+    p.text({
+      message: "Antigravity CLI binary path",
+      placeholder: "leave empty for default (agy on PATH)",
+      initialValue: config.agyBinary || "",
+    }),
+  );
+  const resolved = trimmedOrUndefined(binary);
+  const probe = resolved || "agy";
+  const installed = binaryOnPath(probe);
+  if (!installed) {
+    p.log.warn(
+      `${pc.yellow("!")} \`${probe}\` not found — install the Antigravity CLI ` +
+        `and make sure it is on PATH before starting Talon.`,
+    );
+  }
+  const auth = detectAgyAuth();
+  if (!auth.present) {
+    p.log.warn(
+      `${pc.yellow("!")} No cached Antigravity credentials. Run ${pc.cyan("agy")} ` +
+        `once on this host and complete the Google sign-in; headless runs ` +
+        `then reuse the cache. There is no API key for this backend.`,
+    );
+  } else {
+    p.log.success(
+      `Antigravity credentials found (${auth.method ?? "oauth"}) at ${auth.path}`,
+    );
+  }
+  return { agyBinary: resolved };
+}
+
 async function askOpenAiAgentsBackend(config: Config): Promise<BackendAnswers> {
   const openaiApiKey = trimmedOrUndefined(
     await askOrExit(
@@ -494,6 +539,8 @@ async function askBackendCredentials(
       return askClaudeBackend(config);
     case "codex":
       return askCodexBackend(config);
+    case "agy":
+      return askAgyBackend(config);
     case "openai-agents":
       return askOpenAiAgentsBackend(config);
     default:
@@ -553,6 +600,7 @@ export type SetupAnswers = {
   backend: Config["backend"];
   botToken?: string;
   claudeBinary?: string;
+  agyBinary?: string;
   codexApiKey?: string;
   openaiApiKey?: string;
   openaiBaseUrl?: string;
@@ -612,6 +660,7 @@ export function buildSetupConfig(
     codexApiKey: ownsCredential("codex")
       ? answers.codexApiKey
       : existing.codexApiKey,
+    agyBinary: ownsCredential("agy") ? answers.agyBinary : existing.agyBinary,
     openaiApiKey: ownsCredential("openai-agents")
       ? answers.openaiApiKey
       : existing.openaiApiKey,

package/src/core/agent-runtime/model-ref.ts

@@ -28,6 +28,7 @@ import type { ReasoningEffortLevel } from "../types.js";
  * lockstep.
  */
 export const BACKEND_IDS = [
+  "agy",
   "claude",
   "codex",
   "kilo",

package/src/core/config/index.ts

@@ -360,6 +360,7 @@ const configSchema = z.object({
    * unset, the codex-sdk resolves `codex` from its package / PATH.
    */
   codexBinary: z.string().optional(),
+  agyBinary: z.string().optional(),
   model: z.string().default("default"),
   /**
    * Per-backend default model overrides. Keyed by backend id

package/src/core/daemon/respawn.ts

@@ -13,9 +13,9 @@
  * systemd, foreman, pm2, or running under a debugger. Respawning from
  * our own `process.argv` works regardless of launch method.
  *
- * Ordering matters. `respawnSelf()` only *arms* the handoff and raises
- * SIGTERM; the successor is spawned by `spawnSuccessor()` at the tail of
- * graceful shutdown, once the frontends have stopped. Spawning up-front
+ * Ordering matters. `respawnSelf()` only *arms* the handoff and enters
+ * graceful shutdown; the successor is spawned by `spawnSuccessor()` at
+ * the tail of it, once the frontends have stopped. Spawning up-front
  * (the original behaviour) left the successor long-polling `getUpdates`
  * while the outgoing process was still draining in-flight queries — up
  * to DRAIN_TIMEOUT_MS of two live pollers. Telegram answers only one of
@@ -40,6 +40,16 @@
  *     within a bounded window, and starts the daemon the way `talon
  *     start` does if the successor never comes up. Nothing in the
  *     handoff depends on a process that is about to call process.exit().
+ *
+ * And one thing 2026-09-20 added: the shutdown is entered directly,
+ * through the function app.ts registers with `setRespawnShutdown()`,
+ * not by sending ourselves a SIGTERM. The signal round trip bought
+ * nothing, and under Bun it lost the whole restart: by the time
+ * `/restart` ran, the process had silently lost its OS-level SIGTERM
+ * handler (see ./signals.ts), so the signal terminated it on the spot —
+ * no shutdown, no successor, no pidfile cleanup, and nothing in any log
+ * after "Respawn requested". Only a process that never registered — an
+ * embedder, a test — still falls back to the signal.
  */
 
 import { spawn } from "node:child_process";
@@ -47,6 +57,18 @@ import { log, logError, openRespawnLog } from "../../util/log.js";
 import { HANDOFF_WATCH_SUBCOMMAND } from "./handoff.js";
 
 let pendingReason: string | null = null;
+let shutdown: ((reason: string) => void) | null = null;
+
+/**
+ * Register the graceful-shutdown entry a respawn should run. app.ts
+ * hands over `gracefulShutdown`; `respawnSelf()` then calls it in-process
+ * instead of round-tripping a SIGTERM through the OS. `null` clears it.
+ */
+export function setRespawnShutdown(
+  fn: ((reason: string) => void) | null,
+): void {
+  shutdown = fn;
+}
 
 /**
  * Argv flag that makes the daemon entry resolve its whole import graph
@@ -84,9 +106,8 @@ function selfInvocation(extra: string[]): { cmd: string; args: string[] } {
 }
 
 /**
- * Arm a respawn and raise SIGTERM on ourselves so the existing
- * graceful-shutdown path cleanly stops the frontends, flushes state,
- * and hands off via `spawnSuccessor()`.
+ * Arm a respawn and enter graceful shutdown, which stops the frontends,
+ * flushes state, and hands off via `spawnSuccessor()`.
  *
  * `reason` is logged for operator visibility (e.g. "telegram
  * /restart"). The function returns immediately; the successor starts
@@ -95,10 +116,13 @@ function selfInvocation(extra: string[]): { cmd: string; args: string[] } {
 export function respawnSelf(reason: string): void {
   log("shutdown", `Respawn requested (${reason})`);
   pendingReason = reason;
-  // SIGTERM triggers the graceful-shutdown handler in src/app.ts,
-  // which stops the frontends, flushes state, spawns the successor,
-  // and calls process.exit(0). Don't exit here directly — that would
-  // skip the flush and leave the PID file dangling.
+  // Don't exit here directly — that would skip the flush and leave the
+  // PID file dangling. The registered shutdown is the same path a
+  // SIGTERM takes, entered without the signal.
+  if (shutdown) {
+    shutdown(reason);
+    return;
+  }
   process.kill(process.pid, "SIGTERM");
 }
 

package/src/core/daemon/signals.ts

@@ -0,0 +1,111 @@
+/**
+ * Keep OS-level signal handlers armed under Bun.
+ *
+ * Bun (observed on 1.3.9) uninstalls the process-wide handler for a
+ * signal as soon as ANY listener for it is removed — even while other
+ * listeners remain:
+ *
+ *   process.on("SIGTERM", a);
+ *   process.on("SIGTERM", b);
+ *   process.removeListener("SIGTERM", b);
+ *   // `a` is still registered in JS, yet SigCgt in /proc/<pid>/status
+ *   // no longer lists SIGTERM: the next one terminates the process
+ *   // with the default action, running no JS at all.
+ *
+ * Node keeps the handler until the last listener goes. Adding any
+ * listener makes Bun install the handler again, which is what this
+ * guard relies on.
+ *
+ * Talon hit it through `write-file-atomic`: each call loads signal-exit,
+ * which puts its own listeners on the termination signals, and unloads
+ * it afterwards, removing them. The daemon writes its pidfile that way
+ * while booting — so from that moment every SIGTERM it sent itself
+ * (`/restart` and `/update`, before respawn.ts entered the shutdown
+ * directly) or received from outside (`talon stop`'s fallback, systemd,
+ * docker) killed it outright: no graceful shutdown, no successor, no
+ * pidfile cleanup. Every `/update` between 2026-09-18 (the move to Bun)
+ * and 2026-09-20 ended this way.
+ *
+ * The guard wraps `process.removeListener` / `process.off`. After a
+ * removal that still leaves real listeners on a signal, it re-adds a
+ * no-op sentinel listener (removing any earlier copy first), so the
+ * handler is installed again before the caller gets control back. Once
+ * the last real listener is gone the sentinel goes too, and the signal
+ * falls back to its default action exactly as it would on Node — a
+ * lingering no-op listener would otherwise make the process ignore it.
+ *
+ * Installed by the entry shim (src/index.ts) so every Talon process —
+ * daemon, MCP supervisor, handoff watcher — is covered before any
+ * library gets a chance to remove a listener. A no-op on other runtimes.
+ */
+
+import { isBunRuntime } from "../../util/runtime.js";
+
+type Listener = (...args: unknown[]) => void;
+
+/** The slice of `process` the guard touches; tests pass an EventEmitter. */
+export interface SignalEmitter {
+  on(event: string | symbol, listener: Listener): unknown;
+  removeListener(event: string | symbol, listener: Listener): unknown;
+  off?(event: string | symbol, listener: Listener): unknown;
+  listeners(event: string | symbol): readonly unknown[];
+}
+
+export interface SignalGuardOptions {
+  /** Install even off Bun (tests exercise the wrapper on Node). */
+  force?: boolean;
+}
+
+const SIGNAL_EVENT = /^SIG[A-Z0-9]+$/;
+
+const INSTALLED = Symbol.for("talon.signalListenerGuard");
+
+type Guarded = SignalEmitter & { [INSTALLED]?: () => void };
+
+/** The sentinel. Its only job is to exist, so Bun keeps the handler. */
+function talonSignalRearm(): void {}
+
+/**
+ * Wrap the emitter's listener removal so a signal never silently loses
+ * its OS handler. Idempotent: a second install returns the first one's
+ * uninstall. Production never uninstalls; tests do.
+ */
+export function installSignalListenerGuard(
+  target: SignalEmitter = process,
+  opts: SignalGuardOptions = {},
+): () => void {
+  const emitter = target as Guarded;
+  if (!opts.force && !isBunRuntime()) return () => {};
+  const existing = emitter[INSTALLED];
+  if (existing) return existing;
+
+  const originalRemove = emitter.removeListener;
+  const originalOff = emitter.off;
+
+  const guardedRemove = function (
+    this: Guarded,
+    event: string | symbol,
+    listener: Listener,
+  ): unknown {
+    const result = originalRemove.call(this, event, listener);
+    if (typeof event !== "string" || !SIGNAL_EVENT.test(event)) return result;
+    // Bun has just dropped the handler. What is left decides whether the
+    // signal should still be handled at all.
+    const remaining = this.listeners(event).filter(
+      (fn) => fn !== talonSignalRearm,
+    );
+    originalRemove.call(this, event, talonSignalRearm);
+    if (remaining.length > 0) this.on(event, talonSignalRearm);
+    return result;
+  };
+
+  emitter.removeListener = guardedRemove;
+  if (originalOff) emitter.off = guardedRemove;
+  const uninstall = (): void => {
+    emitter.removeListener = originalRemove;
+    if (originalOff) emitter.off = originalOff;
+    delete emitter[INSTALLED];
+  };
+  emitter[INSTALLED] = uninstall;
+  return uninstall;
+}

package/src/index.ts

@@ -10,6 +10,7 @@
  * backends/frontends/plugins.
  */
 
+import { installSignalListenerGuard } from "./core/daemon/signals.js";
 import {
   MCP_LAUNCH_SUBCOMMAND,
   runSupervisor,
@@ -20,6 +21,12 @@ import {
   runHandoffWatch,
 } from "./core/daemon/handoff.js";
 
+// Before anything can remove a signal listener: under Bun that would
+// silently disarm SIGTERM/SIGINT for the whole process (core/daemon/
+// signals.ts). Every Talon process passes through here, so every one
+// is covered.
+installSignalListenerGuard();
+
 if (process.argv[2] === MCP_LAUNCH_SUBCOMMAND) {
   await runSupervisor(process.argv.slice(3));
 } else if (process.argv[2] === LUA_RUN_SUBCOMMAND) {