clawmoney 0.7.2 → 0.8.1

package/dist/commands/browse.js

@@ -16,9 +16,9 @@ function truncate(str, maxLen) {
         return '-';
     return str.length > maxLen ? str.slice(0, maxLen - 1) + '...' : str;
 }
-function printBoostTable(tasks) {
+function printEngageTable(tasks) {
     if (tasks.length === 0) {
-        console.log(chalk.dim('  No boost tasks found.'));
+        console.log(chalk.dim('  No engage tasks found.'));
         return;
     }
     // Header
@@ -34,9 +34,9 @@ function printBoostTable(tasks) {
         console.log(`  ${chalk.cyan(id.padEnd(8))} ${title.padEnd(30)} ${chalk.green(reward.padEnd(10))} ${budget.padEnd(10)} ${joined.padEnd(8)} ${status.padEnd(10)}`);
     }
 }
-function printHireTable(tasks) {
+function printPromoteTable(tasks) {
     if (tasks.length === 0) {
-        console.log(chalk.dim('  No hire tasks found.'));
+        console.log(chalk.dim('  No promote tasks found.'));
         return;
     }
     // Header
@@ -55,46 +55,46 @@ function printHireTable(tasks) {
 export async function browseCommand(options) {
     const config = loadConfig();
     const apiKey = config?.api_key;
-    const taskType = options.type || 'boost';
+    const taskType = options.type || 'engage';
     const status = options.status || 'active';
     const limit = parseInt(options.limit || '10', 10);
     console.log('');
-    if (taskType === 'hire' || taskType === 'all') {
-        const hireSpinner = ora('Fetching hire tasks...').start();
+    if (taskType === 'promote' || taskType === 'all') {
+        const promoteSpinner = ora('Fetching promote tasks...').start();
         try {
-            const resp = await apiGet(`/api/v1/hire/?status=${status}&sort_by=total_budget&sort_order=desc&limit=${limit}`, apiKey);
+            const resp = await apiGet(`/api/v1/promote/?status=${status}&sort_by=total_budget&sort_order=desc&limit=${limit}`, apiKey);
             if (!resp.ok) {
-                hireSpinner.fail(`Failed to fetch hire tasks (${resp.status})`);
+                promoteSpinner.fail(`Failed to fetch promote tasks (${resp.status})`);
             }
             else {
                 const body = resp.data;
                 const tasks = (body.data || (Array.isArray(body) ? body : []));
-                hireSpinner.succeed(`Hire Tasks (${tasks.length})`);
-                printHireTable(tasks);
+                promoteSpinner.succeed(`Promote Tasks (${tasks.length})`);
+                printPromoteTable(tasks);
             }
         }
         catch (err) {
-            hireSpinner.fail('Failed to fetch hire tasks');
+            promoteSpinner.fail('Failed to fetch promote tasks');
             console.error(chalk.red(err.message));
         }
         console.log('');
     }
-    if (taskType === 'boost' || taskType === 'all') {
-        const boostSpinner = ora('Fetching boost tasks...').start();
+    if (taskType === 'engage' || taskType === 'all') {
+        const engageSpinner = ora('Fetching engage tasks...').start();
         try {
-            const resp = await apiGet(`/api/v1/boost/?status=${status}&limit=${limit}`, apiKey);
+            const resp = await apiGet(`/api/v1/engage/?status=${status}&limit=${limit}`, apiKey);
             if (!resp.ok) {
-                boostSpinner.fail(`Failed to fetch boost tasks (${resp.status})`);
+                engageSpinner.fail(`Failed to fetch engage tasks (${resp.status})`);
             }
             else {
                 const body = resp.data;
                 const tasks = (body.data || (Array.isArray(body) ? body : []));
-                boostSpinner.succeed(`Boost Tasks (${tasks.length})`);
-                printBoostTable(tasks);
+                engageSpinner.succeed(`Engage Tasks (${tasks.length})`);
+                printEngageTable(tasks);
             }
         }
         catch (err) {
-            boostSpinner.fail('Failed to fetch boost tasks');
+            engageSpinner.fail('Failed to fetch engage tasks');
             console.error(chalk.red(err.message));
         }
         console.log('');

package/dist/commands/hub.d.ts

@@ -0,0 +1,14 @@
+export declare function hubStartCommand(options: {
+    cli?: string;
+}): Promise<void>;
+export declare function hubStopCommand(): Promise<void>;
+export declare function hubStatusCommand(): Promise<void>;
+interface RegisterOptions {
+    name: string;
+    category: string;
+    description: string;
+    price: string;
+}
+export declare function hubRegisterCommand(options: RegisterOptions): Promise<void>;
+export declare function hubSkillsCommand(): Promise<void>;
+export {};

package/dist/commands/hub.js

@@ -0,0 +1,164 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import chalk from "chalk";
+import ora from "ora";
+import { requireConfig } from "../utils/config.js";
+import { apiGet, apiPost } from "../utils/api.js";
+import { readPid, isPidAlive, removePid } from "../hub/provider.js";
+const LOG_FILE = join(homedir(), ".clawmoney", "provider.log");
+// ── hub start ──
+export async function hubStartCommand(options) {
+    const config = requireConfig();
+    // Check if already running
+    const existingPid = readPid();
+    if (existingPid && isPidAlive(existingPid)) {
+        console.log(chalk.yellow(`Hub Provider is already running (PID ${existingPid}). Use "clawmoney hub stop" first.`));
+        return;
+    }
+    const spinner = ora("Starting Hub Provider...").start();
+    try {
+        // Spawn the daemon process using node with a special env flag
+        // The daemon will re-import provider.ts and call runProvider()
+        const daemonScript = join(import.meta.url.replace("file://", "").replace(/\/commands\/hub\.js$/, ""), "hub", "daemon.js");
+        const args = [daemonScript];
+        if (options.cli) {
+            args.push("--cli", options.cli);
+        }
+        const child = spawn(process.execPath, args, {
+            stdio: "ignore",
+            detached: true,
+            env: {
+                ...process.env,
+                CLAWMONEY_DAEMON: "1",
+            },
+        });
+        child.unref();
+        // Give the daemon a moment to start and write PID
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const pid = readPid();
+        if (pid && isPidAlive(pid)) {
+            spinner.succeed(chalk.green(`Hub Provider started (PID ${pid})`));
+            console.log(chalk.dim(`  Log file: ${LOG_FILE}`));
+            console.log(chalk.dim(`  CLI command: ${options.cli || "claude"}`));
+            console.log(chalk.dim(`  API key: ${config.api_key.slice(0, 8)}...`));
+        }
+        else {
+            spinner.fail(chalk.red("Failed to start Hub Provider. Check logs at: " + LOG_FILE));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk.red("Failed to start Hub Provider"));
+        throw err;
+    }
+}
+// ── hub stop ──
+export async function hubStopCommand() {
+    const pid = readPid();
+    if (!pid) {
+        console.log(chalk.dim("Hub Provider is not running (no PID file)."));
+        return;
+    }
+    if (!isPidAlive(pid)) {
+        console.log(chalk.dim(`Hub Provider PID ${pid} is not alive. Cleaning up PID file.`));
+        removePid();
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(chalk.green(`Hub Provider stopped (PID ${pid}).`));
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to stop process ${pid}:`), err.message);
+    }
+    // Wait briefly for cleanup, then ensure PID file is removed
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    removePid();
+}
+// ── hub status ──
+export async function hubStatusCommand() {
+    const pid = readPid();
+    if (!pid) {
+        console.log(chalk.dim("Hub Provider is not running."));
+        return;
+    }
+    if (isPidAlive(pid)) {
+        console.log(chalk.green(`Hub Provider is running (PID ${pid}).`));
+        console.log(chalk.dim(`  Log file: ${LOG_FILE}`));
+    }
+    else {
+        console.log(chalk.yellow(`Hub Provider PID ${pid} is not alive (stale PID file).`));
+        removePid();
+    }
+}
+export async function hubRegisterCommand(options) {
+    const config = requireConfig();
+    const price = parseFloat(options.price);
+    if (isNaN(price) || price < 0) {
+        console.error(chalk.red("Invalid price. Must be a non-negative number."));
+        process.exit(1);
+    }
+    const spinner = ora("Registering skill...").start();
+    try {
+        const resp = await apiPost("/api/v1/hub/skills", {
+            name: options.name,
+            category: options.category,
+            description: options.description,
+            price_per_call: price,
+        }, config.api_key);
+        if (!resp.ok) {
+            const detail = resp.data && typeof resp.data === "object" && "detail" in resp.data
+                ? resp.data.detail
+                : JSON.stringify(resp.data);
+            spinner.fail(chalk.red(`Failed to register skill (${resp.status}): ${detail}`));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green("Skill registered successfully!"));
+        console.log("");
+        console.log(`  ${chalk.bold("Name:")}      ${options.name}`);
+        console.log(`  ${chalk.bold("Category:")}  ${options.category}`);
+        console.log(`  ${chalk.bold("Price:")}     $${price.toFixed(2)}/call`);
+    }
+    catch (err) {
+        spinner.fail(chalk.red("Failed to register skill"));
+        throw err;
+    }
+}
+export async function hubSkillsCommand() {
+    const config = requireConfig();
+    const spinner = ora("Fetching skills...").start();
+    try {
+        const resp = await apiGet("/api/v1/hub/skills/mine", config.api_key);
+        if (!resp.ok) {
+            spinner.fail(chalk.red(`Failed to fetch skills (${resp.status})`));
+            process.exit(1);
+        }
+        const skills = Array.isArray(resp.data)
+            ? resp.data
+            : resp.data.data ?? [];
+        spinner.succeed(`My Skills (${skills.length})`);
+        console.log("");
+        if (skills.length === 0) {
+            console.log(chalk.dim('  No skills registered. Use "clawmoney hub register" to add one.'));
+            return;
+        }
+        // Table header
+        console.log(chalk.bold(`  ${"Name".padEnd(20)} ${"Category".padEnd(20)} ${"Price".padEnd(10)} ${"Calls".padEnd(8)} ${"Status".padEnd(10)}`));
+        console.log(chalk.dim("  " + "-".repeat(70)));
+        for (const skill of skills) {
+            const name = (skill.name ?? "-").slice(0, 19);
+            const category = (skill.category ?? "-").slice(0, 19);
+            const price = skill.price_per_call !== undefined
+                ? `$${skill.price_per_call.toFixed(2)}`
+                : "-";
+            const calls = String(skill.call_count ?? "-");
+            const status = skill.status ?? "-";
+            console.log(`  ${chalk.cyan(name.padEnd(20))} ${category.padEnd(20)} ${chalk.green(price.padEnd(10))} ${calls.padEnd(8)} ${status.padEnd(10)}`);
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk.red("Failed to fetch skills"));
+        throw err;
+    }
+}

package/dist/commands/promote.d.ts

@@ -0,0 +1,14 @@
+interface SubmitOptions {
+    url: string;
+    platform?: string;
+    text?: string;
+}
+interface VerifyOptions {
+    witness?: boolean;
+    relevance: string;
+    quality: string;
+    vote?: string;
+}
+export declare function promoteSubmitCommand(taskId: string, options: SubmitOptions): Promise<void>;
+export declare function promoteVerifyCommand(submissionId: string, options: VerifyOptions): Promise<void>;
+export {};

package/dist/commands/promote.js

@@ -0,0 +1,169 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { apiGet, apiPost } from '../utils/api.js';
+import { awalExec } from '../utils/awal.js';
+import { requireConfig } from '../utils/config.js';
+export async function promoteSubmitCommand(taskId, options) {
+    const config = requireConfig();
+    // 自动检测平台（从 task 获取）
+    let platform = options.platform;
+    if (!platform) {
+        try {
+            const taskResp = await apiGet(`/api/v1/promote/${taskId}`, config.api_key);
+            if (taskResp.ok && taskResp.data.platform) {
+                platform = taskResp.data.platform;
+            }
+        }
+        catch { /* ignore */ }
+    }
+    if (!platform)
+        platform = 'twitter';
+    console.log('');
+    const spinner = ora(`Submitting proof for task ${taskId.slice(0, 8)}...`).start();
+    try {
+        const body = {
+            platform,
+            proof_url: options.url,
+        };
+        if (options.text) {
+            body.content_text = options.text;
+        }
+        const resp = await apiPost(`/api/v1/promote/${taskId}/submit`, body, config.api_key);
+        if (!resp.ok) {
+            spinner.fail('Submission failed');
+            const detail = typeof resp.data === 'object' ? (resp.data.detail || JSON.stringify(resp.data)) : String(resp.data);
+            console.error(chalk.red(`  ${detail}`));
+            return;
+        }
+        spinner.succeed('Proof submitted');
+        if (resp.data.id) {
+            console.log(chalk.dim(`  Submission ID: ${resp.data.id}`));
+        }
+    }
+    catch (err) {
+        spinner.fail('Submission failed');
+        console.error(chalk.red(err.message));
+    }
+    console.log('');
+}
+export async function promoteVerifyCommand(submissionId, options) {
+    const config = requireConfig();
+    console.log('');
+    if (options.witness) {
+        // Get submission to extract proof_url
+        const subSpinner = ora('Fetching submission...').start();
+        let proofUrl = '';
+        try {
+            // Try to get submission details - submissionId might be used directly
+            const resp = await apiGet(`/api/v1/promote/submissions/${submissionId}`, config.api_key);
+            if (resp.ok && resp.data.proof_url) {
+                proofUrl = resp.data.proof_url;
+                subSpinner.succeed(`Proof URL: ${proofUrl}`);
+            }
+            else {
+                subSpinner.warn('Could not fetch submission, will need tweet ID');
+            }
+        }
+        catch {
+            subSpinner.warn('Could not fetch submission');
+        }
+        // Extract tweet ID
+        let tweetId = '';
+        if (proofUrl) {
+            const match = proofUrl.match(/status\/(\d+)/);
+            if (match)
+                tweetId = match[1];
+        }
+        if (!tweetId) {
+            console.error(chalk.red('  Could not extract tweet ID from proof URL'));
+            return;
+        }
+        // Fetch witness proof via x402
+        const witnessSpinner = ora('Fetching witness proof via x402 ($0.01)...').start();
+        let witnessData;
+        try {
+            witnessData = await awalExec([
+                'x402', 'pay', `https://witness.bnbot.ai/x/${tweetId}`,
+            ]);
+            witnessSpinner.succeed('Witness proof obtained');
+        }
+        catch (err) {
+            witnessSpinner.fail('Witness fetch failed');
+            console.error(chalk.red(err.message));
+            return;
+        }
+        // Parse witness response — awalExec wraps: { success, data: { status, data: { code, data: {...}, proof: {...} } } }
+        const proof = witnessData?.data?.data?.proof || witnessData?.data?.proof || witnessData?.proof;
+        if (!proof) {
+            console.error(chalk.red('  No proof in witness response'));
+            console.log(chalk.dim(`  Raw: ${JSON.stringify(witnessData).slice(0, 200)}`));
+            return;
+        }
+        // Submit witness verification
+        const vote = options.vote || 'approve';
+        const relevanceScore = parseInt(options.relevance, 10);
+        const qualityScore = parseInt(options.quality, 10);
+        const verifySpinner = ora(`Submitting witness verification (${vote}, R:${relevanceScore} Q:${qualityScore})...`).start();
+        try {
+            const resp = await apiPost(`/api/v1/promote/submissions/${submissionId}/verify`, {
+                vote,
+                relevance_score: relevanceScore,
+                quality_score: qualityScore,
+                tweet_proof: {
+                    payload: proof.payload,
+                    signature: proof.signature,
+                    signer: proof.signer,
+                    timestamp: proof.timestamp,
+                },
+            }, config.api_key);
+            if (!resp.ok) {
+                verifySpinner.fail('Verification failed');
+                const detail = typeof resp.data === 'object' ? (resp.data.detail || JSON.stringify(resp.data)) : String(resp.data);
+                console.error(chalk.red(`  ${detail}`));
+            }
+            else {
+                verifySpinner.succeed('Witness verification submitted');
+                if (resp.data.id) {
+                    console.log(chalk.dim(`  Verification ID: ${resp.data.id}`));
+                }
+            }
+        }
+        catch (err) {
+            verifySpinner.fail('Verification failed');
+            console.error(chalk.red(err.message));
+        }
+    }
+    else {
+        // Manual verification
+        const vote = options.vote || 'approve';
+        const relevanceScore = parseInt(options.relevance, 10);
+        const qualityScore = parseInt(options.quality, 10);
+        const spinner = ora(`Submitting manual verification (${vote}, R:${relevanceScore} Q:${qualityScore})...`).start();
+        try {
+            const resp = await apiPost(`/api/v1/promote/submissions/${submissionId}/verify`, {
+                vote,
+                relevance_score: relevanceScore,
+                quality_score: qualityScore,
+                views: 0,
+                likes: 0,
+                comments: 0,
+            }, config.api_key);
+            if (!resp.ok) {
+                spinner.fail('Verification failed');
+                const detail = typeof resp.data === 'object' ? (resp.data.detail || JSON.stringify(resp.data)) : String(resp.data);
+                console.error(chalk.red(`  ${detail}`));
+            }
+            else {
+                spinner.succeed('Manual verification submitted');
+                if (resp.data.id) {
+                    console.log(chalk.dim(`  Verification ID: ${resp.data.id}`));
+                }
+            }
+        }
+        catch (err) {
+            spinner.fail('Verification failed');
+            console.error(chalk.red(err.message));
+        }
+    }
+    console.log('');
+}

package/dist/commands/setup.js

@@ -203,6 +203,6 @@ export async function setupCommand() {
     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 hire submit')}     Submit a task proof`);
+    console.log(`    ${chalk.cyan('clawmoney promote submit')}  Submit a task proof`);
     console.log('');
 }

package/dist/hub/daemon.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Daemon entry point for the Hub Provider.
+ * This file is spawned as a detached child process by `clawmoney hub start`.
+ * It runs the provider main loop (WS + Poller + Executor).
+ */
+export {};

package/dist/hub/daemon.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Daemon entry point for the Hub Provider.
+ * This file is spawned as a detached child process by `clawmoney hub start`.
+ * It runs the provider main loop (WS + Poller + Executor).
+ */
+import { runProvider } from "./provider.js";
+// Parse CLI args passed from the parent
+let cliCommand;
+const args = process.argv.slice(2);
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--cli" && args[i + 1]) {
+        cliCommand = args[i + 1];
+        i++;
+    }
+}
+// Run the provider (this blocks until shutdown signal)
+runProvider(cliCommand);

package/dist/hub/dedup.d.ts

@@ -0,0 +1,4 @@
+export declare function isProcessed(orderId: string): boolean;
+export declare function markProcessed(orderId: string): void;
+export declare function startDedup(): void;
+export declare function stopDedup(): void;

package/dist/hub/dedup.js

@@ -0,0 +1,35 @@
+import { logger } from "./logger.js";
+const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+const seen = new Map();
+let cleanupTimer = null;
+export function isProcessed(orderId) {
+    return seen.has(orderId);
+}
+export function markProcessed(orderId) {
+    seen.set(orderId, Date.now());
+}
+function cleanup() {
+    const cutoff = Date.now() - TTL_MS;
+    let removed = 0;
+    for (const [id, ts] of seen) {
+        if (ts < cutoff) {
+            seen.delete(id);
+            removed++;
+        }
+    }
+    if (removed > 0) {
+        logger.info(`Dedup cleanup: removed ${removed} stale entries, ${seen.size} remaining`);
+    }
+}
+export function startDedup() {
+    cleanupTimer = setInterval(cleanup, CLEANUP_INTERVAL_MS);
+    cleanupTimer.unref();
+}
+export function stopDedup() {
+    if (cleanupTimer) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = null;
+    }
+    seen.clear();
+}

package/dist/hub/executor.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderConfig, ServiceCallEvent, TestCallEvent, DeliverEvent, TestResponseEvent } from "./types.js";
+type SendFn = (event: DeliverEvent | TestResponseEvent) => boolean;
+export declare class Executor {
+    private config;
+    private send;
+    private activeTasks;
+    constructor(config: ProviderConfig, send: SendFn);
+    get activeCount(): number;
+    handleServiceCall(call: ServiceCallEvent): void;
+    handleTestCall(call: TestCallEvent): void;
+    private executeTask;
+}
+export {};