openzoo 0.33.4 → 0.34.1

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

@@ -152,16 +152,53 @@ 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.
+    // Quit a running instance and WAIT until it is actually gone. A fixed 800ms
+    // wait raced the single-instance lock — Claude was still releasing its file
+    // locks (LOCK errors), so the fresh spawn saw a live instance and exited
+    // immediately ("didn't launch at all"). Poll pgrep until clear, up to ~6s.
     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));
+    for (let i = 0; i < 24; i++) {
+      const r = spawnSync('pgrep', ['-x', 'Claude'], { encoding: 'utf8' });
+      if (!r.stdout || !r.stdout.trim()) break;              // gone
+      if (i === 8) { try { spawnSync('pkill', ['-9', '-x', 'Claude'], { stdio: 'ignore' }); } catch { /* */ } }
+      await new Promise((res) => setTimeout(res, 250));
+    }
+    await new Promise((r) => setTimeout(r, 400));            // let the lock file release
   }
-  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.4",
+  "version": "0.34.1",
   "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",