openzoo 0.7.2 → 0.8.0

package/bin/openzoo.js

@@ -4,10 +4,10 @@ const cmd = process.argv[2] || 'proxy';
 const HELP = `openzoo — local x402-paying proxy + MCP server for openzoo.fun
 
 usage:
-  npx openzoo            start the proxy on http://localhost:8402/v1
+  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 mcp        stdio MCP server (tools: zoo_ask, zoo_models, zoo_wallet)
-  npx openzoo tunnel     public HTTPS url for cloud IDEs that cannot reach localhost
-                         (installs cloudflared itself; mints a required api key)
+  npx openzoo tunnel     public-url-only mode (everything key-gated, no keyless localhost)
   npx openzoo demo       ~1M-token needle demo: direct refuses, the zoo answers
                          (run it twice — the second run reuses the bound corpus and is near-free)
   npx openzoo contexts   list corpora bound to the zoo (never re-uploaded)
@@ -35,13 +35,14 @@ env:
   OPENZOO_NO_CONTEXT_CACHE (0 — set 1 to always ship the full body)
   OPENZOO_ENABLE_RH (0 — let DEFAULT selection fall through to the Robinhood rail;
                      OPENZOO_RAIL=robinhood forces it without this)
-  OPENZOO_TUNNEL_MAX_USD (1.00 — tunnel session ceiling)  OPENZOO_TUNNEL_TOKEN (pin the api key)`;
+  OPENZOO_TUNNEL_MAX_USD (1.00 — public-url session ceiling)  OPENZOO_TUNNEL_TOKEN (pin the api key)
+  OPENZOO_NO_TUNNEL (0 — set 1 for localhost-only, no public url)`;
 
 async function main() {
   switch (cmd) {
     case 'proxy':
     case 'start':
-      await (await import('../lib/proxy.js')).startProxy();
+      await (await import('../lib/proxy.js')).startProxy({ autoTunnel: true });
       break;
     case 'mcp':
       await (await import('../lib/mcp.js')).startMcp();

package/lib/proxy.js

@@ -110,13 +110,23 @@ async function maybeCacheCorpus(req, bodyBuf, log) {
  * becomes the only thing between a stranger and your wallet. Both are off by
  * default, so localhost behaviour is unchanged.
  */
-export async function startProxy({ silent = false, requireToken = null, sessionMaxUsd = null } = {}) {
+export async function startProxy({ silent = false, requireToken = null, sessionMaxUsd = null, autoTunnel = false } = {}) {
   const client = new PayClient();
   const log = silent ? () => {} : (...a) => console.log(...a);
   let sessionSpent = 0;
+  let tunnelSpent = 0;
+  // Set once cloudflared is up (see below). Gating keys off the REQUEST's
+  // origin, not off whether the URL exists yet, so there is no startup window
+  // where public traffic slips through ungated.
+  let tunnelGate = null;
 
   const server = http.createServer(async (req, res) => {
     const url = `${config.apiBase}${req.url}`;
+    // Requests that arrived over the public quick-tunnel URL carry cloudflared's
+    // headers; nothing dialing 127.0.0.1 directly does. That distinction is what
+    // lets localhost stay keyless while the SAME port is safely public.
+    const viaTunnel = !requireToken && tunnelGate
+      && Boolean(req.headers['cf-connecting-ip'] || req.headers['cf-ray']);
     // Auth first: refuse before reading a body, forwarding, quoting or paying.
     if (requireToken) {
       const got = (req.headers.authorization || '').replace(/^Bearer\s+/i, '').trim();
@@ -130,6 +140,18 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         return;
       }
     }
+    if (viaTunnel) {
+      const got = (req.headers.authorization || '').replace(/^Bearer\s+/i, '').trim();
+      if (got !== tunnelGate.token) {
+        log(`public url: 401 ${req.method} ${req.url}`);
+        jsonErr(res, 401, 'unauthorized: this openzoo public URL requires the api key printed at startup');
+        return;
+      }
+      if (tunnelSpent >= tunnelGate.sessionMaxUsd) {
+        jsonErr(res, 402, `openzoo public-URL session cap reached ($${tunnelGate.sessionMaxUsd}) — restart the proxy or raise OPENZOO_TUNNEL_MAX_USD`);
+        return;
+      }
+    }
     let bodyBuf;
     try {
       bodyBuf = await readBody(req);
@@ -175,11 +197,17 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       }
       const { response, paid, receipt } = result;
       if (paid && receipt) {
-        if (receipt.ok && typeof receipt.billedUsd === 'number') sessionSpent += receipt.billedUsd;
+        if (receipt.ok && typeof receipt.billedUsd === 'number') {
+          sessionSpent += receipt.billedUsd;
+          // The public-URL ceiling meters only public-origin spend — your own
+          // local calls never eat into it.
+          if (viaTunnel) tunnelSpent += receipt.billedUsd;
+        }
         const line = receipt.ok ? receipt.line : `paid retry -> HTTP ${receipt.status}`;
-        // In tunnel mode the running total is the thing you actually want to
-        // watch, so it rides on every receipt.
-        log(requireToken ? `${line}  ·  session $${sessionSpent.toFixed(6)}` : line);
+        // Wherever a running total is the thing to watch, it rides the receipt.
+        if (requireToken) log(`${line}  ·  session $${sessionSpent.toFixed(6)}`);
+        else if (viaTunnel) log(`${line}  ·  public-url session $${tunnelSpent.toFixed(6)}`);
+        else log(line);
       }
       await relay(res, response);
     } catch (err) {
@@ -252,5 +280,35 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     console.log(`  base_url = http://localhost:${config.port}/v1`);
     console.log('  api_key  = sk-openzoo   (any value works; the zoo takes payment, not keys)');
   }
+
+  // AUTO-TUNNEL: `npx openzoo` must be end-to-end for cloud IDEs too — their
+  // servers cannot dial localhost, so the default command also publishes a
+  // quick-tunnel URL. It comes up in the background (never delays localhost),
+  // failure degrades to local-only, and public traffic is gated above by
+  // token + its own spend ceiling. OPENZOO_NO_TUNNEL=1 opts out.
+  if (autoTunnel && process.env.OPENZOO_NO_TUNNEL !== '1') {
+    (async () => {
+      try {
+        const { ensureCloudflared, startCloudflared, mintToken } = await import('./tunnel.js');
+        const token = mintToken();
+        const cap = Number(process.env.OPENZOO_TUNNEL_MAX_USD || 1);
+        const bin = await ensureCloudflared((m) => log(m));
+        const { url, proc } = await startCloudflared(bin, config.port, log);
+        tunnelGate = { token, sessionMaxUsd: cap };
+        const bye = () => { try { proc.kill('SIGTERM'); } catch { /* already gone */ } };
+        process.once('SIGINT', () => { bye(); process.exit(0); });
+        process.once('SIGTERM', () => { bye(); process.exit(0); });
+        process.once('exit', bye);
+        log('');
+        log('cloud IDE / remote harness? use the public URL (they cannot reach localhost):');
+        log(`  base_url = ${url}/v1`);
+        log(`  api_key  = ${token}`);
+        log(`  (key REQUIRED on the public URL — it spends this wallet; capped at $${cap.toFixed(2)}/session,`);
+        log('   OPENZOO_TUNNEL_MAX_USD to change, OPENZOO_NO_TUNNEL=1 for localhost-only)');
+      } catch (err) {
+        log(`public URL unavailable (${err.message}) — localhost still works; OPENZOO_NO_TUNNEL=1 hides this line`);
+      }
+    })();
+  }
   return { server, client, spent: () => sessionSpent };
 }

package/package.json

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