openzoo 0.14.0 → 0.15.0

package/bin/openzoo.js

@@ -6,9 +6,10 @@ const HELP = `openzoo — local x402-paying proxy + MCP server for openzoo.fun
 usage:
   npx openzoo            start the proxy: http://localhost:8402/v1 (keyless) PLUS a
                          public HTTPS url for cloud IDEs (key required, printed at start)
-  npx openzoo cursor     wire Cursor to the zoo (writes MCP config, prints the
-                         base_url/key to paste into its AI settings)
-  npx openzoo vscode     same, for VS Code
+  npx openzoo cursor [path]   start proxy+tunnel, write MCP config, and LAUNCH
+                              Cursor already pointed at the zoo (env inherited)
+  npx openzoo vscode [path]   same, for VS Code
+  npx openzoo editor [path]   whichever is installed (Cursor wins if both)
   npx openzoo launch <cmd> [args]   launch a TERMINAL Messages API client
                                     (claude, aider...) already pointed at the zoo
   npx openzoo mcp        stdio MCP server (tools: zoo_ask, zoo_bind, zoo_models, zoo_wallet, zoo_contexts)
@@ -49,10 +50,11 @@ async function main() {
     case 'start':
       await (await import('../lib/proxy.js')).startProxy({ autoTunnel: true });
       break;
+    case 'editor':
     case 'cursor':
     case 'vscode':
       // GUI editors read config files, not env vars — see lib/setup.js.
-      (await import('../lib/setup.js')).setupEditor(cmd);
+      await (await import('../lib/setup.js')).setupEditor(cmd === 'editor' ? undefined : cmd, process.argv[3]);
       break;
     case 'mcp':
       await (await import('../lib/mcp.js')).startMcp();

package/lib/proxy.js

@@ -691,5 +691,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       }
     })();
   }
-  return { server, client, spent: () => sessionSpent };
+  // Expose live tunnel details so a caller that starts the proxy in-process
+  // (openzoo cursor/vscode) can surface the public URL + key instead of the
+  // user hunting for them. Getters, because the tunnel resolves ASYNC after
+  // this returns — a snapshot would always be null.
+  return {
+    server,
+    client,
+    spent: () => sessionSpent,
+    get publicUrl() { return tunnelGate?.publicUrl ?? null; },
+    get tunnelToken() { return tunnelGate?.token ?? null; },
+  };
 }

package/lib/setup.js

@@ -1,59 +1,176 @@
 /**
- * `npx openzoo cursor` / `npx openzoo vscode` — wire a GUI editor to the zoo.
+ * `npx openzoo cursor|vscode [path]` — one command: proxy + tunnel up, config
+ * written, editor launched already pointed at the zoo.
  *
- * WHY THIS IS NOT `launch`: Cursor and VS Code are GUI apps, not processes you
- * hand env vars to. `openzoo launch <cmd>` works for terminal harnesses (claude,
- * aider) because they read ANTHROPIC_BASE_URL/OPENAI_BASE_URL at startup. An
- * editor reads its own config instead, and Cursor keeps the provider base-URL +
- * key in an ENCRYPTED internal store that no CLI can write — that half stays a
- * GUI toggle. So this command does the half that IS automatable (MCP server
- * registration, which is plain JSON) and prints the exact values to paste for
- * the half that is not, instead of pretending it did everything.
+ * THREE THINGS THIS MUST DO, because the user should configure nothing:
+ *  1. ANTHROPIC_BASE_URL (and OPENAI_BASE_URL) exported INTO the editor, so
+ *     its embedded terminals and the Claude Code extension bill through x402.
+ *  2. Config written for them — MCP server registered in the editor's own
+ *     mcp.json, no hand-editing.
+ *  3. The TUNNEL, because a cloud-run harness cannot reach localhost.
+ *
+ * WHY LAUNCH THE BINARY, NOT `open -a`: macOS `open` hands the app to launchd,
+ * which does NOT pass the caller's environment. `open -a Cursor` therefore
+ * configures nothing — the editor comes up with no idea the zoo exists.
+ * Spawning Contents/MacOS/Cursor directly keeps the env, which is the entire
+ * point of this command.
  */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { spawn } from 'node:child_process';
 import { config } from './config.js';
 
-const CURSOR_MCP = path.join(os.homedir(), '.cursor', 'mcp.json');
-const VSCODE_MCP = path.join(os.homedir(), '.vscode', 'mcp.json');
+const MCP_FILES = {
+  cursor: path.join(os.homedir(), '.cursor', 'mcp.json'),
+  vscode: path.join(os.homedir(), '.vscode', 'mcp.json'),
+};
+
+/**
+ * Find a launchable editor binary, platform-agnostically.
+ *
+ * Hardcoding /Applications broke every non-mac install and any mac install
+ * that is not in /Applications (~/Applications, Setapp, a homebrew cask on a
+ * different volume). Order per editor: PATH first (works everywhere and is
+ * what a Linux/Windows user has), then the known app-bundle locations.
+ *
+ * The BUNDLE BINARY is preferred over `open -a` on macOS because `open` hands
+ * the app to launchd, which drops our environment — and the environment IS the
+ * configuration here.
+ */
+const EDITORS = {
+  cursor: {
+    cli: ['cursor'],
+    bundles: [
+      '/Applications/Cursor.app/Contents/MacOS/Cursor',
+      path.join(os.homedir(), 'Applications', 'Cursor.app', 'Contents', 'MacOS', 'Cursor'),
+    ],
+  },
+  vscode: {
+    cli: ['code', 'code-insiders', 'codium'],
+    bundles: [
+      '/Applications/Visual Studio Code.app/Contents/MacOS/Electron',
+      path.join(os.homedir(), 'Applications', 'Visual Studio Code.app', 'Contents', 'MacOS', 'Electron'),
+    ],
+  },
+};
+
+function onPath(bin) {
+  const exts = process.platform === 'win32' ? ['.cmd', '.exe', ''] : [''];
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+    for (const ext of exts) {
+      const f = path.join(dir, bin + ext);
+      try { fs.accessSync(f, fs.constants.X_OK); return f; } catch { /* keep looking */ }
+    }
+  }
+  return null;
+}
+
+/** Resolve one editor to a runnable command, or null if it is not installed. */
+function resolveEditor(which) {
+  const spec = EDITORS[which];
+  if (!spec) return null;
+  for (const c of spec.cli) { const f = onPath(c); if (f) return f; }
+  for (const b of spec.bundles) { try { fs.accessSync(b, fs.constants.X_OK); return b; } catch { /* next */ } }
+  return null;
+}
+
+/** Which editor to use: the one asked for, else Cursor if present, else VS Code. */
+export function pickEditor(requested) {
+  if (requested && EDITORS[requested]) {
+    const found = resolveEditor(requested);
+    if (found) return { which: requested, cmd: found };
+  }
+  for (const which of ['cursor', 'vscode']) { // cursor wins when both exist
+    const cmd = resolveEditor(which);
+    if (cmd) return { which, cmd };
+  }
+  return null;
+}
 
 /** Merge our server into an existing mcp.json without clobbering the user's. */
 function addMcpServer(file) {
   let doc = {};
   try { doc = JSON.parse(fs.readFileSync(file, 'utf8')) || {}; } catch { doc = {}; }
-  const key = doc.mcpServers ? 'mcpServers' : (doc.servers ? 'servers' : 'mcpServers');
+  const key = doc.servers && !doc.mcpServers ? 'servers' : 'mcpServers';
   doc[key] = doc[key] || {};
-  const existed = Boolean(doc[key].openzoo);
   doc[key].openzoo = { command: 'npx', args: ['-y', 'openzoo@latest', 'mcp'] };
   fs.mkdirSync(path.dirname(file), { recursive: true });
   fs.writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
-  return { file, existed };
+  return file;
 }
 
-export function setupEditor(which = 'cursor') {
+/** Is a proxy already listening? Returns its /v1 base or null. */
+async function proxyUp(base) {
+  try {
+    const r = await fetch(`${base}/models`, { signal: AbortSignal.timeout(2500) });
+    return r.ok;
+  } catch { return false; }
+}
+
+export async function setupEditor(which, target) {
   const base = `http://localhost:${config.port}/v1`;
-  const file = which === 'vscode' ? VSCODE_MCP : CURSOR_MCP;
-  const { existed } = addMcpServer(file);
+  const mcpFile = addMcpServer(MCP_FILES[which] || MCP_FILES.cursor);
+
+  // 1. PROXY + TUNNEL. Start in-process if nothing is listening, so the user
+  //    does not need a second terminal. The tunnel URL is what a cloud-run
+  //    harness must use; we surface it rather than leaving them to find it.
+  let publicUrl = null;
+  let tunnelKey = null;
+  if (!(await proxyUp(base))) {
+    console.log(`starting proxy on ${base} (+ public tunnel)...`);
+    const { startProxy } = await import('./proxy.js');
+    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++) {
+      await new Promise((r) => setTimeout(r, 500));
+      publicUrl = started?.publicUrl ?? null;
+      tunnelKey = started?.tunnelToken ?? null;
+    }
+  } else {
+    console.log(`proxy already running on ${base}`);
+  }
+
+  // 2. ENV INTO THE EDITOR. Both vendor shapes, so an OpenAI-compatible pane
+  //    and an Anthropic-shaped one (Claude Code extension) both route here.
+  const env = {
+    ...process.env,
+    OPENAI_BASE_URL: base,
+    OPENAI_API_KEY: process.env.OPENAI_API_KEY || 'sk-openzoo',
+    ANTHROPIC_BASE_URL: base,
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || 'sk-openzoo',
+    ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN || 'sk-openzoo',
+  };
 
-  console.log(`openzoo → ${which}`);
-  console.log('');
-  console.log(`1. MCP: ${existed ? 'updated' : 'added'} "openzoo" in ${file}`);
-  console.log('   tools: zoo_bind, zoo_ask, zoo_models, zoo_wallet, zoo_contexts');
-  console.log('   (restart the editor to pick it up)');
-  console.log('');
-  console.log('2. Model routing — paste these into the editor\'s AI settings.');
-  console.log('   Cursor keeps provider settings in an encrypted store, so this');
-  console.log('   part cannot be scripted; it is two fields:');
-  console.log('');
-  console.log(`     Override OpenAI Base URL :  ${base}`);
-  console.log('     OpenAI API Key           :  sk-openzoo   (any value; x402 pays, not keys)');
   console.log('');
-  console.log('   Then add a model the zoo serves (Cursor validates the name):');
-  console.log('     deepseek/deepseek-v4-pro-0813   ← cheap, stateless tools, recommended');
-  console.log('     openai/gpt-5.6-sol-pro          ← flagship, ~34x the output cost');
-  console.log('   Turn OFF the built-in models (Composer/GPT/Cursor-Grok) while the');
-  console.log('   override is on — those only resolve against Cursor\'s own backend.');
+  console.log(`mcp:     ${mcpFile}  (openzoo: zoo_bind, zoo_ask, zoo_models, zoo_wallet, zoo_contexts)`);
+  console.log(`local:   ${base}   api_key sk-openzoo`);
+  if (publicUrl) {
+    console.log(`tunnel:  ${publicUrl}/v1   api_key ${tunnelKey}`);
+    console.log('         (use the tunnel for any cloud-run harness — it cannot reach localhost)');
+  }
   console.log('');
-  console.log(`3. Make sure the proxy is running:  npx openzoo    (${base})`);
+
+  // 3. LAUNCH with that env. Editor resolved platform-agnostically; Cursor
+  //    wins when both are installed.
+  const cwd = target && !target.startsWith('-') ? target : '.';
+  const picked = pickEditor(which);
+  if (!picked) {
+    console.error('no editor found — install Cursor or VS Code, or put `cursor`/`code` on PATH');
+    console.error(`(config is written either way: ${mcpFile})`);
+    return;
+  }
+  console.log(`launching ${picked.which}...`);
+  const child = spawn(picked.cmd, [cwd], { stdio: 'ignore', env, detached: true });
+  child.on('error', (e) => {
+    console.error(`could not launch ${picked.which}: ${e.message}`);
+  });
+  child.unref();
+  // 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))) {
+    console.log('proxy is running in this terminal — Ctrl-C when done.');
+  }
 }

package/package.json

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