sessioncast-cli 1.0.0 → 1.1.0

package/dist/agent/tmux.js

@@ -7,45 +7,41 @@ exports.sendKeys = sendKeys;
 exports.resizeWindow = resizeWindow;
 exports.createSession = createSession;
 exports.killSession = killSession;
-const child_process_1 = require("child_process");
+exports.isAvailable = isAvailable;
+exports.getVersion = getVersion;
+const tmux_executor_1 = require("./tmux-executor");
+// Lazy-initialized executor (created on first use)
+let executor = null;
+/**
+ * Get or create the tmux executor for the current platform.
+ */
+function getExecutor() {
+    if (!executor) {
+        console.log(`[tmux] Initializing on ${(0, tmux_executor_1.getPlatformName)()}`);
+        executor = (0, tmux_executor_1.createTmuxExecutor)();
+        const version = executor.getVersion();
+        console.log(`[tmux] Version: ${version}`);
+    }
+    return executor;
+}
 /**
  * Scan for all tmux sessions
  */
 function scanSessions() {
-    try {
-        const output = (0, child_process_1.execSync)('tmux ls -F "#{session_name}"', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        return output
-            .trim()
-            .split('\n')
-            .filter(s => s.length > 0);
-    }
-    catch {
-        // tmux not running or no sessions
-        return [];
-    }
+    return getExecutor().listSessions();
 }
 /**
  * Get detailed session info
  */
 function listSessions() {
     try {
-        const output = (0, child_process_1.execSync)('tmux list-sessions -F "#{session_name}|#{session_windows}|#{session_created}|#{session_attached}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-        return output
-            .trim()
-            .split('\n')
-            .filter(line => line.length > 0)
-            .map(line => {
-            const [name, windows, created, attached] = line.split('|');
-            return {
-                name,
-                windows: parseInt(windows, 10) || 1,
-                created: created || undefined,
-                attached: attached === '1'
-            };
-        });
+        const sessions = getExecutor().listSessions();
+        // For now, return basic info (detailed info would require additional tmux commands)
+        return sessions.map(name => ({
+            name,
+            windows: 1,
+            attached: false
+        }));
     }
     catch {
         return [];
@@ -55,53 +51,39 @@ function listSessions() {
  * Capture tmux pane content with escape sequences (colors)
  */
 function capturePane(sessionName) {
-    try {
-        const output = (0, child_process_1.execSync)(`tmux capture-pane -t "${sessionName}" -p -e -N`, {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            maxBuffer: 10 * 1024 * 1024 // 10MB
-        });
-        // Normalize line endings
-        return output.replace(/\n/g, '\r\n');
-    }
-    catch {
-        return null;
-    }
+    return getExecutor().capturePane(sessionName);
 }
 /**
  * Send keys to tmux session
  */
 function sendKeys(target, keys, enter = true) {
+    const exec = getExecutor();
     try {
         // Handle special keys
         if (keys === '\x03') {
             // Ctrl+C
-            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" C-c`, { stdio: 'pipe' });
-            return true;
+            return exec.sendSpecialKey(target, 'C-c');
         }
         if (keys === '\x04') {
             // Ctrl+D
-            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" C-d`, { stdio: 'pipe' });
-            return true;
+            return exec.sendSpecialKey(target, 'C-d');
         }
         // For Enter key only
         if (keys === '\n' || keys === '\r\n') {
-            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" Enter`, { stdio: 'pipe' });
-            return true;
+            return exec.sendSpecialKey(target, 'Enter');
         }
         // For text with newline at end (command + enter)
         if (keys.endsWith('\n')) {
             const cmd = keys.slice(0, -1);
             if (cmd) {
-                (0, child_process_1.execSync)(`tmux send-keys -t "${target}" -l "${escapeForShell(cmd)}"`, { stdio: 'pipe' });
+                exec.sendKeys(target, cmd);
             }
-            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" Enter`, { stdio: 'pipe' });
-            return true;
+            return exec.sendSpecialKey(target, 'Enter');
         }
         // Regular text input
-        (0, child_process_1.execSync)(`tmux send-keys -t "${target}" -l "${escapeForShell(keys)}"`, { stdio: 'pipe' });
+        exec.sendKeys(target, keys);
         if (enter) {
-            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" Enter`, { stdio: 'pipe' });
+            exec.sendSpecialKey(target, 'Enter');
         }
         return true;
     }
@@ -113,45 +95,39 @@ function sendKeys(target, keys, enter = true) {
  * Resize tmux window
  */
 function resizeWindow(sessionName, cols, rows) {
-    try {
-        (0, child_process_1.execSync)(`tmux resize-window -t "${sessionName}" -x ${cols} -y ${rows}`, { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return getExecutor().resizeWindow(sessionName, cols, rows);
 }
 /**
  * Create new tmux session
  */
-function createSession(sessionName) {
-    try {
-        // Sanitize session name
-        const sanitized = sessionName.replace(/[^a-zA-Z0-9_-]/g, '_');
-        if (!sanitized)
-            return false;
-        (0, child_process_1.execSync)(`tmux new-session -d -s "${sanitized}"`, { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
+function createSession(sessionName, workingDir) {
+    return getExecutor().createSession(sessionName, workingDir);
 }
 /**
  * Kill tmux session
  */
 function killSession(sessionName) {
+    return getExecutor().killSession(sessionName);
+}
+/**
+ * Check if tmux is available
+ */
+function isAvailable() {
     try {
-        (0, child_process_1.execSync)(`tmux kill-session -t "${sessionName}"`, { stdio: 'pipe' });
-        return true;
+        return getExecutor().isAvailable();
     }
     catch {
         return false;
     }
 }
 /**
- * Escape string for shell
+ * Get tmux version
  */
-function escapeForShell(str) {
-    return str.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
+function getVersion() {
+    try {
+        return getExecutor().getVersion();
+    }
+    catch {
+        return null;
+    }
 }

package/dist/agent/websocket.d.ts

@@ -26,19 +26,13 @@ export declare class RelayWebSocketClient extends EventEmitter {
     connect(): void;
     private registerAsHost;
     private handleMessage;
+    private handleFileUpload;
     private handleError;
     private scheduleReconnect;
     send(message: Message): boolean;
     sendScreen(data: Buffer): boolean;
     sendScreenCompressed(data: Buffer): boolean;
-    /**
-     * Send file content to be displayed in the web FileViewer
-     * @param filename - The name of the file
-     * @param content - The file content (UTF-8 for text, base64 for images)
-     * @param contentType - MIME type (e.g., 'text/markdown', 'text/html', 'image/png')
-     * @param path - Optional file path
-     */
-    sendFileView(filename: string, content: string, contentType: string, path?: string): boolean;
+    sendFileView(filePath: string, content: string, language: string, error?: string): boolean;
     getConnected(): boolean;
     destroy(): void;
 }

package/dist/agent/websocket.js

@@ -40,6 +40,7 @@ exports.RelayWebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const zlib = __importStar(require("zlib"));
+const fileUtils_1 = require("../utils/fileUtils");
 const MAX_RECONNECT_ATTEMPTS = 5;
 const BASE_RECONNECT_DELAY_MS = 2000;
 const MAX_RECONNECT_DELAY_MS = 60000;
@@ -116,6 +117,10 @@ class RelayWebSocketClient extends events_1.EventEmitter {
         });
     }
     handleMessage(message) {
+        // Debug: log all incoming message types (except frequent ones)
+        if (message.type !== 'pong' && message.type !== 'keys') {
+            console.log(`[WS] Message received: type=${message.type}, session=${message.session}`);
+        }
         switch (message.type) {
             case 'keys':
                 if (message.session === this.sessionId && message.payload) {
@@ -141,6 +146,20 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                     this.emit('killSession');
                 }
                 break;
+            case 'requestFileView':
+                console.log(`[WS] requestFileView received: session=${message.session}, mySession=${this.sessionId}, filePath=${message.meta?.filePath}`);
+                if (message.session === this.sessionId && message.meta?.filePath) {
+                    this.emit('requestFileView', message.meta.filePath);
+                }
+                else {
+                    console.log(`[WS] requestFileView ignored: sessionMatch=${message.session === this.sessionId}, hasFilePath=${!!message.meta?.filePath}`);
+                }
+                break;
+            case 'uploadFile':
+                if (message.session === this.sessionId && message.meta && message.payload) {
+                    this.handleFileUpload(message);
+                }
+                break;
             case 'error':
                 this.handleError(message);
                 break;
@@ -148,6 +167,55 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                 this.emit('message', message);
         }
     }
+    async handleFileUpload(message) {
+        const meta = message.meta;
+        if (!meta || !message.payload)
+            return;
+        try {
+            const result = await (0, fileUtils_1.handleUploadChunk)(this.sessionId, {
+                filename: meta.filename || 'unknown',
+                size: meta.size || '0',
+                mimeType: meta.mimeType || 'application/octet-stream',
+                chunkIndex: meta.chunkIndex || '0',
+                totalChunks: meta.totalChunks || '1',
+            }, message.payload);
+            // Only send response when upload is complete (result is not null)
+            if (result) {
+                if (result.success) {
+                    this.send({
+                        type: 'uploadComplete',
+                        session: this.sessionId,
+                        meta: {
+                            filename: meta.filename || 'unknown',
+                            path: result.path || '',
+                            success: 'true',
+                        },
+                    });
+                }
+                else {
+                    this.send({
+                        type: 'uploadError',
+                        session: this.sessionId,
+                        meta: {
+                            filename: meta.filename || 'unknown',
+                            error: result.error || 'Upload failed',
+                        },
+                    });
+                }
+            }
+        }
+        catch (e) {
+            console.error('[WS] File upload error:', e);
+            this.send({
+                type: 'uploadError',
+                session: this.sessionId,
+                meta: {
+                    filename: meta.filename || 'unknown',
+                    error: e instanceof Error ? e.message : 'Upload failed',
+                },
+            });
+        }
+    }
     handleError(message) {
         const meta = message.meta;
         if (!meta)
@@ -248,25 +316,21 @@ class RelayWebSocketClient extends events_1.EventEmitter {
             return this.sendScreen(data);
         }
     }
-    /**
-     * Send file content to be displayed in the web FileViewer
-     * @param filename - The name of the file
-     * @param content - The file content (UTF-8 for text, base64 for images)
-     * @param contentType - MIME type (e.g., 'text/markdown', 'text/html', 'image/png')
-     * @param path - Optional file path
-     */
-    sendFileView(filename, content, contentType, path) {
+    sendFileView(filePath, content, language, error) {
         if (!this.isConnected)
             return false;
+        const meta = {
+            filePath: filePath,
+            language: language
+        };
+        if (error) {
+            meta.error = error;
+        }
         return this.send({
             type: 'file_view',
             session: this.sessionId,
-            meta: {
-                filename,
-                contentType,
-                path: path || ''
-            },
-            payload: content
+            meta: meta,
+            payload: Buffer.from(content).toString('base64')
         });
     }
     getConnected() {

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>;