clawmoney 0.17.8 → 0.17.9

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

@@ -1 +1,3 @@
-export declare function marketSetupCommand(): Promise<void>;
+export declare function marketSetupCommand(opts?: {
+    nested?: boolean;
+}): Promise<void>;

package/dist/commands/market-setup.js

@@ -88,10 +88,11 @@ function validatePrice(value) {
         return "Price looks unreasonable (> $10,000)";
     return undefined;
 }
-export async function marketSetupCommand() {
+export async function marketSetupCommand(opts = {}) {
     // Step 0: ensure the agent is logged in. Mirrors relaySetupCommand's
     // handoff to setupCommand so first-time users get a clean flow instead
-    // of "No config found" mid-wizard.
+    // of "No config found" mid-wizard. Skipped when nested under
+    // `clawmoney setup` since that command already guarantees a config.
     let existing = loadConfig();
     if (!existing) {
         await setupCommand();
@@ -103,24 +104,44 @@ export async function marketSetupCommand() {
         console.log("");
     }
     const config = existing;
-    intro(chalk.cyan(" ClawMoney Market Setup "));
+    if (!opts.nested) {
+        intro(chalk.cyan(" ClawMoney Market Setup "));
+    }
     log.message("Register one or more skills on the Market so other agents can call (and pay) you.");
-    // ── Step 1: multiselect categories (the big difference vs relay setup —
-    // each picked category becomes one skill, no dupes within this run) ──
+    // ── Step 1: multiselect categories. Grouped visually: Instant first,
+    // then Escrow, then Auto. clack's multiselect has no native separators,
+    // so we fake them with disabled-looking header rows whose value is a
+    // sentinel — selecting one is a no-op (filtered out downstream). ──
+    const INSTANT_HEADER = "__hdr_instant__";
+    const ESCROW_HEADER = "__hdr_escrow__";
+    const AUTO_HEADER = "__hdr_auto__";
+    const HEADERS = new Set([INSTANT_HEADER, ESCROW_HEADER, AUTO_HEADER]);
+    const instantRows = CATEGORIES.filter((c) => c.routing === "instant");
+    const escrowRows = CATEGORIES.filter((c) => c.routing === "escrow");
+    const autoRows = CATEGORIES.filter((c) => c.routing === "auto");
+    const groupedOptions = [
+        { value: INSTANT_HEADER, label: chalk.dim("── Instant · poll for result ──"), hint: "" },
+        ...instantRows.map((row) => ({ value: row.value, label: `  ${row.value}`, hint: formatHint(row) })),
+        { value: ESCROW_HEADER, label: chalk.dim("── Escrow · manual approve ──"), hint: "" },
+        ...escrowRows.map((row) => ({ value: row.value, label: `  ${row.value}`, hint: formatHint(row) })),
+        { value: AUTO_HEADER, label: chalk.dim("── Auto · routed by price ──"), hint: "" },
+        ...autoRows.map((row) => ({ value: row.value, label: `  ${row.value}`, hint: formatHint(row) })),
+    ];
     const picked = await multiselect({
         message: "Pick the skill categories to register (space to toggle, enter to confirm):",
-        options: CATEGORIES.map((row) => ({
-            value: row.value,
-            label: row.value,
-            hint: formatHint(row),
-        })),
+        options: groupedOptions,
         required: true,
     });
     if (isCancel(picked)) {
         cancel("Setup cancelled");
         process.exit(0);
     }
-    const pickedCategories = picked;
+    // Strip header sentinels — they're visual-only group separators.
+    const pickedCategories = picked.filter((v) => !HEADERS.has(v));
+    if (pickedCategories.length === 0) {
+        cancel("No categories selected");
+        process.exit(0);
+    }
     // Preserve the canonical CATEGORIES order rather than the click order —
     // makes the per-skill prompts and the review table read consistently.
     const orderedRows = CATEGORIES.filter((c) => pickedCategories.includes(c.value));
@@ -224,7 +245,7 @@ export async function marketSetupCommand() {
     }
     const okCount = results.filter((r) => r.ok).length;
     const failCount = results.length - okCount;
-    outro([
+    const summary = [
         failCount === 0
             ? chalk.green(`All ${okCount} skills registered.`)
             : okCount === 0
@@ -233,8 +254,16 @@ export async function marketSetupCommand() {
         "",
         chalk.dim(`Next: run ${chalk.cyan("clawmoney market start")} to accept incoming calls in the background.`),
         chalk.dim(`      See your skills listed: ${chalk.cyan("clawmoney market skills")}`),
-    ].join("\n"));
-    if (failCount > 0) {
+    ].join("\n");
+    if (opts.nested) {
+        // Don't close the parent wizard's intro frame — emit the summary as a
+        // log message and let the parent wrap up the whole flow at the end.
+        log.message(summary);
+    }
+    else {
+        outro(summary);
+    }
+    if (failCount > 0 && !opts.nested) {
         process.exit(1);
     }
 }

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

@@ -0,0 +1,7 @@
+/**
+ * Provider setup wizard. Assumes the agent is already registered
+ * (api_key in ~/.clawmoney/config.yaml). Callable on its own — used both
+ * as the post-register step of `clawmoney setup` and as a re-entry point
+ * for users who want to add roles after their first setup.
+ */
+export declare function providerSetupWizard(): Promise<void>;

package/dist/commands/provider-setup.js

@@ -0,0 +1,94 @@
+import { multiselect, isCancel, log, note, } from "@clack/prompts";
+import chalk from "chalk";
+import { loadConfig } from "../utils/config.js";
+const ROLES = [
+    {
+        value: "market",
+        label: "Market skills",
+        hint: "image gen / code / translate / tts / ... — agents pay you per call",
+    },
+    {
+        value: "relay",
+        label: "Relay",
+        hint: "sell idle Claude Max / ChatGPT Pro / Gemini quota at 20% of API price",
+    },
+    {
+        value: "verifier",
+        label: "Verifier",
+        hint: "witness tweet promote tasks — $0.01 per verification, runs in background",
+    },
+];
+/**
+ * Provider setup wizard. Assumes the agent is already registered
+ * (api_key in ~/.clawmoney/config.yaml). Callable on its own — used both
+ * as the post-register step of `clawmoney setup` and as a re-entry point
+ * for users who want to add roles after their first setup.
+ */
+export async function providerSetupWizard() {
+    if (!loadConfig()) {
+        console.log(chalk.red("\n  No agent config found. Run `clawmoney setup` first to register.\n"));
+        process.exit(1);
+    }
+    log.message(chalk.bold("Provider roles") +
+        chalk.dim(" — pick what you want to earn from. You can re-run this anytime."));
+    const picked = await multiselect({
+        message: "Provider roles (space to toggle, enter to confirm):",
+        options: ROLES.map((r) => ({
+            value: r.value,
+            label: r.label,
+            hint: r.hint,
+        })),
+        required: false, // user is allowed to skip — they may have just come to register
+    });
+    if (isCancel(picked)) {
+        log.message(chalk.dim("Skipped. Re-run `clawmoney setup` later to enable provider roles."));
+        return;
+    }
+    const roles = picked;
+    if (roles.length === 0) {
+        note([
+            chalk.dim("No roles enabled. You can still:"),
+            `  ${chalk.cyan("clawmoney browse")}          browse engage tasks`,
+            `  ${chalk.cyan("clawmoney promote")}         work on promote tasks`,
+            "",
+            chalk.dim("Or re-run `clawmoney setup` later to enable provider roles."),
+        ].join("\n"), "Done");
+        return;
+    }
+    // Sort picked roles in canonical ROLES order so the wizard always runs
+    // the same sequence (market → relay → verifier) regardless of click order.
+    const ordered = ROLES.filter((r) => roles.includes(r.value)).map((r) => r.value);
+    for (let i = 0; i < ordered.length; i++) {
+        const role = ordered[i];
+        log.step(`${chalk.bold(`[${i + 1}/${ordered.length}]`)} ${role}`);
+        try {
+            if (role === "market") {
+                const { marketSetupCommand } = await import("./market-setup.js");
+                await marketSetupCommand({ nested: true });
+            }
+            else if (role === "relay") {
+                const { relaySetupCommand } = await import("./relay-setup.js");
+                await relaySetupCommand();
+            }
+            else if (role === "verifier") {
+                const { verifierSetupCommand } = await import("./verifier-setup.js");
+                await verifierSetupCommand({ nested: true });
+            }
+        }
+        catch (err) {
+            log.error(`${role} setup failed: ${err.message}. ` +
+                `You can retry with \`clawmoney ${role} setup\` later.`);
+            // Don't abort the rest — let the user finish other roles. They can
+            // come back to the failed one separately.
+        }
+    }
+    note([
+        chalk.green(`${ordered.length} role${ordered.length === 1 ? "" : "s"} configured.`),
+        "",
+        chalk.dim("Useful next commands:"),
+        `  ${chalk.cyan("clawmoney market skills")}      list your registered skills`,
+        `  ${chalk.cyan("clawmoney market start")}       start the market provider daemon`,
+        `  ${chalk.cyan("clawmoney relay start")}        start the relay daemon`,
+        `  ${chalk.cyan("tail -f ~/.clawmoney/*.log")}  watch all daemons`,
+    ].join("\n"), "All done");
+}

package/dist/commands/setup.js

@@ -38,6 +38,22 @@ export async function setupCommand() {
         console.log('');
         return;
     }
+    // Short-circuit: if an agent is already configured, skip the OTP + claim
+    // flow and jump straight to provider role selection. This makes re-running
+    // `clawmoney setup` cheap — users add new provider roles without going
+    // through email verification every time.
+    const existing = loadConfig();
+    if (existing?.api_key && existing?.agent_slug) {
+        console.log(chalk.green('  Agent already configured.'));
+        console.log(chalk.dim(`    Slug:   ${existing.agent_slug}`));
+        if (existing.wallet_address) {
+            console.log(chalk.dim(`    Wallet: ${existing.wallet_address}`));
+        }
+        console.log('');
+        const { providerSetupWizard } = await import('./provider-setup.js');
+        await providerSetupWizard();
+        return;
+    }
     // Step 1: Ask for email.
     const email = await prompt(chalk.cyan('? ') + 'Enter your email: ');
     if (!email || !email.includes('@')) {
@@ -228,9 +244,9 @@ export async function setupCommand() {
         console.log(chalk.dim(`  Config:      ${getConfigPath()}`));
     }
     console.log('');
-    console.log(`  Next steps:`);
-    console.log(`    ${chalk.cyan('clawmoney browse')}          Browse available tasks`);
-    console.log(`    ${chalk.cyan('clawmoney wallet balance')}  Check your wallet balance`);
-    console.log(`    ${chalk.cyan('clawmoney promote submit')}  Submit a task proof`);
-    console.log('');
+    // Continue into provider role selection. First-time users go straight
+    // from "agent claimed" → "pick what to earn from" without ever needing
+    // to remember a second command. They can still skip (no role = no role).
+    const { providerSetupWizard } = await import('./provider-setup.js');
+    await providerSetupWizard();
 }

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

@@ -0,0 +1,3 @@
+export declare function verifierSetupCommand(opts?: {
+    nested?: boolean;
+}): Promise<void>;

package/dist/commands/verifier-setup.js

@@ -0,0 +1,84 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { intro, outro, confirm, spinner, isCancel, log, note, } from "@clack/prompts";
+import chalk from "chalk";
+import { loadConfig } from "../utils/config.js";
+const LOG_FILE = join(homedir(), ".clawmoney", "verifier.log");
+// Auto-verifier polls every 15 minutes and verifies up to 3 tweets per cycle.
+// Each verification pays $0.01 via x402 witness. Upper bound at 24/7 saturation
+// is 3 × 4/hr × 24 × 30 = 8,640/mo, but real demand caps it much lower —
+// we deliberately quote the per-cycle rate so users see honest numbers.
+const VERIFICATIONS_PER_CYCLE = 3;
+const POLL_INTERVAL_MIN = 15;
+const PRICE_PER_VERIFICATION = 0.01;
+function formatEarnings() {
+    const perHour = (60 / POLL_INTERVAL_MIN) * VERIFICATIONS_PER_CYCLE * PRICE_PER_VERIFICATION;
+    const perDay = perHour * 24;
+    const perMonth = perDay * 30;
+    return [
+        `Per cycle:  $${(VERIFICATIONS_PER_CYCLE * PRICE_PER_VERIFICATION).toFixed(2)} (${VERIFICATIONS_PER_CYCLE} verifications × $${PRICE_PER_VERIFICATION})`,
+        `Cycle:      every ${POLL_INTERVAL_MIN} minutes`,
+        `Upper bound: ~$${perHour.toFixed(2)}/hr · ~$${perDay.toFixed(2)}/day · ~$${perMonth.toFixed(0)}/mo`,
+        chalk.dim("Actual earnings depend on how many tasks are awaiting verification."),
+    ].join("\n");
+}
+export async function verifierSetupCommand(opts = {}) {
+    if (!loadConfig()) {
+        console.log(chalk.red("\n  No config found. Run `clawmoney setup` first to register your agent.\n"));
+        process.exit(1);
+    }
+    if (!opts.nested) {
+        intro(chalk.cyan(" ClawMoney Verifier Setup "));
+    }
+    log.message("Run an auto-verifier daemon that earns by witnessing tweet promote tasks.");
+    note(formatEarnings(), "Earnings model");
+    const startNow = await confirm({
+        message: "Start the verifier daemon in the background now?",
+        initialValue: true,
+    });
+    if (isCancel(startNow)) {
+        log.message(chalk.dim("Skipped. Run `clawmoney promote auto-verify` later to start manually."));
+        if (!opts.nested)
+            outro("");
+        return;
+    }
+    if (!startNow) {
+        log.message(chalk.dim(`Skipped daemon launch. Manual start: ${chalk.cyan("clawmoney promote auto-verify")}`));
+        if (!opts.nested)
+            outro("");
+        return;
+    }
+    // Daemon launch: spawn detached so it survives this process exiting.
+    // stdout/stderr go to ~/.clawmoney/verifier.log — same pattern as relay
+    // daemon. We deliberately don't `setsid` here; users on macOS run from a
+    // GUI shell and the parent's session id is fine.
+    const claw = process.execPath; // node binary path; clawmoney bin script runs through it
+    const cliMain = process.argv[1]; // path to dist/index.js
+    const s = spinner();
+    s.start("Spawning verifier daemon...");
+    try {
+        const out = await import("node:fs").then((m) => m.openSync(LOG_FILE, "a"));
+        const child = spawn(claw, [cliMain, "promote", "auto-verify"], {
+            detached: true,
+            stdio: ["ignore", out, out],
+            env: process.env,
+        });
+        child.unref();
+        s.stop(`${chalk.green("✓")} Verifier daemon started (pid ${child.pid})`);
+        log.message([
+            chalk.dim(`Logs:      ${LOG_FILE}`),
+            chalk.dim(`Tail:      tail -f ${LOG_FILE}`),
+            chalk.dim(`Stop:      kill ${child.pid}`),
+            "",
+            chalk.dim("Tip: to keep it running across reboots, wrap it in a launchd plist"),
+            chalk.dim("(same pattern as scripts/install-daemon-launchd.sh in this repo)."),
+        ].join("\n"));
+    }
+    catch (err) {
+        s.stop(chalk.red(`Failed to spawn verifier: ${err.message}`));
+    }
+    if (!opts.nested) {
+        outro(chalk.green("Verifier setup done."));
+    }
+}

package/dist/index.js

@@ -21,7 +21,7 @@ program
 // setup
 program
     .command('setup')
-    .description('One-click agent onboarding: wallet + registration')
+    .description('One-stop setup: register agent (first run) + pick provider roles (market / relay / verifier)')
     .action(async () => {
     try {
         await setupCommand();

package/package.json

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