talon-agent 3.3.0 → 3.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.3.0",
+  "version": "3.4.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/core/engine/gateway-actions/mesh.ts

@@ -58,11 +58,23 @@ export const meshHandlers: SharedActionHandlers = {
       body.remote_path,
     ),
   // Remote self-update for a headless talon-node: push a new binary and have
-  // the node verify, swap, and restart into it.
+  // the node verify, swap, and restart into it. binary_path is optional —
+  // omitted, the daemon resolves the right build for the node's
+  // platform/arch itself (source build or verified release download).
   update_node: (body) =>
     getMeshService().updateNodeBinary(
       body.device,
       body.binary_path,
       body.remote_path,
     ),
+  // Node provisioning: materialize a talon-node binary for any arch, and
+  // mint single-use bridge-served install links for fresh hosts.
+  get_node_binary: (body) => getMeshService().getNodeBinary(body.os, body.arch),
+  make_node_install_link: (body) =>
+    getMeshService().makeNodeInstallLink(
+      body.os,
+      body.arch,
+      body.name,
+      body.bridge_url,
+    ),
 };

package/src/core/mesh/node-binaries.ts

@@ -0,0 +1,393 @@
+/**
+ * Node-binary resolver — materializes a talon-node binary for any supported
+ * platform/arch, whatever shape this daemon was installed in.
+ *
+ * The old flow required a source checkout plus a Go toolchain (`update_node`
+ * only took a path the caller had built). This resolver keeps that path and
+ * adds two more, tried in order:
+ *
+ *   1. source build — running from a git checkout with Go on PATH: cross-
+ *      compile apps/node for the requested target (always rebuilt, so a dev
+ *      daemon ships its working-tree code, stamped <version>+<sha>).
+ *   2. cache — ~/.talon/node-bin/<talon-version>/talon-node-<os>-<arch>,
+ *      re-verified against its recorded digest on every hit.
+ *   3. release download — the GitHub release matching THIS daemon's version
+ *      publishes the full binary matrix plus a talon-node-SHA256SUMS
+ *      manifest (built by .github/workflows/node.yml); fetch, verify the
+ *      digest, and cache. This is what makes prebuilt installs (npm, deb,
+ *      standalone binary) able to provision nodes at all.
+ *
+ * Version lock is structural: cache keys and release URLs both derive from
+ * `talonVersion()`, so a resolved binary always matches the daemon exactly.
+ */
+
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  chmod,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { TalonError } from "../errors.js";
+import { getRepoRoot } from "../update/self-update.js";
+import { dirs } from "../../util/paths.js";
+import { talonVersion } from "../../util/version.js";
+import type { DevicePlatform } from "./types.js";
+
+/** A cross-compile target, named exactly as Go (and the release assets) do. */
+export type NodeTarget = {
+  goos: "linux" | "darwin" | "windows";
+  goarch: string;
+};
+
+/** The supported matrix — mirrors apps/node/tools/build/main.go. */
+export const NODE_TARGETS: readonly NodeTarget[] = [
+  { goos: "linux", goarch: "amd64" },
+  { goos: "linux", goarch: "arm64" },
+  { goos: "linux", goarch: "arm" },
+  { goos: "darwin", goarch: "amd64" },
+  { goos: "darwin", goarch: "arm64" },
+  { goos: "windows", goarch: "amd64" },
+];
+
+const SUMS_ASSET = "talon-node-SHA256SUMS";
+const RELEASE_BASE = "https://github.com/dylanneve1/talon/releases/download";
+const DOWNLOAD_TIMEOUT_MS = 120_000;
+const BUILD_TIMEOUT_MS = 300_000;
+
+export type ResolvedNodeBinary = {
+  path: string;
+  /** Full stamp the binary reports (release: the semver; build: semver+sha). */
+  version: string;
+  sha256: string;
+  size: number;
+  /** Which tier produced it. */
+  source: "source-build" | "cache" | "release";
+};
+
+export type ResolveNodeBinaryOptions = {
+  /** Cache root (default ~/.talon/node-bin). */
+  cacheRoot?: string;
+  /** Source checkout root; null disables the build tier (default: detect). */
+  repoRoot?: string | null;
+  /** Release download (test seam). */
+  fetchImpl?: typeof fetch;
+  /** Daemon version override (test seam). */
+  version?: string;
+};
+
+/** The resolver's function shape — the seam MeshService accepts in tests. */
+export type NodeBinaryResolver = (
+  goos: string,
+  goarch: string,
+  opts?: ResolveNodeBinaryOptions,
+) => Promise<ResolvedNodeBinary>;
+
+/** Release asset / on-disk name for one target. */
+export function nodeAssetName(goos: string, goarch: string): string {
+  return `talon-node-${goos}-${goarch}${goos === "windows" ? ".exe" : ""}`;
+}
+
+/**
+ * Normalize a caller-supplied OS ("macos", "darwin", "Linux") to a matrix
+ * GOOS, or undefined for anything outside it.
+ */
+export function normalizeGoos(value: unknown): NodeTarget["goos"] | undefined {
+  const v = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (v === "macos" || v === "darwin" || v === "osx") return "darwin";
+  if (v === "linux") return "linux";
+  if (v === "windows" || v === "win32") return "windows";
+  return undefined;
+}
+
+/** Normalize a caller-supplied arch ("x86_64", "aarch64") to a Go arch. */
+export function normalizeGoarch(value: unknown): string | undefined {
+  const v = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (v === "amd64" || v === "x86_64" || v === "x64") return "amd64";
+  if (v === "arm64" || v === "aarch64") return "arm64";
+  if (v === "arm" || v === "armv7" || v === "armv7l") return "arm";
+  return undefined;
+}
+
+/** Map a mesh platform onto a node GOOS (mobile platforms have no node). */
+export function platformToGoos(
+  platform: DevicePlatform,
+): NodeTarget["goos"] | undefined {
+  return normalizeGoos(platform === "macos" ? "darwin" : platform);
+}
+
+function isSupported(goos: string, goarch: string): boolean {
+  return NODE_TARGETS.some((t) => t.goos === goos && t.goarch === goarch);
+}
+
+/**
+ * Resolve a node binary for `goos`/`goarch`. Throws with an operator-facing
+ * message when every tier fails — callers surface it verbatim.
+ */
+export async function resolveNodeBinary(
+  goos: string,
+  goarch: string,
+  opts: ResolveNodeBinaryOptions = {},
+): Promise<ResolvedNodeBinary> {
+  if (!isSupported(goos, goarch)) {
+    throw new TalonError(
+      `No talon-node target for ${goos}/${goarch}. Supported: ${NODE_TARGETS.map(
+        (t) => `${t.goos}/${t.goarch}`,
+      ).join(", ")}.`,
+      { reason: "bad_request" },
+    );
+  }
+  const version = opts.version ?? talonVersion();
+  const cacheRoot = opts.cacheRoot ?? resolve(dirs.root, "node-bin");
+  const repoRoot = opts.repoRoot === undefined ? getRepoRoot() : opts.repoRoot;
+
+  const errors: string[] = [];
+
+  if (repoRoot) {
+    try {
+      return await buildFromSource(repoRoot, goos, goarch, version, cacheRoot);
+    } catch (err) {
+      errors.push(`source build: ${(err as Error).message}`);
+    }
+  }
+
+  const cached = await fromCache(cacheRoot, version, goos, goarch);
+  if (cached) return cached;
+
+  try {
+    return await downloadFromRelease(
+      version,
+      goos,
+      goarch,
+      cacheRoot,
+      opts.fetchImpl ?? fetch,
+    );
+  } catch (err) {
+    errors.push(`release download: ${(err as Error).message}`);
+  }
+
+  throw new TalonError(
+    `Could not obtain talon-node ${goos}/${goarch} for Talon ${version} — ${errors.join("; ")}`,
+    { reason: "unknown" },
+  );
+}
+
+// ── Tier 1: source build ────────────────────────────────────────────────────
+
+async function buildFromSource(
+  repoRoot: string,
+  goos: string,
+  goarch: string,
+  version: string,
+  cacheRoot: string,
+): Promise<ResolvedNodeBinary> {
+  const nodeDir = join(repoRoot, "apps", "node");
+  await stat(join(nodeDir, "go.mod"));
+  // Dev builds land under their own key: they track the working tree, not a
+  // release, and are rebuilt on every resolve so they can never go stale.
+  const outDir = join(cacheRoot, "dev");
+  await mkdir(outDir, { recursive: true });
+  const dest = join(outDir, nodeAssetName(goos, goarch));
+  const stamp = `${version}+${await gitShortSha(repoRoot)}`;
+  await run(
+    "go",
+    [
+      "build",
+      "-trimpath",
+      "-ldflags",
+      `-s -w -X main.ldflagsVersion=${stamp}`,
+      "-o",
+      dest,
+      ".",
+    ],
+    nodeDir,
+    { CGO_ENABLED: "0", GOOS: goos, GOARCH: goarch },
+    BUILD_TIMEOUT_MS,
+  );
+  const { sha256, size } = await hashFile(dest);
+  return { path: dest, version: stamp, sha256, size, source: "source-build" };
+}
+
+async function gitShortSha(repoRoot: string): Promise<string> {
+  try {
+    return (
+      await run("git", ["rev-parse", "--short", "HEAD"], repoRoot, {}, 10_000)
+    ).trim();
+  } catch {
+    return "dev";
+  }
+}
+
+function run(
+  cmd: string,
+  args: string[],
+  cwd: string,
+  env: Record<string, string>,
+  timeoutMs: number,
+): Promise<string> {
+  return new Promise((res, rej) => {
+    execFile(
+      cmd,
+      args,
+      { cwd, env: { ...process.env, ...env }, timeout: timeoutMs },
+      (err, stdout, stderr) => {
+        if (err) {
+          rej(
+            new Error(
+              `${cmd} ${args[0]} failed: ${String(stderr || err.message)
+                .trim()
+                .slice(0, 500)}`,
+            ),
+          );
+        } else {
+          res(String(stdout));
+        }
+      },
+    );
+  });
+}
+
+// ── Tier 2: cache ───────────────────────────────────────────────────────────
+
+async function fromCache(
+  cacheRoot: string,
+  version: string,
+  goos: string,
+  goarch: string,
+): Promise<ResolvedNodeBinary | null> {
+  const path = join(cacheRoot, version, nodeAssetName(goos, goarch));
+  let recorded: string;
+  try {
+    recorded = (await readFile(`${path}.sha256`, "utf8")).trim();
+  } catch {
+    return null;
+  }
+  try {
+    const { sha256, size } = await hashFile(path);
+    if (size > 0 && sha256 === recorded) {
+      return { path, version, sha256, size, source: "cache" };
+    }
+  } catch {
+    // Fall through — a corrupt entry is re-downloaded, not fatal.
+  }
+  await rm(path, { force: true }).catch(() => {});
+  await rm(`${path}.sha256`, { force: true }).catch(() => {});
+  return null;
+}
+
+// ── Tier 3: release download ────────────────────────────────────────────────
+
+async function downloadFromRelease(
+  version: string,
+  goos: string,
+  goarch: string,
+  cacheRoot: string,
+  fetchImpl: typeof fetch,
+): Promise<ResolvedNodeBinary> {
+  const asset = nodeAssetName(goos, goarch);
+  const base = `${RELEASE_BASE}/v${version}`;
+  const sums = parseSums(await fetchText(fetchImpl, `${base}/${SUMS_ASSET}`));
+  const expected = sums.get(asset);
+  if (!expected) {
+    throw new TalonError(
+      `${SUMS_ASSET} for v${version} has no entry for ${asset}`,
+      { reason: "bad_request" },
+    );
+  }
+  const body = await fetchBytes(fetchImpl, `${base}/${asset}`);
+  const sha256 = createHash("sha256").update(body).digest("hex");
+  if (sha256 !== expected) {
+    throw new TalonError(
+      `digest mismatch for ${asset} (expected ${expected.slice(0, 12)}…, got ${sha256.slice(0, 12)}…) — refusing to cache`,
+      { reason: "unknown" },
+    );
+  }
+  const dir = join(cacheRoot, version);
+  await mkdir(dir, { recursive: true });
+  const dest = join(dir, asset);
+  const tmp = `${dest}.tmp-${process.pid}`;
+  await writeFile(tmp, body);
+  await chmod(tmp, 0o755);
+  await rename(tmp, dest);
+  await writeFile(`${dest}.sha256`, `${sha256}\n`);
+  await pruneStaleVersions(cacheRoot, version);
+  return { path: dest, version, sha256, size: body.length, source: "release" };
+}
+
+/** Parse "<hex>  <name>" manifest lines (the `sha256sum` format). */
+function parseSums(text: string): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const line of text.split("\n")) {
+    const m = /^([0-9a-f]{64})\s+\*?(\S+)\s*$/.exec(line.trim());
+    if (m) out.set(m[2]!, m[1]!);
+  }
+  return out;
+}
+
+async function fetchText(
+  fetchImpl: typeof fetch,
+  url: string,
+): Promise<string> {
+  const res = await fetchImpl(url, {
+    redirect: "follow",
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    throw new TalonError(`GET ${url}: HTTP ${res.status}`, {
+      reason: "network",
+      retryable: true,
+      status: res.status,
+    });
+  }
+  return res.text();
+}
+
+async function fetchBytes(
+  fetchImpl: typeof fetch,
+  url: string,
+): Promise<Buffer> {
+  const res = await fetchImpl(url, {
+    redirect: "follow",
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    throw new TalonError(`GET ${url}: HTTP ${res.status}`, {
+      reason: "network",
+      retryable: true,
+      status: res.status,
+    });
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
+
+/** Drop cached matrices for other Talon versions — they can never be used
+ *  again (the resolver only serves version-exact binaries). Best-effort. */
+async function pruneStaleVersions(
+  cacheRoot: string,
+  keep: string,
+): Promise<void> {
+  try {
+    for (const entry of await readdir(cacheRoot)) {
+      if (entry === keep || entry === "dev") continue;
+      await rm(join(cacheRoot, entry), { recursive: true, force: true });
+    }
+  } catch {
+    // Cache hygiene only — never fail a resolve over it.
+  }
+}
+
+async function hashFile(
+  path: string,
+): Promise<{ sha256: string; size: number }> {
+  const data = await readFile(path);
+  return {
+    sha256: createHash("sha256").update(data).digest("hex"),
+    size: data.length,
+  };
+}

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

@@ -0,0 +1,190 @@
+/**
+ * NodeProvisionStore — one-time grants that turn a fresh host into a mesh
+ * node with a single command.
+ *
+ * The daemon mints a grant bound to one resolved binary (path + digest) and
+ * one target platform; the bridge serves two UNAUTHENTICATED but
+ * token-gated routes against it:
+ *
+ *   GET /node/install?provision=<token>   → installer script (once)
+ *   GET /node/binary?provision=<token>    → the binary itself (once)
+ *
+ * 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.ts): random 192-bit, single-use
+ * per leg, expiring unused. The script carries the bridge bearer token and
+ * pinned TLS fingerprint into the node's config, verifies the downloaded
+ * binary against the grant's digest (integrity is the script's own sha256
+ * check, not TLS), installs it, and registers the boot service via
+ * `talon-node install`.
+ */
+
+import { randomBytes } from "node:crypto";
+
+/** Unclaimed grants die after this long. */
+const GRANT_TTL_MS = 30 * 60 * 1000;
+
+export type NodeProvisionGrant = {
+  token: string;
+  goos: "linux" | "darwin" | "windows";
+  goarch: string;
+  /** Device name baked into the installer (optional — defaults to hostname). */
+  name?: string;
+  /** The resolved binary this grant serves. */
+  binaryPath: string;
+  sha256: string;
+  size: number;
+  version: string;
+  /** Bridge base URL as reachable from the target host. */
+  bridgeUrl: string;
+  /** Bridge bearer token the node will authenticate with. */
+  bearerToken: string;
+  /** Bridge TLS certificate fingerprint to pre-pin (absent over plain HTTP). */
+  fingerprint?: string;
+  createdAt: number;
+  scriptUsed: boolean;
+  binaryUsed: boolean;
+};
+
+export class NodeProvisionStore {
+  private readonly grants = new Map<string, NodeProvisionGrant>();
+
+  constructor(private readonly ttlMs = GRANT_TTL_MS) {}
+
+  create(
+    grant: Omit<
+      NodeProvisionGrant,
+      "token" | "createdAt" | "scriptUsed" | "binaryUsed"
+    >,
+  ): NodeProvisionGrant {
+    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) }
+        : {}),
+      token: randomBytes(24).toString("base64url"),
+      createdAt: Date.now(),
+      scriptUsed: false,
+      binaryUsed: false,
+    };
+    this.grants.set(full.token, full);
+    return full;
+  }
+
+  /** Serve the installer script for a live grant — once. */
+  openScript(token: string): { script: string; filename: string } | null {
+    const grant = this.claim(token, "scriptUsed");
+    if (!grant) return null;
+    return grant.goos === "windows"
+      ? {
+          script: powershellInstaller(grant),
+          filename: "install-talon-node.ps1",
+        }
+      : { script: shellInstaller(grant), filename: "install-talon-node.sh" };
+  }
+
+  /** Resolve the binary leg of a live grant — once. */
+  openBinary(token: string): { path: string; size: number } | null {
+    const grant = this.claim(token, "binaryUsed");
+    if (!grant) return null;
+    return { path: grant.binaryPath, size: grant.size };
+  }
+
+  /** Expire-check + single-use latch for one leg of a grant. */
+  private claim(
+    token: string,
+    leg: "scriptUsed" | "binaryUsed",
+  ): NodeProvisionGrant | null {
+    this.sweep();
+    const grant = this.grants.get(token);
+    if (!grant || grant[leg]) return null;
+    grant[leg] = true;
+    if (grant.scriptUsed && grant.binaryUsed) this.grants.delete(token);
+    return grant;
+  }
+
+  private sweep(): void {
+    const cutoff = Date.now() - this.ttlMs;
+    for (const [token, grant] of this.grants) {
+      if (grant.createdAt < cutoff) this.grants.delete(token);
+    }
+  }
+}
+
+/** The command a human (or the model over SSH) runs on the target host. */
+export function installOneLiner(grant: NodeProvisionGrant): string {
+  const url = `${grant.bridgeUrl}/node/install?provision=${grant.token}`;
+  if (grant.goos === "windows") {
+    // -k has no iwr flag; trust-all callback covers the self-signed bridge
+    // cert for the two fetches — the binary itself is digest-verified. The
+    // one-liner is meant for cmd.exe / PowerShell, where $true survives the
+    // outer double quotes verbatim.
+    return (
+      `powershell -ExecutionPolicy Bypass -Command "` +
+      `[Net.ServicePointManager]::ServerCertificateValidationCallback={$true}; ` +
+      `iwr -UseBasicParsing '${url}' | Select-Object -ExpandProperty Content | iex"`
+    );
+  }
+  return `curl -fsSk "${url}" | sh`;
+}
+
+/**
+ * POSIX installer: fetch the binary over the same grant, verify its digest,
+ * install it next to the node's config, and register the boot service. -k on
+ * the fetches is deliberate — the bridge cert is self-signed; integrity
+ * comes from the embedded sha256 and the fingerprint is pre-pinned into the
+ * node's config for every connection after install.
+ */
+function shellInstaller(grant: NodeProvisionGrant): string {
+  const nameFlag = grant.name ? ` --name "${grant.name}"` : "";
+  const fpFlag = grant.fingerprint
+    ? ` --fingerprint "${grant.fingerprint}"`
+    : "";
+  return `#!/bin/sh
+# talon-node installer — generated by Talon ${grant.version} for ${grant.goos}/${grant.goarch}
+set -eu
+BRIDGE="${grant.bridgeUrl}"
+SHA="${grant.sha256}"
+if [ "$(id -u)" = "0" ]; then DEST_DIR="\${TALON_NODE_DIR:-/usr/local/bin}"; else DEST_DIR="\${TALON_NODE_DIR:-$HOME/.talon-node/bin}"; fi
+mkdir -p "$DEST_DIR"
+TMP="$(mktemp)"
+trap 'rm -f "$TMP"' EXIT
+echo "Downloading talon-node ${grant.version} (${grant.goos}/${grant.goarch})..."
+curl -fsSk "$BRIDGE/node/binary?provision=${grant.token}" -o "$TMP"
+if command -v sha256sum >/dev/null 2>&1; then GOT="$(sha256sum "$TMP" | cut -d' ' -f1)"; else GOT="$(shasum -a 256 "$TMP" | cut -d' ' -f1)"; fi
+if [ "$GOT" != "$SHA" ]; then echo "talon-node download failed its checksum — refusing to install" >&2; exit 1; fi
+BIN="$DEST_DIR/talon-node"
+mv "$TMP" "$BIN"
+chmod 0755 "$BIN"
+trap - EXIT
+echo "Installed $BIN"
+"$BIN" install --bridge "$BRIDGE" --token "${grant.bearerToken}"${fpFlag}${nameFlag}
+echo "Done — this host is now on the mesh. Check with: $BIN status"
+`;
+}
+
+/** PowerShell installer (Windows PowerShell 5+ compatible). */
+function powershellInstaller(grant: NodeProvisionGrant): string {
+  const nameArg = grant.name ? `, "--name", "${grant.name}"` : "";
+  const fpArg = grant.fingerprint
+    ? `, "--fingerprint", "${grant.fingerprint}"`
+    : "";
+  return `# talon-node installer — generated by Talon ${grant.version} for ${grant.goos}/${grant.goarch}
+$ErrorActionPreference = "Stop"
+[Net.ServicePointManager]::ServerCertificateValidationCallback = { $true }
+$bridge = "${grant.bridgeUrl}"
+$dest = Join-Path $env:LOCALAPPDATA "talon-node"
+New-Item -ItemType Directory -Force -Path $dest | Out-Null
+$bin = Join-Path $dest "talon-node.exe"
+Write-Host "Downloading talon-node ${grant.version} (${grant.goos}/${grant.goarch})..."
+Invoke-WebRequest -UseBasicParsing "$bridge/node/binary?provision=${grant.token}" -OutFile $bin
+$got = (Get-FileHash $bin -Algorithm SHA256).Hash.ToLower()
+if ($got -ne "${grant.sha256}") { Remove-Item $bin; throw "talon-node download failed its checksum - refusing to install" }
+Write-Host "Installed $bin"
+& $bin install --bridge $bridge --token "${grant.bearerToken}"${fpArg}${nameArg}
+Write-Host "Done - this host is now on the mesh. Check with: $bin status"
+`;
+}

package/src/core/mesh/registry.ts

@@ -237,10 +237,12 @@ function sanitizeDevice(
   ) {
     return null;
   }
+  const arch = stringField(body.arch)?.toLowerCase().slice(0, 16);
   return {
     id: id ?? "",
     name: name ?? "",
     platform: platform ?? "linux",
+    ...(arch ? { arch } : {}),
     appVersion: appVersion ?? "",
     online: body.online === true,
     lastSeen: numberField(body.lastSeen) ?? now,

package/src/core/mesh/service.ts

@@ -30,11 +30,20 @@ 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 { networkInterfaces, tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import type { Readable } from "node:stream";
 import { clampExecOutput } from "../../util/exec-output.js";
 import { dirs } from "../../util/paths.js";
+import {
+  NODE_TARGETS,
+  normalizeGoarch,
+  normalizeGoos,
+  platformToGoos,
+  resolveNodeBinary,
+  type NodeBinaryResolver,
+} from "./node-binaries.js";
+import { installOneLiner, NodeProvisionStore } from "./node-provision.js";
 import { MeshRegistry } from "./registry.js";
 import { TransferStore } from "./transfers.js";
 import type {
@@ -72,6 +81,25 @@ export type MeshServiceOptions = {
   pollIntervalMs?: number;
   /** How long a device command waits for its result before timing out. */
   commandTimeoutMs?: number;
+  /** Node-binary resolver override (tests — the real one builds/downloads). */
+  nodeBinaryResolver?: NodeBinaryResolver;
+};
+
+/**
+ * What the native bridge tells the mesh about itself once it's listening —
+ * everything a generated node installer needs to point a fresh host here.
+ * Registered by the native frontend after server start; null when the
+ * bridge isn't running (provisioning tools then fail with a clear reason).
+ */
+export type MeshBridgeInfo = {
+  scheme: "http" | "https";
+  /** The bind host from config — may be a wildcard (0.0.0.0/::). */
+  host: string;
+  port: number;
+  /** Bearer token clients authenticate with (absent on open loopback). */
+  token?: string;
+  /** TLS certificate SHA-256 (absent over plain HTTP). */
+  fingerprint?: string;
 };
 
 const DEFAULT_FRESH_FIX_TIMEOUT_MS = 8_000;
@@ -144,6 +172,10 @@ export class MeshService {
   private readonly receivedAt = new Map<string, number>();
   /** One-time tokens arranging streamed (single-HTTP-request) transfers. */
   private readonly transfers = new TransferStore();
+  /** One-time grants for bridge-served node installers. */
+  private readonly provision = new NodeProvisionStore();
+  private readonly resolveNode: NodeBinaryResolver;
+  private bridgeInfo: MeshBridgeInfo | null = null;
   private readonly freshFixTimeoutMs: number;
   private readonly pollIntervalMs: number;
   private readonly commandTimeoutMs: number;
@@ -158,6 +190,12 @@ export class MeshService {
     this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     this.commandTimeoutMs =
       options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+    this.resolveNode = options.nodeBinaryResolver ?? resolveNodeBinary;
+  }
+
+  /** The native bridge reports its reachable identity here (null on stop). */
+  setBridgeInfo(info: MeshBridgeInfo | null): void {
+    this.bridgeInfo = info;
   }
 
   /** Hydrate persisted devices/locations. Idempotent — safe to await from
@@ -923,19 +961,17 @@ export class MeshService {
    *
    * The binary is hashed here and the digest travels with the command; the
    * node re-hashes the pushed file and refuses to swap on a mismatch, so a
-   * truncated transfer can never be installed. Build the replacement for the
-   * node's platform/arch (talon-node-<os>-<arch>) before calling.
+   * truncated transfer can never be installed.
+   *
+   * With no binary_path, the replacement is auto-resolved for the node's
+   * registered platform/arch (source build in a dev checkout, else the
+   * version-matched release download — see node-binaries.ts).
    */
   async updateNodeBinary(
     query: unknown,
-    localBinaryPath: unknown,
+    localBinaryPath?: unknown,
     remotePath?: unknown,
   ): Promise<MeshToolResult> {
-    const local =
-      typeof localBinaryPath === "string" && localBinaryPath.trim()
-        ? resolve(dirs.workspace, localBinaryPath.trim())
-        : "";
-    if (!local) return { ok: false, text: "A local binary path is required." };
     await this.load();
     const resolved = this.resolveDevice(query);
     if ("error" in resolved) return { ok: false, text: resolved.error };
@@ -947,6 +983,34 @@ export class MeshService {
       };
     }
 
+    let local: string;
+    let provenance = "";
+    if (typeof localBinaryPath === "string" && localBinaryPath.trim()) {
+      local = resolve(dirs.workspace, localBinaryPath.trim());
+    } else {
+      const goos = platformToGoos(target.platform);
+      if (!goos) {
+        return {
+          ok: false,
+          text: `${target.name} is a ${target.platform} device — update_node targets headless nodes only.`,
+        };
+      }
+      const goarch = normalizeGoarch(target.arch);
+      if (!goarch) {
+        return {
+          ok: false,
+          text: `${target.name} has not advertised its CPU architecture (a node build from before arch reporting). Pass binary_path explicitly for this update — after it, the node advertises arch and future updates auto-resolve.`,
+        };
+      }
+      try {
+        const bin = await this.resolveNode(goos, goarch);
+        local = bin.path;
+        provenance = ` (auto-resolved ${bin.version} for ${goos}/${goarch} via ${bin.source})`;
+      } catch (err) {
+        return { ok: false, text: (err as Error).message };
+      }
+    }
+
     let sha256: string;
     let size: number;
     try {
@@ -989,12 +1053,145 @@ export class MeshService {
     return {
       ok: true,
       text:
-        `Pushed ${formatBytes(size)} and staged the update on ${target.name}. ` +
+        `Pushed ${formatBytes(size)}${provenance} and staged the update on ${target.name}. ` +
         `${dispatched.result.message ?? "Restarting now."} ` +
         `Confirm with get_device_status once it reconnects (appVersion should change).`,
     };
   }
 
+  // ── Node provisioning ──────────────────────────────────────────────────────
+
+  /**
+   * `get_node_binary`: materialize a talon-node binary for any supported
+   * platform/arch on the daemon host — source build in a dev checkout, else
+   * the digest-verified release download (cached under ~/.talon/node-bin).
+   */
+  async getNodeBinary(os: unknown, arch: unknown): Promise<MeshToolResult> {
+    const goos = normalizeGoos(os);
+    const goarch = normalizeGoarch(arch);
+    if (!goos || !goarch) {
+      return { ok: false, text: unknownTargetText(os, arch) };
+    }
+    try {
+      const bin = await this.resolveNode(goos, goarch);
+      return {
+        ok: true,
+        text: `talon-node ${bin.version} for ${goos}/${goarch}: ${bin.path} (${formatBytes(bin.size)}, sha256 ${bin.sha256}, via ${bin.source})`,
+      };
+    } catch (err) {
+      return { ok: false, text: (err as Error).message };
+    }
+  }
+
+  /**
+   * `make_node_install_link`: mint a single-use provisioning URL on the
+   * bridge and return the one command that turns a fresh host into a mesh
+   * node — it fetches the installer script, which downloads the (digest-
+   * verified) binary from the same bridge, installs it, pre-pins the bridge
+   * certificate, and registers the boot service.
+   */
+  async makeNodeInstallLink(
+    os: unknown,
+    arch: unknown,
+    name?: unknown,
+    bridgeUrl?: unknown,
+  ): Promise<MeshToolResult> {
+    const goos = normalizeGoos(os);
+    const goarch = normalizeGoarch(arch);
+    if (!goos || !goarch) {
+      return { ok: false, text: unknownTargetText(os, arch) };
+    }
+    const info = this.bridgeInfo;
+    if (!info) {
+      return {
+        ok: false,
+        text: "The native bridge isn't running, so there is nothing for a new node to connect to. Enable the native frontend first.",
+      };
+    }
+    if (!info.token) {
+      return {
+        ok: false,
+        text: "The bridge has no bearer token (loopback-only bind), and nodes authenticate with one. Set native.host to a reachable address (a token is auto-minted) and restart.",
+      };
+    }
+    const base = this.bridgeBaseUrl(info, bridgeUrl);
+    if (typeof base !== "string") return { ok: false, text: base.error };
+    let bin;
+    try {
+      bin = await this.resolveNode(goos, goarch);
+    } catch (err) {
+      return { ok: false, text: (err as Error).message };
+    }
+    const grant = this.provision.create({
+      goos,
+      goarch,
+      ...(typeof name === "string" && name.trim() ? { name: name.trim() } : {}),
+      binaryPath: bin.path,
+      sha256: bin.sha256,
+      size: bin.size,
+      version: bin.version,
+      bridgeUrl: base,
+      bearerToken: info.token,
+      ...(info.fingerprint ? { fingerprint: info.fingerprint } : {}),
+    });
+    return {
+      ok: true,
+      text: [
+        `Run this on the new ${goos}/${goarch} host:`,
+        "",
+        `  ${installOneLiner(grant)}`,
+        "",
+        `It installs talon-node ${bin.version} (sha256-verified against ${grant.sha256.slice(0, 12)}…), pins the bridge certificate, and registers a boot service — the host appears on the mesh within a minute.`,
+        `Single-use link, expires in 30 minutes. The host must be able to reach ${base}.`,
+      ].join("\n"),
+    };
+  }
+
+  /** GET /node/install — serve a grant's installer script (single-use). */
+  openNodeInstall(token: string): { script: string; filename: string } | null {
+    return this.provision.openScript(token);
+  }
+
+  /** GET /node/binary — serve a grant's binary (single-use). */
+  openNodeBinary(token: string): { path: string; size: number } | null {
+    return this.provision.openBinary(token);
+  }
+
+  /**
+   * The bridge base URL a NEW host should dial: an explicit override wins;
+   * otherwise derive from the bridge's bind. A wildcard bind maps to this
+   * host's first external IPv4; a loopback bind is unreachable from other
+   * machines, so it's an error rather than a link that can't work.
+   */
+  private bridgeBaseUrl(
+    info: MeshBridgeInfo,
+    explicit?: unknown,
+  ): string | { error: string } {
+    if (typeof explicit === "string" && explicit.trim()) {
+      const url = explicit.trim().replace(/\/+$/, "");
+      if (!/^https?:\/\/\S+$/.test(url)) {
+        return { error: `bridge_url must be an http(s) URL, got "${url}".` };
+      }
+      return url;
+    }
+    let host = info.host;
+    if (host === "0.0.0.0" || host === "::") {
+      const external = firstExternalIPv4();
+      if (!external) {
+        return {
+          error:
+            "Could not determine this host's external address — pass bridge_url explicitly (the URL the new node should dial).",
+        };
+      }
+      host = external;
+    } else if (isLoopbackAddress(host)) {
+      return {
+        error: `The bridge is bound to loopback (${host}), which other machines can't reach. Set native.host to a reachable address, or pass bridge_url if a tunnel exposes it.`,
+      };
+    }
+    return `${info.scheme}://${host}:${info.port}`;
+  }
+
   /**
    * Chunked read of a remote file into a Buffer. Loops `read_file` with
    * increasing offsets until the device reports EOF.
@@ -1243,7 +1440,7 @@ export class MeshService {
 
   private deviceLine(device: DeviceInfo): string {
     const parts = [
-      `${device.name} [id: ${device.id}] (${device.platform})`,
+      `${device.name} [id: ${device.id}] (${device.platform}${device.arch ? `/${device.arch}` : ""})`,
       device.online ? "online" : "offline",
       `last seen ${age(Date.now() - device.lastSeen)}`,
     ];
@@ -1445,6 +1642,28 @@ function requirePath(value: unknown): string | undefined {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 
+/** 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(
+    (t) => `${t.goos}/${t.goarch}`,
+  ).join(", ")} (macos ≡ darwin, x86_64 ≡ amd64, aarch64 ≡ arm64).`;
+}
+
+/** First non-internal IPv4 on this host — the wildcard-bind fallback. */
+function firstExternalIPv4(): string | undefined {
+  for (const list of Object.values(networkInterfaces())) {
+    for (const iface of list ?? []) {
+      if (!iface.internal && iface.family === "IPv4") return iface.address;
+    }
+  }
+  return undefined;
+}
+
+function isLoopbackAddress(host: string): boolean {
+  const h = host.toLowerCase();
+  return h === "localhost" || h === "::1" || h.startsWith("127.");
+}
+
 /** Render an exec result: exit code headline + stdout/stderr blocks. */
 function formatExecResult(
   device: DeviceInfo,

package/src/core/mesh/types.ts

@@ -15,6 +15,13 @@ export type DeviceInfo = {
   id: string;
   name: string;
   platform: DevicePlatform;
+  /**
+   * CPU architecture in Go spelling (amd64/arm64/arm), as talon-node
+   * advertises it. Lets the daemon pick the right release binary for
+   * update_node without being told. Absent for companion apps and node
+   * builds that predate arch reporting.
+   */
+  arch?: string;
   appVersion: string;
   online: boolean;
   /** Epoch milliseconds. */
@@ -83,6 +90,7 @@ export function toDeviceInfo(
     id: value.id,
     name: value.name,
     platform: value.platform,
+    ...(value.arch ? { arch: value.arch } : {}),
     appVersion: value.appVersion,
     online: now - value.lastSeen <= offlineAfterMs && value.online,
     lastSeen: value.lastSeen,

package/src/core/tools/mesh.ts

@@ -188,13 +188,14 @@ export const meshTools: ToolDefinition[] = [
   {
     name: "update_node",
     description:
-      "Remotely update a headless talon-node (Linux/macOS/Windows server on the mesh): stream a new node binary from the daemon and have the node verify its hash, atomically swap its own binary, and restart into it. On Linux/macOS this is an in-place execve so the mesh connection returns within seconds; the node re-hashes the pushed file and refuses a truncated or mismatched binary. Build the replacement for the node's platform/arch first (talon-node-<os>-<arch>). Confirm success with get_device_status afterwards (appVersion should change). This is the node counterpart of update_device — use update_device for Android companions.",
+      "Remotely update a headless talon-node (Linux/macOS/Windows server on the mesh): stream a new node binary from the daemon and have the node verify its hash, atomically swap its own binary, and restart into it. On Linux/macOS this is an in-place execve so the mesh connection returns within seconds; the node re-hashes the pushed file and refuses a truncated or mismatched binary. With no binary_path, the daemon auto-resolves the right build for the node's registered platform/arch (source build in a dev checkout, else the digest-verified release download matching this Talon version) — the normal call is just update_node(device). Confirm success with get_device_status afterwards (appVersion should change). This is the node counterpart of update_device — use update_device for Android companions.",
     schema: {
       device: deviceParam,
       binary_path: z
         .string()
+        .optional()
         .describe(
-          "Path to the new talon-node binary, relative to the workspace (or absolute), built for the node's OS/arch.",
+          "Optional explicit binary, relative to the workspace (or absolute), built for the node's OS/arch. Omit to auto-resolve.",
         ),
       remote_path: z
         .string()
@@ -206,4 +207,42 @@ export const meshTools: ToolDefinition[] = [
     execute: (params, bridge) => bridge("update_node", params),
     tag: "mesh",
   },
+  {
+    name: "get_node_binary",
+    description:
+      "Materialize a talon-node binary (the headless mesh device) for any supported platform/arch on the daemon host and return its path, version, and sha256. Resolution order: built from source when running in a dev checkout with Go, else the cached copy, else the digest-verified download from this Talon version's GitHub release — so it works on prebuilt installs with no toolchain. Use it to stage a binary for manual deployment (scp, device_push_file); for onboarding a fresh host prefer make_node_install_link, and for updating an existing node just call update_node (which resolves automatically).",
+    schema: {
+      os: z.string().describe("Target OS: linux, macos/darwin, or windows."),
+      arch: z
+        .string()
+        .describe("Target arch: amd64/x86_64, arm64/aarch64, or arm."),
+    },
+    execute: (params, bridge) => bridge("get_node_binary", params),
+    tag: "mesh",
+  },
+  {
+    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.",
+    schema: {
+      os: z.string().describe("Host OS: linux, macos/darwin, or windows."),
+      arch: z
+        .string()
+        .describe("Host arch: amd64/x86_64, arm64/aarch64, or arm."),
+      name: z
+        .string()
+        .optional()
+        .describe(
+          "Device name to register with (default: the host's hostname).",
+        ),
+      bridge_url: z
+        .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).",
+        ),
+    },
+    execute: (params, bridge) => bridge("make_node_install_link", params),
+    tag: "mesh",
+  },
 ];

package/src/frontend/native/index.ts

@@ -1194,6 +1194,8 @@ export function createNativeFrontend(
     completeCommand: (body) => mesh.completeCommand(body),
     acceptFileUpload: (token, body) => mesh.acceptFileUpload(token, body),
     openFileDownload: (token) => mesh.openFileDownload(token),
+    openNodeInstall: (token) => mesh.openNodeInstall(token),
+    openNodeBinary: (token) => mesh.openNodeBinary(token),
   };
 
   const nativeCfg = config.native ?? { port: 19880, host: "127.0.0.1" };
@@ -1278,6 +1280,15 @@ export function createNativeFrontend(
       chats.restore();
       await server.start();
       const fingerprint = server.getFingerprint();
+      // Tell the mesh how this bridge is reachable — everything a generated
+      // node installer needs (make_node_install_link fails cleanly without it).
+      mesh.setBridgeInfo({
+        scheme: server.getScheme(),
+        host: bridgeHost,
+        port: server.getPort(),
+        ...(bridgeToken ? { token: bridgeToken } : {}),
+        ...(fingerprint ? { fingerprint } : {}),
+      });
       await writeBridgeDiscovery({
         port: server.getPort(),
         token: bridgeToken,
@@ -1297,6 +1308,7 @@ export function createNativeFrontend(
     async stop() {
       unregisterMeshTransport?.();
       unregisterMeshTransport = null;
+      mesh.setBridgeInfo(null);
       await removeBridgeDiscovery();
       await server.stop();
       await gateway.stop();

package/src/frontend/native/server.ts

@@ -142,6 +142,10 @@ export type BridgeServerHandlers = {
   openFileDownload(
     token: string,
   ): Promise<{ path: string; size: number } | 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 the binary to stream, or null. */
+  openNodeBinary(token: string): { path: string; size: number } | null;
 };
 
 const SSE_PING_MS = 25_000;
@@ -377,6 +381,45 @@ export class BridgeServer {
       });
     }
 
+    // Node provisioning runs PRE-AUTH by design: the target host holds no
+    // bridge credential yet — 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.
+    if (
+      method === "GET" &&
+      (path === "/node/install" || path === "/node/binary")
+    ) {
+      const token = url.searchParams.get("provision") ?? "";
+      const unknown = () =>
+        this.json(res, 404, {
+          ok: false,
+          error: "Unknown, expired, or already-used provisioning token",
+        });
+      if (!token) return unknown();
+      if (path === "/node/install") {
+        const install = this.handlers.openNodeInstall(token);
+        if (!install) return unknown();
+        res.writeHead(200, {
+          "Content-Type": "text/plain; charset=utf-8",
+          "Content-Disposition": `attachment; filename="${install.filename}"`,
+          ...this.corsHeaders(),
+        });
+        res.end(install.script);
+        return;
+      }
+      const binary = this.handlers.openNodeBinary(token);
+      if (!binary) return unknown();
+      res.writeHead(200, {
+        "Content-Type": "application/octet-stream",
+        "Content-Length": String(binary.size),
+        ...this.corsHeaders(),
+      });
+      const stream = createReadStream(binary.path);
+      stream.on("error", () => res.destroy());
+      stream.pipe(res);
+      return;
+    }
+
     if (auth !== "ok") {
       return this.json(res, 401, { ok: false, error: "Unauthorized" });
     }

package/src/util/version.ts

@@ -0,0 +1,16 @@
+/**
+ * The daemon's own release version, as a runtime value.
+ *
+ * A JSON import (not an fs read) so every packaging shape agrees: tsx and
+ * Node resolve the file, and `bun build --compile` inlines it into the
+ * standalone binary, where no package.json exists on disk. This is the
+ * version the node-binary resolver keys caches and release-asset URLs on,
+ * so it must exactly match the published tag (publish.yml verifies that).
+ */
+
+import pkg from "../../package.json" with { type: "json" };
+
+/** Talon's semver (e.g. "3.3.0") — the release identity of this build. */
+export function talonVersion(): string {
+  return pkg.version;
+}