@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/clients/llm-client.js

@@ -0,0 +1,119 @@
+/**
+ * LLM Client
+ *
+ * WebSocket client for streaming LLM responses from the LLM Service
+ */
+import { WebSocketClient, WebSocketURLs } from '.';
+/**
+ * LLM Client for streaming chat completions
+ */
+export class LLMClient {
+    wsUrl;
+    constructor(wsUrl) {
+        this.wsUrl = wsUrl || WebSocketURLs.LLM;
+    }
+    /**
+     * Stream a chat completion
+     * @param messages - Array of chat messages
+     * @param options - Chat options (model, taskType)
+     * @returns AsyncGenerator yielding StreamingChunk objects
+     */
+    async *streamChat(messages, options = {}) {
+        const ws = new WebSocketClient(this.wsUrl, {
+            reconnect: false, // Don't reconnect for single requests
+        });
+        const messageQueue = [];
+        let done = false;
+        let error = null;
+        let resolveWaiting = null;
+        // Set up message handler
+        const removeMessageHandler = ws.onMessage((data) => {
+            messageQueue.push(data);
+            if (data.type === 'done' || data.type === 'error') {
+                done = true;
+                if (data.type === 'error') {
+                    error = new Error(data.message || data.error || 'Unknown error');
+                }
+            }
+            // Wake up the generator if it's waiting
+            if (resolveWaiting) {
+                resolveWaiting();
+                resolveWaiting = null;
+            }
+        });
+        const removeErrorHandler = ws.onError(() => {
+            error = new Error('WebSocket connection failed');
+            done = true;
+            if (resolveWaiting) {
+                resolveWaiting();
+                resolveWaiting = null;
+            }
+        });
+        const removeCloseHandler = ws.onClose(() => {
+            done = true;
+            if (resolveWaiting) {
+                resolveWaiting();
+                resolveWaiting = null;
+            }
+        });
+        try {
+            // Connect to WebSocket
+            await ws.connect();
+            // Send the chat request
+            ws.send({
+                messages,
+                model: options.model,
+                taskType: options.taskType,
+            });
+            // Yield chunks as they arrive
+            while (!done || messageQueue.length > 0) {
+                if (messageQueue.length > 0) {
+                    const chunk = messageQueue.shift();
+                    yield chunk;
+                }
+                else if (!done) {
+                    // Wait for more messages
+                    await new Promise(resolve => {
+                        resolveWaiting = resolve;
+                    });
+                }
+            }
+            if (error) {
+                throw error;
+            }
+        }
+        finally {
+            // Clean up
+            removeMessageHandler();
+            removeErrorHandler();
+            removeCloseHandler();
+            ws.close();
+        }
+    }
+    /**
+     * Send a single chat message and get streaming response
+     * Convenience method that builds the messages array
+     */
+    async *chat(userMessage, history = [], options = {}) {
+        const messages = [...history, { role: 'user', content: userMessage }];
+        yield* this.streamChat(messages, options);
+    }
+    /**
+     * Check if LLM service is available
+     */
+    async isAvailable() {
+        try {
+            // Use HTTP health check endpoint
+            const httpUrl = this.wsUrl.replace('ws://', 'http://').replace('wss://', 'https://');
+            const response = await fetch(`${httpUrl}/health`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// Export singleton instance
+export const llmClient = new LLMClient();

package/dist/src/clients/rest-client.js

@@ -0,0 +1,104 @@
+import { logger, ServiceUnavailableError, TimeoutError, getServiceAuthHeaders } from '../utils';
+/**
+ * REST Client for inter-service communication
+ */
+export class RestClient {
+    baseUrl;
+    timeout;
+    headers;
+    retries;
+    constructor(baseUrl, options = {}) {
+        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.timeout = options.timeout || 30000;
+        this.headers = {
+            'Content-Type': 'application/json',
+            ...getServiceAuthHeaders(),
+            ...options.headers,
+        };
+        this.retries = options.retries || 0;
+    }
+    async get(path) {
+        return this.request('GET', path);
+    }
+    async post(path, body) {
+        return this.request('POST', path, body);
+    }
+    async put(path, body) {
+        return this.request('PUT', path, body);
+    }
+    async delete(path) {
+        return this.request('DELETE', path);
+    }
+    async request(method, path, body, attempt = 0) {
+        const url = `${this.baseUrl}${path}`;
+        try {
+            logger.debug(`${method} ${url}`);
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+            const response = await fetch(url, {
+                method,
+                headers: this.headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const error = await response.text();
+                return {
+                    success: false,
+                    error: {
+                        code: `HTTP_${response.status}`,
+                        message: error || response.statusText,
+                        service: this.baseUrl,
+                        timestamp: new Date().toISOString(),
+                    },
+                };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                data: data,
+            };
+        }
+        catch (error) {
+            // Handle abort (timeout)
+            if (error.name === 'AbortError') {
+                if (attempt < this.retries) {
+                    logger.warn(`Request timeout, retrying (${attempt + 1}/${this.retries})...`);
+                    return this.request(method, path, body, attempt + 1);
+                }
+                throw new TimeoutError(`${method} ${path}`, this.baseUrl, this.timeout);
+            }
+            // Handle connection errors
+            if (error.code === 'ECONNREFUSED' || error.cause?.code === 'ECONNREFUSED') {
+                throw new ServiceUnavailableError(this.baseUrl, {
+                    url,
+                    error: error.message,
+                });
+            }
+            // Other errors
+            return {
+                success: false,
+                error: {
+                    code: 'REQUEST_ERROR',
+                    message: error.message || 'Unknown error',
+                    service: this.baseUrl,
+                    timestamp: new Date().toISOString(),
+                    details: error,
+                },
+            };
+        }
+    }
+    /**
+     * Health check helper
+     */
+    async healthCheck() {
+        try {
+            const response = await this.get('/health');
+            return response.success;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/src/clients/service-discovery.js

@@ -0,0 +1,35 @@
+/**
+ * Service Discovery (stub)
+ *
+ * Previously held URLs for 18 microservices. Nimbus is now a standalone binary —
+ * all services run in-process. These constants are kept for legacy import
+ * compatibility only. No HTTP services listen on these ports.
+ */
+function getEnvOrDefault(key, defaultVal) {
+    return process.env[key] ?? defaultVal;
+}
+export const ServiceURLs = {
+    CLI: getEnvOrDefault('CLI_SERVICE_URL', 'http://localhost:3000'),
+    CORE_ENGINE: getEnvOrDefault('CORE_ENGINE_SERVICE_URL', 'http://localhost:3001'),
+    LLM: getEnvOrDefault('LLM_SERVICE_URL', 'http://localhost:3002'),
+    GENERATOR: getEnvOrDefault('GENERATOR_SERVICE_URL', 'http://localhost:3003'),
+    GIT_TOOLS: getEnvOrDefault('GIT_TOOLS_SERVICE_URL', 'http://localhost:3004'),
+    FS_TOOLS: getEnvOrDefault('FS_TOOLS_SERVICE_URL', 'http://localhost:3005'),
+    TERRAFORM_TOOLS: getEnvOrDefault('TERRAFORM_TOOLS_SERVICE_URL', 'http://localhost:3006'),
+    K8S_TOOLS: getEnvOrDefault('K8S_TOOLS_SERVICE_URL', 'http://localhost:3007'),
+    HELM_TOOLS: getEnvOrDefault('HELM_TOOLS_SERVICE_URL', 'http://localhost:3008'),
+    AWS_TOOLS: getEnvOrDefault('AWS_TOOLS_SERVICE_URL', 'http://localhost:3009'),
+    GITHUB_TOOLS: getEnvOrDefault('GITHUB_TOOLS_SERVICE_URL', 'http://localhost:3010'),
+    STATE: getEnvOrDefault('STATE_SERVICE_URL', 'http://localhost:3011'),
+    AUTH: getEnvOrDefault('AUTH_SERVICE_URL', 'http://localhost:3012'),
+    TEAM: getEnvOrDefault('TEAM_SERVICE_URL', 'http://localhost:3013'),
+    BILLING: getEnvOrDefault('BILLING_SERVICE_URL', 'http://localhost:3014'),
+    AUDIT: getEnvOrDefault('AUDIT_SERVICE_URL', 'http://localhost:3015'),
+    GCP_TOOLS: getEnvOrDefault('GCP_TOOLS_URL', 'http://localhost:3016'),
+    AZURE_TOOLS: getEnvOrDefault('AZURE_TOOLS_URL', 'http://localhost:3017'),
+};
+export const WebSocketURLs = {
+    CORE_ENGINE: getEnvOrDefault('CORE_ENGINE_WS_URL', 'ws://localhost:3101'),
+    LLM: getEnvOrDefault('LLM_WS_URL', 'ws://localhost:3102'),
+    GENERATOR: getEnvOrDefault('GENERATOR_WS_URL', 'ws://localhost:3103'),
+};

package/dist/src/clients/terraform-client.js

@@ -0,0 +1,302 @@
+/**
+ * Terraform Tools Client
+ *
+ * REST client for communicating with the Terraform Tools Service
+ */
+import { RestClient, ServiceURLs } from '.';
+/**
+ * Client for Terraform Tools Service
+ */
+export class TerraformClient {
+    client;
+    constructor(baseUrl) {
+        this.client = new RestClient(baseUrl || ServiceURLs.TERRAFORM_TOOLS);
+    }
+    /**
+     * Initialize a Terraform working directory
+     */
+    async init(directory) {
+        const response = await this.client.post('/api/terraform/init', {
+            directory,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Generate a Terraform execution plan
+     */
+    async plan(directory, options) {
+        const response = await this.client.post('/api/terraform/plan', {
+            directory,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return {
+            success: false,
+            output: '',
+            hasChanges: false,
+            error: response.error?.message || 'Unknown error',
+        };
+    }
+    /**
+     * Apply Terraform changes
+     */
+    async apply(directory, options) {
+        const response = await this.client.post('/api/terraform/apply', {
+            directory,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Validate Terraform configuration
+     */
+    async validate(directory) {
+        const response = await this.client.post('/api/terraform/validate', {
+            directory,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { valid: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Destroy Terraform-managed infrastructure
+     */
+    async destroy(directory, options) {
+        const response = await this.client.post('/api/terraform/destroy', {
+            directory,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Show Terraform state
+     */
+    async show(directory) {
+        const response = await this.client.post('/api/terraform/show', { directory });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '' };
+    }
+    /**
+     * Format Terraform configuration files
+     */
+    async fmt(directory, options) {
+        const response = await this.client.post('/api/terraform/fmt', {
+            workingDir: directory,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Manage Terraform workspaces
+     */
+    workspace = {
+        list: async (directory) => {
+            const params = new URLSearchParams();
+            params.set('workingDir', directory);
+            const response = await this.client.get(`/api/terraform/workspace/list?${params.toString()}`);
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+        select: async (name, directory) => {
+            const response = await this.client.post('/api/terraform/workspace/select', { name, workingDir: directory });
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+        new: async (name, directory) => {
+            const response = await this.client.post('/api/terraform/workspace/new', { name, workingDir: directory });
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+        delete: async (name, directory) => {
+            const response = await this.client.post('/api/terraform/workspace/delete', { name, workingDir: directory });
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+    };
+    /**
+     * Import existing infrastructure into Terraform state
+     */
+    async import(directory, address, id) {
+        const response = await this.client.post('/api/terraform/import', {
+            workingDir: directory,
+            address,
+            id,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Manage Terraform state
+     */
+    state = {
+        list: async (directory) => {
+            const params = new URLSearchParams();
+            params.set('workingDir', directory);
+            const response = await this.client.get(`/api/terraform/state/list?${params.toString()}`);
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+        show: async (address, directory) => {
+            const params = new URLSearchParams();
+            params.set('address', address);
+            params.set('workingDir', directory);
+            const response = await this.client.get(`/api/terraform/state/show?${params.toString()}`);
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+        mv: async (directory, source, destination) => {
+            const response = await this.client.post('/api/terraform/state/mv', {
+                directory,
+                source,
+                destination,
+            });
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+        pull: async (directory) => {
+            const params = new URLSearchParams();
+            params.set('directory', directory);
+            const response = await this.client.get(`/api/terraform/state/pull?${params.toString()}`);
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+        push: async (directory, options) => {
+            const response = await this.client.post('/api/terraform/state/push', {
+                directory,
+                ...options,
+            });
+            if (response.success && response.data) {
+                return response.data;
+            }
+            return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+        },
+    };
+    /**
+     * Taint a resource, marking it for recreation on next apply
+     */
+    async taint(directory, address) {
+        const response = await this.client.post('/api/terraform/taint', {
+            directory,
+            address,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Untaint a resource, removing the taint mark
+     */
+    async untaint(directory, address) {
+        const response = await this.client.post('/api/terraform/untaint', {
+            directory,
+            address,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Generate a resource dependency graph in DOT format
+     */
+    async graph(directory, options) {
+        const params = new URLSearchParams();
+        params.set('directory', directory);
+        if (options?.type) {
+            params.set('type', options.type);
+        }
+        const response = await this.client.get(`/api/terraform/graph?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Force unlock a locked state
+     */
+    async forceUnlock(directory, lockId) {
+        const response = await this.client.post('/api/terraform/force-unlock', { directory, lockId });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Refresh Terraform state against real infrastructure
+     */
+    async refresh(directory, options) {
+        const response = await this.client.post('/api/terraform/refresh', {
+            directory,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Show Terraform output values
+     */
+    async output(directory, name) {
+        const params = new URLSearchParams();
+        params.set('workingDir', directory);
+        if (name) {
+            params.set('name', name);
+        }
+        const query = params.toString() ? `?${params.toString()}` : '';
+        const response = await this.client.get(`/api/terraform/output${query}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Check if service is available
+     */
+    async isAvailable() {
+        try {
+            const response = await this.client.get('/health');
+            return response.success && response.data?.status === 'healthy';
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export const terraformClient = new TerraformClient();