@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/tools/terraform-ops.js

@@ -0,0 +1,627 @@
+/**
+ * Terraform Operations — Embedded tool (stripped HTTP wrappers)
+ *
+ * Copied from services/terraform-tools-service/src/terraform/operations.ts
+ * Provides direct terraform CLI operations for the embedded CLI binary.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from '../utils';
+const execAsync = promisify(exec);
+export class TerraformOperations {
+    workingDir;
+    terraformPath;
+    constructor(workingDir = process.cwd(), terraformPath = 'terraform') {
+        this.workingDir = workingDir;
+        this.terraformPath = terraformPath;
+    }
+    /**
+     * Build command arguments array
+     */
+    buildArgs(baseArgs, options) {
+        const args = [...baseArgs];
+        if (options) {
+            for (const [key, value] of Object.entries(options)) {
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                if (key === 'var' && typeof value === 'object') {
+                    for (const [varName, varValue] of Object.entries(value)) {
+                        args.push('-var', `${varName}=${varValue}`);
+                    }
+                }
+                else if (key === 'backendConfig' && typeof value === 'object') {
+                    for (const [configKey, configValue] of Object.entries(value)) {
+                        args.push('-backend-config', `${configKey}=${configValue}`);
+                    }
+                }
+                else if (key === 'target' && Array.isArray(value)) {
+                    for (const target of value) {
+                        args.push('-target', target);
+                    }
+                }
+                else if (typeof value === 'boolean') {
+                    if (value) {
+                        args.push(`-${key}`);
+                    }
+                    else if (key === 'backend') {
+                        args.push('-backend=false');
+                    }
+                }
+                else if (typeof value === 'number') {
+                    args.push(`-${key}=${value}`);
+                }
+                else if (typeof value === 'string') {
+                    args.push(`-${key}=${value}`);
+                }
+            }
+        }
+        return args;
+    }
+    /**
+     * Execute terraform command
+     */
+    async execute(args, options) {
+        const command = `${this.terraformPath} ${args.join(' ')}`;
+        logger.info(`Executing: ${command} in ${this.workingDir}`);
+        try {
+            const result = await execAsync(command, {
+                cwd: this.workingDir,
+                maxBuffer: 50 * 1024 * 1024, // 50MB buffer
+                timeout: options?.timeout || 600000, // 10 minute default timeout
+                env: {
+                    ...process.env,
+                    TF_IN_AUTOMATION: 'true',
+                    TF_INPUT: 'false',
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            // Terraform often writes useful info to stderr even on failure
+            if (error.stdout || error.stderr) {
+                throw new Error(error.stderr || error.stdout || error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Initialize terraform working directory
+     */
+    async init(options = {}) {
+        logger.info(`Terraform init in ${this.workingDir}`);
+        const args = this.buildArgs(['init', '-no-color'], {
+            backend: options.backend,
+            upgrade: options.upgrade,
+            reconfigure: options.reconfigure,
+            backendConfig: options.backendConfig,
+        });
+        const result = await this.execute(args);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Create execution plan
+     */
+    async plan(options = {}) {
+        logger.info(`Terraform plan in ${this.workingDir}`);
+        const args = this.buildArgs(['plan', '-no-color', '-detailed-exitcode'], {
+            'var-file': options.varFile,
+            out: options.out,
+            destroy: options.destroy,
+            target: options.target,
+            var: options.var,
+            refresh: options.refresh,
+        });
+        try {
+            const result = await this.execute(args);
+            return { success: true, output: result.stdout, hasChanges: false };
+        }
+        catch (error) {
+            // Exit code 2 means there are changes
+            if (error.message?.includes('exit code 2') || error.code === 2) {
+                return { success: true, output: error.stdout || error.message, hasChanges: true };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Apply changes
+     */
+    async apply(options = {}) {
+        logger.info(`Terraform apply in ${this.workingDir}`);
+        const args = this.buildArgs(['apply', '-no-color'], {
+            'auto-approve': options.autoApprove,
+            'var-file': options.varFile,
+            target: options.target,
+            var: options.var,
+            parallelism: options.parallelism,
+        });
+        // If a plan file is provided, append it at the end
+        if (options.planFile) {
+            args.push(options.planFile);
+        }
+        const result = await this.execute(args, { timeout: 1800000 }); // 30 minute timeout for apply
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Destroy infrastructure
+     */
+    async destroy(options = {}) {
+        logger.info(`Terraform destroy in ${this.workingDir}`);
+        const args = this.buildArgs(['destroy', '-no-color'], {
+            'auto-approve': options.autoApprove,
+            'var-file': options.varFile,
+            target: options.target,
+            var: options.var,
+        });
+        const result = await this.execute(args, { timeout: 1800000 }); // 30 minute timeout
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Get outputs
+     */
+    async output(options = {}) {
+        logger.info(`Terraform output in ${this.workingDir}`);
+        const args = ['output', '-no-color'];
+        if (options.json !== false) {
+            args.push('-json');
+        }
+        if (options.name) {
+            args.push(options.name);
+        }
+        const result = await this.execute(args);
+        if (options.json !== false) {
+            try {
+                return JSON.parse(result.stdout);
+            }
+            catch {
+                return result.stdout;
+            }
+        }
+        return result.stdout;
+    }
+    /**
+     * Show state or plan
+     */
+    async show(planFile) {
+        logger.info(`Terraform show in ${this.workingDir}`);
+        const args = ['show', '-no-color'];
+        if (planFile) {
+            args.push('-json', planFile);
+        }
+        const result = await this.execute(args);
+        if (planFile) {
+            try {
+                return { output: result.stdout, json: JSON.parse(result.stdout) };
+            }
+            catch {
+                return { output: result.stdout };
+            }
+        }
+        return { output: result.stdout };
+    }
+    /**
+     * Validate configuration
+     */
+    async validate() {
+        logger.info(`Terraform validate in ${this.workingDir}`);
+        try {
+            const result = await this.execute(['validate', '-json']);
+            const parsed = JSON.parse(result.stdout);
+            return {
+                valid: parsed.valid,
+                errorCount: parsed.error_count || 0,
+                warningCount: parsed.warning_count || 0,
+                diagnostics: (parsed.diagnostics || []).map((d) => ({
+                    severity: d.severity,
+                    summary: d.summary,
+                    detail: d.detail,
+                })),
+            };
+        }
+        catch (error) {
+            try {
+                const parsed = JSON.parse(error.message);
+                return {
+                    valid: false,
+                    errorCount: parsed.error_count || 1,
+                    warningCount: parsed.warning_count || 0,
+                    diagnostics: (parsed.diagnostics || []).map((d) => ({
+                        severity: d.severity,
+                        summary: d.summary,
+                        detail: d.detail,
+                    })),
+                };
+            }
+            catch {
+                return {
+                    valid: false,
+                    errorCount: 1,
+                    warningCount: 0,
+                    diagnostics: [{ severity: 'error', summary: error.message }],
+                };
+            }
+        }
+    }
+    /**
+     * Format configuration files
+     */
+    async fmt(options) {
+        logger.info(`Terraform fmt in ${this.workingDir}`);
+        const args = ['fmt', '-no-color'];
+        if (options?.check) {
+            args.push('-check');
+        }
+        if (options?.recursive) {
+            args.push('-recursive');
+        }
+        if (options?.diff) {
+            args.push('-diff');
+        }
+        try {
+            const result = await this.execute(args);
+            const formatted = result.stdout.split('\n').filter(f => f.trim());
+            return { success: true, output: result.stdout, formatted };
+        }
+        catch (error) {
+            // Exit code 3 means files need formatting
+            if (error.code === 3) {
+                return { success: false, output: error.stdout || 'Files need formatting' };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Run tflint and/or checkov linting
+     */
+    async lint(options) {
+        const runTflint = options?.tflint !== false;
+        const runCheckov = options?.checkov !== false;
+        const result = {};
+        if (runTflint) {
+            try {
+                const tflintResult = await execAsync('tflint --format json --no-color', {
+                    cwd: this.workingDir,
+                    timeout: 120000,
+                });
+                const parsed = JSON.parse(tflintResult.stdout || '{}');
+                const issues = (parsed.issues || []).map((issue) => ({
+                    rule: issue.rule?.name || 'unknown',
+                    severity: issue.rule?.severity || 'warning',
+                    message: issue.message || '',
+                    file: issue.range?.filename,
+                    line: issue.range?.start?.line,
+                }));
+                result.tflint = {
+                    available: true,
+                    success: issues.length === 0 || !issues.some((i) => i.severity === 'error'),
+                    issues,
+                };
+            }
+            catch (err) {
+                if (err.code === 'ENOENT' ||
+                    err.message?.includes('ENOENT') ||
+                    err.message?.includes('not found')) {
+                    result.tflint = { available: false, success: false, issues: [] };
+                }
+                else {
+                    try {
+                        const parsed = JSON.parse(err.stdout || '{}');
+                        const issues = (parsed.issues || []).map((issue) => ({
+                            rule: issue.rule?.name || 'unknown',
+                            severity: issue.rule?.severity || 'warning',
+                            message: issue.message || '',
+                            file: issue.range?.filename,
+                            line: issue.range?.start?.line,
+                        }));
+                        result.tflint = {
+                            available: true,
+                            success: false,
+                            issues,
+                        };
+                    }
+                    catch {
+                        result.tflint = {
+                            available: true,
+                            success: false,
+                            issues: [{ rule: 'unknown', severity: 'error', message: err.message }],
+                        };
+                    }
+                }
+            }
+        }
+        if (runCheckov) {
+            try {
+                const checkovResult = await execAsync(`checkov -d ${this.workingDir} --framework terraform --output json --compact`, { cwd: this.workingDir, timeout: 300000 });
+                const parsed = JSON.parse(checkovResult.stdout || '{}');
+                const summary = parsed.summary || {};
+                const checks = (parsed.results?.passed_checks || [])
+                    .map((c) => ({
+                    id: c.check_id,
+                    name: c.check_name || c.name,
+                    result: 'passed',
+                    file: c.file_path,
+                }))
+                    .concat((parsed.results?.failed_checks || []).map((c) => ({
+                    id: c.check_id,
+                    name: c.check_name || c.name,
+                    result: 'failed',
+                    file: c.file_path,
+                })));
+                result.checkov = {
+                    available: true,
+                    success: (summary.failed || 0) === 0,
+                    passed: summary.passed || 0,
+                    failed: summary.failed || 0,
+                    skipped: summary.skipped || 0,
+                    checks,
+                };
+            }
+            catch (err) {
+                if (err.code === 'ENOENT' ||
+                    err.message?.includes('ENOENT') ||
+                    err.message?.includes('not found')) {
+                    result.checkov = {
+                        available: false,
+                        success: false,
+                        passed: 0,
+                        failed: 0,
+                        skipped: 0,
+                        checks: [],
+                    };
+                }
+                else {
+                    try {
+                        const parsed = JSON.parse(err.stdout || '{}');
+                        const summary = parsed.summary || {};
+                        const checks = (parsed.results?.passed_checks || [])
+                            .map((c) => ({
+                            id: c.check_id,
+                            name: c.check_name || c.name,
+                            result: 'passed',
+                            file: c.file_path,
+                        }))
+                            .concat((parsed.results?.failed_checks || []).map((c) => ({
+                            id: c.check_id,
+                            name: c.check_name || c.name,
+                            result: 'failed',
+                            file: c.file_path,
+                        })));
+                        result.checkov = {
+                            available: true,
+                            success: false,
+                            passed: summary.passed || 0,
+                            failed: summary.failed || 0,
+                            skipped: summary.skipped || 0,
+                            checks,
+                        };
+                    }
+                    catch {
+                        result.checkov = {
+                            available: true,
+                            success: false,
+                            passed: 0,
+                            failed: 0,
+                            skipped: 0,
+                            checks: [{ id: 'unknown', name: 'checkov error', result: 'failed', file: undefined }],
+                        };
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * List workspaces
+     */
+    async workspaceList() {
+        logger.info(`Terraform workspace list in ${this.workingDir}`);
+        const result = await this.execute(['workspace', 'list']);
+        const lines = result.stdout.split('\n').filter(line => line.trim());
+        let current = 'default';
+        const workspaces = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('*')) {
+                current = trimmed.replace(/\*/g, '').trim();
+                workspaces.push(current);
+            }
+            else if (trimmed) {
+                workspaces.push(trimmed);
+            }
+        }
+        return { current, workspaces };
+    }
+    /**
+     * Select workspace
+     */
+    async workspaceSelect(name) {
+        logger.info(`Terraform workspace select ${name} in ${this.workingDir}`);
+        await this.execute(['workspace', 'select', name]);
+        return { success: true, workspace: name };
+    }
+    /**
+     * Create new workspace
+     */
+    async workspaceNew(name) {
+        logger.info(`Terraform workspace new ${name} in ${this.workingDir}`);
+        await this.execute(['workspace', 'new', name]);
+        return { success: true, workspace: name };
+    }
+    /**
+     * Delete workspace
+     */
+    async workspaceDelete(name, force = false) {
+        logger.info(`Terraform workspace delete ${name} in ${this.workingDir}`);
+        const args = ['workspace', 'delete'];
+        if (force) {
+            args.push('-force');
+        }
+        args.push(name);
+        await this.execute(args);
+        return { success: true };
+    }
+    /**
+     * Get state list
+     */
+    async stateList() {
+        logger.info(`Terraform state list in ${this.workingDir}`);
+        const result = await this.execute(['state', 'list']);
+        return result.stdout.split('\n').filter(line => line.trim());
+    }
+    /**
+     * Show specific resource in state
+     */
+    async stateShow(address) {
+        logger.info(`Terraform state show ${address} in ${this.workingDir}`);
+        const result = await this.execute(['state', 'show', address]);
+        return result.stdout;
+    }
+    /**
+     * Remove resource from state
+     */
+    async stateRm(address) {
+        logger.info(`Terraform state rm ${address} in ${this.workingDir}`);
+        await this.execute(['state', 'rm', address]);
+        return { success: true };
+    }
+    /**
+     * Import existing resource
+     */
+    async import(address, id, options) {
+        logger.info(`Terraform import ${address} ${id} in ${this.workingDir}`);
+        const args = this.buildArgs(['import', '-no-color'], {
+            'var-file': options?.varFile,
+        });
+        args.push(address, id);
+        const result = await this.execute(args);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Refresh state
+     */
+    async refresh(options) {
+        logger.info(`Terraform refresh in ${this.workingDir}`);
+        const args = this.buildArgs(['refresh', '-no-color'], {
+            'var-file': options?.varFile,
+        });
+        const result = await this.execute(args);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Get providers
+     */
+    async providers() {
+        logger.info(`Terraform providers in ${this.workingDir}`);
+        const result = await this.execute(['providers']);
+        return result.stdout;
+    }
+    /**
+     * Get version
+     */
+    async version() {
+        logger.info('Terraform version');
+        const result = await this.execute(['version', '-json']);
+        const parsed = JSON.parse(result.stdout);
+        return {
+            terraform: parsed.terraform_version,
+            providers: parsed.provider_selections || {},
+        };
+    }
+    /**
+     * Check if terraform is initialized
+     */
+    async isInitialized() {
+        const tfDir = path.join(this.workingDir, '.terraform');
+        try {
+            await fs.access(tfDir);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Move a resource in state
+     */
+    async stateMove(source, destination) {
+        logger.info(`Terraform state mv ${source} ${destination} in ${this.workingDir}`);
+        const result = await this.execute(['state', 'mv', source, destination]);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Taint a resource (mark for recreation)
+     */
+    async taint(address) {
+        logger.info(`Terraform taint ${address} in ${this.workingDir}`);
+        const result = await this.execute(['taint', address]);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Untaint a resource (unmark for recreation)
+     */
+    async untaint(address) {
+        logger.info(`Terraform untaint ${address} in ${this.workingDir}`);
+        const result = await this.execute(['untaint', address]);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Pull remote state
+     */
+    async statePull() {
+        logger.info(`Terraform state pull in ${this.workingDir}`);
+        const result = await this.execute(['state', 'pull']);
+        return { success: true, state: result.stdout };
+    }
+    /**
+     * Push local state to remote
+     */
+    async statePush(stateFile, force) {
+        logger.info(`Terraform state push in ${this.workingDir}`);
+        const args = ['state', 'push'];
+        if (force) {
+            args.push('-force');
+        }
+        if (stateFile) {
+            args.push(stateFile);
+        }
+        const result = await this.execute(args);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Replace a provider in state
+     */
+    async stateReplaceProvider(fromProvider, toProvider) {
+        logger.info(`Terraform state replace-provider ${fromProvider} ${toProvider} in ${this.workingDir}`);
+        const result = await this.execute([
+            'state',
+            'replace-provider',
+            '-auto-approve',
+            fromProvider,
+            toProvider,
+        ]);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+    /**
+     * Get graph of resources
+     */
+    async graph(type) {
+        logger.info(`Terraform graph in ${this.workingDir}`);
+        const args = ['graph'];
+        if (type) {
+            args.push('-type', type);
+        }
+        const result = await this.execute(args);
+        return { success: true, graph: result.stdout };
+    }
+    /**
+     * Force unlock state
+     */
+    async forceUnlock(lockId) {
+        logger.info(`Terraform force-unlock ${lockId} in ${this.workingDir}`);
+        const result = await this.execute(['force-unlock', '-force', lockId]);
+        return { success: true, output: result.stdout || result.stderr };
+    }
+}

package/dist/src/types/config.js

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

package/dist/src/types/drift.js

@@ -0,0 +1,4 @@
+/**
+ * Drift Detection and Remediation Types
+ */
+export {};

package/dist/src/types/enterprise.js

@@ -0,0 +1,5 @@
+/**
+ * Enterprise Types
+ * Types for team collaboration, billing, audit, and SSO features
+ */
+export {};

package/dist/src/types/index.js

@@ -0,0 +1,14 @@
+// Service types
+export * from './service';
+// Request types
+export * from './request';
+// Response types
+export * from './response';
+// Plan types
+export * from './plan';
+// Config types
+export * from './config';
+// Enterprise types
+export * from './enterprise';
+// Drift types
+export * from './drift';

package/dist/src/types/plan.js

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

package/dist/src/types/request.js

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

package/dist/src/types/response.js

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

package/dist/src/types/service.js

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