webhookdrop-tunnel 1.0.0 → 1.0.3

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.3';
 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) => {
@@ -113,20 +109,26 @@ async function forwardRequest(data) {
             method: method,
             headers: {
                 ...headers,
-                'host': targetUrl.host
+                'host': targetUrl.host,
+                // Request uncompressed content to avoid encoding issues
+                'accept-encoding': 'identity'
             },
             timeout: 30000
         };
 
         const req = httpModule.request(requestOptions, (res) => {
-            let responseBody = '';
-            res.on('data', (chunk) => responseBody += chunk);
+            // Collect response as Buffer chunks to handle binary data correctly
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
             res.on('end', () => {
+                const buffer = Buffer.concat(chunks);
                 resolve({
                     success: true,
                     status_code: res.statusCode,
                     headers: res.headers,
-                    body: responseBody
+                    // Send as base64 to preserve binary data
+                    body: buffer.toString('base64'),
+                    body_encoding: 'base64'
                 });
             });
         });
@@ -155,29 +157,51 @@ 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();
+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('');
+        }
+
+        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 25 seconds to keep connection alive
+        // 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) => {
@@ -185,82 +209,105 @@ 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}`);
-                }
-
-                // 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
-                }));
-            }
+                };
 
-            if (message.type === 'error') {
-                console.log(`${timestamp()} ${chalk.red('Server error:')} ${message.error}`);
-            }
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify(responseMessage));
+                }
 
+                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'}`);
+            }
         } 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.0",
+  "version": "1.0.3",
   "description": "Forward webhooks from WebhookDrop to your local development server",
   "main": "index.js",
   "bin": {