@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/clients/core-engine-client.js

@@ -0,0 +1,156 @@
+/**
+ * Core Engine Client
+ *
+ * Client for interacting with the Core Engine Service
+ */
+export class CoreEngineClient {
+    baseUrl;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl || process.env.CORE_ENGINE_URL || 'http://localhost:3010';
+    }
+    /**
+     * Detect drift in infrastructure
+     */
+    async detectDrift(params) {
+        const response = await fetch(`${this.baseUrl}/api/drift/detect`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(params),
+        });
+        if (!response.ok) {
+            const error = (await response.json().catch(() => ({ message: 'Unknown error' })));
+            throw new Error(error.message || `Failed to detect drift: ${response.status}`);
+        }
+        const data = (await response.json());
+        return data.report;
+    }
+    /**
+     * Create a remediation plan for detected drift
+     */
+    async createRemediationPlan(params) {
+        const response = await fetch(`${this.baseUrl}/api/drift/plan`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(params),
+        });
+        if (!response.ok) {
+            const error = (await response.json().catch(() => ({ message: 'Unknown error' })));
+            throw new Error(error.message || `Failed to create remediation plan: ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Fix detected drift
+     */
+    async fixDrift(params) {
+        const response = await fetch(`${this.baseUrl}/api/drift/fix`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(params),
+        });
+        if (!response.ok) {
+            const error = (await response.json().catch(() => ({ message: 'Unknown error' })));
+            throw new Error(error.message || `Failed to fix drift: ${response.status}`);
+        }
+        const data = (await response.json());
+        return data.result;
+    }
+    /**
+     * Check if a task can be rolled back
+     */
+    async canRollback(taskId) {
+        const response = await fetch(`${this.baseUrl}/api/tasks/${taskId}/rollback/check`, {
+            method: 'GET',
+        });
+        if (!response.ok) {
+            return false;
+        }
+        const data = (await response.json());
+        return data.canRollback;
+    }
+    /**
+     * Rollback a task
+     */
+    async rollback(params) {
+        const response = await fetch(`${this.baseUrl}/api/tasks/${params.taskId}/rollback`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ force: params.force }),
+        });
+        if (!response.ok) {
+            const error = (await response.json().catch(() => ({ message: 'Unknown error' })));
+            throw new Error(error.message || `Failed to rollback: ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Resume a task from its last checkpoint
+     */
+    async resumeTask(taskId) {
+        const response = await fetch(`${this.baseUrl}/api/tasks/${taskId}/resume`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const error = (await response.json().catch(() => ({ message: 'Unknown error' })));
+            return {
+                success: false,
+                error: error.error || error.message || `Failed to resume task: ${response.status}`,
+            };
+        }
+        const data = (await response.json());
+        return {
+            success: data.success,
+            data: data.data,
+            error: data.error,
+        };
+    }
+    /**
+     * Get compliance report
+     */
+    async getComplianceReport(params) {
+        const response = await fetch(`${this.baseUrl}/api/drift/compliance`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(params),
+        });
+        if (!response.ok) {
+            const error = (await response.json().catch(() => ({ message: 'Unknown error' })));
+            throw new Error(error.message || `Failed to get compliance report: ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Check if the Core Engine service is available
+     */
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.baseUrl}/health`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(5000),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Health check (alias for isAvailable)
+     */
+    async healthCheck() {
+        return this.isAvailable();
+    }
+}

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

@@ -0,0 +1,246 @@
+/**
+ * Enterprise API Clients
+ * Clients for auth, team, billing, and audit services
+ */
+import { RestClient, ServiceURLs } from '.';
+import { logger } from '../utils';
+// ==================== Auth Client ====================
+export class AuthClient {
+    client;
+    constructor() {
+        this.client = new RestClient(ServiceURLs.AUTH);
+    }
+    async initiateDeviceFlow() {
+        const response = await this.client.post('/api/auth/device/initiate');
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to initiate device flow');
+        }
+        return response.data;
+    }
+    async pollDeviceCode(deviceCode) {
+        const response = await this.client.get(`/api/auth/device/poll/${deviceCode}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to poll device code');
+        }
+        return response.data;
+    }
+    async verifyDeviceCode(userCode, userId) {
+        const response = await this.client.post('/api/auth/device/verify', {
+            userCode,
+            userId,
+        });
+        return response.success && response.data?.verified === true;
+    }
+    async validateToken(accessToken) {
+        const response = await this.client.post('/api/auth/token/validate', {
+            accessToken,
+        });
+        if (!response.success || !response.data) {
+            return { valid: false };
+        }
+        return response.data;
+    }
+}
+// ==================== Team Client ====================
+export class TeamClient {
+    client;
+    constructor() {
+        this.client = new RestClient(ServiceURLs.TEAM);
+    }
+    async createTeam(request) {
+        const response = await this.client.post('/api/team/teams', request);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to create team');
+        }
+        return response.data;
+    }
+    async getTeam(teamId) {
+        const response = await this.client.get(`/api/team/teams/${teamId}`);
+        if (!response.success) {
+            return null;
+        }
+        return response.data || null;
+    }
+    async listTeams(userId) {
+        const response = await this.client.get(`/api/team/teams?userId=${userId}`);
+        if (!response.success || !response.data) {
+            logger.warn('Failed to list teams; returning empty list', {
+                userId,
+                error: response.error?.message,
+            });
+            return [];
+        }
+        return response.data;
+    }
+    async deleteTeam(teamId) {
+        const response = await this.client.delete(`/api/team/teams/${teamId}`);
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to delete team');
+        }
+    }
+    async inviteMember(teamId, request) {
+        const response = await this.client.post(`/api/team/teams/${teamId}/members`, request);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to invite member');
+        }
+        return response.data;
+    }
+    async listMembers(teamId) {
+        const response = await this.client.get(`/api/team/teams/${teamId}/members`);
+        if (!response.success || !response.data) {
+            logger.warn('Failed to list team members; returning empty list', {
+                teamId,
+                error: response.error?.message,
+            });
+            return [];
+        }
+        return response.data;
+    }
+    async removeMember(teamId, userId) {
+        const response = await this.client.delete(`/api/team/teams/${teamId}/members/${userId}`);
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to remove member');
+        }
+    }
+    async updateMemberRole(teamId, userId, role) {
+        const response = await this.client.put(`/api/team/teams/${teamId}/members/${userId}`, { role });
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to update member role');
+        }
+        return response.data;
+    }
+}
+// ==================== Billing Client ====================
+export class BillingClient {
+    client;
+    constructor() {
+        this.client = new RestClient(ServiceURLs.BILLING);
+    }
+    async getStatus(teamId) {
+        const response = await this.client.get(`/api/billing/status?teamId=${teamId}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to get billing status');
+        }
+        return response.data;
+    }
+    async subscribe(teamId, request) {
+        const response = await this.client.post('/api/billing/subscribe', {
+            ...request,
+            teamId,
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to subscribe');
+        }
+        return response.data;
+    }
+    async cancel(teamId) {
+        const response = await this.client.post('/api/billing/cancel', { teamId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to cancel subscription');
+        }
+        return response.data;
+    }
+    async getUsage(teamId, period = 'month') {
+        const response = await this.client.get(`/api/billing/usage?teamId=${teamId}&period=${period}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to get usage');
+        }
+        return response.data;
+    }
+    async getInvoices(teamId, limit = 10) {
+        const response = await this.client.get(`/api/billing/invoices?teamId=${teamId}&limit=${limit}`);
+        if (!response.success || !response.data) {
+            logger.warn('Failed to fetch invoices; returning empty list', {
+                teamId,
+                error: response.error?.message,
+            });
+            return [];
+        }
+        return response.data;
+    }
+    async recordUsage(teamId, operationType, tokensUsed, costUsd, userId) {
+        await this.client.post('/api/billing/usage', {
+            teamId,
+            userId,
+            operationType,
+            tokensUsed,
+            costUsd,
+        });
+    }
+}
+// ==================== Audit Client ====================
+export class AuditClient {
+    client;
+    constructor() {
+        this.client = new RestClient(ServiceURLs.AUDIT);
+    }
+    async createLog(request) {
+        const response = await this.client.post('/api/audit/logs', request);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to create audit log');
+        }
+        return response.data;
+    }
+    async queryLogs(query = {}) {
+        const params = new URLSearchParams();
+        if (query.teamId) {
+            params.set('teamId', query.teamId);
+        }
+        if (query.userId) {
+            params.set('userId', query.userId);
+        }
+        if (query.action) {
+            params.set('action', query.action);
+        }
+        if (query.status) {
+            params.set('status', query.status);
+        }
+        if (query.since) {
+            params.set('since', query.since);
+        }
+        if (query.until) {
+            params.set('until', query.until);
+        }
+        if (query.limit) {
+            params.set('limit', query.limit.toString());
+        }
+        if (query.offset) {
+            params.set('offset', query.offset.toString());
+        }
+        const response = await this.client.get(`/api/audit/logs?${params}`);
+        if (!response.success || !response.data) {
+            return { logs: [], total: 0, limit: 100, offset: 0 };
+        }
+        return response.data;
+    }
+    async exportLogs(format, query = {}) {
+        const params = new URLSearchParams();
+        params.set('format', format);
+        if (query.teamId) {
+            params.set('teamId', query.teamId);
+        }
+        if (query.userId) {
+            params.set('userId', query.userId);
+        }
+        if (query.action) {
+            params.set('action', query.action);
+        }
+        if (query.since) {
+            params.set('since', query.since);
+        }
+        if (query.until) {
+            params.set('until', query.until);
+        }
+        const url = `${ServiceURLs.AUDIT}/api/audit/export?${params}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error('Failed to export audit logs');
+        }
+        return response.text();
+    }
+}
+// ==================== Singleton Instances ====================
+export const authClient = new AuthClient();
+export const teamClient = new TeamClient();
+export const billingClient = new BillingClient();
+export const auditClient = new AuditClient();

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

@@ -0,0 +1,219 @@
+/**
+ * Generator Service Client
+ *
+ * CLI client for communicating with the Generator Service
+ * for conversational IaC generation
+ */
+export class GeneratorClient {
+    baseUrl;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl || process.env.GENERATOR_SERVICE_URL || 'http://localhost:3003';
+    }
+    /**
+     * Check if the generator service is available
+     */
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.baseUrl}/health`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(5000),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Process a conversational message
+     * Sends user message to the generator service and gets response with intent detection
+     */
+    async processConversation(sessionId, message, userId) {
+        const response = await fetch(`${this.baseUrl}/api/conversational/message`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ sessionId, message, userId }),
+        });
+        if (!response.ok) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (!data.success) {
+            throw new Error(data.error || 'Failed to process conversation');
+        }
+        const result = data.data;
+        // Determine if we can generate (have enough information)
+        const canGenerate = result.intent?.type === 'generate' &&
+            (!result.needs_clarification || result.needs_clarification.length === 0) &&
+            result.extracted_requirements?.components?.length > 0;
+        return {
+            message: result.message,
+            intent: result.intent,
+            canGenerate,
+            nextQuestion: result.needs_clarification?.[0],
+            extractedRequirements: result.extracted_requirements,
+            needsClarification: result.needs_clarification,
+            suggestedActions: result.suggested_actions,
+        };
+    }
+    /**
+     * Generate infrastructure from a conversation session
+     */
+    async generateFromConversation(sessionId, options) {
+        const response = await fetch(`${this.baseUrl}/api/generate/from-conversation`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                sessionId,
+                applyBestPractices: options?.applyBestPractices ?? true,
+                autofix: options?.autofix ?? true,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (!data.success) {
+            throw new Error(data.error || 'Failed to generate infrastructure');
+        }
+        return {
+            success: true,
+            files: data.data.generated_files,
+            configuration: data.data.configuration,
+            stack: data.data.stack,
+            bestPracticesReport: data.data.best_practices_report,
+            errors: data.data.errors,
+        };
+    }
+    /**
+     * Get conversation session state
+     */
+    async getSession(sessionId) {
+        const response = await fetch(`${this.baseUrl}/api/conversational/session/${sessionId}`, {
+            method: 'GET',
+        });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return null;
+            }
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (!data.success) {
+            return null;
+        }
+        return {
+            sessionId: data.data.session_id,
+            infrastructureStack: data.data.infrastructure_stack,
+            conversationHistory: data.data.conversation_history || [],
+        };
+    }
+    /**
+     * Clear conversation history but keep session
+     */
+    async clearHistory(sessionId) {
+        const response = await fetch(`${this.baseUrl}/api/conversational/clear/${sessionId}`, {
+            method: 'POST',
+        });
+        if (!response.ok) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+    }
+    /**
+     * Delete a conversation session
+     */
+    async deleteSession(sessionId) {
+        const response = await fetch(`${this.baseUrl}/api/conversational/session/${sessionId}`, {
+            method: 'DELETE',
+        });
+        if (!response.ok && response.status !== 404) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+    }
+    /**
+     * Start a questionnaire session
+     */
+    async startQuestionnaire(type) {
+        const response = await fetch(`${this.baseUrl}/api/questionnaire/start`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ type }),
+        });
+        if (!response.ok) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (!data.success) {
+            throw new Error(data.error || 'Failed to start questionnaire');
+        }
+        return data.data;
+    }
+    /**
+     * Submit questionnaire answer
+     */
+    async submitQuestionnaireAnswer(sessionId, questionId, value) {
+        const response = await fetch(`${this.baseUrl}/api/questionnaire/answer`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ sessionId, questionId, value }),
+        });
+        if (!response.ok) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (!data.success) {
+            throw new Error(data.error || 'Failed to submit answer');
+        }
+        return data.data;
+    }
+    /**
+     * Generate from completed questionnaire
+     */
+    async generateFromQuestionnaire(sessionId, options) {
+        const response = await fetch(`${this.baseUrl}/api/generate/from-questionnaire`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                sessionId,
+                applyBestPractices: options?.applyBestPractices ?? true,
+                autofix: options?.autofix ?? true,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (!data.success) {
+            throw new Error(data.error || 'Failed to generate from questionnaire');
+        }
+        return {
+            success: true,
+            files: data.data.generated_files,
+            configuration: data.data.configuration,
+            stack: {
+                provider: data.data.configuration?.selected_provider || 'aws',
+                components: data.data.configuration?.selected_components || [],
+            },
+            bestPracticesReport: data.data.best_practices_report,
+        };
+    }
+    /**
+     * List available templates
+     */
+    async listTemplates(type) {
+        const url = type
+            ? `${this.baseUrl}/api/templates/type/${type}`
+            : `${this.baseUrl}/api/templates`;
+        const response = await fetch(url, { method: 'GET' });
+        if (!response.ok) {
+            throw new Error(`Generator service error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (!data.success) {
+            throw new Error(data.error || 'Failed to list templates');
+        }
+        return data.data;
+    }
+}
+// Singleton instance
+export const generatorClient = new GeneratorClient();