sessioncast-cli 2.2.2 → 2.3.1

package/dist/commands/tunnel.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTunnel = startTunnel;
+const chalk_1 = __importDefault(require("chalk"));
+const runner_1 = require("../agent/runner");
+const browser_handler_1 = require("../agent/browser-handler");
+const websocket_1 = require("../agent/websocket");
+const debug_1 = require("../agent/debug");
+const sentry_1 = require("../sentry");
+const BATCH_INTERVAL_MS = 50;
+const META_INTERVAL_MS = 15000;
+const FULL_SNAPSHOT_TYPE = 2; // rrweb EventType.FullSnapshot
+async function startTunnel(url, options) {
+    try {
+        if (options.debug) {
+            (0, debug_1.setDebug)(true);
+            console.log(chalk_1.default.yellow('[DEBUG] Debug mode enabled'));
+        }
+        // Load agent config for relay connection
+        const config = await runner_1.AgentRunner.loadConfig(options.config);
+        const cdpPort = options.cdpPort || 9222;
+        const width = options.width || 1280;
+        const height = options.height || 720;
+        console.log(chalk_1.default.bold('\n  SessionCast Tunnel\n'));
+        console.log(`  URL: ${chalk_1.default.cyan(url)}`);
+        console.log(`  Viewport: ${width}x${height}`);
+        console.log(`  Relay: ${config.relay}`);
+        console.log('');
+        // Start headless browser
+        const browser = new browser_handler_1.BrowserHandler();
+        console.log(chalk_1.default.gray('  Starting headless Chrome...'));
+        await browser.start(cdpPort, {
+            url,
+            width,
+            height,
+            chromePath: options.chromePath,
+        });
+        console.log(chalk_1.default.green('  Chrome started'));
+        // Build session ID for tunnel mode (tunnel-{hostname} matches web client detection)
+        const hostname = new URL(url).hostname;
+        const sessionId = `${config.machineId}/tunnel-${hostname}`;
+        // Connect to relay (skipAutoRegister: true — we send custom register with tunnel metadata)
+        const ws = new websocket_1.RelayWebSocketClient({
+            url: config.relay,
+            sessionId,
+            machineId: config.machineId,
+            token: config.token,
+            label: `tunnel:${hostname}`,
+            skipAutoRegister: true,
+        });
+        // Custom register handler with tunnel metadata
+        const registerTunnel = () => {
+            ws.send({
+                type: 'register',
+                role: 'host',
+                session: sessionId,
+                meta: {
+                    label: `tunnel:${hostname}`,
+                    machineId: config.machineId,
+                    token: config.token,
+                    tunnel: 'true',
+                    tunnelUrl: url,
+                    viewportWidth: String(width),
+                    viewportHeight: String(height),
+                },
+            });
+        };
+        // Note: connected/disconnected handlers are set up below with event batching
+        ws.on('error', (err) => {
+            (0, debug_1.debugLog)('Tunnel', 'WebSocket error:', err.message);
+        });
+        // Handle input events from viewer
+        ws.on('webInput', (event) => {
+            (0, debug_1.debugLog)('Tunnel', 'Input event:', event.inputType || event.type);
+            browser.dispatchInput(event).catch((err) => {
+                (0, debug_1.debugLog)('Tunnel', 'dispatchInput error:', err.message);
+            });
+        });
+        // Handle snapshot request from relay (viewer joined / refreshed)
+        // Debounce to avoid excessive reloads when multiple viewers join at once
+        let snapshotTimer = null;
+        ws.on('requestSnapshot', () => {
+            (0, debug_1.debugLog)('Tunnel', 'Snapshot requested by relay');
+            if (snapshotTimer)
+                return; // already scheduled
+            snapshotTimer = setTimeout(() => {
+                snapshotTimer = null;
+                browser.takeFullSnapshot();
+            }, 1000);
+        });
+        // Handle navigation from viewer (localhost only for security)
+        ws.on('webNavigate', (navUrl) => {
+            try {
+                const parsed = new URL(navUrl);
+                if (parsed.hostname !== 'localhost' && parsed.hostname !== '127.0.0.1') {
+                    console.log(chalk_1.default.yellow(`  Blocked navigation to non-localhost URL: ${navUrl}`));
+                    return;
+                }
+            }
+            catch {
+                console.log(chalk_1.default.yellow(`  Blocked navigation to invalid URL: ${navUrl}`));
+                return;
+            }
+            console.log(chalk_1.default.gray(`  Navigating to: ${navUrl}`));
+            browser.navigate(navUrl).catch((err) => {
+                (0, debug_1.debugLog)('Tunnel', 'navigate error:', err.message);
+            });
+        });
+        // Event batching — buffer events until WebSocket is connected
+        let eventBatch = [];
+        let batchTimer = null;
+        let wsConnected = false;
+        ws.on('connected', () => {
+            console.log(chalk_1.default.green('  Connected to relay'));
+            registerTunnel();
+            wsConnected = true;
+            // Flush any events buffered before connection
+            setTimeout(() => flushBatch(), 100);
+            // After reconnect, send a fresh FullSnapshot so viewers get current DOM state
+            setTimeout(() => {
+                browser.takeFullSnapshot();
+            }, 500);
+        });
+        ws.on('disconnected', () => {
+            console.log(chalk_1.default.yellow('  Disconnected from relay'));
+            wsConnected = false;
+        });
+        function flushBatch() {
+            if (eventBatch.length === 0)
+                return;
+            // Don't flush if WebSocket isn't connected — keep buffered
+            if (!wsConnected)
+                return;
+            const batch = eventBatch;
+            eventBatch = [];
+            // FullSnapshot events get sent individually (they're large)
+            const fullSnapshots = batch.filter((e) => e.type === FULL_SNAPSHOT_TYPE);
+            const others = batch.filter((e) => e.type !== FULL_SNAPSHOT_TYPE);
+            for (const snap of fullSnapshots) {
+                ws.sendWebDom(snap);
+            }
+            if (others.length > 0) {
+                ws.sendWebDomBatch(others);
+            }
+        }
+        // Stream DOM events from browser
+        browser.onDomEvent((event) => {
+            eventBatch.push(event);
+            // FullSnapshot: flush immediately (if connected)
+            if (event.type === FULL_SNAPSHOT_TYPE) {
+                flushBatch();
+                return;
+            }
+            // Otherwise batch with a timer
+            if (!batchTimer) {
+                batchTimer = setTimeout(() => {
+                    batchTimer = null;
+                    flushBatch();
+                }, BATCH_INTERVAL_MS);
+            }
+        });
+        // Periodically send page metadata
+        const metaTimer = setInterval(async () => {
+            if (!browser.isRunning())
+                return;
+            ws.sendWebMeta({
+                url: url,
+                viewportWidth: String(width),
+                viewportHeight: String(height),
+                timestamp: String(Date.now()),
+            });
+        }, META_INTERVAL_MS);
+        // Connect to relay
+        ws.connect();
+        console.log(chalk_1.default.green.bold('  Tunnel active'));
+        console.log(chalk_1.default.gray('  Press Ctrl+C to stop\n'));
+        // Graceful shutdown
+        const shutdown = () => {
+            console.log(chalk_1.default.gray('\n  Shutting down tunnel...'));
+            clearInterval(metaTimer);
+            if (batchTimer)
+                clearTimeout(batchTimer);
+            flushBatch();
+            browser.stop();
+            ws.destroy();
+            console.log(chalk_1.default.green('  Tunnel stopped'));
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (error) {
+        (0, sentry_1.captureException)(error);
+        await (0, sentry_1.flush)();
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -46,6 +46,7 @@ const agents_1 = require("./commands/agents");
 const sessions_1 = require("./commands/sessions");
 const sendkeys_1 = require("./commands/sendkeys");
 const agent_1 = require("./commands/agent");
+const tunnel_1 = require("./commands/tunnel");
 const config_1 = require("./config");
 const sentry_1 = require("./sentry");
 // Initialize Sentry as early as possible
@@ -211,6 +212,28 @@ program
     .option('-c, --config <path>', 'Path to config file')
     .option('-d, --debug', 'Enable debug logging')
     .action(agent_1.startAgent);
+// Tunnel command
+program
+    .command('tunnel <target>')
+    .description('Stream a local web service via headless Chrome (port number or URL)')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-d, --debug', 'Enable debug logging')
+    .option('-W, --width <pixels>', 'Viewport width', '1280')
+    .option('-H, --height <pixels>', 'Viewport height', '720')
+    .option('--chrome-path <path>', 'Path to Chrome binary')
+    .option('--cdp-port <port>', 'Chrome DevTools Protocol port', '9222')
+    .action((target, opts) => {
+    // Accept port number (e.g., 3000) or full URL (e.g., http://localhost:3000)
+    const url = /^\d+$/.test(target) ? `http://localhost:${target}` : target;
+    (0, tunnel_1.startTunnel)(url, {
+        config: opts.config,
+        debug: opts.debug,
+        width: parseInt(opts.width, 10),
+        height: parseInt(opts.height, 10),
+        chromePath: opts.chromePath,
+        cdpPort: parseInt(opts.cdpPort, 10),
+    });
+});
 // Help examples
 program.on('--help', () => {
     console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sessioncast-cli",
-  "version": "2.2.2",
+  "version": "2.3.1",
   "description": "SessionCast CLI - Control your agents from anywhere",
   "main": "dist/index.js",
   "bin": {
@@ -50,7 +50,8 @@
     "node-fetch": "^2.7.0",
     "open": "^8.4.2",
     "ora": "^5.4.1",
-    "ws": "^8.18.0"
+    "ws": "^8.18.0",
+    "zstd-napi": "^0.0.12"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",