clawmoney 0.15.55 → 0.15.57

package/dist/commands/relay-setup.js

@@ -11,7 +11,6 @@ import { setupCommand } from "./setup.js";
 import { API_PRICES, PLATFORM_FEE } from "../relay/pricing.js";
 import { hasClaudeFingerprint, bootstrapClaudeFingerprint, } from "../relay/upstream/claude-bootstrap.js";
 import { hasGeminiFingerprint, bootstrapGeminiFingerprint, } from "../relay/upstream/gemini-bootstrap.js";
-import { hasCodexFingerprint, bootstrapCodexFingerprint, } from "../relay/upstream/codex-bootstrap.js";
 // ── Per-cli_type model catalogs ──
 //
 // `RECOMMENDED_MODELS` is what gets registered when the user picks "all
@@ -207,94 +206,42 @@ export async function relaySetupCommand() {
         process.exit(0);
     }
     const selectedClis = familyChoice;
-    // Per-cli inline fingerprint bootstrap helper. Called from Step 3
-    // right after the "cli: N models" line so the capture flow is
-    // visually grouped with its owning cli family.
-    //
-    // The daemon needs a fingerprint file per cli_type
-    // (~/.clawmoney/<cli>-fingerprint.json) to mimic the real CLI's
-    // device identity on every upstream request. Without it, the
-    // daemon fails at execution time and buyers see 502s. We
-    // previously required a manual two-terminal capture dance; now
-    // it's inlined into the wizard.
-    //
-    // claude uses a plain HTTP proxy (in-process TS), same for gemini.
-    // codex uses the existing mjs capture script via subprocess
-    // because Codex CLI 0.118+ talks WebSocket.
-    //
-    // antigravity is handled separately via `clawmoney antigravity
-    // login` and doesn't need a fingerprint file.
-    const runCliBootstrap = async (cli) => {
-        let startLabel;
-        let run;
-        let check;
-        if (cli === "claude") {
-            if (hasClaudeFingerprint())
-                return;
-            startLabel = "Capturing Claude fingerprint (runs `claude -p hi` once, ~5-15s)";
-            check = hasClaudeFingerprint;
-            run = async () => {
-                const fp = await bootstrapClaudeFingerprint({ timeoutMs: 45_000 });
-                return `device=${fp.device_id.slice(0, 8)}… cc_version=${fp.cc_version || "?"}`;
-            };
-        }
-        else if (cli === "gemini") {
-            if (hasGeminiFingerprint())
-                return;
-            startLabel = "Capturing Gemini fingerprint (runs `gemini -p hi` once, ~10-20s)";
-            check = hasGeminiFingerprint;
-            run = async () => {
-                const fp = await bootstrapGeminiFingerprint({ timeoutMs: 60_000 });
-                return `project=${fp.project_id} cli_version=${fp.cli_version}`;
-            };
-        }
-        else if (cli === "codex") {
-            if (hasCodexFingerprint())
-                return;
-            startLabel = "Capturing Codex fingerprint (runs `codex -p hi` once, ~15-30s)";
-            check = hasCodexFingerprint;
-            run = async () => {
-                await bootstrapCodexFingerprint({ timeoutMs: 60_000 });
-                return "from chatgpt.com WS handshake";
-            };
-        }
-        else {
-            // antigravity or unknown — skip, no fingerprint needed.
-            return;
-        }
-        // In-place line replacement: print start line without a newline,
-        // then clear it on completion and print the result over the top.
-        // Uses readline.cursorTo/clearLine for terminal portability.
-        const startLine = `${chalk.gray("◇")}  ${chalk.bold(startLabel)}`;
-        process.stdout.write(startLine);
-        const clearStartLine = () => {
-            try {
-                readline.cursorTo(process.stdout, 0);
-                readline.clearLine(process.stdout, 0);
-            }
-            catch {
-                process.stdout.write("\n");
-            }
-        };
-        try {
-            const summary = await run();
-            clearStartLine();
-            process.stdout.write(`${chalk.green("◆")}  ${chalk.bold(cli)} fingerprint captured ` +
-                chalk.dim(`(${summary})`) +
-                "\n");
-        }
-        catch (err) {
-            clearStartLine();
-            process.stdout.write(`${chalk.yellow("⚠")}  ${chalk.bold(cli)} fingerprint capture failed: ${err.message}\n`);
-            log.message(chalk.dim(`${cli} providers will be registered but the daemon won't be able ` +
-                "to serve them until the fingerprint is bootstrapped. " +
-                `Make sure \`${cli}\` is installed and logged in, then re-run setup.`));
+    const runAllBootstraps = async () => {
+        const tasks = [];
+        if (selectedClis.includes("claude") && !hasClaudeFingerprint()) {
+            tasks.push(bootstrapClaudeFingerprint({ timeoutMs: 45_000 })
+                .then((fp) => ({
+                cli: "claude",
+                ok: true,
+                summary: `device=${fp.device_id.slice(0, 8)}… cc_version=${fp.cc_version || "?"}`,
+            }))
+                .catch((err) => ({
+                cli: "claude",
+                ok: false,
+                error: err.message,
+            })));
         }
-        // Defensive: if the bootstrap somehow resolved without writing
-        // the file, warn so the user isn't surprised later.
-        if (!check()) {
-            log.message(chalk.dim(`(${cli} fingerprint file still missing — daemon preflight will fail for this cli)`));
+        if (selectedClis.includes("gemini") && !hasGeminiFingerprint()) {
+            // Shorter timeout on gemini — recent CLI versions are flaky
+            // under our subprocess-intercept approach. 25s is enough for
+            // a working capture; beyond that we fall through to the
+            // manual instruction path cleanly.
+            tasks.push(bootstrapGeminiFingerprint({ timeoutMs: 25_000 })
+                .then((fp) => ({
+                cli: "gemini",
+                ok: true,
+                summary: `project=${fp.project_id} cli_version=${fp.cli_version}`,
+            }))
+                .catch((err) => ({
+                cli: "gemini",
+                ok: false,
+                error: err.message,
+            })));
         }
+        // Codex intentionally omitted — codex-api.ts has safe defaults.
+        if (tasks.length === 0)
+            return [];
+        return Promise.all(tasks);
     };
     const registrations = [];
     for (const cli of selectedClis) {
@@ -305,10 +252,6 @@ export async function relaySetupCommand() {
             continue;
         }
         log.success(`${chalk.bold(cli)}: ${recommended.length} models ${chalk.dim("— " + recommended.join(", "))}`);
-        // Bootstrap the fingerprint for this cli right after its model
-        // line so the ◆ "fingerprint captured" message sits visually
-        // under its owning family (claude / codex / gemini / antigravity).
-        await runCliBootstrap(cli);
         for (const model of recommended) {
             const p = API_PRICES[model];
             registrations.push({
@@ -323,6 +266,55 @@ export async function relaySetupCommand() {
         cancel("No models selected — nothing to register");
         process.exit(0);
     }
+    // ── Step 3b: parallel fingerprint bootstrap for selected clis ──
+    //
+    // One "Configuring providers..." line that gets overwritten with
+    // the consolidated result. Claude and gemini run concurrently;
+    // codex is skipped (defaults OK); antigravity doesn't use a
+    // fingerprint file.
+    const startLine = `${chalk.gray("◇")}  Configuring providers`;
+    process.stdout.write(startLine);
+    const tickEvery = 500;
+    const ticker = setInterval(() => {
+        process.stdout.write(chalk.dim("."));
+    }, tickEvery);
+    const results = await runAllBootstraps();
+    clearInterval(ticker);
+    try {
+        readline.cursorTo(process.stdout, 0);
+        readline.clearLine(process.stdout, 0);
+    }
+    catch {
+        process.stdout.write("\n");
+    }
+    if (results.length === 0) {
+        // No bootstraps needed — everything was already in place.
+        process.stdout.write(`${chalk.green("◆")}  Providers configured ${chalk.dim("(fingerprints already in place)")}\n`);
+    }
+    else {
+        const okCount = results.filter((r) => r.ok).length;
+        const failCount = results.length - okCount;
+        if (failCount === 0) {
+            process.stdout.write(`${chalk.green("◆")}  Providers configured ` +
+                chalk.dim(`(${okCount} fingerprint${okCount === 1 ? "" : "s"} captured: ${results
+                    .map((r) => r.cli)
+                    .join(", ")})`) +
+                "\n");
+        }
+        else {
+            process.stdout.write(`${chalk.yellow("⚠")}  Providers configured with warnings ` +
+                chalk.dim(`(${okCount} ok / ${failCount} failed)`) +
+                "\n");
+            for (const r of results) {
+                if (r.ok)
+                    continue;
+                log.warn(`${chalk.bold(r.cli)} fingerprint capture failed: ${r.error ?? "unknown"}`);
+                log.message(chalk.dim(`${r.cli} providers will be registered but the daemon won't serve them until you ` +
+                    `run \`node $(npm root -g)/clawmoney/scripts/capture-${r.cli}-request.mjs\` in one terminal ` +
+                    `and \`<CLI env vars> ${r.cli} -p hi\` in another.`));
+            }
+        }
+    }
     // ── Step 4: per-provider daily quota share ──
     //
     // We deliberately don't show USD earnings projections in this prompt

package/dist/relay/upstream/gemini-bootstrap.d.ts

@@ -1,25 +1,15 @@
 /**
  * Programmatic Gemini fingerprint capture.
  *
- * Mirrors scripts/capture-gemini-request.mjs but runs inline so the
- * setup wizard can bootstrap ~/.clawmoney/gemini-fingerprint.json
- * without the two-terminal dance.
+ * Spawns the existing scripts/capture-gemini-request.mjs as a
+ * subprocess and runs `gemini -p hi` against it, rather than
+ * reimplementing the proxy in TypeScript. The TS port I tried
+ * first timed out at 25s even though the mjs script captures in
+ * ~4s on the same machine — the mjs path is proven and reused
+ * code, so keep the pattern consistent with codex-bootstrap.
  *
- * Flow:
- *   1. Listen on a random localhost port.
- *   2. Spawn `gemini -p "hi"` with CODE_ASSIST_ENDPOINT pointing at us.
- *   3. When the first POST hits a /v1internal:generateContent (or
- *      similar) path, extract project_id / user_agent / cli_version /
- *      x_goog_api_client from the body + headers, persist to
- *      ~/.clawmoney/gemini-fingerprint.json, and forward the request
- *      to cloudcode-pa.googleapis.com so the gemini CLI still sees a
- *      valid response.
- *   4. Clean up proxy server + gemini subprocess.
- *
- * Note: the :loadCodeAssist bootstrap request that Gemini CLI fires
- * first carries only `{metadata}` without a project — we skip it and
- * wait for a subsequent v1internal request that actually carries a
- * project field. Mirrors the mjs script's extractFingerprint guard.
+ * Note: the mjs script hardcodes port 8789. A collision surfaces
+ * as a spawn error we forward to the caller.
  */
 export interface GeminiFingerprint {
     project_id: string;

package/dist/relay/upstream/gemini-bootstrap.js

@@ -1,124 +1,61 @@
 /**
  * Programmatic Gemini fingerprint capture.
  *
- * Mirrors scripts/capture-gemini-request.mjs but runs inline so the
- * setup wizard can bootstrap ~/.clawmoney/gemini-fingerprint.json
- * without the two-terminal dance.
+ * Spawns the existing scripts/capture-gemini-request.mjs as a
+ * subprocess and runs `gemini -p hi` against it, rather than
+ * reimplementing the proxy in TypeScript. The TS port I tried
+ * first timed out at 25s even though the mjs script captures in
+ * ~4s on the same machine — the mjs path is proven and reused
+ * code, so keep the pattern consistent with codex-bootstrap.
  *
- * Flow:
- *   1. Listen on a random localhost port.
- *   2. Spawn `gemini -p "hi"` with CODE_ASSIST_ENDPOINT pointing at us.
- *   3. When the first POST hits a /v1internal:generateContent (or
- *      similar) path, extract project_id / user_agent / cli_version /
- *      x_goog_api_client from the body + headers, persist to
- *      ~/.clawmoney/gemini-fingerprint.json, and forward the request
- *      to cloudcode-pa.googleapis.com so the gemini CLI still sees a
- *      valid response.
- *   4. Clean up proxy server + gemini subprocess.
- *
- * Note: the :loadCodeAssist bootstrap request that Gemini CLI fires
- * first carries only `{metadata}` without a project — we skip it and
- * wait for a subsequent v1internal request that actually carries a
- * project field. Mirrors the mjs script's extractFingerprint guard.
+ * Note: the mjs script hardcodes port 8789. A collision surfaces
+ * as a spawn error we forward to the caller.
  */
-import { createServer } from "node:http";
-import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync, } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { spawn } from "node:child_process";
-import { fetch as undiciFetch, ProxyAgent } from "undici";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 const CONFIG_DIR = join(homedir(), ".clawmoney");
 const FINGERPRINT_PATH = join(CONFIG_DIR, "gemini-fingerprint.json");
+const CAPTURE_PORT = 8789;
+const CAPTURE_SCRIPT = "capture-gemini-request.mjs";
 export function hasGeminiFingerprint() {
     return existsSync(FINGERPRINT_PATH);
 }
-const HOP_BY_HOP = new Set([
-    "host",
-    "connection",
-    "content-length",
-    "transfer-encoding",
-    "accept-encoding",
-]);
-function cloneHeaders(src) {
-    const out = {};
-    for (const [k, v] of Object.entries(src)) {
-        if (v == null)
-            continue;
-        if (HOP_BY_HOP.has(k.toLowerCase()))
-            continue;
-        out[k] = Array.isArray(v) ? v.join(", ") : v;
-    }
-    return out;
-}
-// /v1beta and /v1alpha go to generativelanguage (AI Studio).
-// Everything else (notably /v1internal for Code Assist) goes to
-// cloudcode-pa. Matches the manual script's routing.
-function resolveUpstreamURL(path) {
-    if (path.startsWith("/v1beta") ||
-        path.startsWith("/v1/beta") ||
-        path.startsWith("/v1alpha")) {
-        return `https://generativelanguage.googleapis.com${path}`;
-    }
-    return `https://cloudcode-pa.googleapis.com${path}`;
-}
-function extractFingerprint(body, headers) {
-    if (!body || typeof body !== "object")
-        return null;
-    const projectRaw = body.project;
-    const projectId = typeof projectRaw === "string" ? projectRaw.trim() : "";
-    // :loadCodeAssist carries {metadata} without a project — wait for
-    // the next request that does.
-    if (!projectId)
-        return null;
-    const uaRaw = headers["user-agent"];
-    const ua = (Array.isArray(uaRaw) ? uaRaw.join(", ") : (uaRaw ?? "")).trim();
-    const versionMatch = ua.match(/GeminiCLI\/(\d+\.\d+[.\d]*)/i);
-    const cliVersion = versionMatch ? versionMatch[1] : "unknown";
-    const xGoogRaw = headers["x-goog-api-client"];
-    const xGoog = (Array.isArray(xGoogRaw) ? xGoogRaw.join(", ") : (xGoogRaw ?? "")).trim();
-    return {
-        project_id: projectId,
-        cli_version: cliVersion,
-        user_agent: ua || `GeminiCLI/${cliVersion}`,
-        x_goog_api_client: xGoog || "gl-node/unknown",
-    };
-}
-function scrubCaptureFiles() {
-    try {
-        for (const f of readdirSync(CONFIG_DIR)) {
-            if (/^capture-gemini-\d+\.json$/.test(f)) {
-                unlinkSync(join(CONFIG_DIR, f));
-            }
-        }
-    }
-    catch {
-        // ignore — best-effort
+function findCaptureScript() {
+    const thisFile = fileURLToPath(import.meta.url);
+    const thisDir = dirname(thisFile);
+    const candidates = [
+        join(thisDir, "..", "..", "..", "scripts", CAPTURE_SCRIPT),
+        join(thisDir, "..", "..", "scripts", CAPTURE_SCRIPT),
+        join(thisDir, "..", "scripts", CAPTURE_SCRIPT),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
     }
+    return null;
 }
 export async function bootstrapGeminiFingerprint(opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 45_000;
-    mkdirSync(CONFIG_DIR, { recursive: true });
     if (hasGeminiFingerprint()) {
         throw new Error("gemini-fingerprint.json already exists — delete it to re-bootstrap");
     }
-    // Gemini talks to Google — Google is reachable only through a
-    // proxy from GFW-side networks, so we DO honor HTTPS_PROXY for the
-    // upstream forward. The child subprocess gets no proxy env because
-    // it's talking to 127.0.0.1 (us), and routing 127.0.0.1 through
-    // http_proxy tends to wedge.
-    const proxyUrl = process.env.HTTPS_PROXY ||
-        process.env.https_proxy ||
-        process.env.HTTP_PROXY ||
-        process.env.http_proxy;
-    let upstreamDispatcher;
-    if (proxyUrl && /^https?:\/\//.test(proxyUrl)) {
-        upstreamDispatcher = new ProxyAgent(proxyUrl);
+    const scriptPath = findCaptureScript();
+    if (!scriptPath) {
+        throw new Error("capture-gemini-request.mjs not found in the installed clawmoney package");
     }
-    let server = null;
+    let proxyChild = null;
     let geminiChild = null;
-    let resolved = false;
-    let capturedFp = null;
+    let pollInterval = null;
+    let done = false;
     const cleanup = () => {
+        if (pollInterval) {
+            clearInterval(pollInterval);
+            pollInterval = null;
+        }
         if (geminiChild && !geminiChild.killed) {
             try {
                 geminiChild.kill("SIGTERM");
@@ -127,146 +64,99 @@ export async function bootstrapGeminiFingerprint(opts = {}) {
                 // ignore
             }
         }
-        if (server) {
+        if (proxyChild && !proxyChild.killed) {
             try {
-                server.close();
+                // SIGINT lets the mjs script scrub its capture-gemini-*.json
+                // stragglers (they contain OAuth bearer tokens).
+                proxyChild.kill("SIGINT");
             }
             catch {
                 // ignore
             }
-            server = null;
         }
     };
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
-            if (resolved)
+            if (done)
                 return;
-            resolved = true;
+            done = true;
             cleanup();
             reject(new Error(`gemini fingerprint capture timed out after ${timeoutMs}ms`));
         }, timeoutMs);
-        server = createServer((req, res) => {
-            const chunks = [];
-            req.on("data", (c) => chunks.push(c));
-            req.on("end", async () => {
-                const bodyBuf = Buffer.concat(chunks);
-                const bodyText = bodyBuf.toString("utf-8");
-                let parsedBody;
-                try {
-                    parsedBody = JSON.parse(bodyText);
-                }
-                catch {
-                    parsedBody = bodyText;
-                }
-                const isGenerate = req.method === "POST" &&
-                    typeof req.url === "string" &&
-                    (req.url.includes("generateContent") || req.url.includes("v1internal"));
-                if (!capturedFp &&
-                    isGenerate &&
-                    parsedBody &&
-                    typeof parsedBody === "object") {
-                    const fp = extractFingerprint(parsedBody, req.headers);
-                    if (fp) {
-                        capturedFp = fp;
-                        try {
-                            writeFileSync(FINGERPRINT_PATH, JSON.stringify(fp, null, 2), "utf-8");
-                            scrubCaptureFiles();
-                        }
-                        catch (writeErr) {
-                            if (!resolved) {
-                                resolved = true;
-                                clearTimeout(timer);
-                                cleanup();
-                                reject(new Error(`failed to write gemini fingerprint: ${writeErr.message}`));
-                                return;
-                            }
-                        }
-                    }
-                }
-                // Forward to real Google upstream.
-                const upstreamURL = resolveUpstreamURL(req.url || "/");
-                const targetHost = new URL(upstreamURL).host;
-                try {
-                    const upstreamHeaders = cloneHeaders(req.headers);
-                    upstreamHeaders["host"] = targetHost;
-                    const upstreamResp = await undiciFetch(upstreamURL, {
-                        method: req.method,
-                        headers: upstreamHeaders,
-                        body: req.method === "GET" || req.method === "HEAD"
-                            ? undefined
-                            : bodyBuf,
-                        dispatcher: upstreamDispatcher,
-                    });
-                    const respHeaders = {};
-                    upstreamResp.headers.forEach((v, k) => {
-                        const lower = k.toLowerCase();
-                        if (lower === "content-encoding" ||
-                            lower === "content-length" ||
-                            lower === "transfer-encoding")
-                            return;
-                        respHeaders[k] = v;
-                    });
-                    res.writeHead(upstreamResp.status, respHeaders);
-                    if (upstreamResp.body) {
-                        const reader = upstreamResp.body.getReader();
-                        while (true) {
-                            const { done: rDone, value } = await reader.read();
-                            if (rDone)
-                                break;
-                            res.write(Buffer.from(value));
-                        }
-                    }
-                    res.end();
-                }
-                catch (err) {
-                    try {
-                        res.writeHead(502);
-                        res.end();
-                    }
-                    catch {
-                        // ignore
-                    }
-                    if (!resolved && !capturedFp) {
-                        resolved = true;
-                        clearTimeout(timer);
-                        cleanup();
-                        reject(new Error(`upstream google request failed: ${err.message}`));
-                        return;
-                    }
-                }
-                if (capturedFp && !resolved) {
-                    resolved = true;
-                    clearTimeout(timer);
-                    cleanup();
-                    resolve(capturedFp);
-                }
-            });
+        // 1. Spawn the capture proxy (mjs script). It needs HTTPS_PROXY
+        // to reach cloudcode-pa.googleapis.com from a GFW egress.
+        proxyChild = spawn("node", [scriptPath], {
+            env: { ...process.env },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let proxyStderr = "";
+        proxyChild.stderr?.on("data", (c) => {
+            proxyStderr += c.toString();
+            if (proxyStderr.length > 4_000) {
+                proxyStderr = proxyStderr.slice(-4_000);
+            }
+        });
+        proxyChild.stdout?.on("data", () => {
+            // drain — the mjs prints a banner we ignore
         });
-        server.on("error", (err) => {
-            if (resolved)
+        proxyChild.on("error", (err) => {
+            if (done)
                 return;
-            resolved = true;
+            done = true;
             clearTimeout(timer);
             cleanup();
-            reject(new Error(`gemini bootstrap proxy error: ${err.message}`));
+            reject(new Error(`failed to spawn capture proxy: ${err.message}`));
         });
-        server.listen(0, "127.0.0.1", () => {
-            const addr = server.address();
-            if (!addr || typeof addr === "string") {
-                if (resolved)
-                    return;
-                resolved = true;
+        proxyChild.on("exit", (code) => {
+            if (done)
+                return;
+            if (!hasGeminiFingerprint()) {
+                done = true;
                 clearTimeout(timer);
                 cleanup();
-                reject(new Error("failed to bind gemini capture proxy"));
-                return;
+                const tail = proxyStderr.trim().slice(-400);
+                const detail = tail ? ` stderr: ${tail}` : "";
+                reject(new Error(`capture proxy exited (code ${code ?? "unknown"}) before fingerprint.${detail}`));
             }
-            const port = addr.port;
-            // Strip upstream proxy env vars from the child so it hits our
-            // local 127.0.0.1 listener directly. NO_PROXY is belt-and-braces.
+        });
+        // Give the mjs proxy a moment to bind port 8789, then spawn
+        // gemini. 1.5s is enough on every machine I've tested.
+        setTimeout(() => {
+            if (done)
+                return;
+            // Poll the fingerprint file — the mjs script writes it as
+            // soon as the first v1internal request with a project field
+            // comes through.
+            pollInterval = setInterval(() => {
+                if (done) {
+                    if (pollInterval) {
+                        clearInterval(pollInterval);
+                        pollInterval = null;
+                    }
+                    return;
+                }
+                if (hasGeminiFingerprint()) {
+                    done = true;
+                    if (pollInterval) {
+                        clearInterval(pollInterval);
+                        pollInterval = null;
+                    }
+                    clearTimeout(timer);
+                    cleanup();
+                    try {
+                        const raw = JSON.parse(readFileSync(FINGERPRINT_PATH, "utf-8"));
+                        resolve(raw);
+                    }
+                    catch (err) {
+                        reject(new Error(`fingerprint file written but unreadable: ${err.message}`));
+                    }
+                }
+            }, 500);
+            // Strip upstream proxy vars from the gemini subprocess so it
+            // talks to 127.0.0.1:8789 directly. Also set NO_PROXY.
             const childEnv = {
                 ...process.env,
-                CODE_ASSIST_ENDPOINT: `http://127.0.0.1:${port}`,
+                CODE_ASSIST_ENDPOINT: `http://127.0.0.1:${CAPTURE_PORT}`,
                 NO_PROXY: "127.0.0.1,localhost",
                 no_proxy: "127.0.0.1,localhost",
             };
@@ -281,36 +171,36 @@ export async function bootstrapGeminiFingerprint(opts = {}) {
                 stdio: ["ignore", "pipe", "pipe"],
                 shell: process.platform === "win32",
             });
-            let stderrBuf = "";
-            geminiChild.stderr?.on("data", (chunk) => {
-                stderrBuf += chunk.toString();
-                if (stderrBuf.length > 4_000) {
-                    stderrBuf = stderrBuf.slice(-4_000);
+            let geminiStderr = "";
+            geminiChild.stderr?.on("data", (c) => {
+                geminiStderr += c.toString();
+                if (geminiStderr.length > 4_000) {
+                    geminiStderr = geminiStderr.slice(-4_000);
                 }
             });
             geminiChild.stdout?.on("data", () => {
                 // drain
             });
             geminiChild.on("error", (err) => {
-                if (resolved)
+                if (done)
                     return;
-                resolved = true;
+                done = true;
                 clearTimeout(timer);
                 cleanup();
                 reject(new Error(`failed to spawn gemini: ${err.message} (is the gemini CLI installed and in PATH?)`));
             });
             geminiChild.on("exit", (code) => {
                 setTimeout(() => {
-                    if (capturedFp || resolved)
+                    if (done || hasGeminiFingerprint())
                         return;
-                    resolved = true;
+                    done = true;
                     clearTimeout(timer);
                     cleanup();
-                    const tail = stderrBuf.trim().slice(-400);
+                    const tail = geminiStderr.trim().slice(-400);
                     const detail = tail ? ` stderr: ${tail}` : "";
-                    reject(new Error(`gemini -p hi exited with code ${code ?? "unknown"} before sending a v1internal request.${detail}`));
-                }, 500);
+                    reject(new Error(`gemini -p hi exited with code ${code ?? "unknown"} before the capture proxy saw a v1internal request with a project field.${detail}`));
+                }, 800);
             });
-        });
+        }, 1500);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.15.55",
+  "version": "0.15.57",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {