sessioncast-cli 2.0.3 → 2.0.5

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/dist/api.js

@@ -8,12 +8,12 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
 const config_1 = require("./config");
 class ApiClient {
     getHeaders() {
-        const apiKey = (0, config_1.getApiKey)();
-        if (!apiKey) {
+        const token = (0, config_1.getApiKey)() || (0, config_1.getAccessToken)() || (0, config_1.getAgentToken)();
+        if (!token) {
             throw new Error('Not logged in. Run: sessioncast login');
         }
         return {
-            'Authorization': `Bearer ${apiKey}`,
+            'Authorization': `Bearer ${token}`,
             'Content-Type': 'application/json'
         };
     }

package/dist/commands/sendkeys.js

@@ -6,56 +6,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendKeys = sendKeys;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
-const api_1 = require("../api");
+const ws_1 = __importDefault(require("ws"));
 const config_1 = require("../config");
 async function sendKeys(target, keys, options) {
     if (!(0, config_1.isLoggedIn)()) {
-        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login <api-key>'));
+        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login'));
         process.exit(1);
     }
-    // Parse target: "agent:session" or "agent:session:window"
-    const parts = target.split(':');
-    if (parts.length < 2) {
-        console.log(chalk_1.default.red('Invalid target format.'));
-        console.log(chalk_1.default.gray('Expected: <agent>:<session> or <agent>:<session>:<window>'));
-        console.log(chalk_1.default.gray('Example: macbook:dev or server:main:0'));
+    // Parse target: "session" or "machineId/session"
+    // Accept both "machineId/session" and "machineId:session" formats
+    const normalizedTarget = target.replace(':', '/');
+    const token = (0, config_1.getAccessToken)() || (0, config_1.getAgentToken)() || (0, config_1.getApiKey)();
+    if (!token) {
+        console.log(chalk_1.default.red('No auth token found. Run: sessioncast login'));
         process.exit(1);
     }
-    const agentName = parts[0];
-    const sessionTarget = parts.slice(1).join(':'); // session:window or just session
-    const spinner = (0, ora_1.default)('Finding agent...').start();
+    const relayUrl = (0, config_1.getRelayUrl)();
+    const spinner = (0, ora_1.default)('Connecting to relay...').start();
     try {
-        // Find agent by name/label/machineId
-        const agent = await api_1.api.findAgentByName(agentName);
-        if (!agent) {
-            spinner.stop();
-            console.log(chalk_1.default.red(`Agent not found: ${agentName}`));
-            console.log(chalk_1.default.gray('Run: sessioncast agents'));
-            process.exit(1);
-        }
-        if (!agent.isActive) {
-            spinner.stop();
-            console.log(chalk_1.default.red(`Agent is offline: ${agentName}`));
-            process.exit(1);
-        }
-        if (!agent.apiEnabled) {
-            spinner.stop();
-            console.log(chalk_1.default.red(`API is not enabled for agent: ${agentName}`));
-            console.log(chalk_1.default.gray('Enable API in agent settings at https://account.sessioncast.io'));
-            process.exit(1);
-        }
-        spinner.text = 'Sending keys...';
-        const result = await api_1.api.sendKeys(agent.id, sessionTarget, keys, !options.noEnter);
+        const sessionId = await sendKeysViaRelay(relayUrl, token, normalizedTarget, keys, !options.noEnter, spinner);
         spinner.stop();
-        if (result.success) {
-            console.log(chalk_1.default.green(`✓ Keys sent to ${target}`));
-            if (!options.noEnter) {
-                console.log(chalk_1.default.gray('(Enter key was pressed)'));
-            }
-        }
-        else {
-            console.log(chalk_1.default.red(`Failed to send keys: ${result.error || 'Unknown error'}`));
-            process.exit(1);
+        console.log(chalk_1.default.green(`✓ Keys sent to ${sessionId}`));
+        if (!options.noEnter) {
+            console.log(chalk_1.default.gray('(Enter key was pressed)'));
         }
     }
     catch (error) {
@@ -64,3 +37,114 @@ async function sendKeys(target, keys, options) {
         process.exit(1);
     }
 }
+function sendKeysViaRelay(relayUrl, token, target, keys, enter, spinner) {
+    return new Promise((resolve, reject) => {
+        const wsUrl = `${relayUrl}?token=${encodeURIComponent(token)}`;
+        const ws = new ws_1.default(wsUrl);
+        let resolved = false;
+        let sessionList = [];
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                ws.close();
+                reject(new Error('Timeout waiting for relay response'));
+            }
+        }, 10000);
+        ws.on('open', () => {
+            // Request session list to find the target
+            ws.send(JSON.stringify({ type: 'listSessions' }));
+        });
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (message.type === 'sessionList' && message.sessions) {
+                    sessionList = message.sessions;
+                    spinner.text = `Found ${sessionList.length} sessions, finding target...`;
+                    // Find matching session
+                    const matched = findSession(sessionList, target);
+                    if (!matched) {
+                        clearTimeout(timeout);
+                        resolved = true;
+                        ws.close();
+                        const available = sessionList.map(s => `  ${s.id} (${s.label || 'no label'}) [${s.status}]`).join('\n');
+                        reject(new Error(`Session not found: ${target}\n\nAvailable sessions:\n${available || '  (none)'}`));
+                        return;
+                    }
+                    if (matched.status !== 'online') {
+                        clearTimeout(timeout);
+                        resolved = true;
+                        ws.close();
+                        reject(new Error(`Session is offline: ${matched.id}`));
+                        return;
+                    }
+                    // Register as viewer first
+                    ws.send(JSON.stringify({
+                        type: 'register',
+                        role: 'viewer',
+                        session: matched.id,
+                    }));
+                    // Send keys
+                    const payload = enter ? keys + '\n' : keys;
+                    ws.send(JSON.stringify({
+                        type: 'keys',
+                        session: matched.id,
+                        payload,
+                    }));
+                    // Small delay to ensure delivery, then close
+                    setTimeout(() => {
+                        if (!resolved) {
+                            clearTimeout(timeout);
+                            resolved = true;
+                            ws.close();
+                            resolve(matched.id);
+                        }
+                    }, 300);
+                }
+            }
+            catch {
+                // ignore parse errors
+            }
+        });
+        ws.on('error', (err) => {
+            if (!resolved) {
+                clearTimeout(timeout);
+                resolved = true;
+                reject(new Error(`WebSocket error: ${err.message}`));
+            }
+        });
+        ws.on('close', () => {
+            if (!resolved) {
+                clearTimeout(timeout);
+                resolved = true;
+                reject(new Error('Connection closed unexpectedly'));
+            }
+        });
+    });
+}
+function findSession(sessions, target) {
+    // Exact match on session id
+    const exact = sessions.find(s => s.id === target);
+    if (exact)
+        return exact;
+    // Match by label (session name part)
+    const byLabel = sessions.find(s => s.label === target);
+    if (byLabel)
+        return byLabel;
+    // Match by partial: "machineId/session" where target might be partial machineId
+    const parts = target.split('/');
+    if (parts.length >= 2) {
+        const [machineHint, ...sessionParts] = parts;
+        const sessionName = sessionParts.join('/');
+        const match = sessions.find(s => s.id.includes(machineHint) && s.id.endsWith('/' + sessionName));
+        if (match)
+            return match;
+    }
+    // Match just session name (last part of id after /)
+    const bySessionName = sessions.find(s => {
+        const name = s.id.split('/').pop();
+        return name === target;
+    });
+    if (bySessionName)
+        return bySessionName;
+    return null;
+}

package/dist/commands/sessions.js

@@ -6,75 +6,68 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.listSessions = listSessions;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
-const api_1 = require("../api");
+const ws_1 = __importDefault(require("ws"));
 const config_1 = require("../config");
 async function listSessions(agentName) {
     if (!(0, config_1.isLoggedIn)()) {
-        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login <api-key>'));
+        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login'));
         process.exit(1);
     }
-    const spinner = (0, ora_1.default)('Fetching sessions...').start();
+    const token = (0, config_1.getAccessToken)() || (0, config_1.getAgentToken)() || (0, config_1.getApiKey)();
+    if (!token) {
+        console.log(chalk_1.default.red('No auth token found. Run: sessioncast login'));
+        process.exit(1);
+    }
+    const relayUrl = (0, config_1.getRelayUrl)();
+    const spinner = (0, ora_1.default)('Fetching sessions from relay...').start();
     try {
-        const agents = await api_1.api.listAgents();
-        const onlineAgents = agents.filter(a => a.isActive && a.apiEnabled);
-        if (onlineAgents.length === 0) {
-            spinner.stop();
-            console.log(chalk_1.default.yellow('No online agents with API enabled.'));
+        const sessions = await fetchSessionsFromRelay(relayUrl, token);
+        spinner.stop();
+        if (sessions.length === 0) {
+            console.log(chalk_1.default.yellow('No sessions found.'));
             return;
         }
+        // Group by machineId
+        const grouped = sessions.reduce((acc, s) => {
+            const machine = s.machineId || 'unknown';
+            if (!acc[machine])
+                acc[machine] = [];
+            acc[machine].push(s);
+            return acc;
+        }, {});
         // Filter by agent name if provided
-        let targetAgents = onlineAgents;
         if (agentName) {
-            const found = onlineAgents.find(a => a.label?.toLowerCase() === agentName.toLowerCase() ||
-                a.machineId?.toLowerCase() === agentName.toLowerCase() ||
-                a.id.startsWith(agentName));
-            if (!found) {
-                spinner.stop();
-                console.log(chalk_1.default.red(`Agent not found: ${agentName}`));
-                console.log(chalk_1.default.gray('Run: sessioncast agents'));
+            const matchedKey = Object.keys(grouped).find(k => k.toLowerCase().includes(agentName.toLowerCase()));
+            if (!matchedKey) {
+                console.log(chalk_1.default.red(`No agent matching: ${agentName}`));
+                console.log(chalk_1.default.gray('Available agents: ' + Object.keys(grouped).join(', ')));
                 process.exit(1);
             }
-            targetAgents = [found];
-        }
-        // Fetch sessions from all target agents
-        const allSessions = [];
-        for (const agent of targetAgents) {
-            try {
-                const sessions = await api_1.api.listSessions(agent.id);
-                allSessions.push({ agent, sessions });
-            }
-            catch (error) {
-                // Skip failed agents
-            }
+            const filtered = {};
+            filtered[matchedKey] = grouped[matchedKey];
+            Object.keys(grouped).forEach(k => { if (k !== matchedKey)
+                delete grouped[k]; });
+            Object.assign(grouped, filtered);
         }
-        spinner.stop();
-        if (allSessions.every(as => as.sessions.length === 0)) {
-            console.log(chalk_1.default.yellow('No tmux sessions found.'));
-            return;
-        }
-        console.log(chalk_1.default.bold('\nTmux Sessions:\n'));
-        // Table header
-        console.log(chalk_1.default.gray(padRight('AGENT', 16) +
-            padRight('SESSION', 16) +
-            padRight('WINDOWS', 10) +
-            padRight('ATTACHED', 10) +
+        console.log(chalk_1.default.bold('\nSessions:\n'));
+        console.log(chalk_1.default.gray(padRight('AGENT', 30) +
+            padRight('SESSION', 20) +
+            padRight('STATUS', 10) +
             'TARGET'));
-        console.log(chalk_1.default.gray('─'.repeat(70)));
-        // Table rows
-        for (const { agent, sessions } of allSessions) {
-            const agentName = agent.label || agent.machineId || agent.id.substring(0, 8);
-            for (const session of sessions) {
-                const attached = session.attached ? chalk_1.default.green('yes') : chalk_1.default.gray('no');
-                const target = `${agentName}:${session.name}`;
-                console.log(padRight(agentName, 16) +
-                    padRight(session.name, 16) +
-                    padRight(String(session.windows), 10) +
-                    padRight(attached, 10) +
+        console.log(chalk_1.default.gray('─'.repeat(80)));
+        for (const [machineId, machineSessions] of Object.entries(grouped)) {
+            for (const session of machineSessions) {
+                const label = session.label || session.id.split('/').pop() || session.id;
+                const statusColor = session.status === 'online' ? chalk_1.default.green : chalk_1.default.red;
+                const target = session.id;
+                console.log(padRight(machineId, 30) +
+                    padRight(label, 20) +
+                    padRight(statusColor(session.status), 10) +
                     chalk_1.default.cyan(target));
             }
         }
         console.log();
-        console.log(chalk_1.default.gray('Use: sessioncast send <target> "command"'));
+        console.log(chalk_1.default.gray('Use: sessioncast send <session-label> "command"'));
     }
     catch (error) {
         spinner.stop();
@@ -82,6 +75,39 @@ async function listSessions(agentName) {
         process.exit(1);
     }
 }
+function fetchSessionsFromRelay(relayUrl, token) {
+    return new Promise((resolve, reject) => {
+        const wsUrl = `${relayUrl}?token=${encodeURIComponent(token)}`;
+        const ws = new ws_1.default(wsUrl);
+        const timeout = setTimeout(() => {
+            ws.close();
+            reject(new Error('Timeout waiting for session list'));
+        }, 10000);
+        ws.on('open', () => {
+            ws.send(JSON.stringify({ type: 'listSessions' }));
+        });
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (message.type === 'sessionList' && message.sessions) {
+                    clearTimeout(timeout);
+                    ws.close();
+                    resolve(message.sessions);
+                }
+            }
+            catch {
+                // ignore
+            }
+        });
+        ws.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(new Error(`WebSocket error: ${err.message}`));
+        });
+        ws.on('close', () => {
+            clearTimeout(timeout);
+        });
+    });
+}
 function padRight(str, len) {
     const plainStr = str.replace(/\x1b\[[0-9;]*m/g, '');
     const padding = Math.max(0, len - plainStr.length);

package/package.json

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