sessioncast-cli 2.2.2 → 2.3.1

package/dist/agent/llm-service.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlmService = void 0;
 const child_process_1 = require("child_process");
+const readline_1 = require("readline");
 class LlmService {
     constructor(config) {
         this.config = config || {
@@ -37,6 +38,12 @@ class LlmService {
                     return await this.callAnthropic(actualModel, messages || [], temperature, maxTokens);
                 case 'claude-code':
                     return await this.callClaudeCode(actualModel, messages || [], maxTokens);
+                case 'codex':
+                    return await this.callCodex(actualModel, messages || [], maxTokens);
+                case 'gemini':
+                    return await this.callGemini(actualModel, messages || [], temperature, maxTokens);
+                case 'cursor':
+                    return await this.callCursor(actualModel, messages || [], maxTokens);
                 default:
                     return {
                         id: '',
@@ -65,6 +72,42 @@ class LlmService {
             };
         }
     }
+    async chatStream(model, messages, temperature, maxTokens, onChunk) {
+        if (!this.config.enabled || !onChunk) {
+            return this.chat(model, messages, temperature, maxTokens);
+        }
+        const provider = this.config.provider || 'ollama';
+        const actualModel = model || this.config.model;
+        try {
+            switch (provider.toLowerCase()) {
+                case 'claude-code':
+                    return await this.callClaudeCodeStream(actualModel, messages || [], maxTokens, onChunk);
+                case 'ollama':
+                    return await this.callOllamaStream(actualModel, messages || [], temperature, maxTokens, onChunk);
+                case 'openai':
+                    return await this.callOpenAiStream(actualModel, messages || [], temperature, maxTokens, onChunk);
+                case 'anthropic':
+                    return await this.callAnthropicStream(actualModel, messages || [], temperature, maxTokens, onChunk);
+                default:
+                    // For providers without streaming, fall back to non-streaming
+                    const result = await this.chat(model, messages, temperature, maxTokens);
+                    if (result.choices?.[0]?.message?.content) {
+                        onChunk({ content: result.choices[0].message.content, done: true });
+                    }
+                    return result;
+            }
+        }
+        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 = {
@@ -328,6 +371,551 @@ class LlmService {
             });
         });
     }
+    async callCodex(model, messages, maxTokens) {
+        const parts = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                parts.push(`[System] ${msg.content}`);
+            }
+            else if (msg.role === 'user') {
+                parts.push(msg.content);
+            }
+            else if (msg.role === 'assistant') {
+                parts.push(`[Assistant] ${msg.content}`);
+            }
+        }
+        const prompt = parts.join('\n\n');
+        const args = ['exec', '--json'];
+        if (model && model !== 'default') {
+            args.push('-c', `model="${model}"`);
+        }
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('codex', args, {
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            proc.stdin.write(prompt);
+            proc.stdin.end();
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => { stdout += data.toString(); });
+            proc.stderr.on('data', (data) => { stderr += data.toString(); });
+            const timer = setTimeout(() => {
+                proc.kill();
+                resolve({
+                    id: '',
+                    object: 'error',
+                    created: Math.floor(Date.now() / 1000),
+                    model,
+                    choices: [],
+                    error: { message: 'Codex CLI timed out after 120s', type: 'timeout' }
+                });
+            }, 120000);
+            proc.on('close', (code) => {
+                clearTimeout(timer);
+                if (code !== 0) {
+                    resolve({
+                        id: '',
+                        object: 'error',
+                        created: Math.floor(Date.now() / 1000),
+                        model,
+                        choices: [],
+                        error: {
+                            message: `Codex CLI exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`,
+                            type: 'internal_error'
+                        }
+                    });
+                    return;
+                }
+                try {
+                    // codex exec --json outputs JSONL events, find the last assistant message
+                    const lines = stdout.trim().split('\n');
+                    let content = '';
+                    let usage = { input_tokens: 0, output_tokens: 0 };
+                    for (const line of lines) {
+                        try {
+                            const event = JSON.parse(line);
+                            if (event.type === 'message' && event.role === 'assistant') {
+                                content = typeof event.content === 'string'
+                                    ? event.content
+                                    : (event.content || []).filter((c) => c.type === 'output_text').map((c) => c.text).join('');
+                            }
+                            if (event.usage) {
+                                usage = event.usage;
+                            }
+                        }
+                        catch { /* skip non-JSON lines */ }
+                    }
+                    resolve({
+                        id: `codex-${Math.random().toString(36).substring(2, 10)}`,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: model || 'codex',
+                        choices: [{
+                                index: 0,
+                                message: { role: 'assistant', content: content || stdout.trim() },
+                                finish_reason: 'stop'
+                            }],
+                        usage: {
+                            prompt_tokens: usage.input_tokens || 0,
+                            completion_tokens: usage.output_tokens || 0,
+                            total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+                        }
+                    });
+                }
+                catch {
+                    resolve({
+                        id: `codex-${Math.random().toString(36).substring(2, 10)}`,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: model || 'codex',
+                        choices: [{
+                                index: 0,
+                                message: { role: 'assistant', content: stdout.trim() },
+                                finish_reason: 'stop'
+                            }],
+                        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+                    });
+                }
+            });
+        });
+    }
+    async callGemini(model, messages, temperature, maxTokens) {
+        const apiKey = this.config.apiKey;
+        if (!apiKey) {
+            return {
+                id: '',
+                object: 'error',
+                created: Date.now(),
+                model: '',
+                choices: [],
+                error: {
+                    message: 'Gemini API key not configured',
+                    type: 'configuration_error'
+                }
+            };
+        }
+        const actualModel = model || 'gemini-2.0-flash';
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/${actualModel}:generateContent?key=${apiKey}`;
+        // Separate system message from conversation
+        let systemInstruction;
+        const contents = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                systemInstruction = msg.content;
+            }
+            else {
+                contents.push({
+                    role: msg.role === 'assistant' ? 'model' : 'user',
+                    parts: [{ text: msg.content }]
+                });
+            }
+        }
+        const requestBody = { contents };
+        if (systemInstruction) {
+            requestBody.systemInstruction = { parts: [{ text: systemInstruction }] };
+        }
+        const generationConfig = {};
+        if (maxTokens)
+            generationConfig.maxOutputTokens = maxTokens;
+        if (temperature !== undefined)
+            generationConfig.temperature = temperature;
+        if (Object.keys(generationConfig).length > 0) {
+            requestBody.generationConfig = generationConfig;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+            const errorBody = await response.text();
+            throw new Error(`Gemini returned status ${response.status}: ${errorBody}`);
+        }
+        const geminiResponse = await response.json();
+        return this.convertGeminiToOpenAiFormat(geminiResponse, actualModel);
+    }
+    convertGeminiToOpenAiFormat(geminiResponse, model) {
+        const candidate = (geminiResponse.candidates || [])[0] || {};
+        const content = (candidate.content?.parts || [])
+            .map((p) => p.text || '')
+            .join('');
+        const usage = geminiResponse.usageMetadata || {};
+        return {
+            id: `gemini-${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: candidate.finishReason === 'STOP' ? 'stop' : (candidate.finishReason || 'stop')
+                }],
+            usage: {
+                prompt_tokens: usage.promptTokenCount || 0,
+                completion_tokens: usage.candidatesTokenCount || 0,
+                total_tokens: usage.totalTokenCount || 0
+            }
+        };
+    }
+    async callCursor(model, messages, maxTokens) {
+        const parts = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                parts.push(`[System] ${msg.content}`);
+            }
+            else if (msg.role === 'user') {
+                parts.push(msg.content);
+            }
+            else if (msg.role === 'assistant') {
+                parts.push(`[Assistant] ${msg.content}`);
+            }
+        }
+        const prompt = parts.join('\n\n');
+        const args = ['-p', '--output-format', 'json'];
+        if (model && model !== 'default') {
+            args.push('--model', model);
+        }
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('cursor', args, {
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            proc.stdin.write(prompt);
+            proc.stdin.end();
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => { stdout += data.toString(); });
+            proc.stderr.on('data', (data) => { stderr += data.toString(); });
+            const timer = setTimeout(() => {
+                proc.kill();
+                resolve({
+                    id: '',
+                    object: 'error',
+                    created: Math.floor(Date.now() / 1000),
+                    model,
+                    choices: [],
+                    error: { message: 'Cursor CLI timed out after 120s', type: 'timeout' }
+                });
+            }, 120000);
+            proc.on('close', (code) => {
+                clearTimeout(timer);
+                if (code !== 0) {
+                    resolve({
+                        id: '',
+                        object: 'error',
+                        created: Math.floor(Date.now() / 1000),
+                        model,
+                        choices: [],
+                        error: {
+                            message: `Cursor CLI exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`,
+                            type: 'internal_error'
+                        }
+                    });
+                    return;
+                }
+                try {
+                    const events = JSON.parse(stdout);
+                    const resultEvent = Array.isArray(events)
+                        ? events.find((e) => e.type === 'result')
+                        : events;
+                    const content = resultEvent?.result || '';
+                    const usage = resultEvent?.usage || {};
+                    resolve({
+                        id: `cursor-${Math.random().toString(36).substring(2, 10)}`,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: model || 'cursor',
+                        choices: [{
+                                index: 0,
+                                message: { role: 'assistant', content },
+                                finish_reason: 'stop'
+                            }],
+                        usage: {
+                            prompt_tokens: usage.input_tokens || 0,
+                            completion_tokens: usage.output_tokens || 0,
+                            total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+                        }
+                    });
+                }
+                catch {
+                    resolve({
+                        id: `cursor-${Math.random().toString(36).substring(2, 10)}`,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: model || 'cursor',
+                        choices: [{
+                                index: 0,
+                                message: { role: 'assistant', content: stdout.trim() },
+                                finish_reason: 'stop'
+                            }],
+                        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+                    });
+                }
+            });
+        });
+    }
+    async callClaudeCodeStream(model, messages, maxTokens, onChunk) {
+        const parts = [];
+        for (const msg of messages) {
+            if (msg.role === 'system')
+                parts.push(`[System] ${msg.content}`);
+            else if (msg.role === 'user')
+                parts.push(msg.content);
+            else if (msg.role === 'assistant')
+                parts.push(`[Assistant] ${msg.content}`);
+        }
+        const prompt = parts.join('\n\n');
+        const args = ['-p', '--output-format', 'stream-json', '--no-session-persistence'];
+        if (model && model !== 'default') {
+            args.push('--model', model);
+        }
+        return new Promise((resolve) => {
+            const env = { ...process.env };
+            delete env.CLAUDECODE;
+            delete env.CLAUDE_CODE;
+            const proc = (0, child_process_1.spawn)('claude', args, { env, stdio: ['pipe', 'pipe', 'pipe'] });
+            proc.stdin.write(prompt);
+            proc.stdin.end();
+            let fullContent = '';
+            let lastResult = null;
+            let stderr = '';
+            const rl = (0, readline_1.createInterface)({ input: proc.stdout });
+            rl.on('line', (line) => {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === 'assistant' && event.message) {
+                        // Extract text content from assistant message
+                        const text = typeof event.message === 'string'
+                            ? event.message
+                            : (event.message.content || [])
+                                .filter((c) => c.type === 'text')
+                                .map((c) => c.text)
+                                .join('');
+                        if (text) {
+                            fullContent += text;
+                            onChunk({ content: text, done: false });
+                        }
+                    }
+                    else if (event.type === 'content_block_delta') {
+                        const delta = event.delta?.text || '';
+                        if (delta) {
+                            fullContent += delta;
+                            onChunk({ content: delta, done: false });
+                        }
+                    }
+                    else if (event.type === 'result') {
+                        lastResult = event;
+                        if (!fullContent && event.result) {
+                            fullContent = event.result;
+                        }
+                    }
+                }
+                catch { /* skip non-JSON lines */ }
+            });
+            proc.stderr.on('data', (data) => { stderr += data.toString(); });
+            const timer = setTimeout(() => {
+                proc.kill();
+                onChunk({ content: '', done: true });
+                resolve({
+                    id: '', object: 'error', created: Math.floor(Date.now() / 1000), model,
+                    choices: [], error: { message: 'Claude Code timed out after 120s', type: 'timeout' }
+                });
+            }, 120000);
+            proc.on('close', (code) => {
+                clearTimeout(timer);
+                rl.close();
+                onChunk({ content: '', done: true });
+                const usage = lastResult?.usage || {};
+                resolve({
+                    id: lastResult?.session_id || `claude-${Math.random().toString(36).substring(2, 10)}`,
+                    object: 'chat.completion',
+                    created: Math.floor(Date.now() / 1000),
+                    model: model || 'claude-code',
+                    choices: [{
+                            index: 0,
+                            message: { role: 'assistant', content: fullContent || lastResult?.result || '' },
+                            finish_reason: 'stop'
+                        }],
+                    usage: {
+                        prompt_tokens: usage.input_tokens || 0,
+                        completion_tokens: usage.output_tokens || 0,
+                        total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+                    }
+                });
+            });
+        });
+    }
+    async callOllamaStream(model, messages, temperature, maxTokens, onChunk) {
+        const baseUrl = this.config.baseUrl || 'http://localhost:11434';
+        const requestBody = { model, messages, stream: true };
+        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}`);
+        let fullContent = '';
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        if (reader) {
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.message?.content) {
+                            fullContent += event.message.content;
+                            onChunk({ content: event.message.content, done: false });
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+        }
+        onChunk({ content: '', done: true });
+        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: fullContent }, finish_reason: 'stop' }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+        };
+    }
+    async callOpenAiStream(model, messages, temperature, maxTokens, onChunk) {
+        const baseUrl = this.config.baseUrl || 'https://api.openai.com/v1';
+        const apiKey = this.config.apiKey;
+        if (!apiKey)
+            throw new Error('OpenAI API key not configured');
+        const requestBody = { model, messages, stream: true };
+        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}`);
+        let fullContent = '';
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        if (reader) {
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: ') || line === 'data: [DONE]')
+                        continue;
+                    try {
+                        const event = JSON.parse(line.slice(6));
+                        const delta = event.choices?.[0]?.delta?.content || '';
+                        if (delta) {
+                            fullContent += delta;
+                            onChunk({ content: delta, done: false });
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+        }
+        onChunk({ content: '', done: true });
+        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: fullContent }, finish_reason: 'stop' }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+        };
+    }
+    async callAnthropicStream(model, messages, temperature, maxTokens, onChunk) {
+        const baseUrl = this.config.baseUrl || 'https://api.anthropic.com';
+        const apiKey = this.config.apiKey;
+        if (!apiKey)
+            throw new Error('Anthropic API key not configured');
+        let systemPrompt;
+        const chatMessages = [];
+        for (const msg of messages) {
+            if (msg.role === 'system')
+                systemPrompt = msg.content;
+            else
+                chatMessages.push({ role: msg.role, content: msg.content });
+        }
+        const requestBody = { model, messages: chatMessages, max_tokens: maxTokens || 1024, stream: true };
+        if (systemPrompt)
+            requestBody.system = systemPrompt;
+        if (temperature !== undefined)
+            requestBody.temperature = temperature;
+        const response = await fetch(`${baseUrl}/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01'
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok)
+            throw new Error(`Anthropic returned status ${response.status}`);
+        let fullContent = '';
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        if (reader) {
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    try {
+                        const event = JSON.parse(line.slice(6));
+                        if (event.type === 'content_block_delta' && event.delta?.text) {
+                            fullContent += event.delta.text;
+                            onChunk({ content: event.delta.text, done: false });
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+        }
+        onChunk({ content: '', done: true });
+        return {
+            id: `msg-${Math.random().toString(36).substring(2, 10)}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{ index: 0, message: { role: 'assistant', content: fullContent }, finish_reason: 'stop' }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+        };
+    }
     convertAnthropicToOpenAiFormat(anthropicResponse, model) {
         const content = (anthropicResponse.content || [])
             .filter((block) => block.type === 'text')

package/dist/agent/runner.d.ts

@@ -6,11 +6,17 @@ export declare class AgentRunner {
     private scanTimer;
     private running;
     constructor(config: AgentConfig);
-    static loadConfig(configPath?: string): AgentConfig;
+    /**
+     * Fetch optimal relay URL from Platform API using agent token.
+     * Returns null on failure (caller should fall back to default).
+     */
+    private static fetchRelayUrlForAgent;
+    static loadConfig(configPath?: string): Promise<AgentConfig>;
     start(): Promise<void>;
     private scanAndUpdateSessions;
     private startSessionHandler;
     private stopSessionHandler;
     private createTmuxSession;
+    private fetchEncKey;
     stop(): void;
 }