private-connect 0.5.0 → 0.5.8

package/README.md

@@ -2,6 +2,15 @@
 
 Zero-friction connectivity tools. No signup required.
 
+## Installation
+
+```bash
+npm i private-connect          # add to your project
+npm i -g private-connect       # install globally
+```
+
+**Run it:** after a global install use `private-connect`; after a local install use `npx private-connect`. Or run without installing: `npx private-connect <command>`.
+
 ## Quick Start
 
 ```bash
@@ -53,7 +62,7 @@ Private Connect - Temporary Tunnel
 ────────────────────────────────────
 
   Local:   localhost:3000
-  Public:  https://privateconnect.co/w/abc12345
+  Public:  https://abc12345.privateconnect.co
            Anyone can access this URL
   Inspector: https://privateconnect.co/debug/s-xyz789
            Live traffic monitoring & request replay
@@ -64,6 +73,20 @@ Private Connect - Temporary Tunnel
   Press Ctrl+C to stop
 ```
 
+**TCP/UDP Tunnels:**
+```bash
+npx private-connect tunnel 5432 --tcp    # TCP tunnel (databases, etc.)
+npx private-connect tunnel 27015 --udp   # UDP tunnel (game servers, etc.)
+```
+
+TCP/UDP output shows connection details:
+```
+  Local:   localhost:5432
+  Public:  tcp://api.privateconnect.co:40001
+  Connect: api.privateconnect.co:40001
+  Expires: 120 minutes
+```
+
 **Sharing:**
 - The public URL shows your actual website (like ngrok)
 - Perfect for demos, testing, and sharing with teammates
@@ -73,7 +96,7 @@ Private Connect - Temporary Tunnel
 - No signup or account required
 - Auto-expires in 2 hours
 - Real-time request logging
-- Works with any HTTP service
+- Works with HTTP, TCP, and UDP services
 - **Shareable URLs** - The public URL shows your actual website, perfect for demos and testing
 
 ### `setup-openclaw` - One-command OpenClaw setup

package/dist/index.js

@@ -11,6 +11,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const net = require("net");
+const dgram = require("dgram");
 const tls = require("tls");
 const https = require("https");
 const http = require("http");
@@ -260,6 +261,7 @@ ${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 tunnel 27015 --udp
   npx private-connect list
   npx private-connect close abc123
   npx private-connect setup-openclaw
@@ -268,7 +270,7 @@ ${c.bold}Examples:${c.reset}
 ${c.bold}Tunnel:${c.reset}
   • No signup required
   • Auto-expires in 2 hours
-  • HTTP or raw TCP (--tcp flag)
+  • HTTP, TCP (--tcp), or UDP (--udp)
 
 ${c.bold}Test:${c.reset}
   • TCP reachability
@@ -290,24 +292,38 @@ ${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, tcp = false } = options;
-    const tunnelType = tcp ? 'tcp' : 'http';
+    const { host, port, ttl = 120, tcp = false, udp = false } = options;
+    const tunnelType = udp ? 'udp' : (tcp ? 'tcp' : 'http');
     console.log();
-    console.log(`${c.bold}Private Connect${c.reset} - Temporary ${tcp ? 'TCP ' : ''}Tunnel`);
+    console.log(`${c.bold}Private Connect${c.reset} - Temporary ${udp ? 'UDP ' : tcp ? 'TCP ' : ''}Tunnel`);
     console.log(`${c.gray}────────────────────────────────────${c.reset}`);
     console.log();
     // Check if local service is running
     process.stdout.write(`  Checking ${c.cyan}${host}:${port}${c.reset}... `);
-    const localCheck = await testTcp(host, port, 2000);
-    if (!localCheck.ok) {
-        console.log(`${fail}`);
-        console.log();
-        console.log(`  ${c.red}Cannot connect to ${host}:${port}${c.reset}`);
-        console.log(`  ${c.gray}Make sure your service is running${c.reset}`);
-        console.log();
-        process.exit(1);
+    if (udp) {
+        // For UDP, we can't really test connectivity without sending data
+        // Just verify it's a valid port
+        if (port < 1 || port > 65535) {
+            console.log(`${fail}`);
+            console.log();
+            console.log(`  ${c.red}Invalid port: ${port}${c.reset}`);
+            console.log();
+            process.exit(1);
+        }
+        console.log(`${ok} ${c.dim}(UDP - assuming service is ready)${c.reset}`);
+    }
+    else {
+        const localCheck = await testTcp(host, port, 2000);
+        if (!localCheck.ok) {
+            console.log(`${fail}`);
+            console.log();
+            console.log(`  ${c.red}Cannot connect to ${host}:${port}${c.reset}`);
+            console.log(`  ${c.gray}Make sure your service is running${c.reset}`);
+            console.log();
+            process.exit(1);
+        }
+        console.log(`${ok}`);
     }
-    console.log(`${ok}`);
     // Generate a temporary tunnel ID
     const tunnelId = (0, crypto_1.randomBytes)(6).toString('hex');
     // Request tunnel from hub
@@ -388,6 +404,9 @@ async function createTemporaryTunnel(options) {
         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}`);
         }
+        if (data.tunnel.type === 'udp' && data.tunnel.udpHost && data.tunnel.udpPort) {
+            console.log(`  ${c.bold}Connect:${c.reset} ${c.cyan}${data.tunnel.udpHost}:${data.tunnel.udpPort}${c.reset} ${c.dim}(UDP)${c.reset}`);
+        }
         console.log(`  ${c.bold}Expires:${c.reset} ${data.tunnel.ttlMinutes} minutes`);
         console.log();
         console.log(`${c.gray}────────────────────────────────────${c.reset}`);
@@ -395,7 +414,10 @@ async function createTemporaryTunnel(options) {
         console.log(`  ${c.dim}Press Ctrl+C to stop${c.reset}`);
         console.log();
         // Keep connection alive and handle incoming requests
-        if (data.tunnel.type === 'tcp') {
+        if (data.tunnel.type === 'udp') {
+            await runUdpTunnelProxy(data.tunnel.tunnelId, wsUrl, host, port);
+        }
+        else if (data.tunnel.type === 'tcp') {
             await runTcpTunnelProxy(data.tunnel.tunnelId, wsUrl, host, port);
         }
         else {
@@ -698,6 +720,106 @@ async function runTcpTunnelProxy(tunnelId, wsUrl, localHost, localPort) {
         });
     });
 }
+/**
+ * Run UDP tunnel proxy - forward UDP datagrams
+ */
+async function runUdpTunnelProxy(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,
+        });
+        // Create local UDP socket for forwarding to local service
+        const localUdpSocket = dgram.createSocket('udp4');
+        // Track UDP "sessions" by remote address for response routing
+        // sessionId -> { remoteInfo from server }
+        const sessions = new Map();
+        let packetCount = 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) => {
+            localUdpSocket.close();
+            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();
+            localUdpSocket.close();
+            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();
+        });
+        // Handle incoming UDP datagram from server (from remote client)
+        socket.on('udp_datagram', (data) => {
+            packetCount++;
+            const timestamp = new Date().toLocaleTimeString();
+            console.log(`  ${c.gray}[${timestamp}]${c.reset} ${c.cyan}UDP${c.reset} ← ${data.remoteAddress}:${data.remotePort} (${Buffer.from(data.data, 'base64').length} bytes)`);
+            // Store session info for response routing
+            sessions.set(data.sessionId, { address: data.remoteAddress, port: data.remotePort });
+            // Forward to local UDP service
+            const buffer = Buffer.from(data.data, 'base64');
+            localUdpSocket.send(buffer, localPort, localHost, (err) => {
+                if (err) {
+                    console.log(`  ${c.red}UDP send error: ${err.message}${c.reset}`);
+                }
+            });
+        });
+        // Handle response from local UDP service
+        localUdpSocket.on('message', (msg, rinfo) => {
+            const timestamp = new Date().toLocaleTimeString();
+            console.log(`  ${c.gray}[${timestamp}]${c.reset} ${c.cyan}UDP${c.reset} → response (${msg.length} bytes)`);
+            // Find the most recent session to send response to
+            // In practice, you might need more sophisticated session tracking
+            const lastSession = Array.from(sessions.entries()).pop();
+            if (lastSession) {
+                socket.emit('udp_response', {
+                    sessionId: lastSession[0],
+                    data: msg.toString('base64'),
+                });
+            }
+        });
+        localUdpSocket.on('error', (err) => {
+            console.log(`  ${c.red}Local UDP socket error: ${err.message}${c.reset}`);
+        });
+        // Bind local socket to receive responses
+        localUdpSocket.bind();
+        // Handle shutdown
+        process.on('SIGINT', () => {
+            console.log();
+            console.log(`  ${c.yellow}Tunnel closed${c.reset}`);
+            console.log(`  ${c.gray}Handled ${packetCount} UDP packets${c.reset}`);
+            console.log();
+            localUdpSocket.close();
+            socket.disconnect();
+            resolve();
+        });
+    });
+}
 function parseTunnelTarget(target) {
     // Handle just port number
     if (/^\d+$/.test(target)) {
@@ -989,11 +1111,17 @@ else if (args[0] === 'tunnel') {
         console.error(`Usage: npx private-connect tunnel <port>`);
         console.error(`       npx private-connect tunnel localhost:3000`);
         console.error(`       npx private-connect tunnel 4096 --tcp`);
+        console.error(`       npx private-connect tunnel 27015 --udp`);
         process.exit(1);
     }
     const { host, port } = parseTunnelTarget(args[1]);
     const tcp = args.includes('--tcp') || args.includes('-t');
-    createTemporaryTunnel({ host, port, tcp }).catch(console.error);
+    const udp = args.includes('--udp') || args.includes('-u');
+    if (tcp && udp) {
+        console.error(`${c.red}Error: Cannot use both --tcp and --udp${c.reset}`);
+        process.exit(1);
+    }
+    createTemporaryTunnel({ host, port, tcp, udp }).catch(console.error);
 }
 else if (args[0] === 'list' || args[0] === 'ls') {
     listTunnels().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "private-connect",
-  "version": "0.5.0",
+  "version": "0.5.8",
   "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"
@@ -10,6 +10,10 @@
     "dist",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  },
   "keywords": [
     "vpn-alternative",
     "ngrok-alternative",
@@ -40,9 +44,6 @@
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc -w"
   }
-}
+}
+

package/LICENSE

@@ -1,110 +0,0 @@
-# Functional Source License, Version 1.1
-
-## Abbreviation
-
-FSL-1.1-MIT
-
-## Notice
-
-Copyright (c) 2025 Treadie, Inc
-
-## Terms and Conditions
-
-### Licensor ("We")
-
-The party offering the Software under these Terms and Conditions.
-
-### The Software
-
-The "Software" is each version of the software that we make available under
-these Terms and Conditions, as indicated by our inclusion of these Terms and
-Conditions with the Software.
-
-### License Grant
-
-Subject to your compliance with this License Grant and the Patents,
-Redistribution and Trademark clauses below, we hereby grant you the right to
-use, copy, modify, create derivative works, publicly perform, publicly display
-and redistribute the Software for any Permitted Purpose identified below.
-
-### Permitted Purpose
-
-A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
-means making the Software available to others in a commercial product or
-service that:
-
-1. substitutes for the Software;
-
-2. substitutes for any other product or service we offer using the Software
-   that exists as of the date we make the Software available; or
-
-3. offers the same or substantially similar functionality as the Software.
-
-Permitted Purposes specifically include using the Software:
-
-1. for your internal use and access;
-
-2. for non-commercial education;
-
-3. for non-commercial research; and
-
-4. in connection with professional services that you provide to a licensee
-   using the Software in accordance with these Terms and Conditions.
-
-### Patents
-
-To the extent your use for a Permitted Purpose would necessarily infringe our
-patents, the license grant above includes a license under our patents. If you
-make a claim against any party that the Software infringes or contributes to
-the infringement of any patent, then your patent license to the Software ends
-immediately.
-
-### Redistribution
-
-The Terms and Conditions apply to all copies, modifications and derivatives of
-the Software.
-
-If you redistribute any copies, modifications or derivatives of the Software,
-you must include a copy of or a link to these Terms and Conditions and not
-remove any copyright notices provided in or with the Software.
-
-### Disclaimer
-
-THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
-PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
-
-IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
-SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
-EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
-
-### Trademarks
-
-Except for displaying the License Details and identifying us as the origin of
-the Software, you have no right under these Terms and Conditions to use our
-trademarks, trade names, service marks or product names.
-
-## Grant of Future License
-
-We hereby irrevocably grant you an additional license to use the Software under
-the MIT license that is effective on the second anniversary of the date we make
-the Software available. On or after that date, you may use the Software under
-the MIT license, in which case the following will apply:
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.