sessioncast-cli 1.0.0 → 1.1.1

package/README.md

@@ -1,6 +1,6 @@
 # SessionCast CLI
 
-Node.js agent and CLI for [SessionCast](https://sessioncast.io) - a real-time terminal sharing platform.
+Node.js agent and CLI for SessionCast - a real-time terminal streaming platform.
 
 ## Features
 
@@ -9,7 +9,7 @@ Node.js agent and CLI for [SessionCast](https://sessioncast.io) - a real-time te
 - **Real-time screen capture**: Streams terminal output with gzip compression
 - **Circuit breaker**: Prevents reconnection storms with exponential backoff
 - **Interactive control**: Supports keyboard input, resize, and session management
-- **File viewer**: Cmd+Click on file paths to view files in browser
+- **API integration**: External command execution and LLM service support
 
 ### CLI Commands
 - `sessioncast login <api-key>` - Authenticate with API key
@@ -23,36 +23,27 @@ Node.js agent and CLI for [SessionCast](https://sessioncast.io) - a real-time te
 ## Installation
 
 ```bash
-npm install -g sessioncast-cli
-```
-
-## Quick Start
+# Clone the repository
+git clone git@github.com:your-org/sessioncast-cli.git
+cd sessioncast-cli
 
-1. **Get your agent token** from [app.sessioncast.io](https://app.sessioncast.io)
+# Install dependencies
+npm install
 
-2. **Create config file** `~/.sessioncast.yml`:
+# Build
+npm run build
 
-```yaml
-machineId: my-machine
-relay: wss://relay.sessioncast.io/ws
-token: agt_your_agent_token_here
+# Link globally (optional)
+npm link
 ```
 
-3. **Start the agent**:
-
-```bash
-sessioncast agent
-```
-
-4. **View your sessions** at [app.sessioncast.io](https://app.sessioncast.io)
-
 ## Configuration
 
 Create `~/.sessioncast.yml` or `~/.tmux-remote.yml`:
 
 ```yaml
 machineId: my-machine
-relay: wss://relay.sessioncast.io/ws
+relay: wss://your-relay.sessioncast.io/ws
 token: agt_your_agent_token_here
 
 # Optional: API configuration
@@ -68,6 +59,9 @@ api:
 
   llm:
     enabled: false
+    provider: ollama
+    model: codellama
+    endpoint: http://localhost:11434
 ```
 
 ### Environment Variables
@@ -102,15 +96,56 @@ sessioncast send my-machine/dev "Enter"
 ```
 ┌─────────────┐     WebSocket      ┌─────────────┐     WebSocket     ┌─────────────┐
 │   Agent     │ ◄─────────────────► │   Relay     │ ◄────────────────► │   Viewer    │
-│  (Node.js)  │    screen/keys     │  (Server)   │    screen/keys    │   (Web)     │
+│  (Node.js)  │    screen/keys     │  (Spring)   │    screen/keys    │   (Web)     │
 └─────────────┘                    └─────────────┘                   └─────────────┘
-      │
-      │ tmux
-      ▼
-┌─────────────┐
-│   tmux      │
-│  sessions   │
-└─────────────┘
+      │                                   │
+      │ tmux                              │ DynamoDB
+      ▼                                   ▼
+┌─────────────┐                    ┌─────────────┐
+│   tmux      │                    │  Sessions   │
+│  sessions   │                    │  metadata   │
+└─────────────┘                    └─────────────┘
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript
+npm run build
+
+# Watch mode (if configured)
+npm run dev
+```
+
+## Project Structure
+
+```
+sessioncast-cli/
+├── src/
+│   ├── agent/
+│   │   ├── api-client.ts      # API WebSocket client
+│   │   ├── exec-service.ts    # Command execution service
+│   │   ├── llm-service.ts     # LLM integration (Ollama/OpenAI)
+│   │   ├── runner.ts          # Agent runner with auto-discovery
+│   │   ├── session-handler.ts # tmux session handler
+│   │   ├── tmux.ts            # tmux utilities
+│   │   ├── types.ts           # Type definitions
+│   │   └── websocket.ts       # WebSocket client with circuit breaker
+│   ├── commands/
+│   │   ├── agent.ts           # Agent command
+│   │   ├── agents.ts          # List agents command
+│   │   ├── login.ts           # Login command
+│   │   ├── sendkeys.ts        # Send keys command
+│   │   └── sessions.ts        # List sessions command
+│   ├── api.ts                 # API client
+│   ├── config.ts              # Configuration management
+│   └── index.ts               # CLI entry point
+├── package.json
+├── tsconfig.json
+└── README.md
 ```
 
 ## Circuit Breaker
@@ -122,16 +157,6 @@ The agent implements a circuit breaker pattern to prevent reconnection storms:
 - **Max delay**: 30 seconds (with exponential backoff + jitter)
 - **Circuit breaker duration**: 2 minutes cooldown after max attempts
 
-## Requirements
-
-- Node.js >= 18
-- tmux installed on the host machine
-
 ## License
 
-MIT License - see [LICENSE](LICENSE) for details.
-
-## Support
-
-- Homepage: https://sessioncast.io
-- Email: devload@sessioncast.io
+Private - All rights reserved.

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

@@ -19,6 +19,7 @@ export declare class TmuxSessionHandler {
     start(): void;
     private connectAndRun;
     private handleKeys;
+    private handleFileViewRequest;
     private startScreenCapture;
     private stopScreenCapture;
     stop(): void;

package/dist/agent/session-handler.js

@@ -36,6 +36,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TmuxSessionHandler = void 0;
 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;
@@ -102,6 +124,10 @@ class TmuxSessionHandler {
             tmux.killSession(this.tmuxSession);
             this.stop();
         });
+        this.wsClient.on('requestFileView', (filePath) => {
+            console.log(`[${this.tmuxSession}] File view request: ${filePath}`);
+            this.handleFileViewRequest(filePath);
+        });
         this.wsClient.on('error', (error) => {
             console.error(`[${this.tmuxSession}] WebSocket error:`, error.message);
         });
@@ -110,6 +136,22 @@ class TmuxSessionHandler {
     handleKeys(keys) {
         tmux.sendKeys(this.tmuxSession, keys, false);
     }
+    handleFileViewRequest(filePath) {
+        if (!this.wsClient)
+            return;
+        const realPath = expandPath(filePath);
+        const language = getLanguage(filePath);
+        try {
+            const content = fs.readFileSync(realPath, 'utf-8');
+            console.log(`[${this.tmuxSession}] File read: ${content.length} bytes`);
+            this.wsClient.sendFileView(filePath, content, language);
+        }
+        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);
+        }
+    }
     startScreenCapture() {
         if (this.captureTimer)
             return;

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

@@ -0,0 +1,66 @@
+/**
+ * Interface for tmux operations.
+ * Implementations handle platform-specific differences (Unix vs Windows/itmux).
+ */
+export interface TmuxExecutor {
+    listSessions(): string[];
+    capturePane(session: string): string | null;
+    sendKeys(session: string, keys: string): boolean;
+    sendSpecialKey(session: string, key: string): boolean;
+    resizeWindow(session: string, cols: number, rows: number): boolean;
+    killSession(session: string): boolean;
+    createSession(session: string, workingDir?: string): boolean;
+    isAvailable(): boolean;
+    getVersion(): string | null;
+}
+/**
+ * Unix/Linux/macOS implementation of TmuxExecutor.
+ */
+export declare class UnixTmuxExecutor implements TmuxExecutor {
+    listSessions(): string[];
+    capturePane(session: string): string | null;
+    sendKeys(session: string, keys: string): boolean;
+    sendSpecialKey(session: string, key: string): boolean;
+    resizeWindow(session: string, cols: number, rows: number): boolean;
+    killSession(session: string): boolean;
+    createSession(session: string, workingDir?: string): boolean;
+    isAvailable(): boolean;
+    getVersion(): string | null;
+    private escapeForShell;
+}
+/**
+ * Windows implementation of TmuxExecutor using itmux (Cygwin + tmux bundle).
+ */
+export declare class WindowsTmuxExecutor implements TmuxExecutor {
+    private itmuxPath;
+    private bashPath;
+    constructor(itmuxPath: string);
+    private executeCommand;
+    listSessions(): string[];
+    capturePane(session: string): string | null;
+    sendKeys(session: string, keys: string): boolean;
+    sendSpecialKey(session: string, key: string): boolean;
+    resizeWindow(session: string, cols: number, rows: number): boolean;
+    killSession(session: string): boolean;
+    createSession(session: string, workingDir?: string): boolean;
+    isAvailable(): boolean;
+    getVersion(): string | null;
+    private escapeSession;
+    private windowsToCygwinPath;
+    /**
+     * Find itmux installation path on Windows.
+     */
+    static findItmuxPath(): string | null;
+}
+/**
+ * Get the appropriate TmuxExecutor for the current platform.
+ */
+export declare function createTmuxExecutor(): TmuxExecutor;
+/**
+ * Check if the current platform is Windows.
+ */
+export declare function isWindows(): boolean;
+/**
+ * Get platform name for logging.
+ */
+export declare function getPlatformName(): string;

package/dist/agent/tmux-executor.js

@@ -0,0 +1,368 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsTmuxExecutor = exports.UnixTmuxExecutor = void 0;
+exports.createTmuxExecutor = createTmuxExecutor;
+exports.isWindows = isWindows;
+exports.getPlatformName = getPlatformName;
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * Unix/Linux/macOS implementation of TmuxExecutor.
+ */
+class UnixTmuxExecutor {
+    listSessions() {
+        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 {
+            return [];
+        }
+    }
+    capturePane(session) {
+        try {
+            const output = (0, child_process_1.execSync)(`tmux capture-pane -t "${session}" -p -e -N`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                maxBuffer: 10 * 1024 * 1024
+            });
+            return output.replace(/\n/g, '\r\n');
+        }
+        catch {
+            return null;
+        }
+    }
+    sendKeys(session, keys) {
+        try {
+            const escaped = this.escapeForShell(keys);
+            (0, child_process_1.execSync)(`tmux send-keys -t "${session}" -l "${escaped}"`, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    sendSpecialKey(session, key) {
+        try {
+            (0, child_process_1.execSync)(`tmux send-keys -t "${session}" ${key}`, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    resizeWindow(session, cols, rows) {
+        try {
+            (0, child_process_1.execSync)(`tmux resize-window -t "${session}" -x ${cols} -y ${rows}`, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    killSession(session) {
+        try {
+            (0, child_process_1.execSync)(`tmux kill-session -t "${session}"`, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    createSession(session, workingDir) {
+        try {
+            const sanitized = session.replace(/[^a-zA-Z0-9_-]/g, '_');
+            if (!sanitized)
+                return false;
+            let cmd = `tmux new-session -d -s "${sanitized}"`;
+            if (workingDir) {
+                cmd += ` -c "${workingDir}"`;
+            }
+            (0, child_process_1.execSync)(cmd, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    isAvailable() {
+        try {
+            (0, child_process_1.execSync)('which tmux', { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getVersion() {
+        try {
+            return (0, child_process_1.execSync)('tmux -V', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    escapeForShell(str) {
+        return str.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
+    }
+}
+exports.UnixTmuxExecutor = UnixTmuxExecutor;
+/**
+ * Windows implementation of TmuxExecutor using itmux (Cygwin + tmux bundle).
+ */
+class WindowsTmuxExecutor {
+    constructor(itmuxPath) {
+        this.itmuxPath = itmuxPath;
+        this.bashPath = path.join(itmuxPath, 'bin', 'bash.exe');
+        if (!fs.existsSync(this.bashPath)) {
+            throw new Error(`itmux bash not found at: ${this.bashPath}`);
+        }
+        console.log(`[Windows] Using itmux at: ${itmuxPath}`);
+    }
+    executeCommand(command) {
+        try {
+            const result = (0, child_process_1.spawnSync)(this.bashPath, ['-l', '-c', command], {
+                encoding: 'utf-8',
+                cwd: this.itmuxPath,
+                env: {
+                    ...process.env,
+                    CYGWIN: 'nodosfilewarning',
+                    HOME: `/home/${os.userInfo().username}`,
+                    TERM: 'xterm-256color'
+                },
+                maxBuffer: 10 * 1024 * 1024
+            });
+            if (result.stderr) {
+                // Log but don't fail on stderr (tmux often outputs to stderr)
+                console.debug(`[itmux stderr] ${result.stderr}`);
+            }
+            return result.stdout?.trim() || '';
+        }
+        catch (error) {
+            console.error(`[itmux] Command failed: ${command}`, error);
+            return '';
+        }
+    }
+    listSessions() {
+        try {
+            const output = this.executeCommand("tmux ls -F '#{session_name}' 2>/dev/null || true");
+            if (!output)
+                return [];
+            return output
+                .split('\n')
+                .map(s => s.trim())
+                .filter(s => s.length > 0 && !s.startsWith('no server') && !s.includes('error'));
+        }
+        catch {
+            return [];
+        }
+    }
+    capturePane(session) {
+        try {
+            const escaped = this.escapeSession(session);
+            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;
+        }
+    }
+    sendKeys(session, keys) {
+        try {
+            const escapedSession = this.escapeSession(session);
+            const escapedKeys = keys.replace(/'/g, "'\\''");
+            this.executeCommand(`tmux send-keys -t '${escapedSession}' -l '${escapedKeys}'`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    sendSpecialKey(session, key) {
+        try {
+            const escaped = this.escapeSession(session);
+            this.executeCommand(`tmux send-keys -t '${escaped}' ${key}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    resizeWindow(session, cols, rows) {
+        try {
+            const escaped = this.escapeSession(session);
+            this.executeCommand(`tmux resize-window -t '${escaped}' -x ${cols} -y ${rows}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    killSession(session) {
+        try {
+            const escaped = this.escapeSession(session);
+            this.executeCommand(`tmux kill-session -t '${escaped}'`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    createSession(session, workingDir) {
+        try {
+            const sanitized = session.replace(/[^a-zA-Z0-9_-]/g, '_');
+            if (!sanitized)
+                return false;
+            let cmd;
+            if (workingDir) {
+                const cygwinPath = this.windowsToCygwinPath(workingDir);
+                cmd = `tmux new-session -d -s '${sanitized}' -c '${cygwinPath}'`;
+            }
+            else {
+                cmd = `tmux new-session -d -s '${sanitized}'`;
+            }
+            this.executeCommand(cmd);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    isAvailable() {
+        try {
+            const version = this.getVersion();
+            return version !== null && version.includes('tmux');
+        }
+        catch {
+            return false;
+        }
+    }
+    getVersion() {
+        try {
+            const output = this.executeCommand('tmux -V');
+            return output || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    escapeSession(session) {
+        return session.replace(/'/g, "'\\''");
+    }
+    windowsToCygwinPath(windowsPath) {
+        if (!windowsPath)
+            return windowsPath;
+        // Handle UNC paths
+        if (windowsPath.startsWith('\\\\')) {
+            return windowsPath;
+        }
+        // Handle drive letters (C:\...)
+        if (windowsPath.length >= 2 && windowsPath[1] === ':') {
+            const drive = windowsPath[0].toLowerCase();
+            const rest = windowsPath.substring(2).replace(/\\/g, '/');
+            return `/cygdrive/${drive}${rest}`;
+        }
+        return windowsPath.replace(/\\/g, '/');
+    }
+    /**
+     * Find itmux installation path on Windows.
+     */
+    static findItmuxPath() {
+        // 1. Check environment variable
+        const envPath = process.env.ITMUX_HOME;
+        if (envPath && fs.existsSync(path.join(envPath, 'bin', 'bash.exe'))) {
+            return envPath;
+        }
+        // 2. Check common locations
+        const locations = [
+            path.join(os.homedir(), 'itmux'),
+            'C:\\itmux',
+            'D:\\itmux',
+            path.join(process.cwd(), 'itmux'),
+            path.join(process.env.LOCALAPPDATA || '', 'itmux'),
+            path.join(process.env.ProgramFiles || '', 'itmux'),
+        ];
+        for (const loc of locations) {
+            if (loc && fs.existsSync(path.join(loc, 'bin', 'bash.exe'))) {
+                return loc;
+            }
+        }
+        return null;
+    }
+}
+exports.WindowsTmuxExecutor = WindowsTmuxExecutor;
+/**
+ * Get the appropriate TmuxExecutor for the current platform.
+ */
+function createTmuxExecutor() {
+    const isWindows = os.platform() === 'win32';
+    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.');
+        }
+        return new WindowsTmuxExecutor(itmuxPath);
+    }
+    return new UnixTmuxExecutor();
+}
+/**
+ * Check if the current platform is Windows.
+ */
+function isWindows() {
+    return os.platform() === 'win32';
+}
+/**
+ * Get platform name for logging.
+ */
+function getPlatformName() {
+    const platform = os.platform();
+    if (platform === 'win32')
+        return 'Windows';
+    if (platform === 'darwin')
+        return 'macOS';
+    return 'Linux/Unix';
+}

package/dist/agent/tmux.d.ts

@@ -22,8 +22,16 @@ export declare function resizeWindow(sessionName: string, cols: number, rows: nu
 /**
  * Create new tmux session
  */
-export declare function createSession(sessionName: string): boolean;
+export declare function createSession(sessionName: string, workingDir?: string): boolean;
 /**
  * Kill tmux session
  */
 export declare function killSession(sessionName: string): boolean;
+/**
+ * Check if tmux is available
+ */
+export declare function isAvailable(): boolean;
+/**
+ * Get tmux version
+ */
+export declare function getVersion(): string | null;