openzoo 0.34.4 → 0.34.6

package/bin/cursor-backend.js

@@ -19,15 +19,31 @@ const port = Number(process.argv[2] || 443);
 const modelsPath = process.argv[3];
 const logPath = process.argv[4];
 
-const log = (s) => {
-  const line = `${s}\n`;
-  try { if (logPath) fs.appendFileSync(logPath, line); } catch { /* ignore */ }
-  process.stdout.write(line);
-};
+// WRITE EACH LINE ONCE. The launcher now redirects this process's stdout+stderr
+// with `>>` to the SAME logPath (so a startup crash leaves evidence), so doing
+// both an explicit appendFileSync AND a stdout write duplicated every single
+// line in the file. stdout alone is the right channel: it reaches the log via
+// the redirect, and it still shows up when the backend is run by hand on a
+// terminal for debugging.
+const log = (s) => { process.stdout.write(`${s}\n`); };
 
 let models = [];
 try { models = JSON.parse(fs.readFileSync(modelsPath, 'utf8')); }
 catch (e) { log(`cursor-backend: could not read models (${e.message})`); process.exit(1); }
 
+// NEVER LET ONE BAD REQUEST KILL THE SERVER. The h2 header bug threw out of an
+// async handler, which is an unhandled rejection / uncaught throw at process
+// level — node tore the whole backend down mid-request, so :443 went dead and
+// every later attempt logged ECONNRESET with no listener behind it. This is a
+// static impersonation server; staying up while logging the fault is always
+// better than exiting and blackholing the host the app depends on.
+process.on('uncaughtException', (e) => {
+  log(`cursor-backend: UNCAUGHT ${e && e.code ? e.code + ' ' : ''}${e && e.message}`);
+  if (e && e.stack) log(String(e.stack).split('\n').slice(1, 4).join('\n'));
+});
+process.on('unhandledRejection', (e) => {
+  log(`cursor-backend: UNHANDLED REJECTION ${e && e.message ? e.message : e}`);
+});
+
 startCursorBackend({ port, models, log });
 log(`cursor-backend: standalone up on :${port} (${models.length} models)`);

package/lib/cursorbackend.js

@@ -35,21 +35,39 @@ import { encodeAvailableModels, encodeForMethod } from './cursorapi.js';
 
 const TLS_DIR = path.join(os.homedir(), '.openzoo', 'cursor-tls');
 const CURSOR_HOSTS = ['api2.cursor.sh', 'api3.cursor.sh', 'api4.cursor.sh', 'repo42.cursor.sh'];
+// THE CERT MUST COVER ANTHROPIC TOO. This server impersonates api.anthropic.com
+// for `claude --desktop`, but the SAN only ever listed the cursor hosts, so the
+// client got a cert valid for a name it never asked for and killed the
+// handshake before ALPN — logged as `HANDSHAKE FAILED ECONNRESET alpn=?`, with
+// no request ever reaching us. Same cert, one more pair of names.
+const ANTHROPIC_TLS_HOSTS = ['api.anthropic.com', 'api-staging.anthropic.com'];
+const TLS_HOSTS = [...CURSOR_HOSTS, ...ANTHROPIC_TLS_HOSTS];
 
-/** Generate (once) a self-signed cert covering the cursor backends. openssl is
- *  on every mac/linux; this is the only external tool and it is not a trust op. */
+/** Generate (once) a self-signed cert covering every host we impersonate. openssl
+ *  is on every mac/linux; this is the only external tool and it is not a trust op. */
 export function ensureCert(log = () => {}) {
   const cert = path.join(TLS_DIR, 'cert.pem');
   const key = path.join(TLS_DIR, 'key.pem');
-  try { fs.accessSync(cert); fs.accessSync(key); return { cert, key }; } catch { /* make it */ }
+  // STALE-CERT INVALIDATION. A plain existence check meant anyone who had ever
+  // run an older build kept their cursor-only cert forever and never got the
+  // anthropic names — the fix would ship and appear to do nothing. Record the
+  // SAN set the cert was minted for and re-mint whenever that set changes.
+  const stamp = path.join(TLS_DIR, 'san.txt');
+  const want = TLS_HOSTS.join(',');
+  try {
+    fs.accessSync(cert); fs.accessSync(key);
+    if (fs.readFileSync(stamp, 'utf8').trim() === want) return { cert, key };
+    log('cursor-tls: cert predates the current host list — re-minting');
+  } catch { /* make it */ }
   fs.mkdirSync(TLS_DIR, { recursive: true });
-  const san = `subjectAltName=${CURSOR_HOSTS.map((h) => `DNS:${h}`).join(',')}`;
+  const san = `subjectAltName=${TLS_HOSTS.map((h) => `DNS:${h}`).join(',')}`;
   execFileSync('openssl', [
     'req', '-x509', '-newkey', 'rsa:2048', '-nodes',
     '-keyout', key, '-out', cert, '-days', '3650',
     '-subj', '/CN=api2.cursor.sh', '-addext', san,
   ], { stdio: 'ignore' });
-  log(`cursor-tls: self-signed cert minted at ${TLS_DIR} (no CA, no trust prompt)`);
+  fs.writeFileSync(stamp, want);
+  log(`cursor-tls: self-signed cert minted at ${TLS_DIR} covering ${TLS_HOSTS.length} hosts (no CA, no trust prompt)`);
   return { cert, key };
 }
 
@@ -287,7 +305,21 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
           });
           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; });
+          // STRIP EVERY CONNECTION-SPECIFIC HEADER, NOT JUST `connection`.
+          // RFC 7540 §8.1.2.2 bans all of these on HTTP/2, and Node enforces it
+          // by THROWING ERR_HTTP2_INVALID_CONNECTION_HEADERS out of writeHead.
+          // The local proxy answers with `keep-alive`, which sailed past a
+          // denylist that only knew about `connection` — so the very first
+          // desktop request killed the whole backend process (uncaught, since
+          // this is inside the async handler), and every later attempt got
+          // ECONNRESET with nothing listening. Content-length goes too: the
+          // body was re-buffered, so let Node recompute it.
+          const HOP_BY_HOP = new Set([
+            'connection', 'keep-alive', 'upgrade', 'proxy-connection',
+            'transfer-encoding', 'te', 'trailer', 'proxy-authenticate',
+            'proxy-authorization', 'content-encoding', 'content-length',
+          ]);
+          up.headers.forEach((v, k) => { if (!HOP_BY_HOP.has(k.toLowerCase())) 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)`);

package/package.json

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