clawmoney 0.8.0 → 0.8.2

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,166 @@
+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 {
+        // Resolve daemon script path relative to this file's directory
+        // Works for both compiled (dist/commands/hub.js) and dev (src/commands/hub.ts)
+        const thisDir = import.meta.url.replace("file://", "").replace(/\/[^/]+$/, "");
+        const parentDir = thisDir.replace(/\/[^/]+$/, "");
+        const daemonScript = join(parentDir, "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", {
+            skill_name: options.name,
+            category: options.category,
+            description: options.description,
+            price: price,
+        }, 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(`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.skill_name ?? skill.name ?? "-").slice(0, 19);
+            const category = (skill.category ?? "-").slice(0, 19);
+            const rawPrice = skill.price ?? skill.price_per_call;
+            const price = rawPrice !== undefined ? `$${Number(rawPrice).toFixed(2)}` : "-";
+            const calls = String(skill.total_calls ?? skill.call_count ?? "-");
+            const status = skill.is_active !== undefined ? (skill.is_active ? "active" : "inactive") : (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/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 {};

package/dist/hub/executor.js

@@ -0,0 +1,164 @@
+import { spawn } from "node:child_process";
+import { isProcessed, markProcessed } from "./dedup.js";
+import { replaceLocalPaths } from "./media.js";
+import { logger } from "./logger.js";
+const TIMEOUT_BUFFER_S = 15;
+function buildPrompt(call, config) {
+    const skillConfig = config.provider.skills?.[call.skill];
+    if (skillConfig?.prompt_template) {
+        return skillConfig.prompt_template
+            .replace("{{skill}}", call.skill)
+            .replace("{{input}}", JSON.stringify(call.input, null, 2));
+    }
+    return [
+        "You received a paid service request via ClawMoney Hub.",
+        `Skill: ${call.skill}`,
+        `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.",
+    ].join("\n");
+}
+function runCli(command, prompt, timeoutMs) {
+    return new Promise((resolve) => {
+        const args = ["-p", prompt, "--output-format", "json"];
+        const child = spawn(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: timeoutMs,
+            env: { ...process.env },
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ stdout, stderr, exitCode: code });
+        });
+        child.on("error", (err) => {
+            stderr += err.message;
+            resolve({ stdout, stderr, exitCode: null });
+        });
+    });
+}
+function parseJsonOutput(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        // Ignore
+    }
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (match) {
+        try {
+            return JSON.parse(match[0]);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return null;
+}
+export class Executor {
+    config;
+    send;
+    activeTasks = new Set();
+    constructor(config, send) {
+        this.config = config;
+        this.send = send;
+    }
+    get activeCount() {
+        return this.activeTasks.size;
+    }
+    handleServiceCall(call) {
+        if (isProcessed(call.order_id)) {
+            logger.info(`Skipping duplicate order: ${call.order_id}`);
+            return;
+        }
+        if (this.activeTasks.size >= this.config.provider.max_concurrent) {
+            logger.warn(`Rejecting order ${call.order_id}: at max concurrency (${this.config.provider.max_concurrent})`);
+            this.send({
+                event: "deliver",
+                order_id: call.order_id,
+                error: "Provider is at maximum capacity. Please try again later.",
+            });
+            markProcessed(call.order_id);
+            return;
+        }
+        markProcessed(call.order_id);
+        this.activeTasks.add(call.order_id);
+        logger.info(`Processing order=${call.order_id} skill="${call.skill}" from=${call.from}`);
+        this.executeTask(call).catch((err) => {
+            logger.error(`Unhandled error in executeTask for ${call.order_id}:`, err);
+        });
+    }
+    handleTestCall(call) {
+        logger.info(`Test call received: order=${call.order_id}`);
+        const response = {
+            event: "test_response",
+            order_id: call.order_id,
+            output: {
+                echo: call.input,
+                provider_status: "ok",
+                active_tasks: this.activeTasks.size,
+                max_concurrent: this.config.provider.max_concurrent,
+            },
+        };
+        this.send(response);
+    }
+    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 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;
+            }
+            const output = await replaceLocalPaths(parsed, this.config);
+            const sent = this.send({
+                event: "deliver",
+                order_id: call.order_id,
+                output,
+            });
+            if (sent) {
+                logger.info(`Delivered order=${call.order_id} (success)`);
+            }
+            else {
+                logger.warn(`Failed to send delivery for order=${call.order_id} (WS disconnected)`);
+            }
+        }
+        catch (err) {
+            logger.error(`Execution error for order=${call.order_id}:`, err);
+            this.send({
+                event: "deliver",
+                order_id: call.order_id,
+                error: err instanceof Error ? err.message : "Unknown execution error",
+            });
+        }
+        finally {
+            this.activeTasks.delete(call.order_id);
+        }
+    }
+}

package/dist/hub/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logger: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};

package/dist/hub/logger.js

@@ -0,0 +1,47 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const LOG_DIR = join(homedir(), ".clawmoney");
+const LOG_FILE = join(LOG_DIR, "provider.log");
+function timestamp() {
+    return new Date().toISOString().replace("T", " ").replace("Z", "");
+}
+function ensureDir() {
+    try {
+        mkdirSync(LOG_DIR, { recursive: true });
+    }
+    catch {
+        // already exists
+    }
+}
+function log(level, ...args) {
+    const prefix = `${timestamp()} [${level}]`;
+    const message = args
+        .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
+        .join(" ");
+    const line = `${prefix} ${message}\n`;
+    // Write to log file
+    try {
+        ensureDir();
+        appendFileSync(LOG_FILE, line, "utf-8");
+    }
+    catch {
+        // best effort
+    }
+    // Also write to stderr (visible only if not detached)
+    switch (level) {
+        case "ERROR":
+            console.error(prefix, ...args);
+            break;
+        case "WARN":
+            console.warn(prefix, ...args);
+            break;
+        default:
+            console.log(prefix, ...args);
+    }
+}
+export const logger = {
+    info: (...args) => log("INFO", ...args),
+    warn: (...args) => log("WARN", ...args),
+    error: (...args) => log("ERROR", ...args),
+};

package/dist/hub/media.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderConfig } from "./types.js";
+/**
+ * Upload a local file to the Hub media endpoint (R2).
+ * Returns the public CDN URL on success, or null on failure.
+ */
+export declare function uploadFile(filePath: string, config: ProviderConfig): Promise<string | null>;
+/**
+ * Walk the output object and replace any local file paths with CDN URLs.
+ * Mutates the object in-place and returns it.
+ */
+export declare function replaceLocalPaths(output: Record<string, unknown>, config: ProviderConfig): Promise<Record<string, unknown>>;

package/dist/hub/media.js

@@ -0,0 +1,70 @@
+import { readFileSync, statSync } from "node:fs";
+import { basename } from "node:path";
+import { logger } from "./logger.js";
+/**
+ * Upload a local file to the Hub media endpoint (R2).
+ * Returns the public CDN URL on success, or null on failure.
+ */
+export async function uploadFile(filePath, config) {
+    const url = `${config.provider.api_base_url}/hub/media/upload`;
+    try {
+        const stat = statSync(filePath);
+        if (!stat.isFile()) {
+            logger.warn(`uploadFile: not a regular file: ${filePath}`);
+            return null;
+        }
+        const fileBuffer = readFileSync(filePath);
+        const fileName = basename(filePath);
+        const formData = new FormData();
+        formData.append("file", new Blob([fileBuffer]), fileName);
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.api_key}`,
+            },
+            body: formData,
+        });
+        if (!resp.ok) {
+            const body = await resp.text();
+            logger.error(`uploadFile failed (${resp.status}): ${body}`);
+            return null;
+        }
+        const data = (await resp.json());
+        if (!data.file_url) {
+            logger.error("uploadFile: response missing file_url");
+            return null;
+        }
+        logger.info(`Uploaded ${fileName} -> ${data.file_url}`);
+        return data.file_url;
+    }
+    catch (err) {
+        logger.error(`uploadFile error for ${filePath}:`, err);
+        return null;
+    }
+}
+/** Known output keys that may contain local file paths. */
+const FILE_PATH_KEYS = [
+    "image_path",
+    "video_path",
+    "audio_path",
+    "file_path",
+    "document_path",
+];
+/**
+ * Walk the output object and replace any local file paths with CDN URLs.
+ * Mutates the object in-place and returns it.
+ */
+export async function replaceLocalPaths(output, config) {
+    for (const key of FILE_PATH_KEYS) {
+        const val = output[key];
+        if (typeof val === "string" && val.startsWith("/")) {
+            const cdnUrl = await uploadFile(val, config);
+            if (cdnUrl) {
+                const urlKey = key.replace("_path", "_url");
+                output[urlKey] = cdnUrl;
+                delete output[key];
+            }
+        }
+    }
+    return output;
+}

package/dist/hub/poller.d.ts

@@ -0,0 +1,14 @@
+import type { ProviderConfig, ServiceCallEvent } from "./types.js";
+export type PollCallback = (event: ServiceCallEvent) => void;
+export declare class Poller {
+    private config;
+    private onServiceCall;
+    private isWsConnected;
+    private timer;
+    private stopping;
+    constructor(config: ProviderConfig, onServiceCall: PollCallback, isWsConnected: () => boolean);
+    start(): void;
+    stop(): void;
+    private scheduleNext;
+    private poll;
+}

package/dist/hub/poller.js

@@ -0,0 +1,66 @@
+import { logger } from "./logger.js";
+export class Poller {
+    config;
+    onServiceCall;
+    isWsConnected;
+    timer = null;
+    stopping = false;
+    constructor(config, onServiceCall, isWsConnected) {
+        this.config = config;
+        this.onServiceCall = onServiceCall;
+        this.isWsConnected = isWsConnected;
+    }
+    start() {
+        this.stopping = false;
+        this.scheduleNext();
+    }
+    stop() {
+        this.stopping = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    scheduleNext() {
+        if (this.stopping)
+            return;
+        const interval = this.isWsConnected()
+            ? this.config.provider.polling.connected_interval
+            : this.config.provider.polling.disconnected_interval;
+        this.timer = setTimeout(async () => {
+            this.timer = null;
+            await this.poll();
+            this.scheduleNext();
+        }, interval * 1000);
+        this.timer.unref();
+    }
+    async poll() {
+        const url = `${this.config.provider.api_base_url}/hub/tasks/pending`;
+        try {
+            const resp = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.config.api_key}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!resp.ok) {
+                if (resp.status !== 404) {
+                    logger.warn(`Poll failed (${resp.status}): ${await resp.text()}`);
+                }
+                return;
+            }
+            const data = (await resp.json());
+            const tasks = data.tasks ?? [];
+            if (tasks.length > 0) {
+                logger.info(`Poll: received ${tasks.length} pending task(s)`);
+            }
+            for (const task of tasks) {
+                this.onServiceCall(task);
+            }
+        }
+        catch (err) {
+            logger.error("Poll error:", err);
+        }
+    }
+}

package/dist/hub/provider.d.ts

@@ -0,0 +1,4 @@
+export declare function readPid(): number | null;
+export declare function isPidAlive(pid: number): boolean;
+export declare function removePid(): void;
+export declare function runProvider(cliCommand?: string): void;

package/dist/hub/provider.js

@@ -0,0 +1,163 @@
+import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import YAML from "yaml";
+import { WsClient } from "./ws-client.js";
+import { Poller } from "./poller.js";
+import { Executor } from "./executor.js";
+import { startDedup, stopDedup } from "./dedup.js";
+import { logger } from "./logger.js";
+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 = {
+    cli_command: "claude",
+    max_concurrent: 3,
+    ws_url: "wss://api.bnbot.ai/api/v1/ws/agent",
+    api_base_url: "https://api.bnbot.ai/api/v1",
+    polling: {
+        connected_interval: 120,
+        disconnected_interval: 15,
+    },
+    reconnect: {
+        initial: 5,
+        max: 300,
+        multiplier: 2,
+    },
+};
+// ── PID helpers ──
+export function readPid() {
+    try {
+        const content = readFileSync(PID_FILE, "utf-8").trim();
+        const pid = parseInt(content, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function writePid() {
+    writeFileSync(PID_FILE, String(process.pid), "utf-8");
+}
+export function removePid() {
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch {
+        // Ignore
+    }
+}
+// ── Config loading ──
+function loadProviderConfig(cliCommand) {
+    let raw;
+    try {
+        const content = readFileSync(CONFIG_FILE, "utf-8");
+        raw = YAML.parse(content);
+    }
+    catch (err) {
+        logger.error(`Failed to read config from ${CONFIG_FILE}:`, err);
+        process.exit(1);
+    }
+    if (!raw.api_key || typeof raw.api_key !== "string") {
+        logger.error("api_key is required in config.yaml. Run 'clawmoney setup' first.");
+        process.exit(1);
+    }
+    const userProvider = (raw.provider ?? {});
+    const provider = {
+        cli_command: cliCommand ?? userProvider.cli_command ?? DEFAULT_PROVIDER.cli_command,
+        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,
+        polling: {
+            connected_interval: userProvider.polling?.connected_interval ??
+                DEFAULT_PROVIDER.polling.connected_interval,
+            disconnected_interval: userProvider.polling?.disconnected_interval ??
+                DEFAULT_PROVIDER.polling.disconnected_interval,
+        },
+        reconnect: {
+            initial: userProvider.reconnect?.initial ?? DEFAULT_PROVIDER.reconnect.initial,
+            max: userProvider.reconnect?.max ?? DEFAULT_PROVIDER.reconnect.max,
+            multiplier: userProvider.reconnect?.multiplier ??
+                DEFAULT_PROVIDER.reconnect.multiplier,
+        },
+        skills: userProvider.skills,
+    };
+    return {
+        api_key: raw.api_key,
+        agent_id: raw.agent_id,
+        agent_slug: raw.agent_slug,
+        provider,
+    };
+}
+// ── Main daemon entry point ──
+export function runProvider(cliCommand) {
+    // Check for existing process
+    const existingPid = readPid();
+    if (existingPid && isPidAlive(existingPid)) {
+        logger.error(`Hub Provider is already running (PID ${existingPid}). Use "hub stop" first.`);
+        process.exit(1);
+    }
+    const config = loadProviderConfig(cliCommand);
+    // Initialize dedup
+    startDedup();
+    // Create WS client
+    const wsClient = new WsClient(config, (event) => {
+        handleEvent(event);
+    });
+    // Create executor
+    const executor = new Executor(config, (event) => wsClient.send(event));
+    // Event router
+    function handleEvent(event) {
+        switch (event.event) {
+            case "connected":
+                logger.info(`Connected as "${event.agent_name}" (id=${event.agent_id}, hub_level=${event.hub_level})`);
+                break;
+            case "service_call":
+                executor.handleServiceCall(event);
+                break;
+            case "test_call":
+                executor.handleTestCall(event);
+                break;
+            case "error":
+                logger.error(`Server error: ${event.message}`);
+                break;
+            default:
+                logger.warn("Unknown event:", event);
+        }
+    }
+    // Create poller
+    const poller = new Poller(config, (task) => {
+        handleEvent(task);
+    }, () => wsClient.connected);
+    // Graceful shutdown
+    let shuttingDown = false;
+    function shutdown(signal) {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logger.info(`Received ${signal}. Shutting down...`);
+        wsClient.stop();
+        poller.stop();
+        stopDedup();
+        removePid();
+        logger.info("Hub Provider stopped.");
+        process.exit(0);
+    }
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    // Write PID and start
+    writePid();
+    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}`);
+}

package/dist/hub/types.d.ts

@@ -0,0 +1,63 @@
+export interface ServiceCallEvent {
+    event: "service_call";
+    order_id: string;
+    from: string;
+    skill: string;
+    category: string;
+    input: Record<string, unknown>;
+    price: number;
+    timeout: number;
+    payment_method: string;
+}
+export interface TestCallEvent {
+    event: "test_call";
+    order_id: string;
+    input: Record<string, unknown>;
+}
+export interface ConnectedEvent {
+    event: "connected";
+    agent_id: string;
+    agent_name: string;
+    hub_level: number;
+}
+export interface ErrorEvent {
+    event: "error";
+    message: string;
+}
+export type IncomingEvent = ServiceCallEvent | TestCallEvent | ConnectedEvent | ErrorEvent;
+export interface DeliverEvent {
+    event: "deliver";
+    order_id: string;
+    output?: Record<string, unknown>;
+    error?: string;
+}
+export interface TestResponseEvent {
+    event: "test_response";
+    order_id: string;
+    output: Record<string, unknown>;
+}
+export type OutgoingEvent = DeliverEvent | TestResponseEvent;
+export interface ProviderSettings {
+    cli_command: string;
+    max_concurrent: number;
+    ws_url: string;
+    api_base_url: string;
+    polling: {
+        connected_interval: number;
+        disconnected_interval: number;
+    };
+    reconnect: {
+        initial: number;
+        max: number;
+        multiplier: number;
+    };
+    skills?: Record<string, {
+        prompt_template?: string;
+    }>;
+}
+export interface ProviderConfig {
+    api_key: string;
+    agent_id?: string;
+    agent_slug?: string;
+    provider: ProviderSettings;
+}

package/dist/hub/types.js

@@ -0,0 +1,2 @@
+// ── WebSocket events received from server ──
+export {};

package/dist/hub/ws-client.d.ts

@@ -0,0 +1,23 @@
+import type { ProviderConfig, IncomingEvent, OutgoingEvent } from "./types.js";
+export type EventCallback = (event: IncomingEvent) => void;
+export declare class WsClient {
+    private config;
+    private onEvent;
+    private ws;
+    private heartbeatTimer;
+    private reconnectDelay;
+    private reconnectTimer;
+    private _connected;
+    private wsFailLogged;
+    private stopping;
+    constructor(config: ProviderConfig, onEvent: EventCallback);
+    get connected(): boolean;
+    start(): void;
+    stop(): void;
+    send(event: OutgoingEvent): boolean;
+    private connect;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private clearTimers;
+}

package/dist/hub/ws-client.js

@@ -0,0 +1,123 @@
+import WebSocket from "ws";
+import { logger } from "./logger.js";
+const HEARTBEAT_INTERVAL_MS = 30_000;
+export class WsClient {
+    config;
+    onEvent;
+    ws = null;
+    heartbeatTimer = null;
+    reconnectDelay;
+    reconnectTimer = null;
+    _connected = false;
+    wsFailLogged = false;
+    stopping = false;
+    constructor(config, onEvent) {
+        this.config = config;
+        this.onEvent = onEvent;
+        this.reconnectDelay = config.provider.reconnect.initial;
+    }
+    get connected() {
+        return this._connected;
+    }
+    start() {
+        this.stopping = false;
+        this.connect();
+    }
+    stop() {
+        this.stopping = true;
+        this.clearTimers();
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.close();
+            this.ws = null;
+        }
+        this._connected = false;
+    }
+    send(event) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            logger.warn("WS send failed: not connected");
+            return false;
+        }
+        try {
+            this.ws.send(JSON.stringify(event));
+            return true;
+        }
+        catch (err) {
+            logger.error("WS send error:", err);
+            return false;
+        }
+    }
+    // ── Private ──
+    connect() {
+        if (this.stopping)
+            return;
+        const url = `${this.config.provider.ws_url}?api_key=${this.config.api_key}`;
+        this.ws = new WebSocket(url);
+        this.ws.on("open", () => {
+            this._connected = true;
+            this.wsFailLogged = false;
+            this.reconnectDelay = this.config.provider.reconnect.initial;
+            logger.info("WebSocket connected");
+            this.startHeartbeat();
+        });
+        this.ws.on("message", (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                this.onEvent(msg);
+            }
+            catch (err) {
+                logger.error("WS message parse error:", err);
+            }
+        });
+        this.ws.on("close", (code, reason) => {
+            this._connected = false;
+            this.stopHeartbeat();
+            if (!this.wsFailLogged) {
+                logger.warn(`WebSocket closed (code=${code}, reason=${reason.toString()})`);
+                this.wsFailLogged = true;
+            }
+            this.scheduleReconnect();
+        });
+        this.ws.on("error", (err) => {
+            if (!this.wsFailLogged) {
+                logger.error("WebSocket error:", err.message);
+                this.wsFailLogged = true;
+            }
+        });
+    }
+    scheduleReconnect() {
+        if (this.stopping)
+            return;
+        const delay = this.reconnectDelay;
+        logger.info(`Reconnecting in ${delay}s...`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay * 1000);
+        this.reconnectTimer.unref();
+        const { max, multiplier } = this.config.provider.reconnect;
+        this.reconnectDelay = Math.min(delay * multiplier, max);
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.ping();
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+        this.heartbeatTimer.unref();
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    clearTimers() {
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+}

package/dist/index.js

@@ -5,6 +5,7 @@ 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';
 const program = new Command();
 program
     .name('clawmoney')
@@ -137,4 +138,73 @@ program
         process.exit(1);
     }
 });
+// hub
+const hub = program
+    .command('hub')
+    .description('Agent Hub: provide services, register skills');
+hub
+    .command('start')
+    .description('Start Hub Provider (background process)')
+    .option('--cli <command>', 'CLI command for task execution', 'claude')
+    .action(async (options) => {
+    try {
+        await hubStartCommand(options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+hub
+    .command('stop')
+    .description('Stop Hub Provider')
+    .action(async () => {
+    try {
+        await hubStopCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+hub
+    .command('status')
+    .description('Check Hub Provider status')
+    .action(async () => {
+    try {
+        await hubStatusCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+hub
+    .command('register')
+    .description('Register a skill on the Hub')
+    .requiredOption('-n, --name <name>', 'Skill name')
+    .requiredOption('-c, --category <category>', 'Category (e.g., generation/image)')
+    .requiredOption('-d, --description <desc>', 'Description')
+    .requiredOption('-p, --price <price>', 'Price per call in USD')
+    .action(async (options) => {
+    try {
+        await hubRegisterCommand(options);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+hub
+    .command('skills')
+    .description('List my registered skills')
+    .action(async () => {
+    try {
+        await hubSkillsCommand();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {
@@ -21,10 +21,12 @@
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "ora": "^8.0.0",
+    "ws": "^8.20.0",
     "yaml": "^2.4.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.4.0"
   },
   "engines": {