talon-agent 3.8.1 → 3.9.0

package/src/core/vfs/index.ts

@@ -35,27 +35,8 @@ import { createProcMount } from "./mounts/proc.js";
 import { Vfs } from "./vfs.js";
 
 export { Vfs } from "./vfs.js";
-export { createFileMount } from "./mounts/files.js";
-export { createProcMount, type ProcMountDeps } from "./mounts/proc.js";
-export { createPluginsMount, type PluginView } from "./mounts/plugins.js";
-export { syncNamespaceDir, type NsDirSync } from "./nsdir.js";
-export {
-  isNamespaceFsMounted,
-  mountNamespaceFs,
-  namespaceFsStatus,
-  serveNamespaceRequest,
-  unmountNamespaceFs,
-  type FuseStatus,
-  type MountOptions,
-} from "./fusefs.js";
-export type {
-  VfsErrorCode,
-  VfsMount,
-  VfsNodeKind,
-  VfsResult,
-  VfsStat,
-} from "./types.js";
-export { VFS_MAX_READ_BYTES, vfsError, vfsOk } from "./types.js";
+
+export { mountNamespaceFs, unmountNamespaceFs } from "./fusefs.js";
 
 function pluginViews(): PluginView[] {
   const modules: PluginView[] = registry.all.map(({ plugin, path }) => ({

package/src/core/weaver/index.ts

@@ -1,13 +1,9 @@
-export { Thread, type Warp, type ThreadSnapshot } from "./thread.js";
-export { ThreadSession, type SessionSummary } from "./thread-session.js";
+export { Thread, type ThreadSnapshot } from "./thread.js";
+
 export { Loom, type ContextRegistry } from "./loom.js";
-export { carryTurnEvents, type EventSink } from "./shuttle.js";
-export { startTypingLoop, TYPING_REFRESH_MS } from "./typing-loop.js";
-export {
-  resolveWarp,
-  type WarpResolution,
-  type WarpResolverDeps,
-} from "./warp-resolver.js";
+export { carryTurnEvents } from "./shuttle.js";
+export { startTypingLoop } from "./typing-loop.js";
+export { resolveWarp } from "./warp-resolver.js";
 export {
   Weaver,
   getActiveLoom,

package/src/frontend/discord/actions/messaging.ts

@@ -6,7 +6,11 @@
 import type { Client } from "discord.js";
 import { withRetry } from "../../../core/engine/gateway.js";
 import { sendChunked } from "../handlers/index.js";
-import { suppressMentions, DISCORD_MAX_TEXT } from "../formatting.js";
+import {
+  suppressMentions,
+  splitMessage,
+  DISCORD_MAX_TEXT,
+} from "../formatting.js";
 import { log, logError } from "../../../util/log.js";
 import {
   saveScheduled,
@@ -24,6 +28,41 @@ import type { DiscordActionHandlers } from "./types.js";
 /** Longest schedulable delay: 24h. Timers re-arm from the store on boot. */
 const MAX_DELAY_SEC = 24 * 60 * 60;
 
+/**
+ * Deliver one scheduled entry, replaying whatever it was scheduled with.
+ *
+ * The `send` tool documents that "buttons and reply threading survive the
+ * delay — the schedule handler replays them at fire time". Discord's path
+ * used to call `sendChunked(c, entry.text)` and drop both, so a scheduled
+ * message with buttons arrived bare while the caller had been told ok:true.
+ */
+async function fireScheduled(
+  channel: Awaited<ReturnType<typeof resolveChannel>>,
+  entry: ScheduledMessage,
+): Promise<void> {
+  if (!channel) return;
+  const replyTo =
+    entry.replyTo !== undefined ? String(entry.replyTo) : undefined;
+  if (!entry.rows || entry.rows.length === 0) {
+    await sendChunked(channel, entry.text, replyTo);
+    return;
+  }
+  const components = buildButtonRows(entry.rows);
+  const chunks = splitMessage(suppressMentions(entry.text), DISCORD_MAX_TEXT);
+  for (let i = 0; i < chunks.length; i++) {
+    if (!channel.isSendable()) return;
+    const last = i === chunks.length - 1;
+    await channel.send({
+      content: chunks[i],
+      ...(last ? { components } : {}),
+      allowedMentions: { parse: [] },
+      ...(i === 0 && replyTo
+        ? { reply: { messageReference: replyTo, failIfNotExists: false } }
+        : {}),
+    });
+  }
+}
+
 /** Arm a timer for a stored entry; fires, then cleans up store + map. */
 function armScheduled(
   client: Client,
@@ -34,7 +73,7 @@ function armScheduled(
   const timer = setTimeout(async () => {
     try {
       const c = await resolveChannel(client, Number(entry.chatId));
-      if (c) await sendChunked(c, entry.text);
+      if (c) await fireScheduled(c, entry);
     } catch (err) {
       logError(
         "discord",
@@ -189,25 +228,44 @@ export const messagingHandlers: DiscordActionHandlers = {
       }>
     >;
     gateway.incrementMessages(chatId);
-    const components = buildButtonRows(rows);
-    const safe = suppressMentions(text).slice(0, DISCORD_MAX_TEXT);
     if (!channel!.isSendable())
       return { ok: false, error: "Channel not sendable" };
     return tryAction("send_message_with_buttons", async () => {
-      const sent = await withRetry(
-        () =>
-          channel!.send({
-            content: safe,
-            components,
-            allowedMentions: { parse: [] },
-          }) as Promise<{ id: string }>,
-      );
-      return { ok: true, message_id: sent.id };
+      // buildButtonRows is inside tryAction on purpose: it can still reject a
+      // row, and escaping here would bypass the action's error mapping and
+      // lose the text as well as the buttons.
+      const components = buildButtonRows(rows);
+      // Chunk rather than slice. `.slice(0, 2000)` dropped everything past
+      // the limit mid-word and still answered ok:true, so the model never
+      // learned its reply had been cut — while the SAME text without buttons
+      // went through sendChunked and arrived whole.
+      const chunks = splitMessage(suppressMentions(text), DISCORD_MAX_TEXT);
+      const ids: string[] = [];
+      for (let i = 0; i < chunks.length; i++) {
+        const last = i === chunks.length - 1;
+        const sent = await withRetry(
+          () =>
+            channel!.send({
+              content: chunks[i],
+              // Buttons belong on the final chunk: they act on the whole
+              // message, and Discord would render a set per chunk otherwise.
+              ...(last ? { components } : {}),
+              allowedMentions: { parse: [] },
+            }) as Promise<{ id: string }>,
+        );
+        ids.push(sent.id);
+      }
+      return { ok: true, message_id: ids[0], message_ids: ids };
     });
   },
 
   schedule_message: (body, chatId, { client, scheduledMessages }) => {
     const text = String(body.text ?? "");
+    const rows = body.rows as ScheduledMessage["rows"];
+    const replyTo =
+      typeof body.reply_to_message_id === "string"
+        ? body.reply_to_message_id
+        : undefined;
     // NaN (e.g. delay_seconds: "5m") must fall back to the default, not
     // propagate: setTimeout(fn, NaN) fires immediately.
     const requested = Number(body.delay_seconds ?? 60);
@@ -222,6 +280,8 @@ export const messagingHandlers: DiscordActionHandlers = {
       text,
       fireAt: Date.now() + delaySec * 1000,
       createdAt: Date.now(),
+      replyTo,
+      rows,
     };
     // Persist before arming: if we crash between the two, the restore
     // path delivers it; the reverse order could lose it forever.

package/src/frontend/discord/actions/shared.ts

@@ -70,11 +70,21 @@ export function buildButtonRows(
   >,
 ): ActionRowBuilder<ButtonBuilder>[] {
   const out: ActionRowBuilder<ButtonBuilder>[] = [];
+  // custom_id must be unique within a message or Discord rejects the send.
+  // Two buttons with the same label — or none at all, which both collapse to
+  // the bare `ai:` prefix — used to produce a duplicate pair.
+  const usedIds = new Set<string>();
   for (const row of rows.slice(0, 5)) {
     const arb = new ActionRowBuilder<ButtonBuilder>();
     for (const btn of row.slice(0, 5)) {
       const b = new ButtonBuilder().setLabel(safeSlice(btn.text || "•", 80));
-      if (btn.url) {
+      // Only http(s) can be a Link button. discord.js throws on anything
+      // else — a bare domain ("docs.example.com", a common model output) or
+      // a javascript: URL — and the throw escapes before the send, so ONE
+      // malformed URL discarded the reply text and every other button too.
+      // Downgrade to a plain non-link button instead: the label still says
+      // what it meant, and the rest of the message survives.
+      if (btn.url !== undefined && /^https?:\/\//i.test(btn.url)) {
         b.setStyle(ButtonStyle.Link).setURL(btn.url);
       } else {
         const styleMap: Record<string, ButtonStyle> = {
@@ -88,13 +98,21 @@ export function buildButtonRows(
         // Namespace AI-generated custom_ids under `ai:` so the callback router
         // never confuses them with system custom_ids like `settings:done`.
         // The router strips the prefix before forwarding to the agent.
+        //
+        // Budget is 100 UTF-16 units total (Discord's cap), so the raw part
+        // gets 100 minus the 3-unit prefix minus room for a de-dupe suffix.
         const raw = btn.callback_data || btn.text || "";
-        const id = `ai:${safeSlice(raw, 96)}`;
+        let id = `ai:${safeSlice(raw, 93)}`;
+        for (let n = 2; usedIds.has(id); n++)
+          id = `ai:${safeSlice(raw, 93)}#${n}`;
+        usedIds.add(id);
         b.setStyle(style).setCustomId(id);
       }
       arb.addComponents(b);
     }
-    out.push(arb);
+    // Discord requires at least one component per action row; an empty row
+    // (from an empty inner array) fails the whole message.
+    if (arb.components.length > 0) out.push(arb);
   }
   return out;
 }

package/src/frontend/discord/commands/admin.ts

@@ -9,7 +9,7 @@ import type { Gateway } from "../../../core/engine/gateway.js";
 import { respawnSelf } from "../../../util/respawn.js";
 import { forceDream } from "../../../core/background/dream.js";
 import { formatDuration, renderMetricsMessages } from "../helpers.js";
-import { getMetrics, getTodayMetrics } from "../../../util/metrics.js";
+import { getMetrics, getTodayMetrics } from "../../../storage/metrics.js";
 import { handleAdminSubcommand } from "../admin.js";
 import { isAdmin } from "../handlers/index.js";
 import { suppressMentions, DISCORD_MAX_TEXT } from "../formatting.js";

package/src/frontend/discord/errors.ts

@@ -18,13 +18,24 @@ type DiscordAPIErrorLike = {
   rawError?: { code?: number };
 };
 
-/** Extract numeric JSON error code, if this looks like a DiscordAPIError. */
-function discordErrorCode(err: unknown): number | null {
-  if (!err || typeof err !== "object") return null;
-  const e = err as DiscordAPIErrorLike;
+/**
+ * Extract numeric JSON error code, if this looks like a DiscordAPIError.
+ *
+ * Walks the `cause` chain, which is what makes this work at all on the
+ * primary send paths. Those run inside `withRetry`, which rethrows
+ * `classify(err)` — a TalonError carrying only the message, with the
+ * DiscordAPIError demoted to `cause`. A shallow look therefore found no
+ * code and every curated message below was dead on `send_message`,
+ * `reply_to`, `send_message_with_buttons`, the media sends, and
+ * forward/copy: the agent got a bare "Missing Permissions" instead of
+ * being told which permission and on what.
+ */
+function discordErrorCode(err: unknown, depth = 0): number | null {
+  if (depth > 5 || !err || typeof err !== "object") return null;
+  const e = err as DiscordAPIErrorLike & { cause?: unknown };
   if (typeof e.code === "number") return e.code;
   if (typeof e.rawError?.code === "number") return e.rawError.code;
-  return null;
+  return discordErrorCode(e.cause, depth + 1);
 }
 
 /**

package/src/frontend/discord/formatting.ts

@@ -58,12 +58,27 @@ export function suppressMentions(text: string): string {
 }
 
 /**
- * Slice a string to `max` user-visible characters without splitting multi-byte
- * code points (emoji, CJK) on a UTF-16 surrogate boundary. Used for Discord
- * `customId`, `label`, `value`, etc. where Discord measures char count.
+ * Slice a string so it satisfies a Discord length limit, without splitting a
+ * surrogate pair. Used for `customId`, `label`, `value`, etc.
+ *
+ * `max` counts UTF-16 code units, because that is what Discord (and
+ * discord.js's validators, which call `String.length`) measure. Counting
+ * code points instead — `Array.from(text).slice(0, max)` — silently
+ * overshoots for any astral character: 80 code points of emoji is 160 code
+ * units, so the guard passed and discord.js then threw
+ * `ExpectedConstraintError: Invalid string length`, taking the whole message
+ * with it. The guard worked precisely when it wasn't needed and failed when
+ * it was.
  */
 export function safeSlice(text: string, max: number): string {
-  return Array.from(text).slice(0, max).join("");
+  if (text.length <= max) return text;
+  let out = "";
+  // Iterating a string yields whole code points, so a pair is never split.
+  for (const char of text) {
+    if (out.length + char.length > max) break;
+    out += char;
+  }
+  return out;
 }
 
 /** Simple HTML-style escape used when displaying raw text inside code blocks. */

package/src/frontend/native/index.ts

@@ -69,7 +69,7 @@ import {
 } from "../../core/engine/backend-controller/index.js";
 import { getActiveReasoningLevels } from "../shared/reasoning-levels.js";
 import { NativeChats, DEFAULT_CHAT_TITLE, type ChatEntry } from "./chats.js";
-import { extractSessionName } from "../../backend/shared/session-name.js";
+import { extractSessionName } from "../../util/session-name.js";
 import { BridgeServer, type BridgeServerHandlers } from "./server.js";
 import { createNativeActionHandler } from "./actions.js";
 import { getMeshService } from "../../core/mesh/index.js";
@@ -1192,8 +1192,10 @@ export function createNativeFrontend(
     storeLocation: (body) => mesh.storeLocation(body),
     listDevices: () => mesh.list(),
     completeCommand: (body) => mesh.completeCommand(body),
-    acceptFileUpload: (token, body) => mesh.acceptFileUpload(token, body),
-    openFileDownload: (token) => mesh.openFileDownload(token),
+    acceptFileUpload: (token, body, fromDeviceId) =>
+      mesh.acceptFileUpload(token, body, fromDeviceId),
+    openFileDownload: (token, fromDeviceId) =>
+      mesh.openFileDownload(token, fromDeviceId),
     openNodeInstall: (token) => mesh.openNodeInstall(token),
     openNodeBinary: (token) => mesh.openNodeBinary(token),
   };
@@ -1205,14 +1207,22 @@ export function createNativeFrontend(
   const bridgeTls = nativeCfg.tls ?? !isLoopbackHost(bridgeHost);
   // Never serve the agent API to the network unauthenticated: a non-loopback
   // bind with no configured token gets a persistent auto-minted one instead.
+  // `?? ` alone would treat an empty string as a configured token and skip
+  // the mint, serving the LAN unauthenticated while looking configured —
+  // easy to hit from `"token": "${BRIDGE_TOKEN}"` with the var unset.
+  const configuredToken =
+    nativeCfg.token !== undefined && nativeCfg.token !== ""
+      ? nativeCfg.token
+      : undefined;
   const bridgeToken =
-    nativeCfg.token ??
+    configuredToken ??
     (isLoopbackHost(bridgeHost) ? undefined : loadOrCreateBridgeToken());
   const server = new BridgeServer(
     {
       host: bridgeHost,
       port: nativeCfg.port ?? 19880,
       token: bridgeToken,
+      allowedOrigins: nativeCfg.allowedOrigins,
       startedAt,
       ...(bridgeTls ? { tls: () => loadOrCreateBridgeTlsIdentity() } : {}),
     },
@@ -1249,13 +1259,17 @@ export function createNativeFrontend(
     async init() {
       await mesh.load();
       // Plug this bridge in as the mesh's transport: locates and device
-      // commands (from ANY frontend's mesh tool calls) fan out to every
-      // connected companion client as SSE events; each client filters by
-      // its own device id.
+      // commands (from ANY frontend's mesh tool calls) leave as SSE events.
+      //
+      // A locate is a bare "who's there?" — no secret in the frame, and
+      // pre-command app builds rely on receiving it — so it still fans out.
+      // A command is the opposite: its params carry transfer tokens, exec
+      // command lines and (on the chunked fallback) file bodies, so it goes
+      // to the target device's own client(s) only.
       unregisterMeshTransport = mesh.registerTransport({
         locate: (deviceId) => broadcast({ kind: "locate", deviceId }),
         command: (command) =>
-          broadcast({
+          server.sendToDevice(command.deviceId, {
             kind: "device_command",
             id: command.id,
             deviceId: command.deviceId,

package/src/frontend/native/protocol.ts

@@ -286,6 +286,12 @@ export type BridgeEvent =
    * target device executes it and answers via POST /devices/command-result
    * with the same `id` as `commandId`. Additive in v1 — app builds that
    * predate the command channel simply ignore the event.
+   *
+   * Addressed, not broadcast: params carry one-time transfer tokens, exec
+   * command lines and (on the chunked fallback) file bodies, so the frame
+   * goes only to the SSE client(s) that claimed this `deviceId` via
+   * `GET /events?deviceId=…`. Clients that claim no id still receive
+   * commands for devices nobody claimed, so pre-claim builds keep working.
    */
   | {
       kind: "device_command";