@johngalt5/bsv-overlay 0.2.12 → 0.2.14

package/index.ts

@@ -3,6 +3,7 @@ import { promisify } from 'util';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
+import WebSocket from 'ws';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -42,6 +43,14 @@ function loadDailySpending(walletDir: string): DailySpending {
   return { date: today, totalSats: 0, transactions: [] };
 }
 
+function writeActivityEvent(event) {
+  const alertDir = path.join(process.env.HOME || '', '.clawdbot', 'bsv-overlay');
+  try {
+    fs.mkdirSync(alertDir, { recursive: true });
+    fs.appendFileSync(path.join(alertDir, 'activity-feed.jsonl'), JSON.stringify({ ...event, ts: Date.now() }) + '\n');
+  } catch {}
+}
+
 function recordSpend(walletDir: string, sats: number, service: string, provider: string) {
   const spending = loadDailySpending(walletDir);
   spending.totalSats += sats;
@@ -132,6 +141,58 @@ function stopAutoImport() {
   }
 }
 
+// Wake the agent via gateway WebSocket JSON-RPC (event-driven, zero polling)
+function wakeAgent(text: string, logger?: any) {
+  try {
+    const ws = new WebSocket('ws://127.0.0.1:18789');
+    const timeout = setTimeout(() => { try { ws.close(); } catch {} }, 5000);
+    ws.on('open', () => {
+      ws.send(JSON.stringify({
+        jsonrpc: '2.0',
+        id: `overlay-wake-${Date.now()}`,
+        method: 'cron.wake',
+        params: { mode: 'now', text },
+      }));
+      clearTimeout(timeout);
+      setTimeout(() => { try { ws.close(); } catch {} }, 500);
+      logger?.info?.('[bsv-overlay] Agent woken via WebSocket');
+    });
+    ws.on('error', (err) => {
+      clearTimeout(timeout);
+      logger?.warn?.('[bsv-overlay] WebSocket wake failed:', err.message);
+    });
+  } catch (err: any) {
+    logger?.warn?.('[bsv-overlay] Wake failed:', err.message);
+  }
+}
+
+// Categorize WebSocket events into notification types
+function categorizeEvent(event) {
+  const base = { ts: Date.now(), from: event.from?.slice(0, 16), fullFrom: event.from };
+  
+  // 💰 Incoming payment — someone paid us for a service
+  if (event.action === 'queued-for-agent' && event.satoshisReceived) {
+    return { ...base, type: 'incoming_payment', emoji: '💰', serviceId: event.serviceId, sats: event.satoshisReceived, requestId: event.id, message: `Received ${event.satoshisReceived} sats for ${event.serviceId}` };
+  }
+  if (event.action === 'fulfilled' && event.satoshisReceived) {
+    return { ...base, type: 'incoming_payment', emoji: '💰', serviceId: event.serviceId, sats: event.satoshisReceived, message: `Received ${event.satoshisReceived} sats for ${event.serviceId} (auto-fulfilled)` };
+  }
+  
+  // 📬 Response received — a service we requested came back
+  if (event.type === 'service-response' && event.action === 'received') {
+    const payload = event.payload || {};
+    return { ...base, type: 'response_received', emoji: '📬', serviceId: payload.serviceId, status: payload.status, message: `Response received for ${payload.serviceId}: ${payload.status}` };
+  }
+  
+  // ❌ Request rejected
+  if (event.action === 'rejected' && event.serviceId) {
+    return { ...base, type: 'request_rejected', emoji: '❌', serviceId: event.serviceId, reason: event.reason, message: `Rejected ${event.serviceId} request: ${event.reason}` };
+  }
+  
+  // Skip pings/pongs and other noise
+  return null;
+}
+
 function startBackgroundService(env, cliPath, logger) {
   if (backgroundProcess) return;
   serviceRunning = true;
@@ -153,22 +214,21 @@ function startBackgroundService(env, cliPath, logger) {
           const event = JSON.parse(line);
           logger?.debug?.(`[bsv-overlay] ${event.event || event.type || 'message'}:`, JSON.stringify(event).slice(0, 200));
           
-          // Detect queued-for-agent events and wake the agent immediately
+          const alertDir = path.join(process.env.HOME || '', '.clawdbot', 'bsv-overlay');
+          fs.mkdirSync(alertDir, { recursive: true });
+          
+          // Detect queued-for-agent events — wake agent via WebSocket
           if (event.action === 'queued-for-agent' && event.serviceId) {
-            logger?.info?.(`[bsv-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}... — waking agent`);
-            
-            // Write alert file for the cron-based fulfillment checker to pick up
-            const alertDir = path.join(process.env.HOME || '', '.clawdbot', 'bsv-overlay');
-            const alertPath = path.join(alertDir, 'pending-alert.jsonl');
+            logger?.info?.(`[bsv-overlay] ⚡ Incoming ${event.serviceId} request from ${event.from?.slice(0, 12)}...`);
+            const wakeText = `⚡ Incoming overlay service request!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nPaid: ${event.satoshisReceived || '?'} sats\n\nFulfill it now:\n1. overlay({ action: "pending-requests" })\n2. Process the ${event.serviceId} request using your capabilities\n3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
+            wakeAgent(wakeText, logger);
+          }
+          
+          // Write payment/activity notifications for ALL significant events
+          const notifEvent = categorizeEvent(event);
+          if (notifEvent) {
             try {
-              fs.mkdirSync(alertDir, { recursive: true });
-              fs.appendFileSync(alertPath, JSON.stringify({
-                requestId: event.id,
-                serviceId: event.serviceId,
-                from: event.from,
-                satoshis: event.satoshisReceived,
-                ts: Date.now(),
-              }) + '\n');
+              fs.appendFileSync(path.join(alertDir, 'activity-feed.jsonl'), JSON.stringify(notifEvent) + '\n');
             } catch {}
           }
         } catch {}
@@ -601,6 +661,9 @@ async function executeOverlayAction(params, config, api) {
     case "pending-requests":
       return await handlePendingRequests(env, cliPath);
     
+    case "activity":
+      return handleActivity();
+    
     case "fulfill":
       return await handleFulfill(params, env, cliPath);
     
@@ -698,8 +761,9 @@ async function handleServiceRequest(params, env, cliPath, config, api) {
         for (const msg of messages) {
           if (msg.type === 'service-response' && msg.from === bestProvider.identityKey) {
             api.logger.info(`Received response from ${bestProvider.agentName}`);
-            // Record the spending
             recordSpend(walletDir, price, service, bestProvider.agentName);
+            writeActivityEvent({ type: 'outgoing_payment', emoji: '💸', sats: price, service, provider: bestProvider.agentName, message: `Paid ${price} sats to ${bestProvider.agentName} for ${service}` });
+            writeActivityEvent({ type: 'response_received', emoji: '📬', service, provider: bestProvider.agentName, status: msg.payload?.status, message: `${service} response received from ${bestProvider.agentName}` });
             return {
               provider: bestProvider.agentName,
               cost: price,
@@ -715,8 +779,8 @@ async function handleServiceRequest(params, env, cliPath, config, api) {
   }
   
   // Don't throw — the response may still arrive via WebSocket
-  // Record the spend since payment was already sent
   recordSpend(walletDir, price, service, bestProvider.agentName);
+  writeActivityEvent({ type: 'outgoing_payment', emoji: '💸', sats: price, service, provider: bestProvider.agentName, message: `Paid ${price} sats to ${bestProvider.agentName} for ${service} (awaiting response)` });
   return {
     provider: bestProvider.agentName,
     cost: price,
@@ -812,6 +876,7 @@ async function handleDirectPay(params, env, cliPath, config) {
 
   // Record the spending
   recordSpend(walletDir, sats, 'direct-payment', identityKey);
+  writeActivityEvent({ type: 'outgoing_payment', emoji: '💸', sats, service: 'direct-payment', provider: identityKey?.slice(0, 16), message: `Direct payment: ${sats} sats sent` });
   
   return output.data;
 }
@@ -1080,6 +1145,19 @@ async function handlePendingRequests(env, cliPath) {
   return output.data;
 }
 
+function handleActivity() {
+  const feedPath = path.join(process.env.HOME || '', '.clawdbot', 'bsv-overlay', 'activity-feed.jsonl');
+  if (!fs.existsSync(feedPath)) return { events: [], count: 0 };
+  
+  const lines = fs.readFileSync(feedPath, 'utf-8').trim().split('\n').filter(Boolean);
+  const events = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  
+  // Clear the feed after reading
+  fs.writeFileSync(feedPath, '');
+  
+  return { events, count: events.length };
+}
+
 async function handleFulfill(params, env, cliPath) {
   const { requestId, recipientKey, serviceId, result } = params;
   if (!requestId || !recipientKey || !serviceId || !result) {
@@ -1091,6 +1169,9 @@ async function handleFulfill(params, env, cliPath) {
   ], { env });
   const output = parseCliOutput(cliResult.stdout);
   if (!output.success) throw new Error(`Fulfill failed: ${output.error}`);
+  
+  writeActivityEvent({ type: 'service_fulfilled', emoji: '✅', serviceId, recipientKey: recipientKey?.slice(0, 16), message: `Fulfilled ${serviceId} request — response sent` });
+  
   return output.data;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johngalt5/bsv-overlay",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Clawdbot BSV Overlay — agent discovery, service marketplace, and micropayments on the BSV blockchain",
   "type": "module",
   "files": [