sessioncast-cli 2.3.0 → 2.3.1

package/dist/agent/websocket.js

@@ -40,6 +40,8 @@ exports.RelayWebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const zlib = __importStar(require("zlib"));
+const zstd = __importStar(require("zstd-napi"));
+const crypto_1 = require("./crypto");
 const debug_1 = require("./debug");
 const MAX_RECONNECT_ATTEMPTS = 5;
 const BASE_RECONNECT_DELAY_MS = 2000;
@@ -49,6 +51,7 @@ class RelayWebSocketClient extends events_1.EventEmitter {
     constructor(options) {
         super();
         this.ws = null;
+        this.encKeyBuf = null;
         this.isConnected = false;
         this.reconnectAttempts = 0;
         this.circuitBreakerOpen = false;
@@ -61,6 +64,10 @@ class RelayWebSocketClient extends events_1.EventEmitter {
         this.token = options.token;
         this.label = options.label || options.sessionId;
         this.autoReconnect = options.autoReconnect ?? true;
+        if (options.encKey) {
+            this.encKeyBuf = Buffer.from(options.encKey, 'base64url');
+        }
+        this.skipAutoRegister = options.skipAutoRegister ?? false;
     }
     connect() {
         if (this.destroyed)
@@ -72,7 +79,9 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                 this.reconnectAttempts = 0;
                 this.circuitBreakerOpen = false;
                 this.emit('connected');
-                this.registerAsHost();
+                if (!this.skipAutoRegister) {
+                    this.registerAsHost();
+                }
             });
             this.ws.on('message', (data) => {
                 try {
@@ -116,9 +125,28 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             meta
         });
     }
+    decryptPayload(payload) {
+        if (!this.encKeyBuf)
+            return payload;
+        try {
+            const buf = Buffer.from(payload, 'base64');
+            const decrypted = (0, crypto_1.decrypt)(buf, this.encKeyBuf);
+            return decrypted.toString('utf-8');
+        }
+        catch {
+            // If decryption fails, return as-is (unencrypted message)
+            return payload;
+        }
+    }
     handleMessage(message) {
         (0, debug_1.debugLog)('WS:IN', message.type, message.session);
         switch (message.type) {
+            case 'keysEnc':
+                if (message.session === this.sessionId && message.payload) {
+                    const keys = this.decryptPayload(message.payload);
+                    this.emit('keys', keys, message.meta?.pane);
+                }
+                break;
             case 'keys':
                 if (message.session === this.sessionId && message.payload) {
                     this.emit('keys', message.payload, message.meta?.pane);
@@ -148,6 +176,25 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                     this.emit('createWorktree', message.meta.branch);
                 }
                 break;
+            case 'webInput':
+                if (message.session === this.sessionId && message.payload) {
+                    try {
+                        const inputEvent = JSON.parse(message.payload);
+                        this.emit('webInput', inputEvent);
+                    }
+                    catch { /* ignore parse errors */ }
+                }
+                break;
+            case 'webNavigate':
+                if (message.session === this.sessionId && message.meta?.url) {
+                    this.emit('webNavigate', message.meta.url);
+                }
+                break;
+            case 'requestSnapshot':
+                if (message.session === this.sessionId) {
+                    this.emit('requestSnapshot');
+                }
+                break;
             case 'requestFileView':
                 if (message.session === this.sessionId && message.meta?.filePath) {
                     this.emit('requestFileView', message.meta.filePath);
@@ -268,17 +315,37 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             meta
         });
     }
+    compressAndEncrypt(data) {
+        // Step 1: Compress with zstd (fallback to gzip)
+        let compressed;
+        let compressType = 'zstd';
+        try {
+            compressed = zstd.compress(data, { compressionLevel: 3 });
+        }
+        catch {
+            compressed = zlib.gzipSync(data);
+            compressType = 'gz';
+        }
+        // Step 2: Encrypt if encKey is available
+        if (this.encKeyBuf) {
+            const encrypted = (0, crypto_1.encrypt)(compressed, this.encKeyBuf);
+            return {
+                payload: encrypted.toString('base64'),
+                type: 'screenEnc'
+            };
+        }
+        // No encryption — send compressed only
+        return {
+            payload: compressed.toString('base64'),
+            type: compressType === 'zstd' ? 'screenZstd' : 'screenGz'
+        };
+    }
     sendScreenCompressed(data) {
         if (!this.isConnected)
             return false;
         try {
-            const compressed = zlib.gzipSync(data);
-            const base64Data = compressed.toString('base64');
-            return this.send({
-                type: 'screenGz',
-                session: this.sessionId,
-                payload: base64Data
-            });
+            const { payload, type } = this.compressAndEncrypt(data);
+            return this.send({ type, session: this.sessionId, payload });
         }
         catch {
             return this.sendScreen(data);
@@ -288,13 +355,8 @@ class RelayWebSocketClient extends events_1.EventEmitter {
         if (!this.isConnected)
             return false;
         try {
-            const compressed = zlib.gzipSync(data);
-            return this.send({
-                type: 'screenGz',
-                session: this.sessionId,
-                payload: compressed.toString('base64'),
-                meta
-            });
+            const { payload, type } = this.compressAndEncrypt(data);
+            return this.send({ type, session: this.sessionId, payload, meta });
         }
         catch {
             return this.sendScreenWithMeta(data, meta);
@@ -370,6 +432,42 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             }
         });
     }
+    /**
+     * Send a single rrweb DOM event to the relay.
+     */
+    sendWebDom(event) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'webDom',
+            session: this.sessionId,
+            payload: JSON.stringify(event),
+        });
+    }
+    /**
+     * Send a batch of rrweb DOM events.
+     */
+    sendWebDomBatch(events) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'webDomBatch',
+            session: this.sessionId,
+            payload: JSON.stringify(events),
+        });
+    }
+    /**
+     * Send web page metadata (title, URL, viewport).
+     */
+    sendWebMeta(meta) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'webMeta',
+            session: this.sessionId,
+            meta,
+        });
+    }
     getConnected() {
         return this.isConnected;
     }

package/dist/commands/agent.js

@@ -14,7 +14,7 @@ async function startAgent(options) {
             (0, debug_1.setDebug)(true);
             console.log(chalk_1.default.yellow('[DEBUG] Debug mode enabled'));
         }
-        const config = runner_1.AgentRunner.loadConfig(options.config);
+        const config = await runner_1.AgentRunner.loadConfig(options.config);
         const runner = new runner_1.AgentRunner(config);
         await runner.start();
     }

package/dist/commands/tunnel.d.ts

@@ -0,0 +1,10 @@
+interface TunnelOptions {
+    config?: string;
+    debug?: boolean;
+    width?: number;
+    height?: number;
+    chromePath?: string;
+    cdpPort?: number;
+}
+export declare function startTunnel(url: string, options: TunnelOptions): Promise<void>;
+export {};

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.3.0",
+  "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",