openzoo 0.49.10 → 0.49.12

package/lib/launch.js

@@ -68,15 +68,63 @@ export function claudeCodeBinDirs(home = os.homedir()) {
   ];
 }
 
-/** Resolve the Claude Code TERMINAL CLI. */
-export function resolveClaudeCli(env = process.env) {
+/**
+ * Is this file something execvp can actually RUN?
+ *
+ * The +x bit says "you are allowed to run this", not "this is runnable". A
+ * truncated download, a half-written install, or a plain text stub all carry
+ * the bit happily, and execvp then fails with ENOEXEC — which surfaced to a
+ * user as the bare string `openzoo: spawn ENOEXEC` with no path, no cause, and
+ * nothing to act on. A script is runnable when it starts with a shebang; a
+ * binary when it carries a known image magic. Anything else is a bad candidate
+ * and we should keep looking rather than hand it to spawn.
+ */
+export function isRunnableExecutable(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const buf = Buffer.alloc(4);
+    const n = fs.readSync(fd, buf, 0, 4, 0);
+    if (n < 2) return false;                              // empty/truncated
+    if (buf[0] === 0x23 && buf[1] === 0x21) return true;  // "#!"  script
+    if (buf[0] === 0x4d && buf[1] === 0x5a) return true;  // "MZ"  PE (win)
+    if (n < 4) return false;
+    const be = buf.readUInt32BE(0);
+    if (be === 0x7f454c46) return true;                   // ELF
+    // Mach-O thin (32/64, either endianness) and universal/fat.
+    if (be === 0xfeedface || be === 0xfeedfacf) return true;
+    if (be === 0xcefaedfe || be === 0xcffaedfe) return true;
+    if (be === 0xcafebabe || be === 0xbebafeca) return true;
+    return false;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) { try { fs.closeSync(fd); } catch { /* ignore */ } }
+  }
+}
+
+/**
+ * Resolve the Claude Code TERMINAL CLI.
+ *
+ * NOTE THE SEARCH ORDER: claudeCodeBinDirs() is tried BEFORE $PATH, because a
+ * Finder-launched process has no shell PATH. The cost is that a broken
+ * ~/.local/bin/claude — the exact file a half-finished install leaves behind —
+ * outranks a working one further down $PATH. So candidates are now format
+ * checked, and a rejected one does not stop the search; it is recorded so the
+ * caller can say WHICH file was wrong instead of printing an errno.
+ */
+export function resolveClaudeCli(env = process.env, rejected = []) {
   const name = 'claude' + (process.platform === 'win32' ? '.cmd' : '');
   const extras = env.OPENZOO_CLAUDE_PATH_ONLY === '1' ? [] : claudeCodeBinDirs();
   const pathDirs = String(env.PATH || '').split(path.delimiter).filter(Boolean);
   for (const dir of [...new Set([...extras, ...pathDirs])]) {
     if (!dir) continue;
     const f = path.join(dir, name);
-    try { fs.accessSync(f, fs.constants.X_OK); return f; } catch { /* next */ }
+    try { fs.accessSync(f, fs.constants.X_OK); } catch { continue; }
+    // A .cmd shim on Windows is dispatched by the shell, not execvp, so the
+    // magic-number test does not apply there.
+    if (process.platform === 'win32' || isRunnableExecutable(f)) return f;
+    rejected.push(f);
   }
   return null;
 }
@@ -231,8 +279,25 @@ export async function launchClaude(argv) {
   const env = claudeZooEnv(process.env, { base });
 
   if (terminal) {
-    const cli = resolveClaudeCli();
-    if (!cli) { console.error('openzoo: `claude` CLI not found on PATH — install Claude Code, or drop --terminal for the desktop app'); process.exit(1); }
+    const rejected = [];
+    let cli = resolveClaudeCli(process.env, rejected);
+    if (!cli && rejected.length) {
+      // THE FORMAT CHECK IS A TIE-BREAKER, NOT A VETO.
+      //
+      // isRunnableExecutable() knows four magics. Something legitimate that it
+      // has never seen — a packaging format we did not anticipate — would be
+      // refused here even though the OS would have run it happily, and we would
+      // have told the user to reinstall a CLI that was fine. When there is a
+      // real alternative the check earns its keep by preferring the good file;
+      // when this is the ONLY candidate, defer to the kernel and let the spawn
+      // below decide. A wrong heuristic must never be the sole reason we refuse.
+      cli = rejected[0];
+      console.error(`openzoo: ${cli} does not look like a runnable executable — trying it anyway.`);
+    }
+    if (!cli) {
+      console.error('openzoo: `claude` CLI not found on PATH — install Claude Code, or drop --terminal for the desktop app');
+      process.exit(1);
+    }
     // ALWAYS-ON HUD via Claude Code's NATIVE status line (the title bar is owned
     // by Claude Code and gets overwritten, so OSC there is useless). We write a
     // tiny status script that reads the proxy's /v1/info, and merge a statusLine
@@ -350,9 +415,40 @@ export async function launchClaude(argv) {
     console.error('     spend    : live in the status line below (bottom of screen); receipts in ~/.openzoo/proxy.log');
     console.error('     every turn pays x402.');
     console.error('');
-    const child = spawn(cli, rest, { stdio: 'inherit', env });
+    // spawn() THROWS SYNCHRONOUSLY on ENOEXEC — the 'error' listener below is
+    // never reached, which is why this reached a user as the unprefixed
+    // `openzoo: spawn ENOEXEC` from the top-level handler. Catch it here where
+    // `cli` is in scope and the message can name the file.
+    let child;
+    try {
+      child = spawn(cli, rest, { stdio: 'inherit', env });
+    } catch (e) {
+      try { restoreStatus?.(); } catch { /* ignore */ }
+      console.error(`openzoo: cannot execute ${cli} (${e?.code || e?.message})`);
+      console.error('         it is marked executable but the OS refused to run it.');
+      console.error(`         check:  file ${cli}`);
+      console.error(`                 head -c 2 ${cli} | xxd     # a healthy script starts 2321 ("#!")`);
+      console.error('         usually a truncated install, a wrong-architecture binary,');
+      console.error('         or a shebang pointing at an interpreter that no longer exists.');
+      console.error('         fix:    npm i -g @anthropic-ai/claude-code');
+      process.exit(1);
+    }
     child.on('exit', (c) => { try { restoreStatus?.(); } catch { /* ignore */ } process.exit(c ?? 0); });
-    child.on('error', (e) => { console.error(`openzoo: could not launch claude: ${e.message}`); process.exit(1); });
+    child.on('error', (e) => {
+      // ENOEXEC reaches here only if the format check passed and the kernel
+      // still refused it — a wrong-architecture binary, or a shebang pointing
+      // at an interpreter that is gone. Name the file either way; the bare
+      // errno is unactionable.
+      if (e?.code === 'ENOEXEC' || e?.code === 'EACCES') {
+        console.error(`openzoo: cannot execute ${cli} (${e.code})`);
+        console.error('         the file exists and is marked executable, but the OS refused to run it.');
+        console.error(`         check: head -1 ${cli}   and   file ${cli}`);
+        console.error('         a shebang pointing at a missing interpreter (e.g. a removed node) does this.');
+      } else {
+        console.error(`openzoo: could not launch claude (${cli}): ${e.message}`);
+      }
+      process.exit(1);
+    });
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.49.10",
+  "version": "0.49.12",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",