openzoo 0.16.0 → 0.18.0

package/lib/cursorcfg.js

@@ -0,0 +1,92 @@
+/**
+ * Write Cursor / VS Code-fork provider settings directly.
+ *
+ * These live as PLAIN JSON in the editor's globalStorage SQLite (`state.vscdb`,
+ * table ItemTable), under the reactive-storage `applicationUser` blob — NOT in
+ * an encrypted store. The fields that matter:
+ *   openAIBaseUrl        the "Override OpenAI Base URL" box
+ *   useOpenAIKey         the toggle next to it
+ *   availableAPIKeyModels  the custom model names the picker offers
+ *
+ * So the whole "paste these four things into Settings" ritual is scriptable,
+ * and `openzoo cursor` should just do it. The editor must be CLOSED while we
+ * write, or it will overwrite us from memory on exit.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+const KEY = 'src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser';
+
+const STORAGE = {
+  cursor: path.join(os.homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
+  vscode: path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'state.vscdb'),
+};
+
+/** Linux/Windows put globalStorage elsewhere; resolve per platform. */
+function storagePath(which) {
+  if (process.platform === 'darwin') return STORAGE[which];
+  const dir = which === 'vscode' ? 'Code' : 'Cursor';
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), dir, 'User', 'globalStorage', 'state.vscdb');
+  }
+  return path.join(os.homedir(), '.config', dir, 'User', 'globalStorage', 'state.vscdb');
+}
+
+const sqlite = (db, sql) => execFileSync('sqlite3', [db, sql], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+
+/** True when the editor process is running — writing under it gets clobbered. */
+export function editorRunning(which) {
+  try {
+    // 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; }
+}
+
+/**
+ * Point the editor at the zoo: base URL, key toggle, and the models the picker
+ * should offer. Returns what changed, or null when the store is unavailable
+ * (a fresh install with no globalStorage yet).
+ */
+export function writeEditorProviderConfig(which, { baseUrl, models }) {
+  const db = storagePath(which);
+  if (!fs.existsSync(db)) return null;
+  try { execFileSync('sqlite3', ['-version'], { stdio: 'ignore' }); } catch { return { error: 'sqlite3 not available' }; }
+
+  const raw = sqlite(db, `SELECT value FROM ItemTable WHERE key='${KEY}';`).trim();
+  if (!raw) return null;
+  let doc;
+  try { doc = JSON.parse(raw); } catch { return { error: 'could not parse editor config' }; }
+
+  const before = { openAIBaseUrl: doc.openAIBaseUrl, models: (doc.availableAPIKeyModels || []).length };
+  doc.openAIBaseUrl = baseUrl;
+  doc.useOpenAIKey = true;
+  // Merge, don't clobber: a user may have their own custom models listed.
+  const existing = Array.isArray(doc.availableAPIKeyModels) ? doc.availableAPIKeyModels : [];
+  const names = new Set(existing.map((m) => (typeof m === 'string' ? m : m?.name)).filter(Boolean));
+  const added = [];
+  for (const m of models) {
+    if (names.has(m)) continue;
+    // Match the shape already present, so the picker renders it correctly.
+    existing.push(typeof existing[0] === 'string' ? m : { name: m, defaultOn: true, supportsAgent: true });
+    names.add(m);
+    added.push(m);
+  }
+  doc.availableAPIKeyModels = existing;
+
+  // Single-quote escaping for the SQL literal.
+  const json = JSON.stringify(doc).replace(/'/g, "''");
+  sqlite(db, `UPDATE ItemTable SET value='${json}' WHERE key='${KEY}';`);
+  return { db, before, baseUrl, added };
+}

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/lib/setup.js

@@ -20,6 +20,9 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { config } from './config.js';
+import { writeEditorProviderConfig, editorRunning } from './cursorcfg.js';
+
+const DEFAULT_MODELS = ['anthropic/claude-opus-5', 'deepseek/deepseek-v4-pro-0813'];
 
 const MCP_FILES = {
   cursor: path.join(os.homedir(), '.cursor', 'mcp.json'),
@@ -155,19 +158,26 @@ export async function setupEditor(which, target) {
   // CUSTOM model under the OpenAI override, where the proxy serves it and maps
   // the name. Env alone cannot do this; say so plainly instead of implying the
   // launch handled everything.
-  console.log('one manual step — Cursor Settings → Models (built-ins bypass the zoo):');
-  console.log(`  1. Override OpenAI Base URL  ->  ${base}`);
-  console.log('  2. OpenAI API Key            ->  sk-openzoo   (any value; x402 pays)');
-  console.log('  3. Add model                 ->  anthropic/claude-opus-5');
-  console.log('     (or deepseek/deepseek-v4-pro-0813 — ~34x cheaper output)');
-  console.log('  4. Toggle OFF the built-in models (Opus 5 / GPT / Composer) — those');
-  console.log('     resolve against Cursor\'s backend and never touch the zoo.');
-  console.log('  The embedded terminal + Claude Code extension DO inherit the env above.');
-  if (publicUrl) {
-    console.log(`tunnel:  ${publicUrl}/v1   api_key ${tunnelKey}`);
-    console.log('         (use the tunnel for any cloud-run harness — it cannot reach localhost)');
+  // WRITE THE PROVIDER SETTINGS. These are plain JSON in the editor's
+  // globalStorage sqlite — not an encrypted store, as previously assumed — so
+  // the "paste four things into Settings" ritual is unnecessary. Must happen
+  // while the editor is CLOSED or it rewrites them from memory on exit.
+  const picked0 = pickEditor(which);
+  const target0 = picked0?.which || which || 'cursor';
+  if (editorRunning(target0)) {
+    console.log(`NOTE: ${target0} is already running — quit it and re-run so settings stick.`);
+  }
+  const models = [DEFAULT_MODELS[0], ...DEFAULT_MODELS.slice(1)];
+  let wrote = null;
+  try { wrote = writeEditorProviderConfig(target0, { baseUrl: base, models }); } catch (e) { wrote = { error: e.message }; }
+  if (wrote?.error) {
+    console.log(`settings: could not write automatically (${wrote.error}) — set them in Settings → Models`);
+  } else if (wrote) {
+    console.log(`settings: openAIBaseUrl -> ${base}  (was ${wrote.before.openAIBaseUrl || 'unset'})`);
+    console.log(`          useOpenAIKey  -> true`);
+    console.log(`          models added  -> ${wrote.added.length ? wrote.added.join(', ') : '(already present)'}`);
+    console.log('          pick one of those in the model dropdown; built-ins bypass the zoo.');
   }
-  console.log('');
 
   // 3. LAUNCH with that env. Editor resolved platform-agnostically; Cursor
   //    wins when both are installed.

package/package.json

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