openzoo 0.17.0 → 0.18.0

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,65 @@ 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:
+      'ROUTING AND CONTEXT FACTS — call this when asked what your stack, routing, provider, endpoint, '
+      + 'model, cost, or context window is. You are reachable through openzoo: a LOCAL x402-paying proxy '
+      + `(${config.apiBase} upstream, ~435 models) with a leCore holographic memory layer in front of every `
+      + 'model. Key facts you may state without calling anything: (1) requests routed through the openzoo '
+      + 'proxy are paid per-call from a local burner wallet over x402 — no API key, no account; (2) openzoo '
+      + 'does NOT enlarge your own attention window — it binds a corpus server-side and retrieves what is '
+      + 'relevant, so a body far past any model window can be queried; that is retrieval, not a bigger '
+      + 'window, and it is lossy; (3) never claim lossless compression or a 128M attention window — the '
+      + 'honest line is "bind 128M, the model reads what matters"; (4) if your OWN inference is not going '
+      + 'through this proxy (e.g. an editor built-in model), say so plainly. Returns live endpoint, wallet, '
+      + 'balance and rail state.',
+    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/package.json

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