clawmoney 0.15.9 → 0.15.11

package/dist/commands/relay-setup.d.ts

@@ -0,0 +1 @@
+export declare function relaySetupCommand(): Promise<void>;

package/dist/commands/relay-setup.js

@@ -0,0 +1,313 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { intro, outro, multiselect, confirm, text, spinner, isCancel, cancel, log, } from "@clack/prompts";
+import chalk from "chalk";
+import { apiPost } from "../utils/api.js";
+import { requireConfig } from "../utils/config.js";
+import { API_PRICES, RELAY_DISCOUNT, PLATFORM_FEE } from "../relay/pricing.js";
+// ── Per-cli_type model catalogs ──
+//
+// `RECOMMENDED_MODELS` is what gets registered when the user picks "all
+// recommended" — it's a curated subset of API_PRICES that maps to the
+// models a typical end-user actually wants to expose. Old / preview /
+// niche models are intentionally excluded from the default; the user
+// can pick them via "select individually" if needed.
+//
+// `modelsForCli` returns the full set per cli_type drawn directly from
+// API_PRICES so every priced model is available in the manual picker.
+const RECOMMENDED_MODELS = {
+    claude: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"],
+    codex: ["gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex"],
+    antigravity: [
+        "antigravity-gemini-3-pro",
+        "antigravity-claude-opus-4-6",
+        "antigravity-claude-sonnet-4-6",
+    ],
+    gemini: ["gemini-2.5-pro", "gemini-2.5-flash"],
+};
+function modelsForCli(cli) {
+    const all = Object.keys(API_PRICES);
+    if (cli === "claude") {
+        return all.filter((m) => m.startsWith("claude-"));
+    }
+    if (cli === "codex") {
+        return all.filter((m) => m.startsWith("gpt-") || m.startsWith("o3") || m.startsWith("o4"));
+    }
+    if (cli === "antigravity") {
+        return all.filter((m) => m.startsWith("antigravity-"));
+    }
+    if (cli === "gemini") {
+        // Exclude antigravity-prefixed gemini variants — those are served by
+        // the antigravity cli_type, not the standalone gemini cli_type.
+        return all.filter((m) => m.startsWith("gemini-") && !m.startsWith("antigravity-"));
+    }
+    return [];
+}
+function detectInstalledClis() {
+    const results = [];
+    // Binary-based CLIs: probe `which`. We intentionally don't try to
+    // validate OAuth state here — the daemon's preflight does that on
+    // first start, and probing OAuth from a sync setup wizard would be
+    // brittle (keychain prompts, refresh-token races, etc).
+    const binaries = [
+        { cli: "claude", bin: "claude" },
+        { cli: "codex", bin: "codex" },
+        { cli: "gemini", bin: "gemini" },
+    ];
+    for (const { cli, bin } of binaries) {
+        let installed = false;
+        try {
+            execSync(`command -v ${bin}`, { stdio: "pipe" });
+            installed = true;
+        }
+        catch {
+            installed = false;
+        }
+        results.push({
+            cli,
+            available: installed,
+            hint: installed
+                ? "binary in PATH (login state will be validated when daemon starts)"
+                : `${bin} not found in PATH`,
+        });
+    }
+    // Antigravity is OAuth-file based — there's no `antigravity` binary
+    // installed locally. We check for the OAuth credentials file that
+    // `clawmoney antigravity login` writes.
+    const antigravityFile = join(homedir(), ".clawmoney", "antigravity-accounts.json");
+    const antigravityAvailable = existsSync(antigravityFile);
+    results.push({
+        cli: "antigravity",
+        available: antigravityAvailable,
+        hint: antigravityAvailable
+            ? "Google OAuth file present"
+            : "no Google OAuth linked (run `clawmoney antigravity login` first)",
+    });
+    return results;
+}
+// ── Helpers ──
+function formatPrice(input, output) {
+    return `$${input}/$${output} per 1M`;
+}
+function formatBuyerPrice(input, output) {
+    const buyerInput = (input * RELAY_DISCOUNT).toFixed(3);
+    const buyerOutput = (output * RELAY_DISCOUNT).toFixed(3);
+    return `$${buyerInput}/$${buyerOutput} per 1M (after ${Math.round((1 - RELAY_DISCOUNT) * 100)}% relay discount)`;
+}
+// ── Main command ──
+export async function relaySetupCommand() {
+    const config = requireConfig();
+    intro(chalk.cyan(" ClawMoney Relay Setup "));
+    log.message("Sell your idle Claude Max / ChatGPT Pro / Google subscription capacity to other AI agents.");
+    // ── Step 1: detect installed CLIs ──
+    const detectSpin = spinner();
+    detectSpin.start("Scanning for installed CLI clients...");
+    const detected = detectInstalledClis();
+    detectSpin.stop("Scan complete");
+    for (const d of detected) {
+        if (d.available) {
+            log.success(`${chalk.bold(d.cli.padEnd(12))} ${chalk.dim(d.hint)}`);
+        }
+        else {
+            log.warn(`${chalk.bold(d.cli.padEnd(12))} ${chalk.dim(d.hint)}`);
+        }
+    }
+    const available = detected.filter((d) => d.available);
+    if (available.length === 0) {
+        log.error("No supported CLI clients found locally. Install at least one of: " +
+            chalk.cyan("claude, codex, gemini") +
+            " — or run `clawmoney antigravity login` to link a Google account.");
+        cancel("Setup aborted");
+        process.exit(1);
+    }
+    // ── Step 2: pick which families to register ──
+    const familyChoice = await multiselect({
+        message: "Which CLI families do you want to provide? (space to toggle, enter to confirm)",
+        options: available.map((d) => ({
+            value: d.cli,
+            label: d.cli,
+            hint: d.hint,
+        })),
+        initialValues: available.map((d) => d.cli),
+        required: true,
+    });
+    if (isCancel(familyChoice)) {
+        cancel("Setup cancelled");
+        process.exit(0);
+    }
+    const selectedClis = familyChoice;
+    const registrations = [];
+    for (const cli of selectedClis) {
+        const allModels = modelsForCli(cli);
+        const recommended = (RECOMMENDED_MODELS[cli] ?? []).filter((m) => allModels.includes(m));
+        if (allModels.length === 0) {
+            log.warn(`${cli}: no models found in pricing table — skipping`);
+            continue;
+        }
+        log.step(`${chalk.bold(cli)}: choose models`);
+        const useRecommended = await confirm({
+            message: `Register the ${recommended.length} recommended ${cli} models? (${recommended.join(", ")})`,
+            initialValue: true,
+        });
+        if (isCancel(useRecommended)) {
+            cancel("Setup cancelled");
+            process.exit(0);
+        }
+        let chosen;
+        if (useRecommended) {
+            chosen = recommended;
+        }
+        else {
+            const picked = await multiselect({
+                message: `Pick ${cli} models to register:`,
+                options: allModels.map((m) => {
+                    const p = API_PRICES[m];
+                    return {
+                        value: m,
+                        label: m,
+                        hint: formatPrice(p.input, p.output),
+                    };
+                }),
+                initialValues: recommended,
+                required: true,
+            });
+            if (isCancel(picked)) {
+                cancel("Setup cancelled");
+                process.exit(0);
+            }
+            chosen = picked;
+        }
+        for (const model of chosen) {
+            const p = API_PRICES[model];
+            registrations.push({
+                cli,
+                model,
+                input: p.input,
+                output: p.output,
+            });
+        }
+    }
+    if (registrations.length === 0) {
+        cancel("No models selected — nothing to register");
+        process.exit(0);
+    }
+    // ── Step 4: global concurrency + daily budget ──
+    const concurrencyAns = await text({
+        message: "Concurrency cap per provider? (1-5 recommended; higher looks less like a single power user to upstream fingerprint detection)",
+        placeholder: "5",
+        defaultValue: "5",
+        validate: (v) => {
+            const n = parseInt(v || "5", 10);
+            if (Number.isNaN(n) || n < 1 || n > 20) {
+                return "Must be a number between 1 and 20";
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(concurrencyAns)) {
+        cancel("Setup cancelled");
+        process.exit(0);
+    }
+    const dailyLimitAns = await text({
+        message: "Daily API spend cap per provider in USD? (the daemon stops accepting requests when exceeded)",
+        placeholder: "15",
+        defaultValue: "15",
+        validate: (v) => {
+            const n = parseFloat(v || "15");
+            if (Number.isNaN(n) || n < 0) {
+                return "Must be a non-negative number";
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(dailyLimitAns)) {
+        cancel("Setup cancelled");
+        process.exit(0);
+    }
+    const concurrency = parseInt(concurrencyAns, 10);
+    const dailyLimit = parseFloat(dailyLimitAns);
+    // ── Step 5: confirmation summary ──
+    log.step(chalk.bold("Summary"));
+    for (const r of registrations) {
+        log.message(`  ${chalk.cyan(r.cli + "/" + r.model).padEnd(50)} ${chalk.dim(formatBuyerPrice(r.input, r.output))}`);
+    }
+    log.message(chalk.dim(`  ${registrations.length} providers · concurrency=${concurrency} · daily_limit=$${dailyLimit}`));
+    log.message(chalk.dim(`  You earn ~${Math.round((1 - PLATFORM_FEE) * 100)}% of what buyers pay (after platform fee)`));
+    const proceed = await confirm({
+        message: `Register all ${registrations.length} providers now?`,
+        initialValue: true,
+    });
+    if (isCancel(proceed) || !proceed) {
+        cancel("Setup cancelled");
+        process.exit(0);
+    }
+    // ── Step 6: register each (idempotent — "already registered" counts as success) ──
+    let succeeded = 0;
+    let failed = 0;
+    const failures = [];
+    for (const r of registrations) {
+        const regSpin = spinner();
+        regSpin.start(`Registering ${r.cli}/${r.model}...`);
+        try {
+            const body = {
+                cli_type: r.cli,
+                model: r.model,
+                mode: "chat",
+                concurrency,
+                daily_limit_usd: dailyLimit,
+                price_input_per_m: r.input,
+                price_output_per_m: r.output,
+            };
+            const resp = await apiPost("/api/v1/relay/providers", body, config.api_key);
+            if (resp.ok) {
+                regSpin.stop(`${chalk.green("✓")} ${r.cli}/${r.model}`);
+                succeeded++;
+            }
+            else {
+                const raw = resp.data && typeof resp.data === "object" && "detail" in resp.data
+                    ? resp.data.detail
+                    : resp.data;
+                const detail = typeof raw === "string" ? raw : JSON.stringify(raw);
+                // Already-registered is a soft success — idempotent re-run.
+                if (detail.includes("Already registered")) {
+                    regSpin.stop(`${chalk.yellow("~")} ${r.cli}/${r.model} ${chalk.dim("(already registered, no change)")}`);
+                    succeeded++;
+                }
+                else {
+                    regSpin.stop(`${chalk.red("✗")} ${r.cli}/${r.model} ${chalk.dim("(" + detail.slice(0, 80) + ")")}`);
+                    failed++;
+                    failures.push({ cli: r.cli, model: r.model, error: detail });
+                }
+            }
+        }
+        catch (err) {
+            const msg = err.message;
+            regSpin.stop(`${chalk.red("✗")} ${r.cli}/${r.model} ${chalk.dim("(" + msg + ")")}`);
+            failed++;
+            failures.push({ cli: r.cli, model: r.model, error: msg });
+        }
+    }
+    // ── Step 7: next steps ──
+    log.step(chalk.bold("Done"));
+    log.message(`${chalk.green(succeeded.toString())} providers registered`);
+    if (failed > 0) {
+        log.warn(`${failed} registrations failed`);
+        for (const f of failures) {
+            log.message(chalk.dim(`  ${f.cli}/${f.model}: ${f.error.slice(0, 120)}`));
+        }
+    }
+    log.message("");
+    log.message(chalk.bold("Next steps"));
+    log.message("  Start the daemon for each cli_type you registered:");
+    for (const cli of selectedClis) {
+        log.message(`    ${chalk.cyan(`clawmoney relay start --cli ${cli}`)}`);
+    }
+    log.message("");
+    log.message("  Useful follow-up commands:");
+    log.message(`    ${chalk.cyan("clawmoney relay status")}        # check daemon health + provider list`);
+    log.message(`    ${chalk.cyan("clawmoney relay credits")}       # check earnings + payout balance`);
+    log.message(`    ${chalk.cyan("clawmoney relay stop")}          # stop the daemon`);
+    outro(chalk.green("Setup complete"));
+}

package/dist/index.js

@@ -458,6 +458,19 @@ gig
 const relay = program
     .command('relay')
     .description('Relay marketplace: sell idle AI subscription capacity');
+relay
+    .command('setup')
+    .description('Interactive: detect installed CLIs, pick models, register all in one go (recommended for first-time setup)')
+    .action(async () => {
+    try {
+        const { relaySetupCommand } = await import('./commands/relay-setup.js');
+        await relaySetupCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 relay
     .command('register')
     .description('Register as a relay provider')

package/dist/relay/upstream/claude-api.js

@@ -937,41 +937,115 @@ function mergeBetas(required, clientBeta) {
     }
     return out.join(",");
 }
-// Rewrite the first system block's x-anthropic-billing-header (if present)
-// so cc_version and FP3 match OUR fingerprint and the buyer's actual
-// first user message. Real Claude Code always emits this block; sub2api's
-// gateway_service.go mirrors it verbatim but rewrites the version to
-// match the account's pinned UA (syncBillingHeaderVersion, gateway_billing_header.go).
+// Ensure a passthrough body carries the full Claude Code fingerprint
+// shell that Anthropic's OAuth-endpoint validator expects. Called from
+// doCallClaudeApiPassthrough as the last body-munging step before the
+// HTTP request goes out.
 //
-// Critical because Anthropic's validator expects cc_version.<FP3> where
-// FP3 is a deterministic hash of (message_chars + cli_version). If we
-// leave the buyer's FP3 in place but their UA was a different version
-// from our pinned UA, the FP3 no longer matches cli_version in the header
-// and the validator rejects the request.
-function syncPassthroughBillingHeader(body, fingerprint) {
-    if (!Array.isArray(body.system))
-        return;
+// The three fingerprint-sensitive fields that MUST be present on every
+// real Claude Code /v1/messages request:
+//
+//   1. system[0] = {type:"text", text:"x-anthropic-billing-header: ..."}
+//      — always the FIRST block. Contains cc_version.<FP3> where FP3 is
+//      SHA256(SALT + chars_from_first_user_msg + cli_version).hex[:3].
+//   2. system[i] = {type:"text", text:"You are a Claude agent, built on
+//      Anthropic's Claude Agent SDK..."} with cache_control ephemeral.
+//      — the template-mode "CC identity marker" that passes the dice-
+//      coefficient validator.
+//   3. thinking: {type, budget_tokens?} — on Claude 4+ models real CLI
+//      always sends this; zero-thinking accounts stand out.
+//   4. tools: array (empty [] is fine) — real CLI always sends the
+//      field, missing means the request shape doesn't match.
+//
+// For real Claude Code / anthropic SDK clients that already send a full
+// body (via /v1/messages passthrough path), every check here no-ops —
+// the body is already in CC shape and we don't touch it.
+//
+// For OpenAI-SDK-style clients going through /v1/chat/completions (the
+// Hub's chat→anthropic converter produces a minimal body), we augment
+// with the missing shell fields so the outbound request is
+// indistinguishable from a real CC request that happens to have a
+// user-provided system prompt and no local tools.
+//
+// All buyer content (messages, their own system text, their own tools,
+// thinking config if they sent one) is preserved.
+function ensureClaudeCodeShell(body, fingerprint) {
+    // ── Normalize system to an array of content blocks ──
+    if (!Array.isArray(body.system)) {
+        if (typeof body.system === "string" && body.system.length > 0) {
+            // String-shaped system (anthropic SDK convenience form) →
+            // wrap in a single text block so we can prepend.
+            body.system = [{ type: "text", text: body.system }];
+        }
+        else {
+            body.system = [];
+        }
+    }
     const system = body.system;
-    if (system.length === 0)
-        return;
+    // ── Detect CC identity marker anywhere in system ──
+    const hasCcMarker = system.some((b) => b &&
+        typeof b === "object" &&
+        b.type === "text" &&
+        typeof b.text === "string" &&
+        b.text.includes(CLAUDE_CODE_SYSTEM_PROMPT_LEAD));
+    // ── Detect billing header in system[0] ──
     const firstBlock = system[0];
-    if (!firstBlock ||
-        typeof firstBlock !== "object" ||
-        firstBlock.type !== "text" ||
-        typeof firstBlock.text !== "string") {
-        return;
+    const hasBillingHeaderFirst = !!firstBlock &&
+        typeof firstBlock === "object" &&
+        firstBlock.type === "text" &&
+        typeof firstBlock.text === "string" &&
+        firstBlock.text.startsWith("x-anthropic-billing-header:");
+    // ── Build the attribution header (always recompute so cc_version + FP3
+    // match OUR fingerprint and the buyer's actual first user message) ──
+    const firstUserMsg = extractFirstUserMessageText(body.messages);
+    const freshHeader = buildClaudeAttributionHeader(firstUserMsg, fingerprint.cc_version, fingerprint.cc_entrypoint);
+    // ── Inject CC marker if missing ──
+    // Position: right after the billing header slot (idx 1), or right
+    // after any buyer-prefixed system blocks (at head) if we're also
+    // inserting the billing header.
+    if (!hasCcMarker) {
+        const markerBlock = {
+            type: "text",
+            text: `${CLAUDE_CODE_SYSTEM_PROMPT_LEAD}\n\n${RELAY_INSTRUCTIONS}`,
+            cache_control: { type: "ephemeral" },
+        };
+        // Insert at index 1 (slot after billing header), or 0 if we'll be
+        // unshifting the billing header next.
+        if (hasBillingHeaderFirst) {
+            system.splice(1, 0, markerBlock);
+        }
+        else {
+            system.unshift(markerBlock);
+        }
     }
-    const currentText = firstBlock.text;
-    if (!currentText.startsWith("x-anthropic-billing-header:")) {
-        // Non-CC client didn't include a billing header — leave system alone.
-        // If we're strict about this we could PREPEND one, but for now we
-        // only touch what exists so non-CC passthrough (e.g. anthropic SDK
-        // direct) works without extra surgery.
-        return;
+    // ── Update or inject billing header at index 0 ──
+    if (hasBillingHeaderFirst) {
+        // Rewrite in place so cc_version reflects OUR fingerprint, not the
+        // buyer's original (which might have been from a different CLI
+        // version than our pinned fingerprint).
+        firstBlock.text = freshHeader;
+    }
+    else {
+        system.unshift({ type: "text", text: freshHeader });
+    }
+    // ── Ensure tools array exists ──
+    if (!Array.isArray(body.tools)) {
+        body.tools = [];
+    }
+    // ── Inject thinking config if missing ──
+    // Real CLI always sends this for Claude 4+ models; zero-thinking
+    // accounts are a relay-farm tell. pickClaudeThinkingConfig picks the
+    // right shape (adaptive for 4-6, enabled-with-budget for 4-5/haiku).
+    if (!body.thinking || typeof body.thinking !== "object") {
+        const rawMaxTokens = typeof body.max_tokens === "number" && body.max_tokens > 0
+            ? body.max_tokens
+            : 4096;
+        const { config, adjustedMaxTokens } = pickClaudeThinkingConfig(body.model ?? "", rawMaxTokens);
+        if (config) {
+            body.thinking = config;
+            body.max_tokens = adjustedMaxTokens;
+        }
     }
-    const firstUserMsg = extractFirstUserMessageText(body.messages);
-    const newHeader = buildClaudeAttributionHeader(firstUserMsg, fingerprint.cc_version, fingerprint.cc_entrypoint);
-    firstBlock.text = newHeader;
 }
 // Walk system text blocks and rewrite third-party identity sentences
 // (OpenCode, etc.) to the Claude Code banner. sub2api does the same thing
@@ -1025,7 +1099,7 @@ async function doCallClaudeApiPassthrough(opts) {
     // Sanitize system: replace third-party identity sentences + sync
     // billing header cc_version to match our pinned CLI version.
     sanitizePassthroughSystemArray(body);
-    syncPassthroughBillingHeader(body, fp);
+    ensureClaudeCodeShell(body, fp);
     // Clamp thinking.budget_tokens to Anthropic's minimum so buyer-chosen
     // small budgets don't 400. If max_tokens < budget_tokens + 1, bump
     // max_tokens too so the request stays valid.

package/dist/relay/upstream/codex-api.js

@@ -77,9 +77,17 @@ const MAX_TRANSIENT_RETRIES = 2;
 // Codex responses on small prompts come back in <10s; we give a generous
 // ceiling to tolerate slow tokens without hanging the daemon forever.
 const WS_OVERALL_TIMEOUT_MS = 180 * 1000;
-// Default relay instructions for Codex. Upstream treats `instructions` as
-// the system prompt. Keep minimal so the buyer's prompt gets full focus.
+// Default instructions for Codex template mode. Template mode flattens
+// messages into a single prompt and drops buyer's tools — the "plain
+// text only" hint aligns model behavior with what template can actually
+// deliver.
 const RELAY_INSTRUCTIONS = "You are a helpful AI assistant operating in relay mode. Respond to the user's message with plain text only. Be concise.";
+// Neutral fallback for Codex passthrough mode when the buyer did NOT
+// supply their own instructions. Unlike the template-mode string, this
+// one does NOT forbid tool use — if the buyer sent a tools array we
+// want the model to use them. Kept intentionally vague so it doesn't
+// bias the model's behavior when the buyer's intent is unspecified.
+const CODEX_PASSTHROUGH_FALLBACK_INSTRUCTIONS = "You are a helpful coding assistant. Use the available tools when appropriate to answer the user.";
 // ── Proxy ──
 //
 // We configure the global undici dispatcher for the OAuth refresh fetch()
@@ -1051,10 +1059,13 @@ function buildCodexPassthroughFrame(clientBody, model, fingerprint, sessionId, t
     if (frame.parallel_tool_calls === undefined) {
         frame.parallel_tool_calls = false;
     }
-    // Instructions: if buyer didn't send one, fall back to the template
-    // mode's RELAY_INSTRUCTIONS so the model still has guidance.
+    // Instructions: if buyer didn't send one, fall back to a neutral
+    // tool-friendly default so the model still has guidance while not
+    // forbidding tool use (unlike template mode's RELAY_INSTRUCTIONS,
+    // which says "plain text only" — wrong fit for passthrough where
+    // buyer's tools should actually be used).
     if (typeof frame.instructions !== "string" || !frame.instructions) {
-        frame.instructions = RELAY_INSTRUCTIONS;
+        frame.instructions = CODEX_PASSTHROUGH_FALLBACK_INSTRUCTIONS;
     }
     if (warmup) {
         // Real CLI's prewarm flow: first frame of each turn has generate:false.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.15.9",
+  "version": "0.15.11",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {
@@ -20,6 +20,7 @@
   "dependencies": {
     "awal": "^2.2.0",
     "@bnbot/cli": "^0.3.0",
+    "@clack/prompts": "^0.7.0",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "ora": "^8.0.0",