cli-tunnel 1.2.0-beta.9 → 1.2.0

package/README.md

@@ -3,11 +3,13 @@
 Tunnel any CLI app to your phone — see the exact terminal output in your browser and type back into it.
 
 ```bash
-npx cli-tunnel --tunnel copilot --yolo
-npx cli-tunnel --tunnel python -i
-npx cli-tunnel --tunnel htop
+npx cli-tunnel copilot --yolo
+npx cli-tunnel python -i
+npx cli-tunnel k9s
 ```
 
+![Mobile terminal](docs/images/mobile-terminal.png)
+
 ## How It Works
 
 1. Your command runs in a **PTY** (pseudo-terminal) — full TUI with colors, diffs, interactive prompts
@@ -22,53 +24,104 @@ npx cli-tunnel --tunnel htop
 npm install -g cli-tunnel
 ```
 
-Or use directly with npx:
+Or use directly with npx (no install needed):
+
+```bash
+npx cli-tunnel <command> [args...]
+```
+
+If devtunnel isn't installed, cli-tunnel will offer to install it for you automatically.
+
+## Quick Start
 
 ```bash
-npx cli-tunnel --tunnel <command> [args...]
+# Run copilot and access it from your phone
+cli-tunnel copilot --yolo
+
+# A QR code appears — scan it with your phone
+# Press any key to start the CLI tool
+# Your phone now shows the exact same terminal!
 ```
 
 ## Usage
 
-Any flags after the command name are passed directly to the underlying app — cli-tunnel doesn't interpret them.
+Devtunnel is enabled by default. All flags after the command name pass through to the underlying app — cli-tunnel doesn't interpret them.
 
 ```bash
-# Start copilot with remote access (--yolo is a copilot flag, not ours)
-cli-tunnel --tunnel copilot --yolo
+# Run copilot with any flags
+cli-tunnel copilot --yolo
+cli-tunnel copilot --model claude-sonnet-4 --agent squad
 
-# Pass any flags to the underlying command
-cli-tunnel --tunnel copilot --model claude-sonnet-4 --agent squad
-cli-tunnel --tunnel copilot --allow-all --resume
+# Name your session (shows in the hub dashboard)
+cli-tunnel --name wizard copilot --agent squad
 
-# Name your session (shows in dashboard)
-cli-tunnel --tunnel --name wizard copilot --agent squad
+# Works with any CLI app
+cli-tunnel python -i
+cli-tunnel vim myfile.txt
+cli-tunnel htop
+cli-tunnel k9s
+cli-tunnel ssh user@server
 
 # Specific port
-cli-tunnel --tunnel --port 4000 copilot
+cli-tunnel --port 4000 copilot
 
-# Works with any CLI app — all their flags pass through
-cli-tunnel --tunnel python -i
-cli-tunnel --tunnel vim myfile.txt
-cli-tunnel --tunnel htop
-cli-tunnel --tunnel ssh user@server
+# Local only (no tunnel, localhost access only)
+cli-tunnel --local copilot --yolo
+```
 
-# Local only (no tunnel)
-cli-tunnel copilot
+**cli-tunnel's own flags** (`--local`, `--port`, `--name`, `--replay`) must come **before** the command.
+
+## Hub Mode — Sessions Dashboard
+
+Run `cli-tunnel` with no command to start **hub mode** — a dashboard that shows all your active sessions across machines.
+
+```bash
+cli-tunnel
 ```
 
-**cli-tunnel's own flags** (`--tunnel`, `--port`, `--name`) must come **before** the command. Everything after the command name passes through unchanged.
+![Hub dashboard](docs/images/hub-dashboard.png)
+
+The hub discovers sessions via devtunnel labels. Sessions on the same machine are directly connectable — tap a session card to open it. Remote sessions (other machines) are visible but shown with a 🔒 icon.
+
+## Grid View — Monitor All Sessions
+
+When the hub has 2+ connectable sessions, a **⊞ Grid** button appears. Click it to see all sessions as live terminals — like tmux in your browser.
+
+Four layout modes, switchable without reconnecting:
+
+### ⊞ Tiles — Overview
+Scaled-down terminal previews in a card grid, like Windows Task View. Click any tile to go fullscreen.
+
+![Tiles view](docs/images/grid-tiles.png)
+
+### ⊟ Tmux — Split Panels
+Equal split panels with layout presets: **Equal**, **Main+Side**, and **Stacked**.
+
+![Tmux view](docs/images/grid-tmux.png)
+
+### ◉ Focus — Presentation Mode
+One terminal takes the full screen. Other sessions shown as clickable strips at the bottom — tap to swap.
+
+![Focus view](docs/images/grid-focus.png)
+
+### ⊡ Fullscreen
+Single terminal with key bar for mobile input. "← Grid" button to go back.
+
+![Fullscreen view](docs/images/grid-fullscreen.png)
+
+All modes share the same WebSocket connections — switching is instant, no reconnection needed.
 
 ## What You See on Your Phone
 
 - **Full terminal** rendered by xterm.js — exact same output as your local terminal
 - **Key bar** with ↑ ↓ → ← Tab Enter Esc Ctrl+C for mobile navigation
-- **Sessions dashboard** — see all running sessions, tap to connect
-- **Session cleanup** — remove stale tunnels
+- **Sessions button** — switch between terminal and sessions dashboard
+- **QR code** — scan from your phone to connect instantly
 
 ## Prerequisites
 
-- [Node.js](https://nodejs.org/) 22+
-- [Microsoft Dev Tunnels CLI](https://aka.ms/devtunnels/doc) (for `--tunnel` mode)
+- [Node.js](https://nodejs.org/) 22+ (Node 20 works too; Node 23 may need the latest beta)
+- [Microsoft Dev Tunnels CLI](https://aka.ms/devtunnels/doc) — cli-tunnel offers to install it if missing
   ```bash
   winget install Microsoft.devtunnel   # Windows
   brew install --cask devtunnel        # macOS
@@ -81,23 +134,25 @@ cli-tunnel uses a layered security model:
 
 **Network layer** — Microsoft Dev Tunnels are private by default. Only the Microsoft or GitHub account that created the tunnel can connect. TLS encryption is handled by Microsoft's relay infrastructure. No inbound ports are opened on your machine.
 
-**Session authentication** — Each session generates a unique token (cryptographic random UUID). All HTTP API and WebSocket connections require this token. The token is embedded in the URL you receive at startup — anyone without it cannot connect.
+**Session authentication** — Each session generates a unique token (cryptographic random UUID). All HTTP API and WebSocket connections require this token. The token is embedded in the URL you receive at startup.
 
-**WebSocket auth** — cli-tunnel uses a ticket-based handshake: the browser exchanges the session token for a single-use, short-lived ticket (60 seconds) to establish the WebSocket connection. This avoids keeping the long-lived token in WebSocket upgrade logs.
+**Ticket-based WebSocket auth** — The browser exchanges the session token for a single-use, short-lived ticket (60 seconds) to establish the WebSocket connection. This avoids keeping the long-lived token in WebSocket upgrade logs.
 
-**Input validation** — Only structured JSON messages are accepted over WebSocket. Raw text is rejected and logged. Terminal resize commands are bounds-checked to prevent abuse.
+**Rate limiting** — Per-IP rate limits on all endpoints (30 requests/minute for HTTP, 10/minute for ticket minting). Returns 429 Too Many Requests when exceeded.
 
-**Environment isolation** — The child process receives a filtered set of environment variables (an allowlist of ~40 safe variables like PATH, HOME, TERM). Sensitive variables and NODE_OPTIONS are excluded to prevent code injection.
+**Input validation** — Only structured JSON messages are accepted over WebSocket. Raw text is rejected and logged. Terminal resize commands are bounds-checked (1–500 cols, 1–200 rows).
 
-**Audit logging** — All remote keyboard input is logged to `~/.cli-tunnel/audit/` in JSONL format with timestamps and source addresses. Secrets are automatically redacted from audit entries.
+**Environment isolation** — The child process receives filtered environment variables. Dangerous variables (NODE_OPTIONS, BASH_ENV, LD_PRELOAD, etc.) and secrets (tokens, keys, passwords) are stripped.
 
-**Connection limits** — Maximum 5 concurrent WebSocket connections. Sessions expire after 24 hours.
+**Audit logging** — All remote keyboard input is logged to `~/.cli-tunnel/audit/` in JSONL format with timestamps and source addresses. Secrets are automatically redacted (OpenAI, GitHub, AWS, JWT, Slack, npm, PEM, Bearer tokens).
 
-## Terminal Size Behavior
+**Connection limits** — Maximum 5 concurrent WebSocket connections (2 per IP). Ping/pong heartbeat every 30 seconds cleans stale connections. Sessions expire after 4 hours.
 
-cli-tunnel uses a single PTY (pseudo-terminal) shared between your local terminal and all remote viewers. When a phone or tablet connects, the PTY resizes to match the remote device's screen dimensions. This ensures the CLI app renders correctly on the device you're actively using to interact with it.
+**Security headers** — CSP (no unsafe-inline for scripts), HSTS, X-Frame-Options: DENY, X-Content-Type-Options: nosniff, Referrer-Policy: no-referrer, Cache-Control: no-store.
 
-Because the PTY can only have one size at a time, the local terminal on your machine will reflect the remote device's dimensions while it's connected. This is by design — cli-tunnel prioritizes the remote viewing experience since the primary use case is controlling your CLI from another device.
+## Terminal Size Behavior
+
+cli-tunnel uses a single PTY shared between your local terminal and all remote viewers. When a phone connects, the PTY resizes to match the remote device's screen dimensions — the CLI app renders correctly on the device you're actively using.
 
 **Tips for the best experience:**
 - Rotate your phone to landscape for a wider terminal
@@ -107,7 +162,7 @@ Because the PTY can only have one size at a time, the local terminal on your mac
 ## FAQ
 
 **Can multiple devices connect to the same session?**
-Yes, up to 5 devices simultaneously. All viewers see the same terminal output in real time. Input from any device goes to the same CLI session.
+Yes, up to 5 devices simultaneously (2 per IP). All viewers see the same terminal output in real time. Input from any device goes to the same CLI session.
 
 **What happens if my phone disconnects?**
 The CLI session keeps running on your machine. When you reconnect, you'll see live output from that point forward. Use `--replay` to enable history replay so reconnecting devices catch up on what they missed.
@@ -119,18 +174,21 @@ Yes. Any command that runs in a terminal works — copilot, vim, htop, python, s
 No. cli-tunnel runs entirely on your machine. Microsoft Dev Tunnels provides the relay infrastructure, but no third-party server sees your terminal content.
 
 **What about the anti-phishing page?**
-The first time you open a devtunnel URL, Microsoft shows an interstitial warning page. This is a devtunnel security feature — it confirms you trust the tunnel. You only see it once per tunnel.
+The first time you open a devtunnel URL, Microsoft shows an interstitial warning page. This is a devtunnel security feature. You only see it once per tunnel.
 
 **Does the tool work without devtunnel?**
-Yes. Use `--local` to skip tunnel creation. The terminal is available at `http://127.0.0.1:<port>` on your local network only.
+Yes. Use `--local` to skip tunnel creation. The terminal is available at `http://127.0.0.1:<port>` on localhost only.
 
 **What's hub mode?**
-Run `cli-tunnel` with no command to start hub mode — a sessions dashboard that shows all active cli-tunnel sessions on your machine. Tap any online session to connect to it.
+Run `cli-tunnel` with no command to start hub mode — a sessions dashboard that shows all active cli-tunnel sessions. Tap any session to connect, or use Grid view to monitor all sessions simultaneously.
+
+**How does the Grid view connect to sessions?**
+The hub reads session tokens from `~/.cli-tunnel/sessions/` (files with owner-only permissions). It proxies ticket requests to each session's local port — no tokens are exposed to the browser client.
 
 ## How It's Built
 
 - **[node-pty](https://github.com/microsoft/node-pty)** — spawns the command in a pseudo-terminal
-- **[xterm.js](https://xtermjs.org/)** — terminal emulator in the browser (loaded from CDN)
+- **[xterm.js](https://xtermjs.org/)** — terminal emulator in the browser (loaded from CDN with SRI hashes)
 - **[ws](https://github.com/websockets/ws)** — WebSocket server for real-time streaming
 - **[Dev Tunnels](https://learn.microsoft.com/en-us/azure/developer/dev-tunnels/)** — authenticated HTTPS relay
 

package/dist/index.js

@@ -23,6 +23,7 @@ import http from 'node:http';
 import readline from 'node:readline';
 import { WebSocketServer, WebSocket } from 'ws';
 import os from 'node:os';
+import { redactSecrets } from './redact.js';
 function askUser(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
@@ -151,8 +152,8 @@ function readLocalSessions() {
         return [];
     }
 }
-// ─── F-18: Session TTL (24 hours) ──────────────────────────
-const SESSION_TTL = 24 * 60 * 60 * 1000; // 24 hours
+// ─── F-18: Session TTL (4 hours) ───────────────────────────
+const SESSION_TTL = 4 * 60 * 60 * 1000; // 4 hours
 const sessionCreatedAt = Date.now();
 // ─── F-02: One-time ticket store for WebSocket auth ────────
 const tickets = new Map();
@@ -165,24 +166,6 @@ setInterval(() => {
     }
 }, 30000);
 // ─── Security: Redact secrets from replay events ────────────
-function redactSecrets(text) {
-    return text
-        // Generic patterns: key=value, key: value, key="value"
-        .replace(/(?:token|secret|key|password|credential|authorization|api_key|private_key|access_key|connection_string|db_pass|signing)[\s:="']+\S{8,}/gi, '[REDACTED]')
-        // OpenAI keys
-        .replace(/sk-[a-zA-Z0-9]{20,}/g, '[REDACTED]')
-        // GitHub tokens
-        .replace(/gh[ps]_[a-zA-Z0-9]{36,}/g, '[REDACTED]')
-        // AWS keys
-        .replace(/AKIA[A-Z0-9]{16}/g, '[REDACTED]')
-        // Azure connection strings
-        .replace(/DefaultEndpointsProtocol=[^;\s]{20,}/gi, '[REDACTED]')
-        .replace(/AccountKey=[^;\s]{20,}/gi, 'AccountKey=[REDACTED]')
-        // Database URLs
-        .replace(/(postgres|mongodb|mysql|redis):\/\/[^\s"']{10,}/gi, '[REDACTED]')
-        // Bearer tokens in headers
-        .replace(/Bearer\s+[a-zA-Z0-9._-]{20,}/gi, 'Bearer [REDACTED]');
-}
 // ─── Bridge server ──────────────────────────────────────────
 const acpEventLog = [];
 const connections = new Map();
@@ -195,7 +178,51 @@ setInterval(() => {
         }
     }
 }, 60000);
-const server = http.createServer((req, res) => {
+// ─── F-8: Per-IP rate limiter ───────────────────────────────
+const rateLimits = new Map();
+const ticketRateLimits = new Map();
+function checkRateLimit(ip, map, maxRequests) {
+    const now = Date.now();
+    const entry = map.get(ip);
+    if (!entry || entry.resetAt < now) {
+        map.set(ip, { count: 1, resetAt: now + 60000 });
+        return true;
+    }
+    entry.count++;
+    return entry.count <= maxRequests;
+}
+// Clean up rate limit maps every 60s
+setInterval(() => {
+    const now = Date.now();
+    for (const [ip, entry] of rateLimits) {
+        if (entry.resetAt < now)
+            rateLimits.delete(ip);
+    }
+    for (const [ip, entry] of ticketRateLimits) {
+        if (entry.resetAt < now)
+            ticketRateLimits.delete(ip);
+    }
+}, 60000);
+const server = http.createServer(async (req, res) => {
+    const clientIp = req.socket.remoteAddress || 'unknown';
+    // F-8: Rate limiting for HTTP endpoints
+    if (req.url?.startsWith('/api/')) {
+        const isTicket = req.url === '/api/auth/ticket';
+        if (isTicket) {
+            if (!checkRateLimit(clientIp, ticketRateLimits, 10)) {
+                res.writeHead(429, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Too Many Requests' }));
+                return;
+            }
+        }
+        else {
+            if (!checkRateLimit(clientIp, rateLimits, 30)) {
+                res.writeHead(429, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Too Many Requests' }));
+                return;
+            }
+        }
+    }
     // F-18: Session expiry check for API routes
     if (!hubMode && req.url?.startsWith('/api/') && Date.now() - sessionCreatedAt > SESSION_TTL) {
         res.writeHead(401, { 'Content-Type': 'application/json' });
@@ -211,13 +238,14 @@ const server = http.createServer((req, res) => {
             return;
         }
         const ticket = crypto.randomUUID();
-        tickets.set(ticket, { expires: Date.now() + 60000 });
+        const expiresAt = Date.now() + 60000;
+        tickets.set(ticket, { expires: expiresAt });
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ticket, expires: Date.now() + 60000 }));
+        res.end(JSON.stringify({ ticket, expires: expiresAt }));
         return;
     }
-    // F-01: Session token check for all API routes (skip in hub mode)
-    if (!hubMode && req.url?.startsWith('/api/')) {
+    // F-01: Session token check for all API routes
+    if (req.url?.startsWith('/api/')) {
         const reqUrl = new URL(req.url, `http://${req.headers.host}`);
         const authToken = req.headers.authorization?.replace('Bearer ', '') || reqUrl.searchParams.get('token');
         if (authToken !== sessionToken) {
@@ -226,6 +254,46 @@ const server = http.createServer((req, res) => {
             return;
         }
     }
+    // Hub ticket proxy — fetch ticket from local session on behalf of grid client
+    if (hubMode && req.url?.startsWith('/api/proxy/ticket/') && req.method === 'POST') {
+        const ticketPathMatch = req.url?.match(/^\/api\/proxy\/ticket\/(\d+)$/);
+        if (!ticketPathMatch) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid port' }));
+            return;
+        }
+        const targetPort = parseInt(ticketPathMatch[1], 10);
+        if (!Number.isFinite(targetPort) || targetPort < 1 || targetPort > 65535) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid port' }));
+            return;
+        }
+        // Find token for this port from session files
+        const localSessions = readLocalSessions();
+        const session = localSessions.find(s => s.port === targetPort);
+        if (!session) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Session not found' }));
+            return;
+        }
+        try {
+            const ticketResp = await fetch(`http://127.0.0.1:${targetPort}/api/auth/ticket`, {
+                method: 'POST', headers: { 'Authorization': `Bearer ${session.token}` },
+                signal: AbortSignal.timeout(3000),
+            });
+            if (!ticketResp.ok)
+                throw new Error('Ticket request failed');
+            const ticketData = await ticketResp.json();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ticket: ticketData.ticket, port: targetPort }));
+        }
+        catch {
+            res.writeHead(502, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Session unreachable' }));
+            return;
+        }
+        return;
+    }
     // Sessions API
     if ((req.url === '/api/sessions' || req.url?.startsWith('/api/sessions?')) && req.method === 'GET') {
         try {
@@ -256,7 +324,7 @@ const server = http.createServer((req, res) => {
                 const baseId = t.tunnelId?.split('.')[0] || t.tunnelId;
                 const token = tokenMap.get(baseId) || tokenMap.get(t.tunnelId);
                 if (token)
-                    session.token = token;
+                    session.hasToken = true;
                 return session;
             });
             res.writeHead(200, { 'Content-Type': 'application/json', 'X-Frame-Options': 'DENY', 'X-Content-Type-Options': 'nosniff' });
@@ -335,9 +403,10 @@ const server = http.createServer((req, res) => {
         'Content-Type': mimes[ext] || 'application/octet-stream',
         'X-Frame-Options': 'DENY',
         'X-Content-Type-Options': 'nosniff',
-        'Content-Security-Policy': "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; connect-src 'self' ws://localhost:* wss://*.devtunnels.ms;",
+        'Content-Security-Policy': "default-src 'self'; script-src 'self' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; connect-src 'self' ws://localhost:* ws://127.0.0.1:* wss://*.devtunnels.ms https://*.devtunnels.ms;",
         'Referrer-Policy': 'no-referrer',
         'Cache-Control': 'no-store',
+        'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',
     };
     res.writeHead(200, securityHeaders);
     // #8: Handle createReadStream errors
@@ -351,24 +420,10 @@ const wss = new WebSocketServer({
     server,
     maxPayload: 1048576,
     verifyClient: (info) => {
-        if (hubMode)
-            return true; // Hub mode doesn't need WS auth
         // F-18: Session expiry
         if (Date.now() - sessionCreatedAt > SESSION_TTL)
             return false;
-        const url = new URL(info.req.url, `http://${info.req.headers.host}`);
-        // F-02: Accept one-time ticket
-        const ticket = url.searchParams.get('ticket');
-        if (ticket && tickets.has(ticket)) {
-            const t = tickets.get(ticket);
-            tickets.delete(ticket); // Single use
-            return t.expires > Date.now();
-        }
-        // Backward compat: accept token
-        if (url.searchParams.get('token') !== sessionToken)
-            return false;
-        // Validate origin if present
-        // #28: Proper origin validation using URL parsing
+        // F-3: Validate origin BEFORE ticket acceptance
         const origin = info.req.headers.origin;
         if (origin) {
             try {
@@ -382,7 +437,15 @@ const wss = new WebSocketServer({
                 return false;
             }
         }
-        return true;
+        const url = new URL(info.req.url, `http://${info.req.headers.host}`);
+        // F-02: Accept one-time ticket (only auth method for WS)
+        const ticket = url.searchParams.get('ticket');
+        if (ticket && tickets.has(ticket)) {
+            const t = tickets.get(ticket);
+            tickets.delete(ticket); // Single use
+            return t.expires > Date.now();
+        }
+        return false;
     },
 });
 // ─── Security: Audit log for remote PTY input ──────────────
@@ -392,14 +455,27 @@ const auditLogPath = path.join(auditDir, `audit-${new Date().toISOString().slice
 const auditLog = fs.createWriteStream(auditLogPath, { flags: 'a' });
 auditLog.on('error', (err) => { console.error('Audit log error:', err.message); });
 wss.on('connection', (ws, req) => {
-    // F-10: Connection cap
+    // F-10: Connection cap (global + per-IP)
     if (connections.size >= 5) {
         ws.close(1013, 'Max connections reached');
         return;
     }
-    const id = crypto.randomUUID();
     const remoteAddress = req.socket.remoteAddress || 'unknown';
+    let perIpCount = 0;
+    for (const [, c] of connections) {
+        if (c._remoteAddress === remoteAddress)
+            perIpCount++;
+    }
+    if (perIpCount >= 2) {
+        ws.close(1013, 'Max connections per IP reached');
+        return;
+    }
+    const id = crypto.randomUUID();
+    ws._remoteAddress = remoteAddress;
     connections.set(id, ws);
+    // F-10: WS ping/pong heartbeat
+    ws._isAlive = true;
+    ws.on('pong', () => { ws._isAlive = true; });
     // Replay history with secrets redacted (only if replay is enabled)
     if (hasReplay) {
         for (const event of acpEventLog) {
@@ -431,6 +507,18 @@ wss.on('connection', (ws, req) => {
     });
     ws.on('close', () => connections.delete(id));
 });
+// F-10: WS heartbeat — ping every 30s, close unresponsive after 10s
+setInterval(() => {
+    for (const [id, ws] of connections) {
+        if (ws._isAlive === false) {
+            ws.terminate();
+            connections.delete(id);
+            continue;
+        }
+        ws._isAlive = false;
+        ws.ping();
+    }
+}, 30000);
 function broadcast(data) {
     const msg = JSON.stringify({ type: 'pty', data });
     if (hasReplay) {
@@ -459,7 +547,8 @@ async function main() {
     console.log(`\n${BOLD}cli-tunnel${RESET} ${DIM}v1.1.0${RESET}\n`);
     if (hubMode) {
         console.log(`  ${BOLD}📋 Hub Mode${RESET} — sessions dashboard`);
-        console.log(`  ${DIM}Port:${RESET}     ${actualPort}\n`);
+        console.log(`  ${DIM}Port:${RESET}     ${actualPort}`);
+        console.log(`  ${DIM}Local URL:${RESET} http://127.0.0.1:${actualPort}?token=${sessionToken}&hub=1\n`);
     }
     else {
         console.log(`  ${DIM}Command:${RESET}  ${command} ${commandArgs.join(' ')}`);
@@ -580,7 +669,7 @@ async function main() {
                     });
                     hostProc.on('error', (e) => { clearTimeout(timeout); reject(e); });
                 });
-                const tunnelUrlWithToken = `${url}?token=${sessionToken}`;
+                const tunnelUrlWithToken = `${url}?token=${sessionToken}${hubMode ? '&hub=1' : ''}`;
                 console.log(`  ${GREEN}✓${RESET} Tunnel: ${BOLD}${tunnelUrlWithToken}${RESET}\n`);
                 // Write session file for hub discovery
                 writeSessionFile(tunnelId, url, actualPort);
@@ -633,6 +722,21 @@ async function main() {
         // Keep process alive
         await new Promise(() => { });
     }
+    // Wait for user to scan QR / copy URL before starting the CLI tool
+    if (hasTunnel) {
+        console.log(`  ${BOLD}Press any key to start ${command}...${RESET}`);
+        await new Promise((resolve) => {
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.once('data', () => {
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(false);
+                process.stdin.pause();
+                resolve();
+            });
+        });
+    }
     console.log(`  ${DIM}Starting ${command}...${RESET}\n`);
     // Spawn PTY
     const nodePty = await import('node-pty');
@@ -660,8 +764,11 @@ async function main() {
     // Blocklist approach: pass everything except known dangerous vars and secrets
     const DANGEROUS_VARS = new Set(['NODE_OPTIONS', 'NODE_REPL_HISTORY', 'NODE_EXTRA_CA_CERTS',
         'NODE_PATH', 'NODE_REDIRECT_WARNINGS', 'NODE_PENDING_DEPRECATION',
-        'UV_THREADPOOL_SIZE', 'LD_PRELOAD', 'DYLD_INSERT_LIBRARIES']);
-    const sensitivePattern = /token|secret|key|password|credential|api_key|private_key|access_key|connection_string|auth/i;
+        'UV_THREADPOOL_SIZE', 'LD_PRELOAD', 'DYLD_INSERT_LIBRARIES',
+        'SSH_AUTH_SOCK', 'GPG_TTY',
+        'PYTHONPATH', 'BASH_ENV', 'BASH_FUNC', 'JAVA_TOOL_OPTIONS', 'JAVA_OPTIONS', '_JAVA_OPTIONS',
+        'PROMPT_COMMAND', 'ENV', 'ZDOTDIR', 'PERL5OPT', 'RUBYOPT']);
+    const sensitivePattern = /token|secret|key|password|credential|api_key|private_key|access_key|connection_string|auth|kubeconfig|docker_host|docker_config/i;
     const safeEnv = {};
     for (const [k, v] of Object.entries(process.env)) {
         if (v !== undefined && !DANGEROUS_VARS.has(k) && !sensitivePattern.test(k)) {
@@ -674,23 +781,28 @@ async function main() {
         env: safeEnv,
     });
     // Detect CSPRNG crash (rare Node.js + PTY issue) and show helpful message
-    let ptyExitedEarly = false;
+    let earlyExitCode = null;
     const earlyExitCheck = new Promise((resolve) => {
         ptyProcess.onExit(({ exitCode }) => {
-            if (exitCode === 134 || exitCode === 3221226505) {
-                ptyExitedEarly = true;
-                resolve();
-            }
+            earlyExitCode = exitCode;
+            resolve();
         });
         setTimeout(resolve, 2000);
     });
     await earlyExitCheck;
-    if (ptyExitedEarly) {
-        const nodeVer = process.version;
-        console.log(`  ${YELLOW}⚠${RESET} The command crashed (CSPRNG assertion failure).`);
-        console.log(`  This is a known issue with Node.js ${nodeVer} + PTY on Windows.`);
-        console.log(`  ${BOLD}Fix:${RESET} Install Node.js 22 LTS: ${GREEN}nvm install 22${RESET} or ${GREEN}winget install OpenJS.NodeJS.LTS${RESET}\n`);
-        process.exit(1);
+    if (earlyExitCode !== null) {
+        if (earlyExitCode === 134 || earlyExitCode === 3221226505) {
+            const nodeVer = process.version;
+            console.log(`  ${YELLOW}⚠${RESET} The command crashed (CSPRNG assertion failure).`);
+            console.log(`  This is a known issue with Node.js ${nodeVer} + PTY on Windows.`);
+            console.log(`  ${BOLD}Fix:${RESET} Install Node.js 22 LTS: ${GREEN}nvm install 22${RESET} or ${GREEN}winget install OpenJS.NodeJS.LTS${RESET}\n`);
+            process.exit(1);
+        }
+        else {
+            console.log(`\n${DIM}Process exited (code ${earlyExitCode}).${RESET}`);
+            server.close();
+            process.exit(earlyExitCode);
+        }
     }
     ptyProcess.onData((data) => {
         process.stdout.write(data);

package/dist/redact.d.ts

@@ -0,0 +1 @@
+export declare function redactSecrets(text: string): string;

package/dist/redact.js

@@ -0,0 +1,26 @@
+export function redactSecrets(text) {
+    return text
+        // Generic patterns: key=value, key: value, key="value"
+        .replace(/(?:token|secret|key|password|credential|authorization|api_key|private_key|access_key|connection_string|db_pass|signing)[\s:="']+\S{8,}/gi, '[REDACTED]')
+        // OpenAI keys
+        .replace(/sk-[a-zA-Z0-9]{20,}/g, '[REDACTED]')
+        // GitHub tokens
+        .replace(/gh[ps]_[a-zA-Z0-9]{36,}/g, '[REDACTED]')
+        // AWS keys
+        .replace(/AKIA[A-Z0-9]{16}/g, '[REDACTED]')
+        // Azure connection strings
+        .replace(/DefaultEndpointsProtocol=[^;\s]{20,}/gi, '[REDACTED]')
+        .replace(/AccountKey=[^;\s]{20,}/gi, 'AccountKey=[REDACTED]')
+        // Database URLs
+        .replace(/(postgres|mongodb|mysql|redis):\/\/[^\s"']{10,}/gi, '[REDACTED]')
+        // Bearer tokens in headers
+        .replace(/Bearer\s+[a-zA-Z0-9._-]{20,}/gi, 'Bearer [REDACTED]')
+        // JWT tokens
+        .replace(/eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g, '[REDACTED]')
+        // Slack tokens
+        .replace(/xox[bpras]-[a-zA-Z0-9-]{10,}/g, '[REDACTED]')
+        // npm tokens
+        .replace(/npm_[a-zA-Z0-9]{20,}/g, '[REDACTED]')
+        // PEM private keys
+        .replace(/-----BEGIN [A-Z ]+ PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+ PRIVATE KEY-----/g, '[REDACTED]');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-tunnel",
-  "version": "1.2.0-beta.9",
+  "version": "1.2.0",
   "description": "Tunnel any CLI app to your phone — PTY + devtunnel + xterm.js",
   "type": "module",
   "main": "dist/index.js",
@@ -13,7 +13,8 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
   },
   "keywords": [
     "cli",
@@ -35,13 +36,14 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "node-pty": "^1.1.0",
-    "qrcode-terminal": "^0.12.0",
-    "ws": "^8.19.0"
+    "node-pty": "1.1.0",
+    "qrcode-terminal": "0.12.0",
+    "ws": "8.19.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.2",
     "@types/ws": "^8.18.1",
+    "@vitest/coverage-v8": "^4.0.18",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   }