@ocis/myagent-cli 0.2.0 → 0.2.1

package/README.md

@@ -36,15 +36,15 @@ local repo (cwd)                                  remote myagent
 ## Install
 
 ```bash
-npm install -g @ocis/myagent-cli   # global (Node ≥22.19)
-bunx @ocis/myagent-cli             # one-off, no install (Bun)
+bunx @ocis/myagent-cli             # one-off, no install
+npm install -g @ocis/myagent-cli   # global
 ```
 
-The CLI runs on **Node.js ≥22.19** or **Bun ≥1.0** — it detects the runtime it was
-launched with. The published bin uses a Node shebang, so `bun install -g` also runs
-it under Node; use `bunx` (or `bun <path-to-bin>`) to run it on Bun. Configure
-credentials with `myagent config`, or set `MYAGENT_BASE_URL` /
-`MYAGENT_INTEGRATION_ID` / `MYAGENT_API_KEY`.
+The CLI runs on **Bun ≥1.0** or **Node.js ≥22.19**. The published bin is a small
+launcher that prefers Bun and falls back to Node, so `bunx` and `npm install -g`
+both work with whichever runtime you have. Configure credentials with
+`myagent config`, or set `MYAGENT_BASE_URL` / `MYAGENT_INTEGRATION_ID` /
+`MYAGENT_API_KEY`.
 
 ## Plan / Coding / Cowork modes
 

package/bin/myagent.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// Runtime launcher for the myagent CLI.
+//
+// dist/index.js runs on Bun or Node >= 22.19, but a bin shebang names exactly
+// one interpreter — and `bunx` honors it, so a plain Node shebang would run
+// the CLI under whatever Node happens to be on PATH (often too old for
+// pi-tui). This wrapper prefers Bun and falls back to Node.
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const entry = fileURLToPath(new URL("../dist/index.js", import.meta.url));
+const args = process.argv.slice(2);
+
+// Ctrl+C reaches the whole foreground process group, so the CLI handles it
+// itself; the launcher must not exit before that shutdown finishes. SIGTERM /
+// SIGHUP sent to the launcher PID alone are forwarded.
+process.on("SIGINT", () => {});
+
+let child;
+for (const sig of ["SIGTERM", "SIGHUP"]) {
+  process.on(sig, () => { try { child?.kill(sig); } catch { /* already gone */ } });
+}
+
+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)) {
+        console.error(
+          `myagent requires Bun or Node.js >= 22.19 (found Node ${process.versions.node}).\n` +
+            "Install Bun: https://bun.sh",
+        );
+        process.exit(1);
+      }
+      launch(process.execPath);
+      return;
+    }
+    console.error(`myagent: failed to start ${runtime}: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.once("exit", (code) => process.exit(code ?? 1));
+}
+
+launch("bun");

package/dist/agent/sessions.js

@@ -5,9 +5,8 @@
 // remembers which thread belongs to which working directory so `-c`/`-r`
 // resume the right conversation. Never contains credentials.
 // ---------------------------------------------------------------------------
-import { mkdir, rename } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { fileExists, readJsonFile, writeFile } from "../runtime.js";
 export class SessionIndex {
     path;
     data;
@@ -17,9 +16,7 @@ export class SessionIndex {
     }
     static async load(path) {
         try {
-            if (!(await fileExists(path)))
-                return new SessionIndex(path);
-            const parsed = await readJsonFile(path);
+            const parsed = JSON.parse(await readFile(path, "utf8"));
             if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
                 return new SessionIndex(path);
             // Normalize instead of trusting the persisted shape: a truncated write

package/dist/config.js

@@ -7,8 +7,7 @@
 // -------------------------------------------------------------------
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { mkdir, chmod, rename, stat } from "node:fs/promises";
-import { fileExists, readJsonFile, writeFile } from "./runtime.js";
+import { mkdir, chmod, readFile, rename, stat, writeFile } from "node:fs/promises";
 export const EMPTY_CONFIG = {
     baseUrl: "",
     integrationId: "",
@@ -54,10 +53,7 @@ export async function migrateLegacyConfigDir() {
 }
 export async function loadConfig() {
     try {
-        const path = configPath();
-        if (!(await fileExists(path)))
-            return { ...EMPTY_CONFIG };
-        const data = await readJsonFile(path);
+        const data = JSON.parse(await readFile(configPath(), "utf8"));
         const merged = { ...EMPTY_CONFIG, ...data };
         // Legacy field: autoApprove:false used to mean "ask" — honour it once.
         if (data.approvalDefault === undefined && data.autoApprove === false) {

package/dist/git/status.js

@@ -118,7 +118,7 @@ export function mergeGitStatus(porcelain, unstaged, staged) {
 const MAX_GIT_OUTPUT_CHARS = 512 * 1024;
 async function gitOutput(workspace, args, signal, okExitCodes) {
     try {
-        const proc = spawnProcess(["git", "-C", workspace, ...args], { stdout: "pipe", stderr: "ignore", stdin: "ignore" });
+        const proc = spawnProcess(["git", "-C", workspace, ...args], { stdout: "pipe", stderr: "ignore" });
         const onAbort = () => { try {
             proc.kill();
         }

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import { type StoredConfig } from "./config.js";
 import { type AgentMode } from "./agent/modes.js";
 import { type OutputFormat } from "./headless.js";

package/dist/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 // ---------------------------------------------------------------------------
 // myagent CLI — entry point.
 //
@@ -9,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 { fileURLToPath } from "node:url";
 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";
@@ -20,14 +19,14 @@ import { runTui } from "./ui/app.js";
 import { failureDoneEvent, failureResult, runHeadless } from "./headless.js";
 import { discoverSkills, formatSkillList, resolveSkillDirs } from "./skills/discovery.js";
 import { sanitizeForTerminal } from "./sanitize.js";
-import { isMainModule, readJsonFile, readStdinText } from "./runtime.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/.
  */
 async function readVersion() {
     try {
-        const pkg = await readJsonFile(fileURLToPath(new URL("../package.json", import.meta.url)));
+        const pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
         return pkg.version ?? "0.0.0";
     }
     catch {

package/dist/runtime.d.ts

@@ -1,8 +1,3 @@
-export declare const isBun: boolean;
-export declare function fileExists(path: string): Promise<boolean>;
-export declare function readTextFile(path: string): Promise<string>;
-export declare function readJsonFile<T>(path: string): Promise<T>;
-export declare function writeFile(path: string, data: string): Promise<void>;
 /** 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. */
@@ -14,22 +9,15 @@ export declare function readStdinText(): Promise<string>;
  * comparing the resolved entry path (realpath, so npm/bun bin symlinks match).
  */
 export declare function isMainModule(meta: ImportMeta): boolean;
-export interface ProcessStdin {
-    write(data: Uint8Array): void;
-    end(): void;
-}
 export interface ProcessHandle {
     pid: number;
     stdout: ReadableStream<Uint8Array>;
     stderr: ReadableStream<Uint8Array>;
-    stdin: ProcessStdin;
     exited: Promise<number>;
     kill(signal?: number | NodeJS.Signals): void;
 }
 export interface SpawnOptions {
     cwd?: string;
-    env?: Record<string, string>;
-    stdin?: "pipe" | "ignore";
     stdout?: "pipe" | "ignore";
     stderr?: "pipe" | "ignore";
     /** POSIX: run in a new process group so `process.kill(-pid)` reaches the tree. */

package/dist/runtime.js

@@ -1,63 +1,30 @@
 // ---------------------------------------------------------------------------
-// Runtime shims: Bun APIs on Bun, node: equivalents on Node.
+// Runtime shims: the few places where Bun and Node genuinely differ.
 //
-// The CLI runs on both runtimes. Bun's file/spawn/stdin/which globals have no
-// Node counterpart, so every call site goes through this module instead of
-// touching `Bun.*` directly. The Bun branches are guarded by `typeof Bun`, so
-// the emitted JS never touches the `Bun` global on Node.
-//
-// The subprocess shim normalizes both runtimes to one `ProcessHandle` (Web
-// ReadableStreams for stdout/stderr, a FileSink-like stdin, `.pid`, `.kill()`,
-// `.exited`) — the same shape `Bun.spawn` returns, so the shell/git/grep tools
-// run unchanged on either runtime.
+// 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.
 // ---------------------------------------------------------------------------
 import { spawn } from "node:child_process";
 import { realpathSync, statSync } from "node:fs";
-import { readFile, stat, writeFile as writeFileFs } from "node:fs/promises";
 import { Buffer } from "node:buffer";
 import { delimiter, join } from "node:path";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
-export const isBun = typeof Bun !== "undefined";
-// --- files -----------------------------------------------------------------
-export async function fileExists(path) {
-    if (isBun)
-        return Bun.file(path).exists();
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-export async function readTextFile(path) {
-    if (isBun)
-        return Bun.file(path).text();
-    return readFile(path, "utf8");
-}
-export async function readJsonFile(path) {
-    return JSON.parse(await readTextFile(path));
-}
-export async function writeFile(path, data) {
-    if (isBun) {
-        await Bun.write(path, data);
-        return;
-    }
-    await writeFileFs(path, data);
-}
+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 dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
     const exts = process.platform === "win32"
         ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
         : [""];
-    const names = cmd.includes(".") ? [cmd] : exts.map((ext) => cmd + ext);
-    for (const dir of dirs) {
-        for (const name of names) {
-            const candidate = join(dir, name);
+    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;
@@ -106,8 +73,7 @@ export function spawnProcess(args, opts) {
 function spawnBun(args, opts) {
     const proc = Bun.spawn(args, {
         cwd: opts?.cwd,
-        env: opts?.env ? { ...process.env, ...opts.env } : undefined,
-        stdin: opts?.stdin === "pipe" ? "pipe" : "ignore",
+        stdin: "ignore",
         stdout: opts?.stdout === "pipe" ? "pipe" : "ignore",
         stderr: opts?.stderr === "pipe" ? "pipe" : "ignore",
         detached: opts?.detached,
@@ -116,10 +82,6 @@ function spawnBun(args, opts) {
         pid: proc.pid,
         stdout: proc.stdout,
         stderr: proc.stderr,
-        stdin: {
-            write: (data) => { proc.stdin.write(data); },
-            end: () => { proc.stdin.end(); },
-        },
         exited: proc.exited,
         kill: (signal) => { try {
             proc.kill(signal);
@@ -130,9 +92,8 @@ function spawnBun(args, opts) {
 function spawnNode(args, opts) {
     const child = spawn(args[0], args.slice(1), {
         cwd: opts?.cwd,
-        env: opts?.env ? { ...process.env, ...opts.env } : process.env,
         stdio: [
-            opts?.stdin === "pipe" ? "pipe" : "ignore",
+            "ignore",
             opts?.stdout === "pipe" ? "pipe" : "ignore",
             opts?.stderr === "pipe" ? "pipe" : "ignore",
         ],
@@ -151,12 +112,6 @@ function spawnNode(args, opts) {
         stderr: child.stderr
             ? Readable.toWeb(child.stderr)
             : new ReadableStream(),
-        stdin: {
-            write: (data) => { if (child.stdin)
-                child.stdin.write(Buffer.from(data)); },
-            end: () => { if (child.stdin)
-                child.stdin.end(); },
-        },
         exited,
         kill: (signal) => { try {
             child.kill(signal);

package/dist/skills/discovery.js

@@ -8,9 +8,8 @@
 //   2. <workspace>/.myagent/skills
 //   3. <configDir>/skills (created on first run so there's always a home)
 // -------------------------------------------------------------------
-import { mkdir, readdir, stat } from "node:fs/promises";
+import { mkdir, readFile, readdir, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { readTextFile } from "../runtime.js";
 /** Parse the leading `--- ... ---` frontmatter for name/description. */
 export function parseFrontmatter(md) {
     const match = md.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -27,7 +26,7 @@ export function parseFrontmatter(md) {
 async function loadSkillDir(dir, fallbackName) {
     let md;
     try {
-        md = await readTextFile(join(dir, "SKILL.md"));
+        md = await readFile(join(dir, "SKILL.md"), "utf8");
     }
     catch {
         return null;

package/dist/tools/grep.js

@@ -106,10 +106,10 @@ async function searchWithRipgrep(pattern, searchPath, include, signal) {
             if (buffer)
                 consume(buffer);
             const code = await proc.exited;
-            // rg exits 1 for "no matches" (an answer); any other non-zero exit is a
-            // failure — e.g. a JS-valid pattern (backreference, lookahead) its engine
-            // rejects — and must fall back to the JS walk rather than read as "none".
-            if (code > 1)
+            // rg exits 0 (matches) or 1 (no matches); anything else — a rejected
+            // pattern, a spawn failure (-1) — falls back to the JS walk rather than
+            // reading as "none".
+            if (code !== 0 && code !== 1)
                 return null;
             return matches;
         }

package/dist/tools/shell.js

@@ -69,10 +69,8 @@ const shellTool = defineTool({
         const detached = process.platform !== "win32";
         const proc = spawnProcess(shell, {
             cwd: ctx.workspace,
-            env: process.env,
             stdout: "pipe",
             stderr: "pipe",
-            stdin: "ignore",
             // POSIX: a new process group lets us kill the whole pipeline (a bare
             // proc.kill() only signals the shell, and grandchildren keep the pipes
             // open, delaying the timeout unwind).

package/dist/ui/app.js

@@ -5,6 +5,7 @@
 // Owns the slash commands, keybindings, approvals, resume/render of remote
 // history and the git status polling that feeds the right panel.
 // ---------------------------------------------------------------------------
+import { writeFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { CombinedAutocompleteProvider, Box, Container, HStack, isViewportTUI, matchesKey, MouseRegion, ProcessTerminal, ScrollView, SelectList, Spacer, TuiAltScreen, VStack, visibleWidth, } from "@earendil-works/pi-tui";
 import { AgentRunner, usageFromSession } from "../agent/turn.js";
@@ -14,7 +15,6 @@ import { deriveTitle } from "../agent/sessions.js";
 import { TodoStore } from "../agent/todo.js";
 import { ApprovalPolicy } from "../approval/policy.js";
 import { collectFileDiff, collectGitStatus, EMPTY_GIT_STATUS } from "../git/status.js";
-import { writeFile } from "../runtime.js";
 import { bgRgb, isColorEnabled, modeBorder, overlayBackgroundRgb, panelBackgroundRgb, style, userMessageBackgroundRgb } from "./colors.js";
 import { helpLines } from "./help.js";
 import { buildModelItems, currentModelId } from "./model-list.js";

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ocis/myagent-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Terminal coding agent for your local repository, powered by a remote MyAgent server",
   "type": "module",
   "bin": {
-    "myagent": "./dist/index.js"
+    "myagent": "./bin/myagent.js"
   },
   "files": [
+    "bin",
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "skills"