openzoo 0.18.0 → 0.18.2

package/lib/cursorcfg.js

@@ -54,6 +54,34 @@ export function editorRunning(which) {
   } catch { return false; }
 }
 
+/**
+ * Quit the editor and wait for it to exit.
+ *
+ * WHY WE DO THIS FOR THE USER: the editor holds its settings in memory and
+ * flushes them on exit, so a write performed while it is running is silently
+ * reverted — measured: availableAPIKeyModels came back [] every launch, the
+ * model never appeared in the dropdown, and the user was told to "just pick
+ * it". Writing while it is CLOSED sticks. Telling a human to quit their editor
+ * and re-run a command is not automation, so we quit it, write, and relaunch.
+ */
+export async function quitEditor(which) {
+  if (!editorRunning(which)) return { wasRunning: false };
+  const app = which === 'vscode' ? 'Visual Studio Code' : 'Cursor';
+  try {
+    if (process.platform === 'darwin') {
+      // Graceful: ask the app to quit so it flushes state normally.
+      execFileSync('osascript', ['-e', `tell application "${app}" to quit`], { stdio: 'ignore' });
+    } else {
+      execFileSync('pkill', ['-TERM', '-f', which === 'vscode' ? 'Code' : 'Cursor'], { stdio: 'ignore' });
+    }
+  } catch { /* fall through to the wait; it may already be closing */ }
+  for (let i = 0; i < 40; i++) {                 // up to 20s
+    if (!editorRunning(which)) return { wasRunning: true, quit: true };
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return { wasRunning: true, quit: 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
@@ -88,5 +116,22 @@ export function writeEditorProviderConfig(which, { baseUrl, models }) {
   // 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 };
+
+  // VERIFY, DO NOT ASSUME. `availableAPIKeyModels` is SERVER-SYNCED: Cursor
+  // rebuilds it from its own account state on launch and silently discards a
+  // local write, so this function used to report "models added" for a list
+  // that was empty again seconds later — and the user was told to pick a model
+  // that never appeared in the dropdown. Read it back and say which parts
+  // actually stuck.
+  let verified = { openAIBaseUrl: null, models: [] };
+  try {
+    const raw2 = sqlite(db, `SELECT value FROM ItemTable WHERE key='${KEY}';`).trim();
+    const doc2 = JSON.parse(raw2);
+    verified = {
+      openAIBaseUrl: doc2.openAIBaseUrl,
+      models: (doc2.availableAPIKeyModels || []).map((m) => (typeof m === 'string' ? m : m?.name)).filter(Boolean),
+    };
+  } catch { /* verification is advisory */ }
+  const modelsStick = models.every((m) => verified.models.includes(m));
+  return { db, before, baseUrl, added, verified, modelsStick };
 }

package/lib/mcp.js

@@ -175,17 +175,16 @@ export function buildMcpServer() {
   // 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.',
+      '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);

package/lib/setup.js

@@ -20,7 +20,7 @@ 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';
+import { writeEditorProviderConfig, editorRunning, quitEditor } from './cursorcfg.js';
 
 const DEFAULT_MODELS = ['anthropic/claude-opus-5', 'deepseek/deepseek-v4-pro-0813'];
 
@@ -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}`);
   }
@@ -164,8 +169,11 @@ export async function setupEditor(which, target) {
   // while the editor is CLOSED or it rewrites them from memory on exit.
   const picked0 = pickEditor(which);
   const target0 = picked0?.which || which || 'cursor';
+  // Quit it FOR the user — a running editor reverts our write on exit.
   if (editorRunning(target0)) {
-    console.log(`NOTE: ${target0} is already running — quit it and re-run so settings stick.`);
+    console.log(`${target0} is running — quitting it so settings stick (it relaunches below)...`);
+    const q = await quitEditor(target0);
+    if (!q.quit) console.log(`  could not close ${target0} automatically; settings may not persist`);
   }
   const models = [DEFAULT_MODELS[0], ...DEFAULT_MODELS.slice(1)];
   let wrote = null;
@@ -173,10 +181,22 @@ export async function setupEditor(which, target) {
   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(`settings: openAIBaseUrl -> ${wrote.verified?.openAIBaseUrl || base}`);
+    console.log('          useOpenAIKey  -> true');
+    if (wrote.modelsStick) {
+      console.log(`          models        -> ${models.join(', ')}`);
+      console.log('          pick one in the model dropdown; built-ins bypass the zoo.');
+    } else {
+      // Cursor re-syncs this list from its account on launch, so a local write
+      // does not survive. Say so instead of promising a dropdown entry that
+      // will not be there.
+      console.log('          models        -> NOT writable (Cursor re-syncs this list on launch)');
+      console.log('');
+      console.log('  ONE-TIME manual step, in Cursor → Settings → Models:');
+      console.log(`    + Add model  ->  ${models[0]}`);
+      console.log('    then toggle OFF the built-in models, or Cursor keeps using its own backend.');
+      console.log('    (the base URL + key above are already set for you and DO persist)');
+    }
   }
 
   // 3. LAUNCH with that env. Editor resolved platform-agnostically; Cursor

package/package.json

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