openzoo 0.50.90 → 0.50.92

package/bin/claude-zoo.js

@@ -6,7 +6,7 @@
  * the local openzoo proxy on :8402 (x402 per-call payment, no Anthropic
  * subscription, no login):
  *
- *   - starts the proxy if it is not already listening
+ *   - starts the proxy if it is not already THIS version on :8402 (steals stale)
  *   - applies claudeZooEnv(): ANTHROPIC_BASE_URL=localhost:PORT/v1,
  *     AUTH_TOKEN=sk-openzoo, ANTHROPIC_API_KEY deleted, compaction disabled
  *     (the proxy binds the prefix), 1M-token ceiling restored
@@ -16,7 +16,8 @@
  * `claude-code-cli` (same directory, symlinked to occ).
  */
 import { spawn } from 'node:child_process';
-import { existsSync, readdirSync as fsReaddir } from 'node:fs';
+import { existsSync, readdirSync as fsReaddir, readFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
 import { homedir, platform } from 'node:os';
 import { dirname, join, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -50,10 +51,34 @@ if (!occ) {
 const PROXY_PORT = Number(process.env.OPENZOO_PROXY_PORT || 8402);
 const PROXY_URL = `http://localhost:${PROXY_PORT}/v1`;
 
+function mineVersion() {
+  try {
+    return JSON.parse(readFileSync(join(shimRoot, 'package.json'), 'utf8')).version;
+  } catch { return ''; }
+}
+
+function stealPort(port) {
+  const n = Number(port);
+  for (const cmd of [
+    `lsof -t -iTCP:${n} -sTCP:LISTEN | xargs kill -9`,
+    `fuser -k ${n}/tcp`,
+  ]) {
+    try { execSync(cmd, { stdio: 'ignore', timeout: 2000, shell: true }); } catch { /* missing */ }
+  }
+}
+
 async function proxyUp() {
   try {
     const r = await fetch(`http://localhost:${PROXY_PORT}/v1/info`, { signal: AbortSignal.timeout(1500) });
-    return r.ok;
+    if (!r.ok) return false;
+    const j = await r.json().catch(() => ({}));
+    const mine = mineVersion();
+    if (mine && String(j.version || '') !== mine) {
+      console.error(`claude: stale proxy v${j.version || '?'} on :${PROXY_PORT} — stealing for v${mine}`);
+      stealPort(PROXY_PORT);
+      return false;
+    }
+    return true;
   } catch { return false; }
 }
 

package/bin/openzoo.js

@@ -330,7 +330,7 @@ async function main() {
     }
     case 'ask': {
       const question = process.argv[3];
-      if (!question) throw new Error('usage: openzoo ask "<question>" [--context <id>] [--model <id>] [--system <text>] [--web [--web-results N]]');
+      if (!question) throw new Error('usage: openzoo ask "<question>" [--context <id>] [--model <id>] [--system <text>]');
       const ci = process.argv.indexOf('--context');
       const mi = process.argv.indexOf('--model');
       // A BARE QUESTION IS A DIFFERENT PRODUCT FROM A BRIEFED ONE.
@@ -344,20 +344,7 @@ async function main() {
       // DHH, Hyprland and theming. Same gateway, same product, one had context.
       // A caller that knows where it is running can now say so.
       const si = process.argv.indexOf('--system');
-      let system = si !== -1 ? process.argv[si + 1] : '';
-      // --web: a keyless DuckDuckGo search, top results injected into THIS
-      // call's system prompt. The x402 rail strips OpenRouter's `plugins`
-      // field, so search-then-inject has to happen here, on the caller's
-      // side. EGRESS: the question text goes to duckduckgo.com. Also on with
-      // OPENZOO_ASK_WEB=1; --web-results N caps the count (default 5).
-      const wantWeb = process.argv.includes('--web') || process.env.OPENZOO_ASK_WEB === '1';
-      if (wantWeb) {
-        const wi = process.argv.indexOf('--web-results');
-        const n = wi !== -1 ? Number(process.argv[wi + 1]) || 5 : 5;
-        const { webSearch, formatWebResults } = await import('../lib/websearch.js');
-        const hits = await webSearch(question, n).catch((e) => { console.error(`web search failed: ${e.message}`); return []; });
-        if (hits.length) system = (system ? system + '\n\n' : '') + formatWebResults(question, hits);
-      }
+      const system = si !== -1 ? process.argv[si + 1] : '';
       const { PayClient } = await import('../lib/pay.js');
       const { config } = await import('../lib/config.js');
       const client = new PayClient();
@@ -402,17 +389,6 @@ async function main() {
     case '-h':
       console.log(HELP);
       break;
-    case 'version':
-    case '--version':
-    case '-v':
-    case '-V': {
-      // Every installer, mise shim and shell script that probes a CLI asks
-      // this first; answering "unknown command" to it failed real installs.
-      const { readFileSync } = await import('fs');
-      const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-      console.log(pkg.version);
-      break;
-    }
     default:
       console.error(`unknown command: ${cmd}\n`);
       console.log(HELP);

package/lib/aoe.js

@@ -287,9 +287,15 @@ export async function setupAoe(argv = []) {
 
   const base = `http://localhost:${config.port}/v1`;
   if (!flags.has('--no-proxy')) {
-    if (await proxyUp(base)) {
-      console.error(`openzoo: proxy already up on ${base}`);
+    const { oursOn, packageVersion, killListen } = await import('./proxy.js');
+    if (await oursOn(config.port)) {
+      console.error(`openzoo: proxy v${packageVersion()} already on ${base}`);
     } else {
+      if (await proxyUp(base)) {
+        console.error(`openzoo: stale proxy on ${base} — stealing :${config.port}`);
+        killListen(config.port);
+        await new Promise((r) => setTimeout(r, 400));
+      }
       const { pid, logPath } = startDetachedProxy({ tunnel: flags.has('--tunnel') });
       let up = false;
       for (let i = 0; i < 40 && !up; i++) {

package/lib/cursorbackend.js

@@ -3080,6 +3080,8 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
       data.error.message = raw;
       try {
         const { withOnrampLink, isFundInstruction } = await import('./stripeOnramp.js');
+        // Settle/upstream 402s keep the real message. Whop copy-paste only
+        // when this is a genuine empty-wallet / fund-me instruction.
         if (isFundInstruction(raw)) {
           const { loadOrCreateWallet } = await import('./wallet.js');
           const w = loadOrCreateWallet();

package/lib/launch.js

@@ -190,18 +190,21 @@ export function claudeZooEnv(baseEnv = process.env, { base, port } = {}) {
  * DEFAULT is the desktop app; `--terminal` (or `-t`) runs the Claude Code CLI.
  * Both get ANTHROPIC_BASE_URL so inference pays x402.
  */
+
+
 export async function launchClaude(argv) {
-  // let, not const: startProxy can heal onto a different port and every URL
-  // below must follow the port we actually bound.
+  // NEVER hop. :8402 is the product. startProxy steals a stale listener.
   let base = `http://localhost:${config.port}/v1`;
-  // AUTO-START THE PROXY. One command should just work — if nothing is listening,
-  // boot the proxy in THIS process (it stays alive because claude runs in the
-  // foreground below), rather than making the user run `npx openzoo` first.
+  // AUTO-START THE PROXY. One command should just work — if nothing is listening
+  // (or a leftover npx cache is), boot THIS version on :8402 in this process.
   let up = false;
-  // /info, not /models — see the poll below. "Is a proxy already listening" must
-  // not be answered by an endpoint that needs the gateway, or a user whose
-  // upstream is flaky gets told to start a proxy that is already running.
-  try { up = (await fetch(`${base}/info`, { signal: AbortSignal.timeout(3000) })).ok; } catch { up = false; }
+  const { startProxy, oursOn, packageVersion } = await import('./proxy.js');
+  const mine = packageVersion();
+  if (await oursOn(config.port)) {
+    up = true;
+  } else {
+    process.stderr.write(`openzoo: claiming :${config.port} for v${mine}\n`);
+  }
   if (!up) {
     // NEVER GO SILENT DURING STARTUP. silent:true routes the proxy's own lines
     // to ~/.openzoo/proxy.log so payment receipts cannot corrupt Claude Code's
@@ -218,7 +221,6 @@ export async function launchClaude(argv) {
     tick.unref?.();
     const done = (msg) => { clearInterval(tick); process.stderr.write(`\r\x1b[2Kopenzoo: ${msg}\n`); };
     try {
-      const { startProxy } = await import('./proxy.js');
       await startProxy({ silent: true, autoTunnel: true });
     } catch (err) {
       // An exception here used to surface as an eternal spinner. Say what broke.
@@ -227,9 +229,6 @@ export async function launchClaude(argv) {
       console.error('  try: OPENZOO_NO_TUNNEL=1 npx openzoo claude   (skips the cloudflared download)');
       process.exit(1);
     }
-    // The proxy may have healed onto a different port (8402 busy). config.port
-    // is the one it ACTUALLY bound, so re-derive every URL from it — the old
-    // code kept polling the port it wished for and timed out on a live proxy.
     base = `http://localhost:${config.port}/v1`;
     // PROBE /v1/info, NOT /v1/models. `models` is PROXIED UPSTREAM, so on a
     // network with a bad path to the gateway the local proxy is listening and
@@ -580,17 +579,12 @@ export async function launchClaude(argv) {
 }
 
 export async function launchHarness(cmd, args) {
-  const base = `http://localhost:${config.port}/v1`;
-  // Fail early with a clear message rather than letting the harness spew
-  // connection errors — the #1 support question would otherwise be "why won't
-  // claude connect" when the answer is "the proxy isn't up".
-  try {
-    const r = await fetch(`${base}/models`, { signal: AbortSignal.timeout(4000) });
-    if (!r.ok) throw new Error(String(r.status));
-  } catch {
-    console.error(`openzoo: no proxy reachable at ${base}`);
-    console.error('start it first in another terminal:  npx openzoo');
-    process.exit(1);
+  let base = `http://localhost:${config.port}/v1`;
+  const { startProxy, oursOn, packageVersion } = await import('./proxy.js');
+  if (!(await oursOn(config.port))) {
+    process.stderr.write(`openzoo: claiming :${config.port} for v${packageVersion()}\n`);
+    await startProxy({ silent: true, autoTunnel: true });
+    base = `http://localhost:${config.port}/v1`;
   }
 
   const env = claudeZooEnv(process.env, { base });

package/lib/models.js

@@ -168,39 +168,9 @@ const tokensOf = (id) => id.toLowerCase().split(/[^a-z0-9.]+/).filter((t) => t &
  * the id is already servable (no rewrite), otherwise the closest zoo id.
  * OPENZOO_DEFAULT_MODEL is an explicit user override, not a fallback tier.
  */
-/**
- * UNOPENROUTER. OpenRouter is not an upstream any more (gateway, 2026-09-02):
- * every completion is bought from an x402 door, and doors publish BARE ids
- * (`grok-4.3`, `claude-sonnet-5`, `gemini-2.5-flash`). A harness that still
- * sends the OpenRouter spelling (`x-ai/grok-4.3`, `anthropic/claude-sonnet-5`)
- * is rewritten to the bare id whenever the live catalog serves that bare id.
- *
- *   OPENZOO_UNOPENROUTER=1  strip the vendor prefix ALWAYS, catalog or not
- *   OPENZOO_UNOPENROUTER=0  never strip
- *   unset                   strip when the bare id is in the catalog
- *
- * Router aliases and `openzoo-` twins are never touched: their slash is not a
- * vendor.
- */
-export function unopenrouter(requested, ids) {
-  const mode = process.env.OPENZOO_UNOPENROUTER;
-  if (mode === '0') return null;
-  const s = String(requested || '');
-  if (!s || isAutoModel(s) || /^openzoo[-/]/i.test(s)) return null;
-  const slash = s.indexOf('/');
-  if (slash <= 0) return null;
-  const bare = s.slice(slash + 1);
-  if (!bare || bare.includes('/')) return null;
-  if (mode === '1') return bare;
-  return Array.isArray(ids) && ids.includes(bare) ? bare : null;
-}
-
 export function resolveModel(requested, ids) {
   // Virtual router id — never family-match, never steal via OPENZOO_DEFAULT_MODEL.
   if (isAutoModel(requested)) return null;
-  // Vendor-prefixed OpenRouter spelling → the bare id the doors serve.
-  const bareVendor = unopenrouter(requested, ids);
-  if (bareVendor) return bareVendor;
   // Bare Anthropic / Claude Code ids are never live on Fly/OpenRouter
   // (`claude-opus-5` → 500 unknown model). Rewrite even on a catalog miss
   // or if a gateway row lists the bare name — the request must not leave

package/lib/proxy.js

@@ -13,7 +13,7 @@ import { withOnrampLink, settleFailCopy, isFundInstruction } from './stripeOnram
 import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
 import { autoContext } from './autobind.js';
-import { modelsListForRequest, isHarnessAliasId, resolveModel, quoteableRows, unopenrouter } from './models.js';
+import { modelsListForRequest, isHarnessAliasId, resolveModel, quoteableRows } from './models.js';
 
 /**
  * Quoteable catalog ids, cached 5 minutes, for the fuzzy /v1/models/<id> probe.
@@ -38,19 +38,89 @@ import { receiptUsedCogs, receiptDirectUsd, pairActualBilled } from './racesettl
 import { fetchHeaders } from './fetch.js';
 import { attachX402Proof } from './spendProof.js';
 
-/** Kill whatever is LISTEN on this port except this process. */
+/** Kill whatever is LISTEN on this port except this process.
+ *  lsof first (macOS), then fuser, then /proc (Omarchy/Arch with neither).
+ *  Every openzoo subcommand that binds :8402 goes through this. Hopping to
+ *  8403 was the second-burner bug. */
 export function killListen(port, run = execSync) {
-  try {
-    const pids = run(`lsof -nP -iTCP:${Number(port)} -sTCP:LISTEN -t`, {
-      encoding: 'utf8', timeout: 2000,
-    }).trim().split('\n').map(Number).filter((n) => Number.isInteger(n) && n > 0 && n !== process.pid);
-    for (const pid of pids) {
-      try { run(`kill ${pid}`, { stdio: 'ignore', timeout: 2000 }); } catch { /* already gone */ }
+  const n = Number(port);
+  const seen = new Set();
+  const addFrom = (out) => {
+    for (const tok of String(out || '').split(/[^\d]+/)) {
+      const pid = Number(tok);
+      if (Number.isInteger(pid) && pid > 0 && pid !== process.pid) seen.add(pid);
     }
-    return pids;
-  } catch {
-    return [];
+  };
+  const tryRun = (cmd, opts = {}) => {
+    try {
+      return run(cmd, { encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'], ...opts });
+    } catch { return ''; }
+  };
+  addFrom(tryRun(`lsof -nP -iTCP:${n} -sTCP:LISTEN -t`));
+  addFrom(tryRun(`fuser -n tcp ${n}`));
+  if (process.platform === 'linux' && seen.size === 0) {
+    addFrom(tryRun(`python3 - ${n}`, {
+      timeout: 2500,
+      input: `import os, glob, sys
+port=int(sys.argv[1]); hx=f'{port:04X}'
+inodes=set(); pids=set()
+for path in ('/proc/net/tcp','/proc/net/tcp6'):
+    try:
+        for line in open(path):
+            p=line.split()
+            if len(p)<10: continue
+            if p[1].split(':')[-1].upper()==hx: inodes.add(p[9])
+    except FileNotFoundError:
+        pass
+for fd in glob.glob('/proc/[0-9]*/fd/[0-9]*'):
+    try: t=os.readlink(fd)
+    except OSError: continue
+    if any(ino and ino!='0' and ino in t for ino in inodes):
+        try: pids.add(int(fd.split('/')[2]))
+        except (OSError, ValueError): pass
+print('\\n'.join(str(p) for p in pids if p != os.getpid()))
+`,
+    }));
+  }
+  for (const pid of seen) {
+    try { run(`kill ${pid}`, { stdio: 'ignore', timeout: 2000 }); } catch { /* already gone */ }
+    try { run(`kill -9 ${pid}`, { stdio: 'ignore', timeout: 2000 }); } catch { /* already gone */ }
   }
+  return [...seen];
+}
+
+/** This package.json version. Same one /v1/info and /v1/session publish. */
+export function packageVersion() {
+  return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+}
+
+/** True when the listener on this port is THIS openzoo version or newer.
+ *  Missing / unparseable version is stale (0.49.x answered with no version).
+ *  Older than us is stale. Newer we leave alone so we never downgrade. */
+export async function oursOn(port = config.port) {
+  const mine = packageVersion();
+  const parse = (v) => {
+    const m = String(v || '').trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+  };
+  const attachable = (theirs) => {
+    const a = parse(theirs), b = parse(mine);
+    if (!a || !b) return false;
+    for (let i = 0; i < 3; i++) {
+      if (a[i] > b[i]) return true;
+      if (a[i] < b[i]) return false;
+    }
+    return true;
+  };
+  for (const path of ['/v1/info', '/v1/session']) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${Number(port)}${path}`, { signal: AbortSignal.timeout(1500) });
+      if (!r.ok) continue;
+      const j = await r.json().catch(() => ({}));
+      if (attachable(j.version)) return true;
+    } catch { /* try next */ }
+  }
+  return false;
 }
 
 // THE SHIM IS A FACILITATOR, NOT A MIDDLEBOX.
@@ -512,8 +582,13 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           ? `${tunnelGate.publicUrl}/v1`
           : `http://localhost:${config.port}/v1`;
         res.writeHead(200, { 'content-type': 'application/json' });
+        const { version: ozVersion } = JSON.parse(
+          readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
+        );
         res.end(JSON.stringify({
           youAreTalkingTo: 'openzoo proxy',
+          version: ozVersion,
+          solana: client.address,
           yourEndpoint: self,
           reachedVia: viaTunnel ? 'public tunnel' : 'localhost',
           publicTunnel: tunnelGate?.publicUrl ? `${tunnelGate.publicUrl}/v1` : null,
@@ -622,24 +697,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       servedRequests += 1;
       say(`\n<- request #${servedRequests} from ${(req.headers['user-agent'] || 'unknown').slice(0, 40)}`);
       try { wantsStream = JSON.parse(bodyBuf.toString('utf8'))?.stream === true; } catch { /* not JSON */ }
-      // UNOPENROUTER THE MODEL ID before anything downstream sees the body —
-      // the replay key, the outage gate, the wire. A vendor-prefixed
-      // OpenRouter spelling becomes the bare id the doors serve when the
-      // catalog lists it (OPENZOO_UNOPENROUTER=1 forces it, =0 disables).
-      // This is the one place the body is rewritten; see models.js.
-      try {
-        const parsed = JSON.parse(bodyBuf.toString('utf8'));
-        if (parsed && typeof parsed.model === 'string') {
-          let ids = [];
-          try { ids = await catalogIdsCached(`${config.apiBase}/v1/models`, upstreamHeaders(req)); } catch { /* catalog unreachable: only the forced mode rewrites */ }
-          const bare = unopenrouter(parsed.model, ids);
-          if (bare) {
-            say(`   model ${parsed.model} -> ${bare} (bare id: doors, not OpenRouter)`);
-            parsed.model = bare;
-            bodyBuf = Buffer.from(JSON.stringify(parsed));
-          }
-        }
-      } catch { /* not JSON */ }
     }
 
     // Retry of a body we answered seconds ago? Serve the cached completion —
@@ -847,12 +904,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         rememberSpend();
         say(`credit -> $${x.billedUsd.toFixed(6)}  ·  session $${sessionSpent.toFixed(6)}`);
       };
-      // A 402 AFTER we attempted payment is a SETTLEMENT failure, not a quote —
-      // the client-side balance check is advisory, so a wallet that looks
-      // fundable can still fail on-chain, and the gateway answers the paid
-      // retry with a fresh 402. Relaying that raw meant Claude Code printed a
-      // half-kilobyte accepts[] blob at the user instead of the one thing they
-      // need: the price, what the wallet holds, and where to send funds.
+      // A 402 AFTER we attempted payment is a SETTLEMENT failure, not a quote.
+      // The client-side balance check is advisory, so a funded wallet can still
+      // fail on-chain / at the facilitator, and the gateway answers the paid
+      // retry with a fresh 402. Relaying that as "wallet underfunded" + Whop
+      // copy-paste blamed burners that already paid. Surface the gateway's
+      // real reason; only prepend fund-me copy on genuine insufficient_funds.
       if (response.status === 402) {
         let usd;
         let q402 = null;
@@ -874,6 +931,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           if (!Number.isFinite(usd)) usd = undefined;
         } catch { usd = undefined; }
         const copy = settleFailCopy(q402);
+        // paid:true → never "wallet underfunded", never Whop unless the
+        // gateway itself named insufficient_funds. UnderfundedError (empty
+        // wallet preflight) is handled in the catch below.
         let msg = copy.message;
         const wantOnramp = copy.code === 'insufficient_funds'
           || (!paid && isFundInstruction(copy.reason, copy));
@@ -914,11 +974,18 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // OPENZOO_BIND=0.0.0.0 AND a tunnel token, so that port stays gated exactly
   // like the public tunnel path.
   const bindHost = process.env.OPENZOO_BIND || '127.0.0.1';
-  // SELF-HEAL A TAKEN PORT. Walk up to the next free port instead of dying;
-  // the caller reads config.port back out, so every URL printed afterwards is
-  // the one we actually bound. A healthy proxy already on the port is KILLED
-  // — reusing it left a stale PayClient serving $0 after a TOKEN top-up.
-  const wanted = config.port;
+  // SELF-HEAL :8402. Kill whoever is on THIS port, then bind it. Never hop to
+  // 8403 — that was the second-burner. Every subcommand that calls startProxy
+  // (openzoo, claude, bot, web, cursor, aoe, grok, tunnel) goes through here.
+  // Reusing a leftover listener left a stale PayClient serving $0 after a
+  // TOKEN top-up, and an old npx cache answering /v1 with no version.
+  {
+    const pids = killListen(config.port);
+    if (pids.length) {
+      say(`openzoo: killed proxy on :${config.port} (pids ${pids.join(',')})`);
+      await new Promise((r) => setTimeout(r, 400));
+    }
+  }
   for (let attempt = 0; ; attempt++) {
     try {
       await new Promise((resolve, reject) => {
@@ -928,20 +995,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       });
       break;
     } catch (e) {
-      if (e?.code !== 'EADDRINUSE' || attempt >= 12) throw e;
-      if (attempt === 0) {
-        const pids = killListen(config.port);
-        if (pids.length) {
-          say(`openzoo: killed proxy on :${config.port} (pids ${pids.join(',')})`);
-          await new Promise((r) => setTimeout(r, 400));
-          continue;
-        }
-      }
-      config.port += 1;
-      say(`openzoo: :${config.port - 1} busy — trying :${config.port}`);
+      if (e?.code !== 'EADDRINUSE' || attempt >= 8) throw e;
+      const pids = killListen(config.port);
+      if (pids.length) say(`openzoo: killed proxy on :${config.port} (pids ${pids.join(',')})`);
+      await new Promise((r) => setTimeout(r, 300));
     }
   }
-  if (config.port !== wanted) say(`openzoo: listening on :${config.port} (:${wanted} was busy)`);
 
   // AUTO-PREPAY. Paying on-chain per call is where the latency lives: credit
   // is applied automatically server-side whenever a balance covers the quote,

package/lib/setup.js

@@ -214,7 +214,7 @@ async function printStartupDiagnostic(base, which) {
 
   console.log('openzoo diagnostic');
   console.log(`  version    : ${version}   node ${process.version}   ${process.platform}/${process.arch}`);
-  console.log(`  port ${config.port}  : ${portBusy ? 'ALREADY SERVING (an older proxy may still be running — kill it if this build is newer)' : 'free'}`);
+  console.log(`  port ${config.port}  : ${portBusy ? 'occupied (steal unless this exact version)' : 'free'}`);
   console.log(`  editor     : ${picked ? `${picked.which} @ ${picked.cmd}` : 'NONE FOUND'}`);
   console.log(`  running    : ${picked ? (q(() => editorRunning(picked.which), false) ? 'yes — will be quit so settings stick' : 'no') : '-'}`);
   console.log(`  backend    : ${hosts}`);
@@ -245,9 +245,17 @@ export async function setupEditor(which, target) {
   // Declared out here: the tunnel-rebind hook is registered further down, well
   // outside the block that starts the proxy.
   let started = null;
-  if (!(await proxyUp(base))) {
-    console.log(`starting proxy on ${base} (+ public tunnel)...`);
-    const { startProxy } = await import('./proxy.js');
+  const { startProxy, oursOn, packageVersion } = await import('./proxy.js');
+  if (await oursOn(config.port)) {
+    console.log(`proxy v${packageVersion()} already on ${base} — keeping it`);
+    try {
+      const info = await (await fetch(`${base}/info`)).json();
+      publicUrl = (info?.publicTunnel || '').replace(/\/v1$/, '') || null;
+      tunnelKey = info?.tunnelToken ?? tunnelKey;
+      if (publicUrl) console.log(`tunnel:  ${publicUrl}/v1 (from the running proxy)`);
+    } catch { /* no /info */ }
+  } else {
+    console.log(`${(await proxyUp(base)) ? 'stale proxy — stealing' : 'starting proxy on'} ${base} (+ public tunnel)...`);
     started = await startProxy({ silent: true, autoTunnel: true });
     publicUrl = started?.publicUrl ?? null;
     tunnelKey = started?.tunnelToken ?? null;
@@ -298,15 +306,6 @@ export async function setupEditor(which, target) {
       console.log('         most common cause here: no working IPv6 route (we already force');
       console.log('         --edge-ip-version 4). check: npx openzoo tunnel   for the raw log.');
     }
-  } else {
-    console.log(`proxy already running on ${base}`);
-    // A proxy someone else started owns the tunnel; ask it for the public URL.
-    try {
-      const info = await (await fetch(`${base}/info`)).json();
-      publicUrl = (info?.publicTunnel || '').replace(/\/v1$/, '') || null;
-      tunnelKey = info?.tunnelToken ?? tunnelKey;
-      if (publicUrl) console.log(`tunnel:  ${publicUrl}/v1 (from the running proxy)`);
-    } catch { /* no /info — fall through to the localhost warning below */ }
   }
   // What the EDITOR is configured with. Localhost only as a last resort, and
   // said out loud, because it will fail with the private-networks error.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openzoo",
-  "version": "0.50.90",
-  "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 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.",
+  "version": "0.50.92",
+  "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",
   "bin": {

package/lib/websearch.js

@@ -1,31 +0,0 @@
-// Keyless web search for `openzoo ask --web`: DuckDuckGo's HTML endpoint,
-// scraped for title / url / snippet. No API key, no account, one GET. The
-// only thing that leaves is the question text, to duckduckgo.com.
-const strip = (s) => String(s || '')
-  .replace(/<[^>]+>/g, '')
-  .replace(/&amp;/g, '&').replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&lt;/g, '<').replace(/&gt;/g, '>')
-  .replace(/\s+/g, ' ').trim();
-
-export async function webSearch(query, max = 5) {
-  const res = await fetch('https://html.duckduckgo.com/html/?q=' + encodeURIComponent(query), {
-    headers: { 'user-agent': 'Mozilla/5.0 openzoo-ask/1.0' },
-    signal: AbortSignal.timeout(12_000),
-  });
-  if (!res.ok) throw new Error(`duckduckgo HTTP ${res.status}`);
-  const html = await res.text();
-  const out = [];
-  const re = /<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
-  let m;
-  while ((m = re.exec(html)) && out.length < Math.max(1, Math.min(10, max))) {
-    let url = m[1];
-    const redirected = url.match(/uddg=([^&]+)/);
-    if (redirected) url = decodeURIComponent(redirected[1]);
-    out.push({ title: strip(m[2]), url, snippet: strip(m[3]).slice(0, 400) });
-  }
-  return out;
-}
-
-export function formatWebResults(query, hits) {
-  const lines = hits.map((h, i) => `${i + 1}. ${h.title} — ${h.url}\n   ${h.snippet}`);
-  return `Web search results for "${query}" (DuckDuckGo, fetched just now; cite the url when you rely on one):\n${lines.join('\n')}`;
-}