openzoo 0.17.0 → 0.18.1

package/lib/cursorcfg.js

@@ -39,9 +39,18 @@ const sqlite = (db, sql) => execFileSync('sqlite3', [db, sql], { encoding: 'utf8
 /** True when the editor process is running — writing under it gets clobbered. */
 export function editorRunning(which) {
   try {
-    const name = which === 'vscode' ? 'Visual Studio Code' : 'Cursor';
-    const out = execFileSync('pgrep', ['-f', name], { encoding: 'utf8' });
-    return out.trim().length > 0;
+    // MATCH THE APP BINARY, NOT THE WORD. `pgrep -f Cursor` matched 19
+    // processes on a machine with Cursor CLOSED: this very command
+    // (`node openzoo.js cursor` contains the word), leftover crashpad helpers,
+    // and macOS's own CursorUIViewService — so it always warned "already
+    // running" and told the user to quit an editor that was not open.
+    const needle = which === 'vscode'
+      ? 'Visual Studio Code.app/Contents/MacOS/'
+      : 'Cursor.app/Contents/MacOS/Cursor';
+    const out = execFileSync('pgrep', ['-f', needle], { encoding: 'utf8' });
+    const pids = out.split('\n').map((s) => s.trim()).filter(Boolean)
+      .filter((p) => Number(p) !== process.pid && Number(p) !== process.ppid);
+    return pids.length > 0;
   } catch { return false; }
 }
 

package/lib/mcp.js

@@ -167,6 +167,64 @@ export function buildMcpServer() {
     }
   });
 
+  // WHY A DEDICATED TOOL: MCP server `instructions` are advisory and several
+  // clients (Cursor among them) never surface them to the model — so an agent
+  // with this server attached still answers "I have no visibility into the
+  // routing layer", which is the FIRST question users ask, every time. Tool
+  // DESCRIPTIONS are always in context, so the facts live here too, and the
+  // tool returns them live.
+  server.registerTool('zoo_status', {
+    description:
+      'Report what THIS openzoo proxy is and how it is routed, by querying it live (GET /v1/info + wallet + '
+      + 'rails). Call it when asked about the openzoo setup: its endpoint, tunnel URL, upstream, wallet, '
+      + 'balances, or what its context/binding actually does. '
+      + 'SCOPE — it describes the PROXY, not you: it says nothing about which provider serves your own '
+      + 'inference or what your own attention window is, and you should not infer either from it. If your '
+      + 'requests are not going through this proxy, say so. '
+      + 'It is useful for correcting two common overclaims, because the returned values are checkable: '
+      + 'openzoo does not enlarge any model\'s attention window (it binds a corpus server-side and '
+      + 'retrieves top-k chunks, which is lossy), and calls made THROUGH it are paid per-request via x402 '
+      + 'from a local burner wallet rather than with an API key.',
+    inputSchema: {},
+  }, async () => {
+    const rails = await liveRails().catch(() => null);
+    let balances = null;
+    try {
+      const bals = await Promise.all(
+        FUNDING_ASSETS.map((a) => tokenBalance(client.connection, client.keypair.publicKey, a.mint)),
+      );
+      balances = Object.fromEntries(FUNDING_ASSETS.map((a, i) => [a.symbol, bals[i].ui ?? 0]));
+    } catch { /* advisory */ }
+    // ASK THE PROXY, DON'T ASSUME. The public tunnel URL is what a cloud agent
+    // actually reaches us on, and only the running proxy knows it — so read it
+    // from /v1/info instead of reporting a localhost URL that a remote caller
+    // cannot use.
+    let live = null;
+    try {
+      const r = await fetch(`http://localhost:${config.port}/v1/info`, { signal: AbortSignal.timeout(2500) });
+      if (r.ok) live = await r.json();
+    } catch { /* proxy not up — local facts below still hold */ }
+    return text({
+      publicTunnel: live?.publicTunnel ?? null,
+      useThisIfRemote: live?.publicTunnel ?? '(no tunnel — proxy not running, or localhost-only mode)',
+      proxy: `http://localhost:${config.port}/v1`,
+      mcp: `http://localhost:${config.port}/mcp`,
+      upstream: config.apiBase,
+      defaultModel: DEFAULT_MODEL,
+      payment: 'x402 per request from a local burner wallet — no API key, no account',
+      railsLiveNow: rails?.live ?? null,
+      wallet: { solana: client.address, evm: client.evmAddress },
+      balances,
+      contextTruth: {
+        yourAttentionWindow: 'unchanged — openzoo does not enlarge it',
+        boundCeiling: '~128M tokens client-usable via bind + retrieval',
+        singleRequestLimit: '~8MB; larger corpora are bound in parts',
+        retrieval: 'lossy — top-k chunks are retrieved, not the whole corpus',
+      },
+      note: 'A cloud-run harness cannot reach localhost; it needs the public tunnel URL the proxy prints at startup.',
+    });
+  });
+
   server.registerTool('zoo_models', {
     description: 'List the models the zoo serves, with per-token pricing (free endpoint, no payment).',
     inputSchema: {},

package/lib/proxy.js

@@ -325,6 +325,42 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         return;
       }
     }
+    // ROUTING TRUTH, SERVED FROM WHATEVER URL YOU REACHED US ON. A cloud agent
+    // only ever touches the tunnel, so asking a local MCP process "what is my
+    // routing" is the wrong question — the answer has to come from the tunnel
+    // itself, and name the tunnel. Free and unauthenticated: discovery must
+    // never be the thing that is gated.
+    {
+      const p0 = (req.url || '').split('?')[0];
+      if (req.method === 'GET' && (p0 === '/v1/info' || p0 === '/info')) {
+        const self = viaTunnel && tunnelGate?.publicUrl
+          ? `${tunnelGate.publicUrl}/v1`
+          : `http://localhost:${config.port}/v1`;
+        res.writeHead(200, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({
+          youAreTalkingTo: 'openzoo proxy',
+          yourEndpoint: self,
+          reachedVia: viaTunnel ? 'public tunnel' : 'localhost',
+          publicTunnel: tunnelGate?.publicUrl ? `${tunnelGate.publicUrl}/v1` : null,
+          mcp: `${self.replace(/\/v1$/, '')}/mcp`,
+          upstream: config.apiBase,
+          payment: 'x402 per request from the operator\'s local burner wallet — no API key, no account',
+          auth: viaTunnel
+            ? 'this public URL requires the oz_… bearer for paid endpoints; /v1/models and /v1/hrr/bind are free'
+            : 'localhost is keyless',
+          context: {
+            yourAttentionWindow: 'unchanged — openzoo does not enlarge it',
+            boundCeiling: '~128M tokens client-usable via bind + retrieval',
+            singleRequestLimit: '~8MB per request; larger corpora bind in parts',
+            retrieval: 'lossy top-k retrieval, NOT lossless compression',
+          },
+          tools: ['zoo_bind', 'zoo_ask', 'zoo_status', 'zoo_models', 'zoo_wallet', 'zoo_contexts'],
+          docs: 'https://openzoo.fun',
+        }, null, 2));
+        return;
+      }
+    }
+
     if (viaTunnel) {
       const got = (req.headers.authorization || '').replace(/^Bearer\s+/i, '').trim();
       const authed = got === tunnelGate.token;

package/lib/setup.js

@@ -126,12 +126,17 @@ export async function setupEditor(which, target) {
     const started = await startProxy({ silent: true, autoTunnel: true });
     publicUrl = started?.publicUrl ?? null;
     tunnelKey = started?.tunnelToken ?? null;
-    // give the tunnel a moment to publish its URL
-    for (let i = 0; i < 20 && !publicUrl; i++) {
+    // Wait for cloudflared to publish the URL. It downloads on first run and
+    // routinely takes 30-45s; a 10s wait meant the tunnel line simply never
+    // printed and the user never learned the public URL existed.
+    process.stdout.write('waiting for tunnel');
+    for (let i = 0; i < 120 && !publicUrl; i++) {
       await new Promise((r) => setTimeout(r, 500));
       publicUrl = started?.publicUrl ?? null;
       tunnelKey = started?.tunnelToken ?? null;
+      if (i % 4 === 3) process.stdout.write('.');
     }
+    process.stdout.write(publicUrl ? ' ok\n' : ' (not up yet — it will print in this terminal when ready)\n');
   } else {
     console.log(`proxy already running on ${base}`);
   }

package/package.json

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