talon-agent 3.2.0 → 3.3.0

package/package.json

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

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

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" });
+  }
+}