sessioncast-cli 1.0.0

package/dist/agent/tmux.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSessions = scanSessions;
+exports.listSessions = listSessions;
+exports.capturePane = capturePane;
+exports.sendKeys = sendKeys;
+exports.resizeWindow = resizeWindow;
+exports.createSession = createSession;
+exports.killSession = killSession;
+const child_process_1 = require("child_process");
+/**
+ * Scan for all tmux sessions
+ */
+function scanSessions() {
+    try {
+        const output = (0, child_process_1.execSync)('tmux ls -F "#{session_name}"', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        return output
+            .trim()
+            .split('\n')
+            .filter(s => s.length > 0);
+    }
+    catch {
+        // tmux not running or no sessions
+        return [];
+    }
+}
+/**
+ * Get detailed session info
+ */
+function listSessions() {
+    try {
+        const output = (0, child_process_1.execSync)('tmux list-sessions -F "#{session_name}|#{session_windows}|#{session_created}|#{session_attached}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        return output
+            .trim()
+            .split('\n')
+            .filter(line => line.length > 0)
+            .map(line => {
+            const [name, windows, created, attached] = line.split('|');
+            return {
+                name,
+                windows: parseInt(windows, 10) || 1,
+                created: created || undefined,
+                attached: attached === '1'
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Capture tmux pane content with escape sequences (colors)
+ */
+function capturePane(sessionName) {
+    try {
+        const output = (0, child_process_1.execSync)(`tmux capture-pane -t "${sessionName}" -p -e -N`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 10 * 1024 * 1024 // 10MB
+        });
+        // Normalize line endings
+        return output.replace(/\n/g, '\r\n');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Send keys to tmux session
+ */
+function sendKeys(target, keys, enter = true) {
+    try {
+        // Handle special keys
+        if (keys === '\x03') {
+            // Ctrl+C
+            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" C-c`, { stdio: 'pipe' });
+            return true;
+        }
+        if (keys === '\x04') {
+            // Ctrl+D
+            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" C-d`, { stdio: 'pipe' });
+            return true;
+        }
+        // For Enter key only
+        if (keys === '\n' || keys === '\r\n') {
+            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" Enter`, { stdio: 'pipe' });
+            return true;
+        }
+        // For text with newline at end (command + enter)
+        if (keys.endsWith('\n')) {
+            const cmd = keys.slice(0, -1);
+            if (cmd) {
+                (0, child_process_1.execSync)(`tmux send-keys -t "${target}" -l "${escapeForShell(cmd)}"`, { stdio: 'pipe' });
+            }
+            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" Enter`, { stdio: 'pipe' });
+            return true;
+        }
+        // Regular text input
+        (0, child_process_1.execSync)(`tmux send-keys -t "${target}" -l "${escapeForShell(keys)}"`, { stdio: 'pipe' });
+        if (enter) {
+            (0, child_process_1.execSync)(`tmux send-keys -t "${target}" Enter`, { stdio: 'pipe' });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resize tmux window
+ */
+function resizeWindow(sessionName, cols, rows) {
+    try {
+        (0, child_process_1.execSync)(`tmux resize-window -t "${sessionName}" -x ${cols} -y ${rows}`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create new tmux session
+ */
+function createSession(sessionName) {
+    try {
+        // Sanitize session name
+        const sanitized = sessionName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        if (!sanitized)
+            return false;
+        (0, child_process_1.execSync)(`tmux new-session -d -s "${sanitized}"`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Kill tmux session
+ */
+function killSession(sessionName) {
+    try {
+        (0, child_process_1.execSync)(`tmux kill-session -t "${sessionName}"`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Escape string for shell
+ */
+function escapeForShell(str) {
+    return str.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,72 @@
+export interface AgentConfig {
+    machineId: string;
+    relay: string;
+    token: string;
+    api?: ApiConfig;
+}
+export interface ApiConfig {
+    enabled: boolean;
+    agentId?: string;
+    exec?: ExecConfig;
+    llm?: LlmConfig;
+}
+export interface ExecConfig {
+    enabled: boolean;
+    shell: string;
+    workingDir?: string;
+    allowedCommands?: string[];
+    defaultTimeout: number;
+}
+export interface LlmConfig {
+    enabled: boolean;
+    provider: 'ollama' | 'openai';
+    baseUrl: string;
+    model: string;
+    apiKey?: string;
+}
+export interface Message {
+    type: string;
+    role?: string;
+    session?: string;
+    payload?: string;
+    meta?: Record<string, string>;
+}
+export interface TmuxSession {
+    name: string;
+    windows: number;
+    created?: string;
+    attached: boolean;
+}
+export interface ExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    duration: number;
+}
+export interface LlmMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface LlmResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: string;
+            content: string;
+        };
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    error?: {
+        message: string;
+        type: string;
+    };
+}

package/dist/agent/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent/websocket.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from 'events';
+import { Message } from './types';
+interface WebSocketClientOptions {
+    url: string;
+    sessionId: string;
+    machineId: string;
+    token: string;
+    label?: string;
+    autoReconnect?: boolean;
+}
+export declare class RelayWebSocketClient extends EventEmitter {
+    private ws;
+    private url;
+    private sessionId;
+    private machineId;
+    private token;
+    private label;
+    private autoReconnect;
+    private isConnected;
+    private reconnectAttempts;
+    private circuitBreakerOpen;
+    private circuitBreakerResetTime;
+    private reconnectTimer;
+    private destroyed;
+    constructor(options: WebSocketClientOptions);
+    connect(): void;
+    private registerAsHost;
+    private handleMessage;
+    private handleError;
+    private scheduleReconnect;
+    send(message: Message): boolean;
+    sendScreen(data: Buffer): boolean;
+    sendScreenCompressed(data: Buffer): boolean;
+    /**
+     * Send file content to be displayed in the web FileViewer
+     * @param filename - The name of the file
+     * @param content - The file content (UTF-8 for text, base64 for images)
+     * @param contentType - MIME type (e.g., 'text/markdown', 'text/html', 'image/png')
+     * @param path - Optional file path
+     */
+    sendFileView(filename: string, content: string, contentType: string, path?: string): boolean;
+    getConnected(): boolean;
+    destroy(): void;
+}
+export {};

package/dist/agent/websocket.js

@@ -0,0 +1,288 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelayWebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const events_1 = require("events");
+const zlib = __importStar(require("zlib"));
+const MAX_RECONNECT_ATTEMPTS = 5;
+const BASE_RECONNECT_DELAY_MS = 2000;
+const MAX_RECONNECT_DELAY_MS = 60000;
+const CIRCUIT_BREAKER_DURATION_MS = 120000;
+class RelayWebSocketClient extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.ws = null;
+        this.isConnected = false;
+        this.reconnectAttempts = 0;
+        this.circuitBreakerOpen = false;
+        this.circuitBreakerResetTime = 0;
+        this.reconnectTimer = null;
+        this.destroyed = false;
+        this.url = options.url;
+        this.sessionId = options.sessionId;
+        this.machineId = options.machineId;
+        this.token = options.token;
+        this.label = options.label || options.sessionId;
+        this.autoReconnect = options.autoReconnect ?? true;
+    }
+    connect() {
+        if (this.destroyed)
+            return;
+        try {
+            this.ws = new ws_1.default(this.url);
+            this.ws.on('open', () => {
+                this.isConnected = true;
+                this.reconnectAttempts = 0;
+                this.circuitBreakerOpen = false;
+                this.emit('connected');
+                this.registerAsHost();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(message);
+                }
+                catch (e) {
+                    console.error('Failed to parse message:', e);
+                }
+            });
+            this.ws.on('close', (code, reason) => {
+                this.isConnected = false;
+                this.emit('disconnected', { code, reason: reason.toString() });
+                if (this.autoReconnect && !this.destroyed) {
+                    this.scheduleReconnect();
+                }
+            });
+            this.ws.on('error', (error) => {
+                this.emit('error', error);
+            });
+        }
+        catch (error) {
+            this.emit('error', error);
+            if (this.autoReconnect && !this.destroyed) {
+                this.scheduleReconnect();
+            }
+        }
+    }
+    registerAsHost() {
+        const meta = {
+            label: this.label,
+            machineId: this.machineId,
+        };
+        if (this.token) {
+            meta.token = this.token;
+        }
+        this.send({
+            type: 'register',
+            role: 'host',
+            session: this.sessionId,
+            meta
+        });
+    }
+    handleMessage(message) {
+        switch (message.type) {
+            case 'keys':
+                if (message.session === this.sessionId && message.payload) {
+                    this.emit('keys', message.payload);
+                }
+                break;
+            case 'resize':
+                if (message.session === this.sessionId && message.meta) {
+                    const cols = parseInt(message.meta.cols, 10);
+                    const rows = parseInt(message.meta.rows, 10);
+                    if (!isNaN(cols) && !isNaN(rows)) {
+                        this.emit('resize', { cols, rows });
+                    }
+                }
+                break;
+            case 'createSession':
+                if (message.meta?.sessionName) {
+                    this.emit('createSession', message.meta.sessionName);
+                }
+                break;
+            case 'killSession':
+                if (message.session === this.sessionId) {
+                    this.emit('killSession');
+                }
+                break;
+            case 'error':
+                this.handleError(message);
+                break;
+            default:
+                this.emit('message', message);
+        }
+    }
+    handleError(message) {
+        const meta = message.meta;
+        if (!meta)
+            return;
+        if (meta.code === 'LIMIT_EXCEEDED') {
+            console.error('============================================================');
+            console.error('SESSION LIMIT EXCEEDED');
+            console.error('============================================================');
+            console.error(`Resource: ${meta.resource}`);
+            console.error(`Current: ${meta.current}, Max: ${meta.max}`);
+            console.error(`Message: ${meta.messageEn}`);
+            console.error(`한국어: ${meta.messageKo}`);
+            console.error(`Upgrade at: ${meta.upgradeUrl}`);
+            console.error('============================================================');
+            // Stop reconnection and exit
+            this.autoReconnect = false;
+            this.destroy();
+            process.exit(1);
+        }
+        else {
+            console.error(`Error: code=${meta.code}, message=${meta.messageEn}`);
+        }
+    }
+    scheduleReconnect() {
+        if (this.destroyed)
+            return;
+        // Check circuit breaker
+        if (this.circuitBreakerOpen) {
+            const now = Date.now();
+            if (now < this.circuitBreakerResetTime) {
+                const remainingSeconds = Math.ceil((this.circuitBreakerResetTime - now) / 1000);
+                console.log(`Circuit breaker open. Retry in ${remainingSeconds} seconds`);
+                this.reconnectTimer = setTimeout(() => this.scheduleReconnect(), this.circuitBreakerResetTime - now);
+                return;
+            }
+            else {
+                console.log('Circuit breaker reset');
+                this.circuitBreakerOpen = false;
+                this.reconnectAttempts = 0;
+            }
+        }
+        this.reconnectAttempts++;
+        // Check max attempts
+        if (this.reconnectAttempts > MAX_RECONNECT_ATTEMPTS) {
+            console.error(`Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached. Circuit breaker active for ${CIRCUIT_BREAKER_DURATION_MS / 1000} seconds`);
+            this.circuitBreakerOpen = true;
+            this.circuitBreakerResetTime = Date.now() + CIRCUIT_BREAKER_DURATION_MS;
+            this.reconnectAttempts = 0;
+            this.reconnectTimer = setTimeout(() => this.scheduleReconnect(), CIRCUIT_BREAKER_DURATION_MS);
+            return;
+        }
+        // Exponential backoff with jitter
+        const delay = Math.min(BASE_RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempts - 1), MAX_RECONNECT_DELAY_MS);
+        const jitter = Math.random() * delay * 0.5;
+        const reconnectDelay = Math.floor(delay + jitter);
+        console.log(`Reconnecting in ${reconnectDelay}ms (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
+        this.reconnectTimer = setTimeout(() => {
+            if (!this.isConnected && !this.destroyed) {
+                this.connect();
+            }
+        }, reconnectDelay);
+    }
+    send(message) {
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            return false;
+        }
+        try {
+            this.ws.send(JSON.stringify(message));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    sendScreen(data) {
+        if (!this.isConnected)
+            return false;
+        const base64Data = data.toString('base64');
+        return this.send({
+            type: 'screen',
+            session: this.sessionId,
+            payload: base64Data
+        });
+    }
+    sendScreenCompressed(data) {
+        if (!this.isConnected)
+            return false;
+        try {
+            const compressed = zlib.gzipSync(data);
+            const base64Data = compressed.toString('base64');
+            return this.send({
+                type: 'screenGz',
+                session: this.sessionId,
+                payload: base64Data
+            });
+        }
+        catch {
+            return this.sendScreen(data);
+        }
+    }
+    /**
+     * Send file content to be displayed in the web FileViewer
+     * @param filename - The name of the file
+     * @param content - The file content (UTF-8 for text, base64 for images)
+     * @param contentType - MIME type (e.g., 'text/markdown', 'text/html', 'image/png')
+     * @param path - Optional file path
+     */
+    sendFileView(filename, content, contentType, path) {
+        if (!this.isConnected)
+            return false;
+        return this.send({
+            type: 'file_view',
+            session: this.sessionId,
+            meta: {
+                filename,
+                contentType,
+                path: path || ''
+            },
+            payload: content
+        });
+    }
+    getConnected() {
+        return this.isConnected;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.autoReconnect = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
+exports.RelayWebSocketClient = RelayWebSocketClient;

package/dist/api.d.ts

@@ -0,0 +1,31 @@
+export interface Agent {
+    id: string;
+    label: string | null;
+    machineId: string | null;
+    isActive: boolean;
+    apiEnabled: boolean;
+    lastConnectedAt: string | null;
+    createdAt: string;
+}
+export interface TmuxSession {
+    name: string;
+    windows: number;
+    created: string | null;
+    attached: boolean;
+}
+export interface SendKeysResult {
+    success: boolean;
+    agentId: string;
+    target: string;
+    error?: string;
+}
+declare class ApiClient {
+    private getHeaders;
+    listAgents(): Promise<Agent[]>;
+    getAgent(agentId: string): Promise<Agent>;
+    listSessions(agentId: string): Promise<TmuxSession[]>;
+    sendKeys(agentId: string, target: string, keys: string, enter?: boolean): Promise<SendKeysResult>;
+    findAgentByName(name: string): Promise<Agent | null>;
+}
+export declare const api: ApiClient;
+export {};

package/dist/api.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const config_1 = require("./config");
+class ApiClient {
+    getHeaders() {
+        const apiKey = (0, config_1.getApiKey)();
+        if (!apiKey) {
+            throw new Error('Not logged in. Run: sessioncast login');
+        }
+        return {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json'
+        };
+    }
+    async listAgents() {
+        const url = `${(0, config_1.getApiUrl)()}/api/v1/agents`;
+        const response = await (0, node_fetch_1.default)(url, {
+            method: 'GET',
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(error.message || 'Failed to list agents');
+        }
+        const data = await response.json();
+        return data.agents;
+    }
+    async getAgent(agentId) {
+        const url = `${(0, config_1.getApiUrl)()}/api/v1/agents/${agentId}`;
+        const response = await (0, node_fetch_1.default)(url, {
+            method: 'GET',
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            throw new Error('Agent not found');
+        }
+        return await response.json();
+    }
+    async listSessions(agentId) {
+        const url = `${(0, config_1.getApiUrl)()}/api/v1/agents/${agentId}/sessions`;
+        const response = await (0, node_fetch_1.default)(url, {
+            method: 'GET',
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(error.message || 'Failed to list sessions');
+        }
+        const data = await response.json();
+        return data.sessions;
+    }
+    async sendKeys(agentId, target, keys, enter = true) {
+        const url = `${(0, config_1.getApiUrl)()}/api/v1/agents/${agentId}/send-keys`;
+        const response = await (0, node_fetch_1.default)(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({ target, keys, enter })
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(error.message || 'Failed to send keys');
+        }
+        return await response.json();
+    }
+    async findAgentByName(name) {
+        const agents = await this.listAgents();
+        // Search by label or machineId
+        return agents.find(a => a.label?.toLowerCase() === name.toLowerCase() ||
+            a.machineId?.toLowerCase() === name.toLowerCase() ||
+            a.id === name) || null;
+    }
+}
+exports.api = new ApiClient();

package/dist/commands/agent.d.ts

@@ -0,0 +1,5 @@
+interface AgentOptions {
+    config?: string;
+}
+export declare function startAgent(options: AgentOptions): Promise<void>;
+export {};