openzoo 0.48.22 → 0.48.23

package/bin/openzoo.js

@@ -1,4 +1,58 @@
 #!/usr/bin/env node
+// NODE >=18 OR NOTHING — AND HEAL IT IF WE CAN.
+//
+// package.json says engines >=18 but npm only WARNS, so an old node walked
+// straight in and died somewhere useless: there is no global `fetch` before 18,
+// so the very first probe threw, a bare `catch` swallowed it, and the user was
+// left staring at "starting the proxy in the background..." forever with no
+// error to report. Reported from the wild on macOS.
+//
+// Detect-and-exit is not enough when the machine usually HAS a good node sitting
+// in nvm/homebrew and merely isn't using it. Find one and re-exec through it;
+// only give up (with the exact fix) when there is genuinely nothing to run on.
+// NOTE: plain 'fs'/'path' specifiers, not 'node:fs'. The node: prefix only
+// resolves from 14.13.1, and this block's whole job is to run on the old
+// runtime we are rejecting — an import error here would defeat the message.
+import { existsSync, readdirSync } from 'fs';
+import { execFileSync, spawnSync } from 'child_process';
+import { homedir } from 'os';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+const MIN_NODE = 18;
+if (Number(process.versions.node.split('.')[0]) < MIN_NODE && !process.env.OPENZOO_NODE_REEXEC) {
+  const candidates = ['/opt/homebrew/bin/node', '/usr/local/bin/node', '/usr/bin/node'].filter(existsSync);
+  // nvm keeps every install under ~/.nvm/versions/node/vNN.../bin/node —
+  // newest first, so we land on the best available rather than the oldest.
+  try {
+    const nvm = join(process.env.NVM_DIR || join(homedir(), '.nvm'), 'versions', 'node');
+    for (const v of readdirSync(nvm)
+      .filter((d) => /^v\d+/.test(d))
+      .sort((a, b) => parseInt(b.slice(1), 10) - parseInt(a.slice(1), 10))) {
+      const p = join(nvm, v, 'bin', 'node');
+      if (existsSync(p)) candidates.push(p);
+    }
+  } catch { /* no nvm, fine */ }
+
+  for (const node of candidates) {
+    let v = 0;
+    try { v = Number(execFileSync(node, ['-v'], { encoding: 'utf8' }).trim().slice(1).split('.')[0]); } catch { continue; }
+    if (v < MIN_NODE) continue;
+    console.error(`openzoo: node ${process.versions.node} is too old (need >=${MIN_NODE}) — re-running under ${node} (v${v})`);
+    const r = spawnSync(node, [fileURLToPath(import.meta.url), ...process.argv.slice(2)], {
+      stdio: 'inherit',
+      env: { ...process.env, OPENZOO_NODE_REEXEC: '1' },
+    });
+    process.exit(r.status === null ? 1 : r.status);
+  }
+
+  console.error(`openzoo: needs Node >=${MIN_NODE}, you are on ${process.versions.node}.`);
+  console.error('  no newer node found on this machine. install one, then re-run:');
+  console.error('    brew install node            # macOS');
+  console.error('    nvm install 20 && nvm use 20 # if you use nvm');
+  process.exit(1);
+}
+
 const cmd = process.argv[2] || 'proxy';
 
 const HELP = `openzoo — local x402-paying proxy + MCP server for openzoo.fun

package/lib/launch.js

@@ -49,21 +49,54 @@ function resolveClaudeCli() {
  * Both get ANTHROPIC_BASE_URL so inference pays x402.
  */
 export async function launchClaude(argv) {
-  const base = `http://localhost:${config.port}/v1`;
+  // let, not const: startProxy can heal onto a different port and every URL
+  // below must follow the port we actually bound.
+  let base = `http://localhost:${config.port}/v1`;
   // AUTO-START THE PROXY. One command should just work — if nothing is listening,
   // boot the proxy in THIS process (it stays alive because claude runs in the
   // foreground below), rather than making the user run `npx openzoo` first.
   let up = false;
   try { up = (await fetch(`${base}/models`, { signal: AbortSignal.timeout(3000) })).ok; } catch { up = false; }
   if (!up) {
-    console.error('openzoo: starting the proxy in the background...');
-    const { startProxy } = await import('./proxy.js');
-    await startProxy({ silent: true, autoTunnel: true });
+    // NEVER GO SILENT DURING STARTUP. silent:true routes the proxy's own lines
+    // to ~/.openzoo/proxy.log so payment receipts cannot corrupt Claude Code's
+    // stdio — correct DURING the session, wrong BEFORE it, because it made a
+    // slow step and a dead step look identical. Reported from the wild as
+    // "always gets stuck at 'starting the proxy in the background...'": there
+    // was nothing on screen for up to 46s and then, at worst, one terse line.
+    // A ticking elapsed counter is the difference between "hung" and "working".
+    process.stderr.write('openzoo: starting the proxy...');
+    const t0 = Date.now();
+    const tick = setInterval(() => {
+      process.stderr.write(`\ropenzoo: starting the proxy... ${((Date.now() - t0) / 1000).toFixed(0)}s`);
+    }, 1000);
+    tick.unref?.();
+    const done = (msg) => { clearInterval(tick); process.stderr.write(`\r\x1b[2Kopenzoo: ${msg}\n`); };
+    try {
+      const { startProxy } = await import('./proxy.js');
+      await startProxy({ silent: true, autoTunnel: true });
+    } catch (err) {
+      // An exception here used to surface as an eternal spinner. Say what broke.
+      done(`proxy failed to start: ${err?.message || err}`);
+      console.error('  full log: ~/.openzoo/proxy.log');
+      console.error('  try: OPENZOO_NO_TUNNEL=1 npx openzoo claude   (skips the cloudflared download)');
+      process.exit(1);
+    }
+    // The proxy may have healed onto a different port (8402 busy). config.port
+    // is the one it ACTUALLY bound, so re-derive every URL from it — the old
+    // code kept polling the port it wished for and timed out on a live proxy.
+    base = `http://localhost:${config.port}/v1`;
     for (let i = 0; i < 20 && !up; i++) {
       await new Promise((r) => setTimeout(r, 300));
       try { up = (await fetch(`${base}/models`, { signal: AbortSignal.timeout(2000) })).ok; } catch { /* keep waiting */ }
     }
-    if (!up) { console.error(`openzoo: proxy did not come up on ${base}`); process.exit(1); }
+    if (!up) {
+      done(`proxy did not answer on ${base}`);
+      console.error('  full log: ~/.openzoo/proxy.log');
+      console.error('  try: OPENZOO_NO_TUNNEL=1 npx openzoo claude   (skips the cloudflared download)');
+      process.exit(1);
+    }
+    done(`proxy up on :${config.port} (${((Date.now() - t0) / 1000).toFixed(1)}s)`);
   }
   // TERMINAL (Claude Code CLI) IS THE DEFAULT — it is the guaranteed-x402 path
   // and honours ANTHROPIC_BASE_URL. --desktop explicitly opens the desktop app

package/lib/proxy.js

@@ -16,6 +16,7 @@ import { forgetContext } from './contexts.js';
 import { injectBrief } from './brief.js';
 import { withNamespace } from './namespace.js';
 import { anthropicToOpenAI, openAIToAnthropic, writeAnthropicSse } from './anthropic.js';
+import { responsesToChat, chatToResponses, writeResponsesSse } from './responses.js';
 
 const HOP_BY_HOP = new Set([
   'host', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade',
@@ -41,7 +42,7 @@ const HOP_BY_HOP = new Set([
 function normalizePath(url) {
   const [path, query] = (url || '/').split(/(?=\?)/);
   let p = path.replace(/^(?:\/v1)+(?=\/v1\/)/, '');       // /v1/v1/x -> /v1/x
-  if (!/^\/v1(\/|$)/.test(p) && /^\/(hrr|chat|models|completions|embeddings|usage)/.test(p)) p = `/v1${p}`;
+  if (!/^\/v1(\/|$)/.test(p) && /^\/(hrr|chat|models|completions|embeddings|usage|responses)/.test(p)) p = `/v1${p}`;
   return p === path ? url : `${p}${query || ''}`;
 }
 
@@ -547,7 +548,51 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // answer back on the way out. See lib/anthropic.js.
     let anthropicMode = false;
     let anthropicModel = null;
+    let responsesMode = false;
+    let responsesModel = null;
+    let responsesCustom = null;   // names of freeform tools needing custom_tool_call on the way back
     const rawPath = (req.url || '').split('?')[0];
+
+    // RESPONSES API. Some harnesses speak only this wire format — OpenAI's
+    // Codex Security CLI pins `wire_api: "responses"` in its provider table, so
+    // a bare 404 here made it fall back to wss://api.openai.com and bypass the
+    // proxy entirely while reporting the failure as an auth error. Translate
+    // in, translate out; everything between stays on the chat path.
+    if (req.method === 'POST' && (rawPath === '/v1/responses' || rawPath === '/responses')) {
+      try {
+        const inbound = JSON.parse(bodyBuf.toString('utf8'));
+        // TEMP CAPTURE: dump the first few Responses requests so the agent's
+        // actual wire usage (store / previous_response_id / tool shapes) can be
+        // read rather than inferred. Guarded by an env var so it is off unless
+        // asked for.
+        if (process.env.OZ_CAPTURE_RESPONSES) {
+          try {
+            const fs = await import('node:fs');
+            const dir = process.env.OZ_CAPTURE_RESPONSES;
+            fs.mkdirSync(dir, { recursive: true });
+            const n = fs.readdirSync(dir).length;
+            // Capture the LATER turns too. Turn 1 is already understood; the
+            // unknown is what codex sends back after running a tool, so bias
+            // the capture toward requests that carry a tool result.
+            const hasResult = Array.isArray(inbound.input)
+              && inbound.input.some((i) => i && String(i.type || '').endsWith('_call_output'));
+            const tag = hasResult ? 'result' : 'plain';
+            if (n < 24) fs.writeFileSync(`${dir}/${tag}-${n}.json`, JSON.stringify(inbound, null, 2));
+          } catch { /* capture must never break a paid call */ }
+        }
+        responsesModel = inbound.model;
+        const meta = {};
+        bodyBuf = Buffer.from(JSON.stringify(responsesToChat(inbound, meta)));
+        responsesCustom = meta.custom;
+        responsesMode = true;
+        req.url = '/v1/chat/completions';
+        url = `${config.apiBase}${req.url}`;
+      } catch {
+        jsonErr(res, 400, 'invalid responses body');
+        return;
+      }
+    }
+
     if (req.method === 'POST' && (rawPath === '/v1/messages' || rawPath === '/messages')) {
       try {
         const inbound = JSON.parse(bodyBuf.toString('utf8'));
@@ -604,6 +649,18 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       const hit = replayGet(rKey);
       if (hit) {
         log('identical request within 30s — served the cached completion, NOT re-paid');
+        // The cache stores the CHAT shape. A Responses caller must get its own
+        // wire format back, or the replay path silently answers in a format the
+        // client cannot parse — a bug that only appears on the SECOND identical
+        // request, which is exactly when nobody is watching.
+        if (responsesMode) {
+          if (wantsStream) { writeResponsesSse(res, hit.data, responsesModel, null, responsesCustom); return; }
+          const rh = { 'content-type': 'application/json' };
+          if (hit.settle) rh['x-payment-response'] = hit.settle;
+          res.writeHead(200, rh);
+          res.end(JSON.stringify(chatToResponses(hit.data, responsesModel, responsesCustom)));
+          return;
+        }
         if (wantsStream) { serveAsSse(res, hit.data, null); return; }
         const h = { 'content-type': 'application/json' };
         if (hit.settle) h['x-payment-response'] = hit.settle;
@@ -752,6 +809,20 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             res.end(JSON.stringify(msg));
             return;
           }
+          if (responsesMode) {
+            // A Responses client that asked to stream is WAITING for
+            // `response.completed`; handing it a JSON body closes the socket
+            // mid-stream and it reports "stream disconnected before
+            // completion". Honour the streaming contract when it asked for it.
+            if (wantsStream) { writeResponsesSse(res, data, responsesModel, response, responsesCustom); return; }
+            const out = chatToResponses(data, responsesModel, responsesCustom);
+            const h = { 'content-type': 'application/json' };
+            const settleHdr = response.headers.get('x-payment-response');
+            if (settleHdr) h['x-payment-response'] = settleHdr;
+            res.writeHead(200, h);
+            res.end(JSON.stringify(out));
+            return;
+          }
           if (wantsStream) { serveAsSse(res, data, response); return; }
           const h = { 'content-type': 'application/json' };
           const settleHdr = response.headers.get('x-payment-response');
@@ -790,10 +861,40 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // AND a tunnel token, so the RunPod-fronted port stays gated exactly like the
   // public tunnel path.
   const bindHost = process.env.OPENZOO_BIND || '127.0.0.1';
-  await new Promise((resolve, reject) => {
-    server.on('error', reject);
-    server.listen(config.port, bindHost, resolve);
-  });
+  // SELF-HEAL A TAKEN PORT. A killed-but-not-reaped run, a second terminal, or
+  // anything else already on 8402 made listen() reject and took the whole start
+  // down — and because `openzoo claude` starts us with silent:true, the user saw
+  // only "starting the proxy in the background..." and no reason. Walk up to the
+  // next free port instead of dying; the caller reads config.port back out, so
+  // every URL printed afterwards is the one we actually bound.
+  //
+  // EXCEPTION: if the thing already on the port is a HEALTHY openzoo proxy,
+  // reuse it rather than starting a rival that splits spend across two wallets.
+  const wanted = config.port;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const onErr = (e) => { server.removeListener('error', onErr); reject(e); };
+        server.on('error', onErr);
+        server.listen(config.port, bindHost, () => { server.removeListener('error', onErr); resolve(); });
+      });
+      break;
+    } catch (e) {
+      if (e?.code !== 'EADDRINUSE' || attempt >= 12) throw e;
+      if (attempt === 0) {
+        try {
+          const probe = await fetch(`http://127.0.0.1:${config.port}/v1/models`, { signal: AbortSignal.timeout(2500) });
+          if (probe.ok) {
+            say(`openzoo: a healthy proxy is already on :${config.port} — reusing it`);
+            return { server: null, client, reused: true, port: config.port, spent: () => 0, publicUrl: null, tunnelToken: null, tunnelError: null };
+          }
+        } catch { /* not ours, or wedged — take the next port */ }
+      }
+      config.port += 1;
+      say(`openzoo: :${config.port - 1} busy — trying :${config.port}`);
+    }
+  }
+  if (config.port !== wanted) say(`openzoo: listening on :${config.port} (:${wanted} was busy)`);
 
   // AUTO-PREPAY. Paying on-chain per call is where the latency lives: the
   // gateway answers its 402 challenge in ~0.12s while a full settled call