sessioncast-cli 1.1.5 → 2.0.0

package/README.md

@@ -12,7 +12,8 @@ Node.js agent and CLI for [SessionCast](https://sessioncast.io) - a real-time te
 - **File viewer**: Cmd+Click on file paths to view files in browser
 
 ### CLI Commands
-- `sessioncast login <api-key>` - Authenticate with API key
+- `sessioncast login` - Browser-based OAuth login (recommended)
+- `sessioncast login <api-key>` - Authenticate with API key or agent token
 - `sessioncast logout` - Clear stored credentials
 - `sessioncast status` - Check authentication status
 - `sessioncast agents` - List registered agents
@@ -26,6 +27,31 @@ Node.js agent and CLI for [SessionCast](https://sessioncast.io) - a real-time te
 npm install -g sessioncast-cli
 ```
 
+### Requirements
+- Node.js 18+
+- tmux (Linux/macOS) or [itmux](https://github.com/itefixnet/itmux) (Windows)
+
+### Windows Setup
+
+**Quick Install (PowerShell - Recommended)**:
+```powershell
+# Download and extract itmux to C:\itmux
+Invoke-WebRequest -Uri "https://github.com/itefixnet/itmux/releases/download/v1.1.0/itmux_1.1.0_x64_free.zip" -OutFile "$env:TEMP\itmux.zip"
+Expand-Archive -Path "$env:TEMP\itmux.zip" -DestinationPath "C:\itmux" -Force
+
+# Install SessionCast CLI
+npm install -g sessioncast-cli
+```
+
+**Manual Installation**:
+1. Download [itmux v1.1.0](https://github.com/itefixnet/itmux/releases/download/v1.1.0/itmux_1.1.0_x64_free.zip)
+2. Extract to one of these locations:
+   - `C:\itmux` (recommended)
+   - `%USERPROFILE%\itmux`
+   - Or set `ITMUX_HOME` environment variable
+3. Verify: `C:\itmux\bin\bash.exe` should exist
+4. Install CLI: `npm install -g sessioncast-cli`
+
 ## Quick Start
 
 1. **Get your agent token** from [app.sessioncast.io](https://app.sessioncast.io)

package/dist/agent/runner.js

@@ -36,10 +36,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRunner = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const yaml = __importStar(require("js-yaml"));
 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 SCAN_INTERVAL_MS = 5000;
 class AgentRunner {
     constructor(config) {
@@ -50,6 +52,8 @@ class AgentRunner {
         this.config = config;
     }
     static loadConfig(configPath) {
+        // Check if agent token is available (for relay connection)
+        const agentToken = (0, config_1.getAgentToken)();
         // Check environment variable
         const envPath = process.env.SESSIONCAST_CONFIG || process.env.TMUX_REMOTE_CONFIG;
         // Try multiple default paths
@@ -66,33 +70,32 @@ class AgentRunner {
                 }
             }
         }
-        // If yml file found, load from file
-        if (finalPath && fs.existsSync(finalPath)) {
-            console.log(`Loading config from: ${finalPath}`);
-            const content = fs.readFileSync(finalPath, 'utf-8');
-            const ext = path.extname(finalPath).toLowerCase();
-            if (ext === '.json') {
-                return JSON.parse(content);
-            }
-            else {
-                return yaml.load(content);
-            }
-        }
-        // SaaS mode: load from conf store (after sessioncast login)
-        const config_1 = require("../config");
-        const agentToken = (0, config_1.getAgentToken)();
-        const relayUrl = (0, config_1.getRelayUrl)();
-        const machineId = (0, config_1.getMachineId)();
-        if (agentToken) {
-            const os = require("os");
-            console.log('Loading config from login credentials (SaaS mode)');
+        // 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()}`;
             return {
-                machineId: machineId || os.hostname(),
-                relay: relayUrl || 'wss://relay.sessioncast.io/ws',
+                machineId,
+                relay: (0, config_1.getRelayUrl)(),
                 token: agentToken,
+                api: {
+                    enabled: false
+                }
             };
         }
-        throw new Error('No config found. Run "sessioncast login" first, or create ~/.sessioncast.yml');
+        if (!finalPath || !fs.existsSync(finalPath)) {
+            throw new Error(`Config file not found. Tried: ${configPath || envPath || defaultPaths.join(', ')}`);
+        }
+        console.log(`Loading config from: ${finalPath}`);
+        const content = fs.readFileSync(finalPath, 'utf-8');
+        const ext = path.extname(finalPath).toLowerCase();
+        if (ext === '.json') {
+            return JSON.parse(content);
+        }
+        else {
+            return yaml.load(content);
+        }
     }
     async start() {
         if (this.running)

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

@@ -15,11 +15,40 @@ export declare class TmuxSessionHandler {
     private lastForceSendTime;
     private lastChangeTime;
     private captureTimer;
+    private pendingUploads;
+    private uploadDir;
     constructor(options: SessionHandlerOptions);
     start(): void;
     private connectAndRun;
+    /**
+     * Handle file view request from web client
+     */
+    private handleRequestFileView;
+    /**
+     * Handle incoming file upload chunk
+     */
+    private handleUploadChunk;
+    /**
+     * Complete file upload by assembling chunks and writing to disk
+     */
+    private completeUpload;
+    /**
+     * Get upload directory (try to get tmux pane's current working directory)
+     */
+    private getUploadDirectory;
+    /**
+     * Sanitize filename to prevent path traversal attacks
+     */
+    private sanitizeFilename;
+    /**
+     * Get unique file path if file already exists
+     */
+    private getUniqueFilePath;
+    /**
+     * Get content type from file extension
+     */
+    private getContentType;
     private handleKeys;
-    private handleFileViewRequest;
     private startScreenCapture;
     private stopScreenCapture;
     stop(): void;

package/dist/agent/session-handler.js

@@ -38,26 +38,6 @@ const websocket_1 = require("./websocket");
 const tmux = __importStar(require("./tmux"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-function expandPath(filePath) {
-    if (filePath.startsWith('~/')) {
-        return path.join(os.homedir(), filePath.slice(2));
-    }
-    return filePath;
-}
-function getLanguage(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    const langMap = {
-        '.js': 'javascript', '.ts': 'typescript', '.tsx': 'typescript',
-        '.jsx': 'javascript', '.json': 'json', '.md': 'markdown',
-        '.py': 'python', '.java': 'java', '.sh': 'shell',
-        '.css': 'css', '.html': 'html', '.yaml': 'yaml', '.yml': 'yaml',
-        '.kt': 'kotlin', '.swift': 'swift', '.go': 'go', '.rs': 'rust',
-        '.c': 'c', '.cpp': 'cpp', '.h': 'c', '.hpp': 'cpp',
-        '.rb': 'ruby', '.php': 'php', '.sql': 'sql', '.xml': 'xml',
-    };
-    return langMap[ext] || 'text';
-}
 // Capture intervals
 const CAPTURE_INTERVAL_ACTIVE_MS = 50;
 const CAPTURE_INTERVAL_IDLE_MS = 200;
@@ -73,6 +53,9 @@ class TmuxSessionHandler {
         this.lastForceSendTime = 0;
         this.lastChangeTime = 0;
         this.captureTimer = null;
+        // File upload handling
+        this.pendingUploads = new Map();
+        this.uploadDir = process.cwd(); // Default to current working directory
         this.config = options.config;
         this.tmuxSession = options.tmuxSession;
         this.sessionId = `${options.config.machineId}/${options.tmuxSession}`;
@@ -125,32 +108,179 @@ class TmuxSessionHandler {
             this.stop();
         });
         this.wsClient.on('requestFileView', (filePath) => {
-            console.log(`[${this.tmuxSession}] File view request: ${filePath}`);
-            this.handleFileViewRequest(filePath);
+            this.handleRequestFileView(filePath);
+        });
+        this.wsClient.on('uploadFile', (chunk) => {
+            this.handleUploadChunk(chunk);
         });
         this.wsClient.on('error', (error) => {
             console.error(`[${this.tmuxSession}] WebSocket error:`, error.message);
         });
         this.wsClient.connect();
     }
-    handleKeys(keys) {
-        tmux.sendKeys(this.tmuxSession, keys, false);
+    /**
+     * Handle file view request from web client
+     */
+    handleRequestFileView(filePath) {
+        console.log(`[${this.tmuxSession}] File view request: ${filePath}`);
+        try {
+            // Resolve file path (could be relative or absolute)
+            const resolvedPath = path.isAbsolute(filePath)
+                ? filePath
+                : path.resolve(this.uploadDir, filePath);
+            if (!fs.existsSync(resolvedPath)) {
+                console.log(`[${this.tmuxSession}] File not found: ${resolvedPath}`);
+                return;
+            }
+            const stat = fs.statSync(resolvedPath);
+            if (!stat.isFile()) {
+                console.log(`[${this.tmuxSession}] Not a file: ${resolvedPath}`);
+                return;
+            }
+            // Read file and send to viewer
+            const content = fs.readFileSync(resolvedPath);
+            const base64Content = content.toString('base64');
+            const filename = path.basename(resolvedPath);
+            const ext = path.extname(filename).toLowerCase();
+            // Determine content type
+            const contentType = this.getContentType(ext);
+            this.wsClient?.sendFileView(filename, base64Content, contentType, resolvedPath);
+            console.log(`[${this.tmuxSession}] Sent file view: ${filename}`);
+        }
+        catch (error) {
+            console.error(`[${this.tmuxSession}] Error reading file:`, error);
+        }
     }
-    handleFileViewRequest(filePath) {
-        if (!this.wsClient)
-            return;
-        const realPath = expandPath(filePath);
-        const language = getLanguage(filePath);
+    /**
+     * Handle incoming file upload chunk
+     */
+    handleUploadChunk(chunk) {
+        const { filename, size, chunkIndex, totalChunks, payload } = chunk;
+        console.log(`[${this.tmuxSession}] Upload chunk: ${filename} (${chunkIndex + 1}/${totalChunks})`);
+        // Sanitize filename to prevent path traversal
+        const safeFilename = this.sanitizeFilename(filename);
+        const uploadKey = `${safeFilename}_${size}`;
+        // Get or create pending upload
+        let pending = this.pendingUploads.get(uploadKey);
+        if (!pending) {
+            pending = {
+                filename: safeFilename,
+                size,
+                chunks: new Map(),
+                totalChunks,
+                receivedAt: Date.now()
+            };
+            this.pendingUploads.set(uploadKey, pending);
+        }
+        // Store chunk
+        pending.chunks.set(chunkIndex, payload);
+        // Check if all chunks received
+        if (pending.chunks.size === totalChunks) {
+            this.completeUpload(uploadKey, pending);
+        }
+    }
+    /**
+     * Complete file upload by assembling chunks and writing to disk
+     */
+    completeUpload(uploadKey, pending) {
         try {
-            const content = fs.readFileSync(realPath, 'utf-8');
-            console.log(`[${this.tmuxSession}] File read: ${content.length} bytes`);
-            this.wsClient.sendFileView(filePath, content, language);
+            // Assemble chunks in order
+            const chunks = [];
+            for (let i = 0; i < pending.totalChunks; i++) {
+                const chunkData = pending.chunks.get(i);
+                if (!chunkData) {
+                    throw new Error(`Missing chunk ${i}`);
+                }
+                chunks.push(Buffer.from(chunkData, 'base64'));
+            }
+            const fileBuffer = Buffer.concat(chunks);
+            // Determine upload directory (try to get tmux pane's cwd)
+            const uploadPath = this.getUploadDirectory();
+            const filePath = path.join(uploadPath, pending.filename);
+            // Handle filename conflicts
+            const finalPath = this.getUniqueFilePath(filePath);
+            // Write file
+            fs.writeFileSync(finalPath, fileBuffer);
+            console.log(`[${this.tmuxSession}] File uploaded: ${finalPath}`);
+            // Send success notification
+            this.wsClient?.sendUploadComplete(pending.filename, finalPath);
+            // Cleanup
+            this.pendingUploads.delete(uploadKey);
+        }
+        catch (error) {
+            console.error(`[${this.tmuxSession}] Upload failed:`, error);
+            this.wsClient?.sendUploadError(pending.filename, error.message);
+            this.pendingUploads.delete(uploadKey);
+        }
+    }
+    /**
+     * Get upload directory (try to get tmux pane's current working directory)
+     */
+    getUploadDirectory() {
+        try {
+            // Try to get pane's current directory from tmux
+            const paneId = tmux.getActivePane(this.tmuxSession);
+            if (paneId) {
+                const cwd = tmux.getPaneCwd(this.tmuxSession, paneId);
+                if (cwd && fs.existsSync(cwd)) {
+                    return cwd;
+                }
+            }
         }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-            console.error(`[${this.tmuxSession}] File read error: ${errorMessage}`);
-            this.wsClient.sendFileView(filePath, `Error: ${errorMessage}`, 'text', errorMessage);
+        catch {
+            // Ignore errors, fall back to default
         }
+        return this.uploadDir;
+    }
+    /**
+     * Sanitize filename to prevent path traversal attacks
+     */
+    sanitizeFilename(filename) {
+        // Remove path separators and dangerous characters
+        return path.basename(filename).replace(/[<>:"|?*\x00-\x1f]/g, '_');
+    }
+    /**
+     * Get unique file path if file already exists
+     */
+    getUniqueFilePath(filePath) {
+        if (!fs.existsSync(filePath)) {
+            return filePath;
+        }
+        const dir = path.dirname(filePath);
+        const ext = path.extname(filePath);
+        const name = path.basename(filePath, ext);
+        let counter = 1;
+        let newPath;
+        do {
+            newPath = path.join(dir, `${name} (${counter})${ext}`);
+            counter++;
+        } while (fs.existsSync(newPath) && counter < 1000);
+        return newPath;
+    }
+    /**
+     * Get content type from file extension
+     */
+    getContentType(ext) {
+        const types = {
+            '.txt': 'text/plain',
+            '.md': 'text/markdown',
+            '.html': 'text/html',
+            '.css': 'text/css',
+            '.js': 'text/javascript',
+            '.ts': 'text/typescript',
+            '.json': 'application/json',
+            '.xml': 'application/xml',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.pdf': 'application/pdf',
+        };
+        return types[ext] || 'application/octet-stream';
+    }
+    handleKeys(keys) {
+        tmux.sendKeys(this.tmuxSession, keys, false);
     }
     startScreenCapture() {
         if (this.captureTimer)

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

@@ -12,6 +12,8 @@ export interface TmuxExecutor {
     createSession(session: string, workingDir?: string): boolean;
     isAvailable(): boolean;
     getVersion(): string | null;
+    getActivePane(session: string): string | null;
+    getPaneCwd(session: string, paneId?: string): string | null;
 }
 /**
  * Unix/Linux/macOS implementation of TmuxExecutor.
@@ -26,6 +28,8 @@ export declare class UnixTmuxExecutor implements TmuxExecutor {
     createSession(session: string, workingDir?: string): boolean;
     isAvailable(): boolean;
     getVersion(): string | null;
+    getActivePane(session: string): string | null;
+    getPaneCwd(session: string, paneId?: string): string | null;
     private escapeForShell;
 }
 /**
@@ -45,6 +49,8 @@ export declare class WindowsTmuxExecutor implements TmuxExecutor {
     createSession(session: string, workingDir?: string): boolean;
     isAvailable(): boolean;
     getVersion(): string | null;
+    getActivePane(session: string): string | null;
+    getPaneCwd(session: string, paneId?: string): string | null;
     private escapeSession;
     private windowsToCygwinPath;
     /**

package/dist/agent/tmux-executor.js

@@ -143,6 +143,31 @@ class UnixTmuxExecutor {
             return null;
         }
     }
+    getActivePane(session) {
+        try {
+            const output = (0, child_process_1.execSync)(`tmux display-message -t "${session}" -p "#{pane_id}"`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            return output.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getPaneCwd(session, paneId) {
+        try {
+            const target = paneId ? `${session}:${paneId}` : session;
+            const output = (0, child_process_1.execSync)(`tmux display-message -t "${target}" -p "#{pane_current_path}"`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            return output.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
     escapeForShell(str) {
         return str.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
     }
@@ -289,6 +314,27 @@ class WindowsTmuxExecutor {
             return null;
         }
     }
+    getActivePane(session) {
+        try {
+            const escaped = this.escapeSession(session);
+            const output = this.executeCommand(`tmux display-message -t '${escaped}' -p "#{pane_id}"`);
+            return output.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getPaneCwd(session, paneId) {
+        try {
+            const escapedSession = this.escapeSession(session);
+            const target = paneId ? `${escapedSession}:${paneId}` : escapedSession;
+            const output = this.executeCommand(`tmux display-message -t '${target}' -p "#{pane_current_path}"`);
+            return output.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
     escapeSession(session) {
         return session.replace(/'/g, "'\\''");
     }
@@ -342,8 +388,21 @@ function createTmuxExecutor() {
     if (isWindows) {
         const itmuxPath = WindowsTmuxExecutor.findItmuxPath();
         if (!itmuxPath) {
-            throw new Error('itmux not found. Please install itmux from https://github.com/itefixnet/itmux\n' +
-                'Set ITMUX_HOME environment variable or place itmux in a standard location.');
+            throw new Error('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+                '  itmux not found - Windows tmux package required\n' +
+                '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n' +
+                '  Download: https://github.com/itefixnet/itmux/releases/latest\n' +
+                '  Latest:   https://github.com/itefixnet/itmux/releases/download/v1.1.0/itmux_1.1.0_x64_free.zip\n\n' +
+                '  Installation:\n' +
+                '    1. Download and extract itmux_1.1.0_x64_free.zip\n' +
+                '    2. Place in one of these locations:\n' +
+                '       • C:\\itmux\n' +
+                '       • %USERPROFILE%\\itmux\n' +
+                '       • Or set ITMUX_HOME environment variable\n\n' +
+                '  Quick install (PowerShell):\n' +
+                '    Invoke-WebRequest -Uri "https://github.com/itefixnet/itmux/releases/download/v1.1.0/itmux_1.1.0_x64_free.zip" -OutFile "$env:TEMP\\itmux.zip"\n' +
+                '    Expand-Archive -Path "$env:TEMP\\itmux.zip" -DestinationPath "C:\\itmux" -Force\n\n' +
+                '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
         }
         return new WindowsTmuxExecutor(itmuxPath);
     }

package/dist/agent/tmux.d.ts

@@ -35,3 +35,11 @@ export declare function isAvailable(): boolean;
  * Get tmux version
  */
 export declare function getVersion(): string | null;
+/**
+ * Get the active pane ID in a session
+ */
+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;

package/dist/agent/tmux.js

@@ -9,6 +9,8 @@ exports.createSession = createSession;
 exports.killSession = killSession;
 exports.isAvailable = isAvailable;
 exports.getVersion = getVersion;
+exports.getActivePane = getActivePane;
+exports.getPaneCwd = getPaneCwd;
 const tmux_executor_1 = require("./tmux-executor");
 // Lazy-initialized executor (created on first use)
 let executor = null;
@@ -131,3 +133,15 @@ function getVersion() {
         return null;
     }
 }
+/**
+ * Get the active pane ID in a session
+ */
+function getActivePane(sessionName) {
+    return getExecutor().getActivePane(sessionName);
+}
+/**
+ * Get the current working directory of a pane
+ */
+function getPaneCwd(sessionName, paneId) {
+    return getExecutor().getPaneCwd(sessionName, paneId);
+}

package/dist/agent/websocket.d.ts

@@ -26,13 +26,27 @@ 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;
-    sendFileView(filePath: string, content: string, language: string, error?: string): 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;
+    /**
+     * Send upload complete notification to web viewer
+     */
+    sendUploadComplete(filename: string, path: string): boolean;
+    /**
+     * Send upload error notification to web viewer
+     */
+    sendUploadError(filename: string, error: string): boolean;
     getConnected(): boolean;
     destroy(): void;
 }