clawmoney 0.15.59 → 0.15.61

package/dist/commands/relay.js

@@ -120,11 +120,44 @@ export async function relayRegisterCommand(options) {
 // ── relay start ──
 export async function relayStartCommand(options) {
     const config = requireConfig();
-    // Check if already running
+    // If an old daemon is still running, auto-stop and replace it instead
+    // of bailing with "already running, use stop first". Previously re-
+    // running `clawmoney relay setup` (or `relay start`) with a previous
+    // daemon alive produced a confusing error at the last step of an
+    // otherwise-successful flow. SIGTERM → poll for exit (3s) →
+    // SIGKILL on stubborn processes → clean PID file → start fresh.
     const existingPid = readRelayPid();
     if (existingPid && isRelayPidAlive(existingPid)) {
-        console.log(chalk.yellow(`Relay Provider is already running (PID ${existingPid}). Use "clawmoney relay stop" first.`));
-        return;
+        const stopSpin = ora(`Replacing existing daemon (PID ${existingPid})...`).start();
+        try {
+            process.kill(existingPid, "SIGTERM");
+        }
+        catch {
+            // Process may have exited between readPid and kill — ignore.
+        }
+        const deadline = Date.now() + 3000;
+        while (Date.now() < deadline) {
+            if (!isRelayPidAlive(existingPid))
+                break;
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        if (isRelayPidAlive(existingPid)) {
+            try {
+                process.kill(existingPid, "SIGKILL");
+            }
+            catch {
+                // ignore
+            }
+            await new Promise((r) => setTimeout(r, 200));
+            stopSpin.warn(chalk.yellow(`Old daemon (PID ${existingPid}) didn't exit in 3s — forced SIGKILL`));
+        }
+        else {
+            stopSpin.succeed(chalk.dim(`Stopped old daemon (PID ${existingPid})`));
+        }
+        // The graceful-shutdown path in the daemon removes its own PID
+        // file, but SIGKILL leaves a stale one. Make sure we start from
+        // a clean slate either way.
+        removeRelayPid();
     }
     const spinner = ora("Starting Relay Provider...").start();
     try {
@@ -285,21 +318,31 @@ export async function relayStatusCommand() {
         const totalDailySpent = providers.reduce((s, p) => s + (p.daily_spent_usd ?? 0), 0);
         const totalDailyLimit = providers.reduce((s, p) => s + (p.daily_limit_usd ?? 0), 0);
         // Per-provider rows — compact table with status/cli/model/load.
-        const header = `  ${"STATUS".padEnd(9)} ${"CLI".padEnd(12)} ${"MODEL".padEnd(30)} ${"LOAD".padEnd(8)} ${"EARNED".padEnd(10)}`;
+        // QUARANTINED rows get a follow-up indented line showing the
+        // expected/got mismatch reason so the operator knows exactly what
+        // to fix — the WS notice also logs this when it first happens,
+        // but `relay status` is the after-the-fact checkpoint.
+        const header = `  ${"STATUS".padEnd(12)} ${"CLI".padEnd(12)} ${"MODEL".padEnd(30)} ${"LOAD".padEnd(8)} ${"EARNED".padEnd(10)}`;
         console.log(chalk.bold(header));
-        console.log(chalk.dim("  " + "─".repeat(75)));
+        console.log(chalk.dim("  " + "─".repeat(78)));
         for (const p of providers) {
-            const statusRaw = (p.status ?? "-").padEnd(9);
+            const statusRaw = (p.status ?? "-").padEnd(12);
             const statusColored = p.status === "online"
                 ? chalk.green(statusRaw)
-                : p.status === "offline"
-                    ? chalk.dim(statusRaw)
-                    : chalk.yellow(statusRaw);
+                : p.status === "quarantined"
+                    ? chalk.red(statusRaw)
+                    : p.status === "offline"
+                        ? chalk.dim(statusRaw)
+                        : chalk.yellow(statusRaw);
             const cli = (p.cli_type ?? "-").padEnd(12);
             const model = (p.model ?? "-").padEnd(30);
             const load = `${p.current_load ?? 0}/${p.concurrency ?? "-"}`.padEnd(8);
             const earned = `$${(p.total_earned_usd ?? 0).toFixed(2)}`.padEnd(10);
             console.log(`  ${statusColored} ${cli} ${model} ${load} ${earned}`);
+            if (p.status === "quarantined" && p.quarantine_reason) {
+                console.log(chalk.red(`    ↳ ${p.quarantine_reason}`) +
+                    chalk.dim("  (fix: restart daemon after correcting the subscription/registration)"));
+            }
         }
         console.log("");
         console.log(`  ${chalk.bold("Daily quota:")}  $${totalDailySpent.toFixed(2)} / $${totalDailyLimit.toFixed(2)}`);

package/dist/relay/provider.js

@@ -285,13 +285,23 @@ async function executeRelayRequest(request, config, sendChunk) {
                 status: snap.sessionWindow.status,
             };
         }
+        // CLAWMONEY_FAKE_MODEL_USED — test-only lever. When set, rewrite the
+        // reported `model_used` field to the env var's value before returning
+        // to the Hub. Used to manually exercise the Hub's model-mismatch guard
+        // + quarantine flow without having to juggle real subscription tiers
+        // or fake upstream accounts. DO NOT set this in production.
+        const fakeModelUsed = process.env.CLAWMONEY_FAKE_MODEL_USED;
+        const reportedModel = fakeModelUsed || parsed.model || model;
+        if (fakeModelUsed) {
+            logger.warn(`  ! CLAWMONEY_FAKE_MODEL_USED=${fakeModelUsed} — reporting fake model to Hub (test mode)`);
+        }
         return {
             event: "relay_response",
             request_id,
             content: parsed.text,
             cli_session_id: parsed.sessionId || undefined,
             usage: parsed.usage,
-            model_used: parsed.model || model,
+            model_used: reportedModel,
             cost_usd: parsed.costUsd || undefined,
             session_window: sessionWindowTelemetry,
         };
@@ -447,6 +457,18 @@ export function runRelayProvider(cliOverride) {
             case "error":
                 logger.error(`Server error: ${event.message}`);
                 break;
+            case "relay_notice":
+                // Loud WARN for the human operator. Quarantine notices are the
+                // most important kind — they mean buyers are going to stop
+                // seeing this provider until the daemon is restarted, so we
+                // don't want them buried in the log.
+                logger.warn(`[NOTICE ${event.notice_type}] ${event.message}`);
+                if (event.notice_type === "model_mismatch_quarantine" &&
+                    event.expected_model &&
+                    event.got_model) {
+                    logger.warn(`  expected=${event.expected_model}  got=${event.got_model}  cli=${event.cli_type ?? "?"}`);
+                }
+                break;
             default:
                 logger.warn("Unknown event:", event);
         }

package/dist/relay/types.d.ts

@@ -30,7 +30,15 @@ export interface RelayErrorEvent {
     event: "error";
     message: string;
 }
-export type RelayIncomingEvent = RelayRequest | RelayConnectedEvent | RelayErrorEvent;
+export interface RelayNoticeEvent {
+    event: "relay_notice";
+    notice_type: string;
+    cli_type?: string;
+    expected_model?: string;
+    got_model?: string;
+    message: string;
+}
+export type RelayIncomingEvent = RelayRequest | RelayConnectedEvent | RelayErrorEvent | RelayNoticeEvent;
 export interface RelayResponseSessionWindow {
     reset_at_ms: number;
     utilization?: number;

package/package.json

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