@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,299 @@
+/**
+ * Helm Tools Client
+ *
+ * REST client for communicating with the Helm Tools Service
+ */
+import { RestClient, ServiceURLs } from '.';
+/**
+ * Client for Helm Tools Service
+ */
+export class HelmClient {
+    client;
+    constructor(baseUrl) {
+        this.client = new RestClient(baseUrl || ServiceURLs.HELM_TOOLS);
+    }
+    /**
+     * List Helm releases
+     */
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        if (options?.allNamespaces) {
+            params.set('all-namespaces', 'true');
+        }
+        const response = await this.client.get(`/api/helm/list?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, releases: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Install a Helm chart
+     */
+    async install(releaseName, chart, options) {
+        const response = await this.client.post('/api/helm/install', {
+            releaseName,
+            chart,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return {
+            success: false,
+            release: {
+                name: '',
+                namespace: '',
+                revision: 0,
+                status: '',
+                chart: '',
+                appVersion: '',
+                updated: '',
+            },
+            output: '',
+            error: response.error?.message || 'Unknown error',
+        };
+    }
+    /**
+     * Upgrade a Helm release
+     */
+    async upgrade(releaseName, chart, options) {
+        const response = await this.client.post('/api/helm/upgrade', {
+            releaseName,
+            chart,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return {
+            success: false,
+            release: {
+                name: '',
+                namespace: '',
+                revision: 0,
+                status: '',
+                chart: '',
+                appVersion: '',
+                updated: '',
+            },
+            output: '',
+            error: response.error?.message || 'Unknown error',
+        };
+    }
+    /**
+     * Uninstall a Helm release
+     */
+    async uninstall(releaseName, options) {
+        const response = await this.client.post('/api/helm/uninstall', { releaseName, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Rollback a Helm release
+     */
+    async rollback(releaseName, revision, options) {
+        const response = await this.client.post('/api/helm/rollback', { releaseName, revision, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get release history
+     */
+    async history(releaseName, options) {
+        const params = new URLSearchParams();
+        params.set('release', releaseName);
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        const response = await this.client.get(`/api/helm/history?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, history: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Search for Helm charts
+     */
+    async search(keyword, options) {
+        const params = new URLSearchParams();
+        params.set('keyword', keyword);
+        if (options?.repo) {
+            params.set('repo', options.repo);
+        }
+        const response = await this.client.get(`/api/helm/search?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, charts: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Add a Helm repository
+     */
+    async repoAdd(name, url) {
+        const response = await this.client.post('/api/helm/repo/add', { name, url });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Update Helm repositories
+     */
+    async repoUpdate() {
+        const response = await this.client.post('/api/helm/repo/update', {});
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Show chart information
+     */
+    async show(chart, options) {
+        const params = new URLSearchParams();
+        params.set('chart', chart);
+        if (options?.subcommand) {
+            params.set('subcommand', options.subcommand);
+        }
+        if (options?.version) {
+            params.set('version', options.version);
+        }
+        const response = await this.client.get(`/api/helm/show?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Lint a Helm chart
+     */
+    async lint(chartPath, options) {
+        const response = await this.client.post('/api/helm/lint', {
+            chartPath,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get status of a Helm release
+     */
+    async status(releaseName, options) {
+        const params = new URLSearchParams();
+        params.set('release', releaseName);
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        const response = await this.client.get(`/api/helm/status?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Show chart values
+     */
+    async showValues(chart, options) {
+        const params = new URLSearchParams();
+        params.set('chart', chart);
+        if (options?.version) {
+            params.set('version', options.version);
+        }
+        const response = await this.client.get(`/api/helm/show/values?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, values: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Render chart templates locally without installing
+     */
+    async template(releaseName, chart, options) {
+        const response = await this.client.post('/api/helm/template', {
+            name: releaseName,
+            chart,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Package a chart directory into a chart archive
+     */
+    async package(chartPath, options) {
+        const response = await this.client.post('/api/helm/package', {
+            chartPath,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Update chart dependencies
+     */
+    async dependencyUpdate(chartPath) {
+        const response = await this.client.post('/api/helm/dependency/update', {
+            chartPath,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Build chart dependencies
+     */
+    async dependencyBuild(chartPath) {
+        const response = await this.client.post('/api/helm/dependency/build', {
+            chartPath,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get detailed status of a Helm release with optional revision
+     */
+    async statusDetailed(releaseName, options) {
+        const params = new URLSearchParams();
+        params.set('name', releaseName);
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        if (options?.revision !== undefined) {
+            params.set('revision', options.revision.toString());
+        }
+        const response = await this.client.get(`/api/helm/status?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, 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 helmClient = new HelmClient();

package/dist/src/clients/index.js

@@ -0,0 +1,18 @@
+/**
+ * CLI Service Clients
+ *
+ * Exports clients for communicating with backend services
+ */
+// Low-level shared clients
+export { RestClient } from './rest-client';
+export { WebSocketClient } from './ws-client';
+export { ServiceURLs, WebSocketURLs } from './service-discovery';
+export { ToolsClient } from './tools-client';
+// High-level service clients
+export { LLMClient, llmClient, } from './llm-client';
+export { TerraformClient, terraformClient, } from './terraform-client';
+export { K8sClient, k8sClient, } from './k8s-client';
+export { HelmClient, helmClient, } from './helm-client';
+export { GitClient, gitClient, } from './git-client';
+export { GeneratorClient, generatorClient, } from './generator-client';
+export { CoreEngineClient, } from './core-engine-client';

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

@@ -0,0 +1,270 @@
+/**
+ * Kubernetes Tools Client
+ *
+ * REST client for communicating with the K8s Tools Service
+ */
+import { RestClient, ServiceURLs } from '.';
+/**
+ * Client for Kubernetes Tools Service
+ */
+export class K8sClient {
+    client;
+    constructor(baseUrl) {
+        this.client = new RestClient(baseUrl || ServiceURLs.K8S_TOOLS);
+    }
+    /**
+     * Get Kubernetes resources
+     */
+    async get(resource, options) {
+        const params = new URLSearchParams();
+        params.set('resource', resource);
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        if (options?.name) {
+            params.set('name', options.name);
+        }
+        if (options?.output) {
+            params.set('output', options.output);
+        }
+        if (options?.labels) {
+            params.set('labels', JSON.stringify(options.labels));
+        }
+        const response = await this.client.get(`/api/k8s/get?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, items: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Apply Kubernetes manifests
+     */
+    async apply(manifests, options) {
+        const response = await this.client.post('/api/k8s/apply', {
+            manifests,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Delete Kubernetes resources
+     */
+    async delete(resource, name, options) {
+        const response = await this.client.post('/api/k8s/delete', {
+            resource,
+            name,
+            ...options,
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get logs from a pod
+     */
+    async logs(podName, options) {
+        const params = new URLSearchParams();
+        params.set('pod', podName);
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        if (options?.container) {
+            params.set('container', options.container);
+        }
+        if (options?.tail) {
+            params.set('tail', String(options.tail));
+        }
+        if (options?.since) {
+            params.set('since', options.since);
+        }
+        const response = await this.client.get(`/api/k8s/logs?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, logs: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Describe a Kubernetes resource
+     */
+    async describe(resource, name, options) {
+        const params = new URLSearchParams();
+        params.set('resource', resource);
+        params.set('name', name);
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        const response = await this.client.get(`/api/k8s/describe?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Scale a deployment/replicaset
+     */
+    async scale(resource, name, replicas, options) {
+        const response = await this.client.post('/api/k8s/scale', { resource, name, replicas, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Execute a command in a pod
+     */
+    async exec(pod, command, options) {
+        const response = await this.client.post('/api/k8s/exec', { pod, command, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Manage rollouts
+     */
+    async rollout(resource, name, action, options) {
+        const response = await this.client.post('/api/k8s/rollout', { action, resource, name, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get events from a namespace
+     */
+    async events(options) {
+        const params = new URLSearchParams();
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        if (options?.fieldSelector) {
+            params.set('fieldSelector', options.fieldSelector);
+        }
+        const response = await this.client.get(`/api/k8s/events?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, events: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Forward local ports to a pod
+     */
+    async portForward(pod, ports, options) {
+        const response = await this.client.post('/api/k8s/port-forward', { pod, ports, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * List namespaces
+     */
+    async listNamespaces(options) {
+        const params = new URLSearchParams();
+        if (options?.kubeconfig) {
+            params.set('kubeconfig', options.kubeconfig);
+        }
+        if (options?.context) {
+            params.set('context', options.context);
+        }
+        const query = params.toString() ? `?${params.toString()}` : '';
+        const response = await this.client.get(`/api/k8s/namespaces${query}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, namespaces: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Create a namespace
+     */
+    async createNamespace(name, options) {
+        const response = await this.client.post('/api/k8s/namespace', { name, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Delete a namespace
+     */
+    async deleteNamespace(name, options) {
+        const response = await this.client.post('/api/k8s/namespace/delete', { name, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get top resource usage for pods or nodes
+     */
+    async top(resourceType, options) {
+        const params = new URLSearchParams();
+        if (options?.namespace) {
+            params.set('namespace', options.namespace);
+        }
+        if (options?.kubeconfig) {
+            params.set('kubeconfig', options.kubeconfig);
+        }
+        if (options?.context) {
+            params.set('context', options.context);
+        }
+        const query = params.toString() ? `?${params.toString()}` : '';
+        const response = await this.client.get(`/api/k8s/top/${resourceType}${query}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return {
+            success: false,
+            output: '',
+            items: [],
+            error: response.error?.message || 'Unknown error',
+        };
+    }
+    /**
+     * Patch a Kubernetes resource
+     */
+    async patch(resource, name, patch, options) {
+        const response = await this.client.post('/api/k8s/patch', { resource, name, patch, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Label a Kubernetes resource
+     */
+    async label(resource, name, labels, options) {
+        const response = await this.client.post('/api/k8s/label', { resource, name, labels, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Annotate a Kubernetes resource
+     */
+    async annotate(resource, name, annotations, options) {
+        const response = await this.client.post('/api/k8s/annotate', { resource, name, annotations, ...options });
+        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 k8sClient = new K8sClient();