openzoo 0.21.0 → 0.21.1

package/lib/setup.js

@@ -190,7 +190,7 @@ export async function setupEditor(which, target) {
     // an unbounded wait once left the editor never launching at all.
     if (!publicUrl) {
       process.stdout.write('waiting for the public tunnel (the editor\'s server cannot reach localhost)');
-      for (let i = 0; i < 120 && !started?.publicUrl; i++) {   // up to 60s
+      for (let i = 0; i < 240 && !started?.publicUrl; i++) {   // up to 120s (rungs race; first to SERVE wins)
         await new Promise((r) => setTimeout(r, 500));
         if (i % 4 === 3) process.stdout.write('.');
       }

package/lib/tunnel.js

@@ -132,22 +132,33 @@ export async function probeTunnel(url, { tries = 8, gapMs = 2500 } = {}) {
  * Returns { url, proc, rung } or throws when every rung fails.
  */
 export async function startHealthyTunnel(bin, port, log = () => {}) {
-  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)) {
-      log(`tunnel: up via ${rung.why}`);
-      return { ...started, rung: rung.why };
-    }
-    // Printed a URL but never served — kill it before trying the next rung, or
-    // the dead process keeps holding the port's tunnel slot.
-    log(`tunnel: ${rung.why} printed ${started.url} but the edge could not reach it — next`);
-    try { started.proc.kill(); } catch { /* already gone */ }
+  // RACE, DO NOT WALK. Tried serially, four rungs cost up to 60s waiting for a
+  // URL plus ~20s of probing EACH — minutes of "waiting for the public tunnel"
+  // before the good one is even attempted, and the caller times out first.
+  // Quick tunnels are free and independent, so all rungs are started at once and
+  // the first one that actually SERVES wins; the losers are killed. Worst case
+  // becomes one rung's latency instead of four.
+  const losers = [];
+  let settled = false;
+  const attempts = TUNNEL_RUNGS.map(async (rung) => {
+    const started = await startCloudflared(bin, port, log, { args: rung.args });
+    losers.push(started.proc);
+    const ok = await probeTunnel(started.url, { tries: 6, gapMs: 2000 });
+    if (!ok) throw new Error(`${rung.why}: printed ${started.url} but the edge could not reach it`);
+    if (settled) throw new Error('another rung won');
+    settled = true;
+    return { ...started, rung: rung.why };
+  });
+  try {
+    const winner = await Promise.any(attempts);
+    log(`tunnel: up via ${winner.rung}`);
+    for (const p of losers) { if (p !== winner.proc) { try { p.kill(); } catch { /* gone */ } } }
+    return winner;
+  } catch (agg) {
+    for (const p of losers) { try { p.kill(); } catch { /* gone */ } }
+    const why = agg?.errors?.map((e) => e.message).join(' | ') || agg?.message || 'unknown';
+    throw new Error(`no cloudflared configuration produced a working tunnel (${why})`);
   }
-  throw lastErr || new Error('no cloudflared configuration produced a working tunnel');
 }
 
 /**
@@ -195,7 +206,8 @@ 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`)); });
-    setTimeout(() => { if (!settled) reject(new Error('cloudflared did not produce a URL in 60s')); }, 60000);
+    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);
   });
 }
 

package/package.json

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