centaurus-cli 2.5.2 → 2.5.3

package/dist/test/services/__tests__/ai-context-injector.test.js

@@ -1,325 +0,0 @@
-/**
- * Unit tests for AI Context Injector
- *
- * These tests verify:
- * - Context message format
- * - Context injection into message history
- * - Local context (no injection)
- * - Different subshell types (SSH, WSL, Docker)
- */
-import { AIContextInjector } from '../ai-context-injector.js';
-/**
- * Test: No injection for local context
- */
-async function testLocalContextNoInjection() {
-    console.log('Test: No injection for local context');
-    const injector = new AIContextInjector();
-    const messages = [
-        { role: 'user', content: 'Hello' },
-        { role: 'assistant', content: 'Hi there!' },
-        { role: 'user', content: 'List files' },
-    ];
-    const localContext = {
-        type: 'local',
-        metadata: {
-            workingDirectory: '/home/user',
-            shell: 'bash',
-            os: 'linux',
-        },
-        connectionState: 'connected',
-        sessionId: 'local-session',
-    };
-    const result = injector.injectSubshellContext(messages, localContext);
-    // Should return the same messages without modification
-    if (result.length !== messages.length) {
-        throw new Error('Expected no additional messages for local context');
-    }
-    if (result !== messages) {
-        throw new Error('Expected same array reference for local context');
-    }
-    console.log('✓ Local context does not inject additional messages');
-}
-/**
- * Test: SSH context injection
- */
-async function testSSHContextInjection() {
-    console.log('\nTest: SSH context injection');
-    const injector = new AIContextInjector();
-    const messages = [
-        { role: 'user', content: 'Hello' },
-        { role: 'assistant', content: 'Hi there!' },
-        { role: 'user', content: 'List files' },
-    ];
-    const sshContext = {
-        type: 'ssh',
-        metadata: {
-            hostname: 'example.com',
-            username: 'testuser',
-            workingDirectory: '/home/testuser',
-            shell: 'bash',
-            os: 'linux',
-            port: 22,
-        },
-        connectionState: 'connected',
-        sessionId: 'ssh-session',
-    };
-    const result = injector.injectSubshellContext(messages, sshContext);
-    // Should have one additional message (context message)
-    if (result.length !== messages.length + 1) {
-        throw new Error(`Expected ${messages.length + 1} messages, got ${result.length}`);
-    }
-    // Context message should be inserted before the last user message
-    const contextMessage = result[result.length - 2];
-    if (contextMessage.role !== 'system') {
-        throw new Error('Expected context message to have role "system"');
-    }
-    // Verify context message content
-    const content = contextMessage.content;
-    if (!content.includes('SSH')) {
-        throw new Error('Expected context message to mention SSH');
-    }
-    if (!content.includes('example.com')) {
-        throw new Error('Expected context message to include hostname');
-    }
-    if (!content.includes('testuser')) {
-        throw new Error('Expected context message to include username');
-    }
-    if (!content.includes('/home/testuser')) {
-        throw new Error('Expected context message to include working directory');
-    }
-    if (!content.includes('bash')) {
-        throw new Error('Expected context message to include shell type');
-    }
-    if (!content.includes('linux')) {
-        throw new Error('Expected context message to include OS type');
-    }
-    if (!content.includes('22')) {
-        throw new Error('Expected context message to include port');
-    }
-    // Last message should still be the user message
-    const lastMessage = result[result.length - 1];
-    if (lastMessage.role !== 'user' || lastMessage.content !== 'List files') {
-        throw new Error('Expected last message to be the original user message');
-    }
-    console.log('✓ SSH context injects correct message with all details');
-}
-/**
- * Test: WSL context injection
- */
-async function testWSLContextInjection() {
-    console.log('\nTest: WSL context injection');
-    const injector = new AIContextInjector();
-    const messages = [
-        { role: 'user', content: 'Run command' },
-    ];
-    const wslContext = {
-        type: 'wsl',
-        metadata: {
-            distroName: 'Ubuntu-20.04',
-            workingDirectory: '/home/user',
-            shell: 'bash',
-            os: 'linux',
-        },
-        connectionState: 'connected',
-        sessionId: 'wsl-session',
-    };
-    const result = injector.injectSubshellContext(messages, wslContext);
-    // Should have one additional message
-    if (result.length !== 2) {
-        throw new Error('Expected 2 messages after injection');
-    }
-    const contextMessage = result[0];
-    if (contextMessage.role !== 'system') {
-        throw new Error('Expected context message to have role "system"');
-    }
-    const content = contextMessage.content;
-    if (!content.includes('WSL')) {
-        throw new Error('Expected context message to mention WSL');
-    }
-    if (!content.includes('Ubuntu-20.04')) {
-        throw new Error('Expected context message to include distribution name');
-    }
-    console.log('✓ WSL context injects correct message with distribution info');
-}
-/**
- * Test: Docker context injection
- */
-async function testDockerContextInjection() {
-    console.log('\nTest: Docker context injection');
-    const injector = new AIContextInjector();
-    const messages = [
-        { role: 'user', content: 'Check container' },
-    ];
-    const dockerContext = {
-        type: 'docker',
-        metadata: {
-            containerId: 'abc123def456',
-            workingDirectory: '/app',
-            shell: 'sh',
-            os: 'linux',
-        },
-        connectionState: 'connected',
-        sessionId: 'docker-session',
-    };
-    const result = injector.injectSubshellContext(messages, dockerContext);
-    // Should have one additional message
-    if (result.length !== 2) {
-        throw new Error('Expected 2 messages after injection');
-    }
-    const contextMessage = result[0];
-    const content = contextMessage.content;
-    if (!content.includes('DOCKER')) {
-        throw new Error('Expected context message to mention DOCKER');
-    }
-    if (!content.includes('abc123def456')) {
-        throw new Error('Expected context message to include container ID');
-    }
-    if (!content.includes('/app')) {
-        throw new Error('Expected context message to include working directory');
-    }
-    console.log('✓ Docker context injects correct message with container info');
-}
-/**
- * Test: Context message inserted before last user message
- */
-async function testContextMessagePosition() {
-    console.log('\nTest: Context message inserted before last user message');
-    const injector = new AIContextInjector();
-    const messages = [
-        { role: 'user', content: 'First message' },
-        { role: 'assistant', content: 'First response' },
-        { role: 'user', content: 'Second message' },
-        { role: 'assistant', content: 'Second response' },
-        { role: 'tool', content: 'Tool result' },
-        { role: 'user', content: 'Third message' },
-    ];
-    const sshContext = {
-        type: 'ssh',
-        metadata: {
-            hostname: 'server.com',
-            username: 'admin',
-            workingDirectory: '/root',
-            shell: 'zsh',
-            os: 'linux',
-        },
-        connectionState: 'connected',
-        sessionId: 'test-session',
-    };
-    const result = injector.injectSubshellContext(messages, sshContext);
-    // Should have 7 messages (6 original + 1 context)
-    if (result.length !== 7) {
-        throw new Error(`Expected 7 messages, got ${result.length}`);
-    }
-    // Context message should be at index 5 (before last user message at index 6)
-    const contextMessage = result[5];
-    if (contextMessage.role !== 'system') {
-        throw new Error('Expected context message at index 5');
-    }
-    // Last message should still be the user message
-    const lastMessage = result[6];
-    if (lastMessage.role !== 'user' || lastMessage.content !== 'Third message') {
-        throw new Error('Expected last message to be the original user message');
-    }
-    // Previous messages should be unchanged
-    if (result[0].content !== 'First message') {
-        throw new Error('Expected first message to be unchanged');
-    }
-    if (result[4].role !== 'tool') {
-        throw new Error('Expected tool message to remain at correct position');
-    }
-    console.log('✓ Context message inserted at correct position');
-}
-/**
- * Test: Context message when no user messages exist
- */
-async function testContextMessageNoUserMessages() {
-    console.log('\nTest: Context message when no user messages exist');
-    const injector = new AIContextInjector();
-    const messages = [
-        { role: 'system', content: 'System message' },
-        { role: 'assistant', content: 'Assistant message' },
-    ];
-    const sshContext = {
-        type: 'ssh',
-        metadata: {
-            hostname: 'test.com',
-            username: 'user',
-            workingDirectory: '/home/user',
-            shell: 'bash',
-            os: 'linux',
-        },
-        connectionState: 'connected',
-        sessionId: 'test-session',
-    };
-    const result = injector.injectSubshellContext(messages, sshContext);
-    // Should append context message to the end
-    if (result.length !== 3) {
-        throw new Error('Expected 3 messages');
-    }
-    const lastMessage = result[2];
-    if (lastMessage.role !== 'system') {
-        throw new Error('Expected context message to be appended');
-    }
-    console.log('✓ Context message appended when no user messages exist');
-}
-/**
- * Test: Important warning in context message
- */
-async function testContextMessageWarning() {
-    console.log('\nTest: Important warning in context message');
-    const injector = new AIContextInjector();
-    const messages = [
-        { role: 'user', content: 'Test' },
-    ];
-    const sshContext = {
-        type: 'ssh',
-        metadata: {
-            hostname: 'remote.com',
-            username: 'user',
-            workingDirectory: '/tmp',
-            shell: 'bash',
-            os: 'linux',
-        },
-        connectionState: 'connected',
-        sessionId: 'test-session',
-    };
-    const result = injector.injectSubshellContext(messages, sshContext);
-    const contextMessage = result[0];
-    const content = contextMessage.content;
-    // Should contain important warning about execution environment
-    if (!content.includes('IMPORTANT')) {
-        throw new Error('Expected context message to contain IMPORTANT warning');
-    }
-    if (!content.includes('not on the local machine')) {
-        throw new Error('Expected warning about remote execution');
-    }
-    if (!content.includes('ssh environment')) {
-        throw new Error('Expected mention of ssh environment in warning');
-    }
-    console.log('✓ Context message includes important warning');
-}
-/**
- * Run all tests
- */
-async function runTests() {
-    console.log('=== AI Context Injector Tests ===\n');
-    try {
-        await testLocalContextNoInjection();
-        await testSSHContextInjection();
-        await testWSLContextInjection();
-        await testDockerContextInjection();
-        await testContextMessagePosition();
-        await testContextMessageNoUserMessages();
-        await testContextMessageWarning();
-        console.log('\n=== All tests passed! ===');
-    }
-    catch (error) {
-        console.error('\n❌ Test failed:', error);
-        process.exit(1);
-    }
-}
-// Run tests if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    runTests();
-}
-export { runTests };

package/dist/test/services/ai-context-injector.js

@@ -1,96 +0,0 @@
-/**
- * AI Context Injector
- *
- * Injects subshell context into AI message history to make the AI aware
- * of the current execution environment (SSH, WSL, Docker, etc.)
- */
-/**
- * AI Context Injector class
- * Handles injection of subshell context into message history before AI calls
- */
-export class AIContextInjector {
-    /**
-     * Inject subshell context into message history
-     *
-     * If the current context is a subshell (not local), this method inserts
-     * a system message describing the environment before the last user message.
-     * This ensures the AI is aware of where commands will execute.
-     *
-     * @param messages - The conversation history
-     * @param context - The current subshell context
-     * @returns Modified message array with context injected (if applicable)
-     */
-    injectSubshellContext(messages, context) {
-        // Don't inject context for local environment
-        if (context.type === 'local') {
-            return messages;
-        }
-        // Build context message
-        const contextMessage = {
-            role: 'system',
-            content: this.buildContextMessage(context),
-        };
-        // Insert context message before the last user message
-        // This ensures the AI sees the context right before processing the request
-        const result = [...messages];
-        // Find the last user message index
-        let lastUserMessageIndex = -1;
-        for (let i = result.length - 1; i >= 0; i--) {
-            if (result[i].role === 'user') {
-                lastUserMessageIndex = i;
-                break;
-            }
-        }
-        // If we found a user message, insert context before it
-        // Otherwise, append to the end
-        if (lastUserMessageIndex >= 0) {
-            result.splice(lastUserMessageIndex, 0, contextMessage);
-        }
-        else {
-            result.push(contextMessage);
-        }
-        return result;
-    }
-    /**
-     * Build context message describing the current subshell environment
-     *
-     * Creates a formatted message that informs the AI about:
-     * - Environment type (SSH, WSL, Docker)
-     * - Working directory
-     * - Shell type
-     * - Operating system
-     * - Connection details (hostname, username, etc.)
-     *
-     * @param context - The current subshell context
-     * @returns Formatted context message string
-     */
-    buildContextMessage(context) {
-        const { type, metadata } = context;
-        let message = `\n\n## CURRENT EXECUTION ENVIRONMENT\n\n`;
-        message += `You are currently operating in a ${type.toUpperCase()} environment.\n\n`;
-        message += `**Environment Details:**\n`;
-        message += `- Type: ${type}\n`;
-        message += `- Working Directory: ${metadata.workingDirectory}\n`;
-        message += `- Shell: ${metadata.shell}\n`;
-        message += `- OS: ${metadata.os}\n`;
-        // Add type-specific details
-        if (metadata.hostname) {
-            message += `- Hostname: ${metadata.hostname}\n`;
-        }
-        if (metadata.username) {
-            message += `- Username: ${metadata.username}\n`;
-        }
-        if (metadata.distroName) {
-            message += `- Distribution: ${metadata.distroName}\n`;
-        }
-        if (metadata.containerId) {
-            message += `- Container: ${metadata.containerId}\n`;
-        }
-        if (metadata.port) {
-            message += `- Port: ${metadata.port}\n`;
-        }
-        message += `\n**IMPORTANT:** All commands and file operations you execute will run in this ${type} environment, not on the local machine.\n`;
-        message += `When reading files, writing files, executing commands, or performing any operations, they will all happen in the ${type} environment.\n`;
-        return message;
-    }
-}

package/dist/test/services/ai-service-client.js

@@ -1,270 +0,0 @@
-/**
- * AI Service Client
- *
- * Handles communication with the backend AI proxy service for streaming
- * AI chat requests. Replaces direct Gemini SDK usage in the CLI.
- */
-import { apiClient } from './api-client.js';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-/**
- * AI Service Client for streaming chat requests to backend
- */
-export class AIServiceClient {
-    constructor() {
-        this.maxRetries = 3;
-        this.retryDelay = 1000; // Start with 1 second
-        // Don't set baseURL yet - lazy load it when first used
-        // This allows environment variables to be loaded first
-        this.baseURL = '';
-    }
-    /**
-     * Get the base URL for API requests
-     * Lazy-loaded to ensure environment variables are loaded first
-     */
-    getBaseURL() {
-        if (!this.baseURL) {
-            // Use production URL by default, only use localhost in development mode
-            this.baseURL = process.env.DEV_MODE === 'true'
-                ? 'http://localhost:3002/api'
-                : (process.env.BACKEND_URL || 'https://centaurus-backend-354715948975.asia-south1.run.app/api');
-        }
-        return this.baseURL;
-    }
-    /**
-     * Stream chat request to backend AI proxy
-     *
-     * @param model - The AI model to use (e.g., 'gemini-2.5-flash')
-     * @param messages - Conversation history including system, user, assistant, and tool messages
-     * @param tools - Available tool schemas for the AI to use
-     * @param environmentContext - Optional environment context (OS, shell, cwd, etc.)
-     * @param mode - Optional mode (default, plan, command)
-     * @yields Stream chunks (text, tool calls, done, or error events)
-     */
-    async *streamChat(model, messages, tools, environmentContext, mode) {
-        // Build request payload
-        const payload = {
-            model,
-            messages,
-            tools,
-            stream: true,
-            environmentContext,
-            mode,
-        };
-        // Get authentication token from api client
-        if (!apiClient.isAuthenticated()) {
-            yield {
-                type: 'error',
-                message: 'Authentication required. Please sign in.',
-                code: 'AUTH_REQUIRED',
-            };
-            return;
-        }
-        // Retry logic for transient errors
-        let lastError = null;
-        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
-            try {
-                // Make fetch request to backend AI endpoint
-                const response = await fetch(`${this.getBaseURL()}/ai/chat`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.getSessionToken()}`,
-                    },
-                    body: JSON.stringify(payload),
-                    signal: AbortSignal.timeout(60000), // 60 second timeout
-                });
-                // Check for HTTP errors
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-                    let errorCode = 'HTTP_ERROR';
-                    try {
-                        const errorData = JSON.parse(errorText);
-                        if (errorData.error) {
-                            errorMessage = errorData.error.message || errorMessage;
-                            errorCode = errorData.error.code || errorCode;
-                        }
-                    }
-                    catch {
-                        // If response is not JSON, use the text as message
-                        if (errorText) {
-                            errorMessage = errorText;
-                        }
-                    }
-                    // Handle specific error codes
-                    if (response.status === 401) {
-                        yield {
-                            type: 'error',
-                            message: 'Session expired. Please sign in again.',
-                            code: 'AUTH_REQUIRED',
-                        };
-                        return;
-                    }
-                    if (response.status === 429) {
-                        // Rate limit - don't retry immediately
-                        yield {
-                            type: 'error',
-                            message: 'Service temporarily unavailable due to high demand. Please try again in a moment.',
-                            code: 'RATE_LIMIT',
-                        };
-                        return;
-                    }
-                    if (response.status === 504) {
-                        // Timeout error - retryable
-                        lastError = {
-                            type: 'error',
-                            message: 'Request timed out. Retrying...',
-                            code: 'TIMEOUT',
-                        };
-                        if (attempt < this.maxRetries - 1) {
-                            await this.sleep(this.retryDelay * Math.pow(2, attempt));
-                            continue;
-                        }
-                    }
-                    // For other errors, yield and return
-                    yield {
-                        type: 'error',
-                        message: errorMessage,
-                        code: errorCode,
-                    };
-                    return;
-                }
-                // Check if response body exists
-                if (!response.body) {
-                    yield {
-                        type: 'error',
-                        message: 'No response body from backend',
-                        code: 'NO_RESPONSE_BODY',
-                    };
-                    return;
-                }
-                // Parse SSE stream - if successful, we're done
-                yield* this.parseSSEStream(response.body);
-                return;
-            }
-            catch (error) {
-                // Handle network errors
-                if (error.name === 'TypeError' && error.message.includes('fetch')) {
-                    lastError = {
-                        type: 'error',
-                        message: 'Backend service is unreachable. Please check your connection.',
-                        code: 'NETWORK_ERROR',
-                    };
-                }
-                else if (error.name === 'AbortError' || error.name === 'TimeoutError') {
-                    lastError = {
-                        type: 'error',
-                        message: 'Request timed out. Please try again.',
-                        code: 'TIMEOUT',
-                    };
-                }
-                else {
-                    lastError = {
-                        type: 'error',
-                        message: error.message || 'Unknown error occurred',
-                        code: error.code || 'UNKNOWN_ERROR',
-                    };
-                }
-                // Retry for transient errors
-                if (this.isRetryableError(lastError.code) && attempt < this.maxRetries - 1) {
-                    await this.sleep(this.retryDelay * Math.pow(2, attempt));
-                    continue;
-                }
-                // If not retryable or max retries reached, yield error and return
-                break;
-            }
-        }
-        // If we get here, we've exhausted retries
-        if (lastError) {
-            yield lastError;
-        }
-    }
-    /**
-     * Check if an error code is retryable
-     */
-    isRetryableError(code) {
-        const retryableCodes = ['NETWORK_ERROR', 'TIMEOUT', 'UNKNOWN_ERROR'];
-        return retryableCodes.includes(code);
-    }
-    /**
-     * Sleep for specified milliseconds
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Get session token from apiClient
-     * This is a workaround since sessionToken is private
-     */
-    getSessionToken() {
-        // Read session token from the same location apiClient uses
-        const configPath = join(homedir(), '.centaurus', 'session.json');
-        try {
-            if (existsSync(configPath)) {
-                const data = readFileSync(configPath, 'utf-8');
-                const session = JSON.parse(data);
-                return session.sessionToken || '';
-            }
-        }
-        catch (error) {
-            // Return empty string if unable to read
-        }
-        return '';
-    }
-    /**
-     * Parse Server-Sent Events stream from response body
-     *
-     * @param body - ReadableStream from fetch response
-     * @yields Parsed stream chunks
-     */
-    async *parseSSEStream(body) {
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                // Decode chunk and add to buffer
-                buffer += decoder.decode(value, { stream: true });
-                // Process complete lines in buffer
-                const lines = buffer.split('\n');
-                // Keep the last incomplete line in buffer
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    // SSE format: "data: {json}"
-                    if (line.startsWith('data: ')) {
-                        const dataStr = line.slice(6); // Remove "data: " prefix
-                        // Skip empty data lines
-                        if (!dataStr.trim()) {
-                            continue;
-                        }
-                        try {
-                            const chunk = JSON.parse(dataStr);
-                            yield chunk;
-                            // Stop if we receive a done or error event
-                            if (chunk.type === 'done' || chunk.type === 'error') {
-                                return;
-                            }
-                        }
-                        catch (error) {
-                            // Skip malformed JSON
-                            console.error('Failed to parse SSE data:', dataStr);
-                        }
-                    }
-                    // SSE event type line: "event: chunk"
-                    // We don't need to process these separately since the data contains the type
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-}
-// Export singleton instance
-export const aiServiceClient = new AIServiceClient();