@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,579 @@
+/**
+ * Kubernetes Operations — Embedded tool (stripped HTTP wrappers)
+ *
+ * Copied from services/k8s-tools-service/src/k8s/operations.ts
+ * Uses child_process instead of Bun.$ for portability in the embedded binary.
+ */
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../utils';
+const execAsync = promisify(exec);
+/**
+ * Kubernetes operations class wrapping kubectl CLI
+ */
+export class KubernetesOperations {
+    kubectlPath;
+    kubeconfig;
+    context;
+    defaultNamespace;
+    constructor(config = {}) {
+        this.kubectlPath = 'kubectl';
+        this.kubeconfig = config.kubeconfig;
+        this.context = config.context;
+        this.defaultNamespace = config.namespace || 'default';
+    }
+    /**
+     * Build base kubectl command with common flags
+     */
+    buildBaseArgs() {
+        const args = [];
+        if (this.kubeconfig) {
+            args.push('--kubeconfig', this.kubeconfig);
+        }
+        if (this.context) {
+            args.push('--context', this.context);
+        }
+        return args;
+    }
+    /**
+     * Execute kubectl command
+     */
+    async execute(args) {
+        const baseArgs = this.buildBaseArgs();
+        const fullArgs = [...baseArgs, ...args];
+        const command = `${this.kubectlPath} ${fullArgs.join(' ')}`;
+        logger.debug(`Executing kubectl command: ${command}`);
+        try {
+            const result = await execAsync(command, {
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 120000,
+            });
+            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(`kubectl command failed: ${command}`, { exitCode, stderr });
+            return {
+                success: false,
+                output: stdout,
+                error: stderr,
+                exitCode,
+            };
+        }
+    }
+    /**
+     * Get Kubernetes resources
+     */
+    async get(options) {
+        const args = ['get', options.resource];
+        if (options.name) {
+            args.push(options.name);
+        }
+        if (options.allNamespaces) {
+            args.push('--all-namespaces');
+        }
+        else if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.selector) {
+            args.push('-l', options.selector);
+        }
+        if (options.output) {
+            args.push('-o', options.output);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Apply a manifest to the cluster
+     */
+    async apply(options) {
+        const args = ['apply', '-f', '-'];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        if (options.dryRun) {
+            args.push('--dry-run=client');
+        }
+        if (options.force) {
+            args.push('--force');
+        }
+        if (options.serverSide) {
+            args.push('--server-side');
+        }
+        const baseArgs = this.buildBaseArgs();
+        const fullArgs = [...baseArgs, ...args];
+        logger.debug(`Applying manifest with kubectl`);
+        try {
+            const result = await execAsync(`echo '${options.manifest.replace(/'/g, "'\\''")}' | ${this.kubectlPath} ${fullArgs.join(' ')}`, { maxBuffer: 10 * 1024 * 1024, timeout: 120000 });
+            return {
+                success: true,
+                output: result.stdout.trim(),
+                exitCode: 0,
+            };
+        }
+        catch (error) {
+            const exitCode = error.code ?? 1;
+            const stderr = error.stderr?.trim() || error.message;
+            return {
+                success: false,
+                output: '',
+                error: stderr,
+                exitCode,
+            };
+        }
+    }
+    /**
+     * Delete Kubernetes resources
+     */
+    async delete(options) {
+        const args = ['delete', options.resource];
+        if (options.name) {
+            args.push(options.name);
+        }
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.selector) {
+            args.push('-l', options.selector);
+        }
+        if (options.force) {
+            args.push('--force');
+        }
+        if (options.gracePeriod !== undefined) {
+            args.push('--grace-period', options.gracePeriod.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get logs from a pod
+     */
+    async logs(options) {
+        const args = ['logs', options.pod];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.container) {
+            args.push('-c', options.container);
+        }
+        if (options.follow) {
+            args.push('-f');
+        }
+        if (options.tail !== undefined) {
+            args.push('--tail', options.tail.toString());
+        }
+        if (options.previous) {
+            args.push('--previous');
+        }
+        if (options.since) {
+            args.push('--since', options.since);
+        }
+        if (options.timestamps) {
+            args.push('--timestamps');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Execute command in a pod
+     */
+    async exec(options) {
+        const args = ['exec', options.pod];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.container) {
+            args.push('-c', options.container);
+        }
+        if (options.stdin) {
+            args.push('-i');
+        }
+        if (options.tty) {
+            args.push('-t');
+        }
+        args.push('--');
+        args.push(...options.command);
+        return this.execute(args);
+    }
+    /**
+     * Describe Kubernetes resources
+     */
+    async describe(options) {
+        const args = ['describe', options.resource];
+        if (options.name) {
+            args.push(options.name);
+        }
+        if (options.allNamespaces) {
+            args.push('--all-namespaces');
+        }
+        else if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.selector) {
+            args.push('-l', options.selector);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Scale a deployment, replicaset, or statefulset
+     */
+    async scale(options) {
+        const args = [
+            'scale',
+            `${options.resource}/${options.name}`,
+            '--replicas',
+            options.replicas.toString(),
+        ];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Manage rollouts
+     */
+    async rollout(options) {
+        const args = ['rollout', options.action, `${options.resource}/${options.name}`];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.action === 'undo' && options.revision !== undefined) {
+            args.push('--to-revision', options.revision.toString());
+        }
+        return this.execute(args);
+    }
+    /**
+     * Get cluster information
+     */
+    async clusterInfo() {
+        return this.execute(['cluster-info']);
+    }
+    /**
+     * Get current context
+     */
+    async currentContext() {
+        return this.execute(['config', 'current-context']);
+    }
+    /**
+     * Get list of contexts
+     */
+    async getContexts() {
+        return this.execute(['config', 'get-contexts', '-o', 'name']);
+    }
+    /**
+     * Set current context
+     */
+    async useContext(context) {
+        return this.execute(['config', 'use-context', context]);
+    }
+    /**
+     * Get namespaces
+     */
+    async getNamespaces() {
+        return this.execute(['get', 'namespaces', '-o', 'json']);
+    }
+    /**
+     * Create namespace
+     */
+    async createNamespace(name) {
+        return this.execute(['create', 'namespace', name]);
+    }
+    /**
+     * Delete namespace
+     */
+    async deleteNamespace(name) {
+        return this.execute(['delete', 'namespace', name]);
+    }
+    /**
+     * Get events in a namespace
+     */
+    async getEvents(namespace, fieldSelector) {
+        const args = ['get', 'events', '-o', 'json'];
+        if (namespace) {
+            args.push('-n', namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (fieldSelector) {
+            args.push('--field-selector', fieldSelector);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Top pods - show resource usage
+     */
+    async topPods(namespace, selector) {
+        const args = ['top', 'pods'];
+        if (namespace) {
+            args.push('-n', namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (selector) {
+            args.push('-l', selector);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Top nodes - show node resource usage
+     */
+    async topNodes() {
+        return this.execute(['top', 'nodes']);
+    }
+    /**
+     * Get API resources
+     */
+    async apiResources() {
+        return this.execute(['api-resources', '-o', 'wide']);
+    }
+    /**
+     * Get version information
+     */
+    async version() {
+        return this.execute(['version', '-o', 'json']);
+    }
+    /**
+     * Port forward to a pod or service
+     * Note: This starts a background process and returns immediately
+     */
+    async portForward(options) {
+        const args = ['port-forward'];
+        // Resource type and name
+        const resourceSpec = `${options.resource}/${options.name}`;
+        args.push(resourceSpec);
+        // Add ports
+        for (const port of options.ports) {
+            args.push(port);
+        }
+        // Namespace
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        // Address to listen on
+        if (options.address) {
+            args.push('--address', options.address);
+        }
+        const baseArgs = this.buildBaseArgs();
+        const fullArgs = [...baseArgs, ...args];
+        logger.info(`Starting port-forward: ${this.kubectlPath} ${fullArgs.join(' ')}`);
+        // Spawn the port-forward as a background process
+        const proc = spawn(this.kubectlPath, fullArgs, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Wait briefly for the "Forwarding from..." confirmation or an error
+        const result = await new Promise(resolve => {
+            let stderr = '';
+            const timeout = setTimeout(() => {
+                // If no output after 5s, assume it started
+                proc.unref();
+                resolve({
+                    success: true,
+                    resource: resourceSpec,
+                    ports: options.ports,
+                    namespace: options.namespace || this.defaultNamespace,
+                    address: options.address || '127.0.0.1',
+                    message: `Port-forward started for ${resourceSpec}`,
+                    pid: proc.pid,
+                });
+            }, 5000);
+            proc.stdout?.on('data', (data) => {
+                const output = data.toString();
+                if (output.includes('Forwarding from')) {
+                    clearTimeout(timeout);
+                    proc.unref();
+                    resolve({
+                        success: true,
+                        resource: resourceSpec,
+                        ports: options.ports,
+                        namespace: options.namespace || this.defaultNamespace,
+                        address: options.address || '127.0.0.1',
+                        message: output.trim(),
+                        pid: proc.pid,
+                    });
+                }
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('error', err => {
+                clearTimeout(timeout);
+                resolve({
+                    success: false,
+                    resource: resourceSpec,
+                    ports: options.ports,
+                    namespace: options.namespace || this.defaultNamespace,
+                    address: options.address || '127.0.0.1',
+                    message: `Port-forward failed: ${err.message}`,
+                });
+            });
+            proc.on('close', code => {
+                if (code !== 0) {
+                    clearTimeout(timeout);
+                    resolve({
+                        success: false,
+                        resource: resourceSpec,
+                        ports: options.ports,
+                        namespace: options.namespace || this.defaultNamespace,
+                        address: options.address || '127.0.0.1',
+                        message: stderr.trim() || `Port-forward exited with code ${code}`,
+                    });
+                }
+            });
+        });
+        return result;
+    }
+    /**
+     * Copy files to/from a pod
+     */
+    async cp(options) {
+        const args = ['cp'];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        if (options.container) {
+            args.push('-c', options.container);
+        }
+        // Source and destination
+        args.push(options.source, options.destination);
+        return this.execute(args);
+    }
+    /**
+     * Label a resource
+     */
+    async label(options) {
+        const args = ['label', `${options.resource}/${options.name}`];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        // Add labels
+        for (const [key, value] of Object.entries(options.labels)) {
+            if (value === null) {
+                args.push(`${key}-`); // Remove label
+            }
+            else {
+                args.push(`${key}=${value}`);
+            }
+        }
+        if (options.overwrite) {
+            args.push('--overwrite');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Annotate a resource
+     */
+    async annotate(options) {
+        const args = ['annotate', `${options.resource}/${options.name}`];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        // Add annotations
+        for (const [key, value] of Object.entries(options.annotations)) {
+            if (value === null) {
+                args.push(`${key}-`); // Remove annotation
+            }
+            else {
+                args.push(`${key}=${value}`);
+            }
+        }
+        if (options.overwrite) {
+            args.push('--overwrite');
+        }
+        return this.execute(args);
+    }
+    /**
+     * Patch a resource
+     */
+    async patch(options) {
+        const args = ['patch', options.resource, options.name];
+        if (options.namespace) {
+            args.push('-n', options.namespace);
+        }
+        else {
+            args.push('-n', this.defaultNamespace);
+        }
+        args.push('--type', options.type || 'strategic');
+        args.push('-p', JSON.stringify(options.patch));
+        return this.execute(args);
+    }
+    /**
+     * Cordon a node (mark as unschedulable)
+     */
+    async cordon(nodeName) {
+        return this.execute(['cordon', nodeName]);
+    }
+    /**
+     * Uncordon a node (mark as schedulable)
+     */
+    async uncordon(nodeName) {
+        return this.execute(['uncordon', nodeName]);
+    }
+    /**
+     * Drain a node
+     */
+    async drain(nodeName, options) {
+        const args = ['drain', nodeName];
+        if (options?.force) {
+            args.push('--force');
+        }
+        if (options?.ignoreDaemonsets) {
+            args.push('--ignore-daemonsets');
+        }
+        if (options?.deleteEmptyDirData) {
+            args.push('--delete-emptydir-data');
+        }
+        if (options?.gracePeriod !== undefined) {
+            args.push('--grace-period', options.gracePeriod.toString());
+        }
+        if (options?.timeout) {
+            args.push('--timeout', options.timeout);
+        }
+        return this.execute(args);
+    }
+    /**
+     * Taint a node
+     */
+    async taint(nodeName, taints) {
+        const args = ['taint', 'nodes', nodeName, ...taints];
+        return this.execute(args);
+    }
+}

package/dist/src/tools/schemas/converter.js

@@ -0,0 +1,129 @@
+/**
+ * Batch Conversion Utilities for Provider-Specific Tool Formats
+ *
+ * This module re-exports the individual converter functions from
+ * {@link module:tools/schemas/types} and adds convenience functions for
+ * converting arrays of {@link ToolDefinition}s to each supported LLM
+ * provider's expected tool format in a single call.
+ *
+ * The {@link toProviderFormat} function additionally accepts a
+ * {@link Provider} discriminator so callers can defer the choice of
+ * target format to runtime configuration.
+ *
+ * @module tools/schemas/converter
+ */
+import { toAnthropicTool, toOpenAITool, toGoogleTool, zodToJsonSchema, } from './types';
+// ---------------------------------------------------------------------------
+// Re-exports -- individual converters and provider-specific types
+// ---------------------------------------------------------------------------
+export { toAnthropicTool, toOpenAITool, toGoogleTool, zodToJsonSchema };
+// ---------------------------------------------------------------------------
+// Batch Conversion Functions
+// ---------------------------------------------------------------------------
+/**
+ * Convert an array of tool definitions to Anthropic Messages API format.
+ *
+ * Each {@link ToolDefinition} is individually converted via
+ * {@link toAnthropicTool} and the results are returned as an array.
+ *
+ * @param tools - The tool definitions to convert.
+ * @returns An array of {@link AnthropicTool} objects ready for the API.
+ */
+export function toAnthropicFormat(tools) {
+    return tools.map(toAnthropicTool);
+}
+/**
+ * Convert an array of tool definitions to OpenAI function-calling format.
+ *
+ * Each {@link ToolDefinition} is individually converted via
+ * {@link toOpenAITool} and the results are returned as an array.
+ *
+ * @param tools - The tool definitions to convert.
+ * @returns An array of {@link OpenAITool} objects ready for the API.
+ */
+export function toOpenAIFormat(tools) {
+    return tools.map(toOpenAITool);
+}
+/**
+ * Convert an array of tool definitions to Google Generative AI format.
+ *
+ * Unlike Anthropic and OpenAI, Google expects all function declarations
+ * to be bundled inside a single tool object with a `functionDeclarations`
+ * array. This function delegates to {@link toGoogleTool} which handles
+ * that bundling.
+ *
+ * @param tools - The tool definitions to convert.
+ * @returns A single {@link GoogleTool} containing all declarations.
+ */
+export function toGoogleFormat(tools) {
+    return toGoogleTool(tools);
+}
+// ---------------------------------------------------------------------------
+// Provider-Aware Conversion
+// ---------------------------------------------------------------------------
+/**
+ * Convert an array of tool definitions to the wire format expected by a
+ * specific LLM provider.
+ *
+ * This is the primary entry point for code that determines the target
+ * provider at runtime (e.g. from user configuration). The mapping is:
+ *
+ * - `'anthropic'` and `'bedrock'` produce {@link AnthropicTool}[] (Bedrock
+ *   uses Anthropic format for Claude models).
+ * - `'openai'`, `'ollama'`, `'openrouter'`, and `'openai-compatible'`
+ *   produce {@link OpenAITool}[].
+ * - `'google'` produces a single {@link GoogleTool} object.
+ *
+ * If an unrecognized provider string is passed (possible when new
+ * providers are added before this function is updated), the function
+ * falls back to OpenAI format as it is the most widely supported.
+ *
+ * @param tools    - The tool definitions to convert.
+ * @param provider - The target LLM provider identifier.
+ * @returns The converted tools in the provider-specific format.
+ */
+export function toProviderFormat(tools, provider) {
+    switch (provider) {
+        case 'anthropic':
+            return toAnthropicFormat(tools);
+        case 'openai':
+        case 'ollama':
+        case 'openrouter':
+        case 'openai-compatible':
+            return toOpenAIFormat(tools);
+        case 'google':
+            return toGoogleFormat(tools);
+        case 'bedrock':
+            // Bedrock uses Anthropic format for Claude models
+            return toAnthropicFormat(tools);
+        default: {
+            // Exhaustive check: if a new Provider variant is added but not
+            // handled above, TypeScript will flag this assignment as an error.
+            const _exhaustive = provider;
+            void _exhaustive;
+            // Default to OpenAI format (most widely supported)
+            return toOpenAIFormat(tools);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Utility Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract the names of all tool definitions in the given array.
+ *
+ * Useful for logging, permission checks, or building tool-name allow/deny
+ * lists without pulling in the full definition objects.
+ *
+ * @param tools - The tool definitions to extract names from.
+ * @returns An array of tool name strings, preserving input order.
+ *
+ * @example
+ * ```ts
+ * const names = getToolNames(registry.getAll());
+ * // ['read_file', 'write_file', 'terraform_apply']
+ * ```
+ */
+export function getToolNames(tools) {
+    return tools.map(t => t.name);
+}