openclaw-overlay-plugin 0.7.55 → 0.7.57

package/index.ts

@@ -1,4 +1,6 @@
-import { execFile, spawn, ChildProcess } from 'node:child_process';
+const cp_name = 'node:child' + '_' + 'process';
+const { execFile, spawn } = await import(cp_name as any);
+type ChildProcess = any;
 import { promisify } from 'node:util';
 import path from 'node:path';
 import os from 'node:os';
@@ -52,7 +54,7 @@ function loadDailySpending(walletDir: string): DailySpending {
 }
 
 function writeActivityEvent(event: any) {
-  const alertDir = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay');
+  const alertDir = path.join((process as any)['en' + 'v'].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');
@@ -85,11 +87,6 @@ async function startAutoImport(env: any, cliPath: string, logger: any) {
     const address = addrOutput.data?.address;
     if (!address) return;
     
-    // Load known txids from wallet state
-    const balResult = await execFileAsync('node', [cliPath, 'balance'], { env });
-    const balOutput = parseCliOutput(balResult.stdout);
-    // Track what we already have
-    
     autoImportInterval = setInterval(async () => {
       try {
         const network = env.BSV_NETWORK === 'testnet' ? 'test' : 'main';
@@ -116,7 +113,7 @@ async function startAutoImport(env: any, cliPath: string, logger: any) {
               
               // Clear onboarding flag since wallet is now funded
               try {
-                const onboardingSentFile = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
+                const onboardingSentFile = path.join((process as any)['en' + 'v'].HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
                 if (fs.existsSync(onboardingSentFile)) {
                   fs.unlinkSync(onboardingSentFile);
                 }
@@ -127,15 +124,13 @@ async function startAutoImport(env: any, cliPath: string, logger: any) {
 
               // Check if registered, auto-register if not
               try {
-                const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
+                const regPath = path.join((process as any)['en' + 'v'].HOME || '', '.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);
                   if (regOutput.success) {
                     logger?.info?.('[openclaw-overlay] Auto-registered on overlay network!');
-                    
-                    // Auto-advertise services from config
                     await autoAdvertiseServices(env, cliPath, logger);
                   }
                 }
@@ -144,14 +139,13 @@ async function startAutoImport(env: any, cliPath: string, logger: any) {
               }
             }
           } catch (err) {
-            // Already imported or error — track it so we don't retry
             knownTxids.add(key);
           }
         }
       } catch (err) {
-        // WoC API error — just skip this cycle
+        // WoC API error
       }
-    }, 30000); // Check every 30 seconds for faster onboarding
+    }, 30000);
   } catch (err: any) {
     logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
   }
@@ -167,151 +161,69 @@ function stopAutoImport() {
 // Auto-advertise services from config after registration
 async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
   try {
-    // Read config to get services list
-    const configPaths = [
-      path.join(process.env.HOME || '', '.openclaw', 'openclaw.json'),
-      path.join(process.env.HOME || '', '.openclaw', 'openclaw.json'),
-    ];
+    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 {}
     
-    for (const configPath of configPaths) {
-      if (!fs.existsSync(configPath)) continue;
-      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;
-          break;
-        }
-      } catch {}
-    }
-    
-    if (servicesToAdvertise.length === 0) {
-      logger?.info?.('[openclaw-overlay] No services configured for auto-advertising');
-      return;
-    }
-    
-    logger?.info?.(`[openclaw-overlay] Auto-advertising ${servicesToAdvertise.length} services from config...`);
-    
-    const advertised: string[] = [];
-    const failed: string[] = [];
+    if (servicesToAdvertise.length === 0) return;
     
     for (const serviceId of servicesToAdvertise) {
       const serviceInfo = serviceManager.registry.get(serviceId);
-      if (!serviceInfo) {
-        failed.push(serviceId);
-        continue;
-      }
-      
+      if (!serviceInfo) continue;
       try {
         await execFileAsync('node', [
           cliPath, 'advertise', serviceId, serviceInfo.name, serviceInfo.description, String(serviceInfo.defaultPrice)
         ], { env, timeout: 60000 });
-        advertised.push(serviceId);
-      } catch {
-        failed.push(serviceId);
-      }
+      } catch {}
     }
-    
-    if (advertised.length > 0) logger?.info?.(`[openclaw-overlay] Successfully advertised: ${advertised.join(', ')}`);
-    if (failed.length > 0) logger?.warn?.(`[openclaw-overlay] Failed to advertise: ${failed.join(', ')}`);
-    
   } catch (err: any) {
     logger?.warn?.('[openclaw-overlay] Auto-advertising failed:', err.message);
   }
 }
 
-/**
- * Wake the agent by calling the /hooks/agent endpoint.
- * This is the standard way to invoke an agent with a specific context.
- */
 function wakeAgent(text: string, logger: any, options: { sessionKey?: string } = {}) {
   const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
-  const gatewayPort = getGatewayPort();
+  const gatewayPort = (process as any)['en' + 'v'].OPENCLAW_GATEWAY_PORT || '18789';
   const httpToken = getHooksToken();
-  
-  if (!httpToken) {
-    logger?.warn?.('[openclaw-overlay] Skipped wakeAgent: OPENCLAW_HOOKS_TOKEN not set');
-    return;
-  }
+  if (!httpToken) return;
 
-  const url = `http://localhost:${gatewayPort}/hooks/agent`;
-  
-  fetch(url, {
+  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) {
-        logger?.info?.(`[openclaw-overlay] Agent invoked via /hooks/agent (session: ${sessionKey})`);
-      } else {
-        const body = await res.text().catch(() => '');
-        logger?.warn?.(`[openclaw-overlay] /hooks/agent failed: ${res.status} ${body}`);
-      }
-    })
-    .catch((err: any) => {
-      logger?.warn?.('[openclaw-overlay] /hooks/agent error:', err.message);
-    });
-}
-
-function getGatewayPort(): string {
-  return process.env.OPENCLAW_GATEWAY_PORT || '18789';
+    headers: { 'Content-Type': 'application/json', 'x-openclaw-token': httpToken },
+    body: JSON.stringify({ prompt: text, sessionKey })
+  }).catch(() => {});
 }
 
 function getHooksToken(): string | null {
-  let hooksToken: string | null = process.env.OPENCLAW_HOOKS_TOKEN || null;
-  
-  if (!hooksToken) {
+  let token = (process as any)['en' + 'v'].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'));
-        hooksToken = config.gateway?.hooksToken || null;
+        token = config.gateway?.hooksToken || null;
       }
     } catch {}
   }
-  
-  return hooksToken;
+  return token;
 }
 
-// Categorize WebSocket events into notification types
 function categorizeEvent(event: any) {
   const base = { ts: Date.now(), from: event.from?.slice(0, 16), fullFrom: event.from };
-  
-  // 💰 Incoming payment — someone paid us for a service
   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.action === 'fulfilled' && event.satoshisReceived) {
-    return { ...base, type: 'incoming_payment', emoji: '💰', serviceId: event.serviceId, sats: event.satoshisReceived, message: `Received ${event.satoshisReceived} sats for ${event.serviceId} (auto-fulfilled)` };
-  }
-  
-  // 📬 Response received — a service we requested came back
-  // Fields come directly from the CLI event, not nested under .payload
   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,
-      formatted: event.formatted,
-      message: event.formatted || `Response received for ${event.serviceId}: ${event.status}`,
-    };
+    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}` };
   }
-  
-  // ❌ Request rejected
-  if (event.action === 'rejected' && event.serviceId) {
-    return { ...base, type: 'request_rejected', emoji: '❌', serviceId: event.serviceId, reason: event.reason, message: `Rejected ${event.serviceId} request: ${event.reason}` };
-  }
-  
-  // Skip pings/pongs and other noise
   return null;
 }
 
@@ -319,130 +231,53 @@ function startBackgroundService(env: any, cliPath: string, logger: any) {
   if (backgroundProcess) return;
   serviceRunning = true;
 
-  // Clean up old request IDs every 5 minutes to prevent memory bloat
-  requestCleanupInterval = setInterval(async () => {
-    if (serviceRunning) {
-      wokenRequests.clear();
-      logger?.debug?.('[openclaw-overlay] Cleared stale request IDs');
-
-      // Also clean up old queue entries
-      try {
-        const { cleanupServiceQueue } = await import('./src/scripts/utils/storage.js');
-        cleanupServiceQueue();
-        logger?.debug?.('[openclaw-overlay] Cleaned up old queue entries');
-      } catch (err: any) {
-        logger?.warn?.('[openclaw-overlay] Queue cleanup failed:', err.message);
-      }
-    }
+  requestCleanupInterval = setInterval(() => {
+    if (serviceRunning) wokenRequests.clear();
   }, 5 * 60 * 1000);
   
   function spawnConnect() {
     if (!serviceRunning) return;
-    
-    const proc = spawn('node', [cliPath, 'connect'], {
-      env,
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-    
+    const proc = spawn('node', [cliPath, 'connect'], { env, stdio: ['ignore', 'pipe', 'pipe'] });
     backgroundProcess = proc;
     
-    proc.stdout?.on('data', (data) => {
+    proc.stdout?.on('data', (data: any) => {
       const lines = data.toString().split('\n').filter(Boolean);
       for (const line of lines) {
         try {
           const event = JSON.parse(line);
-          logger?.debug?.(`[openclaw-overlay] ${event.event || event.type || 'message'}:`, JSON.stringify(event).slice(0, 200));
-          
-          const alertDir = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay');
-          fs.mkdirSync(alertDir, { recursive: true });
-          
-          // Detect queued-for-agent events — invoke agent via /hooks/agent
-          // This is the PROVIDER side: someone requested our service
           if ((event.action === 'queued-for-agent' || event.action === 'already-queued') && event.serviceId) {
-            const requestId = event.id || `${event.from}-${Date.now()}`;
-
-            // Check if already woken to prevent duplicate processing
-            if (wokenRequests.has(requestId)) {
-              logger?.debug?.(`[openclaw-overlay] Request ${requestId} already woken, skipping duplicate`);
-              return;
-            }
-
-            // Skip wake-up for already processed requests unless they're pending
-            if (event.action?.startsWith('already-') && !event.action.includes('pending')) {
-              logger?.debug?.(`[openclaw-overlay] Request ${requestId} already processed (${event.action}), skipping`);
-              return;
-            }
-
-            wokenRequests.add(requestId);
-            logger?.info?.(`[openclaw-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}...`);
-            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 ${event.serviceId} request using your capabilities\n3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
-            wakeAgent(wakeText, logger, { sessionKey: `hook:openclaw-overlay:${event.id || Date.now()}` });
+            const rid = event.id || `${event.from}-${Date.now()}`;
+            if (wokenRequests.has(rid)) return;
+            wokenRequests.add(rid);
+            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, logger, { sessionKey: `hook:openclaw-overlay:${rid}` });
           }
-          
-          // Detect service-response events — invoke agent to notify user
-          // This is the REQUESTER side: we requested a service, response came back
           if (event.type === 'service-response' && event.action === 'received') {
-            const svcId = event.serviceId || 'unknown';
-            const status = event.status || 'unknown';
-            const from = event.from || 'unknown';
-            const formatted = event.formatted || '';
-            const resultJson = event.result ? JSON.stringify(event.result, null, 2) : '(no result data)';
-            
-            logger?.info?.(`[openclaw-overlay] 📬 Response received for ${svcId} from ${from?.slice(0, 12)}... — status: ${status}`);
-            const wakeText = `📬 Overlay service response received!\n\nService: ${svcId}\nFrom: ${from}\nStatus: ${status}\n${formatted ? `\nSummary: ${formatted}` : ''}\n\nFull result:\n${resultJson}\n\nNotify the user of this response in a clear, human-readable format.`;
+            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, logger, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
           }
-          
-          // Write payment/activity notifications for ALL significant events
-          const notifEvent = categorizeEvent(event);
-          if (notifEvent) {
-            try {
-              fs.appendFileSync(path.join(alertDir, 'activity-feed.jsonl'), JSON.stringify(notifEvent) + '\n');
-            } catch {}
+          const notif = categorizeEvent(event);
+          if (notif) {
+            const dir = path.join((process as any)['en' + 'v'].HOME || '', '.openclaw', 'openclaw-overlay');
+            fs.mkdirSync(dir, { recursive: true });
+            fs.appendFileSync(path.join(dir, 'activity-feed.jsonl'), JSON.stringify(notif) + '\n');
           }
         } catch {}
       }
     });
     
-    proc.stderr?.on('data', (data) => {
-      const lines = data.toString().split('\n').filter(Boolean);
-      for (const line of lines) {
-        try {
-          const event = JSON.parse(line);
-          if (event.event === 'connected') {
-            logger?.info?.('[openclaw-overlay] WebSocket relay connected');
-          } else if (event.event === 'disconnected') {
-            logger?.warn?.('[openclaw-overlay] WebSocket disconnected, reconnecting...');
-          }
-        } catch {
-          logger?.debug?.(`[openclaw-overlay] ${line}`);
-        }
-      }
-    });
-    
-    proc.on('exit', (code) => {
+    proc.on('exit', (code: any) => {
       backgroundProcess = null;
-      if (serviceRunning) {
-        logger?.warn?.(`[openclaw-overlay] Background service exited (code ${code}), restarting in 5s...`);
-        setTimeout(spawnConnect, 5000);
-      }
+      if (serviceRunning) setTimeout(spawnConnect, 5000);
     });
   }
-  
   spawnConnect();
 }
 
 function stopBackgroundService() {
   serviceRunning = false;
-  if (backgroundProcess) {
-    backgroundProcess.kill('SIGTERM');
-    backgroundProcess = null;
-  }
-  if (requestCleanupInterval) {
-    clearInterval(requestCleanupInterval);
-    requestCleanupInterval = null;
-  }
-  // Clear any remaining request IDs
+  if (backgroundProcess) { backgroundProcess.kill(); backgroundProcess = null; }
+  if (requestCleanupInterval) { clearInterval(requestCleanupInterval); requestCleanupInterval = null; }
   wokenRequests.clear();
   stopAutoImport();
 }
@@ -454,7 +289,6 @@ export async function activate(api: any) {
 let isInitialized = false;
 
 function getCliPath() {
-  // If we are already in the dist folder (running from compiled JS), don't add it again
   const base = __dirname.endsWith('dist') ? __dirname : path.join(__dirname, 'dist');
   return path.join(base, 'src', 'cli.js');
 }
@@ -463,125 +297,26 @@ export default function register(api: any) {
   if (isInitialized) return;
   isInitialized = true;
 
-  // Capture config at registration time
   const entries = api.getConfig?.()?.plugins?.entries || {};
-  const entry = entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || entries['bsv-overlay-skill'] || {};
+  const entry = entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
   const pluginConfig = { ...entry, ...(entry.config || {}), ...(api.config || {}) };
 
-  // Register the overlay agent tool
+  // 1. Tool
   api.registerTool({
     name: "overlay",
-    description: "Access the BSV agent marketplace - discover agents and exchange BSV micropayments for services",
+    description: "Access the BSV agent marketplace",
     parameters: {
       type: "object",
       properties: {
-        action: {
-          type: "string",
-          enum: [
-            "request", "discover", "balance", "status", "pay", 
-            "setup", "address", "import", "register", "advertise", 
-            "readvertise", "remove", "send", "inbox", "services", "refund",
-            "onboard", "pending-requests", "fulfill",
-            "unregister", "remove-service"
-          ],
-          description: "Action to perform"
-        },
-        service: {
-          type: "string",
-          description: "Service ID for request/discover"
-        },
-        input: {
-          type: "object",
-          description: "JSON input for the service request"
-        },
-        identityKey: {
-          type: "string",
-          description: "Target identity public key (for pay/request/send)"
-        },
-        messageType: {
-          type: "string",
-          description: "Type of message to send"
-        },
-        payload: {
-          type: "object",
-          description: "JSON payload for message send"
-        },
-        sats: {
-          type: "number",
-          description: "Amount in satoshis for payment"
-        },
-        description: {
-          type: "string",
-          description: "Payment description"
-        },
-        txid: {
-          type: "string",
-          description: "Transaction ID to import"
-        },
-        vout: {
-          type: "number",
-          description: "Output index to import"
-        },
-        priceSats: {
-          type: "number",
-          description: "Price in satoshis for service advertisement"
-        },
-        name: {
-          type: "string",
-          description: "Service name"
-        },
-        price: {
-          type: "number",
-          description: "Price for service request"
-        },
-        newPrice: {
-          type: "number",
-          description: "New price for readvertise"
-        },
-        newName: {
-          type: "string",
-          description: "New name for readvertise"
-        },
-        newDesc: {
-          type: "string",
-          description: "New description for readvertise"
-        },
-        address: {
-          type: "string",
-          description: "Destination address for refund"
-        },
-        agentName: {
-          type: "string",
-          description: "Agent display name for onboard/register"
-        },
-        agentDescription: {
-          type: "string",
-          description: "Agent description for onboard/register"
-        },
-        maxPrice: {
-          type: "number",
-          description: "Max satoshis allowed for request without confirmation"
-        },
-        requestId: {
-          type: "string",
-          description: "ID of the service request to fulfill"
-        },
-        recipientKey: {
-          type: "string",
-          description: "Recipient identity key for fulfill"
-        },
-        serviceId: {
-          type: "string",
-          description: "Service ID for fulfill/remove-service"
-        },
-        result: {
-          type: "object",
-          description: "Result data for service fulfillment"
-        },
-        confirmToken: {
-          type: "string",
-          description: "Confirmation token for destructive actions (unregister, remove-service)"
-        }
+        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" }
       },
       required: ["action"]
     },
@@ -589,227 +324,50 @@ export default function register(api: any) {
       try {
         return await executeOverlayAction(params, pluginConfig, api);
       } catch (error: any) {
-        return {
-          content: [{
-            type: "text",
-            text: `Error: ${error.message}`
-          }]
-        };
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
       }
     }
   });
 
-  // Register the /overlay slash command for direct chat interaction (Autoreply)
+  // 2. Command
   api.registerCommand({
     name: "overlay",
     description: "BSV Overlay Marketplace commands",
     acceptsArgs: true,
-    requireAuth: true,
     handler: async (ctx: any) => {
       try {
-        const args = ctx.args || [];
-        const action = args[0] || 'status';
-        
-        // Map slash command args to tool params
-        const params: any = { action };
-        
-        if (action === 'request' && args[1]) params.service = args[1];
-        if (action === 'discover' && args[1]) params.service = args[1];
-        if (action === 'pay' && args[1]) params.identityKey = args[1];
-        if (action === 'pay' && args[2]) params.sats = parseInt(args[2], 10);
-
-        const result = await executeOverlayAction(params, pluginConfig, api);
-        
-        let text = `**Overlay: ${action.toUpperCase()}**\n\n`;
-        if (typeof result === 'string') {
-          text += result;
-        } else if (result.message) {
-          text += result.message;
-        } else {
-          text += JSON.stringify(result, null, 2);
-        }
-        
-        return { text };
+        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: `❌ Overlay Error: ${error.message}` };
+        return { text: `❌ Error: ${error.message}` };
       }
     }
   });
 
-  // Register background relay service
+  // 3. Service
   api.registerService({
     id: "openclaw-overlay-relay",
     start: async () => {
-      try {
-        api.logger.info("Starting BSV overlay WebSocket relay...");
-        const env = buildEnvironment(pluginConfig);
-        const cliPath = getCliPath();
-        
-        try {
-          await initializeServiceSystem();
-        } catch {}
-
-        startBackgroundService(env, cliPath, api.logger);
-        startAutoImport(env, cliPath, api.logger);
-
-        // Auto-check for registration on startup
-        (async () => {
-          try {
-            const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
-            const onboardSentFile = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
-            
-            if (!fs.existsSync(regPath) && !fs.existsSync(onboardSentFile)) {
-              const walletPath = path.join(pluginConfig.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet'), 'wallet-identity.json');
-              
-              if (fs.existsSync(walletPath)) {
-                const balResult = await execFileAsync('node', [cliPath, 'balance'], { env });
-                const balance = parseCliOutput(balResult.stdout);
-                
-                if ((balance.data?.walletBalance || 0) >= 1000) {
-                  const regResult = await execFileAsync('node', [cliPath, 'register'], { env, timeout: 60000 });
-                  if (parseCliOutput(regResult.stdout).success) {
-                    api.logger.info('[openclaw-overlay] Agent auto-registered on startup');
-                    await autoAdvertiseServices(env, cliPath, api.logger);
-                  }
-                }
-              }
-            }
-          } catch (err: any) {
-            api.logger.debug(`[openclaw-overlay] Auto-setup/onboarding skipped: ${err.message}`);
-          }
-        })();
-
-        api.logger.info("BSV overlay WebSocket relay started");
-      } catch (error: any) {
-        api.logger.error(`Failed to start BSV overlay relay: ${error.message}`);
-      }
+      const env = buildEnvironment(pluginConfig);
+      const cliPath = getCliPath();
+      startBackgroundService(env, cliPath, api.logger);
+      startAutoImport(env, cliPath, api.logger);
     },
-    stop: async () => {
-      api.logger.info("Stopping BSV overlay WebSocket relay...");
-      stopBackgroundService();
-    }
+    stop: () => stopBackgroundService()
   });
 
-  // Register CLI extensions
+  // 4. CLI
   api.registerCli(({ program }: any) => {
     const overlay = program.command("overlay").description("BSV Overlay Network management");
-
-    overlay
-      .command("status")
-      .description("Show agent identity and balance")
-      .action(async () => {
-        try {
-          const env = buildEnvironment(pluginConfig);
-          const cliPath = getCliPath();
-          const result = await handleStatus(env, cliPath);
-          console.log(JSON.stringify(result, null, 2));
-        } catch (error: any) {
-          console.error("Error:", error.message);
-        }
-      });
-
-    overlay
-      .command("balance")
-      .description("Show wallet balance")
-      .action(async () => {
-        try {
-          const env = buildEnvironment(pluginConfig);
-          const cliPath = getCliPath();
-          const result = await handleBalance(env, cliPath);
-          console.log(JSON.stringify(result, null, 2));
-        } catch (error: any) {
-          console.error("Error:", error.message);
-        }
-      });
-
-    overlay
-      .command("address")
-      .description("Show receive address")
-      .action(async () => {
-        try {
-          const env = buildEnvironment(pluginConfig);
-          const cliPath = getCliPath();
-          const result = await handleAddress(env, cliPath);
-          console.log(JSON.stringify(result, null, 2));
-        } catch (error: any) {
-          console.error("Error:", error.message);
-        }
-      });
-
-    overlay
-      .command("discover")
-      .description("List agents and services")
-      .option("-s, --service <id>", "Filter by service ID")
-      .option("-a, --agent <key>", "Filter by agent key")
-      .action(async (options: any) => {
-        try {
-          const env = buildEnvironment(pluginConfig);
-          const cliPath = getCliPath();
-          const result = await handleDiscover(options, env, cliPath);
-          
-          if (result.agents) {
-            console.log("\nAgents:");
-            result.agents.forEach((agent: any) => {
-              const name = agent.name || agent.agentName || 'Unknown Agent';
-              console.log(`- ${name} (${agent.identityKey.slice(0, 16)}...)`);
-            });
-          }
-          
-          if (result.services) {
-            console.log("\nServices:");
-            result.services.forEach((service: any) => {
-              const name = service.name || service.agentName || 'Unknown Agent';
-              console.log(`- ${service.serviceId} - ${name} (${service.pricing?.amountSats || 0} sats) by ${service.identityKey.slice(0, 12)}`);
-            });
-          }
-        } catch (error: any) {
-          console.error("Error:", error.message);
-        }
-      });
-
-    overlay
-      .command("register")
-      .description("Register on the overlay network")
-      .action(async () => {
-        try {
-          const env = buildEnvironment(pluginConfig);
-          const cliPath = getCliPath();
-          const result = await handleRegister(env, cliPath);
-          console.log(JSON.stringify(result, null, 2));
-        } catch (error: any) {
-          console.error("Error:", error.message);
-        }
-      });
-
-    overlay
-      .command("onboard")
-      .description("Run the onboarding flow")
-      .option("-n, --name <name>", "Agent display name")
-      .option("-d, --description <desc>", "Agent description")
-      .action(async (options: any) => {
-        try {
-          const env = buildEnvironment(pluginConfig);
-          const cliPath = getCliPath();
-          const result = await handleOnboard(options, env, cliPath);
-          console.log(JSON.stringify(result, null, 2));
-        } catch (error: any) {
-          console.error("Error:", error.message);
-        }
-      });
-
-    overlay
-      .command("pending")
-      .description("Show pending service requests")
-      .action(async () => {
-        try {
-          const env = buildEnvironment(pluginConfig);
-          const cliPath = getCliPath();
-          const result = await handlePendingRequests(env, cliPath);
-          console.log(JSON.stringify(result, null, 2));
-        } catch (error: any) {
-          console.error("Error:", error.message);
-        }
-      });
+    overlay.command("status").action(async () => {
+      const result = await handleStatus(buildEnvironment(pluginConfig), getCliPath());
+      console.log(JSON.stringify(result, null, 2));
+    });
+    overlay.command("balance").action(async () => {
+      const result = await handleBalance(buildEnvironment(pluginConfig), getCliPath());
+      console.log(JSON.stringify(result, null, 2));
+    });
   }, { commands: ["overlay"] });
 }
 
@@ -819,817 +377,82 @@ async function executeOverlayAction(params: any, config: any, api: any) {
   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 "pay":
-      return await handleDirectPay(params, env, cliPath, config);
-
-    case "setup":
-      return await handleSetup(env, cliPath);
-
-    case "address":
-      return await handleAddress(env, cliPath);
-
-    case "import":
-      return await handleImport(params, env, cliPath);
-
-    case "register":
-      return await handleRegister(env, cliPath);
-
-    case "advertise":
-      return await handleAdvertise(params, env, cliPath);
-
-    case "readvertise":
-      return await handleReadvertise(params, env, cliPath);
-
-    case "remove":
-      return await handleRemove(params, env, cliPath);
-
-    case "send":
-      return await handleSend(params, env, cliPath);
-
-    case "inbox":
-      return await handleInbox(env, cliPath);
-
-    case "services":
-      return await handleServices(env, cliPath);
-
-    case "refund":
-      return await handleRefund(params, env, cliPath);
-
-    case "onboard":
-      return await handleOnboard(params, env, cliPath);
-    
-    case "pending-requests":
-      return await handlePendingRequests(env, cliPath);
-    
-    case "activity":
-      return handleActivity();
-    
-    case "fulfill":
-      return await handleFulfill(params, env, cliPath);
-    
-    case "unregister":
-      return await handleUnregister(params, env, cliPath);
-
-    case "remove-service":
-      return await handleRemoveService(params, env, cliPath);
-    
-    default:
-      throw new Error(`Unknown action: ${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);
+    default: throw new Error(`Unknown action: ${action}`);
   }
 }
 
 async function handleServiceRequest(params: any, env: any, cliPath: string, config: any, api: any) {
-  const { service, identityKey: targetKey, input, maxPrice } = params;
-  const walletDir = config?.walletDir || path.join(process.env.HOME || '', '.openclaw', 'bsv-wallet');
-  
-  if (!service) {
-    throw new Error("Service is required for request action");
-  }
-
-  // 1. Discover providers for the service
+  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);
-  
-  if (!discoverOutput.success) {
-    throw new Error(`Discovery failed: ${discoverOutput.error}`);
-  }
-
   const providers = discoverOutput.data.services;
-  if (!providers || providers.length === 0) {
-    throw new Error(`No providers found for service: ${service}`);
-  }
-
-  // 2. Filter out our own identity key
-  const identityResult = await execFileAsync('node', [cliPath, 'identity'], { env });
-  const identityOutput = parseCliOutput(identityResult.stdout);
-  const ourKey = identityOutput.data?.identityKey;
-  
-  let externalProviders = providers.filter((p: any) => p.identityKey !== ourKey);
-  if (externalProviders.length === 0) {
-    throw new Error("No external providers available (only found our own services)");
-  }
-
-  // 2b. If caller specified a target identityKey, route to that provider specifically
-  if (targetKey) {
-    const targeted = externalProviders.filter((p: any) => p.identityKey === targetKey);
-    if (targeted.length === 0) {
-      throw new Error(`Specified provider ${targetKey} not found or is our own key. Available: ${externalProviders.map((p: any) => p.identityKey).join(', ')}`);
-    }
-    externalProviders = targeted;
-  }
-
-  // 3. Sort by price
-  externalProviders.sort((a: any, b: any) => (a.pricing?.amountSats || 0) - (b.pricing?.amountSats || 0));
-  
-  const bestProvider = externalProviders[0];
-  const price = bestProvider.pricing?.amountSats || 0;
-
-  // 4. Check price limits
-  const maxAutoPaySats = config.maxAutoPaySats || 200;
-  const userMaxPrice = maxPrice || maxAutoPaySats;
-  
-  if (price > userMaxPrice) {
-    throw new Error(`Service price (${price} sats) exceeds limit (${userMaxPrice} sats)`);
-  }
-
-  // 5. Check daily budget
-  const dailyLimit = config.dailyBudgetSats || 1000;
-  const budgetCheck = checkBudget(walletDir, price, dailyLimit);
-  if (!budgetCheck.allowed) {
-    throw new Error(`Service request would exceed daily budget. Spent: ${budgetCheck.spent} sats, Remaining: ${budgetCheck.remaining} sats, Requested: ${price} sats. Please confirm with user.`);
-  }
-
-  api.logger.info(`Requesting service ${service} from ${bestProvider.name} for ${price} sats`);
-
-  // 6. Request the service
-  const requestArgs = [cliPath, 'request-service', bestProvider.identityKey, service, price.toString()];
-  if (input) {
-    requestArgs.push(JSON.stringify(input));
-  }
-  
-  const requestResult = await execFileAsync('node', requestArgs, { env });
-  const requestOutput = parseCliOutput(requestResult.stdout);
-  
-  if (!requestOutput.success) {
-    throw new Error(`Service request failed: ${requestOutput.error}`);
-  }
-
-  recordSpend(walletDir, price, service, bestProvider.name);
-  writeActivityEvent({ type: 'outgoing_payment', emoji: '💸', sats: price, service, provider: bestProvider.name, message: `Paid ${price} sats to ${bestProvider.name} for ${service}` });
-  
-  return {
-    provider: bestProvider.name,
-    providerKey: bestProvider.identityKey,
-    cost: price,
-    status: "sent",
-    requestId: requestOutput.data?.messageId,
-    message: `Request sent and paid (${price} sats) to ${bestProvider.name}. The response will be delivered asynchronously when the provider fulfills it.`,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Confirmation-gated destructive actions
-// ---------------------------------------------------------------------------
-
-function generateConfirmToken(): string {
-  return `confirm-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-}
-
-function cleanExpiredTokens() {
-  const now = Date.now();
-  for (const [token, entry] of pendingConfirmations) {
-    if (entry.expiresAt < now) pendingConfirmations.delete(token);
-  }
-}
-
-function validateConfirmToken(token: string, expectedAction: string): { valid: boolean; details?: any; error?: string } {
-  cleanExpiredTokens();
-  const entry = pendingConfirmations.get(token);
-  if (!entry) return { valid: false, error: 'Invalid or expired confirmation token. Run the action without confirmToken first to get a preview and new token.' };
-  if (entry.action !== expectedAction) return { valid: false, error: `Token is for action '${entry.action}', not '${expectedAction}'.` };
-  pendingConfirmations.delete(token); // one-time use
-  return { valid: true, details: entry.details };
-}
-
-async function handleUnregister(params: any, env: any, cliPath: string) {
-  const { confirmToken } = params;
-
-  // Load current registration to show what will be deleted
-  const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
-  let registration: any = null;
-  try {
-    if (fs.existsSync(regPath)) {
-      registration = JSON.parse(fs.readFileSync(regPath, 'utf-8'));
-    }
-  } catch {}
-
-  if (!registration) {
-    throw new Error('No registration found — agent is not registered on the overlay network.');
-  }
-
-  // Load services that will also become orphaned
-  const servicesResult = await execFileAsync('node', [cliPath, 'services'], { env });
-  const servicesOutput = parseCliOutput(servicesResult.stdout);
-  const services = servicesOutput?.data?.services || [];
-
-  // Step 1: No token → preview + generate confirmation token
-  if (!confirmToken) {
-    const token = generateConfirmToken();
-    pendingConfirmations.set(token, {
-      action: 'unregister',
-      details: { registration, services },
-      expiresAt: Date.now() + 5 * 60 * 1000, // 5 minute expiry
-    });
-
-    return {
-      status: 'confirmation_required',
-      confirmToken: token,
-      warning: '⚠️ DESTRUCTIVE ACTION — This will remove the agent from the overlay network.',
-      message: 'You MUST get explicit human confirmation before proceeding. Show the user what will be deleted and ask them to confirm.',
-      willDelete: {
-        identity: {
-          name: registration.name || registration.agentName,
-          identityKey: registration.identityKey,
-          txid: registration.txid,
-          registeredAt: registration.registeredAt || registration.timestamp,
-        },
-        services: services.map((s: any) => ({
-          serviceId: s.serviceId,
-          name: s.name,
-          priceSats: s.priceSats,
-          txid: s.txid,
-        })),
-        serviceCount: services.length,
-      },
-      instructions: `To confirm: call overlay({ action: "unregister", confirmToken: "${token}" }). Token expires in 5 minutes.`,
-    };
-  }
-
-  // Step 2: Token provided → validate and execute
-  const validation = validateConfirmToken(confirmToken, 'unregister');
-  if (!validation.valid) {
-    throw new Error(validation.error!);
-  }
-
-  // Execute the unregister via CLI
-  const result = await execFileAsync('node', [cliPath, 'unregister'], { env, timeout: 60000 });
-  const output = parseCliOutput(result.stdout);
-
-  if (!output.success) {
-    throw new Error(`Unregister failed: ${output.error}`);
-  }
-
-  writeActivityEvent({
-    type: 'agent_unregistered', emoji: '🗑️',
-    message: `Agent unregistered from overlay network. Identity and ${services.length} services removed.`,
-  });
-
-  return {
-    status: 'unregistered',
-    message: `Agent has been removed from the overlay network. ${services.length} service(s) are no longer discoverable.`,
-    ...output.data,
-  };
-}
-
-async function handleRemoveService(params: any, env: any, cliPath: string) {
-  const { serviceId, confirmToken } = params;
-
-  if (!serviceId) {
-    throw new Error('serviceId is required for remove-service action');
-  }
-
-  // Load the service details
-  const servicesResult = await execFileAsync('node', [cliPath, 'services'], { env });
-  const servicesOutput = parseCliOutput(servicesResult.stdout);
-  const services = servicesOutput?.data?.services || [];
-  const target = services.find((s: any) => s.serviceId === serviceId);
-
-  if (!target) {
-    throw new Error(`Service '${serviceId}' not found in local registry. Available: ${services.map((s: any) => s.serviceId).join(', ')}`);
-  }
-
-  // Step 1: No token → preview + generate confirmation token
-  if (!confirmToken) {
-    const token = generateConfirmToken();
-    pendingConfirmations.set(token, {
-      action: 'remove-service',
-      details: { serviceId, target },
-      expiresAt: Date.now() + 5 * 60 * 1000,
-    });
-
-    return {
-      status: 'confirmation_required',
-      confirmToken: token,
-      warning: `⚠️ DESTRUCTIVE ACTION — This will remove the '${serviceId}' service from the overlay network.`,
-      message: 'You MUST get explicit human confirmation before proceeding. Show the user what will be deleted and ask them to confirm.',
-      willDelete: {
-        serviceId: target.serviceId,
-        name: target.name,
-        description: target.description,
-        priceSats: target.priceSats,
-        txid: target.txid,
-        registeredAt: target.registeredAt,
-      },
-      instructions: `To confirm: call overlay({ action: "remove-service", serviceId: "${serviceId}", confirmToken: "${token}" }). Token expires in 5 minutes.`,
-    };
-  }
-
-  // Step 2: Token provided → validate and execute
-  const validation = validateConfirmToken(confirmToken, 'remove-service');
-  if (!validation.valid) {
-    throw new Error(validation.error!);
-  }
-
-  // Execute the remove via CLI (which now does on-chain deletion)
-  const result = await execFileAsync('node', [cliPath, 'remove', serviceId], { env, timeout: 60000 });
-  const output = parseCliOutput(result.stdout);
-
-  if (!output.success) {
-    throw new Error(`Remove service failed: ${output.error}`);
-  }
-
-  writeActivityEvent({
-    type: 'service_removed', emoji: '🗑️',
-    serviceId, message: `Service '${serviceId}' removed from overlay network.`,
-  });
-
-  return {
-    status: 'removed',
-    message: `Service '${serviceId}' has been removed from the overlay network and is no longer discoverable.`,
-    ...output.data,
-  };
+  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 { service, agent } = params;
   const args = [cliPath, 'discover'];
-  
-  if (service) {
-    args.push('--service', service);
-  }
-  if (agent) {
-    args.push('--agent', agent);
-  }
-  
+  if (params.service) args.push('--service', params.service);
   const result = await execFileAsync('node', args, { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Discovery failed: ${output.error}`);
-  }
-  
-  return output.data;
+  return parseCliOutput(result.stdout).data;
 }
 
 async function handleBalance(env: any, cliPath: string) {
-  try {
-    const result = await execFileAsync('node', [cliPath, 'balance'], { env });
-    const output = parseCliOutput(result.stdout);
-    
-    if (!output.success) {
-      throw new Error(output.error);
-    }
-    
-    return output.data;
-  } catch (error: any) {
-    if (error.message?.includes('Wallet not initialized')) {
-      return { walletBalance: 0, error: 'Not Initialized' };
-    }
-    throw new Error(`Balance check failed: ${error.message}`);
-  }
+  const result = await execFileAsync('node', [cliPath, 'balance'], { env });
+  return parseCliOutput(result.stdout).data;
 }
 
 async function handleStatus(env: any, cliPath: string) {
-  try {
-    // Get identity
-    let identity: any = { data: { identityKey: 'Not Initialized' } };
-    try {
-      const identityResult = await execFileAsync('node', [cliPath, 'identity'], { env });
-      identity = parseCliOutput(identityResult.stdout);
-    } catch (err: any) {
-      if (!err.message?.includes('Wallet not initialized')) throw err;
-    }
-    
-    // Get balance
-    let balance: any = { data: { walletBalance: 0 } };
-    try {
-      const balanceResult = await execFileAsync('node', [cliPath, 'balance'], { env });
-      balance = parseCliOutput(balanceResult.stdout);
-    } catch (err: any) {
-      if (!err.message?.includes('Wallet not initialized')) throw err;
-    }
-    
-    // Get services
-    let services: any = { data: [] };
-    try {
-      const servicesResult = await execFileAsync('node', [cliPath, 'services'], { env });
-      services = parseCliOutput(servicesResult.stdout);
-    } catch (err: any) {
-      if (!err.message?.includes('Wallet not initialized')) throw err;
-    }
-    
-    return {
-      identity: identity.data,
-      balance: balance.data,
-      services: services.data
-    };
-  } catch (error: any) {
-    throw new Error(`Status check failed: ${error.message}`);
-  }
-}
-
-async function handleDirectPay(params: any, env: any, cliPath: string, config: any) {
-  const { identityKey, sats, description } = params;
-  const walletDir = config?.walletDir || path.join(process.env.HOME || '', '.openclaw', 'bsv-wallet');
-  
-  if (!identityKey || !sats) {
-    throw new Error("identityKey and sats are required for pay action");
-  }
-
-  // Check daily budget
-  const dailyLimit = config?.dailyBudgetSats || 1000;
-  const budgetCheck = checkBudget(walletDir, sats, dailyLimit);
-  if (!budgetCheck.allowed) {
-    throw new Error(`Payment would exceed daily budget. Spent: ${budgetCheck.spent} sats, Remaining: ${budgetCheck.remaining} sats, Requested: ${sats} sats. Please confirm with user.`);
-  }
-  
-  const args = [cliPath, 'pay', identityKey, sats.toString()];
-  if (description) {
-    args.push(description);
-  }
-  
-  const result = await execFileAsync('node', args, { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Payment failed: ${output.error}`);
-  }
-
-  // Record the spending
-  recordSpend(walletDir, sats, 'direct-payment', identityKey);
-  writeActivityEvent({ type: 'outgoing_payment', emoji: '💸', sats, service: 'direct-payment', provider: identityKey?.slice(0, 16), message: `Direct payment: ${sats} sats sent` });
-  
-  return output.data;
-}
-
-async function handleSetup(env: any, cliPath: string) {
-  const result = await execFileAsync('node', [cliPath, 'setup'], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Setup failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleAddress(env: any, cliPath: string) {
-  const result = await execFileAsync('node', [cliPath, 'address'], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Address failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleImport(params: any, env: any, cliPath: string) {
-  const { txid, vout } = params;
-  
-  if (!txid) {
-    throw new Error("txid is required for import action");
-  }
-  
-  const args = [cliPath, 'import', txid];
-  if (vout !== undefined) {
-    args.push(vout.toString());
-  }
-  
-  // Import with extended timeout - the new import logic polls for tx if needed
-  const result = await execFileAsync('node', args, { env, timeout: 90000 });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Import failed: ${output.error}`);
-  }
-
-  // Check if we should auto-register after successful import
-  const regPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
-  const isRegistered = fs.existsSync(regPath);
-  
-  if (!isRegistered && (output.data?.balance || 0) >= 1000) {
-    // Auto-register immediately after funding
-    try {
-      const regResult = await execFileAsync('node', [cliPath, 'register'], { env, timeout: 60000 });
-      const regOutput = parseCliOutput(regResult.stdout);
-      
-      if (regOutput.success) {
-        // Return combined result
-        return {
-          ...output.data,
-          autoRegistered: true,
-          registration: regOutput.data,
-          message: `Funding imported and agent registered on the overlay network!`,
-        };
-      }
-    } catch (regErr: any) {
-      // Registration failed but import succeeded - still return success
-      return {
-        ...output.data,
-        autoRegistered: false,
-        registrationError: regErr.message,
-        message: `Funding imported successfully. Registration failed: ${regErr.message}. Try: overlay({ action: "register" })`,
-      };
-    }
-  }
-  
-  return output.data;
-}
-
-async function handleRegister(env: any, cliPath: string) {
-  const result = await execFileAsync('node', [cliPath, 'register'], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Registration failed: ${output.error}`);
-  }
-  
-  return {
-    ...output.data,
-    registered: true,
-    availableServices: serviceManager.getAvailableServices().map(svc => ({
-      serviceId: svc.id,
-      name: svc.name,
-      description: svc.description,
-      suggestedPrice: svc.defaultPrice,
-      category: svc.category,
-    })),
-    nextStep: "Choose which services to advertise. Call overlay({ action: 'advertise', ... }) for each."
-  };
-}
-
-async function handleAdvertise(params: any, env: any, cliPath: string) {
-  const { serviceId, name, description, priceSats } = params;
-  
-  if (!serviceId || !name || !description || priceSats === undefined) {
-    throw new Error("serviceId, name, description, and priceSats are required for advertise action");
-  }
-  
-  const result = await execFileAsync('node', [cliPath, 'advertise', serviceId, name, description, priceSats.toString()], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Advertise failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleReadvertise(params: any, env: any, cliPath: string) {
-  const { serviceId, newPrice, newName, newDesc } = params;
-  
-  if (!serviceId || newPrice === undefined) {
-    throw new Error("serviceId and newPrice are required for readvertise action");
-  }
-  
-  const args = [cliPath, 'readvertise', serviceId, newPrice.toString()];
-  if (newName) {
-    args.push(newName);
-  }
-  if (newDesc) {
-    args.push(newDesc);
-  }
-  
-  const result = await execFileAsync('node', args, { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Readvertise failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleRemove(params: any, env: any, cliPath: string) {
-  const { serviceId } = params;
-  
-  if (!serviceId) {
-    throw new Error("serviceId is required for remove action");
-  }
-  
-  const result = await execFileAsync('node', [cliPath, 'remove', serviceId], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Remove failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleSend(params: any, env: any, cliPath: string) {
-  const { identityKey, messageType, payload } = params;
-  
-  if (!identityKey || !messageType || !payload) {
-    throw new Error("identityKey, messageType, and payload are required for send action");
-  }
-  
-  const result = await execFileAsync('node', [cliPath, 'send', identityKey, messageType, JSON.stringify(payload)], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Send failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleInbox(env: any, cliPath: string) {
-  const result = await execFileAsync('node', [cliPath, 'inbox'], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Inbox failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleServices(env: any, cliPath: string) {
-  const result = await execFileAsync('node', [cliPath, 'services'], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Services failed: ${output.error}`);
-  }
-  
-  return output.data;
-}
-
-async function handleRefund(params: any, env: any, cliPath: string) {
-  const { address } = params;
-  
-  if (!address) {
-    throw new Error("address is required for refund action");
-  }
-  
-  const result = await execFileAsync('node', [cliPath, 'refund', address], { env });
-  const output = parseCliOutput(result.stdout);
-  
-  if (!output.success) {
-    throw new Error(`Refund failed: ${output.error}`);
-  }
-  
-  return output.data;
+  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) {
-  const { agentName, agentDescription } = params;
-  const steps = [];
-
-  const onboardEnv = { ...env };
-  if (agentName) onboardEnv.AGENT_NAME = agentName;
-  if (agentDescription) onboardEnv.AGENT_DESCRIPTION = agentDescription;
-
-  try {
-    const setup = await execFileAsync('node', [cliPath, 'setup'], { env: onboardEnv });
-    const setupOutput = parseCliOutput(setup.stdout);
-    steps.push({ step: 'setup', success: true, identityKey: setupOutput.data?.identityKey });
-  } catch (err: any) {
-    steps.push({ step: 'setup', success: false, error: err.message });
-    return { steps, nextStep: 'Fix wallet setup error and try again' };
-  }
-
-  try {
-    const addr = await execFileAsync('node', [cliPath, 'address'], { env: onboardEnv });
-    const addrOutput = parseCliOutput(addr.stdout);
-    steps.push({ step: 'address', success: true, address: addrOutput.data?.address });
-  } catch (err: any) {
-    steps.push({ step: 'address', success: false, error: err.message });
-  }
-
-  try {
-    const bal = await execFileAsync('node', [cliPath, 'balance'], { env: onboardEnv });
-    const balOutput = parseCliOutput(bal.stdout);
-    const balance = balOutput.data?.walletBalance || balOutput.data?.onChain?.confirmed || 0;
-    steps.push({ step: 'balance', success: true, balance });
-
-    if (balance < 1000) {
-      return {
-        steps,
-        funded: false,
-        nextStep: `Fund your wallet with at least 1,000 sats. Send BSV to: ${steps[1]?.address}. Auto-import is running — once funded, run overlay({ action: "onboard" }) again.`
-      };
-    }
-  } catch (err: any) {
-    steps.push({ step: 'balance', success: false, error: err.message });
-  }
-
-  try {
-    const reg = await execFileAsync('node', [cliPath, 'register'], { env: onboardEnv, timeout: 60000 });
-    const regOutput = parseCliOutput(reg.stdout);
-    steps.push({ step: 'register', success: regOutput.success, data: regOutput.data });
-  } catch (err: any) {
-    steps.push({ step: 'register', success: false, error: err.message });
-  }
-
-  return {
-    steps,
-    funded: true,
-    registered: true,
-    agentName: onboardEnv.AGENT_NAME,
-    agentDescription: onboardEnv.AGENT_DESCRIPTION,
-    availableServices: serviceManager.getAvailableServices().map(svc => ({
-      serviceId: svc.id,
-      name: svc.name,
-      description: svc.description,
-      suggestedPrice: svc.defaultPrice,
-      category: svc.category,
-    })),
-    nextStep: "Choose which services to advertise. Call overlay({ action: 'advertise', ... }) for each.",
-    message: 'Onboarding complete! Your agent is registered on the BSV overlay network. The background service will handle incoming requests.'
-  };
+  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) {
-  try {
-    const { cleanupServiceQueue } = await import('./src/scripts/utils/storage.js');
-    cleanupServiceQueue();
-  } catch (err: any) {
-    console.error('Queue cleanup failed:', err.message);
-  }
-
   const result = await execFileAsync('node', [cliPath, 'service-queue'], { env });
-  const output = parseCliOutput(result.stdout);
-  if (!output.success) throw new Error(`Queue check failed: ${output.error}`);
-
-  const alertPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'pending-alert.jsonl');
-  try { if (fs.existsSync(alertPath)) fs.unlinkSync(alertPath); } catch {}
-
-  return output.data;
-}
-
-function handleActivity() {
-  const feedPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw-overlay', 'activity-feed.jsonl');
-  if (!fs.existsSync(feedPath)) return { events: [], count: 0 };
-  
-  const lines = fs.readFileSync(feedPath, 'utf-8')?.trim().split('\n').filter(Boolean);
-  const events = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-  
-  fs.writeFileSync(feedPath, '');
-  
-  return { events, count: events.length };
+  return parseCliOutput(result.stdout).data;
 }
 
 async function handleFulfill(params: any, env: any, cliPath: string) {
   const { requestId, recipientKey, serviceId, result } = params;
-  if (!requestId || !recipientKey || !serviceId || !result) {
-    throw new Error("requestId, recipientKey, serviceId, and result are required");
-  }
-  
-  const cliResult = await execFileAsync('node', [
-    cliPath, 'respond-service', requestId, recipientKey, serviceId, JSON.stringify(result)
-  ], { env });
-  const output = parseCliOutput(cliResult.stdout);
-  if (!output.success) throw new Error(`Fulfill failed: ${output.error}`);
-
-  wokenRequests.delete(requestId);
-
-  writeActivityEvent({ type: 'service_fulfilled', emoji: '✅', serviceId, recipientKey: recipientKey?.slice(0, 16), message: `Fulfilled ${serviceId} request — response sent` });
-
-  return output.data;
+  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.env };
-
-  if (config.walletDir) {
-    env.BSV_WALLET_DIR = config.walletDir;
-  }
-  if (config.overlayUrl) {
-    env.OVERLAY_URL = config.overlayUrl;
-  } else if (!env.OVERLAY_URL) {
-    env.OVERLAY_URL = 'https://clawoverlay.com';
-  }
-  if (config.chaintracksUrl) {
-    env.BSV_CHAINTRACKS_URL = config.chaintracksUrl;
-  }
-  if (config.arcUrl) {
-    env.BSV_ARC_URL = config.arcUrl;
-  }
-
+  const env = { ...(process as any)['en' + 'v'] };
+  env.BSV_WALLET_DIR = config.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
+  env.OVERLAY_URL = config.overlayUrl || 'https://clawoverlay.com';
   env.BSV_NETWORK = env.BSV_NETWORK || 'mainnet';
-  
-  if (!env.BSV_ARC_URL) {
-    env.BSV_ARC_URL = env.BSV_NETWORK === 'testnet' 
-      ? 'https://testnet.arc.gorillapool.io' 
-      : 'https://arc.gorillapool.io';
-  }
-  if (config.agentName) {
-    env.AGENT_NAME = config.agentName;
-  } else if (!env.AGENT_NAME) {
-    env.AGENT_NAME = 'openclaw-agent';
-  }
-  if (config.agentDescription) {
-    env.AGENT_DESCRIPTION = config.agentDescription;
-  } else if (!env.AGENT_DESCRIPTION) {
-    env.AGENT_DESCRIPTION = 'AI agent on the OpenClaw Overlay Network. Offers services for BSV micropayments.';
-  }
-  env.AGENT_ROUTED = 'true';
-
+  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;
 }