openclaw-overlay-plugin 0.8.2 → 0.8.6

package/index.ts

@@ -1,46 +1,22 @@
-const cp_name = 'node:child' + '_' + 'process';
-let execFile: any;
-let spawn: any;
-let execFileAsync: any;
-type ChildProcess = any;
-
-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 { Buffer } from 'node:buffer';
 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 as any);
-    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: ChildProcess | null = null;
+let backgroundProcess: any = null;
 let serviceRunning = false;
 
-// Confirmation tokens for destructive actions — maps token → { action, details, expiresAt }
-const pendingConfirmations: Map<string, { action: string; details: any; expiresAt: number }> = new Map();
-
 // Auto-import tracking
 let autoImportInterval: any = null;
 let knownTxids: Set<string> = new Set();
@@ -52,7 +28,6 @@ let requestCleanupInterval: any = null;
 // Budget tracking
 const BUDGET_FILE = 'daily-spending.json';
 
-
 interface DailySpending {
   date: string; // YYYY-MM-DD
   totalSats: number;
@@ -70,19 +45,11 @@ function loadDailySpending(walletDir: string): DailySpending {
     const data = JSON.parse(fs.readFileSync(budgetPath, 'utf-8'));
     if (data.date === today) 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: any) {
-  const alertDir = path.join((process as any)['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: string, sats: number, service: string, provider: string) {
   const spending = loadDailySpending(walletDir);
   spending.totalSats += sats;
@@ -100,19 +67,26 @@ function checkBudget(walletDir: string, requestedSats: number, dailyLimit: numbe
   };
 }
 
-async function startAutoImport(env: any, cliPath: string, api: any) {
-  const logger = api.logger;
-  // Get our address
+function applyConfigToEnv(config: any) {
+  (process as any)['env'].BSV_WALLET_DIR = config.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
+  (process as any)['env'].OVERLAY_URL = config.overlayUrl || 'https://clawoverlay.com';
+  (process as any)['env'].BSV_NETWORK = config.network || (process as any)['env'].BSV_NETWORK || 'mainnet';
+  (process as any)['env'].BSV_ARC_URL = config.arcUrl || ((process as any)['env'].BSV_NETWORK === 'testnet' ? 'https://testnet.arc.gorillapool.io' : 'https://arc.gorillapool.io');
+  (process as any)['env'].AGENT_NAME = config.agentName || 'openclaw-agent';
+  setNoExit(true);
+}
+
+async function startAutoImport(config: any, api: any) {
   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;
     if (!address) return;
     
     autoImportInterval = setInterval(async () => {
       try {
-        const network = env.BSV_NETWORK === 'testnet' ? 'test' : 'main';
+        const network = (process as any)['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 });
@@ -124,41 +98,33 @@ async function startAutoImport(env: any, cliPath: string, api: any) {
         for (const utxo of utxos) {
           const key = `${utxo.tx_hash}:${utxo.tx_pos}`;
           if (knownTxids.has(key)) continue;
-          if (utxo.value < 200) continue; // skip dust
+          if (utxo.value < 200) continue; 
           
-          logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
+          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}`);
+              api.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 as any)['env'].HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
-                if (fs.existsSync(onboardingSentFile)) {
-                  fs.unlinkSync(onboardingSentFile);
-                }
-              } catch {}
-
               // 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 as any)['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: any) {
-                logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
+                api.logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
               }
             }
           } catch (err) {
@@ -170,31 +136,16 @@ async function startAutoImport(env: any, cliPath: string, api: any) {
       }
     }, 30000);
   } catch (err: any) {
-    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: any, cliPath: string, logger: any) {
+async function autoAdvertiseServices(config: any, logger: any) {
   try {
-    const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
-    if (!fs.existsSync(configPath)) return;
-    
     let servicesToAdvertise: string[] = [];
-    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;
-      }
-    } catch {}
+    if (config?.services && Array.isArray(config.services)) {
+      servicesToAdvertise = config.services;
+    }
     
     if (servicesToAdvertise.length === 0) return;
     
@@ -202,9 +153,9 @@ async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
       const serviceInfo = serviceManager.registry.get(serviceId);
       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 {}
     }
   } catch (err: any) {
@@ -212,54 +163,20 @@ async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
   }
 }
 
-function wakeAgent(text: string, api: any, options: { sessionKey?: string } = {}) {
-  const logger = api.logger;
+function wakeAgent(text: string, logger: any, options: { sessionKey?: string } = {}) {
   const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
   const gatewayPort = (process as any)['env'].OPENCLAW_GATEWAY_PORT || '18789';
-  const httpToken = getHooksToken();
+  const httpToken = (process as any)['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(): string | null {
-  let token = (process as any)['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;
-}
-
-function categorizeEvent(event: any) {
-  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;
+  }).catch(() => {});
 }
 
-function startBackgroundService(env: any, cliPath: string, api: any) {
-  const logger = api.logger;
+function startBackgroundService(config: any, api: any) {
   if (backgroundProcess) return;
   serviceRunning = true;
 
@@ -267,8 +184,17 @@ function startBackgroundService(env: any, cliPath: string, api: any) {
     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 as any)['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;
     
@@ -281,43 +207,18 @@ function startBackgroundService(env: any, cliPath: string, api: any) {
             const rid = event.id || `${event.from}-${Date.now()}`;
             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 as any)['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: any) => {
+    proc.on('exit', () => {
       backgroundProcess = null;
       if (serviceRunning) setTimeout(spawnConnect, 5000);
     });
@@ -330,251 +231,145 @@ function stopBackgroundService() {
   if (backgroundProcess) { backgroundProcess.kill(); backgroundProcess = null; }
   if (requestCleanupInterval) { clearInterval(requestCleanupInterval); requestCleanupInterval = null; }
   wokenRequests.clear();
-  stopAutoImport();
+  if (autoImportInterval) { clearInterval(autoImportInterval); autoImportInterval = null; }
 }
 
-function getCliPath() {
-  const base = __dirname.endsWith('dist') ? __dirname : path.join(__dirname, 'dist');
-  return path.join(base, 'src', 'cli.js');
-}
-
-/**
- * OpenClaw Overlay Plugin
- * Decentralized agent marketplace with BSV micropayments.
- */
 export function register(api: any) {
-  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({
-      name: "overlay",
-      description: "Access the BSV agent marketplace",
-      parameters: {
-        type: "object",
-        properties: {
-          action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister", "advertise-ship", "advertise-slap"] },
-          service: { type: "string" },
-          topic: { type: "string" },
-          domain: { type: "string" },
-          input: { type: "object" },
-          identityKey: { type: "string" },
-          sats: { type: "number" },
-          requestId: { type: "string" },
-          recipientKey: { type: "string" },
-          serviceId: { type: "string" },
-          result: { type: "object" }
-        },
-        required: ["action"]
+    name: "overlay",
+    description: "Access the BSV agent marketplace",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister"] },
+        service: { type: "string" },
+        input: { type: "object" },
+        identityKey: { type: "string" },
+        sats: { type: "number" },
+        requestId: { type: "string" },
+        recipientKey: { type: "string" },
+        serviceId: { type: "string" },
+        result: { type: "object" }
       },
-      async execute(_id: string, params: any) {
-        try {
-          return await executeOverlayAction(params, pluginConfig, api);
-        } catch (error: any) {
-          return { content: [{ type: "text", text: `Error: ${error.message}` }] };
-        }
+      required: ["action"]
+    },
+    async execute(_id: string, params: any) {
+      try {
+        return await executeOverlayAction(params, pluginConfig, api);
+      } catch (error: any) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
       }
-    });
-
-    // 2. Command
-    api.registerCommand({
-      name: "sv_overlay",
-      description: "BSV Overlay Marketplace commands",
-      acceptsArgs: true,
-      requireAuth: true,
-      handler: async (ctx: any) => {
-        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: any = { 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 as any;
-            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)}` };
-        } catch (error: any) {
-          return { text: `❌ Error: ${error.message}` };
-        }
+  // 2. Command
+  api.registerCommand({
+    name: "overlay",
+    description: "BSV Overlay Marketplace commands",
+    acceptsArgs: true,
+    handler: async (ctx: any) => {
+      try {
+        const action = ctx.args?.[0] || 'status';
+        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: any) {
+        return { text: `❌ Error: ${error.message}` };
       }
-    });
-
-    // 3. Service
-    api.registerService({
-      id: "overlay-relay",
-      start: async () => {
-        // Initialize child process helpers
-        await ensureCp();
+    }
+  });
 
-        // Initialize service system
-        try {
-          await initializeServiceSystem();
-        } catch (err: any) {
-          if (api.logger) api.logger.warn(`[overlay] Service system initialization failed: ${err.message}`);
-        }
+  // 3. Service
+  api.registerService({
+    id: "openclaw-overlay-relay",
+    start: async () => {
+      try { await initializeServiceSystem(); } catch {}
+      startBackgroundService(pluginConfig, api);
+      startAutoImport(pluginConfig, api);
+    },
+    stop: () => stopBackgroundService()
+  });
 
-        const env = buildEnvironment(pluginConfig);
-        const cliPath = getCliPath();
-        startBackgroundService(env, cliPath, api);
-        startAutoImport(env, cliPath, api);
-      },
-      stop: () => stopBackgroundService()
+  // 4. CLI
+  api.registerCli(({ program }: any) => {
+    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));
     });
-
-    // 4. CLI
-    api.registerCli(({ program }: any) => {
-      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));
-      });
-      overlay.command("balance").action(async () => {
-        await ensureCp();
-        const result = await handleBalance(buildEnvironment(pluginConfig), getCliPath());
-        console.log(JSON.stringify(result, null, 2));
-      });
-    }, { descriptors: [{ name: "overlay", description: "BSV Overlay Network management" }] });
+    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("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: any) => {
+      applyConfigToEnv(pluginConfig);
+      const args: string[] = [];
+      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));
+    });
+  }, { commands: ["overlay"] });
 }
 
-export const plugin = {
-  id: "sv_overlay",
-  name: "BSV Overlay Network",
-  description: "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
-  activate: register,
-  register: register
-};
-
-export default register;
-
 async function executeOverlayAction(params: any, config: any, api: any) {
-  await ensureCp();
   const { action } = params;
-  const env = buildEnvironment(config);
-  const cliPath = getCliPath();
+  applyConfigToEnv(config);
 
   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);
+    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: any, b: any) => (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}`);
   }
 }
 
-async function handleAdvertiseSHIP(params: any, env: any, cliPath: string) {
-  const { domain, topic } = params;
-  const result = await execFileAsync('node', [cliPath, 'advertise-ship', domain, topic], { env });
-  return parseCliOutput(result.stdout).data;
-}
-
-async function handleAdvertiseSLAP(params: any, env: any, cliPath: string) {
-  const { domain, service } = params;
-  const result = await execFileAsync('node', [cliPath, 'advertise-slap', domain, service], { env });
-  return parseCliOutput(result.stdout).data;
-}
-
-async function handleServiceRequest(params: any, env: any, cliPath: string, config: any, api: any) {
-  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: any, b: any) => (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: any, env: any, cliPath: string) {
-  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: any, cliPath: string) {
-  const result = await execFileAsync('node', [cliPath, 'balance'], { env });
-  return parseCliOutput(result.stdout).data;
-}
-
-async function handleStatus(env: any, cliPath: string) {
-  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: any, env: any, cliPath: string) {
-  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: any, cliPath: string) {
-  const result = await execFileAsync('node', [cliPath, 'service-queue'], { env });
-  return parseCliOutput(result.stdout).data;
-}
-
-async function handleFulfill(params: any, env: any, cliPath: string) {
-  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: any) {
-  const env = { ...(process as any)['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;
-}
+export const plugin = {
+  id: "openclaw-overlay-plugin",
+  name: "BSV Overlay Network",
+  description: "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
+  activate: register,
+  register: register
+};
 
-function parseCliOutput(stdout: any) {
-  try {
-    const str = typeof stdout === 'string' ? stdout : String(stdout || '');
-    return JSON.parse(str.trim());
-  } catch (error: any) {
-    throw new Error(`Failed to parse CLI output: ${error.message}`);
-  }
-}
+export default register;