@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/mcp/client.js

@@ -0,0 +1,289 @@
+/**
+ * MCP Client
+ *
+ * Connects to Model Context Protocol servers (local command-based or
+ * remote HTTP-based) and dynamically registers their tools into
+ * the Nimbus tool registry.
+ *
+ * MCP specification: https://modelcontextprotocol.io/
+ */
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+/**
+ * MCP Client that connects to a single MCP server.
+ */
+export class MCPClient {
+    config;
+    process = null;
+    connected = false;
+    requestId = 0;
+    pendingRequests = new Map();
+    buffer = '';
+    tools = [];
+    constructor(config) {
+        this.config = config;
+    }
+    /** Whether the client is connected to the server */
+    get isConnected() {
+        return this.connected;
+    }
+    /** The tools discovered from this server */
+    get discoveredTools() {
+        return this.tools;
+    }
+    /**
+     * Connect to the MCP server.
+     * For command servers, spawns the process and initializes via JSON-RPC.
+     * For HTTP servers, sends a GET to check availability.
+     */
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        if (this.config.type === 'command') {
+            await this.connectCommand();
+        }
+        else {
+            await this.connectHttp();
+        }
+        this.connected = true;
+    }
+    /**
+     * Discover tools from the connected server.
+     */
+    async listTools() {
+        if (!this.connected) {
+            await this.connect();
+        }
+        if (this.config.type === 'command') {
+            const response = (await this.sendRequest('tools/list', {}));
+            this.tools = response.tools ?? [];
+        }
+        else {
+            // HTTP server
+            const headers = {};
+            if (this.config.token) {
+                headers['Authorization'] = `Bearer ${this.config.token}`;
+            }
+            const response = await fetch(`${this.config.url}/tools/list`, { headers });
+            const data = (await response.json());
+            this.tools = data.tools ?? [];
+        }
+        return this.tools;
+    }
+    /**
+     * Call a tool on the MCP server.
+     */
+    async callTool(name, input) {
+        if (!this.connected) {
+            await this.connect();
+        }
+        try {
+            let result;
+            if (this.config.type === 'command') {
+                result = (await this.sendRequest('tools/call', {
+                    name,
+                    arguments: input,
+                }));
+            }
+            else {
+                const headers = {
+                    'Content-Type': 'application/json',
+                };
+                if (this.config.token) {
+                    headers['Authorization'] = `Bearer ${this.config.token}`;
+                }
+                const response = await fetch(`${this.config.url}/tools/call`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ name, arguments: input }),
+                });
+                result = (await response.json());
+            }
+            // MCP tool results have content array
+            const content = result.content ?? [];
+            const textParts = content
+                .filter((c) => c.type === 'text' && typeof c.text === 'string')
+                .map(c => c.text);
+            return {
+                output: textParts.join('\n') || JSON.stringify(result),
+                isError: result.isError ?? false,
+                error: result.isError ? textParts.join('\n') : undefined,
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return {
+                output: '',
+                error: `MCP tool call failed: ${msg}`,
+                isError: true,
+            };
+        }
+    }
+    /**
+     * Convert discovered MCP tools to Nimbus ToolDefinition format.
+     */
+    toToolDefinitions() {
+        return this.tools.map(mcpTool => ({
+            name: `mcp_${this.config.name}_${mcpTool.name}`,
+            description: `[MCP: ${this.config.name}] ${mcpTool.description}`,
+            inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
+            execute: async (input) => this.callTool(mcpTool.name, input),
+            permissionTier: 'ask_once',
+            category: 'mcp',
+        }));
+    }
+    /**
+     * Disconnect from the server.
+     */
+    async disconnect() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+        this.connected = false;
+        this.tools = [];
+        this.pendingRequests.clear();
+    }
+    // ---------------------------------------------------------------
+    // Internal: Command-based server
+    // ---------------------------------------------------------------
+    async connectCommand() {
+        if (!this.config.command) {
+            throw new Error(`MCP server '${this.config.name}' has type 'command' but no command specified`);
+        }
+        this.process = spawn(this.config.command, this.config.args ?? [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...this.config.env },
+        });
+        // Handle stdout (JSON-RPC responses)
+        this.process.stdout?.on('data', (data) => {
+            this.buffer += data.toString();
+            this.processBuffer();
+        });
+        this.process.on('exit', () => {
+            this.connected = false;
+        });
+        // Send initialize request
+        await this.sendRequest('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'nimbus', version: '0.2.0' },
+        });
+        // Send initialized notification
+        this.sendNotification('notifications/initialized', {});
+    }
+    async connectHttp() {
+        if (!this.config.url) {
+            throw new Error(`MCP server '${this.config.name}' has type 'http' but no URL specified`);
+        }
+        // Ping the server
+        const headers = {};
+        if (this.config.token) {
+            headers['Authorization'] = `Bearer ${this.config.token}`;
+        }
+        const response = await fetch(this.config.url, { headers });
+        if (!response.ok) {
+            throw new Error(`MCP server '${this.config.name}' returned HTTP ${response.status}`);
+        }
+    }
+    sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            this.pendingRequests.set(id, { resolve, reject });
+            const message = {
+                jsonrpc: '2.0',
+                id,
+                method,
+                params,
+            };
+            if (this.process?.stdin) {
+                this.process.stdin.write(`${JSON.stringify(message)}\n`);
+            }
+            else {
+                reject(new Error('MCP server process stdin not available'));
+            }
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`MCP request timed out: ${method}`));
+                }
+            }, 30_000);
+        });
+    }
+    sendNotification(method, params) {
+        const message = {
+            jsonrpc: '2.0',
+            method,
+            params,
+        };
+        if (this.process?.stdin) {
+            this.process.stdin.write(`${JSON.stringify(message)}\n`);
+        }
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                const message = JSON.parse(line);
+                if (message.id !== undefined && this.pendingRequests.has(message.id)) {
+                    const pending = this.pendingRequests.get(message.id);
+                    this.pendingRequests.delete(message.id);
+                    if (message.error) {
+                        pending.reject(new Error(message.error.message));
+                    }
+                    else {
+                        pending.resolve(message.result);
+                    }
+                }
+            }
+            catch {
+                // Skip non-JSON lines
+            }
+        }
+    }
+}
+/**
+ * Convert a JSON Schema object to a Zod schema.
+ * Handles basic types used in MCP tool definitions.
+ */
+function jsonSchemaToZod(schema) {
+    if (!schema || schema.type !== 'object') {
+        return z.object({});
+    }
+    const shape = {};
+    const required = new Set(schema.required ?? []);
+    for (const [key, prop] of Object.entries(schema.properties ?? {})) {
+        let fieldSchema;
+        switch (prop.type) {
+            case 'string':
+                fieldSchema = prop.enum ? z.enum(prop.enum) : z.string();
+                break;
+            case 'number':
+            case 'integer':
+                fieldSchema = z.number();
+                break;
+            case 'boolean':
+                fieldSchema = z.boolean();
+                break;
+            case 'array':
+                fieldSchema = z.array(prop.items ? jsonSchemaToZod(prop.items) : z.unknown());
+                break;
+            case 'object':
+                fieldSchema = jsonSchemaToZod(prop);
+                break;
+            default:
+                fieldSchema = z.unknown();
+        }
+        if (prop.description) {
+            fieldSchema = fieldSchema.describe(prop.description);
+        }
+        shape[key] = required.has(key) ? fieldSchema : fieldSchema.optional();
+    }
+    return z.object(shape);
+}

package/dist/src/mcp/index.js

@@ -0,0 +1,5 @@
+/**
+ * MCP (Model Context Protocol) -- Barrel re-exports
+ */
+export { MCPClient } from './client';
+export { MCPManager } from './manager';

package/dist/src/mcp/manager.js

@@ -0,0 +1,113 @@
+/**
+ * MCP Manager
+ *
+ * Manages multiple MCP server connections and provides a unified
+ * interface for tool discovery and registration.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { MCPClient } from './client';
+export class MCPManager {
+    clients = new Map();
+    initialized = false;
+    /**
+     * Load MCP server configurations from config files.
+     * Searches: .nimbus/mcp.json, nimbus.json, ~/.nimbus/mcp.json
+     */
+    async loadConfig(cwd) {
+        const configPaths = [
+            cwd ? path.join(cwd, '.nimbus', 'mcp.json') : null,
+            cwd ? path.join(cwd, 'nimbus.json') : null,
+            path.join(homedir(), '.nimbus', 'mcp.json'),
+        ].filter((p) => p !== null);
+        for (const configPath of configPaths) {
+            if (fs.existsSync(configPath)) {
+                try {
+                    const content = fs.readFileSync(configPath, 'utf-8');
+                    const config = JSON.parse(content);
+                    if (config.mcpServers) {
+                        for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+                            if (!this.clients.has(name)) {
+                                this.clients.set(name, new MCPClient({ ...serverConfig, name }));
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip invalid config files
+                }
+            }
+        }
+        this.initialized = true;
+    }
+    /**
+     * Connect to all configured MCP servers and discover tools.
+     * Lazy servers are skipped until explicitly needed.
+     */
+    async connectAll() {
+        if (!this.initialized) {
+            await this.loadConfig();
+        }
+        const connectPromises = [];
+        for (const [name, client] of this.clients) {
+            if (!client.config.lazy) {
+                connectPromises.push(client
+                    .connect()
+                    .then(() => client.listTools())
+                    .then(() => undefined)
+                    .catch((err) => {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.warn(`MCP server '${name}' failed to connect: ${msg}`);
+                }));
+            }
+        }
+        await Promise.all(connectPromises);
+    }
+    /**
+     * Get all tool definitions from connected MCP servers.
+     */
+    getAllTools() {
+        const tools = [];
+        for (const client of this.clients.values()) {
+            if (client.isConnected) {
+                tools.push(...client.toToolDefinitions());
+            }
+        }
+        return tools;
+    }
+    /**
+     * Register all MCP tools into a tool registry.
+     */
+    registerTools(registry) {
+        for (const tool of this.getAllTools()) {
+            try {
+                registry.register(tool);
+            }
+            catch {
+                // Skip duplicate tool names
+            }
+        }
+    }
+    /**
+     * Get a specific client by server name.
+     */
+    getClient(name) {
+        return this.clients.get(name);
+    }
+    /**
+     * Disconnect all MCP servers.
+     */
+    async disconnectAll() {
+        const disconnectPromises = Array.from(this.clients.values()).map(client => client.disconnect());
+        await Promise.all(disconnectPromises);
+    }
+    /** Number of configured servers */
+    get serverCount() {
+        return this.clients.size;
+    }
+    /** Number of connected servers */
+    get connectedCount() {
+        return Array.from(this.clients.values()).filter(c => c.isConnected).length;
+    }
+}

package/dist/src/nimbus.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * Nimbus CLI — Main Entry Point
+ *
+ * Single-process embedded architecture. All modules (LLM, tools, state,
+ * enterprise, engine, generator) run in-process — no HTTP services needed.
+ *
+ * Usage:
+ *   bun src/nimbus.ts --version
+ *   bun src/nimbus.ts --help
+ *   bun src/nimbus.ts chat
+ *   bun src/nimbus.ts ask "what is terraform"
+ *   bun src/nimbus.ts generate terraform --provider aws
+ *   bun src/nimbus.ts tf plan
+ */
+import { VERSION } from './version';
+/**
+ * Non-blocking update check. Fires a single HTTPS HEAD request to npm
+ * and prints a one-liner to stderr if a newer version exists. The check
+ * uses a 3-second timeout so it never slows startup.
+ */
+function checkForUpdates() {
+    // Only check for interactive TTY sessions, not in CI
+    if (!process.stderr.isTTY || process.env.CI || process.env.NIMBUS_NO_UPDATE_CHECK) {
+        return;
+    }
+    // Fire-and-forget — deferred to let the TUI render first
+    (async () => {
+        try {
+            // Small delay so the check doesn't compete with startup I/O
+            await new Promise(r => setTimeout(r, 500));
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 1500);
+            const res = await fetch('https://registry.npmjs.org/@build-astron-co/nimbus/latest', {
+                signal: controller.signal,
+                headers: { Accept: 'application/json' },
+            });
+            clearTimeout(timeout);
+            if (!res.ok) {
+                return;
+            }
+            const data = (await res.json());
+            const latest = data.version;
+            if (!latest || latest === VERSION) {
+                return;
+            }
+            // Simple semver comparison: split on dots, compare numerically
+            const current = VERSION.split('.').map(Number);
+            const remote = latest.split('.').map(Number);
+            let isNewer = false;
+            for (let i = 0; i < 3; i++) {
+                if ((remote[i] ?? 0) > (current[i] ?? 0)) {
+                    isNewer = true;
+                    break;
+                }
+                if ((remote[i] ?? 0) < (current[i] ?? 0)) {
+                    break;
+                }
+            }
+            if (isNewer) {
+                process.stderr.write(`\x1b[33m  Update available: ${VERSION} → ${latest}. Run: nimbus upgrade\x1b[0m\n`);
+            }
+        }
+        catch {
+            // Network errors are silently ignored
+        }
+    })();
+}
+// ---------------------------------------------------------------------------
+// Global error handlers (Gap 6: prevent silent crashes from unhandled promises)
+// ---------------------------------------------------------------------------
+process.on('unhandledRejection', reason => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    process.stderr.write(`\x1b[31mUnhandled promise rejection: ${msg}\x1b[0m\n`);
+    // Don't exit — let the TUI continue running. The user can see the error
+    // and decide whether to continue or quit.
+});
+process.on('uncaughtException', error => {
+    process.stderr.write(`\x1b[31mUncaught exception: ${error.message}\x1b[0m\n`);
+    if (error.stack) {
+        process.stderr.write(`\x1b[2m${error.stack}\x1b[0m\n`);
+    }
+    // For uncaught exceptions, set exit code but let cleanup run
+    process.exitCode = 1;
+});
+async function main() {
+    let args = process.argv.slice(2);
+    // G11: Global --project / --cwd flag: change working directory before command dispatch
+    const cwdFlagIdx = args.findIndex(a => a === '--project' || a === '--cwd');
+    if (cwdFlagIdx !== -1 && args[cwdFlagIdx + 1]) {
+        const { resolve } = await import('node:path');
+        const targetDir = resolve(args[cwdFlagIdx + 1]);
+        process.chdir(targetDir);
+        args.splice(cwdFlagIdx, 2);
+    }
+    // Handle --version and -v before anything else (no init needed)
+    if (args[0] === '--version' || args[0] === '-v') {
+        console.log(`nimbus ${VERSION}`);
+        process.exit(0);
+    }
+    // Handle --completion-install / completion <shell> — print shell completion script
+    if (args[0] === '--completion-install' || args[0] === 'completion') {
+        const shell = args[1] ?? 'bash';
+        const { join } = await import('node:path');
+        const { readFileSync } = await import('node:fs');
+        const { fileURLToPath } = await import('node:url');
+        const dir = join(fileURLToPath(import.meta.url), '../../completions');
+        try {
+            process.stdout.write(readFileSync(join(dir, `nimbus.${shell}`), 'utf-8'));
+        }
+        catch {
+            console.error(`No completion script for shell: ${shell}. Available: bash, zsh, fish`);
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    // Show help when explicitly requested — handles both `nimbus --help`
+    // and subcommand-level help like `nimbus chat --help` or `nimbus tf -h`.
+    if (args.includes('--help') || args.includes('-h')) {
+        const otherArgs = args.filter(a => a !== '--help' && a !== '-h');
+        args.length = 0;
+        args.push('help', ...otherArgs);
+    }
+    // Kick off a non-blocking update check (fire-and-forget)
+    checkForUpdates();
+    // Default no-args: launch chat (or onboarding if first run)
+    if (args.length === 0) {
+        const { needsOnboarding } = await import('./commands/onboarding');
+        if (needsOnboarding()) {
+            args[0] = 'onboarding';
+        }
+        else {
+            args[0] = 'chat';
+        }
+    }
+    // Initialize the application (SQLite, LLM router, etc.)
+    const { initApp, shutdownApp } = await import('./app');
+    // Register shutdown hooks for clean exit.
+    // Use process.exitCode instead of process.exit() to avoid racing
+    // with finally blocks and async cleanup in the TUI.
+    let cleaningUp = false;
+    const cleanup = async () => {
+        if (cleaningUp) {
+            return;
+        } // Prevent double-cleanup on rapid Ctrl+C
+        cleaningUp = true;
+        await shutdownApp();
+        process.exitCode = 0;
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    try {
+        // Commands that don't need full initialization
+        const noInitCommands = new Set([
+            'help',
+            'version',
+            'doctor',
+            'onboarding',
+            'upgrade',
+            'update',
+        ]);
+        if (!noInitCommands.has(args[0])) {
+            // Show brief startup indicator for interactive commands
+            if (args[0] === 'chat' && process.stderr.isTTY) {
+                process.stderr.write('\x1b[2mStarting Nimbus...\x1b[0m');
+            }
+            await initApp();
+            if (args[0] === 'chat' && process.stderr.isTTY) {
+                process.stderr.write('\r\x1b[K');
+            }
+        }
+        // Resolve aliases before dispatching (L2)
+        try {
+            const { resolveAlias } = await import('./commands/alias');
+            args = resolveAlias(args);
+        }
+        catch {
+            /* alias file not found — ignore */
+        }
+        // Import and run CLI command router
+        const { runCommand } = await import('./cli');
+        await runCommand(args);
+        // After onboarding, clear auth cache, initialize app, and launch chat
+        if (args[0] === 'onboarding') {
+            // Clear the auth-bridge cache so the router picks up freshly-saved credentials
+            try {
+                const { clearAuthCache } = await import('./llm/auth-bridge');
+                clearAuthCache();
+            }
+            catch {
+                /* non-critical */
+            }
+            await initApp();
+            await runCommand(['chat']);
+        }
+    }
+    catch (error) {
+        const msg = error.message || String(error);
+        if (error.code === 'MODULE_NOT_FOUND') {
+            console.error(`Error: Missing module — ${msg}`);
+            console.error('Run "npm install" to install dependencies.');
+        }
+        else {
+            console.error(`Error: ${msg}`);
+        }
+        process.exit(1);
+    }
+    finally {
+        await shutdownApp();
+    }
+}
+main();

package/dist/src/plugins/index.js

@@ -0,0 +1,13 @@
+/**
+ * Nimbus Plugin System — Public API
+ *
+ * Re-exports the primary class and types needed by the rest of the
+ * application and by external consumers that want to integrate with the
+ * plugin system without importing internal submodules directly.
+ *
+ * @module plugins
+ */
+// Manager (class + singleton)
+export { PluginManager, pluginManager } from './manager';
+// Loader (class — exposed for testing and advanced use)
+export { PluginLoader } from './loader';