@lifelessrasel/devtunnel-cli 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# Tunnel Client (CLI)
+
+The `tunnel-client` is a Node.js CLI tool that exposes your local server to the internet.
+
+## How it Works
+
+1.  **Connection**: The CLI connects to the **Tunnel Server** via a WebSocket (`wss://tunnel.mohammadrasel.com`).
+2.  **Registration**: It sends a `register` event to claim a subdomain (e.g., `myapp`).
+3.  **Listening**: It keeps the WebSocket open, waiting for requests.
+4.  **Forwarding**:
+    *   When the Tunnel Server receives a public HTTP request (e.g., `https://myapp.tunnel.mohammadrasel.com`), it serializes the request and sends it to the CLI over the WebSocket.
+    *   The CLI receives this message.
+    *   The CLI uses `axios` to make the **actual HTTP request** to your local service (e.g., `http://localhost:3000`).
+    *   The CLI captures the response (status, headers, body).
+    *   The CLI sends the response back to the Tunnel Server over the WebSocket.
+5.  **Response**: The Tunnel Server deserializes the response and sends it to the original public user.
+
+## Usage
+
+```bash
+# Start a tunnel forwarding to localhost:3000
+dt start --port 3000 --subdomain myapp --server wss://tunnel.mohammadrasel.com
+
+# Options
+--port, -p      Local port to expose (default: 3000)
+--subdomain, -s Requested subdomain (default: random)
+--server        Tunnel server URL (default: ws://localhost:8000)
+```
+
+## Architecture Diagram
+
+```mermaid
+sequenceDiagram
+    participant PublicUser
+    participant TunnelServer
+    participant CLI
+    participant LocalApp
+
+    CLI->>TunnelServer: WebSocket Connect (Register 'myapp')
+    TunnelServer-->>CLI: Registered 'myapp.devtunnel.net'
+
+    PublicUser->>TunnelServer: HTTP GET https://myapp.devtunnel.net/api/users
+    TunnelServer->>CLI: WS Message (type: request, path: /api/users)
+    CLI->>LocalApp: HTTP GET http://localhost:3000/api/users
+    LocalApp-->>CLI: JSON Response { "users": [] }
+    CLI->>TunnelServer: WS Message (type: response, body: {...})
+    TunnelServer-->>PublicUser: HTTP 200 OK { "users": [] }
+```

package/bin/devtunnel.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const WebSocket = require('ws');
+const axios = require('axios');
+const program = new Command();
+
+program
+    .name('devtunnel')
+    .description('Expose your local server to the internet')
+    .version('1.0.0');
+
+program.command('start')
+    .description('Start a tunnel')
+    .option('-p, --port <number>', 'Local port to expose', '3000')
+    .option('-s, --subdomain <string>', 'Requested subdomain')
+    .option('--server <string>', 'Tunnel server URL', 'ws://localhost:8000')
+    .action(async (options) => {
+        const localPort = options.port;
+        const serverUrl = options.server;
+        const requestedSubdomain = options.subdomain;
+
+        console.log(`Connecting to ${serverUrl} requesting subdomain: ${requestedSubdomain || '(random)'}...`);
+
+        const ws = new WebSocket(serverUrl);
+
+        ws.on('open', () => {
+            console.log('Connected to Tunnel Server.');
+            ws.send(JSON.stringify({
+                type: 'register',
+                subdomain: requestedSubdomain
+            }));
+        });
+
+        ws.on('message', async (data) => {
+            try {
+                const message = JSON.parse(data);
+
+                if (message.type === 'registered') {
+                    console.log(`\nTunnel Connected! 🚀`);
+                    console.log(`Public URL: ${message.url}`);
+                    console.log(`Forwarding to: http://localhost:${localPort}\n`);
+                }
+
+                else if (message.type === 'request') {
+                    const { requestId, method, path, headers, body } = message;
+
+                    // Forward to local app
+                    try {
+                        // Filter headers (host header usually causes issues)
+                        const { host, ...forwardHeaders } = headers;
+
+                        const response = await axios({
+                            method: method,
+                            url: `http://localhost:${localPort}${path}`,
+                            headers: forwardHeaders,
+                            data: body ? Buffer.from(body, 'base64') : undefined,
+                            validateStatus: () => true, // Accept all status codes
+                            responseType: 'arraybuffer' // Get raw response
+                        });
+
+                        // Send response back
+                        ws.send(JSON.stringify({
+                            type: 'response',
+                            requestId,
+                            status: response.status,
+                            headers: response.headers,
+                            body: response.data.toString('base64')
+                        }));
+
+                        console.log(`[${method}] ${path} -> ${response.status}`);
+
+                    } catch (err) {
+                        console.error(`Error forwarding request: ${err.message}`);
+                        ws.send(JSON.stringify({
+                            type: 'response',
+                            requestId,
+                            status: 502,
+                            body: Buffer.from('Bad Gateway: Local server Error').toString('base64')
+                        }));
+                    }
+                }
+
+                else if (message.type === 'error') {
+                    console.error(`Server Error: ${message.message}`);
+                    process.exit(1);
+                }
+
+            } catch (e) {
+                console.error('Error parsing message:', e);
+            }
+        });
+
+        ws.on('close', () => {
+            console.log('Disconnected from server. Retrying in 3s...');
+            setTimeout(() => process.exit(1), 3000); // Simple restart for now
+        });
+
+        ws.on('error', (err) => {
+            console.error('Connection error:', err.message);
+        });
+    });
+
+program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@lifelessrasel/devtunnel-cli",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "A specialized tunneling tool to expose local servers to the internet via DevTunnel.net",
+  "main": "bin/devtunnel.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "tunnel",
+    "localhost",
+    "proxy",
+    "devtunnel",
+    "cli"
+  ],
+  "author": "Mohammad Rasel",
+  "license": "ISC",
+  "type": "commonjs",
+  "bin": {
+    "dt": "bin/devtunnel.js",
+    "devtunnel": "bin/devtunnel.js"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "commander": "^14.0.2",
+    "ws": "^8.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lifelessrasel/devtunnel.git"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}