openzoo 0.50.89 → 0.50.91

package/lib/cursorbackend.js

@@ -3075,17 +3075,20 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
     if (r.status === 402) {
       const raw = zooTextFromMessage(data?.choices?.[0]?.message, data)
         || data?.error?.message
-        || 'openzoo wallet underfunded.';
+        || 'openzoo payment required (HTTP 402).';
+      data.error = data.error || {};
+      data.error.message = raw;
       try {
-        const { withOnrampLink } = await import('./stripeOnramp.js');
-        const { loadOrCreateWallet } = await import('./wallet.js');
-        const w = loadOrCreateWallet();
-        const usd = Number(String(raw).match(/≈\$([0-9.]+)/)?.[1]);
-        data.error = data.error || {};
-        data.error.message = await withOnrampLink(raw, {
-          solana: w.keypair.publicKey.toBase58(),
-          usd,
-        });
+        const { withOnrampLink, isFundInstruction } = await import('./stripeOnramp.js');
+        if (isFundInstruction(raw)) {
+          const { loadOrCreateWallet } = await import('./wallet.js');
+          const w = loadOrCreateWallet();
+          const usd = Number(String(raw).match(/≈\$([0-9.]+)/)?.[1]);
+          data.error.message = await withOnrampLink(raw, {
+            solana: w.keypair.publicKey.toBase58(),
+            usd,
+          });
+        }
       } catch { /* keep proxy copy */ }
     }
     return { r, data };

package/lib/launch.js

@@ -9,7 +9,7 @@
  * harness with the two env vars set. The proxy must already be running
  * (`npx openzoo` in another terminal); we check first and say so if not.
  */
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn, spawnSync, execSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -190,6 +190,41 @@ 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.
  */
+
+/** Omarchy often has no lsof. Kill whatever is bound to the proxy port. */
+function killPort(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 { /* tool missing */ }
+  }
+  // /proc fallback — no lsof/fuser required (Omarchy).
+  try {
+    execSync(`python3 - ${n}`, {
+      stdio: 'ignore', timeout: 2500, input: `import os, glob, sys
+port=int(sys.argv[1]); hx=f'{port:04X}'
+inodes=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: os.kill(int(fd.split('/')[2]), 9)
+        except OSError: pass
+`,
+    });
+  } catch { /* no python or not linux */ }
+}
+
 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.
@@ -201,7 +236,22 @@ export async function launchClaude(argv) {
   // /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 mine = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+  try {
+    const r = await fetch(`${base}/info`, { signal: AbortSignal.timeout(3000) });
+    if (r.ok) {
+      const info = await r.json().catch(() => ({}));
+      const theirs = String(info.version || '');
+      if (!theirs || theirs !== mine) {
+        process.stderr.write(`openzoo: replacing stale proxy ${theirs ? 'v'+theirs : '(no version)'} with v${mine} on :${config.port}\n`);
+        killPort(config.port);
+        await new Promise((ok) => setTimeout(ok, 300));
+        up = false;
+      } else {
+        up = true;
+      }
+    }
+  } catch { up = false; }
   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

package/lib/proxy.js

@@ -9,11 +9,11 @@ import {
 } from './config.js';
 import { execSync } from 'node:child_process';
 import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
-import { withOnrampLink } from './stripeOnramp.js';
+import { withOnrampLink, settleFailCopy, isFundInstruction } from './stripeOnramp.js';
 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.
@@ -512,8 +512,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 +627,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,14 +834,13 @@ 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 quoted = '';
         let usd;
         let q402 = null;
         try { q402 = await response.clone().json(); } catch { q402 = null; }
@@ -871,18 +857,21 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           return;
         }
         try {
-          const q = q402;
-          usd = Number(q?.accepts?.[0]?.extra?.billedUsd);
-          if (Number.isFinite(usd)) quoted = ` This call needs ≈$${usd.toFixed(4)}.`;
-        } catch { /* body was not the quote after all */ }
-        const msg = await withOnrampLink(
-          `openzoo wallet underfunded — payment did not settle.${quoted} `
-          + `Fund it and retry: send USDC (or TOKEN/LEOS for half price) to ${client.address} on Solana, `
-          + `or USDC to ${client.evmAddress} on Base. Check with: openzoo balance`,
-          { solana: client.address, usd },
-        );
-        log(/ties to your account/i.test(msg) ? 'onramp: whop + copy-paste solana' : 'onramp: no fund blurb');
-        jsonErr(res, 402, msg);
+          usd = Number(q402?.accepts?.[0]?.extra?.billedUsd);
+          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));
+        if (wantOnramp) {
+          msg = await withOnrampLink(msg, { solana: client.address, usd, code: copy.code });
+        }
+        log(/ties to your account/i.test(msg) ? 'onramp: whop + copy-paste solana' : `402: ${msg.slice(0, 140)}`);
+        jsonErr(res, paid ? copy.status : 402, msg);
         return;
       }
       await relay(res, response, meterStreamed);

package/lib/stripeOnramp.js

@@ -103,8 +103,58 @@ export function whopFundBlurb(solana) {
   ].join('\n');
 }
 
+/**
+ * Genuine empty-wallet / fund-me copy. A post-pay settle failure
+ * ("payment did not settle" with a gateway reason and no underfunded
+ * wording) is NOT this — those wallets are often funded; the 402 is
+ * the facilitator or upstream.
+ */
+export function isFundInstruction(text, extra = {}) {
+  const code = extra.code ?? extra.advice?.code;
+  if (String(code || '') === 'insufficient_funds') return true;
+  const s = String(text || '');
+  if (!s) return false;
+  if (/\b(?:wallet underfunded|empty wallet|wallet is empty|needs more than the wallet holds|insufficient[_\s]funds)\b/i.test(s)) return true;
+  if (/\bunderfunded\b/i.test(s)) return true;
+  if (/\bsend (?:usdc|a few cents)\b/i.test(s)) return true;
+  if (/\bno offered payment row is affordable/i.test(s)) return true;
+  return false;
+}
+
+function gatewayReason(q402) {
+  if (!q402 || typeof q402 !== 'object') return '';
+  const err = q402.error;
+  const advice = q402.advice;
+  if (typeof err?.message === 'string' && err.message.trim()) return err.message.trim();
+  if (typeof err === 'string' && err.trim()) return err.trim();
+  if (typeof advice?.message === 'string' && advice.message.trim()) return advice.message.trim();
+  if (typeof advice === 'string' && advice.trim()) return advice.trim();
+  if (advice && typeof advice === 'object') {
+    const bits = [advice.code, advice.reason, advice.detail].filter((x) => typeof x === 'string' && x.trim());
+    if (bits.length) return bits.join(': ');
+  }
+  return '';
+}
+
+/**
+ * Copy for a 402 AFTER PayClient already signed and retried (paid:true).
+ * Never "wallet underfunded" — that string is reserved for preflight
+ * empty-wallet errors. Prefix stays greppable as "payment did not settle".
+ */
+export function settleFailCopy(q402) {
+  const reason = gatewayReason(q402);
+  const code = q402?.advice?.code || q402?.error?.code || '';
+  const fund = isFundInstruction(reason, { code, advice: q402?.advice });
+  const message = reason
+    ? `openzoo payment did not settle: ${reason}`
+    : 'openzoo payment did not settle';
+  const upstreamish = /upstream|facilitator|internal(?: server)? error|settle(?:ment)? (?:failed|error)/i.test(reason) && !fund;
+  return { message, status: upstreamish ? 502 : 402, fund, reason, code: String(code || '') };
+}
+
 export async function withOnrampLink(text, dest) {
   const body = String(text || '').trim();
+  if (!isFundInstruction(body, dest)) return body;
   const blurb = whopFundBlurb(dest?.solana);
   if (!blurb) return body;
   if (/ties to your account/i.test(body) && body.includes(String(dest.solana))) return body;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openzoo",
-  "version": "0.50.89",
-  "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.",
+  "version": "0.50.91",
+  "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.",
   "license": "MIT",
   "type": "module",
   "bin": {