sessioncast-cli 2.0.2 → 2.0.4

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) {
@@ -73,8 +74,7 @@ class AgentRunner {
         // If no config file found but agent token exists, create default config
         if ((!finalPath || !fs.existsSync(finalPath)) && agentToken) {
             console.log('Using OAuth authentication');
-            const hostname = os.hostname();
-            const machineId = `${hostname}-${Date.now()}`;
+            const machineId = os.hostname();
             return {
                 machineId,
                 relay: (0, config_1.getRelayUrl)(),
@@ -105,6 +105,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 +160,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,11 +11,12 @@ export declare class TmuxSessionHandler {
     private wsClient;
     private onCreateSession?;
     private running;
-    private lastScreens;
-    private lastPaneLayoutJson;
+    private lastScreen;
     private lastForceSendTime;
     private lastChangeTime;
     private captureTimer;
+    private lastPaneIds;
+    private lastPaneScreens;
     private pendingUploads;
     private uploadDir;
     constructor(options: SessionHandlerOptions);

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,11 +50,13 @@ 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;
+        // Multi-pane tracking
+        this.lastPaneIds = '';
+        this.lastPaneScreens = new Map();
         // File upload handling
         this.pendingUploads = new Map();
         this.uploadDir = process.cwd(); // Default to current working directory
@@ -84,16 +87,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, paneId) => {
+            this.handleKeys(keys, paneId);
         });
         this.wsClient.on('resize', ({ cols, rows }) => {
             console.log(`[${this.tmuxSession}] Resize: ${cols}x${rows}`);
@@ -117,6 +118,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,8 +284,8 @@ class TmuxSessionHandler {
         };
         return types[ext] || 'application/octet-stream';
     }
-    handleKeys(keys, meta) {
-        const target = meta?.pane ? `${this.tmuxSession}.${meta.pane}` : this.tmuxSession;
+    handleKeys(keys, paneId) {
+        const target = paneId || this.tmuxSession;
         tmux.sendKeys(target, keys, false);
     }
     startScreenCapture() {
@@ -298,58 +300,66 @@ class TmuxSessionHandler {
             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);
-                        }
-                    }
-                }
-                let anyChanged = false;
                 const forceTime = (now - this.lastForceSendTime) >= FORCE_SEND_INTERVAL_MS;
-                if (isMultiPane) {
-                    // Multi-pane: capture each pane individually
+                if (panes && panes.length > 1) {
+                    // Multi-pane mode
+                    const currentPaneIds = panes.map(p => p.id).join(',');
+                    if (currentPaneIds !== this.lastPaneIds || forceTime) {
+                        // Layout changed or periodic resend for late-joining viewers
+                        this.lastPaneIds = currentPaneIds;
+                        this.wsClient.sendPaneLayout(panes);
+                    }
+                    // Capture each pane individually
                     for (const pane of panes) {
-                        const screen = tmux.capturePane(this.tmuxSession, pane.id);
+                        const screen = tmux.capturePaneById(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 lastScreen = this.lastPaneScreens.get(pane.id);
+                            if (screen !== lastScreen || forceTime) {
+                                this.lastPaneScreens.set(pane.id, screen);
+                                if (screen !== lastScreen) {
+                                    this.lastChangeTime = now;
+                                }
                                 const fullOutput = '\x1b[2J\x1b[H' + screen;
                                 const data = Buffer.from(fullOutput, 'utf-8');
-                                const paneMeta = { pane: pane.id, index: pane.index };
+                                const meta = { pane: pane.id };
                                 if (USE_COMPRESSION && data.length > MIN_COMPRESS_SIZE) {
-                                    this.wsClient.sendScreenCompressed(data, paneMeta);
+                                    this.wsClient.sendScreenCompressedWithMeta(data, meta);
                                 }
                                 else {
-                                    this.wsClient.sendScreen(data, paneMeta);
+                                    this.wsClient.sendScreenWithMeta(data, meta);
                                 }
                             }
                         }
                     }
+                    if (forceTime) {
+                        this.lastForceSendTime = now;
+                    }
+                    // Adaptive sleep
+                    const isActive = (now - this.lastChangeTime) < ACTIVE_THRESHOLD_MS;
+                    const sleepMs = isActive ? CAPTURE_INTERVAL_ACTIVE_MS : CAPTURE_INTERVAL_IDLE_MS;
+                    this.captureTimer = setTimeout(capture, sleepMs);
                 }
                 else {
-                    // Single pane: backward compatible (no meta)
+                    // Single pane mode (existing logic)
+                    if (this.lastPaneIds !== '') {
+                        // Was multi-pane, now single — notify viewers
+                        this.lastPaneIds = '';
+                        this.lastPaneScreens.clear();
+                        this.wsClient.sendPaneLayout([]);
+                    }
                     const screen = tmux.capturePane(this.tmuxSession);
                     if (screen !== null) {
-                        const lastScreen = this.lastScreens.get('_single') || '';
-                        const changed = screen !== lastScreen;
+                        const changed = screen !== this.lastScreen;
                         if (changed || forceTime) {
-                            this.lastScreens.set('_single', screen);
-                            if (changed)
-                                anyChanged = true;
+                            this.lastScreen = screen;
+                            this.lastForceSendTime = now;
+                            if (changed) {
+                                this.lastChangeTime = now;
+                            }
+                            // 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);
                             }
@@ -357,25 +367,22 @@ class TmuxSessionHandler {
                                 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

@@ -2,19 +2,21 @@
  * Interface for tmux operations.
  * Implementations handle platform-specific differences (Unix vs Windows/itmux).
  */
+export interface PaneData {
+    id: string;
+    index: number;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    active: boolean;
+    title: string;
+}
 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;
+    capturePaneById(session: string, paneId: string): string | null;
+    listPanes(session: string): PaneData[] | null;
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
@@ -30,17 +32,9 @@ 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;
+    capturePaneById(session: string, paneId: string): string | null;
+    listPanes(session: string): PaneData[] | null;
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
@@ -61,17 +55,9 @@ 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;
+    capturePaneById(session: string, paneId: string): string | null;
+    listPanes(session: string): PaneData[] | 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,22 @@ 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
-                };
+            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
             });
+            return output.replace(/\n/g, '\r\n');
         }
         catch {
-            return [];
+            return null;
         }
     }
-    capturePane(session, paneId) {
+    capturePaneById(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 "${paneId}" -p -e -N`, {
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
                 maxBuffer: 10 * 1024 * 1024
@@ -95,6 +86,22 @@ class UnixTmuxExecutor {
             return null;
         }
     }
+    listPanes(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,1,0}:#{pane_title}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+            return output.trim().split('\n').filter(Boolean).map(line => {
+                const [id, index, width, height, top, left, active, ...titleParts] = line.split(':');
+                return {
+                    id, index: parseInt(index), width: parseInt(width), height: parseInt(height),
+                    top: parseInt(top), left: parseInt(left),
+                    active: active === '1', title: titleParts.join(':') || ''
+                };
+            });
+        }
+        catch {
+            return null;
+        }
+    }
     sendKeys(session, keys) {
         try {
             const escaped = this.escapeForShell(keys);
@@ -245,34 +252,21 @@ 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}'`);
+            const output = this.executeCommand(`tmux capture-pane -t '${escaped}' -p -e -N`);
             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(':')
-                };
-            });
+                return null;
+            return output.replace(/\n/g, '\r\n');
         }
         catch {
-            return [];
+            return null;
         }
     }
-    capturePane(session, paneId) {
+    capturePaneById(session, paneId) {
         try {
-            const target = paneId ? `${session}.${paneId}` : session;
-            const escaped = this.escapeSession(target);
+            const escaped = this.escapeSession(paneId);
             const output = this.executeCommand(`tmux capture-pane -t '${escaped}' -p -e -N`);
             if (!output)
                 return null;
@@ -282,6 +276,25 @@ class WindowsTmuxExecutor {
             return null;
         }
     }
+    listPanes(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,1,0}:#{pane_title}"`);
+            if (!output)
+                return null;
+            return output.trim().split('\n').filter(Boolean).map(line => {
+                const [id, index, width, height, top, left, active, ...titleParts] = line.split(':');
+                return {
+                    id, index: parseInt(index), width: parseInt(width), height: parseInt(height),
+                    top: parseInt(top), left: parseInt(left),
+                    active: active === '1', title: titleParts.join(':') || ''
+                };
+            });
+        }
+        catch {
+            return null;
+        }
+    }
     sendKeys(session, keys) {
         try {
             const escapedSession = this.escapeSession(session);

package/dist/agent/tmux.d.ts

@@ -1,4 +1,5 @@
-import { TmuxSession, PaneInfo } from './types';
+import { PaneData } from './tmux-executor';
+import { TmuxSession } from './types';
 /**
  * Scan for all tmux sessions
  */
@@ -7,14 +8,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
  */
@@ -47,3 +44,12 @@ export declare function getActivePane(sessionName: string): string | null;
  * Get the current working directory of a pane
  */
 export declare function getPaneCwd(sessionName: string, paneId?: string): string | null;
+/**
+ * List all panes in a tmux session
+ */
+export declare function listPanes(sessionName: string): PaneData[] | null;
+/**
+ * Capture a specific pane by its pane ID (e.g., %0, %1)
+ */
+export declare function capturePaneById(sessionName: string, paneId: string): string | null;
+export type { PaneData } from './tmux-executor';

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;
@@ -12,6 +11,8 @@ exports.isAvailable = isAvailable;
 exports.getVersion = getVersion;
 exports.getActivePane = getActivePane;
 exports.getPaneCwd = getPaneCwd;
+exports.listPanes = listPanes;
+exports.capturePaneById = capturePaneById;
 const tmux_executor_1 = require("./tmux-executor");
 // Lazy-initialized executor (created on first use)
 let executor = null;
@@ -50,17 +51,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
@@ -152,3 +147,15 @@ function getActivePane(sessionName) {
 function getPaneCwd(sessionName, paneId) {
     return getExecutor().getPaneCwd(sessionName, paneId);
 }
+/**
+ * List all panes in a tmux session
+ */
+function listPanes(sessionName) {
+    return getExecutor().listPanes(sessionName);
+}
+/**
+ * Capture a specific pane by its pane ID (e.g., %0, %1)
+ */
+function capturePaneById(sessionName, paneId) {
+    return getExecutor().capturePaneById(sessionName, paneId);
+}

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,26 +21,19 @@ 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: {
+    sendScreen(data: Buffer): boolean;
+    sendScreenWithMeta(data: Buffer, meta: Record<string, string>): boolean;
+    sendScreenCompressed(data: Buffer): boolean;
+    sendScreenCompressedWithMeta(data: Buffer, meta: Record<string, string>): boolean;
+    sendPaneLayout(panes: Array<{
         id: string;
         index: number;
         width: number;
@@ -49,7 +42,7 @@ export declare class RelayWebSocketClient extends EventEmitter {
         left: number;
         active: boolean;
         title: string;
-    }[]): boolean;
+    }>): boolean;
     /**
      * Send file content to be displayed in the web FileViewer
      * @param filename - The name of the file