talon-agent 4.6.1 → 5.0.1

package/src/core/engine/gateway-actions/native/search.ts

@@ -0,0 +1,212 @@
+/**
+ * `native_glob` / `native_search` — find files by pattern, find text inside
+ * them.
+ *
+ * ripgrep is the fast path on both hosts; when it isn't installed the local
+ * runs fall back to a pure-JS walker rather than lying "no matches", and a
+ * teleported run falls back to the device's find/grep.
+ */
+
+import { glob as fsGlob, readFile, stat as fsStat } from "node:fs/promises";
+import { join } from "node:path";
+import { getTeleport } from "../../../mesh/teleport.js";
+import { bashTeleported } from "./exec-remote.js";
+import { resolvePathParam, str } from "./params.js";
+import type { Result } from "./results.js";
+import { runLocal, shellQuote } from "./shell.js";
+import type { SharedActionHandlers } from "../types.js";
+
+/**
+ * ripgrep binary, resolved from PATH (env-overridable for tests). NOT a
+ * hardcoded absolute path: /usr/bin/rg only exists on some Linux installs,
+ * and a missing binary must fall back loudly (or to the pure-JS walker),
+ * never masquerade as "no matches".
+ */
+function rgBin(): string {
+  return process.env.TALON_NATIVE_RG ?? "rg";
+}
+/** Caps for the pure-JS glob/search fallbacks (rg unavailable). */
+const MAX_JS_RESULTS = 2_000;
+const MAX_JS_FILE_BYTES = 2 * 1024 * 1024;
+const SKIP_DIRS_RE = /(^|[\\/])(node_modules|\.git)([\\/]|$)/;
+
+export const searchHandlers: SharedActionHandlers = {
+  native_glob: (body, chatId) => glob(chatId, body.pattern, body.path),
+  native_search: (body, chatId) =>
+    search(chatId, body.pattern, body.path, body.glob, body.case_insensitive),
+};
+
+async function glob(
+  chatId: number,
+  pattern: unknown,
+  path: unknown,
+): Promise<Result> {
+  const pat = str(pattern);
+  if (!pat) return { ok: false, text: "A glob pattern is required." };
+  const active = await getTeleport(chatId);
+  const root = resolvePathParam(str(path) ?? ".", active?.deviceName);
+  if (active) {
+    // Prefer rg on the device; fall back to find (basename patterns via
+    // -name, path patterns via -path). `command -v` gates the choice so a
+    // no-match rg exit (1) isn't misread as "rg missing, run find too".
+    const findExpr = pat.includes("/")
+      ? `-type f -path ${shellQuote(`*${pat}`)}`
+      : `-type f -name ${shellQuote(pat)}`;
+    const cmd =
+      `if command -v rg >/dev/null 2>&1; ` +
+      `then rg --files -g ${shellQuote(pat)} ${shellQuote(root)}; ` +
+      `else find ${shellQuote(root)} ${findExpr} 2>/dev/null; fi`;
+    return bashTeleported(chatId, active.deviceId, cmd, 30_000);
+  }
+  const res = await runLocal(rgBin(), ["--files", "-g", pat, root]);
+  let files: string[];
+  if (res.code === 127) {
+    // rg not installed — pure-JS fallback rather than lying "no matches".
+    files = await globJs(pat, root);
+  } else if (res.code > 1 && !res.stdout.trim()) {
+    // exit 2 with output = partial results (e.g. permission-denied subdirs);
+    // exit 2 with none = a real error worth surfacing.
+    return {
+      ok: false,
+      text: `glob failed: ${res.stderr.trim() || `ripgrep exit ${res.code}`}`,
+    };
+  } else {
+    files = res.stdout.trim().split("\n").filter(Boolean);
+  }
+  // rg's parallel directory walk (and the JS fallback's) emit in
+  // nondeterministic order — sort so identical calls render identically.
+  files.sort();
+  return {
+    ok: true,
+    text: files.length
+      ? `${files.length} match(es):\n${files.slice(0, 200).join("\n")}${files.length > 200 ? `\n… (${files.length - 200} more)` : ""}`
+      : `No files match ${pat} under ${root}.`,
+  };
+}
+
+async function search(
+  chatId: number,
+  pattern: unknown,
+  path: unknown,
+  globPat: unknown,
+  caseInsensitive: unknown,
+): Promise<Result> {
+  const pat = str(pattern);
+  if (!pat) return { ok: false, text: "A search pattern is required." };
+  const active = await getTeleport(chatId);
+  const root = resolvePathParam(str(path) ?? ".", active?.deviceName);
+  const g = str(globPat);
+  const ci = caseInsensitive === true;
+  // `-e` keeps a pattern that starts with "-" from being parsed as a flag
+  // (same idiom for rg and grep).
+  const flags = [
+    "-n",
+    "--color=never",
+    ...(ci ? ["-i"] : []),
+    ...(g ? ["-g", g] : []),
+  ];
+  if (active) {
+    // Prefer rg on the device, fall back to grep (Android toybox has grep
+    // but rarely rg). --include is grep's closest analogue of -g.
+    const grepFlags = [
+      "-rn",
+      ...(ci ? ["-i"] : []),
+      ...(g ? [`--include=${g}`] : []),
+    ];
+    const cmd =
+      `if command -v rg >/dev/null 2>&1; ` +
+      `then rg ${flags.map(shellQuote).join(" ")} -e ${shellQuote(pat)} ${shellQuote(root)}; ` +
+      `else grep ${grepFlags.map(shellQuote).join(" ")} -e ${shellQuote(pat)} ${shellQuote(root)} 2>/dev/null; fi`;
+    return bashTeleported(chatId, active.deviceId, cmd, 30_000);
+  }
+  const res = await runLocal(rgBin(), [...flags, "-e", pat, root]);
+  let lines: string[];
+  if (res.code === 127) {
+    // rg not installed — pure-JS fallback rather than lying "no matches".
+    try {
+      lines = await searchJs(pat, root, g, ci);
+    } catch (err) {
+      return { ok: false, text: `search failed: ${(err as Error).message}` };
+    }
+  } else if (res.code > 1 && !res.stdout.trim()) {
+    // exit 2 with output = partial results; exit 2 with none = real error.
+    return {
+      ok: false,
+      text: `search failed: ${res.stderr.trim() || `ripgrep exit ${res.code}`}`,
+    };
+  } else {
+    const out = res.stdout.trim();
+    lines = out ? out.split("\n") : [];
+  }
+  return {
+    ok: true,
+    text: lines.length
+      ? `${lines.length} match line(s):\n${lines.slice(0, 200).join("\n")}${lines.length > 200 ? `\n… (${lines.length - 200} more)` : ""}`
+      : `No matches for ${pat} under ${root}.`,
+  };
+}
+
+// ── pure-JS glob/search fallbacks (no ripgrep on the host) ──────────────────
+
+/**
+ * Glob without ripgrep, via node:fs `glob`. Mirrors rg's -g semantics for
+ * bare names (a pattern without "/" matches at any depth) and skips
+ * node_modules/.git, which rg would exclude via gitignore.
+ */
+async function globJs(pat: string, root: string): Promise<string[]> {
+  const pattern = pat.includes("/") ? pat : `**/${pat}`;
+  const out: string[] = [];
+  try {
+    for await (const entry of fsGlob(pattern, {
+      cwd: root,
+      exclude: (e: unknown) => {
+        const name =
+          typeof e === "string" ? e : ((e as { name?: string }).name ?? "");
+        return (
+          SKIP_DIRS_RE.test(name) || name === "node_modules" || name === ".git"
+        );
+      },
+    })) {
+      out.push(join(root, String(entry)));
+      if (out.length >= MAX_JS_RESULTS) break;
+    }
+  } catch {
+    // unreadable root etc. — empty result, caller reports "no matches"
+  }
+  return out;
+}
+
+/** Content search without ripgrep: walk text files and regex-match lines. */
+async function searchJs(
+  pat: string,
+  root: string,
+  globPat: string | undefined,
+  caseInsensitive: boolean,
+): Promise<string[]> {
+  const re = new RegExp(pat, caseInsensitive ? "i" : "");
+  let files: string[];
+  try {
+    const st = await fsStat(root);
+    files = st.isFile() ? [root] : await globJs(globPat ?? "**/*", root);
+  } catch {
+    return [];
+  }
+  const lines: string[] = [];
+  for (const f of files) {
+    let content: string;
+    try {
+      const st = await fsStat(f);
+      if (!st.isFile() || st.size > MAX_JS_FILE_BYTES) continue;
+      content = await readFile(f, "utf8");
+    } catch {
+      continue;
+    }
+    if (content.includes("\0")) continue; // binary
+    const fileLines = content.split("\n");
+    for (let i = 0; i < fileLines.length; i++) {
+      if (re.test(fileLines[i])) lines.push(`${f}:${i + 1}:${fileLines[i]}`);
+      if (lines.length >= MAX_JS_RESULTS) return lines;
+    }
+  }
+  return lines;
+}

package/src/core/engine/gateway-actions/native/shell.ts

@@ -0,0 +1,39 @@
+/**
+ * Talking to a shell: POSIX single-quoting for a command Talon builds, and a
+ * plain local spawn that collects exit code + stdout + stderr (used for the
+ * ripgrep invocations behind glob/search).
+ */
+
+import { spawn } from "node:child_process";
+import { createOutputCapture } from "../../../../util/exec-output.js";
+
+export function shellQuote(s: string): string {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+export function runLocal(
+  bin: string,
+  args: string[],
+): Promise<{ code: number; stdout: string; stderr: string }> {
+  return new Promise((resolvePromise) => {
+    const child = spawn(bin, args, { env: process.env });
+    const stdout = createOutputCapture();
+    const stderr = createOutputCapture();
+    child.stdout.on("data", stdout.push);
+    child.stderr.on("data", stderr.push);
+    child.on("error", () =>
+      resolvePromise({
+        code: 127,
+        stdout: stdout.value(),
+        stderr: stderr.value(),
+      }),
+    );
+    child.on("close", (code) =>
+      resolvePromise({
+        code: code ?? 0,
+        stdout: stdout.value(),
+        stderr: stderr.value(),
+      }),
+    );
+  });
+}

package/src/core/engine/gateway-actions/native/teleport.ts

@@ -0,0 +1,55 @@
+/**
+ * Teleport control — which host the native tools in this directory target.
+ *
+ *   teleport(device)  → native tools run ON that companion device
+ *   teleport_back()   → native tools run on the daemon host again
+ */
+
+import { getMeshService } from "../../../mesh/index.js";
+import { clearTeleport, setTeleport } from "../../../mesh/teleport.js";
+import type { Result } from "./results.js";
+import type { SharedActionHandlers } from "../types.js";
+
+export const teleportHandlers: SharedActionHandlers = {
+  teleport: (body, chatId) => teleport(chatId, body.device),
+  teleport_back: (_body, chatId) => teleportBack(chatId),
+};
+
+async function teleport(chatId: number, query: unknown): Promise<Result> {
+  const svc = getMeshService();
+  await svc.list();
+  const resolved = svc.resolveDevice(query);
+  if ("error" in resolved) return { ok: false, text: resolved.error };
+  const target = resolved.target;
+  if (!target.online) {
+    return {
+      ok: false,
+      text: `${target.name} appears offline — cannot teleport onto a device that isn't connected.`,
+    };
+  }
+  if (target.capabilities && !target.capabilities.includes("exec")) {
+    return {
+      ok: false,
+      text: `${target.name} does not advertise the "exec" capability, so teleport can't run commands on it.`,
+    };
+  }
+  await setTeleport(chatId, target.id, target.name);
+  return {
+    ok: true,
+    text: [
+      `🛰️ Teleported onto ${target.name}. Native bash/read/write/edit/glob/search now run ON that device.`,
+      `Working dir starts at the device default; \`cd\` in bash persists across calls.`,
+      `Call teleport_back to return to the daemon host.`,
+    ].join(" "),
+  };
+}
+
+async function teleportBack(chatId: number): Promise<Result> {
+  const prior = await clearTeleport(chatId);
+  return {
+    ok: true,
+    text: prior
+      ? `↩️ Teleported back from ${prior.deviceName}. Native tools run on the daemon host again.`
+      : "Not teleported — native tools already run on the daemon host.",
+  };
+}

package/src/core/engine/gateway-actions/native/write.ts

@@ -0,0 +1,170 @@
+/**
+ * `native_write` / `native_edit` — the file-mutating half of the native
+ * tools, local or teleported.
+ *
+ * `edit` splices literally (never String.replace, whose `$` patterns would
+ * corrupt shell snippets and regexes), refuses binary files, and points at
+ * the closest-looking line when old_string doesn't match byte-for-byte.
+ */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getMeshService } from "../../../mesh/index.js";
+import { getTeleport } from "../../../mesh/teleport.js";
+import { resolvePathParam, str } from "./params.js";
+import type { Result } from "./results.js";
+import type { SharedActionHandlers } from "../types.js";
+
+export const writeHandlers: SharedActionHandlers = {
+  native_write: (body, chatId) => write(chatId, body.path, body.content),
+  native_edit: (body, chatId) =>
+    edit(chatId, body.path, body.old_string, body.new_string, body.replace_all),
+};
+
+async function write(
+  chatId: number,
+  path: unknown,
+  content: unknown,
+): Promise<Result> {
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
+  const body = typeof content === "string" ? content : "";
+  const active = await getTeleport(chatId);
+  const p = resolvePathParam(address, active?.deviceName);
+  const shown = p === address ? p : `${address} → ${p}`;
+  if (active) {
+    return getMeshService().writeFileToDevice(active.deviceId, p, body);
+  }
+  try {
+    await mkdir(dirname(p), { recursive: true });
+    await writeFile(p, body);
+  } catch (err) {
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
+  }
+  return {
+    ok: true,
+    text: `Wrote ${Buffer.byteLength(body, "utf8")} bytes to ${shown} [local].`,
+  };
+}
+
+async function edit(
+  chatId: number,
+  path: unknown,
+  oldString: unknown,
+  newString: unknown,
+  replaceAll: unknown,
+): Promise<Result> {
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
+  const from = typeof oldString === "string" ? oldString : "";
+  const to = typeof newString === "string" ? newString : "";
+  if (from === to)
+    return { ok: false, text: "old_string and new_string are identical." };
+  const active = await getTeleport(chatId);
+  const p = resolvePathParam(address, active?.deviceName);
+  const shown = p === address ? p : `${address} → ${p}`;
+  const svc = getMeshService();
+
+  let content: string;
+  if (active) {
+    const res = await svc.readFileBytes(active.deviceId, p);
+    if ("error" in res) return { ok: false, text: res.error };
+    content = res.data.toString("utf8");
+  } else {
+    try {
+      content = await readFile(p, "utf8");
+    } catch (err) {
+      return {
+        ok: false,
+        text: `Cannot read ${shown}: ${(err as Error).message}`,
+      };
+    }
+  }
+
+  // Binary guard: decoding binary as UTF-8 is lossy (invalid sequences
+  // become U+FFFD), so a read→replace→write round-trip would corrupt every
+  // non-text byte — even when old_string matches a clean region.
+  if (content.includes("\0")) {
+    return {
+      ok: false,
+      text: `${shown} looks binary — refusing a text edit that would corrupt it. Use bash for byte-level changes.`,
+    };
+  }
+
+  const count = from ? content.split(from).length - 1 : 0;
+  if (count === 0) {
+    return {
+      ok: false,
+      text: `old_string not found in ${shown}.${nearMissHint(content, from)}`,
+    };
+  }
+  if (count > 1 && replaceAll !== true) {
+    return {
+      ok: false,
+      text: `old_string appears ${count}× in ${shown}; pass replace_all or make it unique.`,
+    };
+  }
+  // Splice, not String.replace: replace() treats dollar-sign substitution
+  // patterns ($&, $', $BACKTICK, $$) in the replacement as directives, silently
+  // corrupting any new_string that contains them (shell snippets, regexes,
+  // Makefiles...). split/join and index-splice are both literal.
+  const updated =
+    replaceAll === true
+      ? content.split(from).join(to)
+      : spliceOnce(content, from, to);
+  const firstLine = content.slice(0, content.indexOf(from)).split("\n").length;
+
+  if (active) {
+    const res = await svc.writeFileToDevice(active.deviceId, p, updated);
+    return res.ok
+      ? {
+          ok: true,
+          text: `Edited ${shown} [${active.deviceName}] (${count} replacement${count === 1 ? "" : "s"}, first at line ${firstLine}).`,
+        }
+      : res;
+  }
+  try {
+    await writeFile(p, updated);
+  } catch (err) {
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
+  }
+  return {
+    ok: true,
+    text: `Edited ${shown} [local] (${count} replacement${count === 1 ? "" : "s"}, first at line ${firstLine}).`,
+  };
+}
+
+/**
+ * When an edit's old_string doesn't match verbatim, the cause is almost
+ * always invisible: indentation, tabs vs spaces, or a trailing space. Point
+ * at the closest-looking line so the model re-reads that region instead of
+ * blindly retrying the same string.
+ */
+function nearMissHint(content: string, from: string): string {
+  const probe =
+    from
+      .split("\n")
+      .map((l) => l.trim())
+      .find((l) => l.length >= 8) ?? from.trim();
+  if (!probe) return "";
+  const lines = content.split("\n");
+  const idx = lines.findIndex((l) => l.trim().includes(probe));
+  if (idx === -1) return "";
+  return (
+    `\nLine ${idx + 1} looks close — whitespace/indentation must match the file byte-for-byte. ` +
+    `Re-read that region before retrying:\n${String(idx + 1).padStart(6)}\t${lines[idx]}`
+  );
+}
+
+/** Replace the first occurrence of `from` with `to`, both taken literally. */
+function spliceOnce(content: string, from: string, to: string): string {
+  const idx = content.indexOf(from);
+  if (idx === -1) return content;
+  return content.slice(0, idx) + to + content.slice(idx + from.length);
+}

package/src/core/engine/gateway.ts

@@ -30,7 +30,6 @@ import {
 } from "./gateway-routes.js";
 import { handlePluginAction } from "../plugin/index.js";
 import type { FrontendActionHandler } from "../types.js";
-import { BOT_MESSAGE_ACTIONS, noteBotMessage } from "../soul/taps.js";
 import type { Backend } from "../agent-runtime/capabilities.js";
 import { resolveOwnerFrontendId } from "../frontend-runtime/routing.js";
 
@@ -320,11 +319,6 @@ export class Gateway {
       if (frontendHandler) {
         const result = await frontendHandler(body, chatId);
         if (result) {
-          // Soul tap: remember our own outgoing message ids so a later
-          // reaction update can be attributed to one of Talon's messages.
-          // No-op unless the soul is enabled.
-          if (BOT_MESSAGE_ACTIONS.has(action) && result.ok && result.message_id)
-            noteBotMessage(chatId, Number(result.message_id));
           logDebug("gateway", `${action} chat=${chatId} ${Date.now() - t0}ms`);
           return result;
         }

package/src/core/frontend-runtime/builtins.ts

@@ -7,7 +7,7 @@
  * imports `src/frontend/factories.ts`.
  *
  * Chat-id shapes are the long-standing conventions from
- * `util/chat-id.ts`. Priorities encode the historical resolution order
+ * `./chat-id.ts`. Priorities encode the historical resolution order
  * (terminal, native, teams, discord, telegram) — load-bearing in two
  * places: telegram's numeric matcher is a near-catch-all so it must run
  * last, and the terminal claims the legacy chat id "1" that telegram's
@@ -25,7 +25,7 @@ import {
   isTelegramChatId,
   isTerminalChatId,
   isWhatsAppChatId,
-} from "../../util/chat-id.js";
+} from "./chat-id.js";
 
 function registerBuiltinFrontends(): void {
   registerFrontend({

package/src/{util → core/frontend-runtime}/chat-id.ts

@@ -67,3 +67,33 @@ export function isWhatsAppChatId(chatId: string): boolean {
 export function isDiscordChatId(chatId: string): boolean {
   return chatId.startsWith("discord_");
 }
+
+/**
+ * Classify a canonical chat ID as a one-to-one chat, a multi-party one,
+ * or something this grammar cannot tell apart.
+ *
+ * The ID is the only signal engine-side code has: a frontend's own
+ * `isGroup` flag rides on the inbound message, while stores, jobs and
+ * gateway actions are keyed by the string ID alone. Per frontend:
+ *
+ *   - `discord_guild_…` / `discord_dm_…` and `wa_group_…` / `wa_dm_…`
+ *     say which they are outright;
+ *   - a Telegram ID is bare digits — negative for a group, supergroup or
+ *     channel, positive for the user's own ID (a DM);
+ *   - terminal (`t_…`, `"1"`) and native (`d_…`) chats are local,
+ *     single-operator surfaces, so they are DMs;
+ *   - `teams_chat_…` covers 1:1 *and* group Teams chats alike, so it is
+ *     `"unknown"` — as is anything a future frontend invents.
+ *
+ * Callers decide what `"unknown"` means for them; anything trust- or
+ * privacy-sensitive should treat it as a group and fail closed.
+ */
+export function chatScope(chatId: string): "dm" | "group" | "unknown" {
+  if (chatId.startsWith("discord_guild_")) return "group";
+  if (chatId.startsWith("discord_dm_")) return "dm";
+  if (chatId.startsWith("wa_group_")) return "group";
+  if (chatId.startsWith("wa_dm_")) return "dm";
+  if (isTelegramChatId(chatId)) return chatId.startsWith("-") ? "group" : "dm";
+  if (isTerminalChatId(chatId) || isNativeChatId(chatId)) return "dm";
+  return "unknown";
+}

package/src/core/mcp-hub/index.ts

@@ -38,7 +38,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { getPluginMcpServers } from "../plugin/index.js";
-import { wrapMcpServer } from "../../util/mcp-launcher.js";
+import { wrapMcpServer } from "./launcher.js";
 import { log, logError } from "../../util/log.js";
 import { buildTalonToolServer, VALID_TOOL_FRONTENDS } from "./talon-server.js";
 import { buildProxyServer } from "./proxy-server.js";

package/src/core/mcp-hub/talon-server.ts

@@ -16,7 +16,7 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { composeTools } from "../tools/index.js";
-import { createBridge, textResult } from "../tools/bridge.js";
+import { createBridge, textResult } from "../tools/ops/bridge.js";
 import type { ToolFrontend, ToolTag } from "../tools/types.js";
 
 export const VALID_TOOL_FRONTENDS: ReadonlySet<string> = new Set([

package/src/core/memory/import.ts

@@ -352,8 +352,9 @@ export function importMemoryFile(path: string = files.memory): ImportCounts {
 
 /**
  * Import the daily notes: one `episode` per `YYYY-MM-DD.md`, subject the
- * date. `diary-*.md` is the soul's first-person writing — a reflection,
- * never a fact source (plan §3.1) — so the filename pattern excludes it.
+ * date. `diary-*.md` is first-person writing — a reflection, never a fact
+ * source (plan §3.1) — so the filename pattern excludes it. The soul kernel
+ * that wrote those files is gone, but its output is still on disk.
  */
 export function importDailyNotes(dir: string = dirs.dailyMemory): ImportCounts {
   if (!existsSync(dir)) return emptyCounts();