omnirush 0.3.0 → 0.3.2

package/assets/extensions/omnirush/auth.js

@@ -400,20 +400,29 @@ export function createRefresher({ dir, origin, fetchImpl, now = () => Date.now()
   };
 }
 
-/** Best-effort browser open: xdg-open / open / cmd start. Never throws. */
+/** Best-effort browser open. NEVER throws or crashes: the spawned child's
+ * 'error' event is always handled (ENOENT on a headless Linux box would
+ * otherwise take the CLI down — Foxtran's login crash). Linux tries a
+ * chain of openers; if all fail the caller's printed URL still works. */
 export function openBrowser(url) {
-  try {
-    if (process.platform === "darwin") {
-      spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
-      return true;
-    }
-    if (process.platform === "win32") {
-      spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+  const spawnSafe = (cmd, args) => {
+    try {
+      const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+      child.on("error", () => undefined);
+      child.unref();
       return true;
+    } catch {
+      return false;
     }
-    spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
-    return true;
-  } catch {
-    return false;
+  };
+  if (process.platform === "darwin") {
+    return spawnSafe("open", [url]);
+  }
+  if (process.platform === "win32") {
+    return spawnSafe("cmd", ["/c", "start", "", url]);
+  }
+  for (const opener of ["xdg-open", "sensible-browser", "gnome-open", "kde-open", "wslview"]) {
+    if (spawnSafe(opener, [url])) return true;
   }
+  return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",

package/scripts/postinstall.js

@@ -12,6 +12,7 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import https from "node:https";
+import zlib from "node:zlib";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -23,13 +24,31 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, "..");
 const RUNTIME = path.join(ROOT, ".runtime", "bin");
 
+function isMusl() {
+  // Node built for musl (Alpine et al.) reports no glibc runtime version.
+  try {
+    if (process.report) {
+      const header = process.report.getReport().header;
+      if (header && header.glibcVersionRuntime) return false;
+    }
+  } catch { /* fall through to the filesystem probe */ }
+  return fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
+         fs.existsSync("/lib/ld-musl-aarch64.so.1");
+}
+
 function platform() {
   const plat = process.platform; // linux | darwin | win32
   const arch = process.arch === "arm64" ? "aarch64" : "x64";
   if (plat === "win32") return "windows-x64";
+  if (plat === "linux" && isMusl()) return `${plat}-${arch}-musl`;
   return `${plat}-${arch}`;
 }
 
+// bun's release assets say "aarch64", node's arch says "arm64".
+function bunAssetPlat(plat) {
+  return plat.replace("arm64", "aarch64");
+}
+
 function exe(name) {
   return name + (process.platform === "win32" ? ".exe" : "");
 }
@@ -55,22 +74,49 @@ function get(url, redirects = 0) {
 }
 
 function extractZip(buf, dest) {
-  // Zero-dependency zip extraction via the system unzip/tar when present,
-  // else fall back to PowerShell on Windows.
-  const tmp = path.join(dest, "omnirush-bun.zip");
-  fs.writeFileSync(tmp, buf);
-  const isWin = process.platform === "win32";
-  try {
-    if (isWin) {
-      execFileSync("powershell", ["-NoProfile", "-Command",
-        `Expand-Archive -Path '${tmp}' -DestinationPath '${dest}' -Force`]);
+  // Pure-JS minimal ZIP reader (stored + deflate entries): zero external
+  // tools, so install works on ANY distro — debian-slim ships neither
+  // unzip nor python, busybox is not universal either.
+  // Layout: find End Of Central Directory -> walk the central directory ->
+  // per entry, slice the local payload and inflateRawSync when deflated.
+  const eocdSig = 0x06054b50;
+  let eocd = -1;
+  for (let i = buf.length - 22; i >= Math.max(0, buf.length - 66000); i--) {
+    if (buf.readUInt32LE(i) === eocdSig) { eocd = i; break; }
+  }
+  if (eocd < 0) throw new Error("omnirush postinstall: bad zip (no EOCD)");
+  const count = buf.readUInt16LE(eocd + 10);
+  let ptr = buf.readUInt32LE(eocd + 16); // central directory offset
+  for (let n = 0; n < count; n++) {
+    if (buf.readUInt32LE(ptr) !== 0x02014b50) {
+      throw new Error("omnirush postinstall: bad zip (central directory)");
+    }
+    const method = buf.readUInt16LE(ptr + 10);
+    const compSize = buf.readUInt32LE(ptr + 20);
+    const nameLen = buf.readUInt16LE(ptr + 28);
+    const extraLen = buf.readUInt16LE(ptr + 30);
+    const commentLen = buf.readUInt16LE(ptr + 32);
+    const localOffset = buf.readUInt32LE(ptr + 42);
+    const name = buf.slice(ptr + 46, ptr + 46 + nameLen).toString("utf8");
+    // Local header: sizes may be zero (streaming bit) — derive the payload
+    // start from the local name/extra lengths, sizes come from central.
+    const localNameLen = buf.readUInt16LE(localOffset + 26);
+    const localExtraLen = buf.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLen + localExtraLen;
+    const payload = buf.slice(dataStart, dataStart + compSize);
+    const outPath = path.join(dest, name);
+    if (name.endsWith("/")) {
+      fs.mkdirSync(outPath, { recursive: true });
     } else {
-      execFileSync("python3", ["-m", "zipfile", "-e", tmp, dest]);
+      fs.mkdirSync(path.dirname(outPath), { recursive: true });
+      let data;
+      if (method === 0) data = payload;
+      else if (method === 8) data = zlib.inflateRawSync(payload);
+      else throw new Error(`omnirush postinstall: unsupported zip method ${method}`);
+      fs.writeFileSync(outPath, data);
     }
-  } catch {
-    execFileSync("unzip", ["-o", "-q", tmp, "-d", dest]);
+    ptr += 46 + nameLen + extraLen + commentLen;
   }
-  fs.rmSync(tmp, { force: true });
 }
 
 function extractTarGz(buf, dest, stamp) {
@@ -102,15 +148,15 @@ function findFile(rootDir, fileName) {
 async function fetchBun(plat) {
   const existing = path.join(RUNTIME, exe("bun"));
   if (fs.existsSync(existing)) return;
-  const zipUrl = `https://github.com/oven-sh/bun/releases/download/${BUN_VERSION}/bun-${plat}.zip`;
+  const zipUrl = `https://github.com/oven-sh/bun/releases/download/${BUN_VERSION}/bun-${bunAssetPlat(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 src = path.join(ROOT, `bun-${plat}`, exe("bun"));
+  const src = path.join(ROOT, `bun-${bunAssetPlat(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 });
+  fs.rmSync(path.join(ROOT, `bun-${bunAssetPlat(plat)}`), { recursive: true, force: true });
   console.log("omnirush: runtime ready");
 }
 

package/src/bin.js

@@ -141,10 +141,22 @@ function agentGatewayUrl(auth) {
   return resolveGatewayUrl(process.env, auth?.gatewayUrl);
 }
 
+function isMusl() {
+  // Node built for musl (Alpine et al.) reports no glibc runtime version.
+  try {
+    if (process.report) {
+      const header = process.report.getReport().header;
+      if (header && header.glibcVersionRuntime) return false;
+    }
+  } catch { /* fall through to the filesystem probe */ }
+  return fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
+         fs.existsSync("/lib/ld-musl-aarch64.so.1");
+}
+
 function findBun() {
-  // Vendored per-platform bun first (bundled for linux-x64, darwin-arm64,
-  // darwin-x64, windows-x64), then PATH, then the standard single-user
-  // install location.
+  // 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.
   const runtimeRoot = path.resolve(__dirname, "..", ".runtime");
   const plat = process.platform;
   const arch = process.arch === "arm64" ? "aarch64" : "x64";
@@ -157,8 +169,10 @@ function findBun() {
       if (dir) candidates.push(path.join(dir, "bun.exe"));
     }
   } else {
-    if (plat === "linux" && arch === "x64") {
-      candidates.push(path.join(runtimeRoot, "bin", "bun"));
+    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" : ""}`));
     }
     candidates.push(path.join(runtimeRoot, `bun-${plat}-${arch}`, "bin", "bun"));
     for (const dir of (process.env.PATH || "").split(path.delimiter)) {
@@ -513,7 +527,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.3.0");
+else if (cmd === "--version" || cmd === "-v") console.log("omnirush 0.3.2");
 else if (cmd === "collect") await cmdCollect(argv.slice(1));
 else if (cmd === undefined || cmd === "run") await cmdRun();
 else {