sessioncast-cli 2.0.3 → 2.0.4

package/dist/agent/runner.js

@@ -74,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)(),

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

@@ -15,6 +15,8 @@ export declare class TmuxSessionHandler {
     private lastForceSendTime;
     private lastChangeTime;
     private captureTimer;
+    private lastPaneIds;
+    private lastPaneScreens;
     private pendingUploads;
     private uploadDir;
     constructor(options: SessionHandlerOptions);

package/dist/agent/session-handler.js

@@ -54,6 +54,9 @@ class TmuxSessionHandler {
         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
@@ -90,8 +93,8 @@ class TmuxSessionHandler {
             console.log(`[${this.tmuxSession}] Disconnected: code=${code}, reason=${reason}`);
             this.stopScreenCapture();
         });
-        this.wsClient.on('keys', (keys) => {
-            this.handleKeys(keys);
+        this.wsClient.on('keys', (keys, paneId) => {
+            this.handleKeys(keys, paneId);
         });
         this.wsClient.on('resize', ({ cols, rows }) => {
             console.log(`[${this.tmuxSession}] Resize: ${cols}x${rows}`);
@@ -281,8 +284,9 @@ class TmuxSessionHandler {
         };
         return types[ext] || 'application/octet-stream';
     }
-    handleKeys(keys) {
-        tmux.sendKeys(this.tmuxSession, keys, false);
+    handleKeys(keys, paneId) {
+        const target = paneId || this.tmuxSession;
+        tmux.sendKeys(target, keys, false);
     }
     startScreenCapture() {
         if (this.captureTimer)
@@ -294,35 +298,83 @@ class TmuxSessionHandler {
                 return;
             }
             try {
-                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;
-                        }
-                        // 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 {
-                            this.wsClient.sendScreen(data);
+                const panes = tmux.listPanes(this.tmuxSession);
+                const now = Date.now();
+                const forceTime = (now - this.lastForceSendTime) >= FORCE_SEND_INTERVAL_MS;
+                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.capturePaneById(this.tmuxSession, pane.id);
+                        if (screen !== null) {
+                            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 meta = { pane: pane.id };
+                                if (USE_COMPRESSION && data.length > MIN_COMPRESS_SIZE) {
+                                    this.wsClient.sendScreenCompressedWithMeta(data, meta);
+                                }
+                                else {
+                                    this.wsClient.sendScreenWithMeta(data, meta);
+                                }
+                            }
                         }
                     }
-                    // Adaptive sleep: faster when active, slower when idle
+                    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 {
-                    this.captureTimer = setTimeout(capture, CAPTURE_INTERVAL_IDLE_MS);
+                    // 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 changed = screen !== this.lastScreen;
+                        if (changed || forceTime) {
+                            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);
+                            }
+                            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);
+                    }
+                    else {
+                        this.captureTimer = setTimeout(capture, CAPTURE_INTERVAL_IDLE_MS);
+                    }
                 }
             }
             catch (error) {

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

@@ -2,9 +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[];
     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;
@@ -21,6 +33,8 @@ export interface TmuxExecutor {
 export declare class UnixTmuxExecutor implements TmuxExecutor {
     listSessions(): string[];
     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;
@@ -42,6 +56,8 @@ export declare class WindowsTmuxExecutor implements TmuxExecutor {
     private executeCommand;
     listSessions(): string[];
     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

@@ -73,6 +73,35 @@ class UnixTmuxExecutor {
             return null;
         }
     }
+    capturePaneById(session, paneId) {
+        try {
+            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
+            });
+            return output.replace(/\n/g, '\r\n');
+        }
+        catch {
+            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);
@@ -235,6 +264,37 @@ class WindowsTmuxExecutor {
             return null;
         }
     }
+    capturePaneById(session, paneId) {
+        try {
+            const escaped = this.escapeSession(paneId);
+            const output = this.executeCommand(`tmux capture-pane -t '${escaped}' -p -e -N`);
+            if (!output)
+                return null;
+            return output.replace(/\n/g, '\r\n');
+        }
+        catch {
+            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,3 +1,4 @@
+import { PaneData } from './tmux-executor';
 import { TmuxSession } from './types';
 /**
  * Scan for all tmux sessions
@@ -43,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

@@ -11,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;
@@ -145,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/websocket.d.ts

@@ -30,7 +30,19 @@ export declare class RelayWebSocketClient extends EventEmitter {
     private scheduleReconnect;
     send(message: Message): boolean;
     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;
+        height: number;
+        top: number;
+        left: number;
+        active: boolean;
+        title: string;
+    }>): boolean;
     /**
      * Send file content to be displayed in the web FileViewer
      * @param filename - The name of the file

package/dist/agent/websocket.js

@@ -119,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);
+                    this.emit('keys', message.payload, message.meta?.pane);
                 }
                 break;
             case 'resize':
@@ -249,6 +249,16 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             payload: base64Data
         });
     }
+    sendScreenWithMeta(data, meta) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'screen',
+            session: this.sessionId,
+            payload: data.toString('base64'),
+            meta
+        });
+    }
     sendScreenCompressed(data) {
         if (!this.isConnected)
             return false;
@@ -265,6 +275,31 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             return this.sendScreen(data);
         }
     }
+    sendScreenCompressedWithMeta(data, meta) {
+        if (!this.isConnected)
+            return false;
+        try {
+            const compressed = zlib.gzipSync(data);
+            return this.send({
+                type: 'screenGz',
+                session: this.sessionId,
+                payload: compressed.toString('base64'),
+                meta
+            });
+        }
+        catch {
+            return this.sendScreenWithMeta(data, meta);
+        }
+    }
+    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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sessioncast-cli",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "SessionCast CLI - Control your agents from anywhere",
   "main": "dist/index.js",
   "bin": {