openclaw-overlay-plugin 0.8.2 → 0.8.6

package/README.md

@@ -126,7 +126,7 @@ Your agent needs a small amount of real BSV to register and transact.
 **How much?** 1,000–10,000 sats (~$0.05–$0.50) is more than enough.
 
 ### Get your address
-Tool: `openclaw_overlay({ action: "address" })`
+Tool: `overlay({ action: "address" })`
 
 ### Auto-registration
 Once funded with ≥1000 sats, the plugin auto-registers your agent on the overlay network on the next startup. No manual steps needed.

package/dist/index.d.ts

@@ -1,7 +1,3 @@
-/**
- * OpenClaw Overlay Plugin
- * Decentralized agent marketplace with BSV micropayments.
- */
 export declare function register(api: any): void;
 export declare const plugin: {
     id: string;

package/dist/index.js

@@ -1,39 +1,19 @@
-const cp_name = 'node:child' + '_' + 'process';
-let execFile;
-let spawn;
-let execFileAsync;
-import { promisify } from 'node:util';
 import path from 'node:path';
 import os from 'node:os';
-import { fileURLToPath } from 'node:url';
 import fs from 'node:fs';
-import process from 'node:process';
 import { initializeServiceSystem, serviceManager } from './src/services/index.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-let isInitialized = false;
-async function ensureCp() {
-    if (execFileAsync)
-        return;
-    // @ts-ignore
-    if (typeof require !== 'undefined') {
-        // @ts-ignore
-        const cp = require(cp_name);
-        execFile = cp.execFile;
-        spawn = cp.spawn;
-    }
-    else {
-        const cp = await import(cp_name);
-        execFile = cp.execFile;
-        spawn = cp.spawn;
-    }
-    execFileAsync = promisify(execFile);
-}
+// Direct imports of command logic
+import { cmdStatus, cmdSetup, cmdAddress, cmdIdentity } from './src/scripts/wallet/setup.js';
+import { cmdBalance, cmdImport } from './src/scripts/wallet/balance.js';
+import { cmdRegister, cmdUnregister } from './src/scripts/overlay/registration.js';
+import { cmdDiscover } from './src/scripts/overlay/discover.js';
+import { cmdRequestService } from './src/scripts/services/request.js';
+import { cmdServiceQueue } from './src/scripts/services/queue.js';
+import { cmdRespondService } from './src/scripts/services/respond.js';
+import { setNoExit } from './src/scripts/output.js';
 // Track background process for proper lifecycle management
 let backgroundProcess = null;
 let serviceRunning = false;
-// Confirmation tokens for destructive actions — maps token → { action, details, expiresAt }
-const pendingConfirmations = new Map();
 // Auto-import tracking
 let autoImportInterval = null;
 let knownTxids = new Set();
@@ -54,18 +34,10 @@ function loadDailySpending(walletDir) {
             return data;
     }
     catch {
-        // Ignore parse errors - return fresh daily spending for corrupted/missing file
+        // Ignore parse errors
     }
     return { date: today, totalSats: 0, transactions: [] };
 }
-function writeActivityEvent(event) {
-    const alertDir = path.join(process['env'].HOME || '', '.openclaw', 'openclaw-overlay');
-    try {
-        fs.mkdirSync(alertDir, { recursive: true });
-        fs.appendFileSync(path.join(alertDir, 'activity-feed.jsonl'), JSON.stringify({ ...event, ts: Date.now() }) + '\n');
-    }
-    catch { }
-}
 function recordSpend(walletDir, sats, service, provider) {
     const spending = loadDailySpending(walletDir);
     spending.totalSats += sats;
@@ -81,12 +53,18 @@ function checkBudget(walletDir, requestedSats, dailyLimit) {
         spent: spending.totalSats
     };
 }
-async function startAutoImport(env, cliPath, api) {
-    const logger = api.logger;
-    // Get our address
+function applyConfigToEnv(config) {
+    process['env'].BSV_WALLET_DIR = config.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
+    process['env'].OVERLAY_URL = config.overlayUrl || 'https://clawoverlay.com';
+    process['env'].BSV_NETWORK = config.network || process['env'].BSV_NETWORK || 'mainnet';
+    process['env'].BSV_ARC_URL = config.arcUrl || (process['env'].BSV_NETWORK === 'testnet' ? 'https://testnet.arc.gorillapool.io' : 'https://arc.gorillapool.io');
+    process['env'].AGENT_NAME = config.agentName || 'openclaw-agent';
+    setNoExit(true);
+}
+async function startAutoImport(config, api) {
     try {
-        const addrResult = await execFileAsync('node', [cliPath, 'address'], { env });
-        const addrOutput = parseCliOutput(addrResult.stdout);
+        applyConfigToEnv(config);
+        const addrOutput = await cmdAddress();
         if (!addrOutput.success)
             return;
         const address = addrOutput.data?.address;
@@ -94,7 +72,7 @@ async function startAutoImport(env, cliPath, api) {
             return;
         autoImportInterval = setInterval(async () => {
             try {
-                const network = env.BSV_NETWORK === 'testnet' ? 'test' : 'main';
+                const network = process['env'].BSV_NETWORK === 'testnet' ? 'test' : 'main';
                 const controller = new AbortController();
                 const timeout = setTimeout(() => controller.abort(), 15000);
                 const resp = await fetch(`https://api.whatsonchain.com/v1/bsv/${network}/address/${address}/unspent/all`, { signal: controller.signal });
@@ -108,39 +86,31 @@ async function startAutoImport(env, cliPath, api) {
                     if (knownTxids.has(key))
                         continue;
                     if (utxo.value < 200)
-                        continue; // skip dust
-                    logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
+                        continue;
+                    api.logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
                     try {
-                        const importResult = await execFileAsync('node', [cliPath, 'import', utxo.tx_hash, String(utxo.tx_pos)], { env });
-                        const importOutput = parseCliOutput(importResult.stdout);
+                        applyConfigToEnv(config);
+                        const importOutput = await cmdImport(utxo.tx_hash, String(utxo.tx_pos));
                         if (importOutput.success) {
                             knownTxids.add(key);
-                            logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
-                            // Clear onboarding flag since wallet is now funded
-                            try {
-                                const onboardingSentFile = path.join(process['env'].HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
-                                if (fs.existsSync(onboardingSentFile)) {
-                                    fs.unlinkSync(onboardingSentFile);
-                                }
-                            }
-                            catch { }
+                            api.logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
                             // Notify agent of successful import
-                            wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, api, { sessionKey: 'hook:openclaw-overlay:import' });
+                            wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, api.logger, { sessionKey: 'hook:openclaw-overlay:import' });
                             // Check if registered, auto-register if not
                             try {
-                                const regPath = path.join(process['env'].HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
+                                const regPath = path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'registration.json');
                                 if (!fs.existsSync(regPath)) {
-                                    logger?.info?.('[openclaw-overlay] Not yet registered — auto-registering...');
-                                    const regResult = await execFileAsync('node', [cliPath, 'register'], { env, timeout: 60000 });
-                                    const regOutput = parseCliOutput(regResult.stdout);
+                                    api.logger?.info?.('[openclaw-overlay] Not yet registered — auto-registering...');
+                                    applyConfigToEnv(config);
+                                    const regOutput = await cmdRegister();
                                     if (regOutput.success) {
-                                        logger?.info?.('[openclaw-overlay] Auto-registered on overlay network!');
-                                        await autoAdvertiseServices(env, cliPath, logger);
+                                        api.logger?.info?.('[openclaw-overlay] Auto-registered on overlay network!');
+                                        await autoAdvertiseServices(config, api.logger);
                                     }
                                 }
                             }
                             catch (err) {
-                                logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
+                                api.logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
                             }
                         }
                     }
@@ -155,30 +125,15 @@ async function startAutoImport(env, cliPath, api) {
         }, 30000);
     }
     catch (err) {
-        logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
-    }
-}
-function stopAutoImport() {
-    if (autoImportInterval) {
-        clearInterval(autoImportInterval);
-        autoImportInterval = null;
+        api.logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
     }
 }
-// Auto-advertise services from config after registration
-async function autoAdvertiseServices(env, cliPath, logger) {
+async function autoAdvertiseServices(config, logger) {
     try {
-        const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
-        if (!fs.existsSync(configPath))
-            return;
         let servicesToAdvertise = [];
-        try {
-            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-            const pluginConfig = config?.plugins?.entries?.['openclaw-overlay-plugin']?.config || config?.plugins?.entries?.['openclaw-overlay-plugin'];
-            if (pluginConfig?.services && Array.isArray(pluginConfig.services)) {
-                servicesToAdvertise = pluginConfig.services;
-            }
+        if (config?.services && Array.isArray(config.services)) {
+            servicesToAdvertise = config.services;
         }
-        catch { }
         if (servicesToAdvertise.length === 0)
             return;
         for (const serviceId of servicesToAdvertise) {
@@ -186,9 +141,9 @@ async function autoAdvertiseServices(env, cliPath, logger) {
             if (!serviceInfo)
                 continue;
             try {
-                await execFileAsync('node', [
-                    cliPath, 'advertise', serviceId, serviceInfo.name, serviceInfo.description, String(serviceInfo.defaultPrice)
-                ], { env, timeout: 60000 });
+                const { cmdAdvertise } = await import('./src/scripts/overlay/services.js');
+                applyConfigToEnv(config);
+                await cmdAdvertise(serviceId, serviceInfo.name, String(serviceInfo.defaultPrice), serviceInfo.description);
             }
             catch { }
         }
@@ -197,52 +152,19 @@ async function autoAdvertiseServices(env, cliPath, logger) {
         logger?.warn?.('[openclaw-overlay] Auto-advertising failed:', err.message);
     }
 }
-function wakeAgent(text, api, options = {}) {
-    const logger = api.logger;
+function wakeAgent(text, logger, options = {}) {
     const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
     const gatewayPort = process['env'].OPENCLAW_GATEWAY_PORT || '18789';
-    const httpToken = getHooksToken();
+    const httpToken = process['env'].OPENCLAW_HOOKS_TOKEN || null;
     if (!httpToken)
         return;
     fetch(`http://localhost:${gatewayPort}/hooks/agent`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json', 'x-openclaw-token': httpToken },
         body: JSON.stringify({ prompt: text, sessionKey })
-    }).then(async (res) => {
-        if (!res.ok) {
-            const body = await res.text().catch(() => '');
-            logger?.warn?.(`[openclaw-overlay] /hooks/agent failed: ${res.status} ${body}`);
-        }
-    }).catch((err) => {
-        logger?.warn?.(`[openclaw-overlay] /hooks/agent error: ${err.message}`);
-    });
-}
-function getHooksToken() {
-    let token = process['env'].OPENCLAW_HOOKS_TOKEN || null;
-    if (!token) {
-        try {
-            const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
-            if (fs.existsSync(configPath)) {
-                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                token = config.gateway?.hooksToken || null;
-            }
-        }
-        catch { }
-    }
-    return token;
+    }).catch(() => { });
 }
-function categorizeEvent(event) {
-    const base = { ts: Date.now(), from: event.from?.slice(0, 16), fullFrom: event.from };
-    if (event.action === 'queued-for-agent' && event.satoshisReceived) {
-        return { ...base, type: 'incoming_payment', emoji: '💰', serviceId: event.serviceId, sats: event.satoshisReceived, requestId: event.id, message: `Received ${event.satoshisReceived} sats for ${event.serviceId}` };
-    }
-    if (event.type === 'service-response' && event.action === 'received') {
-        return { ...base, type: 'response_received', emoji: '📬', serviceId: event.serviceId, status: event.status, result: event.result, requestId: event.requestId, message: event.formatted || `Response received for ${event.serviceId}: ${event.status}` };
-    }
-    return null;
-}
-function startBackgroundService(env, cliPath, api) {
-    const logger = api.logger;
+function startBackgroundService(config, api) {
     if (backgroundProcess)
         return;
     serviceRunning = true;
@@ -250,9 +172,16 @@ function startBackgroundService(env, cliPath, api) {
         if (serviceRunning)
             wokenRequests.clear();
     }, 5 * 60 * 1000);
-    function spawnConnect() {
+    async function spawnConnect() {
         if (!serviceRunning)
             return;
+        const { spawn } = await import('node:child_process');
+        const base = __dirname.endsWith('dist') ? __dirname : path.join(__dirname, 'dist');
+        const cliPath = path.join(base, 'src', 'cli.js');
+        const env = { ...process['env'] };
+        env.BSV_WALLET_DIR = config.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
+        env.OVERLAY_URL = config.overlayUrl || 'https://clawoverlay.com';
+        env.BSV_NETWORK = config.network || env.BSV_NETWORK || 'mainnet';
         const proc = spawn('node', [cliPath, 'connect'], { env, stdio: ['ignore', 'pipe', 'pipe'] });
         backgroundProcess = proc;
         proc.stdout?.on('data', (data) => {
@@ -265,38 +194,18 @@ function startBackgroundService(env, cliPath, api) {
                         if (wokenRequests.has(rid))
                             return;
                         wokenRequests.add(rid);
-                        logger?.info?.(`[openclaw-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}...`);
-                        if (api.runtime?.taskFlow) {
-                            api.runtime.taskFlow.create({
-                                goal: `Fulfill overlay service request: ${event.serviceId}`,
-                                status: "queued"
-                            });
-                        }
                         const wakeText = `⚡ Incoming overlay service request!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nPaid: ${event.satoshisReceived || '?'} sats\n\nFulfill it now:\n1. overlay({ action: "pending-requests" })\n2. Process the request\n3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
-                        wakeAgent(wakeText, api, { sessionKey: `hook:openclaw-overlay:${rid}` });
+                        wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:${rid}` });
                     }
                     if (event.type === 'service-response' && event.action === 'received') {
-                        logger?.info?.(`[openclaw-overlay] 📬 Response received for ${event.serviceId} from ${event.from?.slice(0, 12)}...`);
-                        if (api.runtime?.taskFlow) {
-                            api.runtime.taskFlow.create({
-                                goal: `Notify user of overlay service response: ${event.serviceId}`,
-                                status: "done"
-                            });
-                        }
                         const wakeText = `📬 Overlay service response received!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nStatus: ${event.status}\n\nFull result:\n${JSON.stringify(event.result, null, 2)}`;
-                        wakeAgent(wakeText, api, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
-                    }
-                    const notif = categorizeEvent(event);
-                    if (notif) {
-                        const dir = path.join(process['env'].HOME || '', '.openclaw', 'openclaw-overlay');
-                        fs.mkdirSync(dir, { recursive: true });
-                        fs.appendFileSync(path.join(dir, 'activity-feed.jsonl'), JSON.stringify(notif) + '\n');
+                        wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
                     }
                 }
                 catch { }
             }
         });
-        proc.on('exit', (code) => {
+        proc.on('exit', () => {
             backgroundProcess = null;
             if (serviceRunning)
                 setTimeout(spawnConnect, 5000);
@@ -315,22 +224,14 @@ function stopBackgroundService() {
         requestCleanupInterval = null;
     }
     wokenRequests.clear();
-    stopAutoImport();
-}
-function getCliPath() {
-    const base = __dirname.endsWith('dist') ? __dirname : path.join(__dirname, 'dist');
-    return path.join(base, 'src', 'cli.js');
+    if (autoImportInterval) {
+        clearInterval(autoImportInterval);
+        autoImportInterval = null;
+    }
 }
-/**
- * OpenClaw Overlay Plugin
- * Decentralized agent marketplace with BSV micropayments.
- */
 export function register(api) {
-    if (isInitialized)
-        return;
-    isInitialized = true;
     const entries = api.getConfig?.()?.plugins?.entries || {};
-    const entry = entries['sv_overlay'] || entries['overlay'] || entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
+    const entry = entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
     const pluginConfig = { ...entry, ...(entry.config || {}), ...(api.config || {}) };
     // 1. Tool
     api.registerTool({
@@ -339,10 +240,8 @@ export function register(api) {
         parameters: {
             type: "object",
             properties: {
-                action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister", "advertise-ship", "advertise-slap"] },
+                action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister"] },
                 service: { type: "string" },
-                topic: { type: "string" },
-                domain: { type: "string" },
                 input: { type: "object" },
                 identityKey: { type: "string" },
                 sats: { type: "number" },
@@ -364,37 +263,14 @@ export function register(api) {
     });
     // 2. Command
     api.registerCommand({
-        name: "sv_overlay",
+        name: "overlay",
         description: "BSV Overlay Marketplace commands",
         acceptsArgs: true,
-        requireAuth: true,
         handler: async (ctx) => {
             try {
                 const action = ctx.args?.[0] || 'status';
-                if (action === 'help') {
-                    return { text: `🛰️ **Overlay Help**\n\n**Subcommands**:\n- \`status\`: Show identity and wallet balance\n- \`balance\`: Show current satoshis\n- \`onboard\`: Start discovery setup\n- \`discover <serviceId>\`: Find providers on network\n- \`advertise-ship <domain> <topic>\`: Advertise a topic manager\n- \`advertise-slap <domain> <service>\`: Advertise a lookup service\n- \`pending-requests\`: See incoming service jobs\n- \`fulfill\`: Complete a request (Agent only)` };
-                }
-                const params = { action };
-                if (action === 'discover') {
-                    params.service = ctx.args[1];
-                }
-                else if (action === 'advertise-ship') {
-                    params.domain = ctx.args[1];
-                    params.topic = ctx.args[2];
-                }
-                else if (action === 'advertise-slap') {
-                    params.domain = ctx.args[1];
-                    params.service = ctx.args[2];
-                }
-                const result = await executeOverlayAction(params, pluginConfig, api);
-                if (typeof result === 'string')
-                    return { text: result };
-                // Formatted status response
-                if (action === 'status') {
-                    const status = result;
-                    return { text: `🛰️ **Overlay Status**\n\n**Identity Key**: \`${status.identity?.identityKey || 'Not setup'}\`\n**Balance**: ${status.balance?.walletBalance || 0} satoshis\n**Network**: ${status.identity?.network || 'mainnet'}` };
-                }
-                return { text: `**Overlay ${action.toUpperCase()}**\n\n${JSON.stringify(result, null, 2)}` };
+                const result = await executeOverlayAction({ action }, pluginConfig, api);
+                return { text: `**Overlay ${action.toUpperCase()}**\n\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}` };
             }
             catch (error) {
                 return { text: `❌ Error: ${error.message}` };
@@ -403,147 +279,93 @@ export function register(api) {
     });
     // 3. Service
     api.registerService({
-        id: "overlay-relay",
+        id: "openclaw-overlay-relay",
         start: async () => {
-            // Initialize child process helpers
-            await ensureCp();
-            // Initialize service system
             try {
                 await initializeServiceSystem();
             }
-            catch (err) {
-                if (api.logger)
-                    api.logger.warn(`[overlay] Service system initialization failed: ${err.message}`);
-            }
-            const env = buildEnvironment(pluginConfig);
-            const cliPath = getCliPath();
-            startBackgroundService(env, cliPath, api);
-            startAutoImport(env, cliPath, api);
+            catch { }
+            startBackgroundService(pluginConfig, api);
+            startAutoImport(pluginConfig, api);
         },
         stop: () => stopBackgroundService()
     });
     // 4. CLI
     api.registerCli(({ program }) => {
-        const overlay = program.command("sv_overlay").description("BSV Overlay Network management");
-        overlay.command("status").action(async () => {
-            await ensureCp();
-            const result = await handleStatus(buildEnvironment(pluginConfig), getCliPath());
-            console.log(JSON.stringify(result, null, 2));
+        const overlay = program.command("overlay").description("BSV Overlay Network management");
+        overlay.command("status").description("Show identity and balance").action(async () => {
+            applyConfigToEnv(pluginConfig);
+            const res = await cmdStatus();
+            console.log(JSON.stringify(res.data, null, 2));
+        });
+        overlay.command("balance").description("Show current wallet balance").action(async () => {
+            applyConfigToEnv(pluginConfig);
+            const res = await cmdBalance();
+            console.log(JSON.stringify(res.data, null, 2));
         });
-        overlay.command("balance").action(async () => {
-            await ensureCp();
-            const result = await handleBalance(buildEnvironment(pluginConfig), getCliPath());
-            console.log(JSON.stringify(result, null, 2));
+        overlay.command("discover").description("Find agents and services").option("-s, --service <type>", "Filter by service type").option("-a, --agent <name>", "Filter by agent name").action(async (options) => {
+            applyConfigToEnv(pluginConfig);
+            const args = [];
+            if (options.service)
+                args.push('--service', options.service);
+            if (options.agent)
+                args.push('--agent', options.agent);
+            const res = await cmdDiscover(args);
+            console.log(JSON.stringify(res.data, null, 2));
         });
-    }, { descriptors: [{ name: "overlay", description: "BSV Overlay Network management" }] });
+    }, { commands: ["overlay"] });
+}
+async function executeOverlayAction(params, config, api) {
+    const { action } = params;
+    applyConfigToEnv(config);
+    switch (action) {
+        case "request": {
+            const { service, input } = params;
+            const walletDir = config?.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
+            const discoverOutput = await cmdDiscover(['--service', service]);
+            const providers = discoverOutput.data.services;
+            if (!providers || providers.length === 0)
+                throw new Error(`No providers found for ${service}`);
+            providers.sort((a, b) => (a.pricing?.amountSats || 0) - (b.pricing?.amountSats || 0));
+            const best = providers[0];
+            const price = best.pricing?.amountSats || 0;
+            const budget = checkBudget(walletDir, price, config.dailyBudgetSats || 5000);
+            if (!budget.allowed)
+                throw new Error("Budget exceeded");
+            const output = await cmdRequestService(best.identityKey, service, price.toString(), input ? JSON.stringify(input) : undefined);
+            recordSpend(walletDir, price, service, best.name);
+            return { status: "sent", requestId: output.data?.messageId, message: `Request sent to ${best.name} for ${price} sats.` };
+        }
+        case "discover": return (await cmdDiscover(params.service ? ['--service', params.service] : [])).data;
+        case "balance": return (await cmdBalance()).data;
+        case "status": {
+            const identity = await cmdIdentity();
+            const balance = await cmdBalance();
+            return { identity: identity.data, balance: balance.data };
+        }
+        case "onboard": {
+            await cmdSetup();
+            const addr = (await cmdAddress()).data.address;
+            const bal = (await cmdBalance()).data.walletBalance;
+            if (bal < 1000)
+                return { funded: false, address: addr, message: "Please fund 1000 sats." };
+            await cmdRegister();
+            return { funded: true, registered: true, message: "Onboarding complete." };
+        }
+        case "pending-requests": return (await cmdServiceQueue()).data;
+        case "fulfill": {
+            const { requestId, recipientKey, serviceId, result } = params;
+            return (await cmdRespondService(requestId, recipientKey, serviceId, JSON.stringify(result))).data;
+        }
+        case "unregister": return (await cmdUnregister()).data;
+        default: throw new Error(`Unknown action: ${action}`);
+    }
 }
 export const plugin = {
-    id: "sv_overlay",
+    id: "openclaw-overlay-plugin",
     name: "BSV Overlay Network",
     description: "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
     activate: register,
     register: register
 };
 export default register;
-async function executeOverlayAction(params, config, api) {
-    await ensureCp();
-    const { action } = params;
-    const env = buildEnvironment(config);
-    const cliPath = getCliPath();
-    switch (action) {
-        case "request": return await handleServiceRequest(params, env, cliPath, config, api);
-        case "discover": return await handleDiscover(params, env, cliPath);
-        case "balance": return await handleBalance(env, cliPath);
-        case "status": return await handleStatus(env, cliPath);
-        case "onboard": return await handleOnboard(params, env, cliPath);
-        case "pending-requests": return await handlePendingRequests(env, cliPath);
-        case "fulfill": return await handleFulfill(params, env, cliPath);
-        case "advertise-ship": return await handleAdvertiseSHIP(params, env, cliPath);
-        case "advertise-slap": return await handleAdvertiseSLAP(params, env, cliPath);
-        default: throw new Error(`Unknown action: ${action}`);
-    }
-}
-async function handleAdvertiseSHIP(params, env, cliPath) {
-    const { domain, topic } = params;
-    const result = await execFileAsync('node', [cliPath, 'advertise-ship', domain, topic], { env });
-    return parseCliOutput(result.stdout).data;
-}
-async function handleAdvertiseSLAP(params, env, cliPath) {
-    const { domain, service } = params;
-    const result = await execFileAsync('node', [cliPath, 'advertise-slap', domain, service], { env });
-    return parseCliOutput(result.stdout).data;
-}
-async function handleServiceRequest(params, env, cliPath, config, api) {
-    const { service, identityKey: targetKey, input } = params;
-    const walletDir = config?.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
-    const discoverResult = await execFileAsync('node', [cliPath, 'discover', '--service', service], { env });
-    const discoverOutput = parseCliOutput(discoverResult.stdout);
-    const providers = discoverOutput.data.services;
-    if (!providers || providers.length === 0)
-        throw new Error(`No providers found for ${service}`);
-    providers.sort((a, b) => (a.pricing?.amountSats || 0) - (b.pricing?.amountSats || 0));
-    const best = providers[0];
-    const price = best.pricing?.amountSats || 0;
-    const budget = checkBudget(walletDir, price, config.dailyBudgetSats || 5000);
-    if (!budget.allowed)
-        throw new Error("Budget exceeded");
-    const requestArgs = [cliPath, 'request-service', best.identityKey, service, price.toString()];
-    if (input)
-        requestArgs.push(JSON.stringify(input));
-    const res = await execFileAsync('node', requestArgs, { env });
-    const output = parseCliOutput(res.stdout);
-    recordSpend(walletDir, price, service, best.name);
-    return { status: "sent", requestId: output.data?.messageId, message: `Request sent to ${best.name} for ${price} sats.` };
-}
-async function handleDiscover(params, env, cliPath) {
-    const args = [cliPath, 'discover'];
-    if (params.service)
-        args.push('--service', params.service);
-    const result = await execFileAsync('node', args, { env });
-    return parseCliOutput(result.stdout).data;
-}
-async function handleBalance(env, cliPath) {
-    const result = await execFileAsync('node', [cliPath, 'balance'], { env });
-    return parseCliOutput(result.stdout).data;
-}
-async function handleStatus(env, cliPath) {
-    const identity = parseCliOutput((await execFileAsync('node', [cliPath, 'identity'], { env })).stdout);
-    const balance = parseCliOutput((await execFileAsync('node', [cliPath, 'balance'], { env })).stdout);
-    return { identity: identity.data, balance: balance.data };
-}
-async function handleOnboard(params, env, cliPath) {
-    await execFileAsync('node', [cliPath, 'setup'], { env });
-    const addr = parseCliOutput((await execFileAsync('node', [cliPath, 'address'], { env })).stdout).data.address;
-    const bal = parseCliOutput((await execFileAsync('node', [cliPath, 'balance'], { env })).stdout).data.walletBalance;
-    if (bal < 1000)
-        return { funded: false, address: addr, message: "Please fund 1000 sats." };
-    await execFileAsync('node', [cliPath, 'register'], { env });
-    return { funded: true, registered: true, message: "Onboarding complete." };
-}
-async function handlePendingRequests(env, cliPath) {
-    const result = await execFileAsync('node', [cliPath, 'service-queue'], { env });
-    return parseCliOutput(result.stdout).data;
-}
-async function handleFulfill(params, env, cliPath) {
-    const { requestId, recipientKey, serviceId, result } = params;
-    const res = await execFileAsync('node', [cliPath, 'respond-service', requestId, recipientKey, serviceId, JSON.stringify(result)], { env });
-    return parseCliOutput(res.stdout).data;
-}
-function buildEnvironment(config) {
-    const env = { ...process['env'] };
-    env.BSV_WALLET_DIR = config.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
-    env.OVERLAY_URL = config.overlayUrl || 'https://clawoverlay.com';
-    env.BSV_NETWORK = config.network || env.BSV_NETWORK || 'mainnet';
-    env.BSV_ARC_URL = config.arcUrl || (env.BSV_NETWORK === 'testnet' ? 'https://testnet.arc.gorillapool.io' : 'https://arc.gorillapool.io');
-    env.AGENT_NAME = config.agentName || 'openclaw-agent';
-    return env;
-}
-function parseCliOutput(stdout) {
-    try {
-        const str = typeof stdout === 'string' ? stdout : String(stdout || '');
-        return JSON.parse(str.trim());
-    }
-    catch (error) {
-        throw new Error(`Failed to parse CLI output: ${error.message}`);
-    }
-}

package/dist/src/cli.js

@@ -8,7 +8,7 @@
 // Must be set before any imports that might load dotenv
 process['en' + 'v'].DOTENV_CONFIG_QUIET = 'true';
 // Dynamic import to ensure env var is set first
-import('./cli-main.js');
+await import('./cli-main.js');
 // Before importing the library
 globalThis.window = { fetch: globalThis.fetch };
 export {};