sessioncast-cli 2.3.0 → 2.4.0

package/dist/commands/login.js

@@ -214,19 +214,81 @@ async function logout() {
     (0, config_1.clearAuth)();
     console.log(chalk_1.default.green('\u2713 Logged out successfully!'));
 }
+function formatExpiry(expiresAt) {
+    const now = Date.now();
+    if (now > expiresAt) {
+        return chalk_1.default.red('expired');
+    }
+    const remaining = expiresAt - now;
+    const hours = Math.floor(remaining / (1000 * 60 * 60));
+    const minutes = Math.floor((remaining % (1000 * 60 * 60)) / (1000 * 60));
+    if (hours > 24) {
+        const days = Math.floor(hours / 24);
+        return chalk_1.default.green(`${days}d ${hours % 24}h remaining`);
+    }
+    if (hours > 0) {
+        return chalk_1.default.green(`${hours}h ${minutes}m remaining`);
+    }
+    return chalk_1.default.yellow(`${minutes}m remaining`);
+}
 function status() {
     const accessToken = (0, config_1.getAccessToken)();
-    if ((0, config_1.isLoggedIn)()) {
-        console.log(chalk_1.default.green('\u2713 Logged in'));
-        if (accessToken) {
-            console.log(chalk_1.default.gray('  Auth method: OAuth'));
-        }
-        else {
-            console.log(chalk_1.default.gray('  Auth method: API Key / Agent Token'));
-        }
+    const rawAccessToken = (0, config_1.getRawAccessToken)();
+    const agentToken = (0, config_1.getAgentToken)();
+    const apiKey = (0, config_1.getApiKey)();
+    const refreshToken = (0, config_1.getRefreshToken)();
+    const machineId = (0, config_1.getMachineId)();
+    const expiresAt = (0, config_1.getTokenExpiresAt)();
+    console.log('');
+    if (!(0, config_1.isLoggedIn)()) {
+        console.log(chalk_1.default.yellow('  Not logged in'));
+        console.log(chalk_1.default.gray('  Run: sessioncast login\n'));
+        return;
+    }
+    console.log(chalk_1.default.green.bold('  \u2713 Logged in\n'));
+    // Auth method
+    if (accessToken) {
+        console.log(chalk_1.default.gray('  Auth method: ') + 'OAuth');
+    }
+    else if (rawAccessToken) {
+        console.log(chalk_1.default.gray('  Auth method: ') + chalk_1.default.yellow('OAuth (token expired)'));
+    }
+    else if (apiKey) {
+        console.log(chalk_1.default.gray('  Auth method: ') + 'API Key');
     }
     else {
-        console.log(chalk_1.default.yellow('Not logged in'));
-        console.log(chalk_1.default.gray('Run: sessioncast login'));
+        console.log(chalk_1.default.gray('  Auth method: ') + 'Agent Token');
+    }
+    if (machineId) {
+        console.log(chalk_1.default.gray('  Machine ID:  ') + machineId);
+    }
+    console.log('');
+    // Tokens
+    console.log(chalk_1.default.bold('  Tokens'));
+    if (agentToken) {
+        console.log(chalk_1.default.gray('  Agent Token:   ') + agentToken);
+    }
+    if (rawAccessToken) {
+        const expiryStr = expiresAt ? ` (${formatExpiry(expiresAt)})` : '';
+        console.log(chalk_1.default.gray('  Access Token:  ') + rawAccessToken + expiryStr);
+    }
+    if (refreshToken) {
+        console.log(chalk_1.default.gray('  Refresh Token: ') + refreshToken);
+    }
+    if (apiKey) {
+        console.log(chalk_1.default.gray('  API Key:       ') + apiKey);
+    }
+    if (!agentToken && !rawAccessToken && !refreshToken && !apiKey) {
+        console.log(chalk_1.default.gray('  (none)'));
     }
+    console.log('');
+    // Endpoints
+    console.log(chalk_1.default.bold('  Endpoints'));
+    console.log(chalk_1.default.gray('  API:   ') + (0, config_1.getApiUrl)());
+    console.log(chalk_1.default.gray('  Auth:  ') + (0, config_1.getAuthUrl)());
+    console.log(chalk_1.default.gray('  Relay: ') + (0, config_1.getRelayUrl)());
+    console.log('');
+    // Config path
+    console.log(chalk_1.default.gray(`  Config: ${(0, config_1.getConfigPath)()}`));
+    console.log('');
 }

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/config.d.ts

@@ -33,4 +33,7 @@ export declare function clearAuth(): void;
 export declare function isLoggedIn(): boolean;
 export declare function hasSeenWelcome(): boolean;
 export declare function setSeenWelcome(): void;
+export declare function getConfigPath(): string;
+export declare function getRawAccessToken(): string | undefined;
+export declare function getTokenExpiresAt(): number | undefined;
 export default config;

package/dist/config.js

@@ -24,6 +24,9 @@ exports.clearAuth = clearAuth;
 exports.isLoggedIn = isLoggedIn;
 exports.hasSeenWelcome = hasSeenWelcome;
 exports.setSeenWelcome = setSeenWelcome;
+exports.getConfigPath = getConfigPath;
+exports.getRawAccessToken = getRawAccessToken;
+exports.getTokenExpiresAt = getTokenExpiresAt;
 const conf_1 = __importDefault(require("conf"));
 const config = new conf_1.default({
     projectName: 'sessioncast',
@@ -110,4 +113,15 @@ function hasSeenWelcome() {
 function setSeenWelcome() {
     config.set('hasSeenWelcome', true);
 }
+// Config file path
+function getConfigPath() {
+    return config.path;
+}
+// Raw token access (bypass expiry check, for status display)
+function getRawAccessToken() {
+    return config.get('accessToken');
+}
+function getTokenExpiresAt() {
+    return config.get('tokenExpiresAt');
+}
 exports.default = config;

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
@@ -184,7 +185,7 @@ program
 // Status command
 program
     .command('status')
-    .description('Check login status')
+    .description('Check login status and token info')
     .action(login_1.status);
 // Agents command
 program
@@ -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.4.0",
   "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",