@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/plugin.js

@@ -0,0 +1,325 @@
+/**
+ * Plugin / Extension System (L3)
+ *
+ * Manages MCP server plugins that extend Nimbus's tool capabilities.
+ * Registry stored at ~/.nimbus/plugins.json
+ *
+ * Commands:
+ *   nimbus plugin list           — list installed plugins
+ *   nimbus plugin add <name>     — add a plugin from npm or git URL
+ *   nimbus plugin remove <name>  — remove a plugin
+ *   nimbus plugin init           — scaffold a minimal MCP server in CWD
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { ui } from '../wizard/ui';
+const PLUGINS_FILE = path.join(os.homedir(), '.nimbus', 'plugins.json');
+const MCP_FILE = path.join(os.homedir(), '.nimbus', 'mcp.json');
+function loadMCPConfig() {
+    try {
+        const content = fs.readFileSync(MCP_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { servers: [] };
+    }
+}
+function saveMCPConfig(config) {
+    const dir = path.dirname(MCP_FILE);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(MCP_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+/**
+ * M5: MCP server management command.
+ * Subcommands: add, list, remove, test
+ */
+export async function mcpCommand(subcommand, args) {
+    switch (subcommand) {
+        case 'list': {
+            const config = loadMCPConfig();
+            if (config.servers.length === 0) {
+                ui.info('No MCP servers configured. Add one with: nimbus mcp add <command-or-url>');
+                ui.info(`Config file: ${MCP_FILE}`);
+                return;
+            }
+            ui.header('Configured MCP Servers');
+            for (const s of config.servers) {
+                const cmd = s.type === 'http' ? `${s.url ?? ''}` : `${s.command} ${(s.args ?? []).join(' ')}`;
+                ui.print(`  ${ui.color(s.name, 'cyan')}  [${s.type}]  ${cmd}`);
+            }
+            ui.newLine();
+            ui.info(`Config: ${MCP_FILE}`);
+            break;
+        }
+        case 'add': {
+            const commandOrUrl = args[0];
+            if (!commandOrUrl) {
+                ui.print('Usage: nimbus mcp add <command-or-url> [--name <name>]');
+                ui.print('');
+                ui.print('Examples:');
+                ui.print('  nimbus mcp add "npx -y @my/mcp-server"          (npm package)');
+                ui.print('  nimbus mcp add "https://my-server.example.com"  (HTTP)');
+                ui.print('  nimbus mcp add "./my-server.js"                 (local script)');
+                return;
+            }
+            // Parse optional --name flag
+            let serverName = commandOrUrl;
+            for (let i = 1; i < args.length; i++) {
+                if (args[i] === '--name' && args[i + 1]) {
+                    serverName = args[++i];
+                }
+            }
+            const config = loadMCPConfig();
+            if (config.servers.find(s => s.name === serverName)) {
+                ui.warning(`MCP server "${serverName}" is already configured.`);
+                return;
+            }
+            // Determine transport type and build entry
+            const isHttp = commandOrUrl.startsWith('http://') || commandOrUrl.startsWith('https://');
+            let entry;
+            if (isHttp) {
+                entry = {
+                    name: serverName,
+                    command: '',
+                    type: 'http',
+                    url: commandOrUrl,
+                };
+            }
+            else {
+                // Parse "npx -y @my/mcp-server" into command + args
+                const parts = commandOrUrl.split(/\s+/);
+                entry = {
+                    name: serverName,
+                    command: parts[0] ?? commandOrUrl,
+                    args: parts.slice(1),
+                    type: 'stdio',
+                };
+            }
+            config.servers.push(entry);
+            saveMCPConfig(config);
+            ui.print(`${ui.color('✓', 'green')} MCP server "${serverName}" added.`);
+            ui.info(`Config saved to: ${MCP_FILE}`);
+            ui.info('Restart Nimbus for the server to take effect.');
+            break;
+        }
+        case 'remove': {
+            const name = args[0];
+            if (!name) {
+                ui.print('Usage: nimbus mcp remove <name>');
+                return;
+            }
+            const config = loadMCPConfig();
+            const idx = config.servers.findIndex(s => s.name === name);
+            if (idx === -1) {
+                ui.warning(`MCP server "${name}" not found.`);
+                ui.info('Run "nimbus mcp list" to see configured servers.');
+                return;
+            }
+            config.servers.splice(idx, 1);
+            saveMCPConfig(config);
+            ui.print(`${ui.color('✓', 'green')} MCP server "${name}" removed.`);
+            break;
+        }
+        case 'test': {
+            const name = args[0];
+            if (!name) {
+                ui.print('Usage: nimbus mcp test <name>');
+                return;
+            }
+            const config = loadMCPConfig();
+            const server = config.servers.find(s => s.name === name);
+            if (!server) {
+                ui.warning(`MCP server "${name}" not found.`);
+                ui.info('Run "nimbus mcp list" to see configured servers.');
+                return;
+            }
+            if (server.type === 'http') {
+                // HTTP: send a tools/list request via curl if available
+                ui.startSpinner({ message: `Testing MCP server "${name}" at ${server.url ?? ''}...` });
+                try {
+                    const resp = execFileSync('curl', [
+                        '-s', '--max-time', '5',
+                        '-X', 'POST',
+                        '-H', 'Content-Type: application/json',
+                        '-d', JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }),
+                        server.url ?? '',
+                    ], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+                    const data = JSON.parse(resp);
+                    ui.stopSpinnerSuccess(`Server responded. Result: ${JSON.stringify(data).slice(0, 200)}`);
+                }
+                catch (err) {
+                    ui.stopSpinnerFail(`Could not reach server: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            else {
+                // stdio: spawn briefly and send a tools/list JSON-RPC message
+                ui.startSpinner({ message: `Testing MCP server "${name}" (stdio)...` });
+                try {
+                    const testPayload = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }) + '\n';
+                    const result = execFileSync(server.command, server.args ?? [], {
+                        input: testPayload,
+                        encoding: 'utf-8',
+                        timeout: 5000,
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    const parsed = JSON.parse(result);
+                    const tools = parsed.result?.tools;
+                    const toolCount = Array.isArray(tools) ? tools.length : '?';
+                    ui.stopSpinnerSuccess(`Server responded with ${toolCount} tools.`);
+                }
+                catch (err) {
+                    ui.stopSpinnerFail(`Server test failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            break;
+        }
+        default:
+            ui.print('Usage: nimbus mcp <list|add|remove|test>');
+            ui.print('');
+            ui.print('Commands:');
+            ui.print('  list              List configured MCP servers');
+            ui.print('  add <cmd-or-url>  Add a new MCP server');
+            ui.print('  remove <name>     Remove an MCP server');
+            ui.print('  test <name>       Test that a server responds');
+    }
+}
+function loadRegistry() {
+    try {
+        const content = fs.readFileSync(PLUGINS_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { plugins: [] };
+    }
+}
+function saveRegistry(registry) {
+    const dir = path.dirname(PLUGINS_FILE);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(PLUGINS_FILE, JSON.stringify(registry, null, 2), 'utf-8');
+}
+export async function pluginCommand(subcommand, args) {
+    switch (subcommand) {
+        case 'list': {
+            const registry = loadRegistry();
+            if (registry.plugins.length === 0) {
+                ui.info('No plugins installed. Add one with: nimbus plugin add <name>');
+                return;
+            }
+            ui.header('Installed Plugins');
+            for (const p of registry.plugins) {
+                ui.print(`  ${ui.color(p.name, 'cyan')}  —  ${p.description ?? p.command}`);
+                if (p.args)
+                    ui.print(`    args: ${p.args.join(' ')}`);
+            }
+            break;
+        }
+        case 'add': {
+            const name = args[0];
+            if (!name) {
+                ui.print('Usage: nimbus plugin add <package-name-or-url>');
+                return;
+            }
+            const registry = loadRegistry();
+            if (registry.plugins.find(p => p.name === name)) {
+                ui.warning(`Plugin "${name}" is already installed.`);
+                return;
+            }
+            // Determine command: npm package → `npx <name>`, git URL → clone first
+            const isUrl = name.startsWith('http') || name.startsWith('git@');
+            const command = isUrl ? `node` : `npx`;
+            const pluginArgs = isUrl ? [name] : [name];
+            const entry = {
+                name,
+                command,
+                args: pluginArgs,
+                installedAt: new Date().toISOString(),
+            };
+            registry.plugins.push(entry);
+            saveRegistry(registry);
+            ui.print(`${ui.color('✓', 'green')} Plugin "${name}" added.`);
+            ui.info('Restart Nimbus for the plugin to take effect.');
+            break;
+        }
+        case 'remove': {
+            const name = args[0];
+            if (!name) {
+                ui.print('Usage: nimbus plugin remove <name>');
+                return;
+            }
+            const registry = loadRegistry();
+            const idx = registry.plugins.findIndex(p => p.name === name);
+            if (idx === -1) {
+                ui.warning(`Plugin "${name}" not found.`);
+                return;
+            }
+            registry.plugins.splice(idx, 1);
+            saveRegistry(registry);
+            ui.print(`${ui.color('✓', 'green')} Plugin "${name}" removed.`);
+            break;
+        }
+        case 'init': {
+            const cwd = process.cwd();
+            const serverFile = path.join(cwd, 'nimbus-plugin.js');
+            if (fs.existsSync(serverFile)) {
+                ui.warning(`${serverFile} already exists.`);
+                return;
+            }
+            const template = `#!/usr/bin/env node
+/**
+ * Nimbus MCP Plugin Template
+ *
+ * Implement tools that extend Nimbus's capabilities.
+ * See: https://github.com/the-ai-project-co/nimbus
+ */
+
+const readline = require('readline');
+
+const tools = [
+  {
+    name: 'my_tool',
+    description: 'A custom tool for Nimbus',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        input: { type: 'string', description: 'Input for the tool' },
+      },
+      required: ['input'],
+    },
+  },
+];
+
+// MCP server — reads JSON-RPC requests from stdin, writes responses to stdout
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+
+rl.on('line', (line) => {
+  try {
+    const request = JSON.parse(line);
+    if (request.method === 'tools/list') {
+      respond(request.id, { tools });
+    } else if (request.method === 'tools/call') {
+      const { name, arguments: args } = request.params;
+      if (name === 'my_tool') {
+        respond(request.id, { content: [{ type: 'text', text: \`You called my_tool with: \${args.input}\` }] });
+      }
+    }
+  } catch (e) {
+    process.stderr.write(\`Error: \${e}\\n\`);
+  }
+});
+
+function respond(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\\n');
+}
+`;
+            fs.writeFileSync(serverFile, template, 'utf-8');
+            fs.chmodSync(serverFile, 0o755);
+            ui.print(`${ui.color('✓', 'green')} Created ${serverFile}`);
+            ui.info('Register with: nimbus plugin add ./nimbus-plugin.js');
+            break;
+        }
+        default:
+            ui.print('Usage: nimbus plugin <list|add|remove|init>');
+    }
+}

package/dist/src/commands/preview.js

@@ -0,0 +1,356 @@
+/**
+ * Preview Command
+ *
+ * Preview infrastructure changes without applying them
+ *
+ * Usage:
+ *   nimbus preview terraform [directory]
+ *   nimbus preview k8s [directory]
+ *   nimbus preview helm [chart]
+ */
+import { logger } from '../utils';
+import { ui } from '../wizard/ui';
+import { terraformClient, k8sClient, helmClient } from '../clients';
+import { loadSafetyPolicy, evaluateSafety } from '../config/safety-policy';
+import { displaySafetySummary } from '../wizard/approval';
+/**
+ * Preview command handler
+ */
+export async function previewCommand(options) {
+    logger.info('Running preview', { type: options.type });
+    ui.newLine();
+    ui.header(`Preview ${capitalize(options.type)} Changes`);
+    switch (options.type) {
+        case 'terraform':
+            await previewTerraform(options);
+            break;
+        case 'k8s':
+            await previewKubernetes(options);
+            break;
+        case 'helm':
+            await previewHelm(options);
+            break;
+        default:
+            ui.error(`Unknown preview type: ${options.type}`);
+    }
+}
+/**
+ * Preview Terraform changes
+ */
+async function previewTerraform(options) {
+    const directory = options.directory || '.';
+    ui.info(`Directory: ${directory}`);
+    ui.newLine();
+    // Check if terraform client is available
+    const clientAvailable = await terraformClient.isAvailable();
+    if (clientAvailable) {
+        await previewTerraformWithService(options);
+    }
+    else {
+        await previewTerraformWithCLI(options);
+    }
+}
+/**
+ * Preview Terraform using service
+ */
+async function previewTerraformWithService(options) {
+    const directory = options.directory || '.';
+    ui.startSpinner({ message: 'Creating execution plan...' });
+    try {
+        const result = await terraformClient.plan(directory, {});
+        ui.stopSpinnerSuccess('Plan created');
+        ui.newLine();
+        if (!result.success) {
+            ui.error(`Plan failed: ${result.error}`);
+            return;
+        }
+        // Display plan
+        displayTerraformPlan(result, options);
+        // Run safety checks if not skipped
+        if (!options.skipSafety) {
+            await runSafetyChecks('plan', 'terraform', result.output, options);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Plan failed');
+        ui.error(error.message);
+    }
+}
+/**
+ * Preview Terraform using local CLI
+ */
+async function previewTerraformWithCLI(options) {
+    const { spawn } = await import('child_process');
+    const directory = options.directory || '.';
+    const args = ['plan', '-no-color'];
+    if (options.target) {
+        args.push('-target', options.target);
+    }
+    ui.info(`Running: terraform ${args.join(' ')}`);
+    ui.newLine();
+    return new Promise(resolve => {
+        let output = '';
+        const proc = spawn('terraform', args, {
+            cwd: directory,
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        proc.stdout?.on('data', data => {
+            const text = data.toString();
+            output += text;
+            process.stdout.write(text);
+        });
+        proc.stderr?.on('data', data => {
+            process.stderr.write(data);
+        });
+        proc.on('error', error => {
+            ui.error(`Failed to run terraform: ${error.message}`);
+            ui.info('Make sure terraform is installed and in your PATH');
+            resolve();
+        });
+        proc.on('close', async (code) => {
+            if (code === 0) {
+                ui.newLine();
+                ui.success('Plan preview complete');
+                // Run safety checks if not skipped
+                if (!options.skipSafety) {
+                    await runSafetyChecks('plan', 'terraform', output, options);
+                }
+            }
+            else {
+                ui.newLine();
+                ui.error(`Terraform plan failed with exit code ${code}`);
+            }
+            resolve();
+        });
+    });
+}
+/**
+ * Display Terraform plan results
+ */
+function displayTerraformPlan(result, options) {
+    if (!result.hasChanges) {
+        ui.success('No changes. Infrastructure is up to date.');
+        return;
+    }
+    if (options.format === 'json') {
+        console.log(JSON.stringify({ hasChanges: result.hasChanges, output: result.output }, null, 2));
+        return;
+    }
+    // Parse changes from output
+    const addMatch = result.output.match(/(\d+) to add/);
+    const changeMatch = result.output.match(/(\d+) to change/);
+    const destroyMatch = result.output.match(/(\d+) to destroy/);
+    const add = parseInt(addMatch?.[1] || '0', 10);
+    const change = parseInt(changeMatch?.[1] || '0', 10);
+    const destroy = parseInt(destroyMatch?.[1] || '0', 10);
+    // Display summary table
+    ui.print(ui.bold('Plan Summary:'));
+    ui.newLine();
+    if (add > 0) {
+        ui.print(`  ${ui.color(`+ ${add} to add`, 'green')}`);
+    }
+    if (change > 0) {
+        ui.print(`  ${ui.color(`~ ${change} to change`, 'yellow')}`);
+    }
+    if (destroy > 0) {
+        ui.print(`  ${ui.color(`- ${destroy} to destroy`, 'red')}`);
+    }
+    // Show detailed output if verbose
+    if (options.verbose) {
+        ui.newLine();
+        ui.print(ui.bold('Detailed Changes:'));
+        ui.newLine();
+        ui.print(result.output);
+    }
+}
+/**
+ * Preview Kubernetes changes
+ */
+async function previewKubernetes(options) {
+    const directory = options.directory || '.';
+    const namespace = options.namespace || 'default';
+    ui.info(`Directory: ${directory}`);
+    ui.info(`Namespace: ${namespace}`);
+    ui.newLine();
+    // Check if k8s client is available
+    const clientAvailable = await k8sClient.isAvailable();
+    // K8s client doesn't have a diff method, always use CLI
+    // If client is available, we could use dry-run apply in the future
+    if (clientAvailable) {
+        ui.info('Using kubectl diff for preview...');
+    }
+    // Use kubectl diff CLI
+    await previewKubernetesWithCLI(options);
+}
+/**
+ * Preview Kubernetes using kubectl
+ */
+async function previewKubernetesWithCLI(options) {
+    const { spawn } = await import('child_process');
+    const directory = options.directory || '.';
+    const namespace = options.namespace || 'default';
+    const args = ['diff', '-f', directory, '-n', namespace];
+    ui.info(`Running: kubectl ${args.join(' ')}`);
+    ui.newLine();
+    return new Promise(resolve => {
+        const proc = spawn('kubectl', args, {
+            stdio: 'inherit',
+        });
+        proc.on('error', error => {
+            ui.error(`Failed to run kubectl: ${error.message}`);
+            ui.info('Make sure kubectl is installed and configured');
+            resolve();
+        });
+        proc.on('close', code => {
+            ui.newLine();
+            if (code === 0) {
+                ui.success('No changes detected');
+            }
+            else if (code === 1) {
+                ui.info('Changes detected (see diff above)');
+            }
+            else {
+                ui.error(`kubectl diff failed with exit code ${code}`);
+            }
+            resolve();
+        });
+    });
+}
+/**
+ * Display Kubernetes diff
+ */
+function _displayK8sDiff(result, options) {
+    if (options.format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    ui.print(ui.bold('Kubernetes Diff:'));
+    ui.newLine();
+    if (result.output) {
+        // Color the diff output
+        const lines = result.output.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('+')) {
+                ui.print(ui.color(line, 'green'));
+            }
+            else if (line.startsWith('-')) {
+                ui.print(ui.color(line, 'red'));
+            }
+            else if (line.startsWith('@')) {
+                ui.print(ui.color(line, 'cyan'));
+            }
+            else {
+                ui.print(line);
+            }
+        }
+    }
+}
+/**
+ * Preview Helm changes
+ */
+async function previewHelm(options) {
+    const chart = options.directory || '.';
+    const release = options.release || 'preview';
+    const namespace = options.namespace || 'default';
+    ui.info(`Chart: ${chart}`);
+    ui.info(`Release: ${release}`);
+    ui.info(`Namespace: ${namespace}`);
+    ui.newLine();
+    // Check if helm client is available
+    const clientAvailable = await helmClient.isAvailable();
+    // Helm client doesn't have a diff method, always use CLI
+    // If client is available, we could use template comparison in the future
+    if (clientAvailable) {
+        ui.info('Using helm template for preview...');
+    }
+    // Use helm template CLI
+    await previewHelmWithCLI(options);
+}
+/**
+ * Preview Helm using helm CLI
+ */
+async function previewHelmWithCLI(options) {
+    const { spawn } = await import('child_process');
+    const chart = options.directory || '.';
+    const release = options.release || 'preview';
+    const namespace = options.namespace || 'default';
+    // Use helm template to preview what would be generated
+    const args = ['template', release, chart, '-n', namespace];
+    if (options.valuesFile) {
+        args.push('-f', options.valuesFile);
+    }
+    ui.info(`Running: helm ${args.join(' ')}`);
+    ui.newLine();
+    return new Promise(resolve => {
+        const proc = spawn('helm', args, {
+            stdio: 'inherit',
+        });
+        proc.on('error', error => {
+            ui.error(`Failed to run helm: ${error.message}`);
+            ui.info('Make sure helm is installed and in your PATH');
+            resolve();
+        });
+        proc.on('close', code => {
+            ui.newLine();
+            if (code === 0) {
+                ui.success('Template preview complete');
+            }
+            else {
+                ui.error(`helm template failed with exit code ${code}`);
+            }
+            resolve();
+        });
+    });
+}
+/**
+ * Display Helm diff
+ */
+function _displayHelmDiff(result, options) {
+    if (options.format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.hasDiff) {
+        ui.success('No changes. Helm release is up to date.');
+        return;
+    }
+    ui.print(ui.bold('Helm Diff:'));
+    ui.newLine();
+    if (result.output) {
+        ui.print(result.output);
+    }
+}
+/**
+ * Run safety checks on the preview
+ */
+async function runSafetyChecks(operation, type, output, options) {
+    const policy = loadSafetyPolicy();
+    const context = {
+        operation,
+        type,
+        planOutput: output,
+        metadata: {
+            directory: options.directory,
+            namespace: options.namespace,
+        },
+    };
+    const result = evaluateSafety(context, policy);
+    ui.newLine();
+    displaySafetySummary({
+        operation: `${type} ${operation}`,
+        risks: result.risks,
+        passed: result.passed,
+    });
+    if (result.requiresApproval) {
+        ui.newLine();
+        ui.warning('This operation will require approval when applied');
+    }
+}
+/**
+ * Capitalize first letter
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+// Export as default
+export default previewCommand;