omnirush 0.4.1 → 0.4.2

package/src/bin.js

@@ -42,9 +42,11 @@ import {
   modelsConfig,
   resolveGatewayUrl,
   withModelDefaults,
+  withDefaultThinkingLevel,
   resolveModelDefaults,
 } from "./lib.js";
 import { installManagedTools } from "./tools.js";
+import { ensureRuntime, managedBunPath } from "../scripts/postinstall.js";
 import {
   clearAuth,
   deviceAuthorize,
@@ -70,6 +72,7 @@ const PI_AGENT_DIR = process.env.OMNIRUSH_PI_AGENT_DIR
   ? path.resolve(process.env.OMNIRUSH_PI_AGENT_DIR)
   : path.join(os.homedir(), ".pi", "agent");
 const PI_MODELS_JSON = path.join(PI_AGENT_DIR, "models.json");
+const PI_SETTINGS_JSON = path.join(PI_AGENT_DIR, "settings.json");
 const PI_EXT_DIR = path.join(PI_AGENT_DIR, "extensions", "omnirush");
 
 function managerOrigin() {
@@ -116,6 +119,29 @@ function ensureDirs() {
   } catch {
     /* best effort — pi falls back to PATH, then its own downloader */
   }
+  installDefaultThinkingLevel();
+}
+
+// Product default effort (P2): xhigh. Fills an ABSENT
+// defaultThinkingLevel in the agent settings only — an explicit user
+// choice always wins; the models' thinkingLevelMap is untouched.
+function installDefaultThinkingLevel() {
+  let settings = {};
+  try {
+    settings = JSON.parse(fs.readFileSync(PI_SETTINGS_JSON, "utf8"));
+  } catch {
+    /* fresh install or unparsable — start clean rather than clobber */
+    settings = {};
+  }
+  let next;
+  try {
+    next = withDefaultThinkingLevel(settings);
+  } catch {
+    return;
+  }
+  if (next !== settings) {
+    fs.writeFileSync(PI_SETTINGS_JSON, JSON.stringify(next, null, 2) + "\n");
+  }
 }
 
 // Merge our provider into the user's models.json without clobbering
@@ -163,36 +189,44 @@ function isMusl() {
 }
 
 function findBun() {
-  // Vendored per-platform bun first, then PATH, then the standard
-  // single-user install location. Linux packages ship both the glibc and
-  // the musl binary; the launcher picks by the running libc.
+  // MANAGED runtime first — always (issue #7: a system bun on PATH
+  // shadowed ours when .runtime was missing from a dev checkout, and a
+  // mismatched bun breaks the fork's own extensions). Vendored paths are
+  // canonical; PATH and ~/.bun are last-resort fallbacks that only run
+  // after a self-heal download was attempted. Linux packages ship both
+  // the glibc and the musl binary; the launcher picks by the running libc.
   const runtimeRoot = path.resolve(__dirname, "..", ".runtime");
   const plat = process.platform;
   const arch = process.arch === "arm64" ? "aarch64" : "x64";
-  const candidates = [];
+  const managedCandidates = [];
   if (plat === "win32") {
-    candidates.push(
-      path.join(runtimeRoot, "bun-windows-x64", "bin", "bun.exe"),
-    );
-    for (const dir of (process.env.PATH || "").split(path.delimiter)) {
-      if (dir) candidates.push(path.join(dir, "bun.exe"));
-    }
+    managedCandidates.push(managedBunPath());
+    managedCandidates.push(path.join(runtimeRoot, "bun-windows-x64", "bin", "bun.exe"));
   } else {
     if (plat === "linux") {
-      if (isMusl()) candidates.push(path.join(runtimeRoot, "bin", "bun-musl"));
-      else if (arch === "x64") candidates.push(path.join(runtimeRoot, "bin", "bun"));
-      candidates.push(path.join(runtimeRoot, "bin", `bun-${arch}${isMusl() ? "-musl" : ""}`));
+      if (isMusl()) managedCandidates.push(path.join(runtimeRoot, "bin", "bun-musl"));
+      else if (arch === "x64") managedCandidates.push(path.join(runtimeRoot, "bin", "bun"));
+      managedCandidates.push(path.join(runtimeRoot, "bin", `bun-${arch}${isMusl() ? "-musl" : ""}`));
     }
-    candidates.push(path.join(runtimeRoot, `bun-${plat}-${arch}`, "bin", "bun"));
-    for (const dir of (process.env.PATH || "").split(path.delimiter)) {
-      if (dir) candidates.push(path.join(dir, "bun"));
+    managedCandidates.push(path.join(runtimeRoot, `bun-${plat}-${arch}`, "bin", "bun"));
+  }
+  for (const c of managedCandidates) {
+    try {
+      fs.accessSync(c, fs.constants.X_OK);
+      return { path: c, managed: true };
+    } catch {
+      /* next */
     }
-    candidates.push(path.join(os.homedir(), ".bun", "bin", "bun"));
   }
-  for (const c of candidates) {
+  const fallbackCandidates = [];
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    if (dir) fallbackCandidates.push(path.join(dir, plat === "win32" ? "bun.exe" : "bun"));
+  }
+  fallbackCandidates.push(path.join(os.homedir(), ".bun", "bin", plat === "win32" ? "bun.exe" : "bun"));
+  for (const c of fallbackCandidates) {
     try {
       fs.accessSync(c, fs.constants.X_OK);
-      return c;
+      return { path: c, managed: false };
     } catch {
       /* next */
     }
@@ -200,19 +234,57 @@ function findBun() {
   return null;
 }
 
-function runtimeFor(entry) {
+/**
+ * Self-healing managed-runtime resolution: if no MANAGED bun is
+ * installed, run the same fetch the postinstall runs, then re-check. A
+ * PATH bun is only used when the managed download is impossible — and
+ * the caller reports it.
+ */
+async function resolveBun() {
+  let found = findBun();
+  if (found?.managed) return found;
+  // Self-heal: fetch the managed runtime (downloads only what is
+  // missing; a few MB-100MB depending on platform).
+  try {
+    await ensureRuntime();
+  } catch (error) {
+    // fall through: maybe a usable fallback still exists
+    try {
+      fs.accessSync(managedBunPath(), fs.constants.X_OK);
+      found = { path: managedBunPath(), managed: true };
+    } catch {
+      console.error(`omnirush: managed runtime download failed (${error?.message ?? error})`);
+    }
+  }
+  if (!found?.managed) found = findBun();
+  return found;
+}
+
+async function runtimeFor(entry) {
   // pi is Bun-first; its CLI imports node:module#enableCompileCache,
-  // which needs Node >= 22.8. Prefer bun when present, else enforce the
-  // Node floor with a clear message.
-  const bun = findBun();
-  if (bun) return { cmd: bun, args: [entry] };
+  // which needs Node >= 22.8. The MANAGED bun wins unconditionally
+  // (self-heal download first); a PATH bun is a last resort. Plain node
+  // 22.8+ runs the agent without any bun.
+  const found = await resolveBun();
+  if (found) {
+    if (!found.managed) {
+      console.error(
+        "omnirush: using a non-managed bun from PATH " +
+          `(${found.path}) — the managed runtime is missing. Fix: run ` +
+          "`npm install -g omnirush` again (retries the runtime download).",
+      );
+    }
+    return { cmd: found.path, args: [entry] };
+  }
   const [major, minor] = process.versions.node.split(".").map(Number);
   if (major > 22 || (major === 22 && minor >= 8)) {
     return { cmd: process.execPath, args: [entry] };
   }
   console.error(
-    `omnirush: Node ${process.versions.node} is too old for the agent core ` +
-      "(need >= 22.8) and bun was not found. Install Node 22+ or bun.",
+    `omnirush couldn't set up its agent runtime (Node ${process.versions.node} is too ` +
+      "old for the agent core, which needs Node >= 22.8, and the managed runtime " +
+      "download did not succeed — network or install issue). Fix: run " +
+      "`npm install -g omnirush` again (retries the runtime download), or install Node 22.8+.",
   );
   process.exit(1);
 }
@@ -448,6 +520,54 @@ async function cmdDoctor() {
       );
     }
   }
+  // Agent runtime: the managed bun must exist and always wins (issue #7:
+  // a PATH bun shadowed the managed runtime for a dev). Self-heal by
+  // downloading it right here when missing; report WHICH runtime is in
+  // use so support can see it.
+  {
+    let found = findBun();
+    let healError = null;
+    if (!found?.managed) {
+      try {
+        await ensureRuntime();
+      } catch (error) {
+        healError = error;
+      }
+      found = findBun();
+    }
+    if (found?.managed) {
+      ok(
+        "runtime",
+        true,
+        `bundled bun ${bunVersionOf(found.path)} (${found.path})`,
+      );
+    } else if (healError) {
+      ok(
+        "runtime",
+        false,
+        `managed runtime missing and the download failed (${healError?.message ?? healError}) — ` +
+          "Fix: run `npm install -g omnirush` again (retries the runtime download), or install Node 22.8+",
+      );
+    } else if (found) {
+      console.log(
+        `WARN runtime — using a NON-managed bun ${bunVersionOf(found.path)} from PATH (${found.path}); ` +
+          "the managed runtime is missing. Fix: run `npm install -g omnirush` again (retries the runtime download)",
+      );
+    } else {
+      const [major, minor] = process.versions.node.split(".").map(Number);
+      if (major > 22 || (major === 22 && minor >= 8)) {
+        ok("runtime", true, "no bun needed — Node " + process.versions.node + " runs the agent");
+      } else {
+        ok(
+          "runtime",
+          false,
+          `Node ${process.versions.node} is too old for the agent core (need >= 22.8) and the managed ` +
+            "runtime is missing — Fix: run `npm install -g omnirush` again (retries the runtime download), " +
+            "or install Node 22.8+",
+        );
+      }
+    }
+  }
   // Search tools: bundled fd/rg (or system ones) keep the agent off its
   // GitHub download path, which fails on restricted networks.
   const toolsRoot = path.join(PI_AGENT_DIR, "bin");
@@ -492,6 +612,15 @@ function requireAuth() {
   process.exit(1);
 }
 
+function bunVersionOf(bunPath) {
+  try {
+    const { execFileSync } = require("node:child_process");
+    return String(execFileSync(bunPath, ["--version"], { timeout: 5000 })).trim() || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
 function ownVersion() {
   try {
     return JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8")).version;
@@ -527,24 +656,68 @@ function childEnv(auth) {
   };
 }
 
+/**
+ * Spawn the agent with launcher signal hygiene (issue #9). The terminal's
+ * Ctrl+C already reaches the whole foreground process group — the child
+ * (bun -> pi) handles it itself (first ^C interrupts the turn, second
+ * exits pi). The launcher therefore IGNORES SIGINT (it used to die
+ * immediately, orphaning the TUI and forcing a third ^C), forwards
+ * process-directed signals, and exits only when the child does, with the
+ * child's exit code or signal.
+ */
+function spawnAgent(cmd, args, opts) {
+  const child = spawn(cmd, args, opts);
+  let childAlive = true;
+  let lastExit = { code: 0, signal: null };
+  child.on("exit", (code, signal) => {
+    childAlive = false;
+    lastExit = { code, signal };
+  });
+  const onInterrupt = () => {
+    if (!childAlive) {
+      process.exit(lastExit.code ?? 0);
+    }
+    // Otherwise let pi handle the interrupt — never double-send, never
+    // exit first.
+  };
+  const forward = (signal) => () => {
+    if (childAlive) {
+      try {
+        child.kill(signal);
+      } catch {
+        /* already gone */
+      }
+    } else {
+      process.exit(lastExit.code ?? 0);
+    }
+  };
+  process.on("SIGINT", onInterrupt);
+  process.on("SIGTERM", forward("SIGTERM"));
+  if (process.platform !== "win32") {
+    process.on("SIGHUP", forward("SIGHUP"));
+    process.on("SIGQUIT", forward("SIGQUIT"));
+  }
+  child.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exit(code ?? 0);
+  });
+  return child;
+}
+
 async function cmdRun() {
   ensureDirs();
   const auth = requireAuth();
   installModelsJson(agentGatewayUrl(auth));
   installExtensions();
   const entry = piEntry();
-  const { cmd, args } = runtimeFor(entry);
+  const { cmd, args } = await runtimeFor(entry);
   // Plain `omnirush` always runs the SOTA model (charter rule 1); user
   // flags win when present.
   const piArgs = withModelDefaults([], resolveModelDefaults(process.env));
-  const child = spawn(cmd, [...args, ...piArgs], {
+  spawnAgent(cmd, [...args, ...piArgs], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth) },
   });
-  child.on("exit", (code, signal) => {
-    if (signal) process.kill(process.pid, signal);
-    else process.exit(code ?? 0);
-  });
 }
 
 async function cmdCollect(argv) {
@@ -552,20 +725,59 @@ async function cmdCollect(argv) {
   const auth = requireAuth();
   installExtensions();
   const entry = path.join(__dirname, "..", "assets", "collect-once.ts");
-  const { cmd, args } = runtimeFor(entry);
-  const child = spawn(cmd, [...args, ...argv], {
+  const { cmd, args } = await runtimeFor(entry);
+  spawnAgent(cmd, [...args, ...argv], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth) },
   });
-  child.on("exit", (code, signal) => {
-    if (signal) process.kill(process.pid, signal);
-    else process.exit(code ?? 0);
-  });
+}
+
+// Native omnirush help (issue #8): --help/-h must render OUR commands
+// and branding — never forward to the agent core's help.
+function printHelp() {
+  console.log(`omnirush — free daily tokens for the most powerful coding model on earth
+
+Usage:
+  omnirush                          start the agent (default: gpt-6-astra)
+  omnirush -p "<prompt>"            run a one-shot prompt
+  omnirush login                    sign in (device flow via your browser)
+  omnirush logout                   forget the stored device tokens
+  omnirush whoami                   show the signed-in identity
+  omnirush doctor                   check auth, manager, runtime, agent config
+  omnirush collect [--dir PATH]     one-shot workspace snapshot upload
+  omnirush update                   update omnirush (npm install -g omnirush@latest)
+  omnirush --version                show the omnirush version
+
+Options:
+  --model <model[:effort]>          model override (gpt-6-astra, gpt-5.6-sol;
+                                    effort: minimal..max)
+  --thinking <level>                reasoning effort override
+  --strict-sota                     exit non-zero if the served model is not
+                                    the requested SOTA model
+  --session <file> | --continue     session options (forwarded to the agent)
+  -p, --print "<prompt>"            print-mode: answer once and exit
+  -h, --help                        show this help
+
+Session commands (inside the agent):
+  /grant   today's token grant and usage
+  /usage   detailed usage from the manager (counters + devices)
+  /status  session status (identity, model, grant, collector)
+  /mcp     MCP server state (/mcp reconnect [server])
+  /verify  model attestation (arrives with the gateway lane)
+
+Environment:
+  OMNIRUSH_ORIGIN        manager origin override
+  OMNIRUSH_MODEL         default model override (e.g. gpt-5.6-sol)
+  OMNIRUSH_DIR           state dir override (default ~/.omnirush)
+  OMNIRUSH_DEBUG=1       verbose diagnostics (raw gateway errors on failure)
+
+Docs: https://omnirush.ai/omnirush — state is stored 0600 in ~/.omnirush`);
 }
 
 const [, , ...argv] = process.argv;
 const cmd = argv[0];
-if (cmd === "login") await cmdLogin(argv.slice(1));
+if (cmd === "-h" || cmd === "--help" || cmd === "help") printHelp();
+else if (cmd === "login") await cmdLogin(argv.slice(1));
 else if (cmd === "logout") await cmdLogout();
 else if (cmd === "whoami") await cmdWhoami();
 else if (cmd === "doctor") await cmdDoctor();
@@ -582,11 +794,10 @@ else {
   installModelsJson(agentGatewayUrl(auth));
   installExtensions();
   const entry = piEntry();
-  const { cmd: bin, args } = runtimeFor(entry);
+  const { cmd: bin, args } = await runtimeFor(entry);
   const piArgs = withModelDefaults(argv, resolveModelDefaults(process.env));
-  const child = spawn(bin, [...args, ...piArgs], {
+  spawnAgent(bin, [...args, ...piArgs], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth) },
   });
-  child.on("exit", (code) => process.exit(code ?? 0));
 }

package/src/lib.js

@@ -221,6 +221,19 @@ export function modelsConfig({ gatewayUrl } = {}) {
   };
 }
 
+/**
+ * Product default effort (Dan's call, 2026-09-24): xhigh, not pi's
+ * medium. The `thinkingLevelMap` on each model is unchanged — this only
+ * fills an ABSENT `defaultThinkingLevel` in the agent's settings.json,
+ * so an explicit user choice (saved via Ctrl+S in /thinking, or edited
+ * manually) always wins. Returns the settings object to persist; pure.
+ */
+export function withDefaultThinkingLevel(settings, level = "xhigh") {
+  const base = settings && typeof settings === "object" && !Array.isArray(settings) ? settings : {};
+  if (base.defaultThinkingLevel !== undefined) return base;
+  return { ...base, defaultThinkingLevel: level };
+}
+
 /**
  * Pure mapping of the bundled search-tool binaries for the launcher: pi
  * looks for managed `fd`/`rg` in <agentDir>/bin first and downloads from