omnirush 0.1.1 → 0.3.0

package/scripts/postinstall.js

@@ -1,12 +1,24 @@
-// Downloads the platform bun runtime (v1.4.2) on install so `omnirush`
-// works immediately on linux / macOS / Windows.
+// Postinstall runtime fetcher:
+//   1. bun (v1.4.2)   — required; the agent core runs on it.
+//   2. fd (v10.5.0)   — optional; the agent's file search + autocomplete.
+//   3. rg (v15.2.0)   — optional; the agent's content search.
+//
+// Binaries land in .runtime/bin/ (per-platform release packages ship the
+// same layout prebuilt). The launcher copies fd/rg into the agent's
+// managed-bin dir on every run, so the agent never attempts its own
+// GitHub download at startup (which fails on restricted networks and
+// repeats on every launch). fd/rg failures are warnings: search degrades
+// gracefully without them. A bun failure stays fatal.
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import https from "node:https";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-const VERSION = "bun-v1.4.2";
+const BUN_VERSION = "bun-v1.4.2";
+// fd release tags are v-prefixed; ripgrep tags are bare ("15.2.0").
+const FD_VERSION = "v10.5.0";
+const RG_VERSION = "15.2.0";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, "..");
 const RUNTIME = path.join(ROOT, ".runtime", "bin");
@@ -18,6 +30,10 @@ function platform() {
   return `${plat}-${arch}`;
 }
 
+function exe(name) {
+  return name + (process.platform === "win32" ? ".exe" : "");
+}
+
 function get(url, redirects = 0) {
   if (redirects > 5) throw new Error("too many redirects");
   return new Promise((resolve, reject) => {
@@ -57,22 +73,98 @@ function extractZip(buf, dest) {
   fs.rmSync(tmp, { force: true });
 }
 
-async function main() {
-  // Skip when bundled (GitHub release packages ship .runtime prebuilt).
-  const existing = path.join(RUNTIME, process.platform === "win32" ? "bun.exe" : "bun");
+function extractTarGz(buf, dest, stamp) {
+  const tmp = path.join(dest, stamp);
+  fs.writeFileSync(tmp, buf);
+  // tar handles .tar.gz on linux/macOS; Windows 10+ ships bsdtar in
+  // System32 (the agent core relies on the same thing).
+  try {
+    execFileSync("tar", ["xzf", tmp, "-C", dest]);
+  } catch {
+    execFileSync("python3", ["-m", "tarfile", "-e", tmp, "-C", dest]);
+  }
+  fs.rmSync(tmp, { force: true });
+}
+
+function findFile(rootDir, fileName) {
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isFile() && entry.name === fileName) return full;
+      if (entry.isDirectory()) stack.push(full);
+    }
+  }
+  return null;
+}
+
+async function fetchBun(plat) {
+  const existing = path.join(RUNTIME, exe("bun"));
   if (fs.existsSync(existing)) return;
-  const plat = platform();
-  const zipUrl = `https://github.com/oven-sh/bun/releases/download/${VERSION}/bun-${plat}.zip`;
+  const zipUrl = `https://github.com/oven-sh/bun/releases/download/${BUN_VERSION}/bun-${plat}.zip`;
   process.stdout.write(`omnirush: downloading agent runtime (bun for ${plat})...\n`);
   const buf = await get(zipUrl);
   fs.mkdirSync(RUNTIME, { recursive: true });
   extractZip(buf, ROOT);
-  const exe = process.platform === "win32" ? "bun.exe" : "bun";
-  const src = path.join(ROOT, `bun-${plat}`, exe);
+  const src = path.join(ROOT, `bun-${plat}`, exe("bun"));
   fs.copyFileSync(src, existing);
   if (process.platform !== "win32") fs.chmodSync(existing, 0o755);
   fs.rmSync(path.join(ROOT, `bun-${plat}`), { recursive: true, force: true });
   console.log("omnirush: runtime ready");
 }
 
+// fd/rg release archives both nest the binary under a versioned directory
+// (fd-v10.5.0-x86_64-unknown-linux-musl/fd, ripgrep-15.2.0-.../rg).
+async function fetchSearchTool(name, version, repo, archiveName, plat) {
+  const existing = path.join(RUNTIME, exe(name));
+  if (fs.existsSync(existing)) return;
+  const isZip = plat === "windows-x64";
+  const asset = isZip ? `${archiveName}.zip` : `${archiveName}.tar.gz`;
+  const url = `https://github.com/${repo}/releases/download/${version}/${asset}`;
+  process.stdout.write(`omnirush: downloading ${name} (${plat})...\n`);
+  const buf = await get(url);
+  fs.mkdirSync(RUNTIME, { recursive: true });
+  const extractDir = path.join(RUNTIME, `extract-${name}`);
+  fs.mkdirSync(extractDir, { recursive: true });
+  if (isZip) extractZip(buf, extractDir);
+  else extractTarGz(buf, extractDir, asset);
+  const found = findFile(extractDir, exe(name));
+  if (!found) throw new Error(`${exe(name)} not found in ${asset}`);
+  fs.copyFileSync(found, existing);
+  if (process.platform !== "win32") fs.chmodSync(existing, 0o755);
+  fs.rmSync(extractDir, { recursive: true, force: true });
+}
+
+function fdAsset(plat) {
+  const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
+  if (plat === "windows-x64") return `fd-${FD_VERSION}-${arch}-pc-windows-msvc`;
+  if (plat === "darwin-x64" || plat === "darwin-aarch64") return `fd-${FD_VERSION}-${arch}-apple-darwin`;
+  return `fd-${FD_VERSION}-${arch}-unknown-linux-musl`;
+}
+
+function rgAsset(plat) {
+  const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
+  if (plat === "windows-x64") return `ripgrep-${RG_VERSION}-${arch}-pc-windows-msvc`;
+  if (plat === "darwin-x64" || plat === "darwin-aarch64") return `ripgrep-${RG_VERSION}-${arch}-apple-darwin`;
+  return `ripgrep-${RG_VERSION}-${arch}-unknown-linux-musl`;
+}
+
+async function main() {
+  const plat = platform();
+  await fetchBun(plat);
+  for (const [name, version, repo, archive] of [
+    ["fd", FD_VERSION, "sharkdp/fd", fdAsset(plat)],
+    ["rg", RG_VERSION, "BurntSushi/ripgrep", rgAsset(plat)],
+  ]) {
+    try {
+      await fetchSearchTool(name, version, repo, archive, plat);
+    } catch (error) {
+      // Optional tools: warn and continue (the launcher only installs what
+      // exists; the agent degrades to PATH lookup / built-in search).
+      console.warn(`omnirush: ${name} download failed (search may be degraded):`, error.message);
+    }
+  }
+}
+
 main().catch((e) => { console.error("omnirush postinstall:", e.message); process.exit(1); });

package/src/bin.js

@@ -18,10 +18,12 @@
 //   OMNIRUSH_GATEWAY_URL  provider base URL override ({origin}/v1)
 //   OMNIRUSH_DIR          state dir override (default ~/.omnirush)
 //   OMNIRUSH_MODEL        model override for plain runs (default
-//                         gpt-6-astra; user --model still wins)
+//                         gpt-6-astra; gpt-5.6-sol also available; user
+//                         --model still wins)
 //
-// Agent runs default to `--provider omnirush --model gpt-6-astra` (SOTA
-// only — charter rule 1). The sota extension watches every response,
+// Agent runs default to `--provider omnirush --model gpt-6-astra`; the
+// catalog also carries gpt-5.6-sol (`--model gpt-5.6-sol` or
+// OMNIRUSH_MODEL=gpt-5.6-sol). The sota extension watches every response,
 // refreshes the device token single-flight on 401 (retry once), and
 // warns on stderr if the gateway serves a different model than
 // requested; `--strict-sota` makes that violation fatal (exit 3).
@@ -42,6 +44,7 @@ import {
   withModelDefaults,
   resolveModelDefaults,
 } from "./lib.js";
+import { installManagedTools } from "./tools.js";
 import {
   clearAuth,
   deviceAuthorize,
@@ -99,6 +102,11 @@ function ensureDirs() {
   fs.mkdirSync(OMNI_DIR, { recursive: true, mode: 0o700 });
   fs.mkdirSync(PI_AGENT_DIR, { recursive: true });
   fs.mkdirSync(PI_EXT_DIR, { recursive: true });
+  try {
+    installManagedTools({ agentDir: PI_AGENT_DIR, runtimeRoot: path.resolve(__dirname, "..", ".runtime") });
+  } catch {
+    /* best effort — pi falls back to PATH, then its own downloader */
+  }
 }
 
 // Merge our provider into the user's models.json without clobbering
@@ -353,10 +361,78 @@ async function cmdDoctor() {
     }
   }
 
+  // Update check: npm latest vs this install (cached, once/day).
+  try {
+    const own = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8")).version;
+    const cacheFile = path.join(OMNI_DIR, "update-check.json");
+    let latest = null;
+    let cache = {};
+    try { cache = JSON.parse(fs.readFileSync(cacheFile, "utf8")); } catch {}
+    if (cache.latest && Date.now() - cache.checked_at < 24 * 60 * 60 * 1000) {
+      latest = cache.latest;
+    } else {
+      const r = await fetchJson("https://registry.npmjs.org/omnirush/latest", { timeout: 5000 });
+      if (r.status === 200) {
+        latest = JSON.parse(r.body).version;
+        fs.writeFileSync(cacheFile, JSON.stringify({ latest, checked_at: Date.now() }));
+      }
+    }
+    if (latest && latest !== own) {
+      const cmp = (a, b) => {
+        const pa = a.split(".").map(Number), pb = b.split(".").map(Number);
+        for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+          const d = (pa[i] || 0) - (pb[i] || 0);
+          if (d) return d;
+        }
+        return 0;
+      };
+      if (cmp(latest, own) > 0) {
+        ok("update", true, `update available: ${latest} (installed ${own}) — run omnirush update`);
+      } else {
+        ok("update", true, `installed ${own} is newer than published ${latest} (pre-release)`);
+      }
+    } else if (latest) {
+      ok("update", true, `up to date (${own})`);
+    }
+  } catch {
+    /* update check is advisory only */
+  }
+
   installModelsJson(gateway);
   installExtensions();
-  ok("pi config", true, PI_MODELS_JSON);
+  try {
+    installManagedTools({ agentDir: PI_AGENT_DIR, runtimeRoot: path.resolve(__dirname, "..", ".runtime") });
+  } catch {
+    /* best effort */
+  }
+  ok("agent config", true, PI_MODELS_JSON);
   ok("extensions", true, PI_EXT_DIR);
+  // 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");
+  for (const tool of ["fd", "rg"]) {
+    const exe = process.platform === "win32" ? ".exe" : "";
+    const managed = path.join(toolsRoot, tool + exe);
+    const hasManaged = fs.existsSync(managed);
+    let viaPath = false;
+    if (!hasManaged) {
+      for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+        if (!dir) continue;
+        try {
+          fs.accessSync(path.join(dir, tool + exe), fs.constants.X_OK);
+          viaPath = true;
+          break;
+        } catch {
+          /* next */
+        }
+      }
+    }
+    ok(
+      `search tool ${tool}`,
+      hasManaged || viaPath,
+      hasManaged ? managed : viaPath ? "found on PATH" : "missing — find/autocomplete degraded",
+    );
+  }
   process.exit(healthy ? 0 : 1);
 }
 
@@ -385,9 +461,13 @@ function childEnv(auth) {
     OMNIRUSH_ORIGIN: origin,
     OMNIRUSH_GATEWAY_URL: gateway,
     OMNIRUSH_DIR: OMNI_DIR,
-    // pi resolves its config dir from this env var; keep the child pi on
-    // exactly the models.json/extensions bin.js just installed.
+    // The agent resolves its config dir from <APP>_CODING_AGENT_DIR. The
+    // branding patch renames the app to omnirush, so set the omnirush
+    // spelling; the pi spelling stays for unpatched cores.
+    OMNIRUSH_CODING_AGENT_DIR: PI_AGENT_DIR,
     PI_CODING_AGENT_DIR: PI_AGENT_DIR,
+    // The agent core is a fork/rebrand: never phone home to pi.dev.
+    PI_TELEMETRY: "0",
   };
 }
 
@@ -433,7 +513,7 @@ 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();
-else if (cmd === "--version" || cmd === "-v") console.log("omnirush 0.2.0 (pi core)");
+else if (cmd === "--version" || cmd === "-v") console.log("omnirush 0.3.0");
 else if (cmd === "collect") await cmdCollect(argv.slice(1));
 else if (cmd === undefined || cmd === "run") await cmdRun();
 else {

package/src/lib.js

@@ -67,7 +67,8 @@ const VALUE_FLAGS = new Set([
 
 /**
  * Model defaults for plain `omnirush` runs. OMNIRUSH_MODEL overrides the
- * default model (e.g. to pin a thinking level like "gpt-6-astra:high").
+ * default model — any catalog id below, optionally with a thinking level
+ * like "gpt-6-astra:high" or "gpt-5.6-sol:xhigh".
  */
 export function resolveModelDefaults(env = process.env) {
   return {
@@ -76,6 +77,35 @@ export function resolveModelDefaults(env = process.env) {
   };
 }
 
+// The product's shipped catalog: gpt-6-astra (default) and gpt-5.6-sol.
+// Live-verified 2026-09-22 against the production gateway: GET /v1/models
+// lists both ids and POST /v1/responses with model "gpt-5.6-sol" is served
+// as gpt-5.6-sol (x-omnirush-model response header + the model named in
+// every SSE frame), so the client may offer the switch honestly.
+export const MODELS = [
+  {
+    id: "gpt-6-astra",
+    name: "GPT-6 Astra",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { input: 10, output: 50, cacheRead: 2.5, cacheWrite: 12.5 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+  },
+  {
+    id: "gpt-5.6-sol",
+    name: "GPT-5.6 Sol",
+    reasoning: true,
+    input: ["text", "image"],
+    // Sol list pricing is not published; pi's cost display therefore shows
+    // zeros for it (documented default when cost is omitted).
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    // Same codex backend family as astra; same context window.
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+  },
+];
+
 /**
  * Prepend `--provider`/`--model` defaults for agent runs, without
  * duplicating flags the user already specified. Consumption rules mirror
@@ -145,12 +175,13 @@ export function withModelDefaults(args, defaults) {
 
 /**
  * The provider/models.json payload omnirush installs into pi. This is the
- * product's shipped model catalog: SOTA only (charter rule 1). The served
- * model is forced server-side by the gateway; the client SOTA guard stays
- * on as verification.
+ * product's shipped model catalog (MODELS above). The gateway allow-lists
+ * the same ids server-side; the client SOTA guard stays on as verification
+ * (it compares the model named in the response frames against the one
+ * requested).
  *
  * Hard-won compat fact: the codex backend rejects
- * `max_output_tokens`, so the model sets
+ * `max_output_tokens`, so every model sets
  * `compat.supportsMaxOutputTokens: false` and ships no maxTokens — pi would
  * otherwise clamp a default and break every request.
  */
@@ -162,18 +193,22 @@ export function modelsConfig({ gatewayUrl } = {}) {
         baseUrl: gatewayUrl ?? DEFAULT_GATEWAY_URL,
         api: "openai-responses",
         apiKey: "$OMNIRUSH_TOKEN",
-        models: [
-          {
-            id: DEFAULT_MODEL,
-            name: "GPT-6 Astra",
-            reasoning: true,
-            input: ["text", "image"],
-            cost: { input: 10, output: 50, cacheRead: 2.5, cacheWrite: 12.5 },
-            contextWindow: 400000,
-            compat: { supportsMaxOutputTokens: false },
-          },
-        ],
+        models: MODELS.map((model) => ({ ...model })),
       },
     },
   };
 }
+
+/**
+ * Pure mapping of the bundled search-tool binaries for the launcher: pi
+ * looks for managed `fd`/`rg` in <agentDir>/bin first and downloads from
+ * GitHub when absent. We ship both binaries and the launcher places them
+ * there, so the agent never attempts (or repeats) a download.
+ */
+export function managedToolTargets({ platform = process.platform, runtimeRoot } = {}) {
+  const ext = platform === "win32" ? ".exe" : "";
+  return [
+    { tool: "fd", source: `${runtimeRoot}/bin/fd${ext}`, dest: `bin/fd${ext}` },
+    { tool: "rg", source: `${runtimeRoot}/bin/rg${ext}`, dest: `bin/rg${ext}` },
+  ];
+}

package/src/tools.js

@@ -0,0 +1,40 @@
+// Managed search-tool install (fd, rg) for the agent core.
+//
+// pi checks <agentDir>/bin for managed fd/rg first and, when absent,
+// downloads them from GitHub at every agent startup — on restricted
+// networks that download fails and the attempt repeats on every launch,
+// breaking the find tool and file autocomplete. We bundle the binaries
+// (.runtime/bin, filled by postinstall or the release package) and the
+// launcher places them exactly where pi looks. Best effort: any failure
+// leaves the agent to its own PATH lookup / downloader.
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { managedToolTargets } from "./lib.js";
+
+export function installManagedTools({
+  agentDir,
+  runtimeRoot,
+  platform = process.platform,
+  fsImpl = fs,
+} = {}) {
+  const installed = [];
+  if (!agentDir || !runtimeRoot) return installed;
+  for (const target of managedToolTargets({ platform, runtimeRoot })) {
+    const dest = path.join(agentDir, target.dest);
+    if (fsImpl.existsSync(dest)) continue;
+    if (!fsImpl.existsSync(target.source)) continue;
+    fsImpl.mkdirSync(path.dirname(dest), { recursive: true });
+    fsImpl.copyFileSync(target.source, dest);
+    if (platform !== "win32") {
+      try {
+        fsImpl.chmodSync(dest, 0o755);
+      } catch {
+        /* best effort */
+      }
+    }
+    installed.push(target.tool);
+  }
+  return installed;
+}