webhookdrop-tunnel 1.0.0

package/README.md

@@ -0,0 +1,74 @@
+# WebhookDrop Tunnel
+
+Forward webhooks from WebhookDrop to your local development server.
+
+**Works on:** Windows, macOS, Linux
+
+## Quick Start
+
+```bash
+npx webhookdrop-tunnel --token YOUR_TOKEN --local http://localhost:3000
+```
+
+That's it! No installation required.
+
+## Get Your Token
+
+1. Login to [WebhookDrop](https://webhookdrop.app)
+2. Go to **Tunnels** page
+3. Click **"Connect Tunnel"** on your endpoint
+4. Copy the token from the popup
+
+## Usage
+
+```bash
+npx webhookdrop-tunnel --token <TOKEN> --local <LOCAL_URL>
+```
+
+### Options
+
+| Option | Description | Required |
+|--------|-------------|----------|
+| `-t, --token` | Tunnel authentication token | ✅ Yes |
+| `-l, --local` | Local server URL (e.g., http://localhost:3000) | ✅ Yes |
+| `-e, --endpoint` | Endpoint ID (usually in token) | No |
+| `-s, --server` | WebhookDrop server URL | No |
+| `-V, --version` | Show version | No |
+| `-h, --help` | Show help | No |
+
+### Examples
+
+Forward to Express server on port 3000:
+```bash
+npx webhookdrop-tunnel -t abc123... -l http://localhost:3000
+```
+
+Forward to n8n on port 5678:
+```bash
+npx webhookdrop-tunnel -t abc123... -l http://localhost:5678
+```
+
+Forward to Django on port 8000:
+```bash
+npx webhookdrop-tunnel -t abc123... -l http://127.0.0.1:8000
+```
+
+## How It Works
+
+1. **Connect**: The client establishes a WebSocket connection to WebhookDrop
+2. **Listen**: When a webhook arrives at your WebhookDrop URL, it's sent through the tunnel
+3. **Forward**: The client forwards the webhook to your local server
+4. **Respond**: Your local server's response is sent back through the tunnel
+
+```
+External Service → WebhookDrop → Tunnel → Your Local Server
+                                       ← Response ←
+```
+
+## Requirements
+
+- Node.js 14 or higher
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

package/bin/tunnel.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+
+/**
+ * WebhookDrop Tunnel Client
+ * 
+ * Forwards webhooks from WebhookDrop to your local development server.
+ * 
+ * Usage:
+ *   npx webhookdrop-tunnel --token YOUR_TOKEN --local http://localhost:3000
+ */
+
+const WebSocket = require('ws');
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+const { program } = require('commander');
+
+// Use chalk v4 (CommonJS compatible)
+let chalk;
+try {
+    chalk = require('chalk');
+} catch {
+    // Fallback if chalk not available
+    chalk = {
+        green: (s) => s,
+        red: (s) => s,
+        yellow: (s) => s,
+        blue: (s) => s,
+        gray: (s) => s,
+        bold: (s) => s,
+        cyan: (s) => s
+    };
+}
+
+const VERSION = '1.0.0';
+const DEFAULT_SERVER = 'wss://webhookdrop.app';
+
+// Parse command line arguments
+program
+    .name('webhookdrop-tunnel')
+    .description('Forward webhooks from WebhookDrop to your local server')
+    .version(VERSION)
+    .requiredOption('-t, --token <token>', 'Tunnel authentication token (from WebhookDrop dashboard)')
+    .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)
+    .parse(process.argv);
+
+const options = program.opts();
+
+// Validate local URL
+let localUrl;
+try {
+    localUrl = new URL(options.local);
+} catch (e) {
+    console.error(chalk.red(`❌ Invalid local URL: ${options.local}`));
+    process.exit(1);
+}
+
+// Extract endpoint ID from token if not provided
+function getEndpointIdFromToken(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) return null;
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
+        return payload.endpoint_id;
+    } catch {
+        return null;
+    }
+}
+
+const endpointId = options.endpoint || getEndpointIdFromToken(options.token);
+if (!endpointId) {
+    console.error(chalk.red('❌ Could not determine endpoint ID. Please provide --endpoint flag.'));
+    process.exit(1);
+}
+
+// Build WebSocket URL
+const wsUrl = `${options.server}/ws/tunnel/${endpointId}?token=${encodeURIComponent(options.token)}&local_url=${encodeURIComponent(options.local)}`;
+
+// Format timestamp
+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) => {
+        const method = data.method || 'POST';
+        const path = data.path || '/';
+        const headers = data.headers || {};
+        const body = data.body || '';
+
+        const targetUrl = new URL(path, options.local);
+        if (data.query_string) {
+            targetUrl.search = data.query_string;
+        }
+
+        const isHttps = targetUrl.protocol === 'https:';
+        const httpModule = isHttps ? https : http;
+
+        const requestOptions = {
+            hostname: targetUrl.hostname,
+            port: targetUrl.port || (isHttps ? 443 : 80),
+            path: targetUrl.pathname + targetUrl.search,
+            method: method,
+            headers: {
+                ...headers,
+                'host': targetUrl.host
+            },
+            timeout: 30000
+        };
+
+        const req = httpModule.request(requestOptions, (res) => {
+            let responseBody = '';
+            res.on('data', (chunk) => responseBody += chunk);
+            res.on('end', () => {
+                resolve({
+                    success: true,
+                    status_code: res.statusCode,
+                    headers: res.headers,
+                    body: responseBody
+                });
+            });
+        });
+
+        req.on('error', (error) => {
+            resolve({
+                success: false,
+                status_code: 502,
+                error: error.message
+            });
+        });
+
+        req.on('timeout', () => {
+            req.destroy();
+            resolve({
+                success: false,
+                status_code: 504,
+                error: 'Request timeout'
+            });
+        });
+
+        if (body) {
+            req.write(body);
+        }
+        req.end();
+    });
+}
+
+// Main tunnel connection
+function connect() {
+    console.log(`${timestamp()} Connecting to WebhookDrop...`);
+    console.log(`${timestamp()} Forwarding to: ${chalk.green(options.local)}`);
+    console.log('');
+
+    const ws = new WebSocket(wsUrl.replace('https://', 'wss://').replace('http://', 'ws://'));
+
+    let pingInterval;
+
+    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('');
+
+        // Send ping every 25 seconds to keep connection alive
+        pingInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: 'ping' }));
+            }
+        }, 25000);
+    });
+
+    ws.on('message', async (data) => {
+        try {
+            const message = JSON.parse(data.toString());
+
+            if (message.type === 'connected') {
+                // Initial connection confirmation - already handled in 'open'
+                return;
+            }
+
+            if (message.type === 'pong') {
+                // Ignore pong responses
+                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 || '/';
+
+                console.log(`${timestamp()} ${chalk.blue('→')} ${chalk.bold(method)} ${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',
+                    request_id: requestId,
+                    response: response
+                }));
+            }
+
+            if (message.type === 'error') {
+                console.log(`${timestamp()} ${chalk.red('Server error:')} ${message.error}`);
+            }
+
+        } catch (e) {
+            console.error(`${timestamp()} ${chalk.red('Error parsing message:')} ${e.message}`);
+        }
+    });
+
+    ws.on('close', (code, reason) => {
+        clearInterval(pingInterval);
+        console.log('');
+        console.log(`${timestamp()} ${chalk.yellow('Connection closed:')} ${reason || 'Unknown reason'}`);
+
+        // Reconnect after 5 seconds
+        console.log(`${timestamp()} Reconnecting in 5 seconds...`);
+        setTimeout(connect, 5000);
+    });
+
+    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 {
+            console.error(`${timestamp()} ${chalk.red('Connection error:')} ${error.message}`);
+            console.log(`${timestamp()} Reconnecting in 5 seconds...`);
+            setTimeout(connect, 5000);
+        }
+    });
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+    console.log('');
+    console.log(`${timestamp()} ${chalk.yellow('Shutting down tunnel...')}`);
+    process.exit(0);
+});
+
+// Start the tunnel
+connect();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "webhookdrop-tunnel",
+  "version": "1.0.0",
+  "description": "Forward webhooks from WebhookDrop to your local development server",
+  "main": "index.js",
+  "bin": {
+    "webhookdrop-tunnel": "./bin/tunnel.js"
+  },
+  "scripts": {
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": [
+    "webhook",
+    "tunnel",
+    "localhost",
+    "development",
+    "webhookdrop",
+    "ngrok-alternative",
+    "local-development"
+  ],
+  "author": "WebhookDrop",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webhookdrop/tunnel"
+  },
+  "homepage": "https://webhookdrop.app",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "ws": "^8.14.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0"
+  }
+}