webhookdrop-tunnel 1.0.3 → 1.0.9

package/bin/tunnel.js

@@ -34,7 +34,7 @@ try {
     };
 }
 
-const VERSION = '1.0.3';
+const VERSION = '1.0.8';
 const DEFAULT_SERVER = 'wss://webhookdrop.app';
 const POOL_SIZE = 20;  // Number of WebSocket connections
 const PING_INTERVAL = 10000;  // 10 seconds
@@ -113,7 +113,7 @@ async function forwardRequest(data) {
                 // Request uncompressed content to avoid encoding issues
                 'accept-encoding': 'identity'
             },
-            timeout: 30000
+            timeout: 300000  // 5 minutes for very large files like n8n's nodes.json
         };
 
         const req = httpModule.request(requestOptions, (res) => {
@@ -122,13 +122,28 @@ async function forwardRequest(data) {
             res.on('data', (chunk) => chunks.push(chunk));
             res.on('end', () => {
                 const buffer = Buffer.concat(chunks);
+                const contentType = res.headers['content-type'] || '';
+
+                // Determine if content is text-based (like OnLocal approach)
+                const isText = contentType.includes('text/') ||
+                    contentType.includes('json') ||
+                    contentType.includes('javascript') ||
+                    contentType.includes('xml') ||
+                    contentType.includes('css');
+
+                // Use structured body format: {type, data}
+                let body;
+                if (isText) {
+                    body = { type: 'text', data: buffer.toString('utf-8') };
+                } else {
+                    body = { type: 'binary', data: buffer.toString('base64') };
+                }
+
                 resolve({
                     success: true,
                     status_code: res.statusCode,
                     headers: res.headers,
-                    // Send as base64 to preserve binary data
-                    body: buffer.toString('base64'),
-                    body_encoding: 'base64'
+                    body: body
                 });
             });
         });
@@ -159,6 +174,8 @@ async function forwardRequest(data) {
 
 // Connection pool
 const connections = new Map();
+// Local WebSocket sessions for passthrough
+const localWsSessions = new Map();
 let connectedCount = 0;
 let totalRequests = 0;
 let isShuttingDown = false;
@@ -228,6 +245,12 @@ function createConnection(connectionId) {
                 // Forward to local server
                 const response = await forwardRequest(requestData);
 
+                // Log response size for debugging large files
+                const bodySize = response.body?.data?.length || 0;
+                if (bodySize > 100000) {
+                    console.log(`${timestamp()} ${chalk.yellow('⚠')} Large response: ${Math.round(bodySize / 1024)}KB`);
+                }
+
                 // Send response back
                 const responseMessage = {
                     type: message.type === 'webhook_request' ? 'webhook_response' : 'http_response',
@@ -235,13 +258,132 @@ function createConnection(connectionId) {
                     response: response
                 };
 
-                if (ws.readyState === WebSocket.OPEN) {
-                    ws.send(JSON.stringify(responseMessage));
+                try {
+                    const jsonStr = JSON.stringify(responseMessage);
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(jsonStr);
+                    }
+                } catch (jsonErr) {
+                    console.error(`${timestamp()} ${chalk.red('✗')} JSON serialize error: ${jsonErr.message}`);
+                    // Send error response instead
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: 'http_response',
+                            request_id: requestId,
+                            response: { success: false, status_code: 500, error: 'Response too large to serialize' }
+                        }));
+                    }
                 }
 
                 const statusColor = response.success && response.status_code < 400 ? chalk.green : chalk.red;
                 console.log(`${timestamp()} ${statusColor('←')} ${response.status_code || 502} ${response.success ? 'OK' : response.error || 'Error'}`);
             }
+
+            // WebSocket passthrough: connect to local WebSocket
+            else if (message.type === 'ws_connect') {
+                const sessionId = message.data?.session_id || message.session_id;
+                const wsPath = message.data?.path || message.path || '/';
+                const wsQuery = message.data?.query || message.query || '';
+                const requestId = message.request_id;
+
+                console.log(`${timestamp()} ${chalk.magenta('⚡')} WS Connect: ${wsPath}`);
+
+                try {
+                    // Build local WebSocket URL
+                    const localWsUrl = new URL(wsPath, options.local);
+                    localWsUrl.protocol = localWsUrl.protocol.replace('http', 'ws');
+                    if (wsQuery) {
+                        localWsUrl.search = wsQuery;
+                    }
+
+                    // Connect to local WebSocket
+                    const localWs = new WebSocket(localWsUrl.toString());
+
+                    localWs.on('open', () => {
+                        console.log(`${timestamp()} ${chalk.green('✓')} WS Connected: ${sessionId.slice(0, 8)}`);
+                        localWsSessions.set(sessionId, { ws: localWs, tunnelWs: ws });
+
+                        // Send success response
+                        if (ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify({
+                                type: 'http_response',
+                                request_id: requestId,
+                                response: { success: true }
+                            }));
+                        }
+                    });
+
+                    localWs.on('message', (data) => {
+                        // Forward message from local WebSocket to server
+                        if (ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify({
+                                type: 'ws_message',
+                                session_id: sessionId,
+                                message: data.toString()
+                            }));
+                        }
+                    });
+
+                    localWs.on('close', () => {
+                        console.log(`${timestamp()} ${chalk.yellow('○')} WS Closed: ${sessionId.slice(0, 8)}`);
+                        localWsSessions.delete(sessionId);
+
+                        // Notify server
+                        if (ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify({
+                                type: 'ws_closed',
+                                session_id: sessionId
+                            }));
+                        }
+                    });
+
+                    localWs.on('error', (err) => {
+                        console.log(`${timestamp()} ${chalk.red('✗')} WS Error: ${err.message}`);
+                        localWsSessions.delete(sessionId);
+
+                        // Send error response
+                        if (ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify({
+                                type: 'http_response',
+                                request_id: requestId,
+                                response: { success: false, error: err.message }
+                            }));
+                        }
+                    });
+                } catch (e) {
+                    console.log(`${timestamp()} ${chalk.red('✗')} WS Connect Error: ${e.message}`);
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: 'http_response',
+                            request_id: requestId,
+                            response: { success: false, error: e.message }
+                        }));
+                    }
+                }
+            }
+
+            // WebSocket passthrough: forward message to local WebSocket
+            else if (message.type === 'ws_message') {
+                const sessionId = message.data?.session_id || message.session_id;
+                const wsMessage = message.data?.message || message.message;
+
+                const session = localWsSessions.get(sessionId);
+                if (session && session.ws.readyState === WebSocket.OPEN) {
+                    session.ws.send(wsMessage);
+                }
+            }
+
+            // WebSocket passthrough: close local WebSocket
+            else if (message.type === 'ws_close') {
+                const sessionId = message.data?.session_id || message.session_id;
+
+                const session = localWsSessions.get(sessionId);
+                if (session) {
+                    session.ws.close();
+                    localWsSessions.delete(sessionId);
+                    console.log(`${timestamp()} ${chalk.yellow('○')} WS Close: ${sessionId.slice(0, 8)}`);
+                }
+            }
         } catch (e) {
             console.error(`${timestamp()} ${chalk.red('Error processing message:')} ${e.message}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webhookdrop-tunnel",
-  "version": "1.0.3",
+  "version": "1.0.9",
   "description": "Forward webhooks from WebhookDrop to your local development server",
   "main": "index.js",
   "bin": {