2020117-agent 0.1.7 → 0.1.8

package/dist/agent.js

@@ -356,6 +356,8 @@ async function delegateAPI(kind, input, bidSats, provider) {
 // --- 4. P2P Swarm Listener ---
 const p2pJobs = new Map();
 const activeSessions = new Map();
+// Backend WebSocket connections for WS tunnel (keyed by ws_id)
+const backendWebSockets = new Map();
 async function startSwarmListener(label) {
     const node = new SwarmNode();
     state.swarmNode = node;
@@ -509,6 +511,87 @@ async function startSwarmListener(label) {
             }
             return;
         }
+        // --- WebSocket tunnel ---
+        if (msg.type === 'ws_open') {
+            const session = findSessionBySocket(socket);
+            if (!session) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'No active session' });
+                return;
+            }
+            const processorUrl = process.env.PROCESSOR;
+            if (!processorUrl || (!processorUrl.startsWith('http://') && !processorUrl.startsWith('https://'))) {
+                node.send(socket, { type: 'ws_open', id: msg.id, ws_id: msg.ws_id, message: 'No HTTP backend configured' });
+                return;
+            }
+            const wsId = msg.ws_id;
+            const wsPath = msg.ws_path || '/';
+            const backendWsUrl = processorUrl.replace(/^http:/, 'ws:').replace(/^https:/, 'wss:').replace(/\/$/, '') + wsPath;
+            console.log(`[${label}] WS ${wsId}: opening ${backendWsUrl}`);
+            try {
+                const backendWs = new WebSocket(backendWsUrl, msg.ws_protocols || []);
+                backendWebSockets.set(wsId, { ws: backendWs, peerId });
+                backendWs.addEventListener('open', () => {
+                    console.log(`[${label}] WS ${wsId}: backend connected`);
+                });
+                backendWs.addEventListener('message', (event) => {
+                    const d = event.data;
+                    if (typeof d === 'string') {
+                        node.send(socket, { type: 'ws_message', id: wsId, ws_id: wsId, data: d, ws_frame_type: 'text' });
+                    }
+                    else if (d instanceof ArrayBuffer) {
+                        node.send(socket, { type: 'ws_message', id: wsId, ws_id: wsId, data: Buffer.from(d).toString('base64'), ws_frame_type: 'binary' });
+                    }
+                    else if (d instanceof Blob) {
+                        d.arrayBuffer().then(ab => {
+                            node.send(socket, { type: 'ws_message', id: wsId, ws_id: wsId, data: Buffer.from(ab).toString('base64'), ws_frame_type: 'binary' });
+                        });
+                    }
+                });
+                backendWs.addEventListener('close', (event) => {
+                    console.log(`[${label}] WS ${wsId}: backend closed (code=${event.code})`);
+                    backendWebSockets.delete(wsId);
+                    node.send(socket, { type: 'ws_close', id: wsId, ws_id: wsId, ws_code: event.code, ws_reason: event.reason || '' });
+                });
+                backendWs.addEventListener('error', () => {
+                    console.error(`[${label}] WS ${wsId}: backend error`);
+                    backendWebSockets.delete(wsId);
+                    node.send(socket, { type: 'ws_close', id: wsId, ws_id: wsId, ws_code: 1011, ws_reason: 'Backend WebSocket error' });
+                });
+            }
+            catch (e) {
+                node.send(socket, { type: 'ws_open', id: msg.id, ws_id: wsId, message: e.message });
+            }
+            return;
+        }
+        if (msg.type === 'ws_message') {
+            const entry = backendWebSockets.get(msg.ws_id || '');
+            if (!entry || entry.ws.readyState !== WebSocket.OPEN)
+                return;
+            try {
+                if (msg.ws_frame_type === 'binary') {
+                    entry.ws.send(Buffer.from(msg.data || '', 'base64'));
+                }
+                else {
+                    entry.ws.send(msg.data || '');
+                }
+            }
+            catch (e) {
+                console.error(`[${label}] WS ${msg.ws_id}: send failed: ${e.message}`);
+            }
+            return;
+        }
+        if (msg.type === 'ws_close') {
+            const entry = backendWebSockets.get(msg.ws_id || '');
+            if (entry) {
+                console.log(`[${label}] WS ${msg.ws_id}: closing backend`);
+                try {
+                    entry.ws.close(msg.ws_code || 1000, msg.ws_reason || '');
+                }
+                catch { }
+                backendWebSockets.delete(msg.ws_id || '');
+            }
+            return;
+        }
         // Session-scoped request (no payment negotiation — session pays per-minute)
         if (msg.type === 'request' && msg.session_id) {
             const session = activeSessions.get(msg.session_id);
@@ -613,6 +696,16 @@ function endSession(node, session, label) {
         clearInterval(session.timeoutTimer);
         session.timeoutTimer = null;
     }
+    // Close all backend WebSockets for this peer
+    for (const [wsId, entry] of backendWebSockets) {
+        if (entry.peerId === session.peerId) {
+            try {
+                entry.ws.close(1001, 'Session ended');
+            }
+            catch { }
+            backendWebSockets.delete(wsId);
+        }
+    }
     node.send(session.socket, {
         type: 'session_end',
         id: session.sessionId,

package/dist/session.js

@@ -42,7 +42,7 @@ for (const arg of process.argv.slice(2)) {
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { queryProviderSkill } from './p2p-customer.js';
 import { mintTokens, splitTokens } from './cashu.js';
-import { randomBytes } from 'crypto';
+import { randomBytes, createHash } from 'crypto';
 import { createServer } from 'http';
 import { createInterface } from 'readline';
 import { mkdirSync, writeFileSync } from 'fs';
@@ -70,6 +70,7 @@ const state = {
     shuttingDown: false,
     pendingRequests: new Map(),
     chunkBuffers: new Map(),
+    activeWebSockets: new Map(),
     outputCounter: 0,
 };
 // --- Helpers ---
@@ -172,6 +173,45 @@ function setupMessageHandler() {
                 warn(`Provider error: ${msg.message}`);
                 break;
             }
+            case 'ws_message': {
+                const browserSocket = state.activeWebSockets.get(msg.ws_id || '');
+                if (!browserSocket || browserSocket.destroyed) {
+                    state.activeWebSockets.delete(msg.ws_id || '');
+                    break;
+                }
+                const isText = msg.ws_frame_type !== 'binary';
+                const payload = isText
+                    ? Buffer.from(msg.data || '', 'utf-8')
+                    : Buffer.from(msg.data || '', 'base64');
+                try {
+                    browserSocket.write(buildWsFrame(payload, isText ? 0x01 : 0x02));
+                }
+                catch { }
+                break;
+            }
+            case 'ws_close': {
+                const browserSocket = state.activeWebSockets.get(msg.ws_id || '');
+                if (browserSocket && !browserSocket.destroyed) {
+                    sendWsClose(browserSocket, msg.ws_code || 1000, msg.ws_reason || '');
+                    browserSocket.end();
+                }
+                state.activeWebSockets.delete(msg.ws_id || '');
+                log(`WS ${msg.ws_id}: closed by provider (code=${msg.ws_code || 1000})`);
+                break;
+            }
+            case 'ws_open': {
+                // Provider failed to open backend WS
+                if (msg.message) {
+                    const browserSocket = state.activeWebSockets.get(msg.ws_id || '');
+                    if (browserSocket && !browserSocket.destroyed) {
+                        sendWsClose(browserSocket, 1011, msg.message);
+                        browserSocket.end();
+                    }
+                    state.activeWebSockets.delete(msg.ws_id || '');
+                    warn(`WS ${msg.ws_id}: provider failed: ${msg.message}`);
+                }
+                break;
+            }
             default:
                 // Unrecognized unsolicited message — ignore
                 break;
@@ -259,9 +299,11 @@ function startHttpProxy() {
                 }, HTTP_TIMEOUT_MS);
                 // Forward response back to browser
                 const respHeaders = { ...(resp.headers || {}) };
-                // Remove hop-by-hop headers
+                // Remove hop-by-hop and size headers (body may differ after P2P relay)
                 delete respHeaders['transfer-encoding'];
                 delete respHeaders['connection'];
+                delete respHeaders['content-length'];
+                delete respHeaders['content-encoding'];
                 res.writeHead(resp.status || 200, respHeaders);
                 res.end(resp.body || '');
             }
@@ -270,6 +312,8 @@ function startHttpProxy() {
                 res.end(JSON.stringify({ error: e.message }));
             }
         });
+        // Enable WebSocket tunneling on the same server
+        setupWebSocketProxy(server);
         server.on('error', (err) => {
             if (!state.httpServer) {
                 reject(err);
@@ -284,6 +328,172 @@ function startHttpProxy() {
         });
     });
 }
+// --- 4b. WebSocket tunnel (RFC 6455 minimal codec) ---
+function wsAcceptKey(clientKey) {
+    return createHash('sha1')
+        .update(clientKey + '258EAFA5-E914-47DA-95CA-5AB5DB63F35E')
+        .digest('base64');
+}
+function buildWsFrame(data, opcode) {
+    const len = data.length;
+    let header;
+    if (len < 126) {
+        header = Buffer.alloc(2);
+        header[0] = 0x80 | opcode;
+        header[1] = len;
+    }
+    else if (len < 65536) {
+        header = Buffer.alloc(4);
+        header[0] = 0x80 | opcode;
+        header[1] = 126;
+        header.writeUInt16BE(len, 2);
+    }
+    else {
+        header = Buffer.alloc(10);
+        header[0] = 0x80 | opcode;
+        header[1] = 127;
+        header.writeUInt32BE(0, 2);
+        header.writeUInt32BE(len, 6);
+    }
+    return Buffer.concat([header, data]);
+}
+function sendWsClose(socket, code, reason) {
+    const reasonBuf = Buffer.from(reason, 'utf-8');
+    const payload = Buffer.alloc(2 + reasonBuf.length);
+    payload.writeUInt16BE(code, 0);
+    reasonBuf.copy(payload, 2);
+    try {
+        socket.write(buildWsFrame(payload, 0x08));
+    }
+    catch { }
+}
+class WsFrameParser {
+    buf = Buffer.alloc(0);
+    onFrame = () => { };
+    feed(chunk) {
+        this.buf = Buffer.concat([this.buf, chunk]);
+        while (this.parseOne()) { }
+    }
+    parseOne() {
+        if (this.buf.length < 2)
+            return false;
+        const byte1 = this.buf[1];
+        const masked = (byte1 & 0x80) !== 0;
+        let payloadLen = byte1 & 0x7f;
+        let offset = 2;
+        if (payloadLen === 126) {
+            if (this.buf.length < 4)
+                return false;
+            payloadLen = this.buf.readUInt16BE(2);
+            offset = 4;
+        }
+        else if (payloadLen === 127) {
+            if (this.buf.length < 10)
+                return false;
+            payloadLen = this.buf.readUInt32BE(6);
+            offset = 10;
+        }
+        const maskSize = masked ? 4 : 0;
+        const totalLen = offset + maskSize + payloadLen;
+        if (this.buf.length < totalLen)
+            return false;
+        const opcode = this.buf[0] & 0x0f;
+        let payload;
+        if (masked) {
+            const mask = this.buf.subarray(offset, offset + 4);
+            payload = Buffer.alloc(payloadLen);
+            for (let i = 0; i < payloadLen; i++) {
+                payload[i] = this.buf[offset + 4 + i] ^ mask[i & 3];
+            }
+        }
+        else {
+            payload = Buffer.from(this.buf.subarray(offset, offset + payloadLen));
+        }
+        this.buf = Buffer.from(this.buf.subarray(totalLen));
+        this.onFrame(opcode, payload);
+        return true;
+    }
+}
+function setupWebSocketProxy(server) {
+    server.on('upgrade', (req, socket, head) => {
+        if (!state.sessionId || state.shuttingDown) {
+            socket.end('HTTP/1.1 503 Service Unavailable\r\n\r\n');
+            return;
+        }
+        const wsKey = req.headers['sec-websocket-key'];
+        if (!wsKey) {
+            socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+            return;
+        }
+        const wsId = randomBytes(4).toString('hex');
+        const path = req.url || '/';
+        const protocols = req.headers['sec-websocket-protocol']
+            ? req.headers['sec-websocket-protocol'].split(',').map(s => s.trim())
+            : undefined;
+        log(`WS ${wsId}: upgrade ${path}`);
+        // Complete handshake with browser
+        const lines = [
+            'HTTP/1.1 101 Switching Protocols',
+            'Upgrade: websocket',
+            'Connection: Upgrade',
+            `Sec-WebSocket-Accept: ${wsAcceptKey(wsKey)}`,
+        ];
+        if (protocols && protocols.length > 0)
+            lines.push(`Sec-WebSocket-Protocol: ${protocols[0]}`);
+        socket.write(lines.join('\r\n') + '\r\n\r\n');
+        state.activeWebSockets.set(wsId, socket);
+        // Tell provider to open backend WS
+        state.node.send(state.socket, {
+            type: 'ws_open',
+            id: wsId,
+            ws_id: wsId,
+            session_id: state.sessionId,
+            ws_path: path,
+            ws_protocols: protocols,
+        });
+        // Parse frames from browser → relay to provider
+        const parser = new WsFrameParser();
+        parser.onFrame = (opcode, payload) => {
+            if (opcode === 0x08) { // close
+                const code = payload.length >= 2 ? payload.readUInt16BE(0) : 1000;
+                state.node.send(state.socket, { type: 'ws_close', id: wsId, ws_id: wsId, ws_code: code, ws_reason: payload.length > 2 ? payload.subarray(2).toString('utf-8') : '' });
+                state.activeWebSockets.delete(wsId);
+                return;
+            }
+            if (opcode === 0x09) { // ping → pong
+                try {
+                    socket.write(buildWsFrame(payload, 0x0a));
+                }
+                catch { }
+                return;
+            }
+            if (opcode === 0x0a)
+                return; // pong — ignore
+            // text (0x01) or binary (0x02)
+            const isText = opcode === 0x01;
+            state.node.send(state.socket, {
+                type: 'ws_message',
+                id: wsId,
+                ws_id: wsId,
+                data: isText ? payload.toString('utf-8') : payload.toString('base64'),
+                ws_frame_type: isText ? 'text' : 'binary',
+            });
+        };
+        socket.on('data', (chunk) => parser.feed(chunk));
+        if (head.length > 0)
+            parser.feed(head);
+        socket.on('close', () => {
+            if (state.activeWebSockets.has(wsId)) {
+                state.activeWebSockets.delete(wsId);
+                try {
+                    state.node.send(state.socket, { type: 'ws_close', id: wsId, ws_id: wsId, ws_code: 1001, ws_reason: 'Browser disconnected' });
+                }
+                catch { }
+            }
+        });
+        socket.on('error', () => { state.activeWebSockets.delete(wsId); });
+    });
+}
 // --- 5. CLI REPL ---
 function startRepl() {
     // Skip REPL when stdin is not a TTY (e.g. background process, piped input)
@@ -494,6 +704,12 @@ async function endSession() {
         state.pendingRequests.delete(id);
     }
     state.chunkBuffers.clear();
+    // Close all WebSocket tunnels
+    for (const [wsId, socket] of state.activeWebSockets) {
+        sendWsClose(socket, 1001, 'Session ending');
+        socket.end();
+    }
+    state.activeWebSockets.clear();
     // Send session_end
     if (state.node && state.socket && state.sessionId) {
         const duration = elapsedSeconds();

package/dist/swarm.d.ts

@@ -24,7 +24,7 @@
 import Hyperswarm from 'hyperswarm';
 import { EventEmitter } from 'events';
 export interface SwarmMessage {
-    type: 'request' | 'accepted' | 'chunk' | 'result' | 'error' | 'payment' | 'payment_ack' | 'offer' | 'pay_required' | 'stop' | 'skill_request' | 'skill_response' | 'session_start' | 'session_ack' | 'session_tick' | 'session_tick_ack' | 'session_end' | 'http_request' | 'http_response';
+    type: 'request' | 'accepted' | 'chunk' | 'result' | 'error' | 'payment' | 'payment_ack' | 'offer' | 'pay_required' | 'stop' | 'skill_request' | 'skill_response' | 'session_start' | 'session_ack' | 'session_tick' | 'session_tick_ack' | 'session_end' | 'http_request' | 'http_response' | 'ws_open' | 'ws_message' | 'ws_close';
     id: string;
     kind?: number;
     input?: string;
@@ -52,6 +52,12 @@ export interface SwarmMessage {
     status?: number;
     chunk_index?: number;
     chunk_total?: number;
+    ws_id?: string;
+    ws_path?: string;
+    ws_protocols?: string[];
+    ws_frame_type?: 'text' | 'binary';
+    ws_code?: number;
+    ws_reason?: string;
 }
 /**
  * Create a deterministic topic hash from a service kind number.

package/dist/swarm.js

@@ -51,6 +51,7 @@ export class SwarmNode extends EventEmitter {
                 const combined = existing + buf.toString();
                 const lines = combined.split('\n');
                 // Last element is incomplete (or empty after trailing newline)
+                // Last element is incomplete (or empty after trailing newline)
                 this.buffers.set(peerId, lines.pop());
                 for (const line of lines) {
                     if (!line.trim())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "2020117-agent",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "2020117 agent runtime — API polling + Hyperswarm P2P + Cashu streaming payments",
   "type": "module",
   "bin": {