sessioncast-cli 1.0.0

package/dist/agent/llm-service.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlmService = void 0;
+class LlmService {
+    constructor(config) {
+        this.config = config || {
+            enabled: false,
+            provider: 'ollama',
+            baseUrl: 'http://localhost:11434',
+            model: 'llama2'
+        };
+    }
+    async chat(model, messages, temperature, maxTokens, stream) {
+        if (!this.config.enabled) {
+            return {
+                id: '',
+                object: 'error',
+                created: Date.now(),
+                model: '',
+                choices: [],
+                error: {
+                    message: 'LLM is disabled on this agent',
+                    type: 'service_unavailable'
+                }
+            };
+        }
+        const provider = this.config.provider || 'ollama';
+        const actualModel = model || this.config.model;
+        try {
+            switch (provider.toLowerCase()) {
+                case 'ollama':
+                    return await this.callOllama(actualModel, messages || [], temperature, maxTokens);
+                case 'openai':
+                    return await this.callOpenAi(actualModel, messages || [], temperature, maxTokens);
+                default:
+                    return {
+                        id: '',
+                        object: 'error',
+                        created: Date.now(),
+                        model: '',
+                        choices: [],
+                        error: {
+                            message: `Unknown LLM provider: ${provider}`,
+                            type: 'invalid_request'
+                        }
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                id: '',
+                object: 'error',
+                created: Date.now(),
+                model: '',
+                choices: [],
+                error: {
+                    message: error.message,
+                    type: 'internal_error'
+                }
+            };
+        }
+    }
+    async callOllama(model, messages, temperature, maxTokens) {
+        const baseUrl = this.config.baseUrl || 'http://localhost:11434';
+        const requestBody = {
+            model,
+            messages,
+            stream: false
+        };
+        const options = {};
+        if (temperature !== undefined) {
+            options.temperature = temperature;
+        }
+        if (maxTokens !== undefined) {
+            options.num_predict = maxTokens;
+        }
+        if (Object.keys(options).length > 0) {
+            requestBody.options = options;
+        }
+        const response = await fetch(`${baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama returned status ${response.status}`);
+        }
+        const ollamaResponse = await response.json();
+        return this.convertOllamaToOpenAiFormat(ollamaResponse, model);
+    }
+    convertOllamaToOpenAiFormat(ollamaResponse, model) {
+        const message = ollamaResponse.message || {};
+        const content = message.content || '';
+        const promptTokens = ollamaResponse.prompt_eval_count || 0;
+        const completionTokens = ollamaResponse.eval_count || 0;
+        return {
+            id: `chatcmpl-${Math.random().toString(36).substring(2, 10)}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content
+                    },
+                    finish_reason: 'stop'
+                }],
+            usage: {
+                prompt_tokens: promptTokens,
+                completion_tokens: completionTokens,
+                total_tokens: promptTokens + completionTokens
+            }
+        };
+    }
+    async callOpenAi(model, messages, temperature, maxTokens) {
+        const baseUrl = this.config.baseUrl || 'https://api.openai.com/v1';
+        const apiKey = this.config.apiKey;
+        if (!apiKey) {
+            return {
+                id: '',
+                object: 'error',
+                created: Date.now(),
+                model: '',
+                choices: [],
+                error: {
+                    message: 'OpenAI API key not configured',
+                    type: 'configuration_error'
+                }
+            };
+        }
+        const requestBody = {
+            model,
+            messages
+        };
+        if (temperature !== undefined) {
+            requestBody.temperature = temperature;
+        }
+        if (maxTokens !== undefined) {
+            requestBody.max_tokens = maxTokens;
+        }
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI returned status ${response.status}`);
+        }
+        return await response.json();
+    }
+}
+exports.LlmService = LlmService;

package/dist/agent/runner.d.ts

@@ -0,0 +1,16 @@
+import { AgentConfig } from './types';
+export declare class AgentRunner {
+    private config;
+    private handlers;
+    private apiClient;
+    private scanTimer;
+    private running;
+    constructor(config: AgentConfig);
+    static loadConfig(configPath?: string): AgentConfig;
+    start(): Promise<void>;
+    private scanAndUpdateSessions;
+    private startSessionHandler;
+    private stopSessionHandler;
+    private createTmuxSession;
+    stop(): void;
+}

package/dist/agent/runner.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRunner = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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 SCAN_INTERVAL_MS = 5000;
+class AgentRunner {
+    constructor(config) {
+        this.handlers = new Map();
+        this.apiClient = null;
+        this.scanTimer = null;
+        this.running = false;
+        this.config = config;
+    }
+    static loadConfig(configPath) {
+        // Check environment variable
+        const envPath = process.env.SESSIONCAST_CONFIG || process.env.TMUX_REMOTE_CONFIG;
+        // Try multiple default paths
+        const defaultPaths = [
+            path.join(process.env.HOME || '', '.sessioncast.yml'),
+            path.join(process.env.HOME || '', '.tmux-remote.yml'),
+        ];
+        let finalPath = configPath || envPath;
+        if (!finalPath) {
+            for (const p of defaultPaths) {
+                if (fs.existsSync(p)) {
+                    finalPath = p;
+                    break;
+                }
+            }
+        }
+        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)
+            return;
+        this.running = true;
+        console.log('Starting SessionCast Agent...');
+        console.log(`Machine ID: ${this.config.machineId}`);
+        console.log(`Relay: ${this.config.relay}`);
+        console.log(`Token: ${this.config.token ? 'present' : 'none'}`);
+        // Start API client if configured
+        if (this.config.api?.enabled && this.config.api.agentId) {
+            this.apiClient = new api_client_1.ApiWebSocketClient(this.config);
+            this.apiClient.start();
+        }
+        // Initial scan
+        this.scanAndUpdateSessions();
+        // Schedule periodic scan
+        this.scanTimer = setInterval(() => {
+            this.scanAndUpdateSessions();
+        }, SCAN_INTERVAL_MS);
+        console.log(`Agent started with auto-discovery (scanning every ${SCAN_INTERVAL_MS / 1000}s)`);
+        // Handle shutdown
+        process.on('SIGINT', () => this.stop());
+        process.on('SIGTERM', () => this.stop());
+    }
+    scanAndUpdateSessions() {
+        try {
+            const currentSessions = new Set(tmux.scanSessions());
+            const trackedSessions = new Set(this.handlers.keys());
+            // Start handlers for new sessions
+            for (const session of currentSessions) {
+                if (!trackedSessions.has(session)) {
+                    this.startSessionHandler(session);
+                }
+            }
+            // Stop handlers for removed sessions
+            for (const session of trackedSessions) {
+                if (!currentSessions.has(session)) {
+                    this.stopSessionHandler(session);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error during session scan:', error);
+        }
+    }
+    startSessionHandler(tmuxSession) {
+        console.log(`Discovered new tmux session: ${tmuxSession}`);
+        const handler = new session_handler_1.TmuxSessionHandler({
+            config: this.config,
+            tmuxSession,
+            onCreateSession: (name) => this.createTmuxSession(name)
+        });
+        this.handlers.set(tmuxSession, handler);
+        handler.start();
+        console.log(`Started handler for session: ${this.config.machineId}/${tmuxSession}`);
+    }
+    stopSessionHandler(tmuxSession) {
+        console.log(`Tmux session removed: ${tmuxSession}`);
+        const handler = this.handlers.get(tmuxSession);
+        if (handler) {
+            handler.stop();
+            this.handlers.delete(tmuxSession);
+            console.log(`Stopped handler for session: ${this.config.machineId}/${tmuxSession}`);
+        }
+    }
+    createTmuxSession(sessionName) {
+        // Sanitize session name
+        const sanitized = sessionName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        if (!sanitized) {
+            console.warn(`Invalid session name: ${sessionName}`);
+            return;
+        }
+        if (this.handlers.has(sanitized)) {
+            console.warn(`Session already exists: ${sanitized}`);
+            return;
+        }
+        console.log(`Creating new tmux session: ${sanitized}`);
+        if (tmux.createSession(sanitized)) {
+            console.log(`Successfully created tmux session: ${sanitized}`);
+            // Force immediate scan
+            this.scanAndUpdateSessions();
+        }
+        else {
+            console.error(`Failed to create tmux session: ${sanitized}`);
+        }
+    }
+    stop() {
+        console.log('Shutting down Agent...');
+        this.running = false;
+        if (this.scanTimer) {
+            clearInterval(this.scanTimer);
+            this.scanTimer = null;
+        }
+        if (this.apiClient) {
+            this.apiClient.stop();
+            this.apiClient = null;
+        }
+        for (const handler of this.handlers.values()) {
+            handler.stop();
+        }
+        this.handlers.clear();
+        console.log('Agent shutdown complete');
+        process.exit(0);
+    }
+}
+exports.AgentRunner = AgentRunner;

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

@@ -0,0 +1,28 @@
+import { AgentConfig } from './types';
+interface SessionHandlerOptions {
+    config: AgentConfig;
+    tmuxSession: string;
+    onCreateSession?: (name: string) => void;
+}
+export declare class TmuxSessionHandler {
+    private config;
+    private tmuxSession;
+    private sessionId;
+    private wsClient;
+    private onCreateSession?;
+    private running;
+    private lastScreen;
+    private lastForceSendTime;
+    private lastChangeTime;
+    private captureTimer;
+    constructor(options: SessionHandlerOptions);
+    start(): void;
+    private connectAndRun;
+    private handleKeys;
+    private startScreenCapture;
+    private stopScreenCapture;
+    stop(): void;
+    getSessionId(): string;
+    getTmuxSession(): string;
+}
+export {};

package/dist/agent/session-handler.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TmuxSessionHandler = void 0;
+const websocket_1 = require("./websocket");
+const tmux = __importStar(require("./tmux"));
+// Capture intervals
+const CAPTURE_INTERVAL_ACTIVE_MS = 50;
+const CAPTURE_INTERVAL_IDLE_MS = 200;
+const ACTIVE_THRESHOLD_MS = 2000;
+const FORCE_SEND_INTERVAL_MS = 10000;
+const USE_COMPRESSION = true;
+const MIN_COMPRESS_SIZE = 512;
+class TmuxSessionHandler {
+    constructor(options) {
+        this.wsClient = null;
+        this.running = false;
+        this.lastScreen = '';
+        this.lastForceSendTime = 0;
+        this.lastChangeTime = 0;
+        this.captureTimer = null;
+        this.config = options.config;
+        this.tmuxSession = options.tmuxSession;
+        this.sessionId = `${options.config.machineId}/${options.tmuxSession}`;
+        this.onCreateSession = options.onCreateSession;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        // Add jitter to prevent thundering herd
+        const jitter = Math.floor(Math.random() * 5000);
+        console.log(`[${this.tmuxSession}] Starting in ${jitter}ms`);
+        setTimeout(() => this.connectAndRun(), jitter);
+    }
+    connectAndRun() {
+        if (!this.running)
+            return;
+        this.wsClient = new websocket_1.RelayWebSocketClient({
+            url: this.config.relay,
+            sessionId: this.sessionId,
+            machineId: this.config.machineId,
+            token: this.config.token,
+            label: this.tmuxSession,
+            autoReconnect: true
+        });
+        this.wsClient.on('connected', () => {
+            console.log(`[${this.tmuxSession}] Connected to relay`);
+            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('resize', ({ cols, rows }) => {
+            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}`);
+            if (this.onCreateSession) {
+                this.onCreateSession(name);
+            }
+        });
+        this.wsClient.on('killSession', () => {
+            console.log(`[${this.tmuxSession}] Kill session request`);
+            tmux.killSession(this.tmuxSession);
+            this.stop();
+        });
+        this.wsClient.on('error', (error) => {
+            console.error(`[${this.tmuxSession}] WebSocket error:`, error.message);
+        });
+        this.wsClient.connect();
+    }
+    handleKeys(keys) {
+        tmux.sendKeys(this.tmuxSession, keys, false);
+    }
+    startScreenCapture() {
+        if (this.captureTimer)
+            return;
+        const capture = () => {
+            if (!this.running || !this.wsClient?.getConnected()) {
+                // Wait and retry
+                this.captureTimer = setTimeout(capture, 500);
+                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);
+                        }
+                        else {
+                            this.wsClient.sendScreen(data);
+                        }
+                    }
+                    // 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);
+                }
+            }
+            catch (error) {
+                console.error(`[${this.tmuxSession}] Screen capture error:`, error);
+                this.captureTimer = setTimeout(capture, 500);
+            }
+        };
+        capture();
+        console.log(`[${this.tmuxSession}] Screen capture started`);
+    }
+    stopScreenCapture() {
+        if (this.captureTimer) {
+            clearTimeout(this.captureTimer);
+            this.captureTimer = null;
+        }
+    }
+    stop() {
+        console.log(`[${this.tmuxSession}] Stopping`);
+        this.running = false;
+        this.stopScreenCapture();
+        if (this.wsClient) {
+            this.wsClient.destroy();
+            this.wsClient = null;
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getTmuxSession() {
+        return this.tmuxSession;
+    }
+}
+exports.TmuxSessionHandler = TmuxSessionHandler;

package/dist/agent/tmux.d.ts

@@ -0,0 +1,29 @@
+import { TmuxSession } from './types';
+/**
+ * Scan for all tmux sessions
+ */
+export declare function scanSessions(): string[];
+/**
+ * Get detailed session info
+ */
+export declare function listSessions(): TmuxSession[];
+/**
+ * Capture tmux pane content with escape sequences (colors)
+ */
+export declare function capturePane(sessionName: string): string | null;
+/**
+ * Send keys to tmux session
+ */
+export declare function sendKeys(target: string, keys: string, enter?: boolean): boolean;
+/**
+ * Resize tmux window
+ */
+export declare function resizeWindow(sessionName: string, cols: number, rows: number): boolean;
+/**
+ * Create new tmux session
+ */
+export declare function createSession(sessionName: string): boolean;
+/**
+ * Kill tmux session
+ */
+export declare function killSession(sessionName: string): boolean;