openzoo 0.21.3 → 0.21.5

package/lib/proxy.js

@@ -285,7 +285,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // origin, not off whether the URL exists yet, so there is no startup window
   // where public traffic slips through ungated.
   let tunnelGate = null;
-  const rebindHooks = [];
   let tunnelError = null;
 
   const server = http.createServer(async (req, res) => {
@@ -731,21 +730,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   if (autoTunnel && process.env.OPENZOO_NO_TUNNEL !== '1') {
     (async () => {
       try {
-        const { ensureCloudflared, startHealthyTunnel, superviseTunnel, mintToken } = await import('./tunnel.js');
+        const { ensureCloudflared, startCloudflared, mintToken } = await import('./tunnel.js');
         const token = mintToken();
         const cap = process.env.OPENZOO_TUNNEL_MAX_USD ? Number(process.env.OPENZOO_TUNNEL_MAX_USD) : Infinity;
         const bin = await ensureCloudflared((m) => log(m));
-        // VERIFIED, not merely printed — and supervised, because a quick tunnel
-        // that dies leaves every configured client reconnect-looping at a dead host.
-        const { url, proc } = await startHealthyTunnel(bin, config.port, log);
+        const { url, proc } = await startCloudflared(bin, config.port, log);
         tunnelGate = { token, sessionMaxUsd: cap, publicUrl: url };
-        superviseTunnel({
-          bin, port: config.port, url, proc, log,
-          onRebind: async (next) => {
-            tunnelGate.publicUrl = next;                 // /v1/info and callers follow
-            for (const fn of rebindHooks) { try { await fn(next); } catch { /* advisory */ } }
-          },
-        });
         const bye = () => { try { proc.kill('SIGTERM'); } catch { /* already gone */ } };
         process.once('SIGINT', () => { bye(); process.exit(0); });
         process.once('SIGTERM', () => { bye(); process.exit(0); });
@@ -775,8 +765,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     spent: () => sessionSpent,
     get publicUrl() { return tunnelGate?.publicUrl ?? null; },
     get tunnelToken() { return tunnelGate?.token ?? null; },
-    /** Called with the new public URL whenever the tunnel self-heals. */
-    onTunnelRebind(fn) { rebindHooks.push(fn); },
     get tunnelError() { return tunnelError; },
   };
 }

package/lib/setup.js

@@ -195,17 +195,24 @@ export async function setupEditor(which, target) {
     // cannot reach localhost), but we already have a rebind hook that rewrites
     // and re-pins the config the moment a URL exists, so the honest design is:
     // launch now with what we have, and follow the tunnel in when it arrives.
+    // BOUNDED WAIT, THEN LAUNCH REGARDLESS. The editor's server cannot reach
+    // localhost, so the public URL is what belongs in its config — but an
+    // unbounded wait is how this command ended up sitting on
+    // "waiting for the public tunnel....." and never opening the editor at all.
+    // With --edge-ip-version 4 the tunnel comes up in seconds; if it somehow
+    // does not, we say so plainly and still launch.
     if (!publicUrl) {
-      // A couple of seconds only, in case it is already up — then move on.
-      for (let i = 0; i < 6 && !started?.publicUrl; i++) {
+      process.stdout.write('waiting for the public tunnel');
+      for (let i = 0; i < 180 && !started?.publicUrl; i++) {    // up to 90s
         await new Promise((r) => setTimeout(r, 500));
+        if (i % 4 === 3) process.stdout.write('.');
       }
+      console.log('');
       publicUrl = started?.publicUrl ?? null;
       tunnelKey = started?.tunnelToken ?? tunnelKey;
     }
     if (publicUrl) console.log(`tunnel:  ${publicUrl}/v1   api_key ${tunnelKey}`);
-    else console.log('tunnel:  still coming up — launching now; the editor config is\n'
-      + '         rewritten and re-pinned automatically the moment it is ready.');
+    else console.log('tunnel:  did not come up in 90s.');
   } else {
     console.log(`proxy already running on ${base}`);
     // A proxy someone else started owns the tunnel; ask it for the public URL.
@@ -218,8 +225,13 @@ export async function setupEditor(which, target) {
   }
   // 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.
-  const editorBase = publicUrl ? `${publicUrl}/v1` : base;
-  if (!publicUrl) console.log('settings: falling back to localhost — expect "Access to private networks is forbidden"');
+  // NEVER WRITE LOCALHOST INTO THE EDITOR. Its server makes the request, so a
+  // private address is unreachable from there and every call returns "Access to
+  // private networks is forbidden". Writing it anyway does not degrade
+  // gracefully — it overwrites a config that may have been working with one
+  // that provably cannot. With no tunnel we leave the existing settings alone
+  // and say why.
+  const editorBase = publicUrl ? `${publicUrl}/v1` : null;
 
   // 2. ENV INTO THE EDITOR. Both vendor shapes, so an OpenAI-compatible pane
   //    and an Anthropic-shaped one (Claude Code extension) both route here.
@@ -247,6 +259,12 @@ export async function setupEditor(which, target) {
   // globalStorage sqlite — not an encrypted store, as previously assumed — so
   // the "paste four things into Settings" ritual is unnecessary. Must happen
   // while the editor is CLOSED or it rewrites them from memory on exit.
+  if (!editorBase) {
+    console.log('settings: NOT touched — a tunnel is required for the editor path and none came up.');
+    console.log('          (localhost cannot work here: the editor calls the endpoint from ITS server,');
+    console.log('           which answers "Access to private networks is forbidden".)');
+    console.log('          your previous settings are left as they were — re-run when the network settles.');
+  }
   const picked0 = pickEditor(which);
   const target0 = picked0?.which || which || 'cursor';
   // Quit it FOR the user — a running editor reverts our write on exit.
@@ -257,7 +275,9 @@ export async function setupEditor(which, target) {
   }
   const models = await catalogModels(base);
   let wrote = null;
-  try { wrote = writeEditorProviderConfig(target0, { baseUrl: editorBase, models, apiKey: tunnelKey }); } catch (e) { wrote = { error: e.message }; }
+  if (editorBase) {
+    try { wrote = writeEditorProviderConfig(target0, { baseUrl: editorBase, models, apiKey: tunnelKey }); } catch (e) { wrote = { error: e.message }; }
+  }
   if (wrote?.error) {
     console.log(`settings: could not write automatically (${wrote.error}) — set them in Settings → Models`);
   } else if (wrote) {
@@ -271,23 +291,6 @@ export async function setupEditor(which, target) {
       ? '          pinned        -> yes (the editor re-syncs these from its account; a DB trigger re-applies them)'
       : `          pinned        -> NO (${pin?.error || 'unavailable'}) — the editor may revert these on launch`);
     console.log('  verify: send one message, watch for "paid $0.0… · rail solana · tx …" here.');
-    // FOLLOW THE TUNNEL. A quick tunnel is ephemeral; when it dies the proxy
-    // brings up a new one with a NEW hostname, and an editor still holding the
-    // old URL reconnect-loops against a dead host forever (measured: cloudflare
-    // 530 / error 1033 on every request). Re-write and re-pin on every rebind so
-    // the editor follows without the user restarting anything.
-    started?.onTunnelRebind?.(async (next) => {
-      const base2 = `${next}/v1`;
-      try {
-        unpinEditorProviderConfig(target0);
-        writeEditorProviderConfig(target0, { baseUrl: base2, models, apiKey: tunnelKey });
-        pinEditorProviderConfig(target0, { baseUrl: base2, models });
-        console.log(`\nsettings: tunnel healed — openAIBaseUrl -> ${base2}`);
-        console.log('          (reload the editor window if a request was in flight)');
-      } catch (e) {
-        console.log(`\nsettings: tunnel healed to ${base2} but the config rewrite failed (${e.message})`);
-      }
-    });
   }
 
   // 2b. THE BACKEND BLOCK. Pinning the database is not sufficient on its own:

package/lib/tunnel.js

@@ -91,117 +91,18 @@ export async function ensureCloudflared(log = console.log) {
   return cached;
 }
 
-/**
- * TUNNEL RUNGS, tried in order until one actually SERVES.
- *
- * MEASURED FAILURE: cloudflared came up, printed a URL, and held a single IPv6
- * socket to :443 with NO connection on 7844 — registration never completed — so
- * the edge answered every request with 530 / error 1033 "unable to reach origin"
- * while the process looked perfectly healthy. The URL had already been written
- * into the editor, which then reconnect-looped forever against a dead host.
- *
- * Two lessons, both encoded below: a printed URL is NOT a working tunnel (probe
- * it), and the default QUIC/auto-edge path can fail in a way that a different
- * edge-IP or protocol survives — so cascade instead of giving up.
- */
-const TUNNEL_RUNGS = [
-  // IPv4 FIRST, deliberately. cloudflared prefers IPv6+QUIC to reach the edge
-  // whenever the interface merely HAS an IPv6 address — it never checks the
-  // route is usable. MEASURED on a box with an IPv6 address and no IPv6 route:
-  //   failed to dial to edge with quic: write udp6 [::]->[2606:4700:a8::1]:7844:
-  //   sendmsg: no route to host
-  // ...on every retry, so the tunnel registered and immediately died and the
-  // edge served 502/530 — which looks exactly like a dead origin or a rate
-  // limit, and is neither. Forcing v4 registered first try on the same machine.
-  { args: ['--edge-ip-version', '4'], why: 'ipv4 edge' },
-  { args: [], why: 'default (quic, auto edge ip)' },
-  { args: ['--edge-ip-version', '4', '--protocol', 'http2'], why: 'ipv4 + http2' },
-  { args: ['--protocol', 'http2'], why: 'http2 (quic/udp blocked or lossy)' },
-];
-
-/**
- * Does this public URL actually reach OUR proxy? A 200 from /v1/models is proof
- * end to end; 530/1033 is the edge saying it cannot reach the origin. Retries
- * because a fresh tunnel takes a few seconds to propagate.
- */
-export async function probeTunnel(url, { tries = 8, gapMs = 2500 } = {}) {
-  for (let i = 0; i < tries; i++) {
-    try {
-      const r = await fetch(`${url}/v1/models`, { signal: AbortSignal.timeout(10000) });
-      if (r.ok) return true;
-    } catch { /* not up yet */ }
-    if (i < tries - 1) await new Promise((r) => setTimeout(r, gapMs));
-  }
-  return false;
-}
-
-/**
- * Bring up a tunnel that is VERIFIED to serve, walking the rungs above.
- * Returns { url, proc, rung } or throws when every rung fails.
- */
-export async function startHealthyTunnel(bin, port, log = () => {}) {
-  // ONE AT A TIME, best rung first. An earlier version raced all four at once;
-  // that is four quick tunnels per invocation against a per-IP-limited free
-  // service, which is a good way to get throttled into exactly the failure it
-  // was meant to dodge. Rung 1 (ipv4) is the measured winner on this network,
-  // so the common path costs one tunnel.
-  let lastErr = null;
-  for (const rung of TUNNEL_RUNGS) {
-    let started = null;
-    try {
-      started = await startCloudflared(bin, port, log, { args: rung.args });
-    } catch (e) { lastErr = e; log(`tunnel: ${rung.why} — ${e.message}`); continue; }
-    if (await probeTunnel(started.url, { tries: 5, gapMs: 2000 })) {
-      log(`tunnel: up via ${rung.why}`);
-      return { ...started, rung: rung.why };
-    }
-    log(`tunnel: ${rung.why} registered but the edge could not reach it — next`);
-    try { started.proc.kill(); } catch { /* already gone */ }
-    lastErr = new Error(`${rung.why}: edge could not reach the origin`);
-  }
-  throw lastErr || new Error('no cloudflared configuration produced a working tunnel');
-}
-
-/**
- * Watch a live tunnel and rebuild it when it dies. Quick tunnels are ephemeral;
- * when one drops, the editor is left pointed at a dead host and reconnect-loops,
- * so onRebind is how the caller re-writes the new URL wherever it was published.
- * Returns a stop() function.
- */
-export function superviseTunnel({ bin, port, url, proc, log = () => {}, onRebind, everyMs = 30000 }) {
-  let current = { url, proc };
-  let stopped = false;
-  let healing = false;
-  const timer = setInterval(async () => {
-    if (stopped || healing) return;
-    // One quick probe; a single blip is not a death sentence.
-    if (await probeTunnel(current.url, { tries: 2, gapMs: 3000 })) return;
-    healing = true;
-    log('tunnel: went unreachable — self-healing');
-    try { current.proc?.kill(); } catch { /* already gone */ }
-    try {
-      const next = await startHealthyTunnel(bin, port, log);
-      current = { url: next.url, proc: next.proc };
-      log(`tunnel: healed -> ${next.url}`);
-      await onRebind?.(next.url);
-    } catch (e) {
-      log(`tunnel: could not heal (${e.message}) — localhost is unaffected; will retry`);
-    } finally { healing = false; }
-  }, everyMs);
-  timer.unref?.();
-  return () => { stopped = true; clearInterval(timer); };
-}
-
 /** Start a quick tunnel to localhost:<port>; resolve with its public URL. */
-export function startCloudflared(bin, port, log, { args = [] } = {}) {
+export function startCloudflared(bin, port, log) {
   return new Promise((resolve, reject) => {
-    // 127.0.0.1, NOT localhost. MEASURED: the proxy binds IPv4 only, while
-    // `localhost` resolves to ::1 FIRST on macOS — cloudflared dialled the IPv6
-    // loopback, got connection-refused, and reported "Unable to reach the origin
-    // service" (502) on a tunnel that had registered with Cloudflare perfectly.
-    // Every rung failed identically, which is what made it look like a network
-    // or rate-limit problem when it was a loopback address-family mismatch.
-    const proc = spawn(bin, ['tunnel', '--url', `http://127.0.0.1:${port}`, '--no-autoupdate', ...args], {
+    // --edge-ip-version 4: cloudflared prefers IPv6+QUIC to reach the edge
+    // whenever the interface merely HAS an IPv6 address — it never checks the
+    // route works. MEASURED here (address present, no route):
+    //   failed to dial to edge with quic: write udp6 [::]->[2606:4700:a8::1]:7844:
+    //   sendmsg: no route to host
+    // ...every retry, so the tunnel registered then died and the edge served
+    // 502/530 — which reads exactly like a dead origin or a rate limit, and is
+    // neither. Forcing v4 registered first try on the same machine.
+    const proc = spawn(bin, ['tunnel', '--url', `http://localhost:${port}`, '--no-autoupdate', '--edge-ip-version', '4'], {
       stdio: ['ignore', 'pipe', 'pipe'],
     });
     let settled = false;
@@ -213,8 +114,7 @@ export function startCloudflared(bin, port, log, { args = [] } = {}) {
     proc.stderr.on('data', scan); // cloudflared prints the URL on stderr
     proc.on('error', reject);
     proc.on('exit', (c) => { if (!settled) reject(new Error(`cloudflared exited ${c} before printing a URL`)); });
-    const urlWaitMs = Number(process.env.OPENZOO_TUNNEL_URL_WAIT_MS || 25000);
-    setTimeout(() => { if (!settled) { try { proc.kill(); } catch { /* gone */ } reject(new Error(`cloudflared did not produce a URL in ${urlWaitMs}ms`)); } }, urlWaitMs);
+    setTimeout(() => { if (!settled) reject(new Error('cloudflared did not produce a URL in 60s')); }, 60000);
   });
 }
 

package/package.json

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