sessioncast-cli 2.0.0 → 2.0.2

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

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

package/dist/agent/session-handler.js

@@ -39,8 +39,8 @@ const tmux = __importStar(require("./tmux"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 // Capture intervals
-const CAPTURE_INTERVAL_ACTIVE_MS = 50;
-const CAPTURE_INTERVAL_IDLE_MS = 200;
+const CAPTURE_INTERVAL_ACTIVE_MS = 16;
+const CAPTURE_INTERVAL_IDLE_MS = 100;
 const ACTIVE_THRESHOLD_MS = 2000;
 const FORCE_SEND_INTERVAL_MS = 10000;
 const USE_COMPRESSION = true;
@@ -49,7 +49,8 @@ class TmuxSessionHandler {
     constructor(options) {
         this.wsClient = null;
         this.running = false;
-        this.lastScreen = '';
+        this.lastScreens = new Map();
+        this.lastPaneLayoutJson = '';
         this.lastForceSendTime = 0;
         this.lastChangeTime = 0;
         this.captureTimer = null;
@@ -83,14 +84,16 @@ 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) => {
-            this.handleKeys(keys);
+        this.wsClient.on('keys', (keys, meta) => {
+            this.handleKeys(keys, meta);
         });
         this.wsClient.on('resize', ({ cols, rows }) => {
             console.log(`[${this.tmuxSession}] Resize: ${cols}x${rows}`);
@@ -279,8 +282,9 @@ class TmuxSessionHandler {
         };
         return types[ext] || 'application/octet-stream';
     }
-    handleKeys(keys) {
-        tmux.sendKeys(this.tmuxSession, keys, false);
+    handleKeys(keys, meta) {
+        const target = meta?.pane ? `${this.tmuxSession}.${meta.pane}` : this.tmuxSession;
+        tmux.sendKeys(target, keys, false);
     }
     startScreenCapture() {
         if (this.captureTimer)
@@ -292,43 +296,86 @@ 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;
+                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);
                         }
-                        // 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);
+                    }
+                }
+                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);
+                                }
+                            }
                         }
                     }
-                    // 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);
+                    // 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);
+                            }
+                        }
+                    }
+                }
+                if (anyChanged || forceTime) {
+                    this.lastForceSendTime = now;
+                    if (anyChanged) {
+                        this.lastChangeTime = now;
+                    }
                 }
+                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);
             }
         };
-        capture();
+        // Small delay to ensure register message is processed by server first
+        setTimeout(capture, 300);
         console.log(`[${this.tmuxSession}] Screen capture started`);
     }
     stopScreenCapture() {

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

@@ -4,7 +4,17 @@
  */
 export interface TmuxExecutor {
     listSessions(): string[];
-    capturePane(session: string): string | null;
+    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;
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
@@ -20,7 +30,17 @@ export interface TmuxExecutor {
  */
 export declare class UnixTmuxExecutor implements TmuxExecutor {
     listSessions(): string[];
-    capturePane(session: string): string | null;
+    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;
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
@@ -41,7 +61,17 @@ export declare class WindowsTmuxExecutor implements TmuxExecutor {
     constructor(itmuxPath: string);
     private executeCommand;
     listSessions(): string[];
-    capturePane(session: string): string | null;
+    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;
     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,9 +60,31 @@ class UnixTmuxExecutor {
             return [];
         }
     }
-    capturePane(session) {
+    listPanes(session) {
         try {
-            const output = (0, child_process_1.execSync)(`tmux capture-pane -t "${session}" -p -e -N`, {
+            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`, {
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
                 maxBuffer: 10 * 1024 * 1024
@@ -223,9 +245,34 @@ class WindowsTmuxExecutor {
             return [];
         }
     }
-    capturePane(session) {
+    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}:#{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 } from './types';
+import { TmuxSession, PaneInfo } from './types';
 /**
  * Scan for all tmux sessions
  */
@@ -7,10 +7,14 @@ 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): string | null;
+export declare function capturePane(sessionName: string, paneId?: string): string | null;
 /**
  * Send keys to tmux session
  */

package/dist/agent/tmux.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanSessions = scanSessions;
 exports.listSessions = listSessions;
+exports.listPanes = listPanes;
 exports.capturePane = capturePane;
 exports.sendKeys = sendKeys;
 exports.resizeWindow = resizeWindow;
@@ -49,11 +50,17 @@ 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) {
-    return getExecutor().capturePane(sessionName);
+function capturePane(sessionName, paneId) {
+    return getExecutor().capturePane(sessionName, paneId);
 }
 /**
  * Send keys to tmux session

package/dist/agent/types.d.ts

@@ -37,6 +37,16 @@ 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,16 +21,35 @@ 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): boolean;
-    sendScreenCompressed(data: Buffer): 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;
     /**
      * Send file content to be displayed in the web FileViewer
      * @param filename - The name of the file

package/dist/agent/websocket.js

@@ -40,10 +40,11 @@ exports.RelayWebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const zlib = __importStar(require("zlib"));
-const MAX_RECONNECT_ATTEMPTS = 5;
+const MAX_RECONNECT_ATTEMPTS = 50;
 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();
@@ -53,6 +54,7 @@ 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;
@@ -70,8 +72,9 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                 this.isConnected = true;
                 this.reconnectAttempts = 0;
                 this.circuitBreakerOpen = false;
-                this.emit('connected');
                 this.registerAsHost();
+                this.startPing();
+                this.emit('connected');
             });
             this.ws.on('message', (data) => {
                 try {
@@ -84,6 +87,7 @@ 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();
@@ -119,7 +123,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);
                 }
                 break;
             case 'resize':
@@ -188,6 +192,20 @@ 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;
@@ -239,32 +257,49 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             return false;
         }
     }
-    sendScreen(data) {
+    sendScreen(data, paneMeta) {
         if (!this.isConnected)
             return false;
         const base64Data = data.toString('base64');
-        return this.send({
+        const msg = {
             type: 'screen',
             session: this.sessionId,
             payload: base64Data
-        });
+        };
+        if (paneMeta) {
+            msg.meta = { pane: paneMeta.pane, index: String(paneMeta.index) };
+        }
+        return this.send(msg);
     }
-    sendScreenCompressed(data) {
+    sendScreenCompressed(data, paneMeta) {
         if (!this.isConnected)
             return false;
         try {
             const compressed = zlib.gzipSync(data);
             const base64Data = compressed.toString('base64');
-            return this.send({
+            const msg = {
                 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);
+            return this.sendScreen(data, paneMeta);
         }
     }
+    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
@@ -323,6 +358,7 @@ 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/autopilot/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * AutoPilot - Single-prompt execution layer for SessionCast
+ *
+ * Enables opencode-style experience: one prompt → auto-detect → auto-analyze → auto-execute
+ */
+import { EventEmitter } from 'events';
+import { AutoPilotContext, AutoPilotOptions, GeneratedWorkflow } from './types';
+import { toExecutableWorkflow } from './workflow-generator';
+import { generateSpeckit } from './speckit-generator';
+export * from './types';
+export { generateSpeckit, generateQuickSpeckit, saveSpeckit } from './speckit-generator';
+export type { SpeckitOutput } from './speckit-generator';
+export declare class AutoPilot extends EventEmitter {
+    private options;
+    private context;
+    private llmClient?;
+    constructor(options: AutoPilotOptions);
+    /**
+     * Create initial context
+     */
+    private createInitialContext;
+    /**
+     * Set LLM client for mission analysis
+     */
+    setLlmClient(client: {
+        chat: (messages: {
+            role: string;
+            content: string;
+        }[]) => Promise<string>;
+    }): void;
+    /**
+     * Get current context
+     */
+    getContext(): AutoPilotContext;
+    /**
+     * Main entry point: execute a single prompt
+     */
+    execute(prompt: string): Promise<GeneratedWorkflow>;
+    /**
+     * Quick execute without LLM analysis
+     */
+    quickExecute(prompt: string): Promise<GeneratedWorkflow>;
+    /**
+     * Phase 1: Detect project type
+     */
+    private detectProject;
+    /**
+     * Phase 2: Scan sources
+     */
+    private scanProject;
+    /**
+     * Phase 3: Analyze mission
+     */
+    private analyzeMission;
+    /**
+     * Phase 4: Generate workflow
+     */
+    private generateWorkflow;
+    /**
+     * Convert to executable workflow format (compatible with existing ProjectManager)
+     */
+    toExecutableFormat(): ReturnType<typeof toExecutableWorkflow> | null;
+    /**
+     * Convert to Speckit format (plan.md + tasks.md)
+     */
+    toSpeckit(): ReturnType<typeof generateSpeckit>;
+    /**
+     * Generate and save Speckit files
+     */
+    saveSpeckit(outputDir?: string): {
+        planPath: string;
+        tasksPath: string;
+    };
+    /**
+     * Update status and emit event
+     */
+    private updateStatus;
+    /**
+     * Get a summary of the analysis for display
+     */
+    getSummary(): string;
+    /**
+     * Save workflow to file
+     */
+    saveWorkflow(outputPath?: string): Promise<string>;
+}
+/**
+ * Convenience function for one-shot execution
+ */
+export declare function autoPilot(prompt: string, options: AutoPilotOptions): Promise<GeneratedWorkflow>;
+/**
+ * Quick version without LLM
+ */
+export declare function autoPilotQuick(prompt: string, options: AutoPilotOptions): Promise<GeneratedWorkflow>;