openzoo 0.23.1 → 0.25.0

package/lib/proxy.js

@@ -285,6 +285,10 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // origin, not off whether the URL exists yet, so there is no startup window
   // where public traffic slips through ungated.
   let tunnelGate = null;
+  // How many chat requests actually ARRIVED. The single number that answers
+  // "is the editor really routing through us?" — an editor that silently keeps
+  // using its own backend leaves this at 0 while looking perfectly healthy.
+  let servedRequests = 0;
   let tunnelError = null;
 
   const server = http.createServer(async (req, res) => {
@@ -343,6 +347,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           yourEndpoint: self,
           reachedVia: viaTunnel ? 'public tunnel' : 'localhost',
           publicTunnel: tunnelGate?.publicUrl ? `${tunnelGate.publicUrl}/v1` : null,
+          servedRequests,
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
           upstream: config.apiBase,
           payment: 'x402 per request from the operator\'s local burner wallet — no API key, no account',
@@ -467,6 +472,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // carries a model field, not just chat/completions, so /completions,
     // /responses and future shapes all work. Never silent.
     let wantsStream = false;
+      if ((req.url || '').includes('/chat/completions') && req.method === 'POST') servedRequests += 1;
     if (rewritablePath(req.method, req.url)) {
       const rw = await maybeRewriteModel(bodyBuf);
       if (rw) {

package/lib/setup.js

@@ -193,8 +193,48 @@ async function proxyUp(base) {
   } catch { return false; }
 }
 
+
+/** Facts about THIS run, before anything can go wrong silently. */
+async function printStartupDiagnostic(base, which) {
+  const q = (fn, dflt = '?') => { try { return fn(); } catch { return dflt; } };
+  let version = '?';
+  try {
+    const here = path.dirname(new URL(import.meta.url).pathname);
+    version = JSON.parse(fs.readFileSync(path.join(here, '..', 'package.json'), 'utf8')).version;
+  } catch { /* keep ? */ }
+
+  const picked = q(() => pickEditor(which), null);
+  let hosts = 'n/a';
+  try {
+    const { isBlocked, BACKEND_HOSTS } = await import('./hosts.js');
+    hosts = isBlocked() ? `blocked (${BACKEND_HOSTS.join(', ')})` : 'NOT blocked';
+  } catch { /* n/a */ }
+
+  const portBusy = await proxyUp(base);
+
+  console.log('openzoo diagnostic');
+  console.log(`  version    : ${version}   node ${process.version}   ${process.platform}/${process.arch}`);
+  console.log(`  port ${config.port}  : ${portBusy ? 'ALREADY SERVING (an older proxy may still be running — kill it if this build is newer)' : 'free'}`);
+  console.log(`  editor     : ${picked ? `${picked.which} @ ${picked.cmd}` : 'NONE FOUND'}`);
+  console.log(`  running    : ${picked ? (q(() => editorRunning(picked.which), false) ? 'yes — will be quit so settings stick' : 'no') : '-'}`);
+  console.log(`  backend    : ${hosts}`);
+  console.log(`  upstream   : ${config.apiBase}`);
+  const envs = ['OPENZOO_DEFAULT_MODEL', 'OPENZOO_EDITOR_MODELS', 'OPENZOO_EDITOR_MAP', 'OPENZOO_NO_LABELS', 'OPENZOO_NO_TUNNEL']
+    .filter((k) => process.env[k]).map((k) => `${k}=${process.env[k]}`);
+  if (envs.length) console.log(`  env        : ${envs.join('  ')}`);
+  console.log('');
+}
+
 export async function setupEditor(which, target) {
   const base = `http://localhost:${config.port}/v1`;
+
+  // STARTUP DIAGNOSTIC. Printed unconditionally because every hard bug tonight
+  // was invisible from the outside: a STALE BUILD writing old config (npm caches
+  // metadata and silently serves an older version), a hosts block that never
+  // applied because the sudo prompt was skipped, an editor that was still running
+  // so it clobbered the write, a tunnel that printed a URL and never served.
+  // One block up front turns each of those from a guess into a fact.
+  await printStartupDiagnostic(base, which);
   const mcpFile = addMcpServer(MCP_FILES[which] || MCP_FILES.cursor);
 
   // 1. PROXY + TUNNEL. Start in-process if nothing is listening, so the user
@@ -360,6 +400,18 @@ export async function setupEditor(which, target) {
       ? '          pinned        -> yes (the editor re-syncs these from its account; a DB trigger re-applies them)'
       : `          pinned        -> NO (${pin?.error || 'unavailable'}) — the editor may revert these on launch`);
     console.log('  verify: send one message, watch for "paid $0.0… · rail solana · tx …" here.');
+    // READ-BACK, not what we intended to write. A pin trigger or a running editor
+    // can rewrite this between the write and the launch, and that silent revert
+    // is exactly what made the editor point at a dead tunnel for hours.
+    try {
+      const back = writeEditorProviderConfig(target0, { baseUrl: editorBase, models, apiKey: tunnelKey })?.verified;
+      console.log('  db now  : baseUrl=' + (back?.openAIBaseUrl || '?'));
+      console.log('            models =' + (Array.isArray(back?.availableAPIKeyModels)
+        ? back.availableAPIKeyModels.map((m) => m.name).join(', ') : '?'));
+      if (back?.openAIBaseUrl && back.openAIBaseUrl !== editorBase) {
+        console.log('  WARNING : the database does NOT match what we wrote — something is reverting it.');
+      }
+    } catch (e) { console.log('  db now  : could not read back (' + e.message + ')'); }
   }
 
   // 2b. THE BACKEND BLOCK. Pinning the database is not sufficient on its own:
@@ -416,6 +468,34 @@ export async function setupEditor(which, target) {
     console.error(`could not launch ${picked.which}: ${e.message}`);
   });
   child.unref();
+
+  // DID IT ACTUALLY ROUTE? The editor can look perfectly configured and still
+  // serve every message from its OWN backend — it answers normally, so a reply
+  // proves nothing. This watches the only number that does: chat requests that
+  // actually ARRIVED here. Costs nothing and ends the guessing.
+  (async () => {
+    const seen = async () => {
+      try {
+        const r = await fetch(`${base}/info`, { signal: AbortSignal.timeout(3000) });
+        return (await r.json())?.servedRequests ?? 0;
+      } catch { return 0; }
+    };
+    const before = await seen();
+    for (let i = 0; i < 40; i++) {                      // ~2 min
+      await new Promise((r) => setTimeout(r, 3000));
+      const now = await seen();
+      if (now > before) {
+        console.log(`\nROUTING CONFIRMED — ${now - before} request(s) reached the zoo.`);
+        console.log('   (a receipt line above shows what each one paid)');
+        return;
+      }
+    }
+    console.log('\nNOT ROUTING — 0 requests reached the zoo in 2 minutes.');
+    console.log('   The editor is answering from its OWN backend. Check, in order:');
+    console.log('   1. did you QUIT the editor fully before this ran? it caches config at launch');
+    console.log('   2. Settings -> Models -> "Override OpenAI Base URL" toggle is ON');
+    console.log('   3. the model you picked is one of the ids written above');
+  })();
   // Keep this process alive when we own the proxy — killing it would kill the
   // zoo the editor was just pointed at.
   if (publicUrl || !(await proxyUp(base))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.23.1",
+  "version": "0.25.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",