@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,634 @@
+/**
+ * Helm Operations — Embedded tool (stripped HTTP wrappers)
+ *
+ * Copied from services/helm-tools-service/src/helm/operations.ts
+ * Uses child_process instead of Bun.$ for portability in the embedded binary.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../utils';
+const execAsync = promisify(exec);
+/**
+ * Helm operations class wrapping helm CLI
+ */
+export class HelmOperations {
+    helmPath;
+    kubeconfig;
+    kubeContext;
+    defaultNamespace;
+    constructor(config = {}) {
+        this.helmPath = 'helm';
+        this.kubeconfig = config.kubeconfig;
+        this.kubeContext = config.kubeContext;
+        this.defaultNamespace = config.namespace || 'default';
+    }
+    /**
+     * Build base helm command with common flags
+     */
+    buildBaseArgs() {
+        const args = [];
+        if (this.kubeconfig) {
+            args.push('--kubeconfig', this.kubeconfig);
+        }
+        if (this.kubeContext) {
+            args.push('--kube-context', this.kubeContext);
+        }
+        return args;
+    }
+    /**
+     * Execute helm command
+     */
+    async execute(args) {
+        const baseArgs = this.buildBaseArgs();
+        const fullArgs = [...baseArgs, ...args];
+        const command = `${this.helmPath} ${fullArgs.join(' ')}`;
+        logger.debug(`Executing helm command: ${command}`);
+        try {
+            const result = await execAsync(command, {
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 300000,
+            });
+            return {
+                success: true,
+                output: result.stdout.trim(),
+                exitCode: 0,
+            };
+        }
+        catch (error) {
+            const exitCode = error.code ?? 1;
+            const stderr = error.stderr?.trim() || error.message;
+            const stdout = error.stdout?.trim() || '';
+            logger.error(`helm command failed: ${command}`, { exitCode, stderr });
+            return {
+                success: false,
+                output: stdout,
+                error: stderr,
+                exitCode,
+            };
+        }
+    }
+    /**
+     * Build set arguments from Record
+     */
+    buildSetArgs(set, prefix = '--set') {
+        if (!set) {
+            return [];
+        }
+        return Object.entries(set).flatMap(([key, value]) => [prefix, `${key}=${value}`]);
+    }
+    /**
+     * Install a Helm chart
+     */
+    async install(options) {
+        const args = ['install', options.name, options.chart];
+        const namespace = options.namespace || this.defaultNamespace;
+        args.push('-n', namespace);
+        if (options.createNamespace) {
+            args.push('--create-namespace');
+        }
+        if (options.version) {
+            args.push('--version', options.version);
+        }
+        if (options.values) {
+            args.push('-f', '-');
+        }
+        if (options.valuesFiles) {
+            for (const file of options.valuesFiles) {
+                args.push('-f', file);
+            }
+        }
+        args.push(...this.buildSetArgs(options.set));
+        args.push(...this.buildSetArgs(options.setString, '--set-string'));
+        if (options.dryRun) {
+            args.push('--dry-run');
+        }
+        if (options.wait) {
+            args.push('--wait');
+        }
+        if (options.timeout) {
+            args.push('--timeout', options.timeout);
+        }
+        if (options.atomic) {
+            args.push('--atomic');
+        }
+        args.push('-o', 'json');
+        // If values are provided as string, pipe them
+        if (options.values) {
+            const baseArgs = this.buildBaseArgs();
+            const fullArgs = [...baseArgs, ...args];
+            try {
+                const result = await execAsync(`echo '${options.values.replace(/'/g, "'\\''")}' | ${this.helmPath} ${fullArgs.join(' ')}`, { maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
+                return {
+                    success: true,
+                    output: result.stdout.trim(),
+                    exitCode: 0,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: '',
+                    error: error.stderr?.trim() || error.message,
+                    exitCode: error.code ?? 1,
+                };
+            }
+        }
+        return this.execute(args);
+    }
+    /**
+     * Upgrade a Helm release
+     */
+    async upgrade(options) {
+        const args = ['upgrade', options.name, options.chart];
+        const namespace = options.namespace || this.defaultNamespace;
+        args.push('-n', namespace);
+        if (options.install) {
+            args.push('--install');
+        }
+        if (options.createNamespace) {
+            args.push('--create-namespace');
+        }
+        if (options.version) {
+            args.push('--version', options.version);
+        }
+        if (options.values) {
+            args.push('-f', '-');
+        }
+        if (options.valuesFiles) {
+            for (const file of options.valuesFiles) {
+                args.push('-f', file);
+            }
+        }
+        args.push(...this.buildSetArgs(options.set));
+        args.push(...this.buildSetArgs(options.setString, '--set-string'));
+        if (options.reuseValues) {
+            args.push('--reuse-values');
+        }
+        if (options.resetValues) {
+            args.push('--reset-values');
+        }
+        if (options.dryRun) {
+            args.push('--dry-run');
+        }
+        if (options.wait) {
+            args.push('--wait');
+        }
+        if (options.timeout) {
+            args.push('--timeout', options.timeout);
+        }
+        if (options.atomic) {
+            args.push('--atomic');
+        }
+        args.push('-o', 'json');
+        // If values are provided as string, pipe them
+        if (options.values) {
+            const baseArgs = this.buildBaseArgs();
+            const fullArgs = [...baseArgs, ...args];
+            try {
+                const result = await execAsync(`echo '${options.values.replace(/'/g, "'\\''")}' | ${this.helmPath} ${fullArgs.join(' ')}`, { maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
+                return {
+                    success: true,
+                    output: result.stdout.trim(),
+                    exitCode: 0,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: '',
+                    error: error.stderr?.trim() || error.message,
+                    exitCode: error.code ?? 1,
+                };
+            }
+        }
+        return this.execute(args);
+    }
+    /**
+     * Uninstall a Helm release
+     */
+    async uninstall(options) {
+        const args = ['uninstall', options.name];
+        const namespace = options.namespace || this.defaultNamespace;
+        args.push('-n', namespace);
+        if (options.keepHistory) {
+            args.push('--keep-history');
+        }
+        if (options.dryRun) {
+            args.push('--dry-run');
+        }
+        if (options.wait) {
+            args.push('--wait');
+        }
+        if (options.timeout) {
+            args.push('--timeout', options.timeout);
+        }
+        return this.execute(args);
+    }
+    /**
+     * List Helm releases
+     */
+    async list(options = {}) {
+        const args = ['list', '-o', 'json'];
+        if (options.allNamespaces) {
+            args.push('-A');
+        }
+        else if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.filter) {
+            args.push('-f', options.filter);
+        }
+        if (options.maxResults) {
+            args.push('-m', options.maxResults.toString());
+        }
+        if (options.offset) {
+            args.push('--offset', options.offset.toString());
+        }
+        if (options.pending) {
+            args.push('--pending');
+        }
+        if (options.deployed) {
+            args.push('--deployed');
+        }
+        if (options.failed) {
+            args.push('--failed');
+        }
+        if (options.uninstalling) {
+            args.push('--uninstalling');
+        }
+        if (options.superseded) {
+            args.push('--superseded');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Rollback a Helm release
+     */
+    async rollback(options) {
+        const args = ['rollback', options.name, options.revision.toString()];
+        const namespace = options.namespace || this.defaultNamespace;
+        args.push('-n', namespace);
+        if (options.dryRun) {
+            args.push('--dry-run');
+        }
+        if (options.wait) {
+            args.push('--wait');
+        }
+        if (options.timeout) {
+            args.push('--timeout', options.timeout);
+        }
+        if (options.force) {
+            args.push('--force');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get values for a release
+     */
+    async getValues(options) {
+        const args = ['get', 'values', options.name, '-o', 'yaml'];
+        const namespace = options.namespace || this.defaultNamespace;
+        args.push('-n', namespace);
+        if (options.allValues) {
+            args.push('-a');
+        }
+        if (options.revision) {
+            args.push('--revision', options.revision.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get manifest for a release
+     */
+    async getManifest(name, namespace, revision) {
+        const args = ['get', 'manifest', name];
+        args.push('-n', namespace || this.defaultNamespace);
+        if (revision) {
+            args.push('--revision', revision.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get hooks for a release
+     */
+    async getHooks(name, namespace, revision) {
+        const args = ['get', 'hooks', name];
+        args.push('-n', namespace || this.defaultNamespace);
+        if (revision) {
+            args.push('--revision', revision.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get notes for a release
+     */
+    async getNotes(name, namespace, revision) {
+        const args = ['get', 'notes', name];
+        args.push('-n', namespace || this.defaultNamespace);
+        if (revision) {
+            args.push('--revision', revision.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get release history
+     */
+    async history(options) {
+        const args = ['history', options.name, '-o', 'json'];
+        const namespace = options.namespace || this.defaultNamespace;
+        args.push('-n', namespace);
+        if (options.maxResults) {
+            args.push('-m', options.maxResults.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get release status
+     */
+    async status(name, namespace, revision) {
+        const args = ['status', name, '-o', 'json'];
+        args.push('-n', namespace || this.defaultNamespace);
+        if (revision) {
+            args.push('--revision', revision.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Manage Helm repositories
+     */
+    async repo(options) {
+        const args = ['repo', options.action];
+        switch (options.action) {
+            case 'add':
+                if (!options.name || !options.url) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: 'Name and URL are required for repo add',
+                        exitCode: 1,
+                    };
+                }
+                args.push(options.name, options.url);
+                if (options.username) {
+                    args.push('--username', options.username);
+                }
+                if (options.password) {
+                    args.push('--password', options.password);
+                }
+                break;
+            case 'remove':
+                if (!options.name) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: 'Name is required for repo remove',
+                        exitCode: 1,
+                    };
+                }
+                args.push(options.name);
+                break;
+            case 'list':
+                args.push('-o', 'json');
+                break;
+            case 'update':
+                // No additional args needed
+                break;
+        }
+        return this.execute(args);
+    }
+    /**
+     * Search for charts
+     */
+    async search(options) {
+        const args = ['search', 'repo', options.keyword, '-o', 'json'];
+        if (options.version) {
+            args.push('--version', options.version);
+        }
+        if (options.versions) {
+            args.push('--versions');
+        }
+        if (options.regexp) {
+            args.push('--regexp');
+        }
+        if (options.maxResults) {
+            args.push('-m', options.maxResults.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Search hub for charts
+     */
+    async searchHub(keyword, maxResults) {
+        const args = ['search', 'hub', keyword, '-o', 'json'];
+        if (maxResults) {
+            args.push('-m', maxResults.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Show chart information
+     */
+    async show(options) {
+        const args = ['show', options.subcommand, options.chart];
+        if (options.version) {
+            args.push('--version', options.version);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Template a chart locally
+     */
+    async template(options) {
+        const args = ['template', options.name, options.chart];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        if (options.version) {
+            args.push('--version', options.version);
+        }
+        if (options.values) {
+            args.push('-f', '-');
+        }
+        if (options.valuesFiles) {
+            for (const file of options.valuesFiles) {
+                args.push('-f', file);
+            }
+        }
+        args.push(...this.buildSetArgs(options.set));
+        args.push(...this.buildSetArgs(options.setString, '--set-string'));
+        // If values are provided as string, pipe them
+        if (options.values) {
+            const baseArgs = this.buildBaseArgs();
+            const fullArgs = [...baseArgs, ...args];
+            try {
+                const result = await execAsync(`echo '${options.values.replace(/'/g, "'\\''")}' | ${this.helmPath} ${fullArgs.join(' ')}`, { maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
+                return {
+                    success: true,
+                    output: result.stdout.trim(),
+                    exitCode: 0,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: '',
+                    error: error.stderr?.trim() || error.message,
+                    exitCode: error.code ?? 1,
+                };
+            }
+        }
+        return this.execute(args);
+    }
+    /**
+     * Verify Helm is installed and get version
+     */
+    async version() {
+        return this.execute(['version', '--short']);
+    }
+    /**
+     * Pull a chart from a repository
+     */
+    async pull(chart, version, destination, untar) {
+        const args = ['pull', chart];
+        if (version) {
+            args.push('--version', version);
+        }
+        if (destination) {
+            args.push('-d', destination);
+        }
+        if (untar) {
+            args.push('--untar');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Lint a chart
+     */
+    async lint(chartPath, strict, valuesFiles) {
+        const args = ['lint', chartPath];
+        if (strict) {
+            args.push('--strict');
+        }
+        if (valuesFiles) {
+            for (const file of valuesFiles) {
+                args.push('-f', file);
+            }
+        }
+        return this.execute(args);
+    }
+    /**
+     * Run tests for a release
+     */
+    async test(options) {
+        const args = ['test', options.name];
+        const namespace = options.namespace || this.defaultNamespace;
+        args.push('-n', namespace);
+        if (options.timeout) {
+            args.push('--timeout', options.timeout);
+        }
+        if (options.filter) {
+            args.push('--filter', options.filter);
+        }
+        if (options.logs) {
+            args.push('--logs');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Package a chart
+     */
+    async package(chartPath, options) {
+        const args = ['package', chartPath];
+        if (options?.destination) {
+            args.push('-d', options.destination);
+        }
+        if (options?.version) {
+            args.push('--version', options.version);
+        }
+        if (options?.appVersion) {
+            args.push('--app-version', options.appVersion);
+        }
+        if (options?.dependencyUpdate) {
+            args.push('--dependency-update');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Update chart dependencies
+     */
+    async dependencyUpdate(chartPath) {
+        return this.execute(['dependency', 'update', chartPath]);
+    }
+    /**
+     * Build chart dependencies
+     */
+    async dependencyBuild(chartPath) {
+        return this.execute(['dependency', 'build', chartPath]);
+    }
+    /**
+     * List chart dependencies
+     */
+    async dependencyList(chartPath) {
+        return this.execute(['dependency', 'list', chartPath]);
+    }
+    /**
+     * Verify a chart
+     */
+    async verify(chartPath, keyring) {
+        const args = ['verify', chartPath];
+        if (keyring) {
+            args.push('--keyring', keyring);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get all release information
+     */
+    async getAll(name, namespace, revision) {
+        const args = ['get', 'all', name];
+        args.push('-n', namespace || this.defaultNamespace);
+        if (revision) {
+            args.push('--revision', revision.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Create a new chart
+     */
+    async create(name, starterChart) {
+        const args = ['create', name];
+        if (starterChart) {
+            args.push('--starter', starterChart);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Push a chart to a registry
+     */
+    async push(chartPath, remote) {
+        return this.execute(['push', chartPath, remote]);
+    }
+    /**
+     * Login to a registry
+     */
+    async registryLogin(host, username, password) {
+        return this.execute([
+            'registry',
+            'login',
+            host,
+            '--username',
+            username,
+            '--password',
+            password,
+        ]);
+    }
+    /**
+     * Logout from a registry
+     */
+    async registryLogout(host) {
+        return this.execute(['registry', 'logout', host]);
+    }
+}

package/dist/src/tools/index.js

@@ -0,0 +1,16 @@
+/**
+ * Nimbus Embedded Tools — Barrel re-exports
+ *
+ * All tool operation classes for the embedded CLI binary.
+ * These are direct copies from the service operation classes
+ * with HTTP/route wrappers stripped out.
+ */
+export { FileSystemOperations } from './file-ops';
+export { GitOperations } from './git-ops';
+export { TerraformOperations } from './terraform-ops';
+export { KubernetesOperations } from './k8s-ops';
+export { HelmOperations } from './helm-ops';
+export { AwsOperations } from './aws-ops';
+export { GcpOperations } from './gcp-ops';
+export { AzureOperations } from './azure-ops';
+export { GitHubOperations } from './github-ops';