openzoo 0.33.3 → 0.34.0

package/lib/cursorbackend.js

@@ -272,6 +272,32 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
       const method = full.split('/').filter(Boolean).pop() || '';
       const ct = req.headers['content-type'] || '?';
       const body = await readBody(req);
+      // CLAUDE DESKTOP: api.anthropic.com speaks the JSON Messages API our proxy
+      // already handles. If this is an Anthropic host / messages call, forward it
+      // verbatim to the local paying proxy and relay the response — reusing the
+      // whole translate+x402 path. (SNI is checked because the Host header may be
+      // absent on h2.)
+      const host = String(req.headers[':authority'] || req.headers.host || req.socket?.servername || '');
+      if (/anthropic\.com$/.test(host) || /\/v1\/messages\b/.test(full)) {
+        try {
+          const up = await fetch(`http://127.0.0.1:8402${full}`, {
+            method: req.method,
+            headers: { 'content-type': req.headers['content-type'] || 'application/json' },
+            body: (req.method === 'GET' || req.method === 'HEAD') ? undefined : body,
+          });
+          const buf = Buffer.from(await up.arrayBuffer());
+          const h = { ...CORS };
+          up.headers.forEach((v, k) => { if (!['content-encoding', 'transfer-encoding', 'connection'].includes(k)) h[k] = v; });
+          res.writeHead(up.status, h);
+          res.end(buf);
+          log(`cursor-backend: #${conns} ${req.method} ${full}  ANTHROPIC -> proxy (${up.status}, ${buf.length}b)`);
+        } catch (e) {
+          res.writeHead(502, { 'content-type': 'application/json', ...CORS });
+          res.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: `openzoo forward failed: ${e.message}` } }));
+          log(`cursor-backend: anthropic forward failed: ${e.message}`);
+        }
+        return;
+      }
       log(`cursor-backend: #${conns} ${req.method} ${full}  ct=${ct}  body=${body.length}b`);
       // CAPTURE the chat inference request so its schema can be decoded from
       // REAL bytes (Auto's StreamUnifiedChat). Written once; inspect then build.

package/lib/hosts.js

@@ -47,6 +47,10 @@ const MARK = '# openzoo: force the editor onto the local proxy';
  */
 export const BACKEND_HOSTS = ['api2.cursor.sh'];
 
+// Claude DESKTOP inference host — impersonated + forwarded to the local proxy
+// (Messages API is JSON; the proxy already translates + pays x402).
+export const CLAUDE_HOSTS = ['api.anthropic.com', 'api-staging.anthropic.com'];
+
 export const AGENT_HOSTS = [
   'agent.api5.cursor.sh', 'agentn.api5.cursor.sh',
   'agent-gcpp-uswest.api5.cursor.sh', 'agentn-gcpp-uswest.api5.cursor.sh',

package/lib/launch.js

@@ -93,12 +93,16 @@ export async function launchClaude(argv) {
     try {
       const scriptPath = path.join(os.homedir(), '.openzoo', 'statusline.sh');
       fs.mkdirSync(path.dirname(scriptPath), { recursive: true });
+      // node JSON.parse, not awk — /v1/info is pretty-printed (space after the
+      // colon) and a fixed-offset awk regex silently read 0. This is robust.
       fs.writeFileSync(scriptPath,
         '#!/bin/sh\n'
         + `curl -s --max-time 1 ${base}/info 2>/dev/null | `
-        + 'awk \'{ if (match($0,/"spendUsd":[0-9.eE-]+/)) { s=substr($0,RSTART+11,RLENGTH-11) } '
-        + 'if (match($0,/"paidCalls":[0-9]+/)) { c=substr($0,RSTART+12,RLENGTH-12) } } '
-        + 'END { printf "\\033[38;5;208m●\\033[0m openzoo  $%.4f  %s call%s  · x402", s+0, c+0, (c==1?"":"s") }\'\n');
+        + `${JSON.stringify(process.execPath)} -e `
+        + '\'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{'
+        + 'try{const j=JSON.parse(s);'
+        + 'process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  $"+(Number(j.spendUsd)||0).toFixed(4)+"  "+(j.paidCalls||0)+" call"+((j.paidCalls||0)===1?"":"s")+"  \\u00b7 x402")}'
+        + 'catch{process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  \\u00b7 x402")}})\'\n');
       fs.chmodSync(scriptPath, 0o755);
       const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
       let settings = {};
@@ -148,16 +152,46 @@ export async function launchClaude(argv) {
   // variable, which `open` never could.
   const app = resolveClaudeDesktop();
   if (!app) { console.error('openzoo: Claude desktop app not found — install it, or use `npx openzoo claude --terminal`'); process.exit(1); }
+
+  // ROUTE THE DESKTOP APP BY IMPERSONATING api.anthropic.com.
+  //
+  // The desktop app is OAuth/subscription-bound and ignores ANTHROPIC_BASE_URL,
+  // so env cannot point it at us. Instead we ARE api.anthropic.com: block it in
+  // /etc/hosts, bind our backend on 443 (it forwards /v1/messages to the local
+  // proxy, which translates + pays x402), and launch the app with the Chromium
+  // flags that (a) accept our self-signed cert and (b) override DNS past DoH.
+  // Opt out with --no-intercept (then it just opens, on the subscription).
+  if (process.platform !== 'win32' && !argv.includes('--no-intercept')) {
+    try {
+      const { blockBackend, bindBackend443, CLAUDE_HOSTS } = await import('./hosts.js');
+      const { ensureCert } = await import('./cursorbackend.js');
+      ensureCert(console.error);
+      const r = blockBackend(CLAUDE_HOSTS);
+      console.error(r.already ? 'openzoo: api.anthropic.com already routed to us'
+        : `openzoo: routing ${CLAUDE_HOSTS.join(', ')} -> 127.0.0.1 (sudo)`);
+      const modelsFile = path.join(os.tmpdir(), 'openzoo-claude-models.json');
+      fs.writeFileSync(modelsFile, '[]');
+      const backendLog = path.join(os.homedir(), '.openzoo', 'cursor-backend.log');
+      bindBackend443(modelsFile, backendLog, console.error);
+      await new Promise((res) => setTimeout(res, 800));
+      console.error('openzoo: backend bound on :443 — Claude desktop inference now forwards to the zoo.');
+      console.error('         undo any time with: npx openzoo unblock');
+    } catch (e) { console.error(`openzoo: desktop interception setup failed (${e.message}) — opening app plain`); }
+  }
+
   if (process.platform === 'darwin') {
     // Quit a running instance so the fresh one is not killed by the single-
-    // instance lock. `osascript quit` is graceful; pkill is the backstop.
+    // instance lock, and so it re-resolves api.anthropic.com to us on launch.
     try { spawnSync('osascript', ['-e', 'tell application "Claude" to quit'], { stdio: 'ignore', timeout: 4000 }); } catch { /* not running */ }
     try { spawnSync('pkill', ['-x', 'Claude'], { stdio: 'ignore' }); } catch { /* already gone */ }
     await new Promise((r) => setTimeout(r, 800));
   }
-  console.error(`openzoo: Claude desktop with ANTHROPIC_BASE_URL=${base} (quit any running instance first).`);
-  console.error('         if the desktop app ignores that variable, use --terminal for guaranteed x402.');
-  const child = spawn(app, rest, { stdio: 'ignore', env, detached: true });
+  // Chromium flags: accept the self-signed cert, and MAP the Anthropic hosts to
+  // us at the resolver level (defeats DoH, which ignores /etc/hosts).
+  const flags = argv.includes('--no-intercept') ? []
+    : ['--ignore-certificate-errors', '--host-resolver-rules=MAP api.anthropic.com 127.0.0.1,MAP api-staging.anthropic.com 127.0.0.1'];
+  console.error('openzoo: launching Claude desktop — inference routes through the zoo (pays x402).');
+  const child = spawn(app, [...flags, ...rest], { stdio: 'ignore', env, detached: true });
   child.on('error', (e) => console.error(`openzoo: could not launch Claude desktop: ${e.message}`));
   child.unref();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.33.3",
+  "version": "0.34.0",
   "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",