2020117-agent 0.6.6 → 0.6.8

package/dist/agent.js

@@ -85,7 +85,7 @@ import { SwarmNode, topicFromKind } from './swarm.js';
 import { createProcessor } from './processor.js';
 import { generateInvoice } from './lnurl.js';
 import { generateKeypair, loadSovereignKeys, saveSovereignKeys, loadAgentName, signEvent, signEventWithPow, nip44Encrypt, nip44Decrypt, pubkeyFromPrivkey, RelayPool, } from './nostr.js';
-import { parseNwcUri, nwcGetBalance, nwcPayLightningAddress } from './nwc.js';
+import { parseNwcUri, nwcGetBalance, nwcPayLightningAddress, nwcMakeInvoice } from './nwc.js';
 import { readFileSync } from 'fs';
 import WebSocket from 'ws';
 // Polyfill global WebSocket for Node.js < 22 (needed by ws tunnel)
@@ -827,11 +827,21 @@ function markSeen(eventId) {
     }
     return true;
 }
-/** Send a billing tick to the customer — generate Lightning invoice */
+/** Send a billing tick to the customer — generate Lightning invoice.
+ *  Prefers NWC make_invoice (if nwc_uri configured), falls back to LNURL-pay. */
 async function sendBillingTick(node, session, amount, label) {
     const tickId = randomBytes(4).toString('hex');
     try {
-        const bolt11 = await generateInvoice(LIGHTNING_ADDRESS, amount);
+        let bolt11;
+        if (state.nwcParsed) {
+            // NWC make_invoice: wallet generates invoice directly — no lightning address needed
+            const result = await nwcMakeInvoice(state.nwcParsed, amount * 1000, `2020117 session ${session.sessionId}`);
+            bolt11 = result.bolt11;
+        }
+        else {
+            // Fallback: LNURL-pay via lightning address
+            bolt11 = await generateInvoice(LIGHTNING_ADDRESS, amount);
+        }
         node.send(session.socket, {
             type: 'session_tick',
             id: tickId,
@@ -872,8 +882,8 @@ async function startSwarmListener(label) {
         if (msg.type === 'session_start') {
             const processorUrl = process.env.PROCESSOR || '';
             const proxyMode = processorUrl.startsWith('http://') || processorUrl.startsWith('https://');
-            if (!proxyMode && !LIGHTNING_ADDRESS) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'Provider Lightning Address not configured' });
+            if (!proxyMode && !LIGHTNING_ADDRESS && !state.nwcParsed) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'Provider payment not configured (need --lightning-address or --nwc)' });
                 return;
             }
             const paymentMethod = 'invoice';
@@ -909,9 +919,10 @@ async function startSwarmListener(label) {
                 sats_per_minute: satsPerMinute,
                 payment_method: paymentMethod,
                 pubkey: state.sovereignKeys?.pubkey,
+                proxy_mode: proxyMode,
             });
             if (proxyMode) {
-                if (billingAmount <= 0 || !LIGHTNING_ADDRESS) {
+                if (billingAmount <= 0 || (!LIGHTNING_ADDRESS && !state.nwcParsed)) {
                     // Free proxy — open TCP pipe immediately
                     startTcpProxy(session, node, processorUrl, label);
                 }

package/dist/session.js

@@ -50,6 +50,7 @@ import { randomBytes } from 'crypto';
 import { createServer } from 'http';
 import { createInterface } from 'readline';
 import { mkdirSync, writeFileSync } from 'fs';
+import * as net from 'net';
 import { WebSocketServer, WebSocket as WsWebSocket } from 'ws';
 // --- Config ---
 const KIND = Number(process.env.DVM_KIND) || 5200;
@@ -87,6 +88,8 @@ const state = {
     startedAt: 0,
     httpServer: null,
     shuttingDown: false,
+    isProxyMode: false,
+    proxyReady: null,
     pendingRequests: new Map(),
     chunkBuffers: new Map(),
     activeWebSockets: new Map(),
@@ -195,7 +198,12 @@ function setupMessageHandler() {
                     try {
                         const { preimage } = await nwcPayInvoice(nwcParsed, msg.bolt11);
                         state.totalSpent += amount;
-                        log(`Paid ${amount} sats via NWC (total: ${state.totalSpent}, ~${estimatedMinutesLeft()} min left)`);
+                        if (state.isProxyMode) {
+                            log(`Paid ${amount} sats — activating TCP proxy...`);
+                        }
+                        else {
+                            log(`Paid ${amount} sats via NWC (total: ${state.totalSpent}, ~${estimatedMinutesLeft()} min left)`);
+                        }
                         state.node.send(state.socket, {
                             type: 'session_tick_ack',
                             id: msg.id,
@@ -203,6 +211,11 @@ function setupMessageHandler() {
                             preimage,
                             amount,
                         });
+                        // Proxy mode: payment done, signal TCP pipe is ready
+                        if (state.isProxyMode && state.proxyReady) {
+                            state.proxyReady();
+                            state.proxyReady = null;
+                        }
                     }
                     catch (e) {
                         warn(`NWC invoice payment failed: ${e.message} — ending session`);
@@ -351,6 +364,57 @@ function startHttpProxy() {
         });
     });
 }
+// --- 4a. TCP proxy (proxy mode) ---
+// After payment, the Hyperswarm socket becomes a raw TCP pipe to provider's backend.
+// We start a local TCP server and forward bytes between local clients and the provider socket.
+function startTcpProxy() {
+    return new Promise((resolve, reject) => {
+        const rawSocket = state.socket;
+        // Remove SwarmNode's JSON framing — from here on it's raw bytes
+        rawSocket.removeAllListeners('data');
+        let currentClient = null;
+        // Forward provider data to whatever client is currently connected
+        rawSocket.on('data', (chunk) => {
+            if (currentClient && !currentClient.destroyed) {
+                currentClient.write(chunk);
+            }
+        });
+        rawSocket.on('end', () => {
+            if (currentClient && !currentClient.destroyed)
+                currentClient.end();
+        });
+        rawSocket.on('error', (err) => {
+            warn(`Provider socket error: ${err.message}`);
+            if (currentClient && !currentClient.destroyed)
+                currentClient.destroy();
+            cleanup();
+        });
+        const server = net.createServer((clientSocket) => {
+            if (currentClient && !currentClient.destroyed) {
+                // Only one connection at a time — reject new ones
+                clientSocket.destroy();
+                return;
+            }
+            currentClient = clientSocket;
+            clientSocket.on('data', (chunk) => {
+                if (!rawSocket.destroyed)
+                    rawSocket.write(chunk);
+            });
+            clientSocket.on('close', () => { currentClient = null; });
+            clientSocket.on('error', () => { currentClient = null; });
+        });
+        server.on('error', (err) => {
+            if (!state.httpServer)
+                reject(err);
+            else
+                warn(`TCP proxy error: ${err.message}`);
+        });
+        server.listen(PORT, () => {
+            state.httpServer = server;
+            resolve();
+        });
+    });
+}
 // --- 4b. WebSocket tunnel (via ws library) ---
 function setupWebSocketProxy(server) {
     const wss = new WebSocketServer({ noServer: true });
@@ -772,21 +836,43 @@ async function main() {
     state.sessionId = ackResp.session_id;
     state.startedAt = Date.now();
     providerPubkey = ackResp.pubkey || null;
+    state.isProxyMode = !!ackResp.proxy_mode;
     // If the provider dictated a different rate, use it
     if (ackResp.sats_per_minute && ackResp.sats_per_minute !== satsPerMinute) {
         state.satsPerMinute = ackResp.sats_per_minute;
         log(`Provider adjusted rate: ${ackResp.sats_per_minute} sats/min`);
     }
     log(`Session started: ${state.sessionId}`);
-    log(`Billing: ${state.satsPerMinute} sats/min via ${paymentMethod}`);
-    // 6. Start HTTP proxy
-    try {
-        await startHttpProxy();
-        log(`Web proxy ready at http://localhost:${PORT}`);
+    if (state.isProxyMode) {
+        log(`Mode: TCP proxy (one-time fee, raw HTTP passthrough)`);
     }
-    catch (e) {
-        warn(`Failed to start HTTP proxy on port ${PORT}: ${e.message}`);
-        warn('Continuing without HTTP proxy');
+    else {
+        log(`Billing: ${state.satsPerMinute} sats/min via ${paymentMethod}`);
+    }
+    // 6. Start proxy
+    if (state.isProxyMode) {
+        // Proxy mode: wait for payment, then switch socket to raw TCP pipe
+        const proxyReadyPromise = new Promise(resolve => { state.proxyReady = resolve; });
+        log('Waiting for invoice from provider...');
+        try {
+            await proxyReadyPromise;
+            await startTcpProxy();
+            log(`TCP proxy ready at http://localhost:${PORT}`);
+        }
+        catch (e) {
+            warn(`Failed to start TCP proxy on port ${PORT}: ${e.message}`);
+            warn('Continuing without proxy');
+        }
+    }
+    else {
+        try {
+            await startHttpProxy();
+            log(`Web proxy ready at http://localhost:${PORT}`);
+        }
+        catch (e) {
+            warn(`Failed to start HTTP proxy on port ${PORT}: ${e.message}`);
+            warn('Continuing without HTTP proxy');
+        }
     }
     // 7. Show ready message and start REPL
     log("Type 'help' for commands");

package/dist/swarm.d.ts

@@ -47,6 +47,7 @@ export interface SwarmMessage {
     duration_s?: number;
     payment_method?: 'invoice';
     pubkey?: string;
+    proxy_mode?: boolean;
     bolt11?: string;
     preimage?: string;
     method?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "2020117-agent",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "2020117 agent runtime — Nostr-native relay subscription + Hyperswarm P2P + Lightning payments",
   "type": "module",
   "bin": {