clawmoney 0.8.2 → 0.8.4

package/dist/commands/hub.d.ts

@@ -3,6 +3,21 @@ export declare function hubStartCommand(options: {
 }): Promise<void>;
 export declare function hubStopCommand(): Promise<void>;
 export declare function hubStatusCommand(): Promise<void>;
+interface SearchOptions {
+    query?: string;
+    category?: string;
+    sort?: string;
+    limit?: string;
+    maxPrice?: string;
+}
+export declare function hubSearchCommand(options: SearchOptions): Promise<void>;
+interface CallOptions {
+    agent: string;
+    skill: string;
+    input?: string;
+    timeout?: string;
+}
+export declare function hubCallCommand(options: CallOptions): Promise<void>;
 interface RegisterOptions {
     name: string;
     category: string;

package/dist/commands/hub.js

@@ -41,8 +41,15 @@ export async function hubStartCommand(options) {
         const pid = readPid();
         if (pid && isPidAlive(pid)) {
             spinner.succeed(chalk.green(`Hub Provider started (PID ${pid})`));
+            const mode = config.provider?.execution_mode || "webhook";
             console.log(chalk.dim(`  Log file: ${LOG_FILE}`));
-            console.log(chalk.dim(`  CLI command: ${options.cli || "claude"}`));
+            console.log(chalk.dim(`  Mode: ${mode}`));
+            if (mode === "cli") {
+                console.log(chalk.dim(`  CLI command: ${options.cli || config.provider?.cli_command || "claude"}`));
+            }
+            else {
+                console.log(chalk.dim(`  Webhook: ${config.provider?.webhook_url || "http://127.0.0.1:18789/hooks/agent"}`));
+            }
             console.log(chalk.dim(`  API key: ${config.api_key.slice(0, 8)}...`));
         }
         else {
@@ -94,6 +101,98 @@ export async function hubStatusCommand() {
         removePid();
     }
 }
+export async function hubSearchCommand(options) {
+    const spinner = ora("Searching Hub...").start();
+    try {
+        const params = new URLSearchParams();
+        if (options.query)
+            params.set("q", options.query);
+        if (options.category)
+            params.set("category", options.category);
+        if (options.sort)
+            params.set("sort", options.sort);
+        if (options.limit)
+            params.set("limit", options.limit);
+        if (options.maxPrice)
+            params.set("max_price", options.maxPrice);
+        params.set("online_only", "true");
+        const resp = await apiGet(`/api/v1/hub/skills/search?${params}`);
+        if (!resp.ok) {
+            spinner.fail(chalk.red(`Search failed (${resp.status})`));
+            process.exit(1);
+        }
+        const skills = resp.data.data ?? [];
+        const count = resp.data.count ?? skills.length;
+        spinner.succeed(`Found ${count} service(s)`);
+        console.log("");
+        if (skills.length === 0) {
+            console.log(chalk.dim("  No services found. Try broader search terms."));
+            return;
+        }
+        console.log(chalk.bold(`  ${"Agent".padEnd(18)} ${"Skill".padEnd(18)} ${"Category".padEnd(18)} ${"Price".padEnd(8)} ${"Rating".padEnd(8)} ${"Calls".padEnd(7)}`));
+        console.log(chalk.dim("  " + "-".repeat(79)));
+        for (const s of skills) {
+            const agent = (s.agent_name ?? s.agent_slug ?? "-").slice(0, 17);
+            const name = (s.skill_name ?? "-").slice(0, 17);
+            const category = (s.category ?? "-").slice(0, 17);
+            const price = s.price !== undefined ? `$${s.price.toFixed(3)}` : "-";
+            const rating = s.avg_rating != null ? s.avg_rating.toFixed(1) : "-";
+            const calls = String(s.total_calls ?? 0);
+            const online = s.agent_is_online ? chalk.green("●") : chalk.dim("○");
+            console.log(`  ${online} ${chalk.cyan(agent.padEnd(17))} ${name.padEnd(18)} ${category.padEnd(18)} ${chalk.green(price.padEnd(8))} ${rating.padEnd(8)} ${calls.padEnd(7)}`);
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk.red("Search failed"));
+        throw err;
+    }
+}
+export async function hubCallCommand(options) {
+    const config = requireConfig();
+    let inputData = {};
+    if (options.input) {
+        try {
+            inputData = JSON.parse(options.input);
+        }
+        catch {
+            console.error(chalk.red("Invalid JSON for --input. Example: '{\"prompt\":\"hello\"}'"));
+            process.exit(1);
+        }
+    }
+    const timeout = options.timeout ? parseInt(options.timeout, 10) : 60;
+    const spinner = ora(`Calling ${options.agent}/${options.skill}...`).start();
+    try {
+        // gateway/invoke takes agent_id, skill, timeout as query params; input_data as POST body
+        const qs = new URLSearchParams({
+            agent_id: options.agent,
+            skill: options.skill,
+            timeout: String(timeout),
+            payment_method: "ledger",
+        });
+        const resp = await apiPost(`/api/v1/hub/gateway/invoke?${qs}`, inputData, 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);
+            spinner.fail(chalk.red(`Call failed (${resp.status}): ${detail}`));
+            process.exit(1);
+        }
+        const result = resp.data;
+        spinner.succeed(chalk.green("Call completed!"));
+        console.log("");
+        console.log(`  ${chalk.bold("Order:")}    ${result.id ?? "-"}`);
+        console.log(`  ${chalk.bold("Duration:")} ${typeof result.duration === "number" ? result.duration.toFixed(1) + "s" : "-"}`);
+        console.log(`  ${chalk.bold("Cost:")}     $${typeof result.price === "number" ? result.price.toFixed(3) : "-"}`);
+        console.log("");
+        console.log(chalk.bold("  Output:"));
+        console.log(chalk.cyan("  " + JSON.stringify(result.output_data ?? result.output ?? {}, null, 2).replace(/\n/g, "\n  ")));
+    }
+    catch (err) {
+        spinner.fail(chalk.red("Call failed"));
+        throw err;
+    }
+}
 export async function hubRegisterCommand(options) {
     const config = requireConfig();
     const price = parseFloat(options.price);

package/dist/hub/executor.js

@@ -3,6 +3,7 @@ import { isProcessed, markProcessed } from "./dedup.js";
 import { replaceLocalPaths } from "./media.js";
 import { logger } from "./logger.js";
 const TIMEOUT_BUFFER_S = 15;
+// ── Prompt builder ──
 function buildPrompt(call, config) {
     const skillConfig = config.provider.skills?.[call.skill];
     if (skillConfig?.prompt_template) {
@@ -13,13 +14,60 @@ function buildPrompt(call, config) {
     return [
         "You received a paid service request via ClawMoney Hub.",
         `Skill: ${call.skill}`,
+        `Category: ${call.category}`,
+        `From: ${call.from}`,
+        `Price: $${call.price}`,
         `Input: ${JSON.stringify(call.input, null, 2)}`,
         "",
         "Execute this task and return the result as JSON.",
-        "If you generate any files, save them and include their paths in the output.",
+        "If you generate any files (images, videos, etc.), save them and include their file paths in the output.",
+        "Return ONLY the JSON result, no other text.",
     ].join("\n");
 }
-function runCli(command, prompt, timeoutMs) {
+// ── OpenClaw Webhook execution ──
+async function executeViaWebhook(call, config, prompt, timeoutS) {
+    const { webhook_url, webhook_token } = config.provider;
+    logger.info(`Executing via OpenClaw webhook: skill="${call.skill}" order=${call.order_id}`);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutS * 1000);
+    try {
+        const resp = await fetch(webhook_url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${webhook_token}`,
+            },
+            body: JSON.stringify({
+                message: prompt,
+                name: `Hub: ${call.skill}`,
+                deliver: false, // don't send to messaging channel
+                timeoutSeconds: timeoutS,
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!resp.ok) {
+            const text = await resp.text();
+            throw new Error(`Webhook returned ${resp.status}: ${text}`);
+        }
+        const text = await resp.text();
+        // Try to parse JSON from response
+        const parsed = parseJsonOutput(text);
+        if (parsed)
+            return parsed;
+        // If response is not JSON, wrap as text result
+        return { result: text.trim().slice(0, 5000) };
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error(`Webhook timed out after ${timeoutS}s`);
+        }
+        throw err;
+    }
+}
+// ── CLI (claude -p) execution — fallback ──
+function executeViaCli(command, prompt, timeoutMs) {
     return new Promise((resolve) => {
         const args = ["-p", prompt, "--output-format", "json"];
         const child = spawn(command, args, {
@@ -44,6 +92,7 @@ function runCli(command, prompt, timeoutMs) {
         });
     });
 }
+// ── JSON parser ──
 function parseJsonOutput(raw) {
     try {
         return JSON.parse(raw);
@@ -62,6 +111,7 @@ function parseJsonOutput(raw) {
     }
     return null;
 }
+// ── Executor ──
 export class Executor {
     config;
     send;
@@ -90,7 +140,7 @@ export class Executor {
         }
         markProcessed(call.order_id);
         this.activeTasks.add(call.order_id);
-        logger.info(`Processing order=${call.order_id} skill="${call.skill}" from=${call.from}`);
+        logger.info(`Processing order=${call.order_id} skill="${call.skill}" from=${call.from} mode=${this.config.provider.execution_mode}`);
         this.executeTask(call).catch((err) => {
             logger.error(`Unhandled error in executeTask for ${call.order_id}:`, err);
         });
@@ -103,6 +153,7 @@ export class Executor {
             output: {
                 echo: call.input,
                 provider_status: "ok",
+                execution_mode: this.config.provider.execution_mode,
                 active_tasks: this.activeTasks.size,
                 max_concurrent: this.config.provider.max_concurrent,
             },
@@ -112,31 +163,32 @@ export class Executor {
     async executeTask(call) {
         try {
             const prompt = buildPrompt(call, this.config);
-            const timeoutMs = Math.max((call.timeout - TIMEOUT_BUFFER_S) * 1000, 30_000);
-            const command = this.config.provider.cli_command;
-            logger.info(`Executing: ${command} for skill="${call.skill}" order=${call.order_id} (timeout=${Math.round(timeoutMs / 1000)}s)`);
-            const { stdout, stderr, exitCode } = await runCli(command, prompt, timeoutMs);
-            if (exitCode !== 0) {
-                const errMsg = stderr.trim() || `CLI exited with code ${exitCode}`;
-                logger.error(`CLI failed (code=${exitCode}):`, errMsg);
-                this.send({
-                    event: "deliver",
-                    order_id: call.order_id,
-                    error: errMsg.slice(0, 2000),
-                });
-                return;
+            const timeoutS = Math.max(call.timeout - TIMEOUT_BUFFER_S, 30);
+            let output;
+            if (this.config.provider.execution_mode === "webhook") {
+                // Execute via OpenClaw webhook
+                output = await executeViaWebhook(call, this.config, prompt, timeoutS);
             }
-            const parsed = parseJsonOutput(stdout);
-            if (!parsed) {
-                logger.warn("CLI output was not valid JSON, wrapping as text");
-                this.send({
-                    event: "deliver",
-                    order_id: call.order_id,
-                    output: { result: stdout.trim().slice(0, 5000) },
-                });
-                return;
+            else {
+                // Execute via CLI (claude -p / openclaw -p)
+                const command = this.config.provider.cli_command;
+                logger.info(`Executing via CLI: ${command} for skill="${call.skill}" (timeout=${timeoutS}s)`);
+                const { stdout, stderr, exitCode } = await executeViaCli(command, prompt, timeoutS * 1000);
+                if (exitCode !== 0) {
+                    const errMsg = stderr.trim() || `CLI exited with code ${exitCode}`;
+                    logger.error(`CLI failed (code=${exitCode}):`, errMsg);
+                    this.send({
+                        event: "deliver",
+                        order_id: call.order_id,
+                        error: errMsg.slice(0, 2000),
+                    });
+                    return;
+                }
+                const parsed = parseJsonOutput(stdout);
+                output = parsed ?? { result: stdout.trim().slice(0, 5000) };
             }
-            const output = await replaceLocalPaths(parsed, this.config);
+            // Upload local files to R2 if any
+            output = await replaceLocalPaths(output, this.config);
             const sent = this.send({
                 event: "deliver",
                 order_id: call.order_id,

package/dist/hub/provider.js

@@ -11,7 +11,10 @@ const CONFIG_DIR = join(homedir(), ".clawmoney");
 const CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
 const PID_FILE = join(CONFIG_DIR, "provider.pid");
 const DEFAULT_PROVIDER = {
+    execution_mode: "webhook",
     cli_command: "claude",
+    webhook_url: "http://127.0.0.1:18789/hooks/agent",
+    webhook_token: "",
     max_concurrent: 3,
     ws_url: "wss://api.bnbot.ai/api/v1/ws/agent",
     api_base_url: "https://api.bnbot.ai/api/v1",
@@ -73,7 +76,10 @@ function loadProviderConfig(cliCommand) {
     }
     const userProvider = (raw.provider ?? {});
     const provider = {
+        execution_mode: userProvider.execution_mode ?? DEFAULT_PROVIDER.execution_mode,
         cli_command: cliCommand ?? userProvider.cli_command ?? DEFAULT_PROVIDER.cli_command,
+        webhook_url: userProvider.webhook_url ?? DEFAULT_PROVIDER.webhook_url,
+        webhook_token: userProvider.webhook_token ?? DEFAULT_PROVIDER.webhook_token,
         max_concurrent: userProvider.max_concurrent ?? DEFAULT_PROVIDER.max_concurrent,
         ws_url: userProvider.ws_url ?? DEFAULT_PROVIDER.ws_url,
         api_base_url: userProvider.api_base_url ?? DEFAULT_PROVIDER.api_base_url,
@@ -159,5 +165,8 @@ export function runProvider(cliCommand) {
     wsClient.start();
     poller.start();
     logger.info("Hub Provider running. Listening for service calls...");
-    logger.info(`Config: max_concurrent=${config.provider.max_concurrent}, cli=${config.provider.cli_command}`);
+    logger.info(`Config: mode=${config.provider.execution_mode}, max_concurrent=${config.provider.max_concurrent}` +
+        (config.provider.execution_mode === "webhook"
+            ? `, webhook=${config.provider.webhook_url}`
+            : `, cli=${config.provider.cli_command}`));
 }

package/dist/hub/types.d.ts

@@ -38,7 +38,10 @@ export interface TestResponseEvent {
 }
 export type OutgoingEvent = DeliverEvent | TestResponseEvent;
 export interface ProviderSettings {
+    execution_mode: "webhook" | "cli";
     cli_command: string;
+    webhook_url: string;
+    webhook_token: string;
     max_concurrent: number;
     ws_url: string;
     api_base_url: string;

package/dist/index.js

@@ -5,12 +5,12 @@ import { browseCommand } from './commands/browse.js';
 import { promoteSubmitCommand, promoteVerifyCommand } from './commands/promote.js';
 import { walletStatusCommand, walletBalanceCommand, walletAddressCommand, walletSendCommand, } from './commands/wallet.js';
 import { tweetCommand } from './commands/tweet.js';
-import { hubStartCommand, hubStopCommand, hubStatusCommand, hubRegisterCommand, hubSkillsCommand, } from './commands/hub.js';
+import { hubStartCommand, hubStopCommand, hubStatusCommand, hubSearchCommand, hubCallCommand, hubRegisterCommand, hubSkillsCommand, } from './commands/hub.js';
 const program = new Command();
 program
     .name('clawmoney')
     .description('ClawMoney CLI -- Earn rewards with your AI agent')
-    .version('0.1.0');
+    .version('0.8.2');
 // setup
 program
     .command('setup')
@@ -207,4 +207,37 @@ hub
         process.exit(1);
     }
 });
+hub
+    .command('search')
+    .description('Search for agent services on the Hub')
+    .option('-q, --query <query>', 'Keyword search')
+    .option('-c, --category <category>', 'Category filter (e.g., generation/image)')
+    .option('-s, --sort <sort>', 'Sort by: rating, price, response_time', 'rating')
+    .option('-l, --limit <limit>', 'Number of results', '10')
+    .option('--max-price <price>', 'Maximum price filter')
+    .action(async (options) => {
+    try {
+        await hubSearchCommand(options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+hub
+    .command('call')
+    .description('Call another agent\'s service')
+    .requiredOption('-a, --agent <agent>', 'Target agent slug or ID')
+    .requiredOption('-s, --skill <skill>', 'Skill name to invoke')
+    .option('-i, --input <json>', 'Input parameters as JSON')
+    .option('-t, --timeout <seconds>', 'Timeout in seconds', '60')
+    .action(async (options) => {
+    try {
+        await hubCallCommand(options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/utils/api.js

@@ -39,12 +39,13 @@ export async function apiPost(path, body, apiKey) {
         headers: buildHeaders(apiKey),
         body: JSON.stringify(body),
     });
+    const text = await response.text();
     let data;
     try {
-        data = (await response.json());
+        data = JSON.parse(text);
     }
     catch {
-        data = (await response.text());
+        data = text;
     }
     return {
         ok: response.ok,

package/dist/utils/config.d.ts

@@ -4,6 +4,14 @@ export interface ClawConfig {
     agent_slug: string;
     email?: string;
     wallet_address?: string;
+    provider?: {
+        execution_mode?: string;
+        cli_command?: string;
+        webhook_url?: string;
+        webhook_token?: string;
+        max_concurrent?: number;
+        [key: string]: unknown;
+    };
 }
 export declare function getConfigPath(): string;
 export declare function loadConfig(): ClawConfig | null;

package/package.json

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