talon-agent 3.1.1 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -103,7 +103,7 @@
     "@kilocode/sdk": "^7.2.22",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@openai/agents": "^0.13.0",
-    "@openai/codex-sdk": "^0.144.0",
+    "@openai/codex-sdk": "^0.145.0",
     "@opencode-ai/sdk": "^1.17.4",
     "@playwright/mcp": "^0.0.78",
     "@types/cross-spawn": "^6.0.6",

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

@@ -57,4 +57,12 @@ export const meshHandlers: SharedActionHandlers = {
       body.apk_path,
       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.
+  update_node: (body) =>
+    getMeshService().updateNodeBinary(
+      body.device,
+      body.binary_path,
+      body.remote_path,
+    ),
 };

package/src/core/mesh/service.ts

@@ -54,6 +54,17 @@ export type MeshTransport = {
 
 export type MeshToolResult = { ok: boolean; text: string };
 
+/** Outcome of pinging one device (see {@link MeshService.pingAll}). */
+export type MeshPingResult = {
+  device: DeviceInfo;
+  /** True when the device answered the probe (offline devices are false). */
+  reachable: boolean;
+  /** Round-trip time of the probe, present only when reachable. */
+  latencyMs?: number;
+  /** Why the probe didn't land (offline, no transport, timeout). */
+  error?: string;
+};
+
 export type MeshServiceOptions = {
   /** How long a locate waits for a fresh fix before last-known fallback. */
   freshFixTimeoutMs?: number;
@@ -308,6 +319,36 @@ export class MeshService {
     };
   }
 
+  /**
+   * Ping every registered device: read the registry, then actively probe
+   * each ONLINE device with a lightweight `status` command (concurrently)
+   * and measure round-trip latency. Offline devices are reported from
+   * presence without a probe (a probe would just burn the timeout). The
+   * structured result powers frontend surfaces like Telegram's /mesh — the
+   * mesh tools stay text-only for the model, this is for humans.
+   */
+  async pingAll(timeoutMs = 5_000): Promise<MeshPingResult[]> {
+    const { devices } = await this.list();
+    const hasTransport = this.transports.size > 0;
+    return Promise.all(
+      devices.map(async (device): Promise<MeshPingResult> => {
+        if (!device.online) return { device, reachable: false };
+        if (!hasTransport) {
+          return { device, reachable: false, error: "no transport connected" };
+        }
+        const start = Date.now();
+        const result = await this.sendCommand(device, "status", {}, timeoutMs);
+        return result.ok
+          ? { device, reachable: true, latencyMs: Date.now() - start }
+          : {
+              device,
+              reachable: false,
+              error: result.message ?? "no response",
+            };
+      }),
+    );
+  }
+
   /**
    * `get_device_location`: resolve the target (id, name fragment, or the
    * most recent mobile device), push a locate to connected transports, wait
@@ -873,6 +914,87 @@ export class MeshService {
     };
   }
 
+  /**
+   * `update_node`: remote self-update for a headless talon-node. Streams a
+   * replacement binary to the node, then sends `update_node` so the node
+   * verifies the digest, atomically swaps its own binary, and restarts into
+   * it (an in-place execve under systemd/launchd, so the mesh connection
+   * returns on its own within seconds — the same UX as the Android path).
+   *
+   * 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.
+   */
+  async updateNodeBinary(
+    query: 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 };
+    const target = resolved.target;
+    if (target.capabilities && !target.capabilities.includes("update_node")) {
+      return {
+        ok: false,
+        text: `${target.name} can't self-update — it needs the update_node capability (a talon-node headless device).`,
+      };
+    }
+
+    let sha256: string;
+    let size: number;
+    try {
+      ({ sha256, size } = await hashFile(local));
+    } catch (err) {
+      return {
+        ok: false,
+        text: `Cannot read binary ${local}: ${(err as Error).message}`,
+      };
+    }
+    if (size === 0) return { ok: false, text: `Binary ${local} is empty.` };
+
+    // Default staging path is /tmp on unix nodes (the node re-stages next to
+    // its own executable before the atomic swap, so this is only transient).
+    const remote =
+      typeof remotePath === "string" && remotePath.trim()
+        ? remotePath.trim()
+        : "/tmp/talon-node.update";
+
+    // 1. Stream the new binary to the node.
+    const push = await this.pushFileToDevice(target.id, local, remote);
+    if (!push.ok) {
+      return { ok: false, text: `Update aborted — push failed: ${push.text}` };
+    }
+
+    // 2. Trigger the swap + restart (node verifies the digest first).
+    const dispatched = await this.dispatchCommand(
+      target.id,
+      "update_node",
+      { path: remote, sha256 },
+      this.commandTimeoutMs,
+    );
+    if ("error" in dispatched) return { ok: false, text: dispatched.error };
+    if (!dispatched.result.ok) {
+      return {
+        ok: false,
+        text: dispatched.result.message ?? `${target.name} refused the update.`,
+      };
+    }
+    return {
+      ok: true,
+      text:
+        `Pushed ${formatBytes(size)} and staged the update on ${target.name}. ` +
+        `${dispatched.result.message ?? "Restarting now."} ` +
+        `Confirm with get_device_status once it reconnects (appVersion should change).`,
+    };
+  }
+
   /**
    * Chunked read of a remote file into a Buffer. Loops `read_file` with
    * increasing offsets until the device reports EOF.

package/src/core/tools/mesh.ts

@@ -185,4 +185,25 @@ export const meshTools: ToolDefinition[] = [
     execute: (params, bridge) => bridge("update_device", params),
     tag: "mesh",
   },
+  {
+    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.",
+    schema: {
+      device: deviceParam,
+      binary_path: z
+        .string()
+        .describe(
+          "Path to the new talon-node binary, relative to the workspace (or absolute), built for the node's OS/arch.",
+        ),
+      remote_path: z
+        .string()
+        .optional()
+        .describe(
+          "Where to stage the binary on the node (default /tmp/talon-node.update; the node re-stages next to its own executable before the atomic swap).",
+        ),
+    },
+    execute: (params, bridge) => bridge("update_node", params),
+    tag: "mesh",
+  },
 ];

package/src/frontend/telegram/commands/definitions.ts

@@ -22,6 +22,7 @@ export const TELEGRAM_COMMANDS: ReadonlyArray<{
   },
   { command: "status", description: "Session info, usage, and stats" },
   { command: "ping", description: "Health check with latency" },
+  { command: "mesh", description: "Ping and list mesh devices" },
   { command: "model", description: "Show or change model" },
   { command: "effort", description: "Set thinking effort level" },
   { command: "pulse", description: "Conversation engagement settings" },

package/src/frontend/telegram/commands/info.ts

@@ -7,6 +7,8 @@ import { isUserClientReady } from "../userbot.js";
 import { escapeHtml } from "../formatting.js";
 import { formatDuration } from "../helpers/index.js";
 import { getLoadedPlugins } from "../../../core/plugin/index.js";
+import { getMeshService } from "../../../core/mesh/index.js";
+import type { MeshPingResult } from "../../../core/mesh/service.js";
 
 export function registerInfoCommands(bot: Bot): void {
   bot.command("start", (ctx) =>
@@ -42,6 +44,7 @@ export function registerInfoCommands(bot: Bot): void {
         "  /doctor -- environment and native-module health (admin)",
         "  /dream -- force memory consolidation now",
         "  /ping -- health check with latency",
+        "  /mesh -- ping and list companion mesh devices",
         "  /reset -- clear session and start fresh",
         "  /restart -- restart the bot process",
         "  /plugins -- list loaded plugins",
@@ -100,6 +103,50 @@ export function registerInfoCommands(bot: Bot): void {
     }
   });
 
+  bot.command("mesh", async (ctx) => {
+    const sent = await ctx.reply("🛰️ Pinging mesh devices…");
+    let results: MeshPingResult[];
+    try {
+      results = await getMeshService().pingAll();
+    } catch {
+      await editOrReply(
+        bot,
+        ctx.chat.id,
+        sent.message_id,
+        "Could not reach the mesh service.",
+      );
+      return;
+    }
+    if (results.length === 0) {
+      await editOrReply(
+        bot,
+        ctx.chat.id,
+        sent.message_id,
+        "<b>🛰️ Mesh</b>\n\nNo devices have registered yet.",
+      );
+      return;
+    }
+    // Online (reachable first, by latency) before offline; a stable, useful
+    // order for a glance at the fleet.
+    const sorted = [...results].sort((a, b) => {
+      if (a.device.online !== b.device.online) return a.device.online ? -1 : 1;
+      return (a.latencyMs ?? Infinity) - (b.latencyMs ?? Infinity);
+    });
+    const online = results.filter((r) => r.device.online).length;
+    const reachable = results.filter((r) => r.reachable).length;
+    const lines = sorted.map((r) => meshLine(r));
+    await editOrReply(
+      bot,
+      ctx.chat.id,
+      sent.message_id,
+      [
+        `<b>🛰️ Mesh</b> — ${results.length} device(s), ${online} online, ${reachable} responding`,
+        "",
+        ...lines,
+      ].join("\n"),
+    );
+  });
+
   bot.command("plugins", async (ctx) => {
     const plugins = getLoadedPlugins();
     if (plugins.length === 0) {
@@ -123,3 +170,38 @@ export function registerInfoCommands(bot: Bot): void {
     );
   });
 }
+
+/** One `/mesh` line: presence + reachability + latency + platform. */
+function meshLine(r: MeshPingResult): string {
+  const d = r.device;
+  const dot = r.reachable ? "🟢" : d.online ? "🟡" : "⚪";
+  const name = `<b>${escapeHtml(d.name)}</b>`;
+  const bits: string[] = [`${d.platform}`];
+  if (r.reachable && typeof r.latencyMs === "number") {
+    bits.push(`${r.latencyMs}ms`);
+  } else if (d.online && r.error) {
+    bits.push(escapeHtml(r.error));
+  } else if (!d.online) {
+    bits.push(`offline, last seen ${formatDuration(Date.now() - d.lastSeen)}`);
+  }
+  if (typeof d.battery === "number") {
+    bits.push(`${d.battery}%${d.charging ? "⚡" : ""}`);
+  }
+  return `${dot} ${name} — ${bits.join(" · ")}`;
+}
+
+/** Edit the placeholder in place, falling back to a fresh reply. */
+async function editOrReply(
+  bot: Bot,
+  chatId: number,
+  messageId: number,
+  text: string,
+): Promise<void> {
+  try {
+    await bot.api.editMessageText(chatId, messageId, text, {
+      parse_mode: "HTML",
+    });
+  } catch {
+    await bot.api.sendMessage(chatId, text, { parse_mode: "HTML" });
+  }
+}