clawmoney 0.15.31 → 0.15.32

package/dist/commands/relay-setup.js

@@ -195,7 +195,7 @@ export async function relaySetupCommand() {
             log.warn(`${cli}: no recommended models found — skipping`);
             continue;
         }
-        log.step(`${chalk.bold(cli)}: ${recommended.length} models ${chalk.dim("— " + recommended.join(", "))}`);
+        log.success(`${chalk.bold(cli)}: ${recommended.length} models ${chalk.dim("— " + recommended.join(", "))}`);
         for (const model of recommended) {
             const p = API_PRICES[model];
             registrations.push({
@@ -285,18 +285,18 @@ export async function relaySetupCommand() {
         15: "~25%", 30: "~50%", 45: "~75%", 60: "~100%",
     };
     const earnPct = Math.round((1 - PLATFORM_FEE) * 100);
+    // Single batch POST — one round-trip, one DB session, no
+    // client-side fan-out. The earlier sequential loop paid 7× the
+    // TLS/bcrypt/CF overhead, and parallelizing with Promise.all
+    // tripped over client- or proxy-level concurrency limits on some
+    // machines. Batch endpoint is the right architecture.
     let succeeded = 0;
     let failed = 0;
     const failures = [];
     const regSpin = spinner();
     regSpin.start(`Registering ${registrations.length} providers...`);
-    // Parallel registration — each request creates a distinct RelayProvider
-    // row so there's no write contention, and the backend's insert path is
-    // idempotent on (agent_id, cli_type, model). Sequential registration
-    // was costing ~1 RTT per row, which on a high-latency link (e.g. from
-    // China) added up to 7-10s of visible wait for 7 providers.
-    await Promise.all(registrations.map(async (r) => {
-        const body = {
+    const batchBody = {
+        providers: registrations.map((r) => ({
             cli_type: r.cli,
             model: r.model,
             mode: "chat",
@@ -304,32 +304,31 @@ export async function relaySetupCommand() {
             daily_limit_usd: dailyLimit,
             price_input_per_m: r.input,
             price_output_per_m: r.output,
-        };
-        try {
-            const resp = await apiPost("/api/v1/relay/providers", body, config.api_key);
-            if (resp.ok) {
-                succeeded++;
-                return;
-            }
+        })),
+    };
+    try {
+        const resp = await apiPost("/api/v1/relay/providers/batch", batchBody, config.api_key);
+        if (!resp.ok) {
             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")) {
-                succeeded++;
-            }
-            else {
-                failed++;
-                failures.push({ cli: r.cli, model: r.model, error: detail });
-            }
+            regSpin.stop(chalk.red(`✗ Batch registration failed: ${detail}`));
+            cancel("Setup aborted");
+            process.exit(1);
         }
-        catch (err) {
-            const msg = err.message;
-            failed++;
-            failures.push({ cli: r.cli, model: r.model, error: msg });
+        // Per-row counts from the batch result.
+        succeeded = (resp.data.created?.length ?? 0) + (resp.data.skipped?.length ?? 0);
+        failed = resp.data.failed?.length ?? 0;
+        for (const f of resp.data.failed ?? []) {
+            failures.push({ cli: f.cli_type, model: f.model, error: f.error });
         }
-    }));
+    }
+    catch (err) {
+        regSpin.stop(chalk.red(`✗ Batch registration failed: ${err.message}`));
+        cancel("Setup aborted");
+        process.exit(1);
+    }
     if (failed === 0) {
         regSpin.stop(`${chalk.green(`✓ ${succeeded} providers registered`)}  ` +
             chalk.dim(`(${limitLabel[dailyLimit] ?? `$${dailyLimit}`} quota share · you earn ~${earnPct}%)`));

package/dist/commands/relay.d.ts

@@ -12,6 +12,10 @@ export declare function relayStartCommand(options: {
     cli?: string;
 }): Promise<void>;
 export declare function relayStopCommand(): Promise<void>;
+export declare function relayLogsCommand(options: {
+    follow?: boolean;
+    lines?: string;
+}): Promise<void>;
 export declare function relayStatusCommand(): Promise<void>;
 export declare function relayModelsCommand(): Promise<void>;
 export declare function relayCreditsCommand(): Promise<void>;

package/dist/commands/relay.js

@@ -192,6 +192,32 @@ export async function relayStopCommand() {
     await new Promise((resolve) => setTimeout(resolve, 500));
     removeRelayPid();
 }
+// ── relay logs ──
+export async function relayLogsCommand(options) {
+    const { existsSync } = await import("node:fs");
+    const { spawn } = await import("node:child_process");
+    if (!existsSync(LOG_FILE)) {
+        console.log(chalk.dim(`No log file yet at ${LOG_FILE}`));
+        console.log(chalk.dim("Start the daemon first: clawmoney relay start"));
+        return;
+    }
+    // Default: tail -f the last 50 lines. Use system `tail` rather than
+    // reimplementing it in Node — it's just a debug helper, not worth
+    // a pure-JS reinvention.
+    const nLines = options.lines ?? "50";
+    const args = ["-n", nLines];
+    if (options.follow !== false) {
+        args.push("-f");
+    }
+    args.push(LOG_FILE);
+    const child = spawn("tail", args, { stdio: "inherit" });
+    child.on("exit", (code) => {
+        process.exit(code ?? 0);
+    });
+    // Ctrl-C inside `tail -f` kills tail but returns us here; propagate
+    // the exit code so the wrapper looks transparent.
+    process.on("SIGINT", () => child.kill("SIGINT"));
+}
 export async function relayStatusCommand() {
     const config = requireConfig();
     // Local process status
@@ -237,6 +263,19 @@ export async function relayStatusCommand() {
             console.log(chalk.dim(`  Run "clawmoney relay setup" to get started.`));
             return;
         }
+        // Group rows by cli_type so `claude-*` lines stay together, then
+        // `codex-*`, then `gemini-*`, then `antigravity-*`. Within a family
+        // we sort by model name so the ordering is stable across calls.
+        const CLI_ORDER = ["claude", "codex", "gemini", "antigravity"];
+        providers.sort((a, b) => {
+            const ai = CLI_ORDER.indexOf(a.cli_type ?? "");
+            const bi = CLI_ORDER.indexOf(b.cli_type ?? "");
+            const aRank = ai === -1 ? CLI_ORDER.length : ai;
+            const bRank = bi === -1 ? CLI_ORDER.length : bi;
+            if (aRank !== bRank)
+                return aRank - bRank;
+            return (a.model ?? "").localeCompare(b.model ?? "");
+        });
         spinner.succeed(`Relay Providers (${providers.length})`);
         console.log("");
         // Aggregate stats across all rows since users think of earnings /

package/dist/index.js

@@ -8,7 +8,7 @@ import { walletStatusCommand, walletBalanceCommand, walletAddressCommand, wallet
 import { tweetCommand } from './commands/tweet.js';
 import { gigCreateCommand, gigBrowseCommand, gigDetailCommand, gigAcceptCommand, gigDeliverCommand, gigApproveCommand, gigDisputeCommand, } from './commands/gig.js';
 import { hubStartCommand, hubStopCommand, hubStatusCommand, hubSearchCommand, hubCallCommand, hubRegisterCommand, hubSkillsCommand, hubOrderCommand, hubHistoryCommand, } from './commands/hub.js';
-import { relayRegisterCommand, relayStartCommand, relayStopCommand, relayStatusCommand, relayModelsCommand, relayCreditsCommand, } from './commands/relay.js';
+import { relayRegisterCommand, relayStartCommand, relayStopCommand, relayStatusCommand, relayModelsCommand, relayCreditsCommand, relayLogsCommand, } from './commands/relay.js';
 import { antigravityLoginCommand, antigravityStatusCommand, } from './commands/antigravity.js';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
@@ -527,6 +527,20 @@ relay
         process.exit(1);
     }
 });
+relay
+    .command('logs')
+    .description('Tail the daemon log in real time (like `tail -f ~/.clawmoney/relay.log`)')
+    .option('-n, --lines <n>', 'Lines of history to show before following', '50')
+    .option('--no-follow', "Print and exit instead of following")
+    .action(async (options) => {
+    try {
+        await relayLogsCommand(options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 relay
     .command('models')
     .description('List available relay models')

package/package.json

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