openclaw-overlay-plugin 0.7.30 → 0.7.32

package/index.ts

@@ -1,6 +1,7 @@
 import { execFile, spawn, ChildProcess } from 'node:child_process';
 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 { initializeServiceSystem, serviceManager } from './src/services/index.js';
@@ -50,7 +51,7 @@ function loadDailySpending(walletDir: string): DailySpending {
   return { date: today, totalSats: 0, transactions: [] };
 }
 
-function writeActivityEvent(event) {
+function writeActivityEvent(event: any) {
   const alertDir = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay');
   try {
     fs.mkdirSync(alertDir, { recursive: true });
@@ -75,7 +76,7 @@ function checkBudget(walletDir: string, requestedSats: number, dailyLimit: numbe
   };
 }
 
-async function startAutoImport(env, cliPath, logger) {
+async function startAutoImport(env: any, cliPath: string, logger: any) {
   // Get our address
   try {
     const addrResult = await execFileAsync('node', [cliPath, 'address'], { env });
@@ -138,7 +139,7 @@ async function startAutoImport(env, cliPath, logger) {
                     await autoAdvertiseServices(env, cliPath, logger);
                   }
                 }
-              } catch (err) {
+              } catch (err: any) {
                 logger?.warn?.('[bsv-overlay] Auto-registration failed:', err.message);
               }
             }
@@ -151,7 +152,7 @@ async function startAutoImport(env, cliPath, logger) {
         // WoC API error — just skip this cycle
       }
     }, 30000); // Check every 30 seconds for faster onboarding
-  } catch (err) {
+  } catch (err: any) {
     logger?.warn?.('[bsv-overlay] Auto-import setup failed:', err.message);
   }
 }
@@ -164,7 +165,7 @@ function stopAutoImport() {
 }
 
 // Auto-advertise services from config after registration
-async function autoAdvertiseServices(env, cliPath, logger) {
+async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
   try {
     // Read config to get services list
     const configPaths = [
@@ -199,154 +200,54 @@ async function autoAdvertiseServices(env, cliPath, logger) {
     for (const serviceId of servicesToAdvertise) {
       const serviceInfo = serviceManager.registry.get(serviceId);
       if (!serviceInfo) {
-        logger?.warn?.(`[bsv-overlay] Unknown service ID: ${serviceId}. Skipping.`);
         failed.push(serviceId);
         continue;
       }
-
+      
       try {
-        const result = await execFileAsync('node', [
-          cliPath, 'advertise',
-          serviceId,
-          serviceInfo.name,
-          serviceInfo.defaultPrice.toString(),
-          serviceInfo.description
+        await execFileAsync('node', [
+          cliPath, 'advertise', serviceId, serviceInfo.name, serviceInfo.description, String(serviceInfo.defaultPrice)
         ], { env, timeout: 60000 });
-
-        const output = parseCliOutput(result.stdout);
-        if (output.success) {
-          advertised.push(serviceId);
-          logger?.info?.(`[bsv-overlay] Advertised service: ${serviceInfo.name} (${serviceId}) for ${serviceInfo.defaultPrice} sats`);
-        } else {
-          failed.push(serviceId);
-          logger?.warn?.(`[bsv-overlay] Failed to advertise ${serviceId}: ${output.error}`);
-        }
-      } catch (err: any) {
+        advertised.push(serviceId);
+      } catch {
         failed.push(serviceId);
-        logger?.warn?.(`[bsv-overlay] Error advertising ${serviceId}: ${err.message}`);
       }
     }
     
-    // Wake agent with results
-    if (advertised.length > 0) {
-      const serviceList = advertised.map(id => {
-        const info = serviceManager.registry.get(id);
-        return `• ${info?.name || id} (${info?.defaultPrice || '?'} sats)`;
-      }).join('\n');
-      
-      wakeAgent(
-        `🎉 **Services Auto-Advertised!**\n\nThe following services are now live on the overlay network:\n\n${serviceList}\n\n${failed.length > 0 ? `⚠️ Failed to advertise: ${failed.join(', ')}` : ''}`,
-        logger,
-        { sessionKey: 'hook:bsv-overlay:services' }
-      );
-    }
-  } catch (err: any) {
-    logger?.warn?.(`[bsv-overlay] Auto-advertise failed: ${err.message}`);
-  }
-}
-
-// Auto-enable hooks in OpenClaw config if not already configured.
-// Returns true if config was modified (gateway restart needed to activate).
-function autoEnableHooks(api: any): boolean {
-  try {
-    const configPaths = [
-      path.join(process.env.HOME || '', '.openclaw', 'openclaw.json'),
-      path.join(process.env.HOME || '', '.openclaw', 'openclaw.json'),
-    ];
-
-    for (const configPath of configPaths) {
-      if (!fs.existsSync(configPath)) continue;
-
-      const raw = fs.readFileSync(configPath, 'utf-8');
-      const config = JSON.parse(raw);
-
-      // Check if hooks are already enabled with a token
-      if (config?.hooks?.enabled && config?.hooks?.token) {
-        api?.log?.debug?.('[bsv-overlay] Hooks already configured.');
-        return false;
-      }
-
-      // Generate a random token
-      const tokenBytes = new Uint8Array(24);
-      for (let i = 0; i < 24; i++) tokenBytes[i] = Math.floor(Math.random() * 256);
-      const token = Array.from(tokenBytes).map(b => b.toString(16).padStart(2, '0')).join('');
-
-      // Merge hooks config — preserve existing hooks.internal etc.
-      config.hooks = {
-        ...config.hooks,
-        enabled: true,
-        token: config.hooks?.token || token,
-      };
-
-      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-      api?.log?.info?.(`[bsv-overlay] Auto-enabled hooks in config (${configPath}). Gateway restart needed to activate.`);
-      return true;
-    }
+    if (advertised.length > 0) logger?.info?.(`[bsv-overlay] Successfully advertised: ${advertised.join(', ')}`);
+    if (failed.length > 0) logger?.warn?.(`[bsv-overlay] Failed to advertise: ${failed.join(', ')}`);
+    
   } catch (err: any) {
-    api?.log?.warn?.(`[bsv-overlay] Failed to auto-enable hooks: ${err.message}`);
+    logger?.warn?.('[bsv-overlay] Auto-advertising failed:', err.message);
   }
-  return false;
 }
 
-// Discover the gateway HTTP port from environment
-function getGatewayPort(): string {
-  return process.env.OPENCLAW_GATEWAY_PORT || process.env.OPENCLAW_GATEWAY_PORT || '18789';
-}
-
-// Read tokens from env vars or config files.
-// Returns { hooksToken, gatewayToken } — hooksToken is preferred for HTTP wake.
-function getTokens(): { hooksToken: string | null; gatewayToken: string | null } {
-  let hooksToken: string | null = process.env.OPENCLAW_HOOKS_TOKEN || process.env.OPENCLAW_HOOKS_TOKEN || null;
-  let gatewayToken: string | null = process.env.OPENCLAW_GATEWAY_TOKEN || process.env.OPENCLAW_GATEWAY_TOKEN || null;
-
-  try {
-    const configPaths = [
-      path.join(process.env.HOME || '', '.openclaw', 'openclaw.json'),
-      path.join(process.env.HOME || '', '.openclaw', 'openclaw.json'),
-    ];
-    for (const p of configPaths) {
-      if (!fs.existsSync(p)) continue;
-      const config = JSON.parse(fs.readFileSync(p, 'utf-8'));
-      if (!hooksToken) hooksToken = config?.hooks?.token || null;
-      if (!gatewayToken) gatewayToken = config?.gateway?.auth?.token || null;
-      if (hooksToken && gatewayToken) break;
-    }
-  } catch {}
-  return { hooksToken, gatewayToken };
-}
-
-// Wake the agent via /hooks/agent — runs an isolated agent turn with the
-// message as the actual prompt, so the agent sees the request and can act.
-// NOTE: /hooks/wake only triggers a heartbeat (reads HEARTBEAT.md) which
-// won't surface the overlay request to the agent. /hooks/agent is required.
-function wakeAgent(text: string, logger?: any, opts?: { sessionKey?: string }) {
-  const { hooksToken, gatewayToken } = getTokens();
-  const port = getGatewayPort();
-  const httpToken = hooksToken || gatewayToken;
-
+/**
+ * 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:bsv-overlay:${Date.now()}`;
+  const gatewayPort = getGatewayPort();
+  const httpToken = getHooksToken();
+  
   if (!httpToken) {
-    logger?.warn?.('[bsv-overlay] No gateway/hooks token available — cannot invoke agent');
+    logger?.warn?.('[bsv-overlay] Skipped wakeAgent: OPENCLAW_HOOKS_TOKEN not set');
     return;
   }
 
-  const url = `http://127.0.0.1:${port}/hooks/agent`;
-  const sessionKey = opts?.sessionKey || `hook:bsv-overlay:${Date.now()}`;
-
+  const url = `http://localhost:${gatewayPort}/hooks/agent`;
+  
   fetch(url, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
-      'Authorization': `Bearer ${httpToken}`,
       'x-openclaw-token': httpToken,
     },
     body: JSON.stringify({
-      message: text,
-      name: 'BSV Overlay',
+      prompt: text,
       sessionKey,
-      wakeMode: 'now',
-      deliver: true,
-      channel: 'last',
-    }),
+    })
   })
     .then(async (res) => {
       if (res.ok) {
@@ -356,17 +257,33 @@ function wakeAgent(text: string, logger?: any, opts?: { sessionKey?: string }) {
         logger?.warn?.(`[bsv-overlay] /hooks/agent failed: ${res.status} ${body}`);
       }
     })
-    .catch((err) => {
+    .catch((err: any) => {
       logger?.warn?.('[bsv-overlay] /hooks/agent error:', err.message);
     });
 }
 
-// NOTE: WebSocket wake fallback removed — it used cron.wake which triggers
-// a heartbeat (same problem as /hooks/wake). /hooks/agent is the correct
-// approach for invoking the agent with a specific prompt.
+function getGatewayPort(): string {
+  return process.env.OPENCLAW_GATEWAY_PORT || '18789';
+}
+
+function getHooksToken(): string | null {
+  let hooksToken: string | null = process.env.OPENCLAW_HOOKS_TOKEN || null;
+  
+  if (!hooksToken) {
+    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;
+      }
+    } catch {}
+  }
+  
+  return hooksToken;
+}
 
 // Categorize WebSocket events into notification types
-function categorizeEvent(event) {
+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
@@ -398,7 +315,7 @@ function categorizeEvent(event) {
   return null;
 }
 
-function startBackgroundService(env, cliPath, logger) {
+function startBackgroundService(env: any, cliPath: string, logger: any) {
   if (backgroundProcess) return;
   serviceRunning = true;
 
@@ -413,7 +330,7 @@ function startBackgroundService(env, cliPath, logger) {
         const { cleanupServiceQueue } = await import('./src/scripts/utils/storage.js');
         cleanupServiceQueue();
         logger?.debug?.('[bsv-overlay] Cleaned up old queue entries');
-      } catch (err) {
+      } catch (err: any) {
         logger?.warn?.('[bsv-overlay] Queue cleanup failed:', err.message);
       }
     }
@@ -530,7 +447,7 @@ function stopBackgroundService() {
   stopAutoImport();
 }
 
-export default function register(api) {
+export default function register(api: any) {
   // Capture config at registration time (handle both flat and nested structures)
   const entry = api.getConfig?.()?.plugins?.entries?.['openclaw-overlay'] || {};
   const pluginConfig = { ...entry, ...(entry.config || {}), ...(api.config || {}) };
@@ -559,48 +476,47 @@ export default function register(api) {
         },
         input: {
           type: "object",
-          description: "Service-specific input data"
-        },
-        maxPrice: {
-          type: "number",
-          description: "Max sats willing to pay"
+          description: "JSON input for the service request"
         },
         identityKey: {
           type: "string",
-          description: "Target agent key for direct pay/send"
+          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 for direct pay"
+          description: "Amount in satoshis for payment"
         },
         description: {
-          type: "string"
-        },
-        agent: {
           type: "string",
-          description: "Agent name filter for discover"
+          description: "Payment description"
         },
-        // Import parameters
         txid: {
           type: "string",
-          description: "Transaction ID for import"
+          description: "Transaction ID to import"
         },
         vout: {
           type: "number",
-          description: "Output index for import (optional)"
+          description: "Output index to import"
         },
-        // Service management parameters
-        serviceId: {
-          type: "string",
-          description: "Service ID for advertise/readvertise/remove"
+        priceSats: {
+          type: "number",
+          description: "Price in satoshis for service advertisement"
         },
         name: {
           type: "string",
-          description: "Service name for advertise/readvertise"
+          description: "Service name"
         },
-        priceSats: {
+        price: {
           type: "number",
-          description: "Price in satoshis for advertise"
+          description: "Price for service request"
         },
         newPrice: {
           type: "number",
@@ -608,554 +524,265 @@ export default function register(api) {
         },
         newName: {
           type: "string",
-          description: "New name for readvertise (optional)"
+          description: "New name for readvertise"
         },
         newDesc: {
           type: "string",
-          description: "New description for readvertise (optional)"
+          description: "New description for readvertise"
         },
-        // Messaging parameters
-        messageType: {
-          type: "string",
-          description: "Message type for send"
-        },
-        payload: {
-          type: "object",
-          description: "Message payload for send"
-        },
-        // Refund parameters
         address: {
           type: "string",
           description: "Destination address for refund"
         },
-        // Confirmation token for destructive actions (unregister, remove-service)
-        confirmToken: {
+        agentName: {
           type: "string",
-          description: "Confirmation token from a previous preview call — required to execute destructive actions"
+          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"
         },
-        // Fulfill parameters
         requestId: {
           type: "string",
-          description: "Request ID for fulfill"
+          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: "Service result for fulfill"
-        },
-        // Onboard parameters
-        agentName: {
-          type: "string",
-          description: "Agent display name for onboard/register"
+          description: "Result data for service fulfillment"
         },
-        agentDescription: {
+        confirmToken: {
           type: "string",
-          description: "Agent description for onboard/register"
+          description: "Confirmation token for destructive actions (unregister, remove-service)"
         }
       },
       required: ["action"]
     },
-    async execute(id, params) {
-      const config = pluginConfig;
-      
+    async execute(_id: string, params: any) {
       try {
-        const result = await executeOverlayAction(params, config, api);
-        return { 
-          content: [{ 
-            type: "text", 
-            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
-          }] 
-        };
-      } catch (error) {
-        return { 
-          content: [{ 
-            type: "text", 
-            text: `Error: ${error.message}` 
-          }] 
+        return await executeOverlayAction(params, pluginConfig, api);
+      } catch (error: any) {
+        return {
+          content: [{
+            type: "text",
+            text: `Error: ${error.message}`
+          }]
         };
       }
     }
   });
 
-  // Register background service for WebSocket relay
+  // Register background relay service
   api.registerService({
     id: "bsv-overlay-relay",
     start: async () => {
-      api.logger.info("Starting BSV overlay WebSocket relay...");
       try {
-        const config = pluginConfig;
-        const env = buildEnvironment(config);
+        api.logger.info("Starting BSV overlay WebSocket relay...");
+        const env = buildEnvironment(pluginConfig);
         const cliPath = path.join(__dirname, 'dist', 'cli.js');
         
-        // Use the improved background service
+        // Initialize the service system if available
+        try {
+          await initializeServiceSystem();
+        } catch {}
+
         startBackgroundService(env, cliPath, api.logger);
         
         // Start auto-import
         startAutoImport(env, cliPath, api.logger);
 
         api.logger.info("BSV overlay WebSocket relay started");
-      } catch (error) {
+      } catch (error: any) {
         api.logger.error(`Failed to start BSV overlay relay: ${error.message}`);
       }
     },
     stop: async () => {
       api.logger.info("Stopping BSV overlay WebSocket relay...");
       stopBackgroundService();
-      api.logger.info("BSV overlay WebSocket relay stopped");
     }
   });
 
-  // Register /overlay auto-reply command for instant status
-  api.registerCommand?.({
-    name: 'overlay',
-    description: 'Check BSV Overlay Network status instantly',
-    handler: async (ctx) => {
-      try {
-        const config = pluginConfig;
-        const env = buildEnvironment(config);
-        const cliPath = path.join(__dirname, 'dist', 'cli.js');
-        
-        // Check registration status
-        const regPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'registration.json');
-        const isRegistered = fs.existsSync(regPath);
-        
-        // Get balance
-        let balance = 0;
-        let address = '';
-        try {
-          const balResult = await execFileAsync('node', [cliPath, 'balance'], { env, timeout: 15000 });
-          const balOutput = parseCliOutput(balResult.stdout);
-          balance = balOutput?.data?.walletBalance || 0;
-        } catch {}
-        
+  // Register a skill-style wake handler
+  api.registerHook({
+    id: "bsv-overlay-wake",
+    event: "gateway:start",
+    handler: async (ctx: any) => {
+      // Auto-check for registration on startup
+      (async () => {
         try {
-          const addrResult = await execFileAsync('node', [cliPath, 'address'], { env, timeout: 15000 });
-          const addrOutput = parseCliOutput(addrResult.stdout);
-          address = addrOutput?.data?.address || '';
-        } catch {}
-        
-        // Get services count
-        let servicesCount = 0;
-        try {
-          const svcResult = await execFileAsync('node', [cliPath, 'services'], { env, timeout: 15000 });
-          const svcOutput = parseCliOutput(svcResult.stdout);
-          servicesCount = svcOutput?.data?.count || 0;
-        } catch {}
-        
-        // Build status message
-        let text = '**BSV Overlay Status**\n\n';
-        
-        if (isRegistered) {
-          const reg = JSON.parse(fs.readFileSync(regPath, 'utf-8'));
-          text += `✅ **Registered** as ${reg.agentName || 'Agent'}\n`;
-          text += `💰 **Balance:** ${balance.toLocaleString()} sats\n`;
-          text += `📋 **Services:** ${servicesCount} advertised\n`;
-          text += `🌐 **Network:** ${config?.overlayUrl || 'https://clawoverlay.com'}`;
-        } else if (balance >= 1000) {
-          text += `💰 **Funded** (${balance.toLocaleString()} sats)\n`;
-          text += `⏳ Registering on next cycle...\n`;
-          text += `\nRun \`overlay({ action: "register" })\` to register now.`;
-        } else {
-          text += `❌ **Not Registered**\n\n`;
-          text += `📬 Fund this address to join:\n\`${address}\`\n\n`;
-          text += `💰 Need: 1,000+ sats (~$0.05)`;
+          const env = buildEnvironment(pluginConfig);
+          const cliPath = path.join(__dirname, 'dist', 'cli.js');
+          
+          const regPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'registration.json');
+          const onboardSentFile = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'onboarding-sent.flag');
+          
+          if (!fs.existsSync(regPath) && !fs.existsSync(onboardSentFile)) {
+            // Check if wallet exists
+            const walletPath = path.join(pluginConfig.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet'), 'wallet-identity.json');
+            
+            if (!fs.existsSync(walletPath)) {
+              // No wallet, no registration — first run ever.
+              // We'll let startAutoImport create the wallet via 'address' command,
+              // then it will wake the agent when funded.
+            } else {
+              // Wallet exists but not registered.
+              const balResult = await execFileAsync('node', [cliPath, 'balance'], { env });
+              const balance = parseCliOutput(balResult.stdout);
+              
+              if ((balance.data?.walletBalance || 0) < 1000) {
+                // Funded less than 1000, need more funds to register.
+                // We don't wake up here, we wait for auto-import to detect new funds.
+              } else {
+                // Funded but not registered. Auto-register.
+                const regResult = await execFileAsync('node', [cliPath, 'register'], { env, timeout: 60000 });
+                if (parseCliOutput(regResult.stdout).success) {
+                  ctx.logger.info('[bsv-overlay] Agent auto-registered on startup');
+                  await autoAdvertiseServices(env, cliPath, ctx.logger);
+                }
+              }
+            }
+          }
+
+        } catch (err: any) {
+          api.log?.debug?.('[bsv-overlay] Auto-setup/onboarding skipped:', err.message);
         }
-        
-        return { text };
-      } catch (err: any) {
-        return { text: `❌ Error checking status: ${err.message}` };
-      }
+      })();
     }
   });
 
-  // Register CLI commands
-  api.registerCli(({ program }) => {
-    const overlay = program.command("overlay").description("BSV Overlay Network commands");
-    
-    overlay.command("status")
-      .description("Show identity, balance, registration, and services")
+  // Register CLI extensions
+  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 config = pluginConfig;
-          const result = await handleStatus(buildEnvironment(config), path.join(__dirname, 'dist', 'cli.js'));
-          console.log("BSV Overlay Status:");
-          console.log("Identity:", result.identity);
-          console.log("Balance:", result.balance);
-          console.log("Services:", result.services);
-        } catch (error) {
+          const env = buildEnvironment(pluginConfig);
+          const cliPath = path.join(__dirname, 'dist', 'cli.js');
+          const result = await handleStatus(env, cliPath);
+          console.log(JSON.stringify(result, null, 2));
+        } catch (error: any) {
           console.error("Error:", error.message);
         }
       });
-    
-    overlay.command("balance")
+
+    overlay
+      .command("balance")
       .description("Show wallet balance")
       .action(async () => {
         try {
-          const config = pluginConfig;
-          const result = await handleBalance(buildEnvironment(config), path.join(__dirname, 'dist', 'cli.js'));
-          console.log("Balance:", result);
-        } catch (error) {
+          const env = buildEnvironment(pluginConfig);
+          const cliPath = path.join(__dirname, 'dist', 'cli.js');
+          const result = await handleBalance(env, cliPath);
+          console.log(JSON.stringify(result, null, 2));
+        } catch (error: any) {
           console.error("Error:", error.message);
         }
       });
 
-    overlay.command("address")
+    overlay
+      .command("address")
       .description("Show receive address")
       .action(async () => {
         try {
-          const config = pluginConfig;
-          const result = await handleAddress(buildEnvironment(config), path.join(__dirname, 'dist', 'cli.js'));
-          console.log("Address:", result);
-        } catch (error) {
+          const env = buildEnvironment(pluginConfig);
+          const cliPath = path.join(__dirname, 'dist', 'cli.js');
+          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 on the network")
-      .option("--service <type>", "Filter by service type")
-      .option("--agent <name>", "Filter by agent name")
-      .action(async (options) => {
+    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 config = pluginConfig;
-          const result = await handleDiscover(options, buildEnvironment(config), path.join(__dirname, 'dist', 'cli.js'));
-          console.log("Discovery results:");
-          console.log(`Overlay URL: ${result.overlayUrl}`);
-          console.log(`Agents: ${result.agentCount}, Services: ${result.serviceCount}`);
-          if (result.agents?.length > 0) {
+          const env = buildEnvironment(pluginConfig);
+          const cliPath = path.join(__dirname, 'dist', 'cli.js');
+          const result = await handleDiscover(options, env, cliPath);
+          
+          if (result.agents) {
             console.log("\nAgents:");
-            result.agents.forEach(agent => {
-              console.log(`  ${agent.agentName} (${agent.identityKey})`);
+            result.agents.forEach((agent: any) => {
+              console.log(`- ${agent.name} (${agent.identityKey.slice(0, 16)}...)`);
             });
           }
-          if (result.services?.length > 0) {
+          
+          if (result.services) {
             console.log("\nServices:");
-            result.services.forEach(service => {
-              console.log(`  ${service.serviceId} - ${service.name} (${service.pricing?.amountSats || 0} sats) by ${service.agentName}`);
+            result.services.forEach((service: any) => {
+              console.log(`- ${service.name} (${service.serviceId}): ${service.pricing?.amountSats || 0} sats [${service.identityKey.slice(0, 12)}]`);
             });
           }
-        } catch (error) {
+        } catch (error: any) {
           console.error("Error:", error.message);
         }
       });
 
-    overlay.command("services")
-      .description("List our advertised services")
+    overlay
+      .command("register")
+      .description("Register on the overlay network")
       .action(async () => {
         try {
-          const config = pluginConfig;
-          const result = await handleServices(buildEnvironment(config), path.join(__dirname, 'dist', 'cli.js'));
-          console.log("Our services:", result);
-        } catch (error) {
-          console.error("Error:", error.message);
-        }
-      });
-    
-    overlay.command("setup")
-      .description("Run initial wallet setup")
-      .action(async () => {
-        try {
-          const config = pluginConfig;
-          const env = buildEnvironment(config);
+          const env = buildEnvironment(pluginConfig);
           const cliPath = path.join(__dirname, 'dist', 'cli.js');
-          
-          const result = await execFileAsync('node', [cliPath, 'setup'], { env });
-          const output = parseCliOutput(result.stdout);
-          console.log("Setup result:", output);
-        } catch (error) {
+          const result = await handleRegister(env, cliPath);
+          console.log(JSON.stringify(result, null, 2));
+        } catch (error: any) {
           console.error("Error:", error.message);
         }
       });
-    
-    overlay.command("register")
-      .description("Register with the overlay network")
-      .action(async () => {
+
+    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 config = pluginConfig;
-          const env = buildEnvironment(config);
+          const env = buildEnvironment(pluginConfig);
           const cliPath = path.join(__dirname, 'dist', 'cli.js');
-          
-          const result = await execFileAsync('node', [cliPath, 'register'], { env });
-          const output = parseCliOutput(result.stdout);
-          console.log("Registration result:", output);
-        } catch (error) {
+          const result = await handleOnboard(options, env, cliPath);
+          console.log(JSON.stringify(result, null, 2));
+        } catch (error: any) {
           console.error("Error:", error.message);
         }
       });
 
-    overlay.command("wizard")
-      .description("Interactive setup wizard for BSV Overlay Network")
+    overlay
+      .command("pending")
+      .description("Show pending service requests")
       .action(async () => {
-        const readline = await import('readline');
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        
-        const prompt = (question: string): Promise<string> => 
-          new Promise(resolve => rl.question(question, resolve));
-        
-        console.log('\n🔌 BSV Overlay Network — Setup Wizard\n');
-        console.log('This wizard will help you configure and join the overlay network.\n');
-        
         try {
-          const config = pluginConfig;
-          const env = buildEnvironment(config);
+          const env = buildEnvironment(pluginConfig);
           const cliPath = path.join(__dirname, 'dist', 'cli.js');
-
-          // Step 1: Agent Identity
-          console.log('─'.repeat(50));
-          console.log('Step 1: Agent Identity\n');
-          console.log('Your agent identity is how other agents will see you on the network.\n');
-
-          const currentName = config?.agentName || env.AGENT_NAME || 'openclaw-agent';
-          const agentName = await prompt(`Agent name [${currentName}]: `) || currentName;
-
-          const currentDesc = config?.agentDescription || env.AGENT_DESCRIPTION || 'AI agent on the OpenClaw Overlay Network.';
-          console.log('\nDescribe what your agent does (1-2 sentences):');
-          const agentDescription = await prompt(`Description [${currentDesc}]: `) || currentDesc;
-          
-          // Step 2: Service Selection
-          console.log('\n' + '─'.repeat(50));
-          console.log('Step 2: Services to Offer\n');
-          console.log('Available services:');
-          const availableServices = serviceManager.getAvailableServices();
-          availableServices.forEach((svc, i) => {
-            console.log(`  ${i + 1}. ${svc.name} (${svc.defaultPrice} sats) - ${svc.id}`);
-          });
-          console.log('\nEnter service numbers separated by commas (e.g., 1,2,5)');
-          console.log('Or press Enter to skip service selection.\n');
-          const serviceInput = await prompt('Services to advertise: ');
-          
-          const selectedServices: string[] = [];
-          if (serviceInput.trim()) {
-            const nums = serviceInput.split(',').map(s => parseInt(s.trim()) - 1);
-            for (const n of nums) {
-              if (n >= 0 && n < availableServices.length) {
-                selectedServices.push(availableServices[n].id);
-              }
-            }
-          }
-          
-          // Step 3: Budget Configuration
-          console.log('\n' + '─'.repeat(50));
-          console.log('Step 3: Budget Limits\n');
-          const maxPay = await prompt(`Max auto-pay per request [${config?.maxAutoPaySats || 200}]: `) || String(config?.maxAutoPaySats || 200);
-          const dailyBudget = await prompt(`Daily spending limit [${config?.dailyBudgetSats || 5000}]: `) || String(config?.dailyBudgetSats || 5000);
-          
-          // Generate config
-          console.log('\n' + '─'.repeat(50));
-          console.log('Configuration\n');
-          const newConfig = {
-            agentName,
-            agentDescription,
-            ...(selectedServices.length > 0 && { services: selectedServices }),
-            maxAutoPaySats: parseInt(maxPay),
-            dailyBudgetSats: parseInt(dailyBudget)
-          };
-          console.log('Add this to your config under plugins.entries.bsv-overlay.config:\n');
-          console.log(JSON.stringify(newConfig, null, 2));
-          
-          // Step 4: Show funding address
-          console.log('\n' + '─'.repeat(50));
-          console.log('Step 4: Funding\n');
-          
-          // Ensure wallet exists
-          try {
-            await execFileAsync('node', [cliPath, 'setup'], { env });
-          } catch {}
-          
-          const addrResult = await execFileAsync('node', [cliPath, 'address'], { env });
-          const addrOutput = parseCliOutput(addrResult.stdout);
-          const address = addrOutput?.data?.address;
-          
-          const balResult = await execFileAsync('node', [cliPath, 'balance'], { env });
-          const balOutput = parseCliOutput(balResult.stdout);
-          const balance = balOutput?.data?.walletBalance || 0;
-          
-          if (balance >= 1000) {
-            console.log(`✅ Wallet already funded: ${balance.toLocaleString()} sats`);
-          } else {
-            console.log('Send BSV to this address to fund your agent:\n');
-            console.log(`  📬 ${address}`);
-            console.log(`  💰 Minimum: 1,000 sats (~$0.05)\n`);
-          }
-          
-          // Step 5: Registration
-          console.log('─'.repeat(50));
-          console.log('Step 5: Registration\n');
-          
-          if (balance >= 1000) {
-            const doRegister = await prompt('Register now? [Y/n]: ');
-            if (doRegister.toLowerCase() !== 'n') {
-              console.log('\nRegistering...');
-              const regResult = await execFileAsync('node', [cliPath, 'register'], {
-                env: { ...env, AGENT_NAME: agentName, AGENT_DESCRIPTION: agentDescription },
-                timeout: 60000
-              });
-              const regOutput = parseCliOutput(regResult.stdout);
-              if (regOutput.success) {
-                console.log('✅ Registered on the overlay network!');
-                
-                // Auto-advertise selected services
-                if (selectedServices.length > 0) {
-                  console.log(`\nAdvertising ${selectedServices.length} services...`);
-                  for (const serviceId of selectedServices) {
-                    const svc = serviceManager.registry.get(serviceId);
-                    if (svc) {
-                      try {
-                        await execFileAsync('node', [
-                          cliPath, 'advertise', serviceId, svc.name, svc.defaultPrice.toString(), svc.description
-                        ], { env, timeout: 60000 });
-                        console.log(`  ✅ ${svc.name} (${svc.defaultPrice} sats)`);
-                      } catch (err: any) {
-                        console.log(`  ❌ ${svc.name}: ${err.message}`);
-                      }
-                    }
-                  }
-                }
-              } else {
-                console.log(`❌ Registration failed: ${regOutput.error}`);
-              }
-            }
-          } else {
-            console.log('Fund your wallet, then run: openclaw overlay register');
-          }
-          
-          console.log('\n' + '─'.repeat(50));
-          console.log('Setup complete! 🎉\n');
-          
+          const result = await handlePendingRequests(env, cliPath);
+          console.log(JSON.stringify(result, null, 2));
         } catch (error: any) {
-          console.error('\nError:', error.message);
-        } finally {
-          rl.close();
+          console.error("Error:", error.message);
         }
       });
-  }, { commands: ["overlay"] });
-
-  // ---------------------------------------------------------------------------
-  // Auto-setup + onboarding (best-effort, non-fatal, fire-and-forget)
-  // ---------------------------------------------------------------------------
-  (async () => {
-    try {
-      const config = pluginConfig;
-      const walletDir = config?.walletDir || path.join(process.env.HOME || '', '.openclaw', 'bsv-wallet');
-      const identityFile = path.join(walletDir, 'wallet-identity.json');
-      const env = buildEnvironment(config || {});
-      const cliPath = path.join(__dirname, 'dist', 'cli.js');
-
-      // Step 0: Auto-enable hooks if not configured
-      // The plugin needs hooks.enabled + hooks.token for async wake-ups via /hooks/agent
-      const hooksAutoConfigured = autoEnableHooks(api);
-
-      // Step 1: Create wallet if missing
-      let walletJustCreated = false;
-      if (!fs.existsSync(identityFile)) {
-        api.log?.info?.('[bsv-overlay] No wallet found — running auto-setup...');
-        await execFileAsync('node', [cliPath, 'setup'], { env });
-        api.log?.info?.('[bsv-overlay] Wallet initialized.');
-        walletJustCreated = true;
-      }
-
-      // Step 2: Get wallet address for onboarding message
-      let walletAddress = '';
-      try {
-        const addrResult = await execFileAsync('node', [cliPath, 'address'], { env });
-        const addrOutput = parseCliOutput(addrResult.stdout);
-        walletAddress = addrOutput?.data?.address || '';
-      } catch {}
-
-      // Step 3: Check registration and balance state
-      const regPath = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'registration.json');
-      const isRegistered = fs.existsSync(regPath);
-      let balance = 0;
-      try {
-        const balResult = await execFileAsync('node', [cliPath, 'balance'], { env });
-        const balOutput = parseCliOutput(balResult.stdout);
-        balance = balOutput?.data?.walletBalance || 0;
-      } catch {}
-
-      // Step 4: If funded and not registered → auto-register
-      if (!isRegistered && balance >= 1000) {
-        // Clear onboarding flag since wallet is now funded
-        try {
-          const onboardingSentFile = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'onboarding-sent.flag');
-          if (fs.existsSync(onboardingSentFile)) {
-            fs.unlinkSync(onboardingSentFile);
-          }
-        } catch {}
-
-        api.log?.info?.('[bsv-overlay] Wallet funded but not registered — auto-registering...');
-        const regResult = await execFileAsync('node', [cliPath, 'register'], { env, timeout: 60000 });
-        const regOutput = parseCliOutput(regResult.stdout);
-        if (regOutput.success) {
-          api.log?.info?.('[bsv-overlay] Auto-registered on overlay network!');
-
-          // Auto-advertise services from config
-          await autoAdvertiseServices(env, cliPath, api.log);
-
-          const wakeText = `🎉 **BSV Overlay: Registered on the network!**\n\nYour agent is now live on the OpenClaw Overlay Network.\n\nCurrent name: "${env.AGENT_NAME}"\n\nUse /overlay for instant status or ask me about your services.`;
-          wakeAgent(wakeText, api.log);
-          return; // Registered — done with onboarding
-        }
-      }
-
-      // Step 5: If already registered, nothing to onboard
-      if (isRegistered) return;
-
-      // Step 6: Not registered + not funded → send onboarding message (only once per wallet)
-      // This runs on first startup after plugin install (wallet just created or exists but empty)
-      const onboardingSentFile = path.join(process.env.HOME || '', '.openclaw', 'bsv-overlay', 'onboarding-sent.flag');
-
-      // Check if we already sent onboarding message for this wallet
-      let alreadySent = false;
-      try {
-        if (fs.existsSync(onboardingSentFile)) {
-          const flagData = fs.readFileSync(onboardingSentFile, 'utf-8');
-          if (flagData.trim() === walletAddress) {
-            alreadySent = true;
-          }
-        }
-      } catch {
-        // Ignore errors reading flag file
-      }
-
-      if (alreadySent) {
-        api.log?.debug?.('[bsv-overlay] Onboarding message already sent for this wallet address');
-        return;
-      }
-
-      const needsRestart = hooksAutoConfigured;
-      let onboardingMsg = `The BSV Overlay Network plugin is installed. Ask the user:\n`;
-      onboardingMsg += `1. What name they want for their agent on the network\n`;
-      onboardingMsg += `2. A short description of what their agent does\n\n`;
-      onboardingMsg += `Wallet address: ${walletAddress}\n`;
-      onboardingMsg += `Minimum funding: 1,000 sats (~$0.05). Auto-import runs every 30 seconds.\n`;
-
-      if (needsRestart) {
-        onboardingMsg += `\nNote: Hooks were auto-configured. A gateway restart is needed to activate async wake-ups.`;
-      }
-
-      onboardingMsg += `\n\nOnce the user provides name and description, and the wallet is funded, run:\n`;
-      onboardingMsg += `overlay({ action: "onboard", agentName: "<name>", agentDescription: "<description>" })`;
-
-      wakeAgent(onboardingMsg, api.log, { sessionKey: 'hook:bsv-overlay:onboarding' });
-
-      // Mark onboarding as sent for this wallet address
-      try {
-        fs.mkdirSync(path.dirname(onboardingSentFile), { recursive: true });
-        fs.writeFileSync(onboardingSentFile, walletAddress);
-      } catch (err: any) {
-        api.log?.warn?.(`[bsv-overlay] Failed to save onboarding flag: ${err.message}`);
-      }
-
-    } catch (err: any) {
-      api.log?.debug?.('[bsv-overlay] Auto-setup/onboarding skipped:', err.message);
-    }
-  })();
+  });
 }
 
-async function executeOverlayAction(params, config, api) {
+async function executeOverlayAction(params: any, config: any, api: any) {
   const { action } = params;
   const env = buildEnvironment(config);
   const cliPath = path.join(__dirname, 'dist', 'cli.js');
@@ -1232,7 +859,7 @@ async function executeOverlayAction(params, config, api) {
   }
 }
 
-async function handleServiceRequest(params, env, cliPath, config, api) {
+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');
   
@@ -1259,22 +886,22 @@ async function handleServiceRequest(params, env, cliPath, config, api) {
   const identityOutput = parseCliOutput(identityResult.stdout);
   const ourKey = identityOutput.data?.identityKey;
   
-  let externalProviders = providers.filter(p => p.identityKey !== ourKey);
+  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 => p.identityKey === 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 => p.identityKey).join(', ')}`);
+      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 - FIX: Use pricing.amountSats instead of pricingSats
-  externalProviders.sort((a, b) => (a.pricing?.amountSats || 0) - (b.pricing?.amountSats || 0));
+  externalProviders.sort((a: any, b: any) => (a.pricing?.amountSats || 0) - (b.pricing?.amountSats || 0));
   
   const bestProvider = externalProviders[0];
   const price = bestProvider.pricing?.amountSats || 0;
@@ -1350,7 +977,7 @@ function validateConfirmToken(token: string, expectedAction: string): { valid: b
   return { valid: true, details: entry.details };
 }
 
-async function handleUnregister(params, env, cliPath) {
+async function handleUnregister(params: any, env: any, cliPath: string) {
   const { confirmToken } = params;
 
   // Load current registration to show what will be deleted
@@ -1430,7 +1057,7 @@ async function handleUnregister(params, env, cliPath) {
   };
 }
 
-async function handleRemoveService(params, env, cliPath) {
+async function handleRemoveService(params: any, env: any, cliPath: string) {
   const { serviceId, confirmToken } = params;
 
   if (!serviceId) {
@@ -1499,7 +1126,7 @@ async function handleRemoveService(params, env, cliPath) {
   };
 }
 
-async function handleDiscover(params, env, cliPath) {
+async function handleDiscover(params: any, env: any, cliPath: string) {
   const { service, agent } = params;
   const args = [cliPath, 'discover'];
   
@@ -1520,7 +1147,7 @@ async function handleDiscover(params, env, cliPath) {
   return output.data;
 }
 
-async function handleBalance(env, cliPath) {
+async function handleBalance(env: any, cliPath: string) {
   const result = await execFileAsync('node', [cliPath, 'balance'], { env });
   const output = parseCliOutput(result.stdout);
   
@@ -1531,7 +1158,7 @@ async function handleBalance(env, cliPath) {
   return output.data;
 }
 
-async function handleStatus(env, cliPath) {
+async function handleStatus(env: any, cliPath: string) {
   try {
     // Get identity
     const identityResult = await execFileAsync('node', [cliPath, 'identity'], { env });
@@ -1550,12 +1177,12 @@ async function handleStatus(env, cliPath) {
       balance: balance.data,
       services: services.data
     };
-  } catch (error) {
+  } catch (error: any) {
     throw new Error(`Status check failed: ${error.message}`);
   }
 }
 
-async function handleDirectPay(params, env, cliPath, config) {
+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');
   
@@ -1589,7 +1216,7 @@ async function handleDirectPay(params, env, cliPath, config) {
   return output.data;
 }
 
-async function handleSetup(env, cliPath) {
+async function handleSetup(env: any, cliPath: string) {
   const result = await execFileAsync('node', [cliPath, 'setup'], { env });
   const output = parseCliOutput(result.stdout);
   
@@ -1600,7 +1227,7 @@ async function handleSetup(env, cliPath) {
   return output.data;
 }
 
-async function handleAddress(env, cliPath) {
+async function handleAddress(env: any, cliPath: string) {
   const result = await execFileAsync('node', [cliPath, 'address'], { env });
   const output = parseCliOutput(result.stdout);
   
@@ -1611,7 +1238,7 @@ async function handleAddress(env, cliPath) {
   return output.data;
 }
 
-async function handleImport(params, env, cliPath) {
+async function handleImport(params: any, env: any, cliPath: string) {
   const { txid, vout } = params;
   
   if (!txid) {
@@ -1664,7 +1291,7 @@ async function handleImport(params, env, cliPath) {
   return output.data;
 }
 
-async function handleRegister(env, cliPath) {
+async function handleRegister(env: any, cliPath: string) {
   const result = await execFileAsync('node', [cliPath, 'register'], { env });
   const output = parseCliOutput(result.stdout);
   
@@ -1686,7 +1313,7 @@ async function handleRegister(env, cliPath) {
   };
 }
 
-async function handleAdvertise(params, env, cliPath) {
+async function handleAdvertise(params: any, env: any, cliPath: string) {
   const { serviceId, name, description, priceSats } = params;
   
   if (!serviceId || !name || !description || priceSats === undefined) {
@@ -1703,7 +1330,7 @@ async function handleAdvertise(params, env, cliPath) {
   return output.data;
 }
 
-async function handleReadvertise(params, env, cliPath) {
+async function handleReadvertise(params: any, env: any, cliPath: string) {
   const { serviceId, newPrice, newName, newDesc } = params;
   
   if (!serviceId || newPrice === undefined) {
@@ -1728,7 +1355,7 @@ async function handleReadvertise(params, env, cliPath) {
   return output.data;
 }
 
-async function handleRemove(params, env, cliPath) {
+async function handleRemove(params: any, env: any, cliPath: string) {
   const { serviceId } = params;
   
   if (!serviceId) {
@@ -1745,7 +1372,7 @@ async function handleRemove(params, env, cliPath) {
   return output.data;
 }
 
-async function handleSend(params, env, cliPath) {
+async function handleSend(params: any, env: any, cliPath: string) {
   const { identityKey, messageType, payload } = params;
   
   if (!identityKey || !messageType || !payload) {
@@ -1762,7 +1389,7 @@ async function handleSend(params, env, cliPath) {
   return output.data;
 }
 
-async function handleInbox(env, cliPath) {
+async function handleInbox(env: any, cliPath: string) {
   const result = await execFileAsync('node', [cliPath, 'inbox'], { env });
   const output = parseCliOutput(result.stdout);
   
@@ -1773,7 +1400,7 @@ async function handleInbox(env, cliPath) {
   return output.data;
 }
 
-async function handleServices(env, cliPath) {
+async function handleServices(env: any, cliPath: string) {
   const result = await execFileAsync('node', [cliPath, 'services'], { env });
   const output = parseCliOutput(result.stdout);
   
@@ -1784,7 +1411,7 @@ async function handleServices(env, cliPath) {
   return output.data;
 }
 
-async function handleRefund(params, env, cliPath) {
+async function handleRefund(params: any, env: any, cliPath: string) {
   const { address } = params;
   
   if (!address) {
@@ -1801,7 +1428,7 @@ async function handleRefund(params, env, cliPath) {
   return output.data;
 }
 
-async function handleOnboard(params, env, cliPath) {
+async function handleOnboard(params: any, env: any, cliPath: string) {
   const { agentName, agentDescription } = params;
   const steps = [];
 
@@ -1815,7 +1442,7 @@ async function handleOnboard(params, env, cliPath) {
     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) {
+  } catch (err: any) {
     steps.push({ step: 'setup', success: false, error: err.message });
     return { steps, nextStep: 'Fix wallet setup error and try again' };
   }
@@ -1825,7 +1452,7 @@ async function handleOnboard(params, env, cliPath) {
     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) {
+  } catch (err: any) {
     steps.push({ step: 'address', success: false, error: err.message });
   }
 
@@ -1843,7 +1470,7 @@ async function handleOnboard(params, env, cliPath) {
         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) {
+  } catch (err: any) {
     steps.push({ step: 'balance', success: false, error: err.message });
   }
 
@@ -1852,7 +1479,7 @@ async function handleOnboard(params, env, cliPath) {
     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) {
+  } catch (err: any) {
     steps.push({ step: 'register', success: false, error: err.message });
   }
 
@@ -1874,12 +1501,12 @@ async function handleOnboard(params, env, cliPath) {
   };
 }
 
-async function handlePendingRequests(env, cliPath) {
+async function handlePendingRequests(env: any, cliPath: string) {
   // Clean up old queue entries before checking pending requests
   try {
     const { cleanupServiceQueue } = await import('./src/scripts/utils/storage.js');
     cleanupServiceQueue();
-  } catch (err) {
+  } catch (err: any) {
     console.error('Queue cleanup failed:', err.message);
   }
 
@@ -1907,7 +1534,7 @@ function handleActivity() {
   return { events, count: events.length };
 }
 
-async function handleFulfill(params, env, cliPath) {
+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");
@@ -1927,7 +1554,7 @@ async function handleFulfill(params, env, cliPath) {
   return output.data;
 }
 
-function buildEnvironment(config) {
+function buildEnvironment(config: any) {
   const env = { ...process.env };
 
   if (config.walletDir) {
@@ -1959,12 +1586,12 @@ function buildEnvironment(config) {
   return env;
 }
 
-function parseCliOutput(stdout) {
+function parseCliOutput(stdout: any) {
   try {
     return JSON.parse(stdout.trim());
-  } catch (error) {
+  } catch (error: any) {
     throw new Error(`Failed to parse CLI output: ${error.message}`);
   }
 }
 
-// sleep() removed — no longer needed since polling loop was removed
+// sleep() removed — no longer needed since polling loop was removed