openzoo 0.34.3 → 0.34.5

package/bin/cursor-backend.js

@@ -19,11 +19,13 @@ 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')); }

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 };
 }
 

package/lib/hosts.js

@@ -269,9 +269,31 @@ export function bindBackend443(modelsPath, logPath, log = console.log) {
   );
   // Report whether it ACTUALLY came up rather than whether sudo exited 0 —
   // `nohup ... &` always succeeds, so `ok` alone said nothing about the bind.
-  const listening = spawnSync('sh', ['-c',
-    'for i in 1 2 3 4 5 6 7 8; do lsof -nP -iTCP:443 -sTCP:LISTEN -t >/dev/null 2>&1 && exit 0; sleep 0.5; done; exit 1',
-  ]).status === 0;
+  //
+  // PROBE BY CONNECTING, NOT BY lsof. The backend we just started is ROOT-owned;
+  // unprivileged `lsof -iTCP:443` cannot see another user's descriptors and exits
+  // 1 even while `netstat -an` shows `*.443 LISTEN`. That false negative made the
+  // caller tear down a WORKING setup and print "FAILED to bind" directly under
+  // the backend's own "listening on [::]+127.0.0.1:443" log line. A TCP connect
+  // is ownership-blind, and it proves the far more useful property anyway: that
+  // the socket actually accepts. Try both families — hosts.js pins both.
+  const listening = spawnSync(node, ['-e', `
+    const net = require('net');
+    const hit = (host) => new Promise((r) => {
+      const s = net.connect({ host, port: 443 });
+      s.setTimeout(1000);
+      s.on('connect', () => { s.destroy(); r(true); });
+      s.on('error', () => r(false));
+      s.on('timeout', () => { s.destroy(); r(false); });
+    });
+    (async () => {
+      for (let i = 0; i < 10; i++) {
+        if (await hit('127.0.0.1') || await hit('::1')) process.exit(0);
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      process.exit(1);
+    })();
+  `], { timeout: 20000 }).status === 0;
   if (!listening) {
     log(`  backend did NOT bind :443 — see ${logPath}`);
     try {
@@ -288,6 +310,8 @@ export function unbindBackend443() {
   return { ok: privileged(
     flushPf
     + "pkill -9 -f 'cursor-backend.js' 2>/dev/null; "
-    + 'for p in $(lsof -nP -iTCP:8443 -sTCP:LISTEN -t 2>/dev/null); do kill -9 "$p" 2>/dev/null; done; true',
+    // 443 as well as 8443: the backend binds :443 directly now, and this runs
+    // under sudo so lsof CAN see the root-owned socket here.
+    + 'for p in $(lsof -nP -iTCP:443 -sTCP:LISTEN -t 2>/dev/null) $(lsof -nP -iTCP:8443 -sTCP:LISTEN -t 2>/dev/null); do kill -9 "$p" 2>/dev/null; done; true',
   ) };
 }

package/package.json

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