private-connect 0.3.6 → 0.4.0

package/dist/index.js

@@ -254,11 +254,12 @@ ${c.bold}Examples:${c.reset}
   npx private-connect test https://api.example.com
   npx private-connect tunnel 3000
   npx private-connect tunnel localhost:8080
+  npx private-connect tunnel 4096 --tcp
 
 ${c.bold}Tunnel:${c.reset}
   • No signup required
   • Auto-expires in 2 hours
-  • Get a public URL instantly
+  • HTTP or raw TCP (--tcp flag)
 
 ${c.bold}Test:${c.reset}
   • TCP reachability
@@ -275,9 +276,10 @@ ${c.dim}For permanent tunnels: https://privateconnect.co${c.reset}
 const HUB_URL = process.env.CONNECT_HUB_URL || 'https://api.privateconnect.co';
 const TUNNEL_DOMAIN = process.env.CONNECT_TUNNEL_DOMAIN || 'tunnel.privateconnect.co';
 async function createTemporaryTunnel(options) {
-    const { host, port, ttl = 120 } = options;
+    const { host, port, ttl = 120, tcp = false } = options;
+    const tunnelType = tcp ? 'tcp' : 'http';
     console.log();
-    console.log(`${c.bold}Private Connect${c.reset} - Temporary Tunnel`);
+    console.log(`${c.bold}Private Connect${c.reset} - Temporary ${tcp ? 'TCP ' : ''}Tunnel`);
     console.log(`${c.gray}────────────────────────────────────${c.reset}`);
     console.log();
     // Check if local service is running
@@ -294,9 +296,8 @@ async function createTemporaryTunnel(options) {
     console.log(`${ok}`);
     // Generate a temporary tunnel ID
     const tunnelId = (0, crypto_1.randomBytes)(6).toString('hex');
-    const publicUrl = `https://${tunnelId}.${TUNNEL_DOMAIN}`;
     // Request tunnel from hub
-    process.stdout.write(`  Requesting tunnel... `);
+    process.stdout.write(`  Requesting ${tunnelType} tunnel... `);
     try {
         const response = await httpRequest(`${HUB_URL}/v1/tunnels/temporary`, {
             method: 'POST',
@@ -306,6 +307,7 @@ async function createTemporaryTunnel(options) {
                 localHost: host,
                 localPort: port,
                 ttlMinutes: ttl,
+                type: tunnelType,
             }),
         });
         if (!response.ok) {
@@ -339,6 +341,9 @@ async function createTemporaryTunnel(options) {
         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}`);
+        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}`);
+        }
         console.log(`  ${c.bold}Expires:${c.reset} ${data.tunnel.ttlMinutes} minutes`);
         console.log();
         console.log(`${c.gray}────────────────────────────────────${c.reset}`);
@@ -346,7 +351,12 @@ async function createTemporaryTunnel(options) {
         console.log(`  ${c.dim}Press Ctrl+C to stop${c.reset}`);
         console.log();
         // Keep connection alive and handle incoming requests
-        await runTunnelProxy(data.tunnel.tunnelId, wsUrl, host, port);
+        if (data.tunnel.type === 'tcp') {
+            await runTcpTunnelProxy(data.tunnel.tunnelId, wsUrl, host, port);
+        }
+        else {
+            await runTunnelProxy(data.tunnel.tunnelId, wsUrl, host, port);
+        }
     }
     catch (err) {
         console.log(`${fail}`);
@@ -512,6 +522,110 @@ function forwardToLocal(host, port, request) {
         req.end();
     });
 }
+/**
+ * Run TCP tunnel proxy - forward raw TCP connections
+ */
+async function runTcpTunnelProxy(tunnelId, wsUrl, localHost, localPort) {
+    return new Promise((resolve) => {
+        const url = new url_1.URL(wsUrl.replace('ws://', 'http://').replace('wss://', 'https://'));
+        const baseUrl = `${url.protocol}//${url.host}`;
+        const namespace = url.pathname || '/temp-tunnel';
+        const socket = (0, socket_io_client_1.io)(`${baseUrl}${namespace}`, {
+            transports: ['websocket'],
+            reconnection: true,
+            reconnectionAttempts: 10,
+            reconnectionDelay: 1000,
+        });
+        // Track active TCP connections
+        const tcpConnections = new Map();
+        let connectionCount = 0;
+        socket.on('connect', () => {
+            socket.emit('register', { tunnelId }, (response) => {
+                if (!response.success) {
+                    console.log(`  ${c.red}Failed to register: ${response.error}${c.reset}`);
+                    socket.disconnect();
+                    resolve();
+                }
+            });
+        });
+        socket.on('disconnect', (reason) => {
+            // Close all TCP connections
+            for (const [, conn] of tcpConnections) {
+                conn.end();
+            }
+            tcpConnections.clear();
+            if (reason === 'io server disconnect') {
+                console.log(`  ${c.yellow}Tunnel expired or closed by server${c.reset}`);
+            }
+        });
+        socket.on('tunnel_expired', () => {
+            console.log();
+            console.log(`  ${c.yellow}Tunnel expired${c.reset}`);
+            console.log();
+            socket.disconnect();
+            resolve();
+        });
+        // 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
+            const localSocket = net.createConnection({
+                host: data.targetHost,
+                port: data.targetPort,
+            });
+            tcpConnections.set(data.connectionId, localSocket);
+            localSocket.on('connect', () => {
+                socket.emit('tcp_dial_success', { connectionId: data.connectionId });
+            });
+            localSocket.on('data', (chunk) => {
+                socket.emit('tcp_data', {
+                    connectionId: data.connectionId,
+                    data: chunk.toString('base64'),
+                });
+            });
+            localSocket.on('close', () => {
+                socket.emit('tcp_close', { connectionId: data.connectionId });
+                tcpConnections.delete(data.connectionId);
+            });
+            localSocket.on('error', (err) => {
+                console.log(`  ${c.red}TCP error: ${err.message}${c.reset}`);
+                socket.emit('tcp_close', { connectionId: data.connectionId });
+                tcpConnections.delete(data.connectionId);
+            });
+        });
+        // Handle TCP data from hub (from remote client)
+        socket.on('tcp_data', (data) => {
+            const localSocket = tcpConnections.get(data.connectionId);
+            if (localSocket) {
+                const buffer = Buffer.from(data.data, 'base64');
+                localSocket.write(buffer);
+            }
+        });
+        // Handle TCP close from hub
+        socket.on('tcp_close', (data) => {
+            const localSocket = tcpConnections.get(data.connectionId);
+            if (localSocket) {
+                localSocket.end();
+                tcpConnections.delete(data.connectionId);
+            }
+        });
+        // Handle shutdown
+        process.on('SIGINT', () => {
+            console.log();
+            console.log(`  ${c.yellow}Tunnel closed${c.reset}`);
+            console.log(`  ${c.gray}Handled ${connectionCount} connections${c.reset}`);
+            console.log();
+            // Close all connections
+            for (const [, conn] of tcpConnections) {
+                conn.end();
+            }
+            socket.disconnect();
+            resolve();
+        });
+    });
+}
 function parseTunnelTarget(target) {
     // Handle just port number
     if (/^\d+$/.test(target)) {
@@ -546,10 +660,12 @@ else if (args[0] === 'tunnel') {
         console.error(`${c.red}Error: Port required${c.reset}`);
         console.error(`Usage: npx private-connect tunnel <port>`);
         console.error(`       npx private-connect tunnel localhost:3000`);
+        console.error(`       npx private-connect tunnel 4096 --tcp`);
         process.exit(1);
     }
     const { host, port } = parseTunnelTarget(args[1]);
-    createTemporaryTunnel({ host, port }).catch(console.error);
+    const tcp = args.includes('--tcp') || args.includes('-t');
+    createTemporaryTunnel({ host, port, tcp }).catch(console.error);
 }
 else {
     // Default to test if just a target is provided

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "private-connect",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "Test connectivity to any service. No signup required.",
   "bin": {
     "private-connect": "./dist/index.js"