sessioncast-cli 2.0.4 → 2.0.6

package/README.md

@@ -1,25 +1,11 @@
 # SessionCast CLI
 
-Node.js agent and CLI for [SessionCast](https://sessioncast.io) - a real-time terminal sharing platform.
+[![npm version](https://img.shields.io/npm/v/sessioncast-cli)](https://www.npmjs.com/package/sessioncast-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-## Features
-
-### Agent
-- **Auto-discovery**: Automatically detects and connects tmux sessions
-- **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
+Node.js agent and CLI for [SessionCast](https://sessioncast.io) — a real-time terminal sharing and AI agent orchestration platform.
 
-### CLI Commands
-- `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
-- `sessioncast list [agent]` - List tmux sessions
-- `sessioncast send <target> <keys>` - Send keys to a session
-- `sessioncast agent` - Start the agent
+**SessionCast enables any AI coding agent (Claude Code, Gemini CLI, Codex, Cursor, Aider) to control other agents across machines through tmux sessions.**
 
 ## Installation
 
@@ -27,15 +13,12 @@ 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)
+**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
+# Install 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
 
@@ -43,20 +26,21 @@ Expand-Archive -Path "$env:TEMP\itmux.zip" -DestinationPath "C:\itmux" -Force
 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)
+### 1. Login
 
-2. **Create config file** `~/.sessioncast.yml`:
+```bash
+# Browser-based OAuth (recommended)
+sessioncast login
+
+# Or with agent token
+sessioncast login agt_your_token_here
+```
+
+### 2. Configure the agent
+
+Create `~/.sessioncast.yml`:
 
 ```yaml
 machineId: my-machine
@@ -64,19 +48,168 @@ relay: wss://relay.sessioncast.io/ws
 token: agt_your_agent_token_here
 ```
 
-3. **Start the agent**:
+### 3. Start the agent
 
 ```bash
+# Background (recommended)
+nohup sessioncast agent > /tmp/sessioncast-agent.log 2>&1 &
+
+# Foreground (for debugging)
 sessioncast agent
 ```
 
-4. **View your sessions** at [app.sessioncast.io](https://app.sessioncast.io)
+### 4. View your sessions
+
+Open [app.sessioncast.io](https://app.sessioncast.io) to see your terminal sessions in real-time.
+
+## CLI Commands
+
+### Authentication
+
+```bash
+sessioncast login              # Browser-based OAuth login
+sessioncast login agt_xxx      # Login with agent token
+sessioncast login sk-xxx       # Login with API key
+sessioncast logout             # Clear stored credentials
+sessioncast status             # Check authentication status
+```
+
+### Session Discovery
+
+```bash
+sessioncast list               # List all sessions across machines
+sessioncast list dev-server    # Filter by machine name
+sessioncast agents             # List registered agents
+```
+
+Example output:
+```
+Sessions:
+
+AGENT                  SESSION      STATUS    TARGET
+dev-macbook            workspace    online    dev-macbook/workspace
+dev-macbook            worker1      online    dev-macbook/worker1
+staging-server         main         online    staging-server/main
+```
+
+### Send Keys
+
+Send keystrokes to any remote tmux session:
+
+```bash
+# Send a command (Enter is pressed automatically)
+sessioncast send workspace "npm run build"
+
+# Target a specific machine
+sessioncast send dev-macbook/workspace "git status"
+sessioncast send dev-macbook:workspace "git status"    # colon works too
+
+# Send without pressing Enter (for special keys)
+sessioncast send workspace "C-c" --no-enter            # Ctrl+C
+sessioncast send workspace "C-l" --no-enter            # Ctrl+L (clear)
+```
+
+### Agent
+
+```bash
+sessioncast agent                          # Start agent
+sessioncast agent -c /path/to/config.yml   # Custom config path
+```
+
+## AI Agent Orchestration
+
+SessionCast's key capability is enabling AI-to-AI orchestration. Any terminal-based AI agent can create tmux sessions, launch other AI agents, and send them tasks.
+
+### Launch an AI Worker
+
+```bash
+# Create a tmux session and launch an AI agent
+tmux new-session -d -s worker1
+sessioncast send worker1 "claude"          # or: gemini, codex, aider, cursor
+sleep 5
+
+# Send a task
+sessioncast send worker1 "Implement input validation for the signup form in src/validators/signup.ts"
+```
+
+### Supported AI Agents
+
+| Agent | Launch Command | Best For |
+|-------|---------------|----------|
+| Claude Code | `claude` | Multi-file tasks, architecture |
+| Gemini CLI | `gemini` | Code review, analysis |
+| OpenAI Codex | `codex` | Code generation, testing |
+| Cursor CLI | `cursor` | Interactive editing |
+| Aider | `aider` | Git-aware pair programming |
+| GitHub Copilot | `gh copilot` | GitHub-integrated tasks |
+
+### Dev → QA → Deploy Pipeline
+
+```bash
+# Setup sessions with different AI agents
+tmux new-session -d -s dev
+tmux new-session -d -s qa
+tmux new-session -d -s deploy
+sessioncast send dev "claude"
+sessioncast send qa "codex"
+sessioncast send deploy "gemini"
+sleep 10
+
+# Stage 1: Development
+sessioncast send dev "Implement GET /api/users/:id endpoint in src/routes/users.ts"
+
+# Stage 2: QA (after dev completes)
+sessioncast send qa "Run tests: npm test -- --grep 'user profile'. Report any failures."
+
+# Stage 3: Deploy (after QA passes)
+sessioncast send deploy "Deploy to staging: git pull && npm run build && pm2 restart api"
+```
+
+### Dev ↔ QA Feedback Loop
+
+```bash
+# QA finds issues → send back to dev
+sessioncast send dev "QA found: GET /api/users/:id returns 500 when user not found. Should return 404."
+
+# Dev fixes → QA re-tests
+sessioncast send qa "Re-run user profile tests: npm test src/__tests__/users.test.ts"
+```
+
+### Multi-Agent Fan-Out
+
+```bash
+# Parallel development across multiple areas
+tmux new-session -d -s frontend
+tmux new-session -d -s backend
+tmux new-session -d -s tests
+
+sessioncast send frontend "claude"
+sessioncast send backend "gemini"
+sessioncast send tests "codex"
+sleep 10
+
+sessioncast send frontend "Build Settings page at src/pages/Settings.tsx with theme toggle and language selector"
+sessioncast send backend "Create REST endpoints: GET/PUT /api/settings in src/routes/settings.ts"
+sessioncast send tests "Write integration tests for the settings API in src/__tests__/settings.test.ts"
+```
+
+### Cross-Machine Control
+
+```bash
+# Control agents on different servers
+sessioncast send dev-macbook/workspace "npm run build"
+sessioncast send staging-server/main "git pull && npm test"
+sessioncast send prod-server/deploy "pm2 reload api"
+```
+
+For more orchestration patterns (code review pipeline, incident response, monorepo development), see [docs/claude-to-claude.md](docs/claude-to-claude.md).
 
 ## Configuration
 
-Create `~/.sessioncast.yml` or `~/.tmux-remote.yml`:
+### Agent Config (`~/.sessioncast.yml`)
 
 ```yaml
+# Required
 machineId: my-machine
 relay: wss://relay.sessioncast.io/ws
 token: agt_your_agent_token_here
@@ -85,79 +218,110 @@ token: agt_your_agent_token_here
 api:
   enabled: true
   agentId: "your-agent-uuid"
-
   exec:
     enabled: true
     shell: /bin/bash
     workingDir: /home/user
     defaultTimeout: 30000
-
   llm:
     enabled: false
 ```
 
 ### Environment Variables
 
-- `SESSIONCAST_CONFIG` - Custom config file path
-- `TMUX_REMOTE_CONFIG` - Alternative config file path
+| Variable | Description |
+|----------|-------------|
+| `SESSIONCAST_CONFIG` | Custom config file path |
+| `TMUX_REMOTE_CONFIG` | Alternative config file path |
 
-## Usage
+### CLI Config
 
-### Start the Agent
+After `sessioncast login`, credentials are stored automatically in the system config directory (`~/.config/sessioncast/`). No manual config needed for `send`, `list`, and other CLI commands.
 
-```bash
-# Run agent (foreground)
-sessioncast agent
+## Features
 
-# Run agent (background)
-nohup sessioncast agent > /tmp/sessioncast-agent.log 2>&1 &
-```
+### Agent Capabilities
+- **Auto-discovery**: Detects and connects all tmux sessions automatically
+- **Real-time streaming**: Captures terminal output with gzip compression
+- **Multi-pane support**: Detects tmux panes and streams each independently
+- **File viewer**: Cmd+Click on file paths to view files in browser
+- **Circuit breaker**: Prevents reconnection storms with exponential backoff (max 5 retries, 30s max delay, 2min cooldown)
 
-### Send Keys to Session
+### Web Viewer (app.sessioncast.io)
+- Real-time terminal rendering with xterm.js
+- Multi-pane layout view
+- Interactive keyboard input
+- File viewer panel
+- Session sharing via links
+- Dark/light theme
 
-```bash
-# Send text to a session
-sessioncast send my-machine/dev "ls -la"
+## Architecture
 
-# Send special keys
-sessioncast send my-machine/dev "Enter"
+```
+┌──────────────┐     WebSocket      ┌──────────────┐     WebSocket     ┌──────────────┐
+│    Agent      │ ◄────────────────► │    Relay      │ ◄───────────────► │   Viewer     │
+│  (sessioncast │   screen/keys     │ (relay.       │   screen/keys    │  (app.       │
+│   agent)      │   paneLayout      │  sessioncast  │   paneLayout     │  sessioncast  │
+│               │                   │  .io)         │                  │  .io)         │
+└──────┬───────┘                    └──────────────┘                   └──────────────┘
+       │
+       │ tmux capture-pane / send-keys
+       ▼
+┌──────────────┐
+│  tmux        │
+│  sessions    │
+│  (AI agents) │
+└──────────────┘
 ```
 
-## Architecture
+**Message flow:**
+1. Agent captures tmux screen → sends `screen`/`screenGz` via WebSocket
+2. Relay forwards to all connected viewers
+3. Viewer sends `keys` → Relay forwards to agent → Agent runs `tmux send-keys`
+4. For multi-pane: Agent sends `paneLayout` + per-pane `screen` with `meta.pane`
 
-```
-┌─────────────┐     WebSocket      ┌─────────────┐     WebSocket     ┌─────────────┐
-│   Agent     │ ◄─────────────────► │   Relay     │ ◄────────────────► │   Viewer    │
-│  (Node.js)  │    screen/keys     │  (Server)   │    screen/keys    │   (Web)     │
-└─────────────┘                    └─────────────┘                   └─────────────┘
-      │
-      │ tmux
-      ▼
-┌─────────────┐
-│   tmux      │
-│  sessions   │
-└─────────────┘
+## Troubleshooting
+
+### Session not found
+```bash
+# Verify available sessions
+sessioncast list
+
+# Use the exact target from the TARGET column
+sessioncast send my-machine/worker1 "hello"
 ```
 
-## Circuit Breaker
+### Agent not connecting
+```bash
+# Check tmux is running
+tmux ls
 
-The agent implements a circuit breaker pattern to prevent reconnection storms:
+# Check agent logs
+tail -f /tmp/sessioncast-agent.log
 
-- **Max reconnect attempts**: 5
-- **Base delay**: 1 second
-- **Max delay**: 30 seconds (with exponential backoff + jitter)
-- **Circuit breaker duration**: 2 minutes cooldown after max attempts
+# Restart agent
+pkill -f "sessioncast agent"
+nohup sessioncast agent > /tmp/sessioncast-agent.log 2>&1 &
+```
 
-## Requirements
+### Authentication issues
+```bash
+# Re-login
+sessioncast logout
+sessioncast login
 
-- Node.js >= 18
-- tmux installed on the host machine
+# Verify
+sessioncast status
+```
 
 ## License
 
 MIT License - see [LICENSE](LICENSE) for details.
 
-## Support
+## Links
 
-- Homepage: https://sessioncast.io
-- Email: devload@sessioncast.io
+- **Homepage**: [sessioncast.io](https://sessioncast.io)
+- **Web App**: [app.sessioncast.io](https://app.sessioncast.io)
+- **npm**: [sessioncast-cli](https://www.npmjs.com/package/sessioncast-cli)
+- **GitHub**: [sessioncast/sessioncast-cli](https://github.com/sessioncast/sessioncast-cli)
+- **Email**: devload@sessioncast.io

package/dist/agent/session-handler.js

@@ -96,9 +96,19 @@ class TmuxSessionHandler {
         this.wsClient.on('keys', (keys, paneId) => {
             this.handleKeys(keys, paneId);
         });
-        this.wsClient.on('resize', ({ cols, rows }) => {
-            console.log(`[${this.tmuxSession}] Resize: ${cols}x${rows}`);
-            tmux.resizeWindow(this.tmuxSession, cols, rows);
+        this.wsClient.on('resize', ({ cols, rows, pane }) => {
+            if (cols < 10 || rows < 4) {
+                console.log(`[${this.tmuxSession}] Ignoring resize with too-small dimensions: ${cols}x${rows}`);
+                return;
+            }
+            if (pane) {
+                console.log(`[${this.tmuxSession}] Resize pane ${pane}: ${cols}x${rows}`);
+                tmux.resizePane(pane, cols, rows);
+            }
+            else {
+                console.log(`[${this.tmuxSession}] Resize: ${cols}x${rows}`);
+                tmux.resizeWindow(this.tmuxSession, cols, rows);
+            }
         });
         this.wsClient.on('createSession', (name) => {
             console.log(`[${this.tmuxSession}] Create session request: ${name}`);

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

@@ -20,6 +20,7 @@ export interface TmuxExecutor {
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
+    resizePane(paneId: string, cols: number, rows: number): boolean;
     killSession(session: string): boolean;
     createSession(session: string, workingDir?: string): boolean;
     isAvailable(): boolean;
@@ -38,6 +39,7 @@ export declare class UnixTmuxExecutor implements TmuxExecutor {
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
+    resizePane(paneId: string, cols: number, rows: number): boolean;
     killSession(session: string): boolean;
     createSession(session: string, workingDir?: string): boolean;
     isAvailable(): boolean;
@@ -61,6 +63,7 @@ export declare class WindowsTmuxExecutor implements TmuxExecutor {
     sendKeys(session: string, keys: string): boolean;
     sendSpecialKey(session: string, key: string): boolean;
     resizeWindow(session: string, cols: number, rows: number): boolean;
+    resizePane(paneId: string, cols: number, rows: number): boolean;
     killSession(session: string): boolean;
     createSession(session: string, workingDir?: string): boolean;
     isAvailable(): boolean;

package/dist/agent/tmux-executor.js

@@ -130,6 +130,15 @@ class UnixTmuxExecutor {
             return false;
         }
     }
+    resizePane(paneId, cols, rows) {
+        try {
+            (0, child_process_1.execSync)(`tmux resize-pane -t "${paneId}" -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' });
@@ -326,6 +335,16 @@ class WindowsTmuxExecutor {
             return false;
         }
     }
+    resizePane(paneId, cols, rows) {
+        try {
+            const escaped = this.escapeSession(paneId);
+            this.executeCommand(`tmux resize-pane -t '${escaped}' -x ${cols} -y ${rows}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     killSession(session) {
         try {
             const escaped = this.escapeSession(session);

package/dist/agent/tmux.d.ts

@@ -20,6 +20,10 @@ export declare function sendKeys(target: string, keys: string, enter?: boolean):
  * Resize tmux window
  */
 export declare function resizeWindow(sessionName: string, cols: number, rows: number): boolean;
+/**
+ * Resize a specific tmux pane by its ID (e.g., %0, %1)
+ */
+export declare function resizePane(paneId: string, cols: number, rows: number): boolean;
 /**
  * Create new tmux session
  */

package/dist/agent/tmux.js

@@ -5,6 +5,7 @@ exports.listSessions = listSessions;
 exports.capturePane = capturePane;
 exports.sendKeys = sendKeys;
 exports.resizeWindow = resizeWindow;
+exports.resizePane = resizePane;
 exports.createSession = createSession;
 exports.killSession = killSession;
 exports.isAvailable = isAvailable;
@@ -101,6 +102,12 @@ function sendKeys(target, keys, enter = true) {
 function resizeWindow(sessionName, cols, rows) {
     return getExecutor().resizeWindow(sessionName, cols, rows);
 }
+/**
+ * Resize a specific tmux pane by its ID (e.g., %0, %1)
+ */
+function resizePane(paneId, cols, rows) {
+    return getExecutor().resizePane(paneId, cols, rows);
+}
 /**
  * Create new tmux session
  */

package/dist/agent/websocket.js

@@ -127,7 +127,7 @@ class RelayWebSocketClient extends events_1.EventEmitter {
                     const cols = parseInt(message.meta.cols, 10);
                     const rows = parseInt(message.meta.rows, 10);
                     if (!isNaN(cols) && !isNaN(rows)) {
-                        this.emit('resize', { cols, rows });
+                        this.emit('resize', { cols, rows, pane: message.meta.pane });
                     }
                 }
                 break;

package/dist/api.js

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

package/dist/commands/sendkeys.js

@@ -6,56 +6,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendKeys = sendKeys;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
-const api_1 = require("../api");
+const ws_1 = __importDefault(require("ws"));
 const config_1 = require("../config");
 async function sendKeys(target, keys, options) {
     if (!(0, config_1.isLoggedIn)()) {
-        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login <api-key>'));
+        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login'));
         process.exit(1);
     }
-    // Parse target: "agent:session" or "agent:session:window"
-    const parts = target.split(':');
-    if (parts.length < 2) {
-        console.log(chalk_1.default.red('Invalid target format.'));
-        console.log(chalk_1.default.gray('Expected: <agent>:<session> or <agent>:<session>:<window>'));
-        console.log(chalk_1.default.gray('Example: macbook:dev or server:main:0'));
+    // Parse target: "session" or "machineId/session"
+    // Accept both "machineId/session" and "machineId:session" formats
+    const normalizedTarget = target.replace(':', '/');
+    const token = (0, config_1.getAccessToken)() || (0, config_1.getAgentToken)() || (0, config_1.getApiKey)();
+    if (!token) {
+        console.log(chalk_1.default.red('No auth token found. Run: sessioncast login'));
         process.exit(1);
     }
-    const agentName = parts[0];
-    const sessionTarget = parts.slice(1).join(':'); // session:window or just session
-    const spinner = (0, ora_1.default)('Finding agent...').start();
+    const relayUrl = (0, config_1.getRelayUrl)();
+    const spinner = (0, ora_1.default)('Connecting to relay...').start();
     try {
-        // Find agent by name/label/machineId
-        const agent = await api_1.api.findAgentByName(agentName);
-        if (!agent) {
-            spinner.stop();
-            console.log(chalk_1.default.red(`Agent not found: ${agentName}`));
-            console.log(chalk_1.default.gray('Run: sessioncast agents'));
-            process.exit(1);
-        }
-        if (!agent.isActive) {
-            spinner.stop();
-            console.log(chalk_1.default.red(`Agent is offline: ${agentName}`));
-            process.exit(1);
-        }
-        if (!agent.apiEnabled) {
-            spinner.stop();
-            console.log(chalk_1.default.red(`API is not enabled for agent: ${agentName}`));
-            console.log(chalk_1.default.gray('Enable API in agent settings at https://account.sessioncast.io'));
-            process.exit(1);
-        }
-        spinner.text = 'Sending keys...';
-        const result = await api_1.api.sendKeys(agent.id, sessionTarget, keys, !options.noEnter);
+        const sessionId = await sendKeysViaRelay(relayUrl, token, normalizedTarget, keys, !options.noEnter, spinner);
         spinner.stop();
-        if (result.success) {
-            console.log(chalk_1.default.green(`✓ Keys sent to ${target}`));
-            if (!options.noEnter) {
-                console.log(chalk_1.default.gray('(Enter key was pressed)'));
-            }
-        }
-        else {
-            console.log(chalk_1.default.red(`Failed to send keys: ${result.error || 'Unknown error'}`));
-            process.exit(1);
+        console.log(chalk_1.default.green(`✓ Keys sent to ${sessionId}`));
+        if (!options.noEnter) {
+            console.log(chalk_1.default.gray('(Enter key was pressed)'));
         }
     }
     catch (error) {
@@ -64,3 +37,114 @@ async function sendKeys(target, keys, options) {
         process.exit(1);
     }
 }
+function sendKeysViaRelay(relayUrl, token, target, keys, enter, spinner) {
+    return new Promise((resolve, reject) => {
+        const wsUrl = `${relayUrl}?token=${encodeURIComponent(token)}`;
+        const ws = new ws_1.default(wsUrl);
+        let resolved = false;
+        let sessionList = [];
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                ws.close();
+                reject(new Error('Timeout waiting for relay response'));
+            }
+        }, 10000);
+        ws.on('open', () => {
+            // Request session list to find the target
+            ws.send(JSON.stringify({ type: 'listSessions' }));
+        });
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (message.type === 'sessionList' && message.sessions) {
+                    sessionList = message.sessions;
+                    spinner.text = `Found ${sessionList.length} sessions, finding target...`;
+                    // Find matching session
+                    const matched = findSession(sessionList, target);
+                    if (!matched) {
+                        clearTimeout(timeout);
+                        resolved = true;
+                        ws.close();
+                        const available = sessionList.map(s => `  ${s.id} (${s.label || 'no label'}) [${s.status}]`).join('\n');
+                        reject(new Error(`Session not found: ${target}\n\nAvailable sessions:\n${available || '  (none)'}`));
+                        return;
+                    }
+                    if (matched.status !== 'online') {
+                        clearTimeout(timeout);
+                        resolved = true;
+                        ws.close();
+                        reject(new Error(`Session is offline: ${matched.id}`));
+                        return;
+                    }
+                    // Register as viewer first
+                    ws.send(JSON.stringify({
+                        type: 'register',
+                        role: 'viewer',
+                        session: matched.id,
+                    }));
+                    // Send keys
+                    const payload = enter ? keys + '\n' : keys;
+                    ws.send(JSON.stringify({
+                        type: 'keys',
+                        session: matched.id,
+                        payload,
+                    }));
+                    // Small delay to ensure delivery, then close
+                    setTimeout(() => {
+                        if (!resolved) {
+                            clearTimeout(timeout);
+                            resolved = true;
+                            ws.close();
+                            resolve(matched.id);
+                        }
+                    }, 300);
+                }
+            }
+            catch {
+                // ignore parse errors
+            }
+        });
+        ws.on('error', (err) => {
+            if (!resolved) {
+                clearTimeout(timeout);
+                resolved = true;
+                reject(new Error(`WebSocket error: ${err.message}`));
+            }
+        });
+        ws.on('close', () => {
+            if (!resolved) {
+                clearTimeout(timeout);
+                resolved = true;
+                reject(new Error('Connection closed unexpectedly'));
+            }
+        });
+    });
+}
+function findSession(sessions, target) {
+    // Exact match on session id
+    const exact = sessions.find(s => s.id === target);
+    if (exact)
+        return exact;
+    // Match by label (session name part)
+    const byLabel = sessions.find(s => s.label === target);
+    if (byLabel)
+        return byLabel;
+    // Match by partial: "machineId/session" where target might be partial machineId
+    const parts = target.split('/');
+    if (parts.length >= 2) {
+        const [machineHint, ...sessionParts] = parts;
+        const sessionName = sessionParts.join('/');
+        const match = sessions.find(s => s.id.includes(machineHint) && s.id.endsWith('/' + sessionName));
+        if (match)
+            return match;
+    }
+    // Match just session name (last part of id after /)
+    const bySessionName = sessions.find(s => {
+        const name = s.id.split('/').pop();
+        return name === target;
+    });
+    if (bySessionName)
+        return bySessionName;
+    return null;
+}

package/dist/commands/sessions.js

@@ -6,75 +6,68 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.listSessions = listSessions;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
-const api_1 = require("../api");
+const ws_1 = __importDefault(require("ws"));
 const config_1 = require("../config");
 async function listSessions(agentName) {
     if (!(0, config_1.isLoggedIn)()) {
-        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login <api-key>'));
+        console.log(chalk_1.default.red('Not logged in. Run: sessioncast login'));
         process.exit(1);
     }
-    const spinner = (0, ora_1.default)('Fetching sessions...').start();
+    const token = (0, config_1.getAccessToken)() || (0, config_1.getAgentToken)() || (0, config_1.getApiKey)();
+    if (!token) {
+        console.log(chalk_1.default.red('No auth token found. Run: sessioncast login'));
+        process.exit(1);
+    }
+    const relayUrl = (0, config_1.getRelayUrl)();
+    const spinner = (0, ora_1.default)('Fetching sessions from relay...').start();
     try {
-        const agents = await api_1.api.listAgents();
-        const onlineAgents = agents.filter(a => a.isActive && a.apiEnabled);
-        if (onlineAgents.length === 0) {
-            spinner.stop();
-            console.log(chalk_1.default.yellow('No online agents with API enabled.'));
+        const sessions = await fetchSessionsFromRelay(relayUrl, token);
+        spinner.stop();
+        if (sessions.length === 0) {
+            console.log(chalk_1.default.yellow('No sessions found.'));
             return;
         }
+        // Group by machineId
+        const grouped = sessions.reduce((acc, s) => {
+            const machine = s.machineId || 'unknown';
+            if (!acc[machine])
+                acc[machine] = [];
+            acc[machine].push(s);
+            return acc;
+        }, {});
         // Filter by agent name if provided
-        let targetAgents = onlineAgents;
         if (agentName) {
-            const found = onlineAgents.find(a => a.label?.toLowerCase() === agentName.toLowerCase() ||
-                a.machineId?.toLowerCase() === agentName.toLowerCase() ||
-                a.id.startsWith(agentName));
-            if (!found) {
-                spinner.stop();
-                console.log(chalk_1.default.red(`Agent not found: ${agentName}`));
-                console.log(chalk_1.default.gray('Run: sessioncast agents'));
+            const matchedKey = Object.keys(grouped).find(k => k.toLowerCase().includes(agentName.toLowerCase()));
+            if (!matchedKey) {
+                console.log(chalk_1.default.red(`No agent matching: ${agentName}`));
+                console.log(chalk_1.default.gray('Available agents: ' + Object.keys(grouped).join(', ')));
                 process.exit(1);
             }
-            targetAgents = [found];
-        }
-        // Fetch sessions from all target agents
-        const allSessions = [];
-        for (const agent of targetAgents) {
-            try {
-                const sessions = await api_1.api.listSessions(agent.id);
-                allSessions.push({ agent, sessions });
-            }
-            catch (error) {
-                // Skip failed agents
-            }
+            const filtered = {};
+            filtered[matchedKey] = grouped[matchedKey];
+            Object.keys(grouped).forEach(k => { if (k !== matchedKey)
+                delete grouped[k]; });
+            Object.assign(grouped, filtered);
         }
-        spinner.stop();
-        if (allSessions.every(as => as.sessions.length === 0)) {
-            console.log(chalk_1.default.yellow('No tmux sessions found.'));
-            return;
-        }
-        console.log(chalk_1.default.bold('\nTmux Sessions:\n'));
-        // Table header
-        console.log(chalk_1.default.gray(padRight('AGENT', 16) +
-            padRight('SESSION', 16) +
-            padRight('WINDOWS', 10) +
-            padRight('ATTACHED', 10) +
+        console.log(chalk_1.default.bold('\nSessions:\n'));
+        console.log(chalk_1.default.gray(padRight('AGENT', 30) +
+            padRight('SESSION', 20) +
+            padRight('STATUS', 10) +
             'TARGET'));
-        console.log(chalk_1.default.gray('─'.repeat(70)));
-        // Table rows
-        for (const { agent, sessions } of allSessions) {
-            const agentName = agent.label || agent.machineId || agent.id.substring(0, 8);
-            for (const session of sessions) {
-                const attached = session.attached ? chalk_1.default.green('yes') : chalk_1.default.gray('no');
-                const target = `${agentName}:${session.name}`;
-                console.log(padRight(agentName, 16) +
-                    padRight(session.name, 16) +
-                    padRight(String(session.windows), 10) +
-                    padRight(attached, 10) +
+        console.log(chalk_1.default.gray('─'.repeat(80)));
+        for (const [machineId, machineSessions] of Object.entries(grouped)) {
+            for (const session of machineSessions) {
+                const label = session.label || session.id.split('/').pop() || session.id;
+                const statusColor = session.status === 'online' ? chalk_1.default.green : chalk_1.default.red;
+                const target = session.id;
+                console.log(padRight(machineId, 30) +
+                    padRight(label, 20) +
+                    padRight(statusColor(session.status), 10) +
                     chalk_1.default.cyan(target));
             }
         }
         console.log();
-        console.log(chalk_1.default.gray('Use: sessioncast send <target> "command"'));
+        console.log(chalk_1.default.gray('Use: sessioncast send <session-label> "command"'));
     }
     catch (error) {
         spinner.stop();
@@ -82,6 +75,39 @@ async function listSessions(agentName) {
         process.exit(1);
     }
 }
+function fetchSessionsFromRelay(relayUrl, token) {
+    return new Promise((resolve, reject) => {
+        const wsUrl = `${relayUrl}?token=${encodeURIComponent(token)}`;
+        const ws = new ws_1.default(wsUrl);
+        const timeout = setTimeout(() => {
+            ws.close();
+            reject(new Error('Timeout waiting for session list'));
+        }, 10000);
+        ws.on('open', () => {
+            ws.send(JSON.stringify({ type: 'listSessions' }));
+        });
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (message.type === 'sessionList' && message.sessions) {
+                    clearTimeout(timeout);
+                    ws.close();
+                    resolve(message.sessions);
+                }
+            }
+            catch {
+                // ignore
+            }
+        });
+        ws.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(new Error(`WebSocket error: ${err.message}`));
+        });
+        ws.on('close', () => {
+            clearTimeout(timeout);
+        });
+    });
+}
 function padRight(str, len) {
     const plainStr = str.replace(/\x1b\[[0-9;]*m/g, '');
     const padding = Math.max(0, len - plainStr.length);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sessioncast-cli",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "SessionCast CLI - Control your agents from anywhere",
   "main": "dist/index.js",
   "bin": {
@@ -17,10 +17,26 @@
     "tmux",
     "cli",
     "terminal",
-    "remote"
+    "remote",
+    "ai-agent",
+    "orchestration",
+    "claude",
+    "gemini",
+    "codex",
+    "websocket",
+    "screen-sharing",
+    "multi-pane"
   ],
   "author": "SessionCast",
   "license": "MIT",
+  "homepage": "https://sessioncast.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sessioncast/sessioncast-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sessioncast/sessioncast-cli/issues"
+  },
   "type": "commonjs",
   "files": [
     "dist"