private-connect 0.4.2 → 0.4.7

package/README.md

@@ -1,82 +1,88 @@
-# private-connect
-
-Zero-friction connectivity tools. No signup required.
-
-## Quick Start
-
-```bash
-# Test connectivity to any service
-npx private-connect test db.internal:5432
-
-# Create a temporary public tunnel
-npx private-connect tunnel 3000
-```
-
-## Commands
-
-### `test` - Test connectivity
-
-```bash
-npx private-connect test <target>
-```
-
-**Examples:**
-```bash
-npx private-connect test db.internal:5432      # Database
-npx private-connect test redis:6379            # Redis
-npx private-connect test https://api.internal  # API
-```
-
-**What it checks:**
-- TCP connection
-- TLS/SSL (if applicable)
-- HTTP response (for web services)
-- Latency
-
-### `tunnel` - Create a temporary tunnel
-
-```bash
-npx private-connect tunnel <port>
-```
-
-Instantly expose a local service to the internet. No signup required.
-
-**Examples:**
-```bash
-npx private-connect tunnel 3000              # Expose localhost:3000
-npx private-connect tunnel localhost:8080    # Specify host and port
-```
-
-**Output:**
-```
-Private Connect - Temporary Tunnel
-────────────────────────────────────
-
-  Local:   localhost:3000
-  Public:  https://api.privateconnect.co/t/abc123
-  Expires: 120 minutes
-
-────────────────────────────────────
-
-  Press Ctrl+C to stop
-
-  [12:00:01] GET /api/users
-  [12:00:02] POST /api/login
-```
-
-**Features:**
-- No signup or account required
-- Auto-expires in 2 hours
-- Real-time request logging
-- Works with any HTTP service
-
-## Need more?
-
-For permanent tunnels, sharing with teammates, and AI agent integration:
-
-```bash
-curl -fsSL https://privateconnect.co/install.sh | bash
-connect up
-```
-
-→ [privateconnect.co](https://privateconnect.co)
+# Private Connect
+
+Zero-friction connectivity tools. No signup required.
+
+## Quick Start
+
+```bash
+# Test connectivity to any service
+npx private-connect test db.internal:5432
+
+# Create a temporary public tunnel
+npx private-connect tunnel 3000
+```
+
+## Commands
+
+### `test` - Test connectivity
+
+```bash
+npx private-connect test <target>
+```
+
+**Examples:**
+```bash
+npx private-connect test db.internal:5432      # Database
+npx private-connect test redis:6379            # Redis
+npx private-connect test https://api.internal  # API
+```
+
+**What it checks:**
+- TCP connection
+- TLS/SSL (if applicable)
+- HTTP response (for web services)
+- Latency
+
+### `tunnel` - Create a temporary tunnel
+
+```bash
+npx private-connect tunnel <port>
+```
+
+Instantly expose a local service to the internet. No signup required.
+
+**Examples:**
+```bash
+npx private-connect tunnel 3000              # Expose localhost:3000
+npx private-connect tunnel localhost:8080    # Specify host and port
+```
+
+**Output:**
+```
+Private Connect - Temporary Tunnel
+────────────────────────────────────
+
+  Local:   localhost:3000
+  Public:  https://privateconnect.co/w/abc12345
+           Anyone can access this URL
+  Inspector: https://privateconnect.co/debug/s-xyz789
+           Live traffic monitoring & request replay
+  Expires: 120 minutes
+
+────────────────────────────────────
+
+  Press Ctrl+C to stop
+```
+
+**Sharing:**
+- The public URL shows your actual website (like ngrok)
+- Perfect for demos, testing, and sharing with teammates
+- Works immediately - no landing page, just your app
+
+**Features:**
+- No signup or account required
+- Auto-expires in 2 hours
+- Real-time request logging
+- Works with any HTTP service
+- **Shareable URLs** - The public URL shows your actual website, perfect for demos and testing
+
+## Need more?
+
+For permanent tunnels, sharing with teammates, and AI agent integration:
+
+```bash
+curl -fsSL https://privateconnect.co/install.sh | bash
+connect up
+```
+
+→ [privateconnect.co](https://privateconnect.co)

package/dist/index.js

@@ -248,6 +248,9 @@ ${c.bold}Commands:${c.reset}
   check <target>     Test connectivity to any service
   test <target>      Alias for check
   tunnel <port>      Create a temporary public tunnel
+  list               List all active tunnels
+  close <id>         Close a tunnel by ID
+  close --all        Close all active tunnels
 
 ${c.bold}Examples:${c.reset}
   npx private-connect test vault.internal:8200
@@ -255,6 +258,8 @@ ${c.bold}Examples:${c.reset}
   npx private-connect tunnel 3000
   npx private-connect tunnel localhost:8080
   npx private-connect tunnel 4096 --tcp
+  npx private-connect list
+  npx private-connect close abc123
 
 ${c.bold}Tunnel:${c.reset}
   • No signup required
@@ -336,11 +341,41 @@ async function createTemporaryTunnel(options) {
         if (HUB_URL.includes('localhost')) {
             wsUrl = HUB_URL.replace('http', 'ws') + '/temp-tunnel';
         }
+        // Auto-create debug session for HTTP tunnels
+        let debugSession = null;
+        if (data.tunnel.type === 'http') {
+            try {
+                const debugResponse = await httpRequest(`${HUB_URL}/v1/tunnels/temporary/${data.tunnel.tunnelId}/debug`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ aiEnabled: false }),
+                });
+                if (debugResponse.ok) {
+                    const debugData = JSON.parse(debugResponse.body);
+                    debugSession = { token: debugData.session.token, url: debugData.session.url };
+                }
+            }
+            catch (err) {
+                // Silently fail - debug is optional
+            }
+        }
         console.log();
         console.log(`${c.gray}────────────────────────────────────${c.reset}`);
         console.log();
         console.log(`  ${c.bold}Local:${c.reset}   ${c.cyan}${host}:${port}${c.reset}`);
-        console.log(`  ${c.bold}Public:${c.reset}  ${c.green}${data.tunnel.publicUrl}${c.reset}`);
+        // Show public URL prominently
+        if (data.tunnel.subdomain) {
+            console.log(`  ${c.bold}Public:${c.reset}  ${c.green}${c.bold}${data.tunnel.publicUrl}${c.reset}`);
+            console.log(`  ${c.gray}         Anyone can access this URL${c.reset}`);
+        }
+        else {
+            console.log(`  ${c.bold}Public:${c.reset}  ${c.green}${data.tunnel.publicUrl}${c.reset}`);
+        }
+        // Show debug inspector link
+        if (debugSession) {
+            console.log(`  ${c.bold}Inspector:${c.reset} ${c.cyan}${debugSession.url}${c.reset}`);
+            console.log(`  ${c.gray}         Live traffic monitoring & request replay${c.reset}`);
+        }
         if (data.tunnel.type === 'tcp' && data.tunnel.tcpHost && data.tunnel.tcpPort) {
             console.log(`  ${c.bold}Connect:${c.reset} ${c.cyan}${data.tunnel.tcpHost}:${data.tunnel.tcpPort}${c.reset}`);
         }
@@ -440,6 +475,17 @@ async function runTunnelProxy(tunnelId, wsUrl, localHost, localPort) {
             socket.disconnect();
             resolve();
         });
+        socket.on('server_shutdown', (data) => {
+            console.log();
+            console.log(`  ${c.yellow}⚠ Server shutting down${c.reset}`);
+            if (data.message) {
+                console.log(`  ${c.dim}${data.message}${c.reset}`);
+            }
+            if (data.reconnectIn) {
+                console.log(`  ${c.dim}Reconnect in ${data.reconnectIn} seconds...${c.reset}`);
+            }
+            console.log();
+        });
         socket.on('connect_error', (err) => {
             console.log(`  ${c.red}Connection error: ${err.message}${c.reset}`);
         });
@@ -565,15 +611,32 @@ async function runTcpTunnelProxy(tunnelId, wsUrl, localHost, localPort) {
             socket.disconnect();
             resolve();
         });
+        socket.on('server_shutdown', (data) => {
+            console.log();
+            console.log(`  ${c.yellow}⚠ Server shutting down${c.reset}`);
+            if (data.message) {
+                console.log(`  ${c.dim}${data.message}${c.reset}`);
+            }
+            if (data.reconnectIn) {
+                console.log(`  ${c.dim}Reconnect in ${data.reconnectIn} seconds...${c.reset}`);
+            }
+            console.log();
+            // Close all TCP connections gracefully
+            for (const [, conn] of tcpConnections) {
+                conn.end();
+            }
+            tcpConnections.clear();
+        });
         // Handle TCP dial request from hub
         socket.on('tcp_dial', (data) => {
             connectionCount++;
             const timestamp = new Date().toLocaleTimeString();
             console.log(`  ${c.gray}[${timestamp}]${c.reset} ${c.cyan}TCP${c.reset} connection ${data.connectionId.slice(0, 8)}`);
-            // Connect to local service
+            // Connect to local service - use validated localHost/localPort, not server-provided values
+            // This prevents SSRF attacks where a compromised server could redirect connections
             const localSocket = net.createConnection({
-                host: data.targetHost,
-                port: data.targetPort,
+                host: localHost,
+                port: localPort,
             });
             tcpConnections.set(data.connectionId, localSocket);
             localSocket.on('connect', () => {
@@ -639,6 +702,167 @@ function parseTunnelTarget(target) {
     // Default to localhost with provided port
     return { host: 'localhost', port: parseInt(target, 10) || 3000 };
 }
+/**
+ * List all active tunnels
+ */
+async function listTunnels() {
+    console.log();
+    console.log(`  ${c.cyan}${c.bold}Private Connect${c.reset} ${c.dim}Active Tunnels${c.reset}`);
+    console.log();
+    const hubUrl = process.env.CONNECT_HUB_URL || 'https://api.privateconnect.co';
+    try {
+        const response = await new Promise((resolve, reject) => {
+            const url = new url_1.URL(`${hubUrl}/v1/tunnels/temporary`);
+            const protocol = url.protocol === 'https:' ? https : http;
+            const req = protocol.get(url.href, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(data));
+                    }
+                    catch {
+                        reject(new Error('Invalid response'));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.setTimeout(10000, () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+        });
+        if (response.count === 0) {
+            console.log(`  ${c.dim}No active tunnels${c.reset}`);
+        }
+        else {
+            console.log(`  ${c.green}${response.count}${c.reset} active tunnel${response.count > 1 ? 's' : ''}`);
+            console.log();
+            for (const tunnel of response.tunnels) {
+                const status = tunnel.connected ? `${c.green}connected${c.reset}` : `${c.yellow}waiting${c.reset}`;
+                const expiresIn = Math.max(0, Math.floor((new Date(tunnel.expiresAt).getTime() - Date.now()) / 60000));
+                console.log(`  ${c.cyan}${tunnel.tunnelId}${c.reset}`);
+                console.log(`    Type: ${tunnel.type}  Status: ${status}  Requests: ${tunnel.requestCount}  Expires: ${expiresIn}m`);
+                if (tunnel.subdomain) {
+                    console.log(`    Subdomain: ${c.dim}${tunnel.subdomain}${c.reset}`);
+                }
+                console.log();
+            }
+        }
+    }
+    catch (err) {
+        console.error(`  ${fail} Failed to list tunnels: ${err.message}`);
+    }
+    console.log();
+}
+/**
+ * Close a tunnel by ID
+ */
+async function closeTunnel(tunnelId) {
+    console.log();
+    console.log(`  ${c.cyan}${c.bold}Private Connect${c.reset} ${c.dim}Close Tunnel${c.reset}`);
+    console.log();
+    const hubUrl = process.env.CONNECT_HUB_URL || 'https://api.privateconnect.co';
+    try {
+        await new Promise((resolve, reject) => {
+            const url = new url_1.URL(`${hubUrl}/v1/tunnels/temporary/${tunnelId}`);
+            const protocol = url.protocol === 'https:' ? https : http;
+            const req = protocol.request(url.href, { method: 'DELETE' }, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    if (res.statusCode === 200) {
+                        resolve();
+                    }
+                    else if (res.statusCode === 404) {
+                        reject(new Error('Tunnel not found or already expired'));
+                    }
+                    else {
+                        reject(new Error(`Server error: ${res.statusCode}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.setTimeout(10000, () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.end();
+        });
+        console.log(`  ${ok} Tunnel ${c.cyan}${tunnelId}${c.reset} closed`);
+    }
+    catch (err) {
+        console.error(`  ${fail} ${err.message}`);
+    }
+    console.log();
+}
+/**
+ * Close all active tunnels
+ */
+async function closeAllTunnels() {
+    console.log();
+    console.log(`  ${c.cyan}${c.bold}Private Connect${c.reset} ${c.dim}Close All Tunnels${c.reset}`);
+    console.log();
+    const hubUrl = process.env.CONNECT_HUB_URL || 'https://api.privateconnect.co';
+    try {
+        // First list all tunnels
+        const response = await new Promise((resolve, reject) => {
+            const url = new url_1.URL(`${hubUrl}/v1/tunnels/temporary`);
+            const protocol = url.protocol === 'https:' ? https : http;
+            const req = protocol.get(url.href, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(data));
+                    }
+                    catch {
+                        reject(new Error('Invalid response'));
+                    }
+                });
+            });
+            req.on('error', reject);
+        });
+        if (response.count === 0) {
+            console.log(`  ${c.dim}No active tunnels to close${c.reset}`);
+        }
+        else {
+            let closed = 0;
+            for (const tunnel of response.tunnels) {
+                try {
+                    await new Promise((resolve, reject) => {
+                        const url = new url_1.URL(`${hubUrl}/v1/tunnels/temporary/${tunnel.tunnelId}`);
+                        const protocol = url.protocol === 'https:' ? https : http;
+                        const req = protocol.request(url.href, { method: 'DELETE' }, (res) => {
+                            res.on('data', () => { });
+                            res.on('end', () => {
+                                if (res.statusCode === 200) {
+                                    resolve();
+                                }
+                                else {
+                                    reject(new Error(`Failed: ${res.statusCode}`));
+                                }
+                            });
+                        });
+                        req.on('error', reject);
+                        req.end();
+                    });
+                    console.log(`  ${ok} Closed ${c.cyan}${tunnel.tunnelId}${c.reset}`);
+                    closed++;
+                }
+                catch (err) {
+                    console.log(`  ${fail} Failed to close ${tunnel.tunnelId}: ${err.message}`);
+                }
+            }
+            console.log();
+            console.log(`  ${c.green}Closed ${closed}/${response.count} tunnels${c.reset}`);
+        }
+    }
+    catch (err) {
+        console.error(`  ${fail} Failed to close tunnels: ${err.message}`);
+    }
+    console.log();
+}
 // Main
 const args = process.argv.slice(2);
 if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
@@ -667,6 +891,23 @@ else if (args[0] === 'tunnel') {
     const tcp = args.includes('--tcp') || args.includes('-t');
     createTemporaryTunnel({ host, port, tcp }).catch(console.error);
 }
+else if (args[0] === 'list' || args[0] === 'ls') {
+    listTunnels().catch(console.error);
+}
+else if (args[0] === 'close' || args[0] === 'kill') {
+    if (!args[1]) {
+        console.error(`${c.red}Error: Tunnel ID required${c.reset}`);
+        console.error(`Usage: npx private-connect close <tunnelId>`);
+        console.error(`       npx private-connect close --all`);
+        process.exit(1);
+    }
+    if (args[1] === '--all' || args[1] === '-a') {
+        closeAllTunnels().catch(console.error);
+    }
+    else {
+        closeTunnel(args[1]).catch(console.error);
+    }
+}
 else {
     // Default to test if just a target is provided
     runTest(args[0]).catch(console.error);

package/package.json

@@ -1,23 +1,35 @@
 {
   "name": "private-connect",
-  "version": "0.4.2",
-  "description": "Test connectivity to any service. No signup required.",
+  "version": "0.4.7",
+  "description": "Access private services by name from anywhere. No VPN setup, no firewall rules. Open source alternative to ngrok and Tailscale for service-level connectivity.",
   "bin": {
     "private-connect": "./dist/index.js"
   },
   "main": "dist/index.js",
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc -w"
   },
   "keywords": [
-    "connectivity",
-    "diagnostics",
-    "network",
+    "vpn-alternative",
+    "ngrok-alternative",
+    "tailscale-alternative",
+    "secure-tunneling",
+    "private-services",
+    "service-connectivity",
+    "zero-trust",
+    "networking",
+    "developer-tools",
+    "cli-tool",
     "tunnel",
+    "connectivity",
+    "ssh-tunnel-alternative",
+    "firewall-bypass",
+    "service-mesh",
     "private-connect"
   ],
   "license": "FSL-1.1-MIT",