openclaw-overlay-plugin 0.8.1 → 0.8.4

package/README.md

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,17 +1,15 @@
-const cp_name = 'node:child' + '_' + 'process';
-let execFile;
-let spawn;
-let execFileAsync;
 import { promisify } from 'node:util';
 import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import fs from 'node:fs';
-import process from 'node:process';
 import { initializeServiceSystem, serviceManager } from './src/services/index.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-let isInitialized = false;
+const cp_name = 'node:child' + '_' + 'process';
+let execFile_orig;
+let spawn_orig;
+let execFileAsync;
 async function ensureCp() {
     if (execFileAsync)
         return;
@@ -19,15 +17,15 @@ async function ensureCp() {
     if (typeof require !== 'undefined') {
         // @ts-ignore
         const cp = require(cp_name);
-        execFile = cp.execFile;
-        spawn = cp.spawn;
+        execFile_orig = cp.execFile;
+        spawn_orig = cp.spawn;
     }
     else {
         const cp = await import(cp_name);
-        execFile = cp.execFile;
-        spawn = cp.spawn;
+        execFile_orig = cp.execFile;
+        spawn_orig = cp.spawn;
     }
-    execFileAsync = promisify(execFile);
+    execFileAsync = promisify(execFile_orig);
 }
 // Track background process for proper lifecycle management
 let backgroundProcess = null;
@@ -82,7 +80,6 @@ function checkBudget(walletDir, requestedSats, dailyLimit) {
     };
 }
 async function startAutoImport(env, cliPath, api) {
-    const logger = api.logger;
     // Get our address
     try {
         const addrResult = await execFileAsync('node', [cliPath, 'address'], { env });
@@ -109,13 +106,13 @@ async function startAutoImport(env, cliPath, api) {
                         continue;
                     if (utxo.value < 200)
                         continue; // skip dust
-                    logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
+                    api.logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
                     try {
                         const importResult = await execFileAsync('node', [cliPath, 'import', utxo.tx_hash, String(utxo.tx_pos)], { env });
                         const importOutput = parseCliOutput(importResult.stdout);
                         if (importOutput.success) {
                             knownTxids.add(key);
-                            logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
+                            api.logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
                             // Clear onboarding flag since wallet is now funded
                             try {
                                 const onboardingSentFile = path.join(process['env'].HOME || '', '.openclaw', 'openclaw-overlay', 'onboarding-sent.flag');
@@ -125,22 +122,22 @@ async function startAutoImport(env, cliPath, api) {
                             }
                             catch { }
                             // Notify agent of successful import
-                            wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, api, { sessionKey: 'hook:openclaw-overlay:import' });
+                            wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, api.logger, { sessionKey: 'hook:openclaw-overlay:import' });
                             // Check if registered, auto-register if not
                             try {
                                 const regPath = path.join(process['env'].HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
                                 if (!fs.existsSync(regPath)) {
-                                    logger?.info?.('[openclaw-overlay] Not yet registered — auto-registering...');
+                                    api.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!');
-                                        await autoAdvertiseServices(env, cliPath, logger);
+                                        api.logger?.info?.('[openclaw-overlay] Auto-registered on overlay network!');
+                                        await autoAdvertiseServices(env, cliPath, api.logger);
                                     }
                                 }
                             }
                             catch (err) {
-                                logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
+                                api.logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
                             }
                         }
                     }
@@ -155,7 +152,7 @@ async function startAutoImport(env, cliPath, api) {
         }, 30000);
     }
     catch (err) {
-        logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
+        api.logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
     }
 }
 function stopAutoImport() {
@@ -164,7 +161,6 @@ function stopAutoImport() {
         autoImportInterval = null;
     }
 }
-// Auto-advertise services from config after registration
 async function autoAdvertiseServices(env, cliPath, logger) {
     try {
         const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
@@ -197,8 +193,7 @@ async function autoAdvertiseServices(env, cliPath, logger) {
         logger?.warn?.('[openclaw-overlay] Auto-advertising failed:', err.message);
     }
 }
-function wakeAgent(text, api, options = {}) {
-    const logger = api.logger;
+function wakeAgent(text, logger, options = {}) {
     const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
     const gatewayPort = process['env'].OPENCLAW_GATEWAY_PORT || '18789';
     const httpToken = getHooksToken();
@@ -208,14 +203,7 @@ function wakeAgent(text, api, options = {}) {
         method: 'POST',
         headers: { 'Content-Type': 'application/json', 'x-openclaw-token': httpToken },
         body: JSON.stringify({ prompt: text, sessionKey })
-    }).then(async (res) => {
-        if (!res.ok) {
-            const body = await res.text().catch(() => '');
-            logger?.warn?.(`[openclaw-overlay] /hooks/agent failed: ${res.status} ${body}`);
-        }
-    }).catch((err) => {
-        logger?.warn?.(`[openclaw-overlay] /hooks/agent error: ${err.message}`);
-    });
+    }).catch(() => { });
 }
 function getHooksToken() {
     let token = process['env'].OPENCLAW_HOOKS_TOKEN || null;
@@ -242,7 +230,6 @@ function categorizeEvent(event) {
     return null;
 }
 function startBackgroundService(env, cliPath, api) {
-    const logger = api.logger;
     if (backgroundProcess)
         return;
     serviceRunning = true;
@@ -253,7 +240,7 @@ function startBackgroundService(env, cliPath, api) {
     function spawnConnect() {
         if (!serviceRunning)
             return;
-        const proc = spawn('node', [cliPath, 'connect'], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+        const proc = spawn_orig('node', [cliPath, 'connect'], { env, stdio: ['ignore', 'pipe', 'pipe'] });
         backgroundProcess = proc;
         proc.stdout?.on('data', (data) => {
             const lines = data.toString().split('\n').filter(Boolean);
@@ -265,26 +252,12 @@ function startBackgroundService(env, cliPath, api) {
                         if (wokenRequests.has(rid))
                             return;
                         wokenRequests.add(rid);
-                        logger?.info?.(`[openclaw-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}...`);
-                        if (api.runtime?.taskFlow) {
-                            api.runtime.taskFlow.create({
-                                goal: `Fulfill overlay service request: ${event.serviceId}`,
-                                status: "queued"
-                            });
-                        }
                         const wakeText = `⚡ Incoming overlay service request!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nPaid: ${event.satoshisReceived || '?'} sats\n\nFulfill it now:\n1. overlay({ action: "pending-requests" })\n2. Process the request\n3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
-                        wakeAgent(wakeText, api, { sessionKey: `hook:openclaw-overlay:${rid}` });
+                        wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:${rid}` });
                     }
                     if (event.type === 'service-response' && event.action === 'received') {
-                        logger?.info?.(`[openclaw-overlay] 📬 Response received for ${event.serviceId} from ${event.from?.slice(0, 12)}...`);
-                        if (api.runtime?.taskFlow) {
-                            api.runtime.taskFlow.create({
-                                goal: `Notify user of overlay service response: ${event.serviceId}`,
-                                status: "done"
-                            });
-                        }
                         const wakeText = `📬 Overlay service response received!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nStatus: ${event.status}\n\nFull result:\n${JSON.stringify(event.result, null, 2)}`;
-                        wakeAgent(wakeText, api, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
+                        wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
                     }
                     const notif = categorizeEvent(event);
                     if (notif) {
@@ -317,20 +290,20 @@ function stopBackgroundService() {
     wokenRequests.clear();
     stopAutoImport();
 }
+export async function activate(api) {
+    return register(api);
+}
+let isInitialized = false;
 function getCliPath() {
     const base = __dirname.endsWith('dist') ? __dirname : path.join(__dirname, 'dist');
     return path.join(base, 'src', 'cli.js');
 }
-/**
- * OpenClaw Overlay Plugin
- * Decentralized agent marketplace with BSV micropayments.
- */
 export function register(api) {
     if (isInitialized)
         return;
     isInitialized = true;
     const entries = api.getConfig?.()?.plugins?.entries || {};
-    const entry = entries['sv_overlay'] || entries['overlay'] || entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
+    const entry = entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
     const pluginConfig = { ...entry, ...(entry.config || {}), ...(api.config || {}) };
     // 1. Tool
     api.registerTool({
@@ -339,10 +312,8 @@ export function register(api) {
         parameters: {
             type: "object",
             properties: {
-                action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister", "advertise-ship", "advertise-slap"] },
+                action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister"] },
                 service: { type: "string" },
-                topic: { type: "string" },
-                domain: { type: "string" },
                 input: { type: "object" },
                 identityKey: { type: "string" },
                 sats: { type: "number" },
@@ -364,37 +335,14 @@ export function register(api) {
     });
     // 2. Command
     api.registerCommand({
-        name: "sv_overlay",
+        name: "overlay",
         description: "BSV Overlay Marketplace commands",
         acceptsArgs: true,
-        requireAuth: true,
         handler: async (ctx) => {
             try {
                 const action = ctx.args?.[0] || 'status';
-                if (action === 'help') {
-                    return { text: `🛰️ **Overlay Help**\n\n**Subcommands**:\n- \`status\`: Show identity and wallet balance\n- \`balance\`: Show current satoshis\n- \`onboard\`: Start discovery setup\n- \`discover <serviceId>\`: Find providers on network\n- \`advertise-ship <domain> <topic>\`: Advertise a topic manager\n- \`advertise-slap <domain> <service>\`: Advertise a lookup service\n- \`pending-requests\`: See incoming service jobs\n- \`fulfill\`: Complete a request (Agent only)` };
-                }
-                const params = { action };
-                if (action === 'discover') {
-                    params.service = ctx.args[1];
-                }
-                else if (action === 'advertise-ship') {
-                    params.domain = ctx.args[1];
-                    params.topic = ctx.args[2];
-                }
-                else if (action === 'advertise-slap') {
-                    params.domain = ctx.args[1];
-                    params.service = ctx.args[2];
-                }
-                const result = await executeOverlayAction(params, pluginConfig, api);
-                if (typeof result === 'string')
-                    return { text: result };
-                // Formatted status response
-                if (action === 'status') {
-                    const status = result;
-                    return { text: `🛰️ **Overlay Status**\n\n**Identity Key**: \`${status.identity?.identityKey || 'Not setup'}\`\n**Balance**: ${status.balance?.walletBalance || 0} satoshis\n**Network**: ${status.identity?.network || 'mainnet'}` };
-                }
-                return { text: `**Overlay ${action.toUpperCase()}**\n\n${JSON.stringify(result, null, 2)}` };
+                const result = await executeOverlayAction({ action }, pluginConfig, api);
+                return { text: `**Overlay ${action.toUpperCase()}**\n\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}` };
             }
             catch (error) {
                 return { text: `❌ Error: ${error.message}` };
@@ -403,9 +351,8 @@ export function register(api) {
     });
     // 3. Service
     api.registerService({
-        id: "overlay-relay",
+        id: "openclaw-overlay-relay",
         start: async () => {
-            // Initialize child process helpers
             await ensureCp();
             // Initialize service system
             try {
@@ -424,7 +371,7 @@ export function register(api) {
     });
     // 4. CLI
     api.registerCli(({ program }) => {
-        const overlay = program.command("sv_overlay").description("BSV Overlay Network management");
+        const overlay = program.command("overlay").description("BSV Overlay Network management");
         overlay.command("status").action(async () => {
             await ensureCp();
             const result = await handleStatus(buildEnvironment(pluginConfig), getCliPath());
@@ -435,10 +382,10 @@ export function register(api) {
             const result = await handleBalance(buildEnvironment(pluginConfig), getCliPath());
             console.log(JSON.stringify(result, null, 2));
         });
-    }, { descriptors: [{ name: "overlay", description: "BSV Overlay Network management" }] });
+    }, { commands: ["overlay"] });
 }
 export const plugin = {
-    id: "sv_overlay",
+    id: "openclaw-overlay-plugin",
     name: "BSV Overlay Network",
     description: "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
     activate: register,
@@ -458,21 +405,9 @@ async function executeOverlayAction(params, config, api) {
         case "onboard": return await handleOnboard(params, env, cliPath);
         case "pending-requests": return await handlePendingRequests(env, cliPath);
         case "fulfill": return await handleFulfill(params, env, cliPath);
-        case "advertise-ship": return await handleAdvertiseSHIP(params, env, cliPath);
-        case "advertise-slap": return await handleAdvertiseSLAP(params, env, cliPath);
         default: throw new Error(`Unknown action: ${action}`);
     }
 }
-async function handleAdvertiseSHIP(params, env, cliPath) {
-    const { domain, topic } = params;
-    const result = await execFileAsync('node', [cliPath, 'advertise-ship', domain, topic], { env });
-    return parseCliOutput(result.stdout).data;
-}
-async function handleAdvertiseSLAP(params, env, cliPath) {
-    const { domain, service } = params;
-    const result = await execFileAsync('node', [cliPath, 'advertise-slap', domain, service], { env });
-    return parseCliOutput(result.stdout).data;
-}
 async function handleServiceRequest(params, env, cliPath, config, api) {
     const { service, identityKey: targetKey, input } = params;
     const walletDir = config?.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');

package/index.ts

@@ -1,22 +1,17 @@
-const cp_name = 'node:child' + '_' + 'process';
-let execFile: any;
-let spawn: any;
-let execFileAsync: any;
-type ChildProcess = any;
-
+import { execFile as execFile_orig_node, spawn as spawn_orig_node, 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 process from 'node:process';
-import { Buffer } from 'node:buffer';
 import { initializeServiceSystem, serviceManager } from './src/services/index.js';
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-let isInitialized = false;
+const cp_name = 'node:child' + '_' + 'process';
+let execFile_orig: any;
+let spawn_orig: any;
+let execFileAsync: any;
 
 async function ensureCp() {
   if (execFileAsync) return;
@@ -24,18 +19,18 @@ async function ensureCp() {
   if (typeof require !== 'undefined') {
     // @ts-ignore
     const cp = require(cp_name);
-    execFile = cp.execFile;
-    spawn = cp.spawn;
+    execFile_orig = cp.execFile;
+    spawn_orig = cp.spawn;
   } else {
     const cp = await import(cp_name as any);
-    execFile = cp.execFile;
-    spawn = cp.spawn;
+    execFile_orig = cp.execFile;
+    spawn_orig = cp.spawn;
   }
-  execFileAsync = promisify(execFile);
+  execFileAsync = promisify(execFile_orig);
 }
 
 // Track background process for proper lifecycle management
-let backgroundProcess: ChildProcess | null = null;
+let backgroundProcess: any = null;
 let serviceRunning = false;
 
 // Confirmation tokens for destructive actions — maps token → { action, details, expiresAt }
@@ -101,7 +96,6 @@ function checkBudget(walletDir: string, requestedSats: number, dailyLimit: numbe
 }
 
 async function startAutoImport(env: any, cliPath: string, api: any) {
-  const logger = api.logger;
   // Get our address
   try {
     const addrResult = await execFileAsync('node', [cliPath, 'address'], { env });
@@ -126,13 +120,13 @@ async function startAutoImport(env: any, cliPath: string, api: any) {
           if (knownTxids.has(key)) continue;
           if (utxo.value < 200) continue; // skip dust
           
-          logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
+          api.logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
           try {
             const importResult = await execFileAsync('node', [cliPath, 'import', utxo.tx_hash, String(utxo.tx_pos)], { env });
             const importOutput = parseCliOutput(importResult.stdout);
             if (importOutput.success) {
               knownTxids.add(key);
-              logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
+              api.logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
               
               // Clear onboarding flag since wallet is now funded
               try {
@@ -143,22 +137,22 @@ async function startAutoImport(env: any, cliPath: string, api: any) {
               } catch {}
 
               // Notify agent of successful import
-              wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, api, { sessionKey: 'hook:openclaw-overlay:import' });
+              wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, api.logger, { sessionKey: 'hook:openclaw-overlay:import' });
 
               // Check if registered, auto-register if not
               try {
                 const regPath = path.join((process as any)['env'].HOME || '', '.openclaw', 'openclaw-overlay', 'registration.json');
                 if (!fs.existsSync(regPath)) {
-                  logger?.info?.('[openclaw-overlay] Not yet registered — auto-registering...');
+                  api.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!');
-                    await autoAdvertiseServices(env, cliPath, logger);
+                    api.logger?.info?.('[openclaw-overlay] Auto-registered on overlay network!');
+                    await autoAdvertiseServices(env, cliPath, api.logger);
                   }
                 }
               } catch (err: any) {
-                logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
+                api.logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
               }
             }
           } catch (err) {
@@ -170,7 +164,7 @@ async function startAutoImport(env: any, cliPath: string, api: any) {
       }
     }, 30000);
   } catch (err: any) {
-    logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
+    api.logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
   }
 }
 
@@ -181,7 +175,6 @@ function stopAutoImport() {
   }
 }
 
-// Auto-advertise services from config after registration
 async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
   try {
     const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
@@ -212,8 +205,7 @@ async function autoAdvertiseServices(env: any, cliPath: string, logger: any) {
   }
 }
 
-function wakeAgent(text: string, api: any, options: { sessionKey?: string } = {}) {
-  const logger = api.logger;
+function wakeAgent(text: string, logger: any, options: { sessionKey?: string } = {}) {
   const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
   const gatewayPort = (process as any)['env'].OPENCLAW_GATEWAY_PORT || '18789';
   const httpToken = getHooksToken();
@@ -223,14 +215,7 @@ function wakeAgent(text: string, api: any, options: { sessionKey?: string } = {}
     method: 'POST',
     headers: { 'Content-Type': 'application/json', 'x-openclaw-token': httpToken },
     body: JSON.stringify({ prompt: text, sessionKey })
-  }).then(async (res) => {
-    if (!res.ok) {
-      const body = await res.text().catch(() => '');
-      logger?.warn?.(`[openclaw-overlay] /hooks/agent failed: ${res.status} ${body}`);
-    }
-  }).catch((err) => {
-    logger?.warn?.(`[openclaw-overlay] /hooks/agent error: ${err.message}`);
-  });
+  }).catch(() => {});
 }
 
 function getHooksToken(): string | null {
@@ -259,7 +244,6 @@ function categorizeEvent(event: any) {
 }
 
 function startBackgroundService(env: any, cliPath: string, api: any) {
-  const logger = api.logger;
   if (backgroundProcess) return;
   serviceRunning = true;
 
@@ -269,7 +253,7 @@ function startBackgroundService(env: any, cliPath: string, api: any) {
   
   function spawnConnect() {
     if (!serviceRunning) return;
-    const proc = spawn('node', [cliPath, 'connect'], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+    const proc = spawn_orig('node', [cliPath, 'connect'], { env, stdio: ['ignore', 'pipe', 'pipe'] });
     backgroundProcess = proc;
     
     proc.stdout?.on('data', (data: any) => {
@@ -281,31 +265,12 @@ function startBackgroundService(env: any, cliPath: string, api: any) {
             const rid = event.id || `${event.from}-${Date.now()}`;
             if (wokenRequests.has(rid)) return;
             wokenRequests.add(rid);
-            
-            logger?.info?.(`[openclaw-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}...`);
-            
-            if (api.runtime?.taskFlow) {
-              api.runtime.taskFlow.create({
-                goal: `Fulfill overlay service request: ${event.serviceId}`,
-                status: "queued"
-              });
-            }
-
             const wakeText = `⚡ Incoming overlay service request!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nPaid: ${event.satoshisReceived || '?'} sats\n\nFulfill it now:\n1. overlay({ action: "pending-requests" })\n2. Process the request\n3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
-            wakeAgent(wakeText, api, { sessionKey: `hook:openclaw-overlay:${rid}` });
+            wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:${rid}` });
           }
           if (event.type === 'service-response' && event.action === 'received') {
-            logger?.info?.(`[openclaw-overlay] 📬 Response received for ${event.serviceId} from ${event.from?.slice(0, 12)}...`);
-            
-            if (api.runtime?.taskFlow) {
-              api.runtime.taskFlow.create({
-                goal: `Notify user of overlay service response: ${event.serviceId}`,
-                status: "done"
-              });
-            }
-
             const wakeText = `📬 Overlay service response received!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nStatus: ${event.status}\n\nFull result:\n${JSON.stringify(event.result, null, 2)}`;
-            wakeAgent(wakeText, api, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
+            wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
           }
           const notif = categorizeEvent(event);
           if (notif) {
@@ -333,135 +298,106 @@ function stopBackgroundService() {
   stopAutoImport();
 }
 
+export async function activate(api: any) {
+  return register(api);
+}
+
+let isInitialized = false;
+
 function getCliPath() {
   const base = __dirname.endsWith('dist') ? __dirname : path.join(__dirname, 'dist');
   return path.join(base, 'src', 'cli.js');
 }
 
-/**
- * OpenClaw Overlay Plugin
- * Decentralized agent marketplace with BSV micropayments.
- */
 export function register(api: any) {
   if (isInitialized) return;
   isInitialized = true;
 
   const entries = api.getConfig?.()?.plugins?.entries || {};
-  const entry = entries['sv_overlay'] || entries['overlay'] || entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
+  const entry = entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
   const pluginConfig = { ...entry, ...(entry.config || {}), ...(api.config || {}) };
 
   // 1. Tool
   api.registerTool({
-      name: "overlay",
-      description: "Access the BSV agent marketplace",
-      parameters: {
-        type: "object",
-        properties: {
-          action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister", "advertise-ship", "advertise-slap"] },
-          service: { type: "string" },
-          topic: { type: "string" },
-          domain: { type: "string" },
-          input: { type: "object" },
-          identityKey: { type: "string" },
-          sats: { type: "number" },
-          requestId: { type: "string" },
-          recipientKey: { type: "string" },
-          serviceId: { type: "string" },
-          result: { type: "object" }
-        },
-        required: ["action"]
+    name: "overlay",
+    description: "Access the BSV agent marketplace",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister"] },
+        service: { type: "string" },
+        input: { type: "object" },
+        identityKey: { type: "string" },
+        sats: { type: "number" },
+        requestId: { type: "string" },
+        recipientKey: { type: "string" },
+        serviceId: { type: "string" },
+        result: { type: "object" }
       },
-      async execute(_id: string, params: any) {
-        try {
-          return await executeOverlayAction(params, pluginConfig, api);
-        } catch (error: any) {
-          return { content: [{ type: "text", text: `Error: ${error.message}` }] };
-        }
+      required: ["action"]
+    },
+    async execute(_id: string, params: any) {
+      try {
+        return await executeOverlayAction(params, pluginConfig, api);
+      } catch (error: any) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
       }
-    });
-
-    // 2. Command
-    api.registerCommand({
-      name: "sv_overlay",
-      description: "BSV Overlay Marketplace commands",
-      acceptsArgs: true,
-      requireAuth: true,
-      handler: async (ctx: any) => {
-        try {
-          const action = ctx.args?.[0] || 'status';
-
-          if (action === 'help') {
-            return { text: `🛰️ **Overlay Help**\n\n**Subcommands**:\n- \`status\`: Show identity and wallet balance\n- \`balance\`: Show current satoshis\n- \`onboard\`: Start discovery setup\n- \`discover <serviceId>\`: Find providers on network\n- \`advertise-ship <domain> <topic>\`: Advertise a topic manager\n- \`advertise-slap <domain> <service>\`: Advertise a lookup service\n- \`pending-requests\`: See incoming service jobs\n- \`fulfill\`: Complete a request (Agent only)` };
-          }
-
-          const params: any = { action };
-          if (action === 'discover') {
-            params.service = ctx.args[1];
-          } else if (action === 'advertise-ship') {
-            params.domain = ctx.args[1];
-            params.topic = ctx.args[2];
-          } else if (action === 'advertise-slap') {
-            params.domain = ctx.args[1];
-            params.service = ctx.args[2];
-          }
-
-          const result = await executeOverlayAction(params, pluginConfig, api);
-          
-          if (typeof result === 'string') return { text: result };
-          
-          // Formatted status response
-          if (action === 'status') {
-            const status = result as any;
-            return { text: `🛰️ **Overlay Status**\n\n**Identity Key**: \`${status.identity?.identityKey || 'Not setup'}\`\n**Balance**: ${status.balance?.walletBalance || 0} satoshis\n**Network**: ${status.identity?.network || 'mainnet'}` };
-          }
+    }
+  });
 
-          return { text: `**Overlay ${action.toUpperCase()}**\n\n${JSON.stringify(result, null, 2)}` };
-        } catch (error: any) {
-          return { text: `❌ Error: ${error.message}` };
-        }
+  // 2. Command
+  api.registerCommand({
+    name: "overlay",
+    description: "BSV Overlay Marketplace commands",
+    acceptsArgs: true,
+    handler: async (ctx: any) => {
+      try {
+        const action = ctx.args?.[0] || 'status';
+        const result = await executeOverlayAction({ action }, pluginConfig, api);
+        return { text: `**Overlay ${action.toUpperCase()}**\n\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}` };
+      } catch (error: any) {
+        return { text: `❌ Error: ${error.message}` };
       }
-    });
-
-    // 3. Service
-    api.registerService({
-      id: "overlay-relay",
-      start: async () => {
-        // Initialize child process helpers
-        await ensureCp();
+    }
+  });
 
-        // Initialize service system
-        try {
-          await initializeServiceSystem();
-        } catch (err: any) {
-          if (api.logger) api.logger.warn(`[overlay] Service system initialization failed: ${err.message}`);
-        }
+  // 3. Service
+  api.registerService({
+    id: "openclaw-overlay-relay",
+    start: async () => {
+      await ensureCp();
+      // Initialize service system
+      try {
+        await initializeServiceSystem();
+      } catch (err: any) {
+        if (api.logger) api.logger.warn(`[overlay] Service system initialization failed: ${err.message}`);
+      }
+      const env = buildEnvironment(pluginConfig);
+      const cliPath = getCliPath();
+      startBackgroundService(env, cliPath, api);
+      startAutoImport(env, cliPath, api);
+    },
+    stop: () => stopBackgroundService()
+  });
 
-        const env = buildEnvironment(pluginConfig);
-        const cliPath = getCliPath();
-        startBackgroundService(env, cliPath, api);
-        startAutoImport(env, cliPath, api);
-      },
-      stop: () => stopBackgroundService()
+  // 4. CLI
+  api.registerCli(({ program }: any) => {
+    const overlay = program.command("overlay").description("BSV Overlay Network management");
+    overlay.command("status").action(async () => {
+      await ensureCp();
+      const result = await handleStatus(buildEnvironment(pluginConfig), getCliPath());
+      console.log(JSON.stringify(result, null, 2));
     });
-
-    // 4. CLI
-    api.registerCli(({ program }: any) => {
-      const overlay = program.command("sv_overlay").description("BSV Overlay Network management");
-      overlay.command("status").action(async () => {
-        await ensureCp();
-        const result = await handleStatus(buildEnvironment(pluginConfig), getCliPath());
-        console.log(JSON.stringify(result, null, 2));
-      });
-      overlay.command("balance").action(async () => {
-        await ensureCp();
-        const result = await handleBalance(buildEnvironment(pluginConfig), getCliPath());
-        console.log(JSON.stringify(result, null, 2));
-      });
-    }, { descriptors: [{ name: "overlay", description: "BSV Overlay Network management" }] });
+    overlay.command("balance").action(async () => {
+      await ensureCp();
+      const result = await handleBalance(buildEnvironment(pluginConfig), getCliPath());
+      console.log(JSON.stringify(result, null, 2));
+    });
+  }, { commands: ["overlay"] });
 }
 
 export const plugin = {
-  id: "sv_overlay",
+  id: "openclaw-overlay-plugin",
   name: "BSV Overlay Network",
   description: "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
   activate: register,
@@ -484,24 +420,10 @@ async function executeOverlayAction(params: any, config: any, api: any) {
     case "onboard": return await handleOnboard(params, env, cliPath);
     case "pending-requests": return await handlePendingRequests(env, cliPath);
     case "fulfill": return await handleFulfill(params, env, cliPath);
-    case "advertise-ship": return await handleAdvertiseSHIP(params, env, cliPath);
-    case "advertise-slap": return await handleAdvertiseSLAP(params, env, cliPath);
     default: throw new Error(`Unknown action: ${action}`);
   }
 }
 
-async function handleAdvertiseSHIP(params: any, env: any, cliPath: string) {
-  const { domain, topic } = params;
-  const result = await execFileAsync('node', [cliPath, 'advertise-ship', domain, topic], { env });
-  return parseCliOutput(result.stdout).data;
-}
-
-async function handleAdvertiseSLAP(params: any, env: any, cliPath: string) {
-  const { domain, service } = params;
-  const result = await execFileAsync('node', [cliPath, 'advertise-slap', domain, service], { env });
-  return parseCliOutput(result.stdout).data;
-}
-
 async function handleServiceRequest(params: any, env: any, cliPath: string, config: any, api: any) {
   const { service, identityKey: targetKey, input } = params;
   const walletDir = config?.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
-  "id": "sv_overlay",
+  "id": "openclaw-overlay-plugin",
   "name": "BSV Overlay Network",
   "description": "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
-  "version": "0.2.0",
+  "version": "0.8.4",
   "skills": [
     "./SKILL.md"
   ],
@@ -20,7 +20,7 @@
   ],
   "commands": [
     {
-      "name": "sv_overlay",
+      "name": "overlay",
       "description": "BSV Overlay Network management",
       "isAutoreply": true
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-overlay-plugin",
-  "version": "0.8.1",
+  "version": "0.8.4",
   "description": "Openclaw BSV Overlay — agent discovery, service marketplace, and micropayments on the BSV blockchain",
   "publishConfig": {
     "access": "public"
@@ -23,6 +23,7 @@
     "prepublishOnly": "npm run build && npm test",
     "cli": "node dist/src/cli.js",
     "test": "npx tsx src/test/cli.test.ts && npx tsx src/test/taskflow.test.ts && npx tsx src/test/key-derivation.test.ts",
+    "postversion": "node ../sync_versions.js",
     "lint": "eslint src/**/*.ts"
   },
   "dependencies": {