@ocis/myagent-cli 0.2.1 → 0.2.2

package/bin/myagent.js

@@ -21,13 +21,18 @@ for (const sig of ["SIGTERM", "SIGHUP"]) {
   process.on(sig, () => { try { child?.kill(sig); } catch { /* already gone */ } });
 }
 
+/** pi-tui's regex needs the `v` flag, which Node only has from 22.19. */
+function nodeTooOld() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  return major < 22 || (major === 22 && minor < 19);
+}
+
 function launch(runtime) {
   child = spawn(runtime, [entry, ...args], { stdio: "inherit" });
 
   child.once("error", (err) => {
     if (err.code === "ENOENT" && runtime !== process.execPath) {
-      const [major, minor] = process.versions.node.split(".").map(Number);
-      if (major < 22 || (major === 22 && minor < 19)) {
+      if (nodeTooOld()) {
         console.error(
           `myagent requires Bun or Node.js >= 22.19 (found Node ${process.versions.node}).\n` +
             "Install Bun: https://bun.sh",

package/dist/agent/turn.js

@@ -850,6 +850,11 @@ export class AgentRunner {
             if (adopted) {
                 live.push({ ...output, tool_call_id: adopted.id });
                 unmatched.delete(adopted.id);
+                // The original id is never submitted (its result was re-attached to
+                // the retry), so it must leave the pending set — otherwise the run-end
+                // sweep announces a release for a call that was answered.
+                if (call)
+                    this.pendingSubmission.delete(call.id);
                 cb.onNotice(`Re-attached the result of ${call?.name ?? "a tool call"} to the agent's retry.`, "info");
                 continue;
             }

package/dist/approval/policy.js

@@ -142,7 +142,7 @@ export class ApprovalPolicy {
         try {
             // A cancel/timeout while queued settles immediately — no card, no wait.
             if (wait)
-                await Promise.race([previous.catch(() => { }), deadline.promise]);
+                await Promise.race([previous, deadline.promise]);
             if (settled)
                 return await deadline.promise;
             return await Promise.race([this.prompt(request, controller.signal), deadline.promise]);

package/dist/index.js

@@ -8,8 +8,8 @@
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { homedir } from "node:os";
-import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
+import pkg from "../package.json" with { type: "json" };
 import { IntegrationClient } from "./protocol/client.js";
 import { ToolRegistry } from "./tools/registry.js";
 import { combinedIntegrationUrl, configDir, isConfigured, loadConfig, migrateLegacyConfigDir, resolveConfig, saveConfig, sessionsPath, splitIntegrationUrl, } from "./config.js";
@@ -21,18 +21,11 @@ import { discoverSkills, formatSkillList, resolveSkillDirs } from "./skills/disc
 import { sanitizeForTerminal } from "./sanitize.js";
 import { isMainModule, readStdinText } from "./runtime.js";
 /**
- * Package version, read from package.json so npm releases never drift from
- * `--version`. Resolves to the package root from both src/ (dev) and dist/.
+ * Package version, bundled from package.json so npm releases and the compiled
+ * binary never drift from `--version` (a runtime read cannot resolve inside
+ * `bun build --compile`'s virtual filesystem).
  */
-async function readVersion() {
-    try {
-        const pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
-        return pkg.version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-}
+const VERSION = pkg.version;
 const HELP = `myagent — a coding agent for your local repository, powered by MyAgent
 
 Usage:
@@ -304,7 +297,7 @@ async function main() {
         return 0;
     }
     if (args.command === "version") {
-        process.stdout.write(`${await readVersion()}\n`);
+        process.stdout.write(`${VERSION}\n`);
         return 0;
     }
     const stored = await loadConfig();

package/dist/runtime.d.ts

@@ -1,5 +1,3 @@
-/** Resolve an executable on PATH (Bun.which on Bun, a PATH scan on Node). */
-export declare function which(cmd: string): string | null;
 /** Read all of stdin as UTF-8 text. Callers check `process.stdin.isTTY` first. */
 export declare function readStdinText(): Promise<string>;
 /**
@@ -24,3 +22,10 @@ export interface SpawnOptions {
     detached?: boolean;
 }
 export declare function spawnProcess(args: string[], opts?: SpawnOptions): ProcessHandle;
+/**
+ * Exit code for a child that ended, matching Bun's convention: a signal death
+ * is 128 + signal number (SIGKILL → 137). Node's `close` reports `code: null`
+ * with the signal name, so without this the same kill reads as 0 on Node and
+ * 137 on Bun — abort paths key on the code.
+ */
+export declare function exitCodeFromClose(code: number | null, signal: NodeJS.Signals | null): number;

package/dist/runtime.js

@@ -2,40 +2,18 @@
 // Runtime shims: the few places where Bun and Node genuinely differ.
 //
 // Everything else uses node: builtins, which Bun implements natively — only
-// subprocess spawning (Bun.spawn vs node:child_process), PATH lookup
-// (Bun.which), stdin (Bun.stdin) and entry-point detection (import.meta.main)
-// need a runtime branch. The Bun branches are guarded by `typeof Bun`, so the
-// emitted JS never touches the `Bun` global on Node.
+// subprocess spawning (Bun.spawn vs node:child_process), stdin (Bun.stdin) and
+// entry-point detection (import.meta.main) need a runtime branch. The Bun
+// branches are guarded by `typeof Bun`, so the emitted JS never touches the
+// `Bun` global on Node.
 // ---------------------------------------------------------------------------
 import { spawn } from "node:child_process";
-import { realpathSync, statSync } from "node:fs";
+import { realpathSync } from "node:fs";
 import { Buffer } from "node:buffer";
-import { delimiter, join } from "node:path";
+import { constants as osConstants } from "node:os";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 const isBun = typeof Bun !== "undefined";
-// --- which -----------------------------------------------------------------
-/** Resolve an executable on PATH (Bun.which on Bun, a PATH scan on Node). */
-export function which(cmd) {
-    if (isBun && Bun.which)
-        return Bun.which(cmd);
-    const exts = process.platform === "win32"
-        ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
-        : [""];
-    for (const dir of (process.env.PATH ?? "").split(delimiter)) {
-        for (const ext of exts) {
-            const candidate = join(dir, cmd + ext);
-            try {
-                if (statSync(candidate).isFile())
-                    return candidate;
-            }
-            catch {
-                /* keep looking */
-            }
-        }
-    }
-    return null;
-}
 // --- stdin -----------------------------------------------------------------
 /** Read all of stdin as UTF-8 text. Callers check `process.stdin.isTTY` first. */
 export async function readStdinText() {
@@ -70,18 +48,51 @@ export function isMainModule(meta) {
 export function spawnProcess(args, opts) {
     return isBun ? spawnBun(args, opts) : spawnNode(args, opts);
 }
+/** An already-ended stream, for pipes that were not requested. */
+function emptyStream() {
+    return new ReadableStream();
+}
+/**
+ * Exit code for a child that ended, matching Bun's convention: a signal death
+ * is 128 + signal number (SIGKILL → 137). Node's `close` reports `code: null`
+ * with the signal name, so without this the same kill reads as 0 on Node and
+ * 137 on Bun — abort paths key on the code.
+ */
+export function exitCodeFromClose(code, signal) {
+    if (code !== null)
+        return code;
+    if (!signal)
+        return 0;
+    return 128 + (osConstants.signals[signal] ?? 0);
+}
 function spawnBun(args, opts) {
-    const proc = Bun.spawn(args, {
-        cwd: opts?.cwd,
-        stdin: "ignore",
-        stdout: opts?.stdout === "pipe" ? "pipe" : "ignore",
-        stderr: opts?.stderr === "pipe" ? "pipe" : "ignore",
-        detached: opts?.detached,
-    });
+    let proc;
+    try {
+        proc = Bun.spawn(args, {
+            cwd: opts?.cwd,
+            stdin: "ignore",
+            stdout: opts?.stdout === "pipe" ? "pipe" : "ignore",
+            stderr: opts?.stderr === "pipe" ? "pipe" : "ignore",
+            detached: opts?.detached,
+        });
+    }
+    catch (err) {
+        // Bun throws synchronously for a missing binary; Node reports it through
+        // `exited` = -1. Normalize so callers see one contract on both runtimes.
+        if (err?.code !== "ENOENT")
+            throw err;
+        return {
+            pid: 0,
+            stdout: emptyStream(),
+            stderr: emptyStream(),
+            exited: Promise.resolve(-1),
+            kill: () => { },
+        };
+    }
     return {
         pid: proc.pid,
-        stdout: proc.stdout,
-        stderr: proc.stderr,
+        stdout: opts?.stdout === "pipe" ? proc.stdout : emptyStream(),
+        stderr: opts?.stderr === "pipe" ? proc.stderr : emptyStream(),
         exited: proc.exited,
         kill: (signal) => { try {
             proc.kill(signal);
@@ -101,17 +112,17 @@ function spawnNode(args, opts) {
     });
     // First of close/error wins: a spawn failure (ENOENT) may emit only `error`.
     const exited = new Promise((resolve) => {
-        child.once("close", (code) => resolve(code ?? 0));
+        child.once("close", (code, signal) => resolve(exitCodeFromClose(code, signal)));
         child.once("error", () => resolve(-1));
     });
     return {
         pid: child.pid ?? 0,
         stdout: child.stdout
             ? Readable.toWeb(child.stdout)
-            : new ReadableStream(),
+            : emptyStream(),
         stderr: child.stderr
             ? Readable.toWeb(child.stderr)
-            : new ReadableStream(),
+            : emptyStream(),
         exited,
         kill: (signal) => { try {
             child.kill(signal);

package/dist/tools/grep.js

@@ -8,7 +8,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { defineTool, optionalString, requireString } from "./types.js";
 import { resolveToolPath } from "./paths.js";
-import { spawnProcess, which } from "../runtime.js";
+import { spawnProcess } from "../runtime.js";
 const MAX_MATCHES = 100;
 /**
  * Wall-clock budget for the JS fallback walk. The pattern is LLM-authored and
@@ -31,7 +31,9 @@ function formatMatches(matches, workspace) {
     return lines.join("\n") + (truncated ? `\n… (results capped at ${MAX_MATCHES} matches)` : "");
 }
 /**
- * Search with ripgrep when available. Returns null when rg is unavailable.
+ * Search with ripgrep when available. Returns null when rg is unavailable
+ * (missing binary, rejected pattern, spawn failure) so the caller falls back
+ * to the JS walk.
  *
  * The cap is enforced HERE, on the parse: rg's `--max-count` is per FILE, so
  * on a large tree it can still produce a huge JSON stream. The output is read
@@ -39,9 +41,6 @@ function formatMatches(matches, workspace) {
  * buffer nor the child outlives the cap.
  */
 async function searchWithRipgrep(pattern, searchPath, include, signal) {
-    const rg = which("rg");
-    if (!rg)
-        return null;
     // --max-count bounds the per-file work rg does; the global cap is ours.
     const args = ["--json", "--max-count", String(MAX_MATCHES), "--no-ignore", "-e", pattern];
     if (include)
@@ -50,7 +49,7 @@ async function searchWithRipgrep(pattern, searchPath, include, signal) {
         args.push("--glob", `!**/${dir}/**`);
     args.push(searchPath);
     try {
-        const proc = spawnProcess([rg, ...args], { stdout: "pipe", stderr: "ignore" });
+        const proc = spawnProcess(["rg", ...args], { stdout: "pipe", stderr: "ignore" });
         const onAbort = () => { try {
             proc.kill();
         }

package/dist/ui/components.d.ts

@@ -42,6 +42,9 @@ export declare class AssistantMessageComponent implements Component {
     /** Raw stream (unsanitized) — the sanitizing pass needs the whole text. */
     private raw;
     private text;
+    /** Set once any delta carried a control char: from then on the accumulated
+     *  text must be re-sanitized (a sequence can span deltas). */
+    private dirty;
     constructor();
     append(delta: string): void;
     get content(): string;
@@ -51,6 +54,7 @@ export declare class AssistantMessageComponent implements Component {
 export declare class ReasoningBlockComponent implements Component {
     private raw;
     private text;
+    private dirty;
     expanded: boolean;
     append(delta: string): void;
     toggle(): void;

package/dist/ui/components.js

@@ -84,11 +84,21 @@ export class UserMessageComponent {
         ];
     }
 }
+/**
+ * Characters `sanitizeForTerminal` would change (ESC and C0/C1 controls; tab
+ * and newline are kept). While a stream has never contained one, the sanitizer
+ * is the identity — re-running it over the whole accumulated text on every
+ * delta is O(n²) for no effect.
+ */
+const CONTROL_CHARS = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/;
 export class AssistantMessageComponent {
     md;
     /** Raw stream (unsanitized) — the sanitizing pass needs the whole text. */
     raw = "";
     text = "";
+    /** Set once any delta carried a control char: from then on the accumulated
+     *  text must be re-sanitized (a sequence can span deltas). */
+    dirty = false;
     constructor() {
         this.md = new Markdown("", 0, 0, markdownTheme, { color: assistantColor });
     }
@@ -97,9 +107,16 @@ export class AssistantMessageComponent {
         // material (file bodies, fetched pages) verbatim — strip terminal
         // sequences, like tool output and headless deltas do. Sanitizing the
         // ACCUMULATED text, not the delta: a sequence split across two deltas
-        // would slip through a per-delta pass.
+        // would slip through a per-delta pass. The clean fast path is exact: with
+        // no control char anywhere, the sanitizer returns the input unchanged.
         this.raw += delta;
-        this.text = sanitizeForTerminal(this.raw);
+        if (!this.dirty && !CONTROL_CHARS.test(delta)) {
+            this.text = this.raw;
+        }
+        else {
+            this.dirty = true;
+            this.text = sanitizeForTerminal(this.raw);
+        }
         this.md.setText(this.text);
     }
     get content() {
@@ -164,12 +181,19 @@ export class AssistantMessageComponent {
 export class ReasoningBlockComponent {
     raw = "";
     text = "";
+    dirty = false;
     expanded = false;
     append(delta) {
         // Same rule as assistant text: reasoning is model output rendered to the
         // real terminal, and it quotes tool output freely.
         this.raw += delta;
-        this.text = sanitizeForTerminal(this.raw);
+        if (!this.dirty && !CONTROL_CHARS.test(delta)) {
+            this.text = this.raw;
+        }
+        else {
+            this.dirty = true;
+            this.text = sanitizeForTerminal(this.raw);
+        }
     }
     toggle() {
         this.expanded = !this.expanded;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocis/myagent-cli",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Terminal coding agent for your local repository, powered by a remote MyAgent server",
   "type": "module",
   "bin": {