centaurus-cli 2.3.0 → 2.5.0

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

@@ -0,0 +1,270 @@
+/**
+ * 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();

package/dist/src/services/api-client.js

@@ -0,0 +1,349 @@
+/**
+ * API Client Service for Centaurus CLI
+ *
+ * Handles all communication with the backend REST API including:
+ * - Authentication and session management
+ * - Conversation and message operations
+ * - User settings management
+ * - API key storage and retrieval
+ */
+import axios from 'axios';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+/**
+ * API Client class for communicating with the backend service
+ */
+class ApiClient {
+    constructor() {
+        this.client = null;
+        this.sessionToken = null;
+        // Set up session storage path: ~/.centaurus/session.json
+        this.configDir = join(homedir(), '.centaurus');
+        this.configPath = join(this.configDir, 'session.json');
+        // Load existing session if available
+        this.loadSession();
+        // Don't create axios client yet - wait until first use
+        // This allows environment variables to be loaded first
+    }
+    /**
+     * Get or create the axios client instance
+     * This is lazy-loaded to ensure environment variables are loaded first
+     */
+    getClient() {
+        if (!this.client) {
+            // Create axios instance with base configuration
+            // Use production URL by default, only use localhost in development mode
+            const baseURL = process.env.DEV_MODE === 'true'
+                ? 'http://localhost:3002/api'
+                : (process.env.BACKEND_URL || 'https://centaurus-backend-354715948975.asia-south1.run.app/api');
+            this.client = axios.create({
+                baseURL,
+                timeout: 30000,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            // Request interceptor: Add Authorization header if session token exists
+            this.getClient().interceptors.request.use((config) => {
+                if (this.sessionToken) {
+                    config.headers.Authorization = `Bearer ${this.sessionToken}`;
+                }
+                return config;
+            }, (error) => {
+                return Promise.reject(error);
+            });
+            // Response interceptor: Handle 401 errors (expired/invalid session)
+            this.getClient().interceptors.response.use((response) => response, async (error) => {
+                if (error.response?.status === 401) {
+                    // Clear invalid session
+                    this.clearSession();
+                    // Create a more user-friendly error
+                    const authError = new Error('Session expired. Please sign in again.');
+                    authError.name = 'AuthenticationError';
+                    throw authError;
+                }
+                // For other errors, extract message from API response if available
+                if (error.response?.data) {
+                    const apiError = error.response.data;
+                    if (apiError.error) {
+                        const customError = new Error(apiError.error.message);
+                        customError.name = apiError.error.code;
+                        throw customError;
+                    }
+                }
+                throw error;
+            });
+        }
+        return this.client;
+    }
+    /**
+     * Load session token from local config file
+     */
+    loadSession() {
+        try {
+            if (existsSync(this.configPath)) {
+                const data = readFileSync(this.configPath, 'utf-8');
+                const session = JSON.parse(data);
+                this.sessionToken = session.sessionToken || null;
+            }
+        }
+        catch (error) {
+            // If there's any error reading the session, just start fresh
+            this.sessionToken = null;
+        }
+    }
+    /**
+     * Save session token to local config file
+     */
+    saveSession(token, expiresAt) {
+        try {
+            // Ensure config directory exists
+            if (!existsSync(this.configDir)) {
+                mkdirSync(this.configDir, { recursive: true });
+            }
+            // Save session data
+            const sessionData = {
+                sessionToken: token,
+                expiresAt: expiresAt || null,
+                savedAt: new Date().toISOString(),
+            };
+            writeFileSync(this.configPath, JSON.stringify(sessionData, null, 2), 'utf-8');
+            this.sessionToken = token;
+        }
+        catch (error) {
+            console.error('Failed to save session:', error);
+            throw new Error('Failed to save session locally');
+        }
+    }
+    /**
+     * Clear session token from memory and local storage
+     */
+    clearSession() {
+        this.sessionToken = null;
+        try {
+            if (existsSync(this.configPath)) {
+                unlinkSync(this.configPath);
+            }
+        }
+        catch (error) {
+            // Ignore errors when clearing session
+        }
+    }
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated() {
+        return this.sessionToken !== null;
+    }
+    // ==================== Authentication Methods ====================
+    /**
+     * Initialize Google OAuth flow
+     * @param redirectUri - The URI to redirect to after OAuth
+     * @returns OAuth URL and state parameter
+     */
+    async initGoogleAuth(redirectUri) {
+        const response = await this.getClient().post('/auth/google/init', { redirectUri });
+        return response.data.data;
+    }
+    /**
+     * Complete Google OAuth authentication
+     * @param code - Authorization code from Google
+     * @param state - State parameter for CSRF protection
+     * @returns Session token and user information
+     */
+    async authenticate(code, state) {
+        const response = await this.getClient().post('/auth/google/callback', { code, state });
+        const authData = response.data.data;
+        this.saveSession(authData.sessionToken, authData.expiresAt);
+        return authData;
+    }
+    /**
+     * Set session token directly (used when receiving token from web app)
+     * @param sessionToken - The session token to save
+     * @param user - User information
+     */
+    setSessionToken(sessionToken, user) {
+        // Calculate expiration (30 days from now)
+        const expiresAt = new Date();
+        expiresAt.setDate(expiresAt.getDate() + 30);
+        this.saveSession(sessionToken, expiresAt.toISOString());
+    }
+    /**
+     * Refresh the current session token
+     * @returns New session token and expiration
+     */
+    async refreshSession() {
+        const response = await this.getClient().post('/auth/refresh');
+        const refreshData = response.data.data;
+        this.saveSession(refreshData.sessionToken, refreshData.expiresAt);
+        return refreshData;
+    }
+    /**
+     * Logout and invalidate current session
+     */
+    async logout() {
+        try {
+            await this.getClient().post('/auth/logout');
+        }
+        finally {
+            // Always clear local session, even if API call fails
+            this.clearSession();
+        }
+    }
+    /**
+     * Get current authenticated user profile
+     * @returns User profile information
+     */
+    async getCurrentUser() {
+        const response = await this.getClient().get('/auth/me');
+        return response.data.data;
+    }
+    // ==================== Conversation Methods ====================
+    /**
+     * Create a new conversation
+     * @param data - Conversation creation parameters
+     * @returns Created conversation
+     */
+    async createConversation(data) {
+        const response = await this.getClient().post('/conversations', data);
+        return response.data.data;
+    }
+    /**
+     * Get all conversations for the authenticated user
+     * @param params - Pagination and filter parameters
+     * @returns List of conversations with pagination metadata
+     */
+    async getConversations(params) {
+        const queryParams = {
+            page: params?.page || 1,
+            limit: params?.limit || 20,
+        };
+        if (params?.includeArchived !== undefined) {
+            queryParams.includeArchived = params.includeArchived;
+        }
+        if (params?.tags && params.tags.length > 0) {
+            queryParams.tags = params.tags.join(',');
+        }
+        const response = await this.getClient().get('/conversations', { params: queryParams });
+        return response.data;
+    }
+    /**
+     * Get a specific conversation by ID
+     * @param conversationId - The conversation ID
+     * @returns Conversation details
+     */
+    async getConversation(conversationId) {
+        const response = await this.getClient().get(`/conversations/${conversationId}`);
+        return response.data.data;
+    }
+    /**
+     * Update a conversation
+     * @param conversationId - The conversation ID
+     * @param data - Fields to update
+     * @returns Updated conversation
+     */
+    async updateConversation(conversationId, data) {
+        const response = await this.getClient().put(`/conversations/${conversationId}`, data);
+        return response.data.data;
+    }
+    /**
+     * Delete (archive) a conversation
+     * @param conversationId - The conversation ID
+     */
+    async deleteConversation(conversationId) {
+        await this.getClient().delete(`/conversations/${conversationId}`);
+    }
+    // ==================== Message Methods ====================
+    /**
+     * Add a message to a conversation
+     * @param conversationId - The conversation ID
+     * @param message - Message data
+     * @returns Created message
+     */
+    async addMessage(conversationId, message) {
+        const response = await this.getClient().post(`/conversations/${conversationId}/messages`, message);
+        return response.data.data;
+    }
+    /**
+     * Get all messages for a conversation
+     * @param conversationId - The conversation ID
+     * @param params - Pagination parameters
+     * @returns List of messages with pagination metadata
+     */
+    async getMessages(conversationId, params) {
+        const queryParams = {
+            page: params?.page || 1,
+            limit: params?.limit || 50,
+        };
+        const response = await this.getClient().get(`/conversations/${conversationId}/messages`, { params: queryParams });
+        return response.data;
+    }
+    // ==================== Settings Methods ====================
+    /**
+     * Get user settings
+     * @returns User settings object
+     */
+    async getSettings() {
+        const response = await this.getClient().get('/settings');
+        return response.data.data;
+    }
+    /**
+     * Update user settings
+     * @param settings - Settings to update (partial update supported)
+     * @returns Updated settings
+     */
+    async updateSettings(settings) {
+        const response = await this.getClient().put('/settings', settings);
+        return response.data.data;
+    }
+    // ==================== API Key Methods ====================
+    /**
+     * Store an encrypted API key
+     * @param data - API key data including provider, name, and key value
+     * @returns API key metadata (without the actual key)
+     */
+    async storeApiKey(data) {
+        const response = await this.getClient().post('/api-keys', data);
+        return response.data.data;
+    }
+    /**
+     * Get all API keys (metadata only, not actual keys)
+     * @returns List of API key metadata
+     */
+    async getApiKeys() {
+        const response = await this.getClient().get('/api-keys');
+        return response.data.data;
+    }
+    /**
+     * Decrypt and retrieve an API key for a specific provider
+     * @param provider - The provider name
+     * @returns Decrypted API key
+     */
+    async decryptApiKey(provider) {
+        const response = await this.getClient().get(`/api-keys/${provider}/decrypt`);
+        return response.data.data;
+    }
+    /**
+     * Delete an API key
+     * @param keyId - The API key ID
+     */
+    async deleteApiKey(keyId) {
+        await this.getClient().delete(`/api-keys/${keyId}`);
+    }
+    // ==================== Health Check ====================
+    /**
+     * Check backend service health
+     * @returns Health status information
+     */
+    async healthCheck() {
+        // Health endpoint is at root level, not under /api
+        // So we need to construct the full URL manually
+        const baseURL = process.env.BACKEND_API_URL || 'http://localhost:3000/api';
+        const healthURL = baseURL.replace('/api', '/health');
+        const response = await axios.get(healthURL);
+        return response.data.data;
+    }
+}
+// Export singleton instance
+export const apiClient = new ApiClient();

package/dist/src/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/test/context/types.js

@@ -0,0 +1,27 @@
+/**
+ * Core types for the subshell context management system
+ */
+/**
+ * Error thrown when a subshell connection fails
+ */
+export class SubshellConnectionError extends Error {
+    constructor(type, reason, recoverable) {
+        super(`${type} connection failed: ${reason}`);
+        this.type = type;
+        this.reason = reason;
+        this.recoverable = recoverable;
+        this.name = 'SubshellConnectionError';
+    }
+}
+/**
+ * Error thrown when a subshell command execution fails
+ */
+export class SubshellExecutionError extends Error {
+    constructor(command, reason, exitCode) {
+        super(`Command execution failed: ${reason}`);
+        this.command = command;
+        this.reason = reason;
+        this.exitCode = exitCode;
+        this.name = 'SubshellExecutionError';
+    }
+}