sessioncast-cli 2.3.0 → 2.3.1

package/dist/agent/cdp-client.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const events_1 = require("events");
+const debug_1 = require("./debug");
+/**
+ * Lightweight Chrome DevTools Protocol client.
+ * Uses the existing `ws` package — no additional dependencies.
+ */
+class CdpClient extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.ws = null;
+        this.nextId = 1;
+        this.callbacks = new Map();
+        this.connected = false;
+    }
+    /**
+     * Connect to a Chrome DevTools WebSocket URL.
+     * URL is obtained from Chrome's --remote-debugging-port output.
+     */
+    async connect(browserDebugUrl) {
+        return new Promise((resolve, reject) => {
+            this.ws = new ws_1.default(browserDebugUrl);
+            this.ws.on('open', () => {
+                this.connected = true;
+                (0, debug_1.debugLog)('CDP', 'Connected to', browserDebugUrl);
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.id !== undefined) {
+                        // Response to a command
+                        const cb = this.callbacks.get(msg.id);
+                        if (cb) {
+                            this.callbacks.delete(msg.id);
+                            if (msg.error) {
+                                cb.reject(new Error(`CDP error: ${msg.error.message}`));
+                            }
+                            else {
+                                cb.resolve(msg.result);
+                            }
+                        }
+                    }
+                    else if (msg.method) {
+                        // Event notification
+                        this.emit(msg.method, msg.params);
+                    }
+                }
+                catch (e) {
+                    (0, debug_1.debugLog)('CDP', 'Failed to parse message:', e.message);
+                }
+            });
+            this.ws.on('close', () => {
+                this.connected = false;
+                this.emit('close');
+                // Reject all pending callbacks
+                for (const [id, cb] of this.callbacks) {
+                    cb.reject(new Error('CDP connection closed'));
+                    this.callbacks.delete(id);
+                }
+            });
+            this.ws.on('error', (err) => {
+                if (!this.connected) {
+                    reject(err);
+                }
+                this.emit('error', err);
+            });
+        });
+    }
+    /**
+     * Send a CDP command and wait for the response.
+     */
+    async send(method, params) {
+        if (!this.ws || !this.connected) {
+            throw new Error('CDP not connected');
+        }
+        const id = this.nextId++;
+        const message = { id, method };
+        if (params) {
+            message.params = params;
+        }
+        return new Promise((resolve, reject) => {
+            this.callbacks.set(id, { resolve, reject });
+            this.ws.send(JSON.stringify(message), (err) => {
+                if (err) {
+                    this.callbacks.delete(id);
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Check if connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Close the CDP connection.
+     */
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+    }
+}
+exports.CdpClient = CdpClient;

package/dist/agent/chrome-finder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Find system Chrome/Chromium binary path.
+ * Returns null if no Chrome installation is found.
+ */
+export declare function findChromePath(): string | null;

package/dist/agent/chrome-finder.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findChromePath = findChromePath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+/**
+ * Find system Chrome/Chromium binary path.
+ * Returns null if no Chrome installation is found.
+ */
+function findChromePath() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        const macPaths = [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            path.join(os.homedir(), 'Applications/Google Chrome.app/Contents/MacOS/Google Chrome'),
+        ];
+        for (const p of macPaths) {
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    else if (platform === 'linux') {
+        const linuxNames = [
+            'google-chrome-stable',
+            'google-chrome',
+            'chromium-browser',
+            'chromium',
+        ];
+        for (const name of linuxNames) {
+            try {
+                const result = (0, child_process_1.execSync)(`which ${name}`, { stdio: 'pipe' }).toString().trim();
+                if (result)
+                    return result;
+            }
+            catch { /* not found */ }
+        }
+        // Common Linux paths
+        const linuxPaths = [
+            '/usr/bin/google-chrome-stable',
+            '/usr/bin/google-chrome',
+            '/usr/bin/chromium-browser',
+            '/usr/bin/chromium',
+            '/snap/bin/chromium',
+        ];
+        for (const p of linuxPaths) {
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    else if (platform === 'win32') {
+        const winPaths = [
+            path.join(process.env['PROGRAMFILES'] || '', 'Google/Chrome/Application/chrome.exe'),
+            path.join(process.env['PROGRAMFILES(X86)'] || '', 'Google/Chrome/Application/chrome.exe'),
+            path.join(process.env['LOCALAPPDATA'] || '', 'Google/Chrome/Application/chrome.exe'),
+            path.join(process.env['PROGRAMFILES'] || '', 'Chromium/Application/chrome.exe'),
+        ];
+        for (const p of winPaths) {
+            if (p && fs.existsSync(p))
+                return p;
+        }
+    }
+    return null;
+}

package/dist/agent/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(data: Buffer, key: Buffer): Buffer;
+export declare function decrypt(data: Buffer, key: Buffer): Buffer;

package/dist/agent/crypto.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+const crypto_1 = require("crypto");
+const ALGO = 'aes-256-gcm';
+const IV_LEN = 12;
+const TAG_LEN = 16;
+function encrypt(data, key) {
+    const iv = (0, crypto_1.randomBytes)(IV_LEN);
+    const cipher = (0, crypto_1.createCipheriv)(ALGO, key, iv);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    // Format: [iv(12) | tag(16) | ciphertext]
+    return Buffer.concat([iv, tag, encrypted]);
+}
+function decrypt(data, key) {
+    const iv = data.subarray(0, IV_LEN);
+    const tag = data.subarray(IV_LEN, IV_LEN + TAG_LEN);
+    const ciphertext = data.subarray(IV_LEN + TAG_LEN);
+    const decipher = (0, crypto_1.createDecipheriv)(ALGO, key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}

package/dist/agent/runner.d.ts

@@ -6,11 +6,17 @@ export declare class AgentRunner {
     private scanTimer;
     private running;
     constructor(config: AgentConfig);
-    static loadConfig(configPath?: string): AgentConfig;
+    /**
+     * Fetch optimal relay URL from Platform API using agent token.
+     * Returns null on failure (caller should fall back to default).
+     */
+    private static fetchRelayUrlForAgent;
+    static loadConfig(configPath?: string): Promise<AgentConfig>;
     start(): Promise<void>;
     private scanAndUpdateSessions;
     private startSessionHandler;
     private stopSessionHandler;
     private createTmuxSession;
+    private fetchEncKey;
     stop(): void;
 }

package/dist/agent/runner.js

@@ -32,12 +32,16 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRunner = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const yaml = __importStar(require("js-yaml"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
 const session_handler_1 = require("./session-handler");
 const api_client_1 = require("./api-client");
 const tmux = __importStar(require("./tmux"));
@@ -52,7 +56,29 @@ class AgentRunner {
         this.running = false;
         this.config = config;
     }
-    static loadConfig(configPath) {
+    /**
+     * Fetch optimal relay URL from Platform API using agent token.
+     * Returns null on failure (caller should fall back to default).
+     */
+    static async fetchRelayUrlForAgent(token) {
+        try {
+            const apiUrl = (0, config_1.getApiUrl)();
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3000);
+            const res = await (0, node_fetch_1.default)(`${apiUrl}/public/agent-tokens/${token}/relay`, {
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (!res.ok)
+                return null;
+            const data = await res.json();
+            return data.relayUrl || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async loadConfig(configPath) {
         // Check if agent token is available (for relay connection)
         const agentToken = (0, config_1.getAgentToken)();
         // Check environment variable
@@ -75,9 +101,18 @@ class AgentRunner {
         if ((!finalPath || !fs.existsSync(finalPath)) && agentToken) {
             console.log('Using OAuth authentication');
             const machineId = os.hostname();
+            // Try to fetch optimal relay URL from Platform API
+            let relayUrl = await AgentRunner.fetchRelayUrlForAgent(agentToken);
+            if (relayUrl) {
+                console.log(`Fetched relay URL from Platform API: ${relayUrl}`);
+            }
+            else {
+                relayUrl = (0, config_1.getRelayUrl)();
+                console.log(`Using default relay URL: ${relayUrl}`);
+            }
             return {
                 machineId,
-                relay: (0, config_1.getRelayUrl)(),
+                relay: relayUrl,
                 token: agentToken,
                 api: {
                     enabled: false
@@ -101,10 +136,23 @@ class AgentRunner {
         if (this.running)
             return;
         this.running = true;
+        // Fetch encryption key from Platform API if not already set
+        if (!this.config.encKey && this.config.token) {
+            try {
+                const encKey = await this.fetchEncKey(this.config.token);
+                if (encKey) {
+                    this.config.encKey = encKey;
+                }
+            }
+            catch (e) {
+                console.warn('Failed to fetch encryption key (E2E disabled):', e.message);
+            }
+        }
         console.log('Starting SessionCast Agent...');
         console.log(`Machine ID: ${this.config.machineId}`);
         console.log(`Relay: ${this.config.relay}`);
         console.log(`Token: ${this.config.token ? 'present' : 'none'}`);
+        console.log(`E2E Encryption: ${this.config.encKey ? 'enabled' : 'disabled'}`);
         // Check tmux/itmux availability before starting
         if (!tmux.isAvailable()) {
             const platform = os.platform();
@@ -220,6 +268,16 @@ class AgentRunner {
             console.error(`Failed to create tmux session: ${sanitized}`);
         }
     }
+    async fetchEncKey(agentToken) {
+        const fetch = (await Promise.resolve().then(() => __importStar(require('node-fetch')))).default;
+        const apiUrl = (0, config_1.getApiUrl)();
+        const url = `${apiUrl}/internal/agents/enc-key?token=${encodeURIComponent(agentToken)}`;
+        const res = await fetch(url, { timeout: 5000 });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.encKey || null;
+    }
     stop() {
         console.log('Shutting down Agent...');
         this.running = false;

package/dist/agent/session-handler.js

@@ -89,7 +89,8 @@ class TmuxSessionHandler {
             machineId: this.config.machineId,
             token: this.config.token,
             label: this.tmuxSession,
-            autoReconnect: true
+            autoReconnect: true,
+            encKey: this.config.encKey
         });
         this.wsClient.on('connected', () => {
             console.log(`[${this.tmuxSession}] Connected to relay`);

package/dist/agent/tunnel-handler.d.ts

@@ -0,0 +1,12 @@
+export declare class TunnelHandler {
+    private port;
+    private host;
+    private activeRequests;
+    private readonly MAX_CONCURRENT;
+    private readonly MAX_RESPONSE_SIZE;
+    private readonly CHUNK_SIZE;
+    constructor(port: number, host?: string);
+    handleRequest(requestId: string, method: string, path: string, queryString: string, headers: Record<string, string>, body: string | undefined, sendResponse: (msg: any) => void): Promise<void>;
+    private getBase64ChunkSize;
+    private makeHttpRequest;
+}

package/dist/agent/tunnel-handler.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelHandler = void 0;
+const http = __importStar(require("http"));
+const debug_1 = require("./debug");
+const ALLOWED_HOSTS = ['localhost', '127.0.0.1', '::1'];
+class TunnelHandler {
+    constructor(port, host = 'localhost') {
+        this.activeRequests = 0;
+        this.MAX_CONCURRENT = 10;
+        this.MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5MB
+        this.CHUNK_SIZE = 200 * 1024; // 200KB before base64
+        this.port = port;
+        this.host = host;
+    }
+    async handleRequest(requestId, method, path, queryString, headers, body, sendResponse) {
+        // Check concurrent limit
+        if (this.activeRequests >= this.MAX_CONCURRENT) {
+            sendResponse({
+                requestId,
+                statusCode: 503,
+                headers: { 'content-type': 'text/plain' },
+                body: Buffer.from('Too many concurrent requests').toString('base64'),
+            });
+            return;
+        }
+        // Validate host (SSRF prevention)
+        if (!ALLOWED_HOSTS.includes(this.host)) {
+            sendResponse({
+                requestId,
+                statusCode: 403,
+                headers: { 'content-type': 'text/plain' },
+                body: Buffer.from('Forbidden: only localhost connections allowed').toString('base64'),
+            });
+            return;
+        }
+        this.activeRequests++;
+        try {
+            const fullPath = queryString ? `${path}?${queryString}` : path;
+            const requestBody = body ? Buffer.from(body, 'base64') : undefined;
+            (0, debug_1.debugLog)('TUNNEL', `${method} ${fullPath} -> ${this.host}:${this.port}`);
+            const { statusCode, responseHeaders, responseBody } = await this.makeHttpRequest(method, fullPath, headers, requestBody);
+            const bodyBase64 = responseBody.toString('base64');
+            if (responseBody.length > this.CHUNK_SIZE) {
+                // Split into chunks
+                const totalChunks = Math.ceil(bodyBase64.length / this.getBase64ChunkSize());
+                for (let i = 0; i < totalChunks; i++) {
+                    const start = i * this.getBase64ChunkSize();
+                    const end = Math.min(start + this.getBase64ChunkSize(), bodyBase64.length);
+                    const chunk = bodyBase64.slice(start, end);
+                    const isFinal = i === totalChunks - 1;
+                    sendResponse({
+                        requestId,
+                        statusCode,
+                        headers: responseHeaders,
+                        body: chunk,
+                        chunkIndex: i,
+                        isFinal,
+                        chunked: true,
+                    });
+                }
+            }
+            else {
+                sendResponse({
+                    requestId,
+                    statusCode,
+                    headers: responseHeaders,
+                    body: bodyBase64,
+                });
+            }
+        }
+        catch (error) {
+            (0, debug_1.debugLog)('TUNNEL', `Error: ${error.message}`);
+            sendResponse({
+                requestId,
+                statusCode: 502,
+                headers: { 'content-type': 'text/plain' },
+                body: Buffer.from(`Bad Gateway: ${error.message}`).toString('base64'),
+            });
+        }
+        finally {
+            this.activeRequests--;
+        }
+    }
+    getBase64ChunkSize() {
+        // base64 encoding expands data by ~4/3, so chunk size in base64 chars
+        // for 200KB raw data is approximately 200*1024*4/3 ≈ 273KB base64
+        return Math.ceil(this.CHUNK_SIZE * 4 / 3);
+    }
+    makeHttpRequest(method, path, headers, body) {
+        return new Promise((resolve, reject) => {
+            // Build headers, removing hop-by-hop headers that shouldn't be forwarded
+            const forwardHeaders = {
+                ...headers,
+                host: `${this.host}:${this.port}`,
+            };
+            delete forwardHeaders['connection'];
+            delete forwardHeaders['keep-alive'];
+            delete forwardHeaders['transfer-encoding'];
+            const options = {
+                hostname: this.host,
+                port: this.port,
+                path,
+                method,
+                headers: forwardHeaders,
+                timeout: 30000,
+            };
+            const req = http.request(options, (res) => {
+                const chunks = [];
+                let totalSize = 0;
+                res.on('data', (chunk) => {
+                    totalSize += chunk.length;
+                    if (totalSize > this.MAX_RESPONSE_SIZE) {
+                        req.destroy();
+                        reject(new Error(`Response exceeds maximum size of ${this.MAX_RESPONSE_SIZE} bytes`));
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                res.on('end', () => {
+                    const responseHeaders = {};
+                    for (const [key, value] of Object.entries(res.headers)) {
+                        if (value) {
+                            responseHeaders[key] = Array.isArray(value) ? value.join(', ') : value;
+                        }
+                    }
+                    resolve({
+                        statusCode: res.statusCode || 502,
+                        responseHeaders,
+                        responseBody: Buffer.concat(chunks),
+                    });
+                });
+                res.on('error', reject);
+            });
+            req.on('error', reject);
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timed out'));
+            });
+            if (body) {
+                req.write(body);
+            }
+            req.end();
+        });
+    }
+}
+exports.TunnelHandler = TunnelHandler;

package/dist/agent/types.d.ts

@@ -2,6 +2,7 @@ export interface AgentConfig {
     machineId: string;
     relay: string;
     token: string;
+    encKey?: string;
     api?: ApiConfig;
 }
 export interface ApiConfig {
@@ -64,6 +65,26 @@ export interface ExecResult {
     stderr: string;
     duration: number;
 }
+export interface TunnelConfig {
+    chromePath?: string;
+    width?: number;
+    height?: number;
+    cdpPort?: number;
+}
+export interface WebInputEvent {
+    inputType?: string;
+    type?: string;
+    x?: number;
+    y?: number;
+    button?: string;
+    clickCount?: number;
+    key?: string;
+    code?: string;
+    text?: string;
+    modifiers?: number;
+    deltaX?: number;
+    deltaY?: number;
+}
 export interface LlmMessage {
     role: 'system' | 'user' | 'assistant';
     content: string;

package/dist/agent/websocket.d.ts

@@ -7,6 +7,8 @@ interface WebSocketClientOptions {
     token: string;
     label?: string;
     autoReconnect?: boolean;
+    encKey?: string;
+    skipAutoRegister?: boolean;
 }
 export declare class RelayWebSocketClient extends EventEmitter {
     private ws;
@@ -16,6 +18,8 @@ export declare class RelayWebSocketClient extends EventEmitter {
     private token;
     private label;
     private autoReconnect;
+    private encKeyBuf;
+    private skipAutoRegister;
     private isConnected;
     private reconnectAttempts;
     private circuitBreakerOpen;
@@ -25,12 +29,14 @@ export declare class RelayWebSocketClient extends EventEmitter {
     constructor(options: WebSocketClientOptions);
     connect(): void;
     private registerAsHost;
+    private decryptPayload;
     private handleMessage;
     private handleError;
     private scheduleReconnect;
     send(message: Message): boolean;
     sendScreen(data: Buffer): boolean;
     sendScreenWithMeta(data: Buffer, meta: Record<string, string>): boolean;
+    private compressAndEncrypt;
     sendScreenCompressed(data: Buffer): boolean;
     sendScreenCompressedWithMeta(data: Buffer, meta: Record<string, string>): boolean;
     sendSessionMeta(meta: Record<string, string>): boolean;
@@ -60,6 +66,18 @@ export declare class RelayWebSocketClient extends EventEmitter {
      * Send upload error notification to web viewer
      */
     sendUploadError(filename: string, error: string): boolean;
+    /**
+     * Send a single rrweb DOM event to the relay.
+     */
+    sendWebDom(event: any): boolean;
+    /**
+     * Send a batch of rrweb DOM events.
+     */
+    sendWebDomBatch(events: any[]): boolean;
+    /**
+     * Send web page metadata (title, URL, viewport).
+     */
+    sendWebMeta(meta: Record<string, string>): boolean;
     getConnected(): boolean;
     destroy(): void;
 }