openzoo 0.34.10 → 0.34.11

package/lib/cursorbackend.js

@@ -27,6 +27,7 @@
  * + trailers for grpc-web. Both are handled below.
  */
 import http2 from 'node:http2';
+import https from 'node:https';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -236,17 +237,36 @@ const HOP_BY_HOP = new Set([
  * over UDP (which ignores /etc/hosts entirely), cache it, and dial the address
  * with the Host/SNI still set to the real hostname so TLS and routing succeed.
  */
-let realIpCache = null;
+// KEYED BY HOST. A single shared slot meant whichever of api/api-staging
+// resolved first pinned its address for the other one too.
+const realIpCache = new Map();
 async function resolveRealAnthropic(host) {
-  if (realIpCache) return realIpCache;
+  const hit = realIpCache.get(host);
+  if (hit) return hit;
   const { Resolver } = await import('node:dns/promises');
   const r = new Resolver();
   r.setServers(['1.1.1.1', '8.8.8.8']);
   const [ip] = await r.resolve4(host);
-  realIpCache = ip;
+  realIpCache.set(host, ip);
   return ip;
 }
 
+/**
+ * Headers we must NOT copy back from the upstream response.
+ *
+ * DELIBERATELY NARROWER THAN HOP_BY_HOP: `content-encoding` is absent here on
+ * purpose. Unlike fetch(), node:https hands us the body EXACTLY as it arrived —
+ * still gzip/brotli compressed. Stripping the encoding header while forwarding
+ * compressed bytes tells the app "this is plain JSON" over binary garbage, and
+ * it fails to parse the bootstrap payload. Forward body and label together.
+ * `content-length` still goes, because we set it from the buffer we actually
+ * have, and the h2 layer rejects the connection-specific ones outright.
+ */
+const RESP_DROP = new Set([
+  'connection', 'keep-alive', 'upgrade', 'proxy-connection',
+  'transfer-encoding', 'te', 'trailer', 'content-length',
+]);
+
 async function passthroughToRealAnthropic(req, res, body, host, full, log) {
   try {
     const ip = await resolveRealAnthropic(host);
@@ -256,18 +276,42 @@ async function passthroughToRealAnthropic(req, res, body, host, full, log) {
       headers[k] = Array.isArray(v) ? v.join(', ') : String(v);
     }
     headers.host = host;
-    const up = await fetch(`https://${ip}${full}`, {
-      method: req.method,
-      headers,
-      body: (req.method === 'GET' || req.method === 'HEAD') ? undefined : body,
-      redirect: 'manual',
+
+    // DIAL THE ADDRESS, BUT SPEAK THE NAME. fetch(`https://${ip}/...`) cannot do
+    // this: undici derives SNI from the URL, so the server saw a bare IP, had no
+    // certificate to offer for it, and killed the handshake
+    // (ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE). node:https lets the two be set
+    // independently — a custom `lookup` pins the connection to the public-DNS
+    // address (bypassing our own /etc/hosts entry, which would otherwise loop
+    // this request straight back into this very server), while `servername` and
+    // the Host header keep presenting the real hostname so the cert validates.
+    const lookup = (h, o, cb) => (o && o.all ? cb(null, [{ address: ip, family: 4 }]) : cb(null, ip, 4));
+    const { status, respHeaders, buf } = await new Promise((resolve, reject) => {
+      const up = https.request({
+        hostname: host, servername: host, port: 443, path: full,
+        method: req.method, headers, lookup,
+      }, (r) => {
+        const chunks = [];
+        r.on('data', (d) => chunks.push(d));
+        r.on('end', () => resolve({
+          status: r.statusCode, respHeaders: r.headers, buf: Buffer.concat(chunks),
+        }));
+        r.on('error', reject);
+      });
+      up.on('error', reject);
+      up.setTimeout(20000, () => up.destroy(new Error('upstream timeout')));
+      if (req.method !== 'GET' && req.method !== 'HEAD' && body && body.length) up.write(body);
+      up.end();
     });
-    const buf = Buffer.from(await up.arrayBuffer());
+
     const h = {};
-    up.headers.forEach((v, k) => { if (!HOP_BY_HOP.has(k.toLowerCase())) h[k] = v; });
-    res.writeHead(up.status, h);
+    for (const [k, v] of Object.entries(respHeaders)) {
+      if (RESP_DROP.has(k.toLowerCase())) continue;
+      h[k] = v;
+    }
+    res.writeHead(status, h);
     res.end(buf);
-    log(`cursor-backend:      ${req.method} ${full} -> REAL anthropic (${up.status}, ${buf.length}b)`);
+    log(`cursor-backend:      ${req.method} ${full} -> REAL anthropic (${status}, ${buf.length}b)`);
   } catch (e) {
     res.writeHead(502, { 'content-type': 'application/json' });
     res.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: `passthrough failed: ${e.message}` } }));
@@ -360,8 +404,15 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
       // 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 || '');
-      const isAnthropic = /anthropic\.com$/.test(host);
+      // STRIP THE PORT BEFORE MATCHING. :authority / Host carry `host:port`
+      // whenever the client dials a non-default port, so an anchored
+      // /anthropic\.com$/ silently failed to match and the request fell through
+      // to the gRPC branch, which answered empty-OK. The desktop app then saw a
+      // 200 with no body for its session bootstrap — indistinguishable from the
+      // 404 it used to get, and it wedged the same way.
+      const rawHost = String(req.headers[':authority'] || req.headers.host || req.socket?.servername || '');
+      const host = rawHost.replace(/:\d+$/, '');
+      const isAnthropic = /(^|\.)anthropic\.com$/.test(host);
       // INTERCEPT INFERENCE ONLY. Matching the whole HOST sent every request the
       // desktop app makes to the local proxy — including the session bootstrap
       // (/api/organizations, /api/bootstrap, /api/account), which the proxy does

package/package.json

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