webhookdrop-tunnel 1.0.1 → 1.0.9

package/bin/tunnel.js

@@ -4,6 +4,7 @@
  * WebhookDrop Tunnel Client
  * 
  * Forwards webhooks from WebhookDrop to your local development server.
+ * Uses connection pooling for high-concurrency SPA tunneling.
  * 
  * Usage:
  *   npx webhookdrop-tunnel --token YOUR_TOKEN --local http://localhost:3000
@@ -28,12 +29,15 @@ try {
         blue: (s) => s,
         gray: (s) => s,
         bold: (s) => s,
-        cyan: (s) => s
+        cyan: (s) => s,
+        magenta: (s) => s
     };
 }
 
-const VERSION = '1.0.0';
+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
 
 // Parse command line arguments
 program
@@ -44,9 +48,11 @@ program
     .requiredOption('-l, --local <url>', 'Local server URL to forward webhooks to (e.g., http://localhost:3000)')
     .option('-e, --endpoint <id>', 'Endpoint ID (usually embedded in token)')
     .option('-s, --server <url>', 'WebhookDrop server URL', DEFAULT_SERVER)
+    .option('-p, --pool <size>', 'Connection pool size', String(POOL_SIZE))
     .parse(process.argv);
 
 const options = program.opts();
+const poolSize = parseInt(options.pool) || POOL_SIZE;
 
 // Validate local URL
 let localUrl;
@@ -75,21 +81,11 @@ if (!endpointId) {
     process.exit(1);
 }
 
-// Build WebSocket URL
-const wsUrl = `${options.server}/ws/tunnel/${endpointId}?token=${encodeURIComponent(options.token)}&local_url=${encodeURIComponent(options.local)}`;
-
-// Format timestamp
+// Timestamp helper
 function timestamp() {
     return chalk.gray(new Date().toLocaleTimeString());
 }
 
-// Print banner
-console.log('');
-console.log(chalk.cyan('╔══════════════════════════════════════════╗'));
-console.log(chalk.cyan('║') + chalk.bold('     WebhookDrop Tunnel Client            ') + chalk.cyan('║'));
-console.log(chalk.cyan('╚══════════════════════════════════════════╝'));
-console.log('');
-
 // Forward HTTP request to local server
 async function forwardRequest(data) {
     return new Promise((resolve) => {
@@ -117,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) => {
@@ -126,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
                 });
             });
         });
@@ -161,29 +172,53 @@ async function forwardRequest(data) {
     });
 }
 
-// Main tunnel connection
-function connect() {
-    console.log(`${timestamp()} Connecting to WebhookDrop...`);
-    console.log(`${timestamp()} Forwarding to: ${chalk.green(options.local)}`);
-    console.log('');
+// Connection pool
+const connections = new Map();
+// Local WebSocket sessions for passthrough
+const localWsSessions = new Map();
+let connectedCount = 0;
+let totalRequests = 0;
+let isShuttingDown = false;
 
-    const ws = new WebSocket(wsUrl.replace('https://', 'wss://').replace('http://', 'ws://'));
+// Create a single WebSocket connection
+function createConnection(connectionId) {
+    const wsUrl = `${options.server}/ws/tunnel/${endpointId}?token=${encodeURIComponent(options.token)}&local_url=${encodeURIComponent(options.local)}&connection_id=${connectionId}`;
 
+    const ws = new WebSocket(wsUrl.replace('https://', 'wss://').replace('http://', 'ws://'));
     let pingInterval;
+    let isConnected = false;
 
     ws.on('open', () => {
-        console.log(`${timestamp()} ${chalk.green('✓')} ${chalk.bold('Tunnel connected!')}`);
-        console.log(`${timestamp()}   Endpoint: ${chalk.cyan(endpointId.substring(0, 8))}...`);
-        console.log('');
-        console.log(`${timestamp()} ${chalk.yellow('Waiting for webhooks...')} (Press Ctrl+C to stop)`);
-        console.log('');
+        isConnected = true;
+        connectedCount++;
+
+        if (connectedCount === 1) {
+            // First connection - show banner
+            console.log('');
+            console.log(chalk.cyan('╔══════════════════════════════════════════════════╗'));
+            console.log(chalk.cyan('║') + chalk.bold('     WebhookDrop Tunnel Client (Pool Mode)       ') + chalk.cyan('║'));
+            console.log(chalk.cyan('╚══════════════════════════════════════════════════╝'));
+            console.log('');
+            console.log(`${timestamp()} Forwarding to: ${chalk.cyan(options.local)}`);
+            console.log('');
+        }
 
-        // Send ping every 25 seconds to keep connection alive
+        if (connectedCount === poolSize) {
+            console.log(`${timestamp()} ${chalk.green('✓')} ${chalk.bold(`All ${poolSize} connections established!`)}`);
+            console.log(`${timestamp()}   Endpoint: ${chalk.cyan(endpointId.substring(0, 8))}...`);
+            console.log('');
+            console.log(`${timestamp()} ${chalk.yellow('Waiting for requests...')} (Press Ctrl+C to stop)`);
+            console.log('');
+        }
+
+        // Send ping every 10 seconds to keep connection alive
         pingInterval = setInterval(() => {
             if (ws.readyState === WebSocket.OPEN) {
                 ws.send(JSON.stringify({ type: 'ping' }));
             }
-        }, 25000);
+        }, PING_INTERVAL);
+
+        connections.set(connectionId, { ws, pingInterval, isConnected: true });
     });
 
     ws.on('message', async (data) => {
@@ -191,82 +226,230 @@ function connect() {
             const message = JSON.parse(data.toString());
 
             if (message.type === 'connected') {
-                // Initial connection confirmation - already handled in 'open'
+                // Initial connection confirmation
                 return;
             }
 
             if (message.type === 'pong') {
-                // Ignore pong responses
+                // Heartbeat response - connection healthy
                 return;
             }
 
             if (message.type === 'webhook_request' || message.type === 'http_request') {
                 const requestId = message.request_id;
-                const requestData = message.data || message;
-                const method = requestData.method || 'POST';
-                const path = requestData.path || '/';
+                const requestData = message.data || {};
 
-                console.log(`${timestamp()} ${chalk.blue('→')} ${chalk.bold(method)} ${path}`);
+                totalRequests++;
+                console.log(`${timestamp()} ${chalk.blue('→')} ${requestData.method || 'POST'} ${requestData.path || '/'}`);
 
                 // Forward to local server
                 const response = await forwardRequest(requestData);
 
-                if (response.success) {
-                    console.log(`${timestamp()} ${chalk.green('←')} ${response.status_code} OK`);
-                } else {
-                    console.log(`${timestamp()} ${chalk.red('←')} ${response.status_code} ${response.error}`);
+                // 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 to server
-                ws.send(JSON.stringify({
-                    type: 'webhook_response',
+                // Send response back
+                const responseMessage = {
+                    type: message.type === 'webhook_request' ? 'webhook_response' : 'http_response',
                     request_id: requestId,
                     response: response
-                }));
+                };
+
+                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'}`);
             }
 
-            if (message.type === 'error') {
-                console.log(`${timestamp()} ${chalk.red('Server error:')} ${message.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 parsing message:')} ${e.message}`);
+            console.error(`${timestamp()} ${chalk.red('Error processing message:')} ${e.message}`);
         }
     });
 
-    ws.on('close', (code, reason) => {
-        clearInterval(pingInterval);
-        console.log('');
-        console.log(`${timestamp()} ${chalk.yellow('Connection closed:')} ${reason || 'Unknown reason'}`);
+    ws.on('close', () => {
+        if (isConnected) {
+            connectedCount--;
+        }
+        isConnected = false;
 
-        // Reconnect after 5 seconds
-        console.log(`${timestamp()} Reconnecting in 5 seconds...`);
-        setTimeout(connect, 5000);
+        if (pingInterval) {
+            clearInterval(pingInterval);
+        }
+
+        connections.delete(connectionId);
+
+        if (!isShuttingDown) {
+            // Reconnect after delay
+            setTimeout(() => {
+                if (!isShuttingDown) {
+                    createConnection(connectionId);
+                }
+            }, 2000);
+        }
     });
 
     ws.on('error', (error) => {
-        clearInterval(pingInterval);
-
-        if (error.message.includes('401')) {
-            console.error(`${timestamp()} ${chalk.red('❌ Authentication failed. Please check your token.')}`);
-            process.exit(1);
-        } else if (error.message.includes('404')) {
-            console.error(`${timestamp()} ${chalk.red('❌ Endpoint not found. Please check your endpoint ID.')}`);
-            process.exit(1);
-        } else {
+        // Suppress error logging for normal reconnection cases
+        if (!isShuttingDown && error.code !== 'ECONNREFUSED') {
             console.error(`${timestamp()} ${chalk.red('Connection error:')} ${error.message}`);
-            console.log(`${timestamp()} Reconnecting in 5 seconds...`);
-            setTimeout(connect, 5000);
         }
     });
+
+    return ws;
 }
 
-// Handle graceful shutdown
-process.on('SIGINT', () => {
+// Start connection pool
+console.log('');
+console.log(`${timestamp()} Starting connection pool (${poolSize} connections)...`);
+
+for (let i = 0; i < poolSize; i++) {
+    const connectionId = `conn-${i.toString().padStart(2, '0')}`;
+    setTimeout(() => createConnection(connectionId), i * 100);  // Stagger connections
+}
+
+// Handle shutdown
+function shutdown() {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
     console.log('');
-    console.log(`${timestamp()} ${chalk.yellow('Shutting down tunnel...')}`);
-    process.exit(0);
-});
+    console.log(`${timestamp()} Shutting down tunnel...`);
+    console.log(`${timestamp()} Total requests handled: ${totalRequests}`);
+
+    for (const [id, conn] of connections) {
+        if (conn.pingInterval) {
+            clearInterval(conn.pingInterval);
+        }
+        if (conn.ws && conn.ws.readyState === WebSocket.OPEN) {
+            conn.ws.close();
+        }
+    }
+
+    setTimeout(() => process.exit(0), 1000);
+}
 
-// Start the tunnel
-connect();
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/package.json

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