sessioncast-cli 2.0.2 → 2.0.3

package/dist/agent/runner.js

@@ -42,6 +42,7 @@ const session_handler_1 = require("./session-handler");
 const api_client_1 = require("./api-client");
 const tmux = __importStar(require("./tmux"));
 const config_1 = require("../config");
+const sentry_1 = require("../sentry");
 const SCAN_INTERVAL_MS = 5000;
 class AgentRunner {
     constructor(config) {
@@ -105,6 +106,27 @@ class AgentRunner {
         console.log(`Machine ID: ${this.config.machineId}`);
         console.log(`Relay: ${this.config.relay}`);
         console.log(`Token: ${this.config.token ? 'present' : 'none'}`);
+        // Check tmux availability before starting
+        if (!tmux.isAvailable()) {
+            const platform = os.platform();
+            let installHint;
+            if (platform === 'darwin') {
+                installHint = '  Install: brew install tmux';
+            }
+            else {
+                installHint = '  Install: sudo apt install tmux  (Debian/Ubuntu)\n' +
+                    '           sudo yum install tmux  (RHEL/CentOS)';
+            }
+            throw new Error('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+                '  tmux not found - required for SessionCast Agent\n' +
+                '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n' +
+                `${installHint}\n\n` +
+                '  After installing, start a tmux session:\n' +
+                '    tmux new -s main\n\n' +
+                '  Then run the agent:\n' +
+                '    sessioncast agent\n\n' +
+                '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        }
         // Start API client if configured
         if (this.config.api?.enabled && this.config.api.agentId) {
             this.apiClient = new api_client_1.ApiWebSocketClient(this.config);
@@ -139,6 +161,7 @@ class AgentRunner {
             }
         }
         catch (error) {
+            (0, sentry_1.captureException)(error);
             console.error('Error during session scan:', error);
         }
     }

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

@@ -11,8 +11,7 @@ export declare class TmuxSessionHandler {
     private wsClient;
     private onCreateSession?;
     private running;
-    private lastScreens;
-    private lastPaneLayoutJson;
+    private lastScreen;
     private lastForceSendTime;
     private lastChangeTime;
     private captureTimer;

package/dist/agent/session-handler.js

@@ -38,9 +38,10 @@ const websocket_1 = require("./websocket");
 const tmux = __importStar(require("./tmux"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const sentry_1 = require("../sentry");
 // Capture intervals
-const CAPTURE_INTERVAL_ACTIVE_MS = 16;
-const CAPTURE_INTERVAL_IDLE_MS = 100;
+const CAPTURE_INTERVAL_ACTIVE_MS = 50;
+const CAPTURE_INTERVAL_IDLE_MS = 200;
 const ACTIVE_THRESHOLD_MS = 2000;
 const FORCE_SEND_INTERVAL_MS = 10000;
 const USE_COMPRESSION = true;
@@ -49,8 +50,7 @@ class TmuxSessionHandler {
     constructor(options) {
         this.wsClient = null;
         this.running = false;
-        this.lastScreens = new Map();
-        this.lastPaneLayoutJson = '';
+        this.lastScreen = '';
         this.lastForceSendTime = 0;
         this.lastChangeTime = 0;
         this.captureTimer = null;
@@ -84,16 +84,14 @@ class TmuxSessionHandler {
         });
         this.wsClient.on('connected', () => {
             console.log(`[${this.tmuxSession}] Connected to relay`);
-            // Reset pane layout cache so it gets re-sent on reconnection
-            this.lastPaneLayoutJson = '';
             this.startScreenCapture();
         });
         this.wsClient.on('disconnected', ({ code, reason }) => {
             console.log(`[${this.tmuxSession}] Disconnected: code=${code}, reason=${reason}`);
             this.stopScreenCapture();
         });
-        this.wsClient.on('keys', (keys, meta) => {
-            this.handleKeys(keys, meta);
+        this.wsClient.on('keys', (keys) => {
+            this.handleKeys(keys);
         });
         this.wsClient.on('resize', ({ cols, rows }) => {
             console.log(`[${this.tmuxSession}] Resize: ${cols}x${rows}`);
@@ -117,6 +115,7 @@ class TmuxSessionHandler {
             this.handleUploadChunk(chunk);
         });
         this.wsClient.on('error', (error) => {
+            (0, sentry_1.captureException)(error);
             console.error(`[${this.tmuxSession}] WebSocket error:`, error.message);
         });
         this.wsClient.connect();
@@ -282,9 +281,8 @@ class TmuxSessionHandler {
         };
         return types[ext] || 'application/octet-stream';
     }
-    handleKeys(keys, meta) {
-        const target = meta?.pane ? `${this.tmuxSession}.${meta.pane}` : this.tmuxSession;
-        tmux.sendKeys(target, keys, false);
+    handleKeys(keys) {
+        tmux.sendKeys(this.tmuxSession, keys, false);
     }
     startScreenCapture() {
         if (this.captureTimer)
@@ -296,86 +294,43 @@ class TmuxSessionHandler {
                 return;
             }
             try {
-                const panes = tmux.listPanes(this.tmuxSession);
-                const now = Date.now();
-                const isMultiPane = panes.length > 1;
-                // Check if pane layout changed
-                const paneLayoutJson = JSON.stringify(panes);
-                if (paneLayoutJson !== this.lastPaneLayoutJson) {
-                    this.lastPaneLayoutJson = paneLayoutJson;
-                    this.wsClient.sendPaneLayout(panes);
-                    // Clean up screens for removed panes
-                    const currentPaneIds = new Set(panes.map(p => p.id));
-                    for (const key of this.lastScreens.keys()) {
-                        if (!currentPaneIds.has(key)) {
-                            this.lastScreens.delete(key);
+                const screen = tmux.capturePane(this.tmuxSession);
+                if (screen !== null) {
+                    const now = Date.now();
+                    const changed = screen !== this.lastScreen;
+                    const forceTime = (now - this.lastForceSendTime) >= FORCE_SEND_INTERVAL_MS;
+                    if (changed || forceTime) {
+                        this.lastScreen = screen;
+                        this.lastForceSendTime = now;
+                        if (changed) {
+                            this.lastChangeTime = now;
                         }
-                    }
-                }
-                let anyChanged = false;
-                const forceTime = (now - this.lastForceSendTime) >= FORCE_SEND_INTERVAL_MS;
-                if (isMultiPane) {
-                    // Multi-pane: capture each pane individually
-                    for (const pane of panes) {
-                        const screen = tmux.capturePane(this.tmuxSession, pane.id);
-                        if (screen !== null) {
-                            const lastScreen = this.lastScreens.get(pane.id) || '';
-                            const changed = screen !== lastScreen;
-                            if (changed || forceTime) {
-                                this.lastScreens.set(pane.id, screen);
-                                if (changed)
-                                    anyChanged = true;
-                                const fullOutput = '\x1b[2J\x1b[H' + screen;
-                                const data = Buffer.from(fullOutput, 'utf-8');
-                                const paneMeta = { pane: pane.id, index: pane.index };
-                                if (USE_COMPRESSION && data.length > MIN_COMPRESS_SIZE) {
-                                    this.wsClient.sendScreenCompressed(data, paneMeta);
-                                }
-                                else {
-                                    this.wsClient.sendScreen(data, paneMeta);
-                                }
-                            }
+                        // Send clear screen + content
+                        const fullOutput = '\x1b[2J\x1b[H' + screen;
+                        const data = Buffer.from(fullOutput, 'utf-8');
+                        // Compress if enabled and data is large enough
+                        if (USE_COMPRESSION && data.length > MIN_COMPRESS_SIZE) {
+                            this.wsClient.sendScreenCompressed(data);
                         }
-                    }
-                }
-                else {
-                    // Single pane: backward compatible (no meta)
-                    const screen = tmux.capturePane(this.tmuxSession);
-                    if (screen !== null) {
-                        const lastScreen = this.lastScreens.get('_single') || '';
-                        const changed = screen !== lastScreen;
-                        if (changed || forceTime) {
-                            this.lastScreens.set('_single', screen);
-                            if (changed)
-                                anyChanged = true;
-                            const fullOutput = '\x1b[2J\x1b[H' + screen;
-                            const data = Buffer.from(fullOutput, 'utf-8');
-                            if (USE_COMPRESSION && data.length > MIN_COMPRESS_SIZE) {
-                                this.wsClient.sendScreenCompressed(data);
-                            }
-                            else {
-                                this.wsClient.sendScreen(data);
-                            }
+                        else {
+                            this.wsClient.sendScreen(data);
                         }
                     }
+                    // Adaptive sleep: faster when active, slower when idle
+                    const isActive = (now - this.lastChangeTime) < ACTIVE_THRESHOLD_MS;
+                    const sleepMs = isActive ? CAPTURE_INTERVAL_ACTIVE_MS : CAPTURE_INTERVAL_IDLE_MS;
+                    this.captureTimer = setTimeout(capture, sleepMs);
                 }
-                if (anyChanged || forceTime) {
-                    this.lastForceSendTime = now;
-                    if (anyChanged) {
-                        this.lastChangeTime = now;
-                    }
+                else {
+                    this.captureTimer = setTimeout(capture, CAPTURE_INTERVAL_IDLE_MS);
                 }
-                const isActive = (now - this.lastChangeTime) < ACTIVE_THRESHOLD_MS;
-                const sleepMs = isActive ? CAPTURE_INTERVAL_ACTIVE_MS : CAPTURE_INTERVAL_IDLE_MS;
-                this.captureTimer = setTimeout(capture, sleepMs);
             }
             catch (error) {
                 console.error(`[${this.tmuxSession}] Screen capture error:`, error);
                 this.captureTimer = setTimeout(capture, 500);
             }
         };
-        // Small delay to ensure register message is processed by server first
-        setTimeout(capture, 300);
+        capture();
         console.log(`[${this.tmuxSession}] Screen capture started`);
     }
     stopScreenCapture() {

package/dist/agent/tmux-executor.d.ts

@@ -4,17 +4,7 @@
  */
 export interface TmuxExecutor {
     listSessions(): string[];
-    listPanes(session: string): {
-        id: string;
-        index: number;
-        width: number;
-        height: number;
-        top: number;
-        left: number;
-        active: boolean;
-        title: string;
-    }[];
-    capturePane(session: string, paneId?: string): string | null;
+    capturePane(session: string): string | null;
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
@@ -30,17 +20,7 @@ export interface TmuxExecutor {
  */
 export declare class UnixTmuxExecutor implements TmuxExecutor {
     listSessions(): string[];
-    listPanes(session: string): {
-        id: string;
-        index: number;
-        width: number;
-        height: number;
-        top: number;
-        left: number;
-        active: boolean;
-        title: string;
-    }[];
-    capturePane(session: string, paneId?: string): string | null;
+    capturePane(session: string): string | null;
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
@@ -61,17 +41,7 @@ export declare class WindowsTmuxExecutor implements TmuxExecutor {
     constructor(itmuxPath: string);
     private executeCommand;
     listSessions(): string[];
-    listPanes(session: string): {
-        id: string;
-        index: number;
-        width: number;
-        height: number;
-        top: number;
-        left: number;
-        active: boolean;
-        title: string;
-    }[];
-    capturePane(session: string, paneId?: string): string | null;
+    capturePane(session: string): string | null;
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;

package/dist/agent/tmux-executor.js

@@ -60,31 +60,9 @@ class UnixTmuxExecutor {
             return [];
         }
     }
-    listPanes(session) {
+    capturePane(session) {
         try {
-            const output = (0, child_process_1.execSync)(`tmux list-panes -t "${session}" -F "#{pane_id}:#{pane_index}:#{pane_width}:#{pane_height}:#{pane_top}:#{pane_left}:#{pane_active}:#{pane_title}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-            return output.trim().split('\n').filter(l => l.length > 0).map(line => {
-                const parts = line.split(':');
-                return {
-                    id: parts[0],
-                    index: parseInt(parts[1], 10),
-                    width: parseInt(parts[2], 10),
-                    height: parseInt(parts[3], 10),
-                    top: parseInt(parts[4], 10),
-                    left: parseInt(parts[5], 10),
-                    active: parts[6] === '1',
-                    title: parts.slice(7).join(':') // title may contain colons
-                };
-            });
-        }
-        catch {
-            return [];
-        }
-    }
-    capturePane(session, paneId) {
-        try {
-            const target = paneId ? `${session}.${paneId}` : session;
-            const output = (0, child_process_1.execSync)(`tmux capture-pane -t "${target}" -p -e -N`, {
+            const output = (0, child_process_1.execSync)(`tmux capture-pane -t "${session}" -p -e -N`, {
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
                 maxBuffer: 10 * 1024 * 1024
@@ -245,34 +223,9 @@ class WindowsTmuxExecutor {
             return [];
         }
     }
-    listPanes(session) {
+    capturePane(session) {
         try {
             const escaped = this.escapeSession(session);
-            const output = this.executeCommand(`tmux list-panes -t '${escaped}' -F '#{pane_id}:#{pane_index}:#{pane_width}:#{pane_height}:#{pane_top}:#{pane_left}:#{pane_active}:#{pane_title}'`);
-            if (!output)
-                return [];
-            return output.split('\n').map(s => s.trim()).filter(l => l.length > 0).map(line => {
-                const parts = line.split(':');
-                return {
-                    id: parts[0],
-                    index: parseInt(parts[1], 10),
-                    width: parseInt(parts[2], 10),
-                    height: parseInt(parts[3], 10),
-                    top: parseInt(parts[4], 10),
-                    left: parseInt(parts[5], 10),
-                    active: parts[6] === '1',
-                    title: parts.slice(7).join(':')
-                };
-            });
-        }
-        catch {
-            return [];
-        }
-    }
-    capturePane(session, paneId) {
-        try {
-            const target = paneId ? `${session}.${paneId}` : session;
-            const escaped = this.escapeSession(target);
             const output = this.executeCommand(`tmux capture-pane -t '${escaped}' -p -e -N`);
             if (!output)
                 return null;

package/dist/agent/tmux.d.ts

@@ -1,4 +1,4 @@
-import { TmuxSession, PaneInfo } from './types';
+import { TmuxSession } from './types';
 /**
  * Scan for all tmux sessions
  */
@@ -7,14 +7,10 @@ export declare function scanSessions(): string[];
  * Get detailed session info
  */
 export declare function listSessions(): TmuxSession[];
-/**
- * List all panes in a tmux session
- */
-export declare function listPanes(sessionName: string): PaneInfo[];
 /**
  * Capture tmux pane content with escape sequences (colors)
  */
-export declare function capturePane(sessionName: string, paneId?: string): string | null;
+export declare function capturePane(sessionName: string): string | null;
 /**
  * Send keys to tmux session
  */

package/dist/agent/tmux.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanSessions = scanSessions;
 exports.listSessions = listSessions;
-exports.listPanes = listPanes;
 exports.capturePane = capturePane;
 exports.sendKeys = sendKeys;
 exports.resizeWindow = resizeWindow;
@@ -50,17 +49,11 @@ function listSessions() {
         return [];
     }
 }
-/**
- * List all panes in a tmux session
- */
-function listPanes(sessionName) {
-    return getExecutor().listPanes(sessionName);
-}
 /**
  * Capture tmux pane content with escape sequences (colors)
  */
-function capturePane(sessionName, paneId) {
-    return getExecutor().capturePane(sessionName, paneId);
+function capturePane(sessionName) {
+    return getExecutor().capturePane(sessionName);
 }
 /**
  * Send keys to tmux session

package/dist/agent/types.d.ts

@@ -37,16 +37,6 @@ export interface TmuxSession {
     created?: string;
     attached: boolean;
 }
-export interface PaneInfo {
-    id: string;
-    index: number;
-    width: number;
-    height: number;
-    top: number;
-    left: number;
-    active: boolean;
-    title: string;
-}
 export interface ExecResult {
     exitCode: number;
     stdout: string;

package/dist/agent/websocket.d.ts

@@ -21,35 +21,16 @@ export declare class RelayWebSocketClient extends EventEmitter {
     private circuitBreakerOpen;
     private circuitBreakerResetTime;
     private reconnectTimer;
-    private pingTimer;
     private destroyed;
     constructor(options: WebSocketClientOptions);
     connect(): void;
     private registerAsHost;
     private handleMessage;
     private handleError;
-    private startPing;
-    private stopPing;
     private scheduleReconnect;
     send(message: Message): boolean;
-    sendScreen(data: Buffer, paneMeta?: {
-        pane: string;
-        index: number;
-    }): boolean;
-    sendScreenCompressed(data: Buffer, paneMeta?: {
-        pane: string;
-        index: number;
-    }): boolean;
-    sendPaneLayout(panes: {
-        id: string;
-        index: number;
-        width: number;
-        height: number;
-        top: number;
-        left: number;
-        active: boolean;
-        title: string;
-    }[]): boolean;
+    sendScreen(data: Buffer): boolean;
+    sendScreenCompressed(data: Buffer): boolean;
     /**
      * Send file content to be displayed in the web FileViewer
      * @param filename - The name of the file

package/dist/agent/websocket.js

@@ -40,11 +40,10 @@ exports.RelayWebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const zlib = __importStar(require("zlib"));
-const MAX_RECONNECT_ATTEMPTS = 50;
+const MAX_RECONNECT_ATTEMPTS = 5;
 const BASE_RECONNECT_DELAY_MS = 2000;
 const MAX_RECONNECT_DELAY_MS = 60000;
 const CIRCUIT_BREAKER_DURATION_MS = 120000;
-const PING_INTERVAL_MS = 30000;
 class RelayWebSocketClient extends events_1.EventEmitter {
     constructor(options) {
         super();
@@ -54,7 +53,6 @@ class RelayWebSocketClient extends events_1.EventEmitter {
         this.circuitBreakerOpen = false;
         this.circuitBreakerResetTime = 0;
         this.reconnectTimer = null;
-        this.pingTimer = null;
         this.destroyed = false;
         this.url = options.url;
         this.sessionId = options.sessionId;
@@ -72,9 +70,8 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                 this.isConnected = true;
                 this.reconnectAttempts = 0;
                 this.circuitBreakerOpen = false;
-                this.registerAsHost();
-                this.startPing();
                 this.emit('connected');
+                this.registerAsHost();
             });
             this.ws.on('message', (data) => {
                 try {
@@ -87,7 +84,6 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             });
             this.ws.on('close', (code, reason) => {
                 this.isConnected = false;
-                this.stopPing();
                 this.emit('disconnected', { code, reason: reason.toString() });
                 if (this.autoReconnect && !this.destroyed) {
                     this.scheduleReconnect();
@@ -123,7 +119,7 @@ class RelayWebSocketClient extends events_1.EventEmitter {
         switch (message.type) {
             case 'keys':
                 if (message.session === this.sessionId && message.payload) {
-                    this.emit('keys', message.payload, message.meta);
+                    this.emit('keys', message.payload);
                 }
                 break;
             case 'resize':
@@ -192,20 +188,6 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             console.error(`Error: code=${meta.code}, message=${meta.messageEn}`);
         }
     }
-    startPing() {
-        this.stopPing();
-        this.pingTimer = setInterval(() => {
-            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                this.ws.ping();
-            }
-        }, PING_INTERVAL_MS);
-    }
-    stopPing() {
-        if (this.pingTimer) {
-            clearInterval(this.pingTimer);
-            this.pingTimer = null;
-        }
-    }
     scheduleReconnect() {
         if (this.destroyed)
             return;
@@ -257,49 +239,32 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             return false;
         }
     }
-    sendScreen(data, paneMeta) {
+    sendScreen(data) {
         if (!this.isConnected)
             return false;
         const base64Data = data.toString('base64');
-        const msg = {
+        return this.send({
             type: 'screen',
             session: this.sessionId,
             payload: base64Data
-        };
-        if (paneMeta) {
-            msg.meta = { pane: paneMeta.pane, index: String(paneMeta.index) };
-        }
-        return this.send(msg);
+        });
     }
-    sendScreenCompressed(data, paneMeta) {
+    sendScreenCompressed(data) {
         if (!this.isConnected)
             return false;
         try {
             const compressed = zlib.gzipSync(data);
             const base64Data = compressed.toString('base64');
-            const msg = {
+            return this.send({
                 type: 'screenGz',
                 session: this.sessionId,
                 payload: base64Data
-            };
-            if (paneMeta) {
-                msg.meta = { pane: paneMeta.pane, index: String(paneMeta.index) };
-            }
-            return this.send(msg);
+            });
         }
         catch {
-            return this.sendScreen(data, paneMeta);
+            return this.sendScreen(data);
         }
     }
-    sendPaneLayout(panes) {
-        if (!this.isConnected)
-            return false;
-        return this.send({
-            type: 'paneLayout',
-            session: this.sessionId,
-            payload: JSON.stringify(panes)
-        });
-    }
     /**
      * Send file content to be displayed in the web FileViewer
      * @param filename - The name of the file
@@ -358,7 +323,6 @@ class RelayWebSocketClient extends events_1.EventEmitter {
     destroy() {
         this.destroyed = true;
         this.autoReconnect = false;
-        this.stopPing();
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;

package/dist/commands/agent.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startAgent = startAgent;
 const chalk_1 = __importDefault(require("chalk"));
 const runner_1 = require("../agent/runner");
+const sentry_1 = require("../sentry");
 async function startAgent(options) {
     try {
         const config = runner_1.AgentRunner.loadConfig(options.config);
@@ -13,6 +14,8 @@ async function startAgent(options) {
         await runner.start();
     }
     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

@@ -47,6 +47,20 @@ const sessions_1 = require("./commands/sessions");
 const sendkeys_1 = require("./commands/sendkeys");
 const agent_1 = require("./commands/agent");
 const config_1 = require("./config");
+const sentry_1 = require("./sentry");
+// Initialize Sentry as early as possible
+(0, sentry_1.initSentry)();
+// Catch unhandled errors globally
+process.on('uncaughtException', async (error) => {
+    (0, sentry_1.captureException)(error);
+    await (0, sentry_1.flush)();
+    console.error(chalk_1.default.red(`Fatal error: ${error.message}`));
+    process.exit(1);
+});
+process.on('unhandledRejection', async (reason) => {
+    (0, sentry_1.captureException)(reason);
+    await (0, sentry_1.flush)();
+});
 // Check if tmux/itmux is available
 function checkTmux() {
     const isWindows = os.platform() === 'win32';

package/dist/sentry.d.ts

@@ -0,0 +1,4 @@
+export declare function initSentry(): void;
+export declare function captureException(error: unknown): void;
+export declare function setUser(email: string): void;
+export declare function flush(): Promise<void>;