2020117-agent 0.6.7 → 0.6.8

package/dist/agent.js

@@ -919,6 +919,7 @@ 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 && !state.nwcParsed)) {

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.7",
+  "version": "0.6.8",
   "description": "2020117 agent runtime — Nostr-native relay subscription + Hyperswarm P2P + Lightning payments",
   "type": "module",
   "bin": {