talon-agent 5.21.0 → 5.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "5.21.0",
+  "version": "5.22.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "The Falconry",
   "license": "Apache-2.0",
@@ -101,7 +101,7 @@
     "build:fusefs": "node native/talon-fusefs/build.mjs"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.283",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.284",
     "@anthropic-ai/sdk": "^0.104.1",
     "@brave/brave-search-mcp-server": "^2.0.75",
     "@clack/prompts": "^1.2.0",

package/src/core/mesh/devices/service.ts

@@ -877,8 +877,12 @@ export class MeshService {
   }
 
   /** GET /node/install — serve a grant's installer script (single-use). */
-  openNodeInstall(token: string): { script: string; filename: string } | null {
-    return this.links.openNodeInstall(token);
+  openNodeInstall(
+    token: string,
+    os?: string | null,
+    arch?: string | null,
+  ): Promise<{ script: string; filename: string } | null> {
+    return this.links.openNodeInstall(token, os, arch);
   }
 
   /** GET /node/binary — serve a grant's binary (single-use). */

package/src/core/mesh/links/bridge-links.ts

@@ -24,8 +24,10 @@ import {
   type NodeBinaryResolver,
 } from "./node-binaries.js";
 import {
+  autoInstallOneLiners,
   checkBridgeUrl,
   installOneLiner,
+  installRefusalScript,
   NodeProvisionStore,
 } from "./node-provision.js";
 import {
@@ -141,9 +143,10 @@ export class BridgeLinks {
     name?: unknown,
     bridgeUrl?: unknown,
   ): Promise<MeshToolResult> {
+    const auto = isBlank(os) && isBlank(arch);
     const goos = normalizeGoos(os);
     const goarch = normalizeGoarch(arch);
-    if (!goos || !goarch) {
+    if (!auto && (!goos || !goarch)) {
       return { ok: false, text: unknownTargetText(os, arch) };
     }
     const info = this.bridgeInfo;
@@ -161,6 +164,33 @@ export class BridgeLinks {
     }
     const base = this.bridgeBaseUrl(info, bridgeUrl);
     if (typeof base !== "string") return { ok: false, text: base.error };
+    if (auto || !goos || !goarch) {
+      const pending = this.provision.createAuto({
+        ...(typeof name === "string" && name.trim()
+          ? { name: name.trim() }
+          : {}),
+        bridgeUrl: base,
+        bearerToken: this.linkCredential(info.token, NODE_SCOPES, "install"),
+        ...(info.fingerprint ? { fingerprint: info.fingerprint } : {}),
+        ...(info.spkiPin ? { spkiPin: info.spkiPin } : {}),
+      });
+      const cmd = autoInstallOneLiners(pending);
+      return {
+        ok: true,
+        text: [
+          "Run ONE of these on the new host — it reports its own OS and CPU, and the bridge picks the matching talon-node:",
+          "",
+          "Linux / macOS:",
+          `  ${cmd.posix}`,
+          "",
+          "Windows (elevated PowerShell or cmd):",
+          `  ${cmd.windows}`,
+          "",
+          `It installs talon-node (sha256-verified), pins the bridge certificate, and registers a boot service — the host appears on the mesh within a minute. Supported: ${NODE_TARGETS.map((t) => `${t.goos}/${t.goarch}`).join(", ")}.`,
+          `Single-use link, expires in 30 minutes. The host must be able to reach ${base}.`,
+        ].join("\n"),
+      };
+    }
     let bin;
     try {
       bin = await this.resolveNode(goos, goarch);
@@ -305,7 +335,46 @@ export class BridgeLinks {
   }
 
   /** GET /node/install — serve a grant's installer script (single-use). */
-  openNodeInstall(token: string): { script: string; filename: string } | null {
+  /**
+   * An auto grant is pinned here first, from the os/arch its one-liner
+   * reported; a host with no build gets a failing script and the grant
+   * stays unspent.
+   */
+  async openNodeInstall(
+    token: string,
+    os?: string | null,
+    arch?: string | null,
+  ): Promise<{ script: string; filename: string } | null> {
+    if (this.provision.isPending(token)) {
+      const goos = normalizeGoos(os);
+      const goarch = normalizeGoarch(arch);
+      if (!goos || !goarch) {
+        return {
+          script: installRefusalScript(
+            `no talon-node build for os=${os ?? ""} arch=${arch ?? ""}`,
+          ),
+          filename: "install-talon-node.txt",
+        };
+      }
+      try {
+        const bin = await this.resolveNode(goos, goarch);
+        this.provision.pin(token, {
+          goos,
+          goarch,
+          binaryPath: bin.path,
+          sha256: bin.sha256,
+          size: bin.size,
+          version: bin.version,
+        });
+      } catch (err) {
+        return {
+          script: installRefusalScript(
+            `could not resolve talon-node for ${goos}/${goarch}: ${(err as Error).message}`,
+          ),
+          filename: "install-talon-node.txt",
+        };
+      }
+    }
     return this.provision.openScript(token);
   }
 
@@ -355,6 +424,15 @@ export class BridgeLinks {
   }
 }
 
+/** An omitted tool argument: absent, or an empty/whitespace string. */
+function isBlank(value: unknown): boolean {
+  return (
+    value === undefined ||
+    value === null ||
+    (typeof value === "string" && !value.trim())
+  );
+}
+
 /** Error text for an os/arch pair outside the talon-node build matrix. */
 function unknownTargetText(os: unknown, arch: unknown): string {
   return `No talon-node target for os="${String(os)}", arch="${String(arch)}". Supported: ${NODE_TARGETS.map(

package/src/core/mesh/links/node-provision.ts

@@ -9,6 +9,12 @@
  *   GET /node/install?provision=<token>   → installer script (once)
  *   GET /node/binary?provision=<token>    → the binary itself (once)
  *
+ * A grant can also be minted WITHOUT a target ("auto"): the one-liner then
+ * reports the host's own `uname -s`/`uname -m` (or PowerShell's
+ * PROCESSOR_ARCHITECTURE) on the script fetch, and the caller resolves the
+ * binary and pins it into the grant before the script is rendered — so the
+ * script still embeds the digest and nothing about integrity changes.
+ *
  * The routes must work pre-auth — the whole point is a host that holds no
  * bridge credential yet — so the grant token IS the authorization, exactly
  * like streamed-transfer tokens (transfers/transfers.ts): random 192-bit, single-use
@@ -56,8 +62,22 @@ export type NodeProvisionGrant = {
   binaryUsed: boolean;
 };
 
+/** The fields an auto grant is missing until the target host reports in. */
+export type NodeProvisionTarget = Pick<
+  NodeProvisionGrant,
+  "goos" | "goarch" | "binaryPath" | "sha256" | "size" | "version"
+>;
+
+/** An auto grant before its target is known — everything but the binary. */
+export type PendingNodeProvision = Omit<
+  NodeProvisionGrant,
+  keyof NodeProvisionTarget | "scriptUsed" | "binaryUsed"
+>;
+
 export class NodeProvisionStore {
   private readonly grants = new Map<string, NodeProvisionGrant>();
+  /** Auto grants whose target host hasn't fetched the script yet. */
+  private readonly pending = new Map<string, PendingNodeProvision>();
 
   constructor(private readonly ttlMs = GRANT_TTL_MS) {}
 
@@ -70,11 +90,7 @@ export class NodeProvisionStore {
     this.sweep();
     const full: NodeProvisionGrant = {
       ...grant,
-      // Device names are injected into generated shell/PowerShell text —
-      // keep them to characters that can't break out of a quoted string.
-      ...(grant.name
-        ? { name: grant.name.replace(/[^\w .-]+/g, "").slice(0, 64) }
-        : {}),
+      ...sanitizedName(grant.name),
       token: randomBytes(24).toString("base64url"),
       createdAt: Date.now(),
       scriptUsed: false,
@@ -84,6 +100,48 @@ export class NodeProvisionStore {
     return full;
   }
 
+  /**
+   * Mint an auto grant: no target yet. {@link pin} fills it in when the host
+   * fetches the script and reports its own os/arch.
+   */
+  createAuto(
+    grant: Omit<PendingNodeProvision, "token" | "createdAt">,
+  ): PendingNodeProvision {
+    this.sweep();
+    const pending: PendingNodeProvision = {
+      ...grant,
+      ...sanitizedName(grant.name),
+      token: randomBytes(24).toString("base64url"),
+      createdAt: Date.now(),
+    };
+    this.pending.set(pending.token, pending);
+    return pending;
+  }
+
+  /** Whether `token` is a live auto grant still waiting for its target. */
+  isPending(token: string): boolean {
+    this.sweep();
+    return this.pending.has(token);
+  }
+
+  /**
+   * Bind an auto grant to the binary for its host. It becomes an ordinary
+   * grant under the same token (same TTL clock); a second pin is a no-op.
+   */
+  pin(token: string, target: NodeProvisionTarget): boolean {
+    this.sweep();
+    const pending = this.pending.get(token);
+    if (!pending) return false;
+    this.pending.delete(token);
+    this.grants.set(token, {
+      ...pending,
+      ...target,
+      scriptUsed: false,
+      binaryUsed: false,
+    });
+    return true;
+  }
+
   /** Serve the installer script for a live grant — once. */
   openScript(token: string): { script: string; filename: string } | null {
     const grant = this.claim(token, "scriptUsed");
@@ -121,9 +179,20 @@ export class NodeProvisionStore {
     for (const [token, grant] of this.grants) {
       if (grant.createdAt < cutoff) this.grants.delete(token);
     }
+    for (const [token, grant] of this.pending) {
+      if (grant.createdAt < cutoff) this.pending.delete(token);
+    }
   }
 }
 
+/**
+ * Device names are injected into generated shell/PowerShell text — keep them
+ * to characters that can't break out of a quoted string.
+ */
+function sanitizedName(name: string | undefined): { name?: string } {
+  return name ? { name: name.replace(/[^\w .-]+/g, "").slice(0, 64) } : {};
+}
+
 /**
  * Anything that could end, expand, or escape inside a quoted sh,
  * PowerShell, or cmd.exe string: both quote kinds, `$`, backtick,
@@ -257,6 +326,46 @@ export function installOneLiner(grant: NodeProvisionGrant): string {
   );
 }
 
+/**
+ * The two commands for an auto grant — one per shell family, pinned exactly
+ * like {@link installOneLiner}. Each appends its host's platform to the
+ * script fetch; the bridge maps `Linux`/`Darwin`, `x86_64`/`aarch64`/
+ * `armv7l`, and PowerShell's `AMD64`/`ARM64` through the same normalizers
+ * the tool arguments use.
+ *
+ * The PowerShell line carries one `$` (`$env:PROCESSOR_ARCHITECTURE`): from
+ * cmd.exe it reaches PowerShell verbatim, and from a PowerShell prompt the
+ * outer double quotes expand it first — the same value either way.
+ */
+export function autoInstallOneLiners(
+  grant: Pick<
+    NodeProvisionGrant,
+    "bridgeUrl" | "token" | "fingerprint" | "spkiPin"
+  >,
+): { posix: string; windows: string } {
+  const url = `${grant.bridgeUrl}/node/install?provision=${grant.token}`;
+  const posix = `curl ${curlFlags(grant.spkiPin)} "${sh(url)}&os=$(uname -s)&arch=$(uname -m)" | sh`;
+  const psUrl = `('${psq(url)}&os=windows&arch=' + $env:PROCESSOR_ARCHITECTURE)`;
+  const windows = grant.fingerprint
+    ? `powershell -ExecutionPolicy Bypass -Command "` +
+      `${psPinSetup(grant.fingerprint)}; ` +
+      `iex ([TalonPin]::Get${psUrl})"`
+    : `powershell -ExecutionPolicy Bypass -Command "` +
+      `[Net.ServicePointManager]::ServerCertificateValidationCallback={$true}; ` +
+      `iwr -UseBasicParsing ${psUrl} | Select-Object -ExpandProperty Content | iex"`;
+  return { posix, windows };
+}
+
+/**
+ * What an auto grant serves when the host's platform has no build or the
+ * binary can't be resolved: a script that fails loudly. Valid as both POSIX
+ * sh and PowerShell, since which shell is piping it isn't known.
+ */
+export function installRefusalScript(reason: string): string {
+  const safe = reason.replace(/["'`$\\%\n\r]+/g, " ").slice(0, 300);
+  return `echo "talon-node install refused: ${safe}"\nexit 1\n`;
+}
+
 /**
  * POSIX installer: fetch the binary over the same grant (pinned like the
  * script fetch), verify its digest, install it next to the node's config,

package/src/core/tools/ops/mesh.ts

@@ -235,12 +235,20 @@ export const meshTools: ToolDefinition[] = [
   {
     name: "make_node_install_link",
     description:
-      "Mint a single-use install link served by this daemon's bridge and return the one command that attaches a fresh Linux/macOS/Windows host to the mesh as a headless talon-node. Running it on the host downloads the installer script and binary from the bridge (sha256-verified), installs talon-node, pre-pins the bridge TLS certificate, embeds the bearer token, and registers a boot service — no toolchain, package manager, or manual config on the host. The link expires in 30 minutes and each leg serves exactly once; the host only needs to reach the bridge URL. Requires the native bridge running on a non-loopback bind with a token.",
+      "Mint a single-use install link served by this daemon's bridge and return the one command that attaches a fresh Linux/macOS/Windows host to the mesh as a headless talon-node. Running it on the host downloads the installer script and binary from the bridge (sha256-verified), installs talon-node, pre-pins the bridge TLS certificate, embeds the bearer token, and registers a boot service — no toolchain, package manager, or manual config on the host. Omit os and arch when you don't know the host: you get a POSIX and a PowerShell command, and whichever runs reports its own platform so the bridge picks the right binary. The link expires in 30 minutes and each leg serves exactly once; the host only needs to reach the bridge URL. Requires the native bridge running on a non-loopback bind with a token.",
     schema: {
-      os: z.string().describe("Host OS: linux, macos/darwin, or windows."),
+      os: z
+        .string()
+        .optional()
+        .describe(
+          "Host OS: linux, macos/darwin, or windows. Omit (with arch) to auto-detect on the host.",
+        ),
       arch: z
         .string()
-        .describe("Host arch: amd64/x86_64, arm64/aarch64, or arm."),
+        .optional()
+        .describe(
+          "Host arch: amd64/x86_64, arm64/aarch64, or arm. Omit (with os) to auto-detect on the host.",
+        ),
       name: z
         .string()
         .optional()
@@ -251,7 +259,7 @@ export const meshTools: ToolDefinition[] = [
         .string()
         .optional()
         .describe(
-          "Bridge base URL as reachable FROM the new host (e.g. https://100.64.0.7:19880). Default: derived from the bridge bind (wildcard binds use this host's first external IPv4).",
+          "Bridge base URL as reachable FROM the new host (e.g. https://100.64.0.7:19880). Default: native.publicUrl when set, else derived from the bridge bind (wildcard binds use this host's first external IPv4).",
         ),
     },
     execute: (params, bridge) => bridge("make_node_install_link", params),

package/src/frontend/native/bridge/routes/host.ts

@@ -149,8 +149,18 @@ export type BridgeServerHandlers = {
     token: string,
     format: "html" | "json",
   ): { contentType: string; body: string } | null;
-  /** Resolve a node-provisioning token to its installer script, or null. */
-  openNodeInstall(token: string): { script: string; filename: string } | null;
+  /**
+   * Resolve a node-provisioning token to its installer script, or null. An
+   * auto link passes the os/arch its host reported.
+   */
+  openNodeInstall(
+    token: string,
+    os?: string | null,
+    arch?: string | null,
+  ):
+    | { script: string; filename: string }
+    | null
+    | Promise<{ script: string; filename: string } | null>;
   /** Resolve a node-provisioning token to the binary to stream, or null. */
   openNodeBinary(token: string): { path: string; size: number } | null;
 };

package/src/frontend/native/bridge/routes/pre-auth.ts

@@ -73,9 +73,15 @@ export function preAuthRoutes(
     // the single-use grant token (minted by make_node_install_link,
     // expiring, one serve per leg) is the entire authorization, the same
     // trust model as streamed-transfer tokens.
-    "GET /node/install": ({ res, url }) => {
+    "GET /node/install": async ({ res, url }) => {
       const token = url.searchParams.get("provision") ?? "";
-      const install = token ? h.openNodeInstall(token) : null;
+      const install = token
+        ? await h.openNodeInstall(
+            token,
+            url.searchParams.get("os"),
+            url.searchParams.get("arch"),
+          )
+        : null;
       if (!install) return host.unknownProvision(res);
       res.writeHead(200, {
         "Content-Type": "text/plain; charset=utf-8",

package/src/frontend/native/surface/handlers.ts

@@ -191,7 +191,7 @@ export function buildBridgeHandlers(
     openFileDownload: (token, fromDeviceId) =>
       mesh.openFileDownload(token, fromDeviceId),
     openCompanionPair: (token, format) => mesh.openCompanionPair(token, format),
-    openNodeInstall: (token) => mesh.openNodeInstall(token),
+    openNodeInstall: (token, os, arch) => mesh.openNodeInstall(token, os, arch),
     openNodeBinary: (token) => mesh.openNodeBinary(token),
   };
 }