private-connect 0.3.1 → 0.3.4

package/README.md

@@ -1,50 +1,78 @@
 # private-connect
 
-Test connectivity to any service. No signup required.
+Zero-friction connectivity tools. No signup required.
 
-## Usage
+## Quick Start
 
 ```bash
-npx private-connect test <target>
-```
+# Test connectivity to any service
+npx private-connect test db.internal:5432
 
-## Examples
+# Create a temporary public tunnel
+npx private-connect tunnel 3000
+```
 
-```bash
-# Test database connectivity
-npx private-connect test db.internal:5432
+## Commands
 
-# Test Redis
-npx private-connect test redis:6379
+### `test` - Test connectivity
 
-# Test an API
-npx private-connect test api.internal:8080
+```bash
+npx private-connect test <target>
 ```
 
-## What it checks
+**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
+```
 
-- DNS resolution
+**What it checks:**
 - TCP connection
-- Port accessibility
 - TLS/SSL (if applicable)
-- Response time
+- HTTP response (for web services)
+- Latency
 
-## Output
+### `tunnel` - Create a temporary tunnel
 
+```bash
+npx private-connect tunnel <port>
 ```
-Testing db.internal:5432...
 
-✓ DNS resolved (12ms)
-✓ TCP connection (45ms)
-✓ Port open
-✓ PostgreSQL detected
+Instantly expose a local service to the internet. No signup required.
 
-Connection successful!
+**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 tunneling, sharing, and accessing private services:
+For permanent tunnels, sharing with teammates, and AI agent integration:
 
 ```bash
 curl -fsSL https://privateconnect.co/install.sh | bash
@@ -52,4 +80,3 @@ connect up
 ```
 
 → [privateconnect.co](https://privateconnect.co)
-

package/dist/index.d.ts

@@ -2,10 +2,10 @@
 /**
  * Private Connect CLI
  *
- * Zero-friction connectivity testing. No signup required.
+ * Zero-friction connectivity testing and temporary tunnels. No signup required.
  *
  * Usage:
  *   npx private-connect test vault.internal:8200
- *   npx private-connect test https://api.example.com
+ *   npx private-connect tunnel 3000
  */
 export {};

package/dist/index.js

@@ -3,11 +3,11 @@
 /**
  * Private Connect CLI
  *
- * Zero-friction connectivity testing. No signup required.
+ * Zero-friction connectivity testing and temporary tunnels. No signup required.
  *
  * Usage:
  *   npx private-connect test vault.internal:8200
- *   npx private-connect test https://api.example.com
+ *   npx private-connect tunnel 3000
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const net = require("net");
@@ -15,6 +15,8 @@ const tls = require("tls");
 const https = require("https");
 const http = require("http");
 const url_1 = require("url");
+const crypto_1 = require("crypto");
+const socket_io_client_1 = require("socket.io-client");
 // Colors (no dependencies)
 const c = {
     reset: '\x1b[0m',
@@ -220,41 +222,313 @@ function printCta(success) {
 }
 function printHelp() {
     console.log(`
-${c.bold}Private Connect${c.reset} - Test connectivity to any service
+${c.bold}Private Connect${c.reset} - Zero-friction connectivity tools
 
-${c.bold}Usage:${c.reset}
-  npx private-connect test <target>
+${c.bold}Commands:${c.reset}
+  check <target>     Test connectivity to any service
+  test <target>      Alias for check
+  tunnel <port>      Create a temporary public tunnel
 
 ${c.bold}Examples:${c.reset}
   npx private-connect test vault.internal:8200
   npx private-connect test https://api.example.com
-  npx private-connect test postgres.prod:5432
+  npx private-connect tunnel 3000
+  npx private-connect tunnel localhost:8080
 
-${c.bold}What it checks:${c.reset}
+${c.bold}Tunnel:${c.reset}
+  • No signup required
+  • Auto-expires in 2 hours
+  • Get a public URL instantly
+
+${c.bold}Test:${c.reset}
   • TCP reachability
   • TLS validation  
-  • HTTP response (if applicable)
+  • HTTP response
   • Latency
 
-No signup. No account. Just diagnostics.
-
-${c.dim}For full features: https://privateconnect.co${c.reset}
+${c.dim}For permanent tunnels: https://privateconnect.co${c.reset}
 `);
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Temporary Tunnel
+// ─────────────────────────────────────────────────────────────────────────────
+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;
+    console.log();
+    console.log(`${c.bold}Private Connect${c.reset} - Temporary 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);
+    }
+    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... `);
+    try {
+        const response = await httpRequest(`${HUB_URL}/v1/tunnels/temporary`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                tunnelId,
+                localHost: host,
+                localPort: port,
+                ttlMinutes: ttl,
+            }),
+        });
+        if (!response.ok) {
+            console.log(`${fail}`);
+            console.log();
+            if (response.status === 503 || response.status === 404 || response.status === 501) {
+                console.log(`  ${c.yellow}Temporary tunnels coming soon!${c.reset}`);
+                console.log();
+                console.log(`  For now, use the full CLI:`);
+                console.log(`  ${c.cyan}curl -fsSL https://privateconnect.co/install.sh | bash${c.reset}`);
+                console.log(`  ${c.cyan}connect up && connect localhost:${port} --share${c.reset}`);
+            }
+            else {
+                console.log(`  ${c.red}Failed to create tunnel: ${response.status}${c.reset}`);
+            }
+            console.log();
+            process.exit(1);
+        }
+        console.log(`${ok}`);
+        console.log();
+        console.log(`${c.gray}────────────────────────────────────${c.reset}`);
+        console.log();
+        const data = JSON.parse(response.body);
+        // For local dev, adjust the WS URL
+        let wsUrl = data.tunnel.wsUrl;
+        if (HUB_URL.includes('localhost')) {
+            wsUrl = HUB_URL.replace('http', 'ws') + '/temp-tunnel';
+        }
+        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}`);
+        console.log(`  ${c.bold}Expires:${c.reset} ${data.tunnel.ttlMinutes} minutes`);
+        console.log();
+        console.log(`${c.gray}────────────────────────────────────${c.reset}`);
+        console.log();
+        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);
+    }
+    catch (err) {
+        console.log(`${fail}`);
+        console.log();
+        if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
+            console.log(`  ${c.yellow}Temporary tunnels coming soon!${c.reset}`);
+            console.log();
+            console.log(`  For now, use the full CLI:`);
+            console.log(`  ${c.cyan}curl -fsSL https://privateconnect.co/install.sh | bash${c.reset}`);
+            console.log(`  ${c.cyan}connect up && connect localhost:${port} --share${c.reset}`);
+        }
+        else {
+            console.log(`  ${c.red}Error: ${err.message}${c.reset}`);
+        }
+        console.log();
+        process.exit(1);
+    }
+}
+// Simple HTTP request helper (no dependencies)
+function httpRequest(url, options) {
+    return new Promise((resolve, reject) => {
+        const parsedUrl = new url_1.URL(url);
+        const client = parsedUrl.protocol === 'https:' ? https : http;
+        const req = client.request(url, {
+            method: options.method || 'GET',
+            headers: options.headers,
+        }, (res) => {
+            let body = '';
+            res.on('data', chunk => body += chunk);
+            res.on('end', () => {
+                resolve({
+                    ok: res.statusCode >= 200 && res.statusCode < 300,
+                    status: res.statusCode,
+                    body,
+                });
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => reject(new Error('Request timeout')));
+        if (options.body) {
+            req.write(options.body);
+        }
+        req.end();
+    });
+}
+/**
+ * Connect to hub via WebSocket and forward HTTP requests to local service
+ */
+async function runTunnelProxy(tunnelId, wsUrl, localHost, localPort) {
+    return new Promise((resolve) => {
+        // Extract base URL and namespace
+        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,
+        });
+        let requestCount = 0;
+        socket.on('connect', () => {
+            // Register this tunnel
+            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) => {
+            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();
+        });
+        socket.on('connect_error', (err) => {
+            console.log(`  ${c.red}Connection error: ${err.message}${c.reset}`);
+        });
+        // Handle incoming HTTP requests from the hub
+        socket.on('http_request', async (data) => {
+            requestCount++;
+            const timestamp = new Date().toLocaleTimeString();
+            console.log(`  ${c.gray}[${timestamp}]${c.reset} ${c.cyan}${data.method}${c.reset} ${data.path}`);
+            try {
+                // Forward request to local service
+                const response = await forwardToLocal(localHost, localPort, data);
+                // Send response back to hub
+                socket.emit('http_response', {
+                    requestId: data.requestId,
+                    status: response.status,
+                    headers: response.headers,
+                    body: response.body,
+                });
+            }
+            catch (err) {
+                // Send error response
+                socket.emit('http_response', {
+                    requestId: data.requestId,
+                    status: 502,
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ error: 'Bad Gateway', message: err.message }),
+                });
+            }
+        });
+        // Handle shutdown
+        process.on('SIGINT', () => {
+            console.log();
+            console.log(`  ${c.yellow}Tunnel closed${c.reset}`);
+            console.log(`  ${c.gray}Handled ${requestCount} requests${c.reset}`);
+            console.log();
+            socket.disconnect();
+            resolve();
+        });
+    });
+}
+/**
+ * Forward an HTTP request to the local service
+ */
+function forwardToLocal(host, port, request) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: host,
+            port: port,
+            path: request.path,
+            method: request.method,
+            headers: { ...request.headers, host: `${host}:${port}` },
+            timeout: 30000,
+        };
+        const req = http.request(options, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                const body = Buffer.concat(chunks).toString('utf-8');
+                const headers = {};
+                for (const [key, value] of Object.entries(res.headers)) {
+                    if (typeof value === 'string') {
+                        headers[key] = value;
+                    }
+                    else if (Array.isArray(value)) {
+                        headers[key] = value.join(', ');
+                    }
+                }
+                resolve({
+                    status: res.statusCode || 500,
+                    headers,
+                    body,
+                });
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => reject(new Error('Request timeout')));
+        if (request.body) {
+            req.write(request.body);
+        }
+        req.end();
+    });
+}
+function parseTunnelTarget(target) {
+    // Handle just port number
+    if (/^\d+$/.test(target)) {
+        return { host: 'localhost', port: parseInt(target, 10) };
+    }
+    // Handle host:port
+    const parts = target.split(':');
+    if (parts.length === 2) {
+        return { host: parts[0], port: parseInt(parts[1], 10) };
+    }
+    // Default to localhost with provided port
+    return { host: 'localhost', port: parseInt(target, 10) || 3000 };
+}
 // Main
 const args = process.argv.slice(2);
 if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
     printHelp();
     process.exit(0);
 }
-if (args[0] === 'test') {
+if (args[0] === 'test' || args[0] === 'check') {
     if (!args[1]) {
         console.error(`${c.red}Error: Target required${c.reset}`);
-        console.error(`Usage: npx private-connect test <host:port>`);
+        console.error(`Usage: npx private-connect ${args[0]} <host:port>`);
         process.exit(1);
     }
     runTest(args[1]).catch(console.error);
 }
+else if (args[0] === 'tunnel') {
+    if (!args[1]) {
+        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`);
+        process.exit(1);
+    }
+    const { host, port } = parseTunnelTarget(args[1]);
+    createTemporaryTunnel({ host, port }).catch(console.error);
+}
 else {
     // Default to test if just a target is provided
     runTest(args[0]).catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "private-connect",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "description": "Test connectivity to any service. No signup required.",
   "bin": {
     "private-connect": "./dist/index.js"
@@ -26,6 +26,9 @@
     "url": "https://github.com/treadiehq/private-connect.git",
     "directory": "packages/cli"
   },
+  "dependencies": {
+    "socket.io-client": "^4.7.0"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0"