sessioncast-cli 1.1.5 → 2.0.1

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

@@ -11,15 +11,45 @@ export declare class TmuxSessionHandler {
     private wsClient;
     private onCreateSession?;
     private running;
-    private lastScreen;
+    private lastScreens;
+    private lastPaneLayoutJson;
     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;
@@ -69,10 +49,14 @@ 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;
+        // 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}`;
@@ -100,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}`);
@@ -125,33 +111,181 @@ 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 (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 (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 {
+            // 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, meta) {
+        const target = meta?.pane ? `${this.tmuxSession}.${meta.pane}` : this.tmuxSession;
+        tmux.sendKeys(target, keys, false);
+    }
     startScreenCapture() {
         if (this.captureTimer)
             return;
@@ -162,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;
-                        }
-                        // 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);
+                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);
                         }
-                        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;
@@ -12,13 +22,25 @@ 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.
  */
 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;
@@ -26,6 +48,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;
 }
 /**
@@ -37,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;
@@ -45,6 +79,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

@@ -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
@@ -143,6 +165,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, '\\`');
     }
@@ -198,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;
@@ -289,6 +361,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 +435,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

@@ -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
  */
@@ -35,3 +39,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

@@ -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;
@@ -9,6 +10,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;
@@ -47,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
@@ -131,3 +140,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/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

@@ -26,13 +26,43 @@ 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;
+    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
+     * @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;
 }

package/dist/agent/websocket.js

@@ -40,7 +40,6 @@ 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;
@@ -71,8 +70,8 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                 this.isConnected = true;
                 this.reconnectAttempts = 0;
                 this.circuitBreakerOpen = false;
-                this.emit('connected');
                 this.registerAsHost();
+                this.emit('connected');
             });
             this.ws.on('message', (data) => {
                 try {
@@ -117,14 +116,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) {
-                    this.emit('keys', message.payload);
+                    this.emit('keys', message.payload, message.meta);
                 }
                 break;
             case 'resize':
@@ -147,17 +142,20 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                 }
                 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);
+                if (message.session === this.sessionId && message.payload && message.meta) {
+                    this.emit('uploadFile', {
+                        filename: message.meta.filename,
+                        size: parseInt(message.meta.size || '0', 10),
+                        mimeType: message.meta.mimeType,
+                        chunkIndex: parseInt(message.meta.chunkIndex || '0', 10),
+                        totalChunks: parseInt(message.meta.totalChunks || '1', 10),
+                        payload: message.payload
+                    });
                 }
                 break;
             case 'error':
@@ -167,55 +165,6 @@ 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)
@@ -290,47 +239,99 @@ 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);
         }
     }
-    sendFileView(filePath, content, language, error) {
+    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
+     * @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) {
         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: meta,
-            payload: Buffer.from(content).toString('base64')
+            meta: {
+                filename,
+                contentType,
+                path: path || ''
+            },
+            payload: content
+        });
+    }
+    /**
+     * Send upload complete notification to web viewer
+     */
+    sendUploadComplete(filename, path) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'uploadComplete',
+            session: this.sessionId,
+            meta: {
+                filename,
+                path,
+                success: 'true'
+            }
+        });
+    }
+    /**
+     * Send upload error notification to web viewer
+     */
+    sendUploadError(filename, error) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'uploadError',
+            session: this.sessionId,
+            meta: {
+                filename,
+                error
+            }
         });
     }
     getConnected() {

package/dist/api.js

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

package/dist/commands/login.js

@@ -69,11 +69,11 @@ async function manualLogin(apiKey, options) {
     }
     if (apiKey.startsWith('agt_')) {
         (0, config_1.setAgentToken)(apiKey);
-        console.log(chalk_1.default.green('✓ Agent token saved!'));
+        console.log(chalk_1.default.green('\u2713 Agent token saved!'));
     }
     else {
         (0, config_1.setApiKey)(apiKey);
-        console.log(chalk_1.default.green('✓ API key saved!'));
+        console.log(chalk_1.default.green('\u2713 API key saved!'));
     }
 }
 async function browserLogin(options = {}) {
@@ -197,15 +197,9 @@ async function browserLogin(options = {}) {
             (0, config_1.setMachineId)(agentData.machineId || os.hostname());
         }
         spinner.succeed('Login successful!');
-        console.log(chalk_1.default.green('\n✓ You are now logged in to SessionCast\n'));
-        console.log(chalk_1.default.gray('  Start the agent:'));
-        console.log(chalk_1.default.white('    sessioncast agent\n'));
-        console.log(chalk_1.default.gray('  Run in background:'));
-        console.log(chalk_1.default.white('    nohup sessioncast agent > agent.log 2>&1 &\n'));
-        console.log(chalk_1.default.gray('  Check logs:'));
-        console.log(chalk_1.default.white('    tail -f agent.log\n'));
-        await checkForUpdates();
-        process.exit(0);
+        console.log(chalk_1.default.green('\n\u2713 You are now logged in to SessionCast\n'));
+        console.log(chalk_1.default.gray('  Run `sessioncast agent` to start the agent'));
+        console.log(chalk_1.default.gray('  Run `sessioncast status` to check your login status\n'));
     }
     catch (err) {
         spinner.fail(`Login failed: ${err.message}`);
@@ -218,12 +212,12 @@ async function logout() {
         return;
     }
     (0, config_1.clearAuth)();
-    console.log(chalk_1.default.green('✓ Logged out successfully!'));
+    console.log(chalk_1.default.green('\u2713 Logged out successfully!'));
 }
 function status() {
     const accessToken = (0, config_1.getAccessToken)();
     if ((0, config_1.isLoggedIn)()) {
-        console.log(chalk_1.default.green('✓ Logged in'));
+        console.log(chalk_1.default.green('\u2713 Logged in'));
         if (accessToken) {
             console.log(chalk_1.default.gray('  Auth method: OAuth'));
         }
@@ -236,19 +230,3 @@ function status() {
         console.log(chalk_1.default.gray('Run: sessioncast login'));
     }
 }
-const CURRENT_VERSION = require('../../package.json').version;
-async function checkForUpdates() {
-    try {
-        const res = await (0, node_fetch_1.default)('https://registry.npmjs.org/sessioncast-cli/latest', { timeout: 3000 });
-        if (!res.ok) return;
-        const data = await res.json();
-        const latest = data.version;
-        if (latest && latest !== CURRENT_VERSION) {
-            console.log(chalk_1.default.yellow(`  ⬆ Update available: ${CURRENT_VERSION} → ${latest}`));
-            console.log(chalk_1.default.white(`    npm install -g sessioncast-cli@latest\n`));
-        }
-    }
-    catch (_e) {
-        // silently ignore - network errors shouldn't block login
-    }
-}

package/dist/index.js

@@ -85,12 +85,12 @@ function showWelcome() {
         return;
     const { available, isWindows } = checkTmux();
     console.log('');
-    console.log(chalk_1.default.green.bold('✓ SessionCast CLI installed'));
+    console.log(chalk_1.default.green.bold('\u2713 SessionCast CLI installed'));
     console.log('');
     if (!available) {
-        console.log(chalk_1.default.yellow('⚠ tmux not found'));
+        console.log(chalk_1.default.yellow('\u26a0 tmux not found'));
         if (isWindows) {
-            console.log(chalk_1.default.gray('  Install itmux: https://github.com/phayte/itmux'));
+            console.log(chalk_1.default.gray('  Install itmux: https://github.com/itefixnet/itmux'));
             console.log(chalk_1.default.gray('  Or: choco install itmux'));
         }
         else if (os.platform() === 'darwin') {

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "sessioncast-cli",
-  "version": "1.1.5",
+  "version": "2.0.1",
   "description": "SessionCast CLI - Control your agents from anywhere",
   "main": "dist/index.js",
   "bin": {
-    "sessioncast": "dist/index.js"
+    "sessioncast": "./dist/index.js"
   },
   "scripts": {
     "build": "tsc",
     "dev": "ts-node src/index.ts",
     "start": "node dist/index.js",
-    "prepublishOnly": "echo 'skip build'"
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "sessioncast",

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 SessionCast
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.