openclaw-overlay-plugin 0.7.65 → 0.7.67

package/openclaw.plugin.json

@@ -2,10 +2,22 @@
   "id": "openclaw-overlay-plugin",
   "name": "BSV Overlay Network",
   "description": "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
-  "version": "0.7.65",
+  "version": "0.7.67",
   "skills": [
     "./SKILL.md"
   ],
+  "providerAuthEnvVars": {
+    "OVERLAY_URL": "Overlay server URL (defaults to https://clawoverlay.com)",
+    "BSV_NETWORK": "BSV network to use (mainnet/testnet)",
+    "BSV_WALLET_DIR": "Path to the shared BSV wallet directory"
+  },
+  "providerAuthChoices": [
+    {
+      "id": "standard-wallet",
+      "label": "Standard BSV Wallet (~/.openclaw/bsv-wallet)",
+      "description": "Uses the default shared agent identity key"
+    }
+  ],
   "commands": [
     {
       "name": "overlay",
@@ -23,56 +35,8 @@
   },
   "configSchema": {
     "type": "object",
-    "additionalProperties": true,
+    "additionalProperties": false,
     "properties": {
-      "enabled": {
-        "type": "boolean"
-      },
-      "config": {
-        "type": "object",
-        "additionalProperties": true,
-        "properties": {
-          "overlayUrl": {
-            "type": "string"
-          },
-          "network": {
-            "type": "string"
-          },
-          "chaintracksUrl": {
-            "type": "string"
-          },
-          "arcUrl": {
-            "type": "string"
-          },
-          "agentName": {
-            "type": "string"
-          },
-          "agentDescription": {
-            "type": "string"
-          },
-          "walletDir": {
-            "type": "string"
-          },
-          "maxAutoPaySats": {
-            "type": "number"
-          },
-          "dailyBudgetSats": {
-            "type": "number"
-          },
-          "autoAcceptPayments": {
-            "type": "boolean"
-          },
-          "preferCheapest": {
-            "type": "boolean"
-          },
-          "services": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          }
-        }
-      },
       "overlayUrl": {
         "type": "string",
         "default": "https://clawoverlay.com",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-overlay-plugin",
-  "version": "0.7.65",
+  "version": "0.7.67",
   "description": "Openclaw BSV Overlay — agent discovery, service marketplace, and micropayments on the BSV blockchain",
   "publishConfig": {
     "access": "public"

package/src/compatibility.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Compatibility Test for Node 24 and OpenClaw SDK
+ */
+
+import sqlite3 from 'sqlite3';
+import { plugin } from '../index.js';
+
+async function testCompatibility() {
+  console.log('--- Overlay Compatibility Test ---');
+  
+  // 1. Verify SQLite3 Native Bindings
+  try {
+    const db = new sqlite3.Database(':memory:');
+    console.log('✓ SQLite3 native bindings loaded successfully.');
+    db.close();
+  } catch (err: any) {
+    console.error('✗ SQLite3 failed to load bindings:', err.message);
+    process.exit(1);
+  }
+
+  // 2. Verify Plugin Registration (SDK Descriptors)
+  let registeredCli = false;
+  let hasDescriptors = false;
+  
+  const mockApi = {
+    logger: { info: () => {}, warn: () => {}, error: () => {} },
+    registerTool: () => {},
+    registerCommand: () => {},
+    registerService: () => {},
+    registerCli: (fn: any, options: any) => {
+      registeredCli = true;
+      if (options && options.descriptors && options.descriptors[0].name === 'overlay') {
+        hasDescriptors = true;
+      }
+    },
+    getConfig: () => ({ plugins: { entries: {} } })
+  };
+
+  try {
+    plugin.register(mockApi);
+    if (registeredCli && hasDescriptors) {
+      console.log('✓ CLI descriptors registered correctly for Phase 1 discovery.');
+    } else {
+      throw new Error(`CLI registration missing or using old 'commands' array format.`);
+    }
+  } catch (err: any) {
+    console.error('✗ Plugin registration failed:', err.message);
+    process.exit(1);
+  }
+
+  console.log('--- All Compatibility Tests Passed ---\n');
+}
+
+testCompatibility().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/src/scripts/baemail/commands.ts

@@ -1,172 +1,98 @@
-/**
- * Baemail commands - paid message forwarding service.
- */
-
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import os from 'node:os';
 import fs from 'node:fs';
-import { PATHS } from '../config.js';
+import process from 'node:process';
+import { Buffer } from 'node:buffer';
 import { ok, fail } from '../output.js';
 import { loadIdentity } from '../wallet/identity.js';
-import { ensureStateDir } from '../utils/storage.js';
-import { fetchWithTimeout } from '../utils/woc.js';
-
-// Types
-export interface BaemailConfig {
-  deliveryChannel: string;
-  tiers: {
-    standard: number;
-    priority: number;
-    urgent: number;
-  };
-  maxMessageLength: number;
-  blocklist: string[];
-  createdAt: string;
-  updatedAt: string;
-}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Define paths relative to home directory
+const PATHS = {
+  walletIdentity: path.join(os.homedir(), '.openclaw', 'bsv-wallet', 'wallet-identity.json'),
+  baemailLog: path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'baemail-deliveries.jsonl'),
+  baemailConfig: path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'baemail-config.json'),
+  baemailBlocklist: path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'baemail-blocklist.json'),
+};
 
 export interface BaemailLogEntry {
   requestId: string;
   from: string;
-  senderName: string;
-  tier: string;
+  to?: string;
   paidSats: number;
-  messageLength: number;
-  deliveryChannel: string;
   deliverySuccess: boolean;
-  deliveryError: string | null;
-  paymentTxid: string;
-  refundStatus: string | null;
+  refundStatus?: 'pending' | 'completed';
   refundTxid?: string;
-  refundedAt?: string;
-  timestamp: string;
   _lineIdx?: number;
+  ts?: number;
+  senderName?: string;
+  messageLength?: number;
+  tier?: string;
+  deliveryChannel?: string;
+  deliveryError?: string | null;
+  paymentTxid?: string;
+  timestamp?: string;
 }
 
 /**
- * Load baemail configuration.
+ * Log a baemail delivery event.
  */
-export function loadBaemailConfig(): BaemailConfig | null {
+export function logBaemailDelivery(entry: BaemailLogEntry) {
   try {
-    if (fs.existsSync(PATHS.baemailConfig)) {
-      return JSON.parse(fs.readFileSync(PATHS.baemailConfig, 'utf-8'));
-    }
-  } catch (err) {
-    console.warn(`[baemail] Warning: Could not read config: ${(err as Error).message}`);
-  }
-  return null;
+    const dir = path.dirname(PATHS.baemailLog);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(PATHS.baemailLog, JSON.stringify({ ...entry, ts: Date.now() }) + '\n');
+  } catch {}
 }
 
-/**
- * Save baemail configuration.
- */
-export function saveBaemailConfig(config: BaemailConfig): void {
-  ensureStateDir();
-  fs.writeFileSync(PATHS.baemailConfig, JSON.stringify(config, null, 2));
-}
-
-/**
- * Setup baemail service with delivery channel and tier pricing.
- */
-export async function cmdBaemailSetup(
-  channel: string | undefined,
-  standardStr: string | undefined,
-  priorityStr?: string,
-  urgentStr?: string
-): Promise<never> {
-  if (!channel || !standardStr) {
-    return fail('Usage: baemail-setup <channel> <standardSats> [prioritySats] [urgentSats]');
-  }
-
-  const standard = parseInt(standardStr, 10);
-  const priority = priorityStr ? parseInt(priorityStr, 10) : standard * 2;
-  const urgent = urgentStr ? parseInt(urgentStr, 10) : standard * 5;
-
-  if (isNaN(standard) || standard < 1) {
-    return fail('Standard rate must be a positive integer (sats)');
-  }
-  if (priority < standard) {
-    return fail('Priority rate must be >= standard rate');
-  }
-  if (urgent < priority) {
-    return fail('Urgent rate must be >= priority rate');
-  }
-
-  const config: BaemailConfig = {
-    deliveryChannel: channel,
-    tiers: { standard, priority, urgent },
+export async function loadBaemailConfig() {
+  const defaults = { 
+    enabled: true, 
+    priceSats: 100, 
+    autoRefund: true,
+    blocklist: [] as string[],
     maxMessageLength: 4000,
-    blocklist: [],
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
+    deliveryChannel: 'agent-hook',
+    tiers: {
+      standard: 100,
+      priority: 500,
+      urgent: 1000
+    }
   };
 
-  saveBaemailConfig(config);
-
-  return ok({
-    configured: true,
-    deliveryChannel: channel,
-    tiers: config.tiers,
-    note: `Advertise with: cli advertise baemail "Baemail" "Paid message forwarding. Pay ${standard}+ sats to reach me." ${standard}`,
-  });
-}
-
-/**
- * View current baemail configuration.
- */
-export async function cmdBaemailConfig(): Promise<never> {
-  const config = loadBaemailConfig();
-  if (!config) {
-    return fail('Baemail not configured. Run: baemail-setup <channel> <standardSats> [prioritySats] [urgentSats]');
+  if (!fs.existsSync(PATHS.baemailConfig)) {
+    return defaults;
   }
-  return ok(config);
-}
-
-/**
- * Block a sender from using baemail.
- */
-export async function cmdBaemailBlock(identityKey: string | undefined): Promise<never> {
-  if (!identityKey) return fail('Usage: baemail-block <identityKey>');
-
-  const config = loadBaemailConfig();
-  if (!config) {
-    return fail('Baemail not configured. Run baemail-setup first.');
-  }
-
-  if (!config.blocklist) config.blocklist = [];
-  if (config.blocklist.includes(identityKey)) {
-    return fail('Identity already blocked');
+  try {
+    const config = JSON.parse(fs.readFileSync(PATHS.baemailConfig, 'utf-8'));
+    return { ...defaults, ...config };
+  } catch {
+    return defaults;
   }
-
-  config.blocklist.push(identityKey);
-  config.updatedAt = new Date().toISOString();
-  saveBaemailConfig(config);
-
-  return ok({ blocked: identityKey, totalBlocked: config.blocklist.length });
 }
 
-/**
- * Unblock a sender.
- */
-export async function cmdBaemailUnblock(identityKey: string | undefined): Promise<never> {
-  if (!identityKey) return fail('Usage: baemail-unblock <identityKey>');
-
-  const config = loadBaemailConfig();
-  if (!config) {
-    return fail('Baemail not configured. Run baemail-setup first.');
-  }
-
-  if (!config.blocklist || !config.blocklist.includes(identityKey)) {
-    return fail('Identity not in blocklist');
+async function fetchWithTimeout(url: string, options: any = {}) {
+  const { timeout = 15000 } = options;
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(id);
+    return response;
+  } catch (err) {
+    clearTimeout(id);
+    throw err;
   }
-
-  config.blocklist = config.blocklist.filter(k => k !== identityKey);
-  config.updatedAt = new Date().toISOString();
-  saveBaemailConfig(config);
-
-  return ok({ unblocked: identityKey, totalBlocked: config.blocklist.length });
 }
 
 /**
- * View baemail delivery log.
+ * List recent baemail deliveries.
  */
 export async function cmdBaemailLog(limitStr?: string): Promise<never> {
   const limit = parseInt(limitStr || '20', 10) || 20;
@@ -175,8 +101,8 @@ export async function cmdBaemailLog(limitStr?: string): Promise<never> {
     return ok({ log: [], count: 0 });
   }
 
-  const lines = fs.readFileSync(PATHS.baemailLog, 'utf-8').split('\n').filter(l => l.trim());
-  const entries: BaemailLogEntry[] = lines.map(l => {
+  const lines = fs.readFileSync(PATHS.baemailLog, 'utf-8').split('\n').filter((l: string) => l.trim());
+  const entries: BaemailLogEntry[] = lines.map((l: string) => {
     try { return JSON.parse(l); } catch { return null; }
   }).filter(Boolean) as BaemailLogEntry[];
 
@@ -184,6 +110,52 @@ export async function cmdBaemailLog(limitStr?: string): Promise<never> {
   return ok({ log: recent, count: entries.length, showing: recent.length });
 }
 
+export async function cmdBaemailSetup(priceSatsStr: string, prioritySats?: string, urgentSats?: string, channel?: string): Promise<never> {
+  const standard = parseInt(priceSatsStr, 10) || 100;
+  const priority = parseInt(prioritySats || '', 10) || (standard * 5);
+  const urgent = parseInt(urgentSats || '', 10) || (standard * 10);
+  
+  const config = { 
+    enabled: true, 
+    priceSats: standard, 
+    autoRefund: true,
+    deliveryChannel: channel || 'agent-hook',
+    tiers: { standard, priority, urgent }
+  };
+  
+  const dir = path.dirname(PATHS.baemailConfig);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(PATHS.baemailConfig, JSON.stringify(config, null, 2));
+  return ok({ message: `Baemail setup complete.`, config });
+}
+
+export async function cmdBaemailConfig(): Promise<never> {
+  const config = await loadBaemailConfig();
+  return ok(config);
+}
+
+export async function cmdBaemailBlock(pubkey: string): Promise<never> {
+  if (!pubkey) return fail('Usage: baemail-block <pubkey>');
+  let blocklist: string[] = [];
+  if (fs.existsSync(PATHS.baemailBlocklist)) {
+    try { blocklist = JSON.parse(fs.readFileSync(PATHS.baemailBlocklist, 'utf-8')); } catch { blocklist = []; }
+  }
+  if (!blocklist.includes(pubkey)) blocklist.push(pubkey);
+  fs.writeFileSync(PATHS.baemailBlocklist, JSON.stringify(blocklist, null, 2));
+  return ok({ blocked: true, pubkey, count: blocklist.length });
+}
+
+export async function cmdBaemailUnblock(pubkey: string): Promise<never> {
+  if (!pubkey) return fail('Usage: baemail-unblock <pubkey>');
+  let blocklist: string[] = [];
+  if (fs.existsSync(PATHS.baemailBlocklist)) {
+    try { blocklist = JSON.parse(fs.readFileSync(PATHS.baemailBlocklist, 'utf-8')); } catch { blocklist = []; }
+  }
+  blocklist = blocklist.filter(p => p !== pubkey);
+  fs.writeFileSync(PATHS.baemailBlocklist, JSON.stringify(blocklist, null, 2));
+  return ok({ unblocked: true, pubkey, count: blocklist.length });
+}
+
 /**
  * Refund a failed baemail delivery.
  */
@@ -195,8 +167,8 @@ export async function cmdBaemailRefund(requestId: string | undefined): Promise<n
   }
 
   // Find the entry
-  const lines = fs.readFileSync(PATHS.baemailLog, 'utf-8').split('\n').filter(l => l.trim());
-  const entries: BaemailLogEntry[] = lines.map((l, idx) => {
+  const lines = fs.readFileSync(PATHS.baemailLog, 'utf-8').split('\n').filter((l: string) => l.trim());
+  const entries: BaemailLogEntry[] = lines.map((l: string, idx: number) => {
     try { return { ...JSON.parse(l), _lineIdx: idx }; } catch { return null; }
   }).filter(Boolean) as BaemailLogEntry[];
 
@@ -289,7 +261,7 @@ export async function cmdBaemailRefund(requestId: string | undefined): Promise<n
     await tx.sign();
 
     // Broadcast using configured ARC/Arcade URL or fallback to WhatsOnChain
-    const arcUrl = (process as any)['en' + 'v'].BSV_ARC_URL;
+    const arcUrl = (process as any)['env'].BSV_ARC_URL;
     let broadcastResp;
     
     if (arcUrl) {
@@ -314,7 +286,7 @@ export async function cmdBaemailRefund(requestId: string | undefined): Promise<n
     const txid = tx.id('hex');
 
     // Update log entry
-    const updatedLines = lines.map((l, idx) => {
+    const updatedLines = lines.map((l: string, idx: number) => {
       if (idx === entry._lineIdx) {
         const updated = { ...JSON.parse(l), refundStatus: 'completed', refundTxid: txid, refundedAt: new Date().toISOString() };
         return JSON.stringify(updated);

package/src/scripts/baemail/handler.ts

@@ -68,7 +68,7 @@ export async function processBaemail(
   const payment = msg.payload?.payment;
 
   // Load config
-  const config = loadBaemailConfig();
+  const config = await loadBaemailConfig();
   if (!config) {
     const rejectPayload = {
       requestId: msg.id,
@@ -289,7 +289,7 @@ _Reply via overlay: \`cli send ${replyKey} ping "your reply"\`_`;
     deliverySuccess,
     deliveryError: deliveryError ?? null,
     paymentTxid: payResult.txid || '',
-    refundStatus: deliverySuccess ? null : 'pending',
+    refundStatus: deliverySuccess ? undefined : 'pending',
     timestamp: new Date().toISOString(),
   };
   fs.appendFileSync(PATHS.baemailLog, JSON.stringify(logEntry) + '\n');

package/src/scripts/services/respond.ts

@@ -139,7 +139,7 @@ export async function cmdResearchRespond(resultJsonPath: string | undefined): Pr
   // Remove from queue
   if (fs.existsSync(PATHS.researchQueue)) {
     const lines = fs.readFileSync(PATHS.researchQueue, 'utf-8').trim().split('\n').filter(Boolean);
-    const remaining = lines.filter(l => {
+    const remaining = lines.filter((l: string) => {
       try { return JSON.parse(l).requestId !== requestId; } catch { return true; }
     });
     fs.writeFileSync(PATHS.researchQueue, remaining.length ? remaining.join('\n') + '\n' : '');

package/src/scripts/utils/storage.ts

@@ -104,7 +104,7 @@ export function appendToJsonl(filePath: string, entry: Record<string, unknown>):
 export function readJsonl<T>(filePath: string): T[] {
   if (!fs.existsSync(filePath)) return [];
   const lines = fs.readFileSync(filePath, 'utf-8').trim().split('\n').filter(Boolean);
-  return lines.map(line => {
+  return lines.map((line: string) => {
     try {
       return JSON.parse(line);
     } catch {

package/src/test/request-response-flow.test.ts

@@ -4,6 +4,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
+import process from 'node:process';
 
 // Simple test runner (matching existing pattern)
 let passed = 0;
@@ -127,13 +128,13 @@ async function run() {
 
     // Check remaining entries
     const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
-    const remaining = lines.map(line => JSON.parse(line));
+    const remaining = lines.map((line: string) => JSON.parse(line));
 
     assert(remaining.length === 2, `Expected 2 remaining entries, got ${remaining.length}`);
-    assert(remaining.find(e => e.requestId === 'pending-1') !== undefined, 'Should keep recent pending');
-    assert(remaining.find(e => e.requestId === 'recent-fulfilled') !== undefined, 'Should keep recent fulfilled');
-    assert(remaining.find(e => e.requestId === 'old-fulfilled') === undefined, 'Should remove old fulfilled');
-    assert(remaining.find(e => e.requestId === 'old-rejected') === undefined, 'Should remove old rejected');
+    assert(remaining.find((e: any) => e.requestId === 'pending-1') !== undefined, 'Should keep recent pending');
+    assert(remaining.find((e: any) => e.requestId === 'recent-fulfilled') !== undefined, 'Should keep recent fulfilled');
+    assert(remaining.find((e: any) => e.requestId === 'old-fulfilled') === undefined, 'Should remove old fulfilled');
+    assert(remaining.find((e: any) => e.requestId === 'old-rejected') === undefined, 'Should remove old rejected');
 
     cleanupTestEnv();
   });
@@ -159,7 +160,7 @@ async function run() {
       const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
       let updated = false;
 
-      const updatedLines = lines.map(line => {
+      const updatedLines = lines.map((line: string) => {
         try {
           const entryData = JSON.parse(line);
           if (entryData.requestId === requestId) {
@@ -215,7 +216,7 @@ async function run() {
       const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
       let updated = false;
 
-      lines.map(line => {
+      lines.map((line: string) => {
         try {
           const entry = JSON.parse(line);
           if (entry.requestId === requestId) {