clawmoney 0.15.20 → 0.15.22

package/dist/commands/relay-setup.js

@@ -5,7 +5,8 @@ import { join } from "node:path";
 import { intro, outro, multiselect, confirm, select, spinner, isCancel, cancel, log, } from "@clack/prompts";
 import chalk from "chalk";
 import { apiPost } from "../utils/api.js";
-import { requireConfig } from "../utils/config.js";
+import { loadConfig, requireConfig } from "../utils/config.js";
+import { setupCommand } from "./setup.js";
 import { API_PRICES, RELAY_DISCOUNT, PLATFORM_FEE } from "../relay/pricing.js";
 // ── Per-cli_type model catalogs ──
 //
@@ -129,6 +130,27 @@ function formatBuyerPrice(input, output) {
 }
 // ── Main command ──
 export async function relaySetupCommand() {
+    // ── Step 0: ensure the agent is logged in ──
+    //
+    // Relay setup relies on an ACTIVE ClawMoney agent (api_key + agent_id
+    // in ~/.clawmoney/config.yaml) to register provider rows and to auth
+    // the daemon's WS connection. If the user runs `clawmoney relay setup`
+    // before ever running `clawmoney setup`, we inline the login flow
+    // here instead of throwing a raw "No config found" error. The nested
+    // setupCommand uses its own ora/prompt UI — visually different from
+    // the clack wizard below, but that's acceptable since it only runs on
+    // the first-time-user path.
+    let existing = loadConfig();
+    if (!existing) {
+        console.log(chalk.yellow("\n  You're not logged in yet — running `clawmoney setup` first.\n"));
+        await setupCommand();
+        existing = loadConfig();
+        if (!existing) {
+            console.log(chalk.red("\n  Login did not complete. Run `clawmoney setup` manually, then re-run `clawmoney relay setup`.\n"));
+            process.exit(1);
+        }
+        console.log("");
+    }
     const config = requireConfig();
     intro(chalk.cyan(" ClawMoney Relay Setup "));
     log.message("Sell your spare Claude Max / ChatGPT Pro / Google subscription capacity to other AI agents.");
@@ -363,54 +385,30 @@ export async function relaySetupCommand() {
     }
     // ── Step 8: auto-start the daemon ──
     //
-    // Daemon limitation: a single clawmoney process can only serve ONE
-    // cli_type today (single ~/.clawmoney/relay.pid file). When the user
-    // registered providers across multiple cli_types we can still
-    // auto-start ONE of them and tell them how to switch later. Tracked
-    // separately as a daemon refactor task.
+    // The daemon now runs in multi-cli auto mode by default: it fetches
+    // every provider this agent has registered, preflights each distinct
+    // cli_type, and dispatches requests to the right upstream based on
+    // the `cli_type` field in each incoming relay_request. A single
+    // daemon process can serve Claude + Codex + Gemini + Antigravity
+    // simultaneously, so there's no need to pick one here.
     const uniqueClis = Array.from(new Set(selectedClis));
-    if (uniqueClis.length === 1) {
-        // Single cli_type — go straight into the daemon. The user already
-        // confirmed "Register all N providers?" above, so asking a second
-        // time just adds friction.
-        const cli = uniqueClis[0];
-        const { relayStartCommand } = await import("./relay.js");
-        try {
-            await relayStartCommand({ cli });
-        }
-        catch (err) {
-            log.error(`Failed to start daemon: ${err.message}\n` +
-                `Try manually: ${chalk.cyan(`clawmoney relay start --cli ${cli}`)}`);
-            outro(chalk.yellow("Setup complete (daemon not started)"));
-            return;
-        }
-        log.message("");
-        log.message(chalk.dim("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 · daemon running"));
-        return;
-    }
-    // Multi cli_type — daemon can only host one at a time today. Start
-    // the first registered cli_type directly and tell the user how to
-    // switch to the others later.
-    const firstCli = uniqueClis[0];
-    log.warn(`You registered providers across ${uniqueClis.length} CLI families ` +
-        `(${uniqueClis.join(", ")}). The daemon currently serves ONE cli_type ` +
-        `per process — starting ${chalk.cyan(firstCli)} first.`);
     const { relayStartCommand } = await import("./relay.js");
     try {
-        await relayStartCommand({ cli: firstCli });
+        await relayStartCommand({});
     }
     catch (err) {
         log.error(`Failed to start daemon: ${err.message}\n` +
-            `Try manually: ${chalk.cyan(`clawmoney relay start --cli ${firstCli}`)}`);
+            `Try manually: ${chalk.cyan("clawmoney relay start")}`);
         outro(chalk.yellow("Setup complete (daemon not started)"));
         return;
     }
     log.message("");
-    log.message(chalk.dim("To switch to a different cli_type later:"));
-    log.message(chalk.dim(`    ${chalk.cyan("clawmoney relay stop")} && ${chalk.cyan("clawmoney relay start --cli <other-cli>")}`));
-    outro(chalk.green(`Setup complete · ${firstCli} daemon running`));
+    log.message(chalk.dim("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`);
+    const cliLabel = uniqueClis.length === 1
+        ? `${uniqueClis[0]} daemon running`
+        : `daemon serving ${uniqueClis.join(" + ")}`;
+    outro(chalk.green(`Setup complete · ${cliLabel}`));
 }

package/dist/commands/relay.js

@@ -151,7 +151,12 @@ export async function relayStartCommand(options) {
         if (pid && isRelayPidAlive(pid)) {
             spinner.succeed(chalk.green(`Relay Provider started (PID ${pid})`));
             console.log(chalk.dim(`  Log file: ${LOG_FILE}`));
-            console.log(chalk.dim(`  CLI: ${options.cli || "claude (default)"}`));
+            if (options.cli) {
+                console.log(chalk.dim(`  CLI: ${options.cli} (single)`));
+            }
+            else {
+                console.log(chalk.dim(`  CLI: auto (serving all registered cli_types for this agent)`));
+            }
             console.log(chalk.dim(`  API key: ${config.api_key.slice(0, 8)}...`));
         }
         else {

package/dist/relay/provider.js

@@ -7,6 +7,7 @@ import { callClaudeApi, callClaudeApiPassthrough, preflightClaudeApi, getRateGua
 import { callCodexApi, callCodexApiPassthrough, preflightCodexApi, getRateGuardSnapshot as getCodexRateGuardSnapshot, } from "./upstream/codex-api.js";
 import { callGeminiApi, preflightGeminiApi, getGeminiRateGuardSnapshot, } from "./upstream/gemini-api.js";
 import { callAntigravityApi, preflightAntigravityApi, getAntigravityRateGuardSnapshot, } from "./upstream/antigravity-api.js";
+import { apiGet } from "../utils/api.js";
 /**
  * Pick the rate-guard snapshot matching this request's cli_type. Fixes a
  * pre-existing bug where gemini/codex responses were piggy-backing Claude's
@@ -305,6 +306,45 @@ async function executeRelayRequest(request, config, sendChunk) {
         };
     }
 }
+// ── Preflight helpers ──
+// Map a cli_type string to its preflight function. Returns null for
+// unknown types so the caller can skip them gracefully instead of
+// crashing the daemon.
+function getPreflightFn(cliType) {
+    switch (cliType) {
+        case "claude":
+            return preflightClaudeApi;
+        case "codex":
+            return preflightCodexApi;
+        case "gemini":
+            return preflightGeminiApi;
+        case "antigravity":
+            return preflightAntigravityApi;
+        default:
+            return null;
+    }
+}
+// Query the Hub for the full set of cli_types the current agent has
+// registered as relay providers. Used by the multi-cli daemon to decide
+// which upstream preflights to run. Returns null on any network / auth
+// failure — caller falls back to single-cli mode.
+async function fetchRegisteredCliTypes(config) {
+    try {
+        const resp = await apiGet("/api/v1/relay/providers/me", config.api_key);
+        if (!resp.ok || !Array.isArray(resp.data)) {
+            return null;
+        }
+        const seen = new Set();
+        for (const p of resp.data) {
+            if (typeof p.cli_type === "string" && p.cli_type)
+                seen.add(p.cli_type);
+        }
+        return Array.from(seen);
+    }
+    catch {
+        return null;
+    }
+}
 // ── Main daemon entry point ──
 export function runRelayProvider(cliOverride) {
     // Check for existing process
@@ -318,23 +358,76 @@ export function runRelayProvider(cliOverride) {
     // process.env.HTTPS_PROXY / http_proxy at init time. Must run BEFORE any
     // preflight call so the first outbound request already goes through it.
     applyProxyFromConfig(config);
-    // Validate the OAuth token + fingerprint up-front so we fail fast instead
-    // of on the first inbound request. Each cli_type has its own preflight
-    // path (different credential file, different fingerprint schema, different
-    // rate-guard instance).
-    const preflightFn = config.relay.cli_type === "codex"
-        ? preflightCodexApi
-        : config.relay.cli_type === "gemini"
-            ? preflightGeminiApi
-            : config.relay.cli_type === "claude"
-                ? preflightClaudeApi
-                : config.relay.cli_type === "antigravity"
-                    ? preflightAntigravityApi
-                    : null;
-    if (preflightFn) {
-        preflightFn(config.relay.rate_guard).catch((err) => {
-            logger.error(`${config.relay.cli_type} API preflight failed: ${err.message}`);
-            process.exit(1);
+    // Validate OAuth tokens + fingerprints up front so we fail fast on the
+    // happy path instead of on the first inbound request.
+    //
+    // Two modes:
+    //
+    // 1. Single-cli legacy mode — `--cli X` passed explicitly. Run only
+    //    that one preflight and fail-fast on error (preserves the old
+    //    behavior when the user knows exactly what they're starting).
+    //
+    // 2. Multi-cli auto mode — no `--cli` override. Query the Hub for the
+    //    full list of registered providers, collect their distinct
+    //    cli_types, and run each preflight in parallel. Per-cli failures
+    //    are tolerated (logged as a warning) so a broken codex OAuth
+    //    doesn't take down the claude half of the daemon.
+    //
+    // The Hub already dispatches requests by agent_id and stamps each
+    // relay_request with its target `cli_type` — provider.ts's request
+    // handler (`executeRelayRequest`) routes to the right upstream module
+    // based on that field. So from the Hub's point of view, a daemon that
+    // has preflighted multiple cli_types is just "a more capable provider".
+    if (cliOverride) {
+        // Legacy single-cli path.
+        const preflightFn = getPreflightFn(cliOverride);
+        if (preflightFn) {
+            preflightFn(config.relay.rate_guard).catch((err) => {
+                logger.error(`${cliOverride} API preflight failed: ${err.message}`);
+                process.exit(1);
+            });
+        }
+    }
+    else {
+        // Multi-cli auto mode — fire-and-forget, don't block startup on the
+        // HTTP round-trip. The WS connection can come up in parallel; the
+        // preflights only gate the FIRST call of each family, not the WS
+        // handshake.
+        (async () => {
+            const registered = await fetchRegisteredCliTypes(config);
+            if (!registered || registered.length === 0) {
+                logger.warn("Could not determine registered cli_types from Hub. " +
+                    "Falling back to config cli_type for preflight.");
+                const fallback = config.relay.cli_type;
+                const fn = getPreflightFn(fallback);
+                if (fn) {
+                    try {
+                        await fn(config.relay.rate_guard);
+                    }
+                    catch (err) {
+                        logger.warn(`${fallback} preflight failed: ${err.message}`);
+                    }
+                }
+                return;
+            }
+            logger.info(`Preflighting ${registered.length} registered cli_type(s): ${registered.join(", ")}`);
+            await Promise.all(registered.map(async (ct) => {
+                const fn = getPreflightFn(ct);
+                if (!fn) {
+                    logger.warn(`Unknown cli_type ${ct} — skipping preflight`);
+                    return;
+                }
+                try {
+                    await fn(config.relay.rate_guard);
+                    logger.info(`  ${ct} preflight OK`);
+                }
+                catch (err) {
+                    logger.warn(`  ${ct} preflight failed: ${err.message} — ` +
+                        `that family will NOT be able to serve requests until fixed`);
+                }
+            }));
+        })().catch((err) => {
+            logger.warn(`Multi-cli preflight driver error: ${err.message}`);
         });
     }
     const activeTasks = new Set();
@@ -419,5 +512,10 @@ export function runRelayProvider(cliOverride) {
     writeRelayPid();
     wsClient.start();
     logger.info("Relay Provider running. Listening for relay requests...");
-    logger.info(`Config: cli=${config.relay.cli_type}, model=${config.relay.model}, mode=${config.relay.mode}, concurrency=${config.relay.concurrency}`);
+    if (cliOverride) {
+        logger.info(`Config: cli=${cliOverride} (single), mode=${config.relay.mode}, concurrency=${config.relay.concurrency}`);
+    }
+    else {
+        logger.info(`Config: cli=auto (multi), mode=${config.relay.mode}, concurrency=${config.relay.concurrency}`);
+    }
 }

package/package.json

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