talon-agent 5.2.0 → 5.2.2

package/src/core/update/self-update.ts

@@ -8,6 +8,17 @@
  * source tree on disk, so {@link getRepoRoot} returns `null` and the
  * `/update` command is never registered.
  *
+ * The install is verified before anyone hands off to it. `npm install`
+ * rewrites node_modules underneath the still-running process, so a bad
+ * dependency resolution does not surface until the *successor* imports
+ * the tree — detached, with its output going nowhere, at the one moment
+ * the daemon has no one left to report to. On 2026-09-18 that cost a
+ * 45-minute outage. The last step of an update therefore runs the new
+ * tree in a child with {@link BOOT_SMOKE_FLAG}: it resolves the daemon's
+ * entire import graph and exits without booting. If it fails, the update
+ * fails — the caller reports it to the chat and the current process, the
+ * one that still works, keeps running.
+ *
  * The update force-syncs the checkout to the remote branch with
  * `git reset --hard` (plus `git clean -fd`), discarding any local edits
  * or diverged commits. A bot host is meant to mirror the remote exactly,
@@ -22,6 +33,11 @@ import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  BOOT_SMOKE_FLAG,
+  BOOT_SMOKE_OK,
+  successorCommand,
+} from "../daemon/respawn.js";
 
 /** Tuning knobs for {@link runSelfUpdate}. */
 export interface UpdateOptions {
@@ -36,6 +52,11 @@ export interface UpdateOptions {
   setup?: readonly string[];
   /** Override the repo root (tests). Defaults to {@link getRepoRoot}. */
   repoRoot?: string;
+  /**
+   * The command that re-runs this process, used for the post-install
+   * import check. Defaults to our own argv (tests override it).
+   */
+  entry?: { cmd: string; args: readonly string[] };
   /** Injectable command runner (tests). */
   runner?: CommandRunner;
 }
@@ -70,6 +91,8 @@ export type CommandRunner = (
 ) => Promise<{ ok: boolean; output: string }>;
 
 const GIT_TIMEOUT_MS = 60_000;
+/** A cold import of the whole daemon graph, on a busy host. */
+const VERIFY_TIMEOUT_MS = 180_000;
 const INSTALL_TIMEOUT_MS = 300_000;
 const SETUP_TIMEOUT_MS = 300_000;
 const MAX_OUTPUT_BUFFER = 16 * 1024 * 1024;
@@ -265,5 +288,26 @@ export async function runSelfUpdate(
     }
   }
 
+  const entry = opts.entry ?? successorCommand();
+  const verify = await record(
+    "verify import",
+    entry.cmd,
+    [...entry.args, BOOT_SMOKE_FLAG],
+    VERIFY_TIMEOUT_MS,
+  );
+  if (!verify.ok || !verify.output.includes(BOOT_SMOKE_OK)) {
+    return {
+      ok: false,
+      repoRoot,
+      steps,
+      before,
+      after,
+      changed,
+      error:
+        `the updated tree does not import — not restarting into it. ` +
+        `Still running ${before}; the checkout is at ${after}.`,
+    };
+  }
+
   return { ok: true, repoRoot, steps, before, after, changed: true };
 }

package/src/index.ts

@@ -1,11 +1,13 @@
 /**
  * Talon entry shim.
  *
- * Dispatches the hidden `_mcp-launch` (MCP supervisor) and `_lua-run`
- * (WASM Lua trigger runner) subcommands BEFORE the app graph loads —
- * both are Talon re-invoking itself (see core/mcp-hub/launcher.ts). The
- * dynamic import keeps these helper processes light: they evaluate this
- * shim and their own module, never the backends/frontends/plugins.
+ * Dispatches the hidden `_mcp-launch` (MCP supervisor), `_lua-run`
+ * (WASM Lua trigger runner) and `_handoff-watch` (restart/update
+ * witness) subcommands BEFORE the app graph loads — all three are Talon
+ * re-invoking itself (see core/mcp-hub/launcher.ts, core/daemon/
+ * handoff.ts). The dynamic import keeps these helper processes light:
+ * they evaluate this shim and their own module, never the
+ * backends/frontends/plugins.
  */
 
 import {
@@ -13,11 +15,17 @@ import {
   runSupervisor,
 } from "./core/mcp-hub/launcher.js";
 import { LUA_RUN_SUBCOMMAND, runLuaMain } from "./core/scripts/lua.js";
+import {
+  HANDOFF_WATCH_SUBCOMMAND,
+  runHandoffWatch,
+} from "./core/daemon/handoff.js";
 
 if (process.argv[2] === MCP_LAUNCH_SUBCOMMAND) {
   await runSupervisor(process.argv.slice(3));
 } else if (process.argv[2] === LUA_RUN_SUBCOMMAND) {
   await runLuaMain(process.argv.slice(3));
+} else if (process.argv[2] === HANDOFF_WATCH_SUBCOMMAND) {
+  await runHandoffWatch(process.argv.slice(3));
 } else {
   await import("./app.js");
 }

package/src/plugins/playwright/index.ts

@@ -25,9 +25,9 @@
  * with "428 Precondition Required". @playwright/mcp is therefore pinned
  * exactly in package.json (0.0.56 → playwright 1.58.x, matching python
  * playwright 1.58 which hosts Camoufox — camoufox itself caps playwright at
- * <1.61, so the node client cannot chase latest). Bump BOTH sides together,
- * deliberately — do not let a routine dependency bump move one without the
- * other.
+ * <1.61, so the node client cannot chase latest). The pin is enforced, not
+ * just documented: see version-coupling.ts (unit test that fails CI on a
+ * bump, validateConfig refusal, and a live handshake probe at init).
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -35,6 +35,12 @@ 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";
+import {
+  ENDPOINT_PLAYWRIGHT_MINOR,
+  bundledPlaywrightVersion,
+  couplingError,
+  probeEndpoint,
+} from "./version-coupling.js";
 
 export function createPlaywrightPlugin(config: {
   browser?: string;
@@ -141,6 +147,13 @@ export function createPlaywrightPlugin(config: {
         );
       }
 
+      // Endpoint mode: refuse to start on a client/server minor mismatch
+      // rather than fail every tool call later (see version-coupling.ts).
+      if (endpoint) {
+        const coupling = couplingError(bundledPlaywrightVersion());
+        if (coupling) errors.push(coupling);
+      }
+
       return errors.length > 0 ? errors : undefined;
     },
 
@@ -149,6 +162,29 @@ export function createPlaywrightPlugin(config: {
         "playwright",
         `Ready (${endpoint ? `Camoufox @ ${endpoint}` : `${browser}, headless=${headless}`})`,
       );
+      if (!endpoint) return;
+      // Live handshake with the bundled client version: catches a drifted
+      // server (the static check only knows the expected minor).
+      const client =
+        bundledPlaywrightVersion() ?? `${ENDPOINT_PLAYWRIGHT_MINOR}.0`;
+      const probe = await probeEndpoint(endpoint, client);
+      switch (probe.state) {
+        case "match":
+          log("playwright", `Endpoint handshake OK (Playwright ${client})`);
+          break;
+        case "mismatch":
+          log(
+            "playwright",
+            `ERROR: endpoint ${endpoint} is on Playwright ${probe.server} but the bundled client is ${probe.client} — every browser tool call will fail with 428. Align the python playwright hosting Camoufox with ENDPOINT_PLAYWRIGHT_MINOR (${ENDPOINT_PLAYWRIGHT_MINOR}) or re-pin @playwright/mcp.`,
+          );
+          break;
+        case "unreachable":
+          log(
+            "playwright",
+            `Warning: endpoint ${endpoint} did not answer the handshake probe (${probe.reason}); browser tools will fail until it is up.`,
+          );
+          break;
+      }
     },
   };
 }

package/src/plugins/playwright/provision.ts

@@ -28,6 +28,11 @@ import {
   type ProvisionOutcome,
 } from "../../core/plugin/provision.js";
 import { dirs } from "../../util/paths.js";
+import {
+  ENDPOINT_PLAYWRIGHT_MINOR,
+  bundledPlaywrightVersion,
+  couplingError,
+} from "./version-coupling.js";
 
 /** Engines whose builds Playwright manages (vs system channels). */
 const MANAGED_ENGINES = new Set(["chromium", "firefox", "webkit"]);
@@ -54,6 +59,8 @@ export interface PlaywrightProvisionDeps {
   listDir?: (p: string) => string[];
   /** playwright-core's browser registry (default: browsers.json beside the CLI). */
   registry?: BrowserDescriptor[];
+  /** Bundled playwright-core version (default: read from node_modules). */
+  bundledPlaywrightVersion?: string;
 }
 
 /** One entry of playwright-core's browsers.json. */
@@ -287,12 +294,26 @@ export function inspectPlaywright(
   deps: PlaywrightProvisionDeps = {},
 ): DoctorCheck[] {
   if (section.endpoint ?? section.endpointFile) {
+    const bundled = deps.bundledPlaywrightVersion ?? bundledPlaywrightVersion();
+    const coupling = couplingError(bundled);
     return [
       {
         label: "Playwright: remote endpoint mode",
         status: "info",
         detail: "browser lives on the remote end",
       },
+      coupling
+        ? {
+            label: "Playwright: client/endpoint version mismatch",
+            status: "fail",
+            detail: coupling,
+            issue: true,
+          }
+        : {
+            label: `Playwright: client on endpoint minor ${ENDPOINT_PLAYWRIGHT_MINOR}`,
+            status: "ok",
+            detail: bundled ? `playwright-core ${bundled}` : undefined,
+          },
     ];
   }
   const browser = section.browser ?? "chromium";

package/src/plugins/playwright/version-coupling.ts

@@ -0,0 +1,195 @@
+/**
+ * Endpoint-mode version coupling — the machinery behind the pin.
+ *
+ * In endpoint mode the MCP child connects to a remote Playwright server
+ * (the python-playwright process hosting Camoufox). Playwright's server
+ * refuses the WebSocket upgrade with "428 Precondition Required" when the
+ * client's playwright MINOR (sent in the User-Agent, `Playwright/x.y.z`)
+ * differs from its own — so a client bump that nobody noticed turns every
+ * browser tool call into an opaque error at the worst possible moment.
+ *
+ * Three guards, all keyed on ENDPOINT_PLAYWRIGHT_MINOR:
+ *  - a unit test asserts the playwright-core that @playwright/mcp bundles is
+ *    on that minor, so a dependency bump goes red in CI instead of green;
+ *  - `validateConfig` refuses to start the plugin on a mismatch, with a
+ *    message that names both versions and the fix;
+ *  - `probeEndpoint` performs the real handshake at init and reports the
+ *    server's verdict, so a drifted *server* is caught too.
+ *
+ * Bumping: change ENDPOINT_PLAYWRIGHT_MINOR and `@playwright/mcp` in
+ * package.json in the same commit, after upgrading the python side
+ * (camoufox caps python-playwright, so the node side cannot chase latest).
+ */
+
+import { randomBytes } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { resolve } from "node:path";
+
+/**
+ * Playwright minor of the remote endpoint (python playwright behind
+ * Camoufox). Must equal the minor of the playwright-core bundled by the
+ * pinned @playwright/mcp — see the header comment before changing it.
+ */
+export const ENDPOINT_PLAYWRIGHT_MINOR = "1.58";
+
+/** "1.58.0-alpha-2026-01-16" → "1.58". */
+export function minorOf(version: string): string {
+  const m = version.match(/^(\d+)\.(\d+)/);
+  return m ? `${m[1]}.${m[2]}` : version;
+}
+
+function defaultModulesRoot(): string {
+  return resolve(import.meta.dirname ?? ".", "../../../node_modules");
+}
+
+/** Version of the playwright-core the MCP child will run with. */
+export function bundledPlaywrightVersion(
+  modulesRoot: string = defaultModulesRoot(),
+): string | undefined {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(
+        resolve(modulesRoot, "playwright-core/package.json"),
+        "utf-8",
+      ),
+    ) as { version?: string };
+    return pkg.version;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Static check: does the bundled client sit on the endpoint's minor?
+ * Returns an error message, or undefined when coupled (or when the bundle
+ * cannot be read — that is reported separately as a missing install).
+ */
+export function couplingError(
+  bundled: string | undefined,
+  expectedMinor: string = ENDPOINT_PLAYWRIGHT_MINOR,
+): string | undefined {
+  if (!bundled) return undefined;
+  const got = minorOf(bundled);
+  if (got === expectedMinor) return undefined;
+  return (
+    `@playwright/mcp bundles playwright-core ${bundled} (minor ${got}) but the ` +
+    `remote endpoint is on Playwright ${expectedMinor} — every browser tool call ` +
+    `would fail with "428 Precondition Required". Pin @playwright/mcp to the ` +
+    `release that bundles playwright-core ${expectedMinor}.x, or bump ` +
+    `ENDPOINT_PLAYWRIGHT_MINOR together with the python side ` +
+    `(src/plugins/playwright/version-coupling.ts).`
+  );
+}
+
+export type EndpointProbe =
+  | { state: "match"; client: string }
+  | { state: "mismatch"; client: string; server: string }
+  | { state: "unreachable"; client: string; reason: string };
+
+/** Parse the body Playwright's server sends with its 428. */
+export function parseMismatch(
+  body: string,
+): { server: string; client: string } | undefined {
+  const server = body.match(/server version:\s*v?([\d.]+)/);
+  const client = body.match(/client version:\s*v?([\d.]+)/);
+  return server && client
+    ? { server: server[1], client: client[1] }
+    : undefined;
+}
+
+/**
+ * Perform the WebSocket upgrade the MCP child performs, advertising
+ * `clientVersion`, and read the server's verdict. Never throws; never
+ * leaves a connection open (a completed upgrade is torn down at once, and
+ * Playwright's server treats that as an ordinary client disconnect).
+ */
+export function probeEndpoint(
+  endpoint: string,
+  clientVersion: string,
+  timeoutMs = 3000,
+): Promise<EndpointProbe> {
+  return new Promise((settle) => {
+    let url: URL;
+    try {
+      url = new URL(endpoint);
+    } catch {
+      settle({
+        state: "unreachable",
+        client: clientVersion,
+        reason: `invalid endpoint URL: ${endpoint}`,
+      });
+      return;
+    }
+    const secure = url.protocol === "wss:" || url.protocol === "https:";
+    const request = secure ? httpsRequest : httpRequest;
+    const req = request({
+      host: url.hostname,
+      port: url.port || (secure ? 443 : 80),
+      path: `${url.pathname}${url.search}`,
+      method: "GET",
+      headers: {
+        Connection: "Upgrade",
+        Upgrade: "websocket",
+        "Sec-WebSocket-Version": "13",
+        "Sec-WebSocket-Key": randomBytes(16).toString("base64"),
+        "User-Agent": `Playwright/${clientVersion} (talon endpoint probe)`,
+      },
+      timeout: timeoutMs,
+    });
+    let settled = false;
+    const done = (result: EndpointProbe) => {
+      if (settled) return;
+      settled = true;
+      req.destroy();
+      settle(result);
+    };
+    req.on("upgrade", (_res, socket) => {
+      socket.destroy();
+      done({ state: "match", client: clientVersion });
+    });
+    req.on("response", (res) => {
+      let body = "";
+      res.setEncoding("utf-8");
+      res.on("data", (chunk: string) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        if (res.statusCode === 428) {
+          const parsed = parseMismatch(body);
+          done(
+            parsed
+              ? {
+                  state: "mismatch",
+                  client: clientVersion,
+                  server: parsed.server,
+                }
+              : {
+                  state: "unreachable",
+                  client: clientVersion,
+                  reason: "428 without a version box in the body",
+                },
+          );
+          return;
+        }
+        done({
+          state: "unreachable",
+          client: clientVersion,
+          reason: `HTTP ${res.statusCode ?? "?"} instead of an upgrade`,
+        });
+      });
+    });
+    req.on("timeout", () =>
+      done({ state: "unreachable", client: clientVersion, reason: "timeout" }),
+    );
+    req.on("error", (err: Error) =>
+      done({
+        state: "unreachable",
+        client: clientVersion,
+        reason: err.message,
+      }),
+    );
+    req.end();
+  });
+}