talon-agent 3.0.2 → 3.0.4

package/package.json

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

package/src/backend/claude-sdk/models/discovery.ts

@@ -52,6 +52,10 @@ async function probeSupportedModels(
           reject(new Error("aborted")),
         );
       });
+      // Unreachable — the promise above only ever rejects. The yield* both
+      // satisfies require-yield and documents that this stream produces
+      // nothing by design (streaming-input mode with no user message).
+      yield* [] as never[];
     };
 
     const q = query({

package/src/backend/claude-sdk/warm.ts

@@ -43,6 +43,10 @@ export async function warmSession(chatId: string): Promise<void> {
           reject(new Error("aborted")),
         );
       });
+      // Unreachable — the promise above only ever rejects. The yield* both
+      // satisfies require-yield and documents that this stream produces
+      // nothing by design (streaming-input mode with no user message).
+      yield* [] as never[];
     };
 
     const q = query({

package/src/backend/remote-server/mcp.ts

@@ -133,7 +133,8 @@ export async function ensureChatMcpServer<TClient extends RemoteAgentClient>(
   // Rotate out other chat servers BEFORE registering this one. The
   // heartbeat sentinel server is exempt (it has no real chat to leak
   // into and stays connected for cron / trigger paths).
-  for (const other of [...state.registeredMcpServers]) {
+  // Snapshot: rotation removes entries from the live set mid-iteration.
+  for (const other of Array.from(state.registeredMcpServers)) {
     if (
       !other.startsWith(`${TALON_MCP_SERVER_NAME}-`) ||
       other === serverName ||

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

@@ -75,6 +75,12 @@ const TELEPORT_TIMEOUT_HINT =
   "background it in-shell instead: `cmd > /tmp/out.log 2>&1 &`, then poll the log " +
   "with read, or bound the command itself: `logcat -d`, `timeout 30 …`, `head -n 200`.)";
 const MAX_READ_LINES = 2_000;
+/**
+ * Refuse to slurp huge files into memory: `read` loads the whole file to
+ * slice lines, so an unbounded readFile of a multi-GB log balloons RSS.
+ * Past this, bash is the right tool (`sed -n`, `tail`, `head`).
+ */
+const MAX_READ_FILE_BYTES = 32 * 1024 * 1024;
 /**
  * Image extensions the model can actually view, mapped to their MIME type.
  * Reading one returns an image content block instead of the file's raw bytes
@@ -169,7 +175,19 @@ async function bash(
   const active = await getTeleport(chatId);
 
   let dir = typeof cwd === "string" && cwd.trim() ? cwd.trim() : undefined;
-  if (dir !== undefined && !active) dir = resolvePathParam(dir, undefined);
+  if (dir !== undefined && !active) {
+    dir = resolvePathParam(dir, undefined);
+    // Validate here: a bad cwd makes spawn fail with "spawn bash ENOENT",
+    // which reads as "bash is missing" and sends the model down the wrong
+    // path. Name the actual problem instead.
+    try {
+      const st = await fsStat(dir);
+      if (!st.isDirectory())
+        return { ok: false, text: `cwd is not a directory: ${dir}` };
+    } catch {
+      return { ok: false, text: `Working directory does not exist: ${dir}` };
+    }
+  }
 
   const result = await (async () => {
     if (background === true) {
@@ -509,6 +527,10 @@ async function read(
       bytes = res.data;
     } else {
       try {
+        // stat first — no point slurping a 40MB photo just to refuse it.
+        const st = await fsStat(p);
+        if (st.size > MAX_IMAGE_BYTES)
+          return oversizeImageResult(shown, where, st.size, p);
         bytes = await readFile(p);
       } catch (err) {
         return {
@@ -518,13 +540,7 @@ async function read(
       }
     }
     if (bytes.length > MAX_IMAGE_BYTES) {
-      return {
-        ok: false,
-        text:
-          `${shown} [${where}] is ${(bytes.length / 1_048_576).toFixed(1)}MB — over the ` +
-          `${MAX_IMAGE_BYTES / 1_048_576}MB image limit. Downscale it first ` +
-          `(e.g. \`convert '${p}' -resize 1568x /tmp/small.jpg\`) and read that.`,
-      };
+      return oversizeImageResult(shown, where, bytes.length, p);
     }
     return {
       ok: true,
@@ -533,15 +549,26 @@ async function read(
     };
   }
 
-  const start = num(offset) ?? 0;
-  const max = Math.min(num(limit) ?? MAX_READ_LINES, MAX_READ_LINES);
+  // Clamp: a negative offset would silently flip slice() into
+  // count-from-the-end (with line numbers that lie), and a zero/negative
+  // limit would return an empty read that looks like an empty file.
+  const start = Math.max(0, Math.trunc(num(offset) ?? 0));
+  const max = Math.min(
+    Math.max(1, Math.trunc(num(limit) ?? MAX_READ_LINES)),
+    MAX_READ_LINES,
+  );
   let content: string;
   if (active) {
     const res = await getMeshService().readFileBytes(active.deviceId, p);
     if ("error" in res) return { ok: false, text: res.error };
+    if (res.data.length > MAX_READ_FILE_BYTES)
+      return oversizeReadResult(shown, where, res.data.length, p);
     content = res.data.toString("utf8");
   } else {
     try {
+      const st = await fsStat(p);
+      if (st.isFile() && st.size > MAX_READ_FILE_BYTES)
+        return oversizeReadResult(shown, where, st.size, p);
       content = await readFile(p, "utf8");
     } catch (err) {
       return {
@@ -550,7 +577,24 @@ async function read(
       };
     }
   }
+  // Binary files decoded as UTF-8 are mojibake the model can't use — same
+  // rationale as the image branch, but with no viewable representation to
+  // return. Point at the shell tools that can actually inspect the bytes.
+  if (content.includes("\0")) {
+    return {
+      ok: false,
+      text:
+        `${shown} [${where}] looks binary — refusing to render it as text. ` +
+        `Inspect it with bash instead: \`file '${p}'\`, \`xxd '${p}' | head\`, \`strings '${p}'\`.`,
+    };
+  }
   const lines = content.split("\n");
+  if (start >= lines.length) {
+    return {
+      ok: false,
+      text: `${shown} [${where}] has ${lines.length} lines — offset ${start} is past the end.`,
+    };
+  }
   const slice = lines.slice(start, start + max);
   const numbered = slice
     .map((line, i) => `${String(start + i + 1).padStart(6)}\t${line}`)
@@ -588,7 +632,10 @@ async function write(
       text: `Cannot write ${shown}: ${(err as Error).message}`,
     };
   }
-  return { ok: true, text: `Wrote ${body.length} bytes to ${shown} [local].` };
+  return {
+    ok: true,
+    text: `Wrote ${Buffer.byteLength(body, "utf8")} bytes to ${shown} [local].`,
+  };
 }
 
 async function edit(
@@ -625,6 +672,16 @@ async function edit(
     }
   }
 
+  // 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 {
@@ -638,17 +695,22 @@ async function edit(
       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)
-      : content.replace(from, 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"}).`,
+          text: `Edited ${shown} [${active.deviceName}] (${count} replacement${count === 1 ? "" : "s"}, first at line ${firstLine}).`,
         }
       : res;
   }
@@ -662,7 +724,7 @@ async function edit(
   }
   return {
     ok: true,
-    text: `Edited ${shown} [local] (${count} replacement${count === 1 ? "" : "s"}).`,
+    text: `Edited ${shown} [local] (${count} replacement${count === 1 ? "" : "s"}, first at line ${firstLine}).`,
   };
 }
 
@@ -682,8 +744,8 @@ async function glob(
     // -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("/")
-      ? `-path ${shellQuote(`*${pat}`)}`
-      : `-name ${shellQuote(pat)}`;
+      ? `-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)}; ` +
@@ -705,6 +767,9 @@ async function glob(
   } 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
@@ -840,6 +905,36 @@ async function searchJs(
   return lines;
 }
 
+function oversizeReadResult(
+  shown: string,
+  where: string,
+  size: number,
+  p: string,
+): Result {
+  return {
+    ok: false,
+    text:
+      `${shown} [${where}] is ${(size / 1_048_576).toFixed(1)}MB — over the ` +
+      `${MAX_READ_FILE_BYTES / 1_048_576}MB read limit. Slice it with bash instead: ` +
+      `\`sed -n '1,200p' '${p}'\`, \`tail -n 200 '${p}'\`, or \`grep\` for what you need.`,
+  };
+}
+
+function oversizeImageResult(
+  shown: string,
+  where: string,
+  size: number,
+  p: string,
+): Result {
+  return {
+    ok: false,
+    text:
+      `${shown} [${where}] is ${(size / 1_048_576).toFixed(1)}MB — over the ` +
+      `${MAX_IMAGE_BYTES / 1_048_576}MB image limit. Downscale it first ` +
+      `(e.g. \`convert '${p}' -resize 1568x /tmp/small.jpg\`) and read that.`,
+  };
+}
+
 /**
  * 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
@@ -862,6 +957,13 @@ function nearMissHint(content: string, from: string): string {
   );
 }
 
+/** 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);
+}
+
 // ── helpers ─────────────────────────────────────────────────────────────────
 
 function runLocal(

package/src/core/mesh/service.ts

@@ -193,7 +193,9 @@ export class MeshService {
     // Stamp arrival against our own clock so waitForFreshLocation is immune
     // to device clock skew.
     this.receivedAt.set(loc.deviceId, Date.now());
-    for (const notify of [...this.waiters]) notify();
+    // Snapshot: a notified waiter removes itself (and new waiters may be
+    // added) mid-iteration — iterate a copy, not the live set.
+    for (const notify of Array.from(this.waiters)) notify();
     return loc;
   }
 
@@ -372,11 +374,11 @@ export class MeshService {
 
   /** `ring_device`: make the device sound/vibrate so it can be found. */
   ringDevice(query?: unknown, message?: unknown): Promise<MeshToolResult> {
-    return this.commandTool(query, "ring", {
-      ...(typeof message === "string" && message.trim()
-        ? { message: message.trim().slice(0, 200) }
-        : {}),
-    });
+    const note =
+      typeof message === "string" && message.trim()
+        ? message.trim().slice(0, 200)
+        : undefined;
+    return this.commandTool(query, "ring", note ? { message: note } : {});
   }
 
   /**

package/src/core/plugin/manage.ts

@@ -77,7 +77,7 @@ export function setPluginEnabled(
   if (!name) return { ok: false, error: "A plugin name is required." };
 
   if (isBuiltinPlugin(name)) {
-    const section = { ...(builtinSection(config, name) ?? {}), enabled };
+    const section = { ...builtinSection(config, name), enabled };
     (config as unknown as Record<string, unknown>)[name] = section;
     return { ok: true, name, persist: { [name]: section } };
   }

package/src/core/soul/centrality.ts

@@ -48,7 +48,7 @@ export function pagerank(
   const idx = new Map(nodes.map((h, i) => [h, i]));
 
   // Weighted out-adjacency over coactivation edges (only among value nodes).
-  const outWeight = new Array<number>(n).fill(0);
+  const outWeight = Array.from({ length: n }, () => 0);
   const edges: { from: number; to: number; w: number }[] = [];
   for (const from of nodes) {
     for (const e of dag.edgesFrom(from, "coactivation")) {
@@ -61,7 +61,7 @@ export function pagerank(
   }
 
   // Teleport / personalization vector.
-  const teleport = new Array<number>(n).fill(1 / n);
+  const teleport = Array.from({ length: n }, () => 1 / n);
   if (opts.personalization && opts.personalization.size > 0) {
     let total = 0;
     for (const [, w] of opts.personalization) total += Math.max(0, w);
@@ -74,7 +74,7 @@ export function pagerank(
     }
   }
 
-  let rank = new Array<number>(n).fill(1 / n);
+  let rank = Array.from({ length: n }, () => 1 / n);
   for (let it = 0; it < iterations; it++) {
     const next = teleport.map((t) => (1 - damping) * t);
 

package/src/core/soul/critic.ts

@@ -66,7 +66,10 @@ const SYCOPHANCY = [
 
 // Emoji detection without a heavy dependency: pictographic + symbol ranges.
 const EMOJI_RE =
-  /[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2190}-\u{21FF}\u{2B00}-\u{2BFF}\u{FE00}-\u{FE0F}\u{1F000}-\u{1F0FF}]/gu;
+  // Variation selectors are combining marks — alternated separately so the
+  // character class holds only standalone pictographic ranges
+  // (no-misleading-character-class).
+  /[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2190}-\u{21FF}\u{2B00}-\u{2BFF}\u{1F000}-\u{1F0FF}]|[\u{FE00}-\u{FE0F}]/gu;
 
 function countOccurrences(
   haystack: string,

package/src/core/soul/embedder.ts

@@ -63,7 +63,7 @@ export function cosineDistance(
 export function centroid(vectors: readonly (readonly number[])[]): number[] {
   if (vectors.length === 0) return [];
   const dim = vectors[0]!.length;
-  const acc = new Array<number>(dim).fill(0);
+  const acc = Array.from({ length: dim }, () => 0);
   for (const v of vectors) {
     for (let i = 0; i < dim; i++) acc[i]! += v[i]!;
   }
@@ -110,7 +110,7 @@ export class HashingEmbedder implements Embedder {
   }
 
   private embedOne(text: string): number[] {
-    const vec = new Array<number>(this.dim).fill(0);
+    const vec = Array.from({ length: this.dim }, () => 0);
     const lower = text.toLowerCase();
     const add = (feature: string): void => {
       const h = createHash("md5").update(feature).digest();

package/src/core/soul/talon-embedder.ts

@@ -67,7 +67,7 @@ export class TalonEmbedder implements Embedder {
       }
     }
 
-    const vec = new Array<number>(this.dim).fill(0);
+    const vec = Array.from({ length: this.dim }, () => 0);
     for (const [feature, count] of counts) {
       const h = createHash("md5").update(feature).digest();
       const idx = ((h[0]! << 16) | (h[1]! << 8) | h[2]!) % this.dim;

package/src/plugins/github/index.ts

@@ -98,9 +98,9 @@ export function createGitHubPlugin(config: { token?: string }): TalonPlugin {
     },
 
     getEnvVars() {
-      return {
-        ...(token ? { GITHUB_PERSONAL_ACCESS_TOKEN: token } : {}),
-      };
+      const vars: Record<string, string> = {};
+      if (token) vars.GITHUB_PERSONAL_ACCESS_TOKEN = token;
+      return vars;
     },
   };
 }