monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/mcp-client.js

@@ -0,0 +1,270 @@
+/**
+ * CLI MCP Client
+ *
+ * Thin wrapper for calling MCP tools from CLI commands.
+ * Implements ADR-005: MCP-First API Design - CLI as thin wrapper around MCP tools
+ *
+ * This provides a simple interface for CLI commands to call MCP tools without
+ * containing hardcoded business logic. All business logic lives in MCP tool handlers.
+ */
+// Import MCP tool handlers from local package
+import { agentTools } from './mcp-tools/agent-tools.js';
+import { swarmTools } from './mcp-tools/swarm-tools.js';
+import { memoryTools } from './mcp-tools/memory-tools.js';
+import { configTools } from './mcp-tools/config-tools.js';
+import { hooksTools } from './mcp-tools/hooks-tools.js';
+import { taskTools } from './mcp-tools/task-tools.js';
+import { sessionTools } from './mcp-tools/session-tools.js';
+import { hiveMindTools } from './mcp-tools/hive-mind-tools.js';
+import { workflowTools } from './mcp-tools/workflow-tools.js';
+import { analyzeTools } from './mcp-tools/analyze-tools.js';
+import { progressTools } from './mcp-tools/progress-tools.js';
+import { embeddingsTools } from './mcp-tools/embeddings-tools.js';
+import { claimsTools } from './mcp-tools/claims-tools.js';
+import { securityTools } from './mcp-tools/security-tools.js';
+import { transferTools } from './mcp-tools/transfer-tools.js';
+// V2 Compatibility tools
+import { systemTools } from './mcp-tools/system-tools.js';
+import { terminalTools } from './mcp-tools/terminal-tools.js';
+import { neuralTools } from './mcp-tools/neural-tools.js';
+import { performanceTools } from './mcp-tools/performance-tools.js';
+import { githubTools } from './mcp-tools/github-tools.js';
+import { daaTools } from './mcp-tools/daa-tools.js';
+import { coordinationTools } from './mcp-tools/coordination-tools.js';
+import { browserTools } from './mcp-tools/browser-tools.js';
+// Phase 6: AgentDB v1 controller tools
+import { agentdbTools } from './mcp-tools/agentdb-tools.js';
+// RuVector WASM tools
+import { ruvllmWasmTools } from './mcp-tools/ruvllm-tools.js';
+import { wasmAgentTools } from './mcp-tools/wasm-agent-tools.js';
+import { guidanceTools } from './mcp-tools/guidance-tools.js';
+import { autopilotTools } from './mcp-tools/autopilot-tools.js';
+// Knowledge graph tools (graphify — deprecated shims + monograph native)
+import { graphifyTools } from './mcp-tools/graphify-tools.js';
+import { monographTools } from './mcp-tools/monograph-tools.js';
+// Coverage-aware routing tools
+import { coverageRouterTools } from './ruvector/coverage-tools.js';
+// A2A Agent Card protocol (source: https://a2a-protocol.org)
+import { a2aTools } from './mcp-tools/a2a-tools.js';
+/**
+ * MCP Tool Registry
+ * Maps tool names to their handler functions
+ */
+const TOOL_REGISTRY = new Map();
+// Register all tools — refuse silent overrides so a future plugin/IPFS-loaded
+// tool cannot shadow a built-in handler (e.g. `agent_spawn`, `memory_store`)
+// without an explicit override flag. Logical-name collision is a real concern
+// when the plugin system goes live.
+function registerTools(tools, options = {}) {
+    for (const tool of tools) {
+        if (TOOL_REGISTRY.has(tool.name) && !options.override) {
+            throw new Error(`Tool name collision: ${tool.name} already registered`);
+        }
+        TOOL_REGISTRY.set(tool.name, tool);
+    }
+}
+// Initialize registry with all available tools
+registerTools([
+    ...agentTools,
+    ...swarmTools,
+    ...memoryTools,
+    ...configTools,
+    ...hooksTools,
+    ...taskTools,
+    ...sessionTools,
+    ...hiveMindTools,
+    ...workflowTools,
+    ...analyzeTools,
+    ...progressTools,
+    ...embeddingsTools,
+    ...claimsTools,
+    ...securityTools,
+    ...transferTools,
+    // V2 Compatibility tools
+    ...systemTools,
+    ...terminalTools,
+    ...neuralTools,
+    ...performanceTools,
+    ...githubTools,
+    ...daaTools,
+    ...coordinationTools,
+    ...browserTools,
+    // Phase 6: AgentDB v1 controller tools
+    ...agentdbTools,
+    // RuVector WASM tools
+    ...ruvllmWasmTools,
+    ...wasmAgentTools,
+    // Guidance & discovery tools
+    ...guidanceTools,
+    // Autopilot persistent completion tools
+    ...autopilotTools,
+    // Knowledge graph — native monograph tools (replaces Python graphify)
+    ...monographTools,
+    // Graphify deprecated shims — proxy to monograph_* tools
+    ...graphifyTools,
+    // Coverage-aware routing tools
+    ...coverageRouterTools,
+    // A2A Agent Card protocol (source: https://a2a-protocol.org)
+    ...a2aTools,
+]);
+/**
+ * MCP Client Error
+ */
+export class MCPClientError extends Error {
+    toolName;
+    cause;
+    constructor(message, toolName, cause) {
+        super(message);
+        this.toolName = toolName;
+        this.cause = cause;
+        this.name = 'MCPClientError';
+    }
+}
+/**
+ * Call an MCP tool by name with input parameters
+ *
+ * @param toolName - Name of the MCP tool (e.g., 'agent_spawn', 'swarm_init')
+ * @param input - Input parameters for the tool
+ * @param context - Optional tool context
+ * @returns Promise resolving to tool result
+ * @throws {MCPClientError} If tool not found or execution fails
+ *
+ * @example
+ * ```typescript
+ * // Spawn an agent
+ * const result = await callMCPTool('agent_spawn', {
+ *   agentType: 'coder',
+ *   priority: 'normal'
+ * });
+ *
+ * // Initialize swarm
+ * const swarm = await callMCPTool('swarm_init', {
+ *   topology: 'hierarchical-mesh',
+ *   maxAgents: 15
+ * });
+ * ```
+ */
+export async function callMCPTool(toolName, input = {}, context) {
+    // Look up tool in registry
+    const tool = TOOL_REGISTRY.get(toolName);
+    if (!tool) {
+        throw new MCPClientError(`MCP tool not found: ${toolName}`, toolName);
+    }
+    try {
+        // Call the tool handler
+        const result = await tool.handler(input, context);
+        return result;
+    }
+    catch (error) {
+        // Wrap and re-throw with context
+        throw new MCPClientError(`Failed to execute MCP tool '${toolName}': ${error instanceof Error ? error.message : String(error)}`, toolName, error instanceof Error ? error : undefined);
+    }
+}
+/**
+ * Get tool metadata by name
+ *
+ * @param toolName - Name of the MCP tool
+ * @returns Tool metadata or undefined if not found
+ */
+export function getToolMetadata(toolName) {
+    const tool = TOOL_REGISTRY.get(toolName);
+    if (!tool) {
+        return undefined;
+    }
+    // Return everything except the handler function
+    return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        category: tool.category,
+        tags: tool.tags,
+        version: tool.version,
+        cacheable: tool.cacheable,
+        cacheTTL: tool.cacheTTL,
+    };
+}
+/**
+ * List all available MCP tools
+ *
+ * @param category - Optional category filter
+ * @returns Array of tool metadata
+ */
+export function listMCPTools(category) {
+    const tools = Array.from(TOOL_REGISTRY.values());
+    const filtered = category
+        ? tools.filter(t => t.category === category)
+        : tools;
+    return filtered.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        category: tool.category,
+        tags: tool.tags,
+        version: tool.version,
+        cacheable: tool.cacheable,
+        cacheTTL: tool.cacheTTL,
+    }));
+}
+/**
+ * Check if an MCP tool exists
+ *
+ * @param toolName - Name of the MCP tool
+ * @returns True if tool exists
+ */
+export function hasTool(toolName) {
+    return TOOL_REGISTRY.has(toolName);
+}
+/**
+ * Get all tool categories
+ *
+ * @returns Array of unique categories
+ */
+export function getToolCategories() {
+    const categories = new Set();
+    TOOL_REGISTRY.forEach(tool => {
+        if (tool.category) {
+            categories.add(tool.category);
+        }
+    });
+    return Array.from(categories).sort();
+}
+/**
+ * Validate tool input against schema
+ *
+ * @param toolName - Name of the MCP tool
+ * @param input - Input to validate
+ * @returns Validation result with errors if any
+ */
+export function validateToolInput(toolName, input) {
+    const tool = TOOL_REGISTRY.get(toolName);
+    if (!tool) {
+        return {
+            valid: false,
+            errors: [`Tool '${toolName}' not found`],
+        };
+    }
+    // Basic validation - check required fields
+    const schema = tool.inputSchema;
+    const errors = [];
+    if (schema.required && Array.isArray(schema.required)) {
+        for (const requiredField of schema.required) {
+            if (!(requiredField in input)) {
+                errors.push(`Missing required field: ${requiredField}`);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors: errors.length > 0 ? errors : undefined,
+    };
+}
+export default {
+    callMCPTool,
+    getToolMetadata,
+    listMCPTools,
+    hasTool,
+    getToolCategories,
+    validateToolInput,
+    MCPClientError,
+};
+//# sourceMappingURL=mcp-client.js.map

package/packages/@monomind/cli/dist/src/mcp-server.d.ts

@@ -0,0 +1,170 @@
+/**
+ * CLI MCP Server Management
+ *
+ * Provides server lifecycle management for MCP integration:
+ * - Start/stop/status methods with process management
+ * - Health check endpoint integration
+ * - Graceful shutdown handling
+ * - PID file management for daemon detection
+ * - Event-based status monitoring
+ *
+ * Performance Targets:
+ * - Server startup: <400ms
+ * - Health check: <10ms
+ * - Graceful shutdown: <5s
+ *
+ * @module @monomind/cli/mcp-server
+ * @version 3.0.0
+ */
+import { EventEmitter } from 'events';
+/**
+ * MCP Server configuration
+ */
+export interface MCPServerOptions {
+    transport?: 'stdio' | 'http' | 'websocket';
+    host?: string;
+    port?: number;
+    pidFile?: string;
+    logFile?: string;
+    tools?: string[] | 'all';
+    daemonize?: boolean;
+    timeout?: number;
+}
+/**
+ * MCP Server status
+ */
+export interface MCPServerStatus {
+    running: boolean;
+    pid?: number;
+    transport?: string;
+    host?: string;
+    port?: number;
+    uptime?: number;
+    tools?: number;
+    startedAt?: string;
+    health?: {
+        healthy: boolean;
+        error?: string;
+        metrics?: Record<string, number>;
+    };
+}
+/**
+ * MCP Server Manager
+ *
+ * Manages the lifecycle of the MCP server process
+ */
+export declare class MCPServerManager extends EventEmitter {
+    private options;
+    private process?;
+    private server?;
+    private startTime?;
+    private _stdioServerStarted;
+    private healthCheckInterval?;
+    constructor(options?: MCPServerOptions);
+    /**
+     * Start the MCP server
+     */
+    start(): Promise<MCPServerStatus>;
+    /**
+     * Stop the MCP server
+     */
+    stop(force?: boolean): Promise<void>;
+    /**
+     * Get server status
+     */
+    getStatus(): Promise<MCPServerStatus>;
+    /**
+     * Check server health
+     */
+    checkHealth(): Promise<{
+        healthy: boolean;
+        error?: string;
+        metrics?: Record<string, number>;
+    }>;
+    /**
+     * Restart the server
+     */
+    restart(): Promise<MCPServerStatus>;
+    /**
+     * Start stdio server in-process
+     * Handles stdin/stdout directly like V2 implementation
+     */
+    private startStdioServer;
+    /**
+     * Handle incoming MCP message
+     */
+    private handleMCPMessage;
+    /**
+     * Start HTTP server in-process.
+     *
+     * SECURITY: refuses to bind to non-loopback hosts unless the operator opts
+     * in via MONOMIND_MCP_ALLOW_REMOTE=1 AND provides a bearer token via
+     * MONOMIND_MCP_TOKEN. Without this gate, `--host 0.0.0.0` exposed every
+     * registered tool (including agent_spawn, terminal-tools, system tools) to
+     * any LAN attacker as unauthenticated RCE.
+     */
+    private startHttpServer;
+    /**
+     * Wait for server to be ready
+     */
+    private waitForReady;
+    /**
+     * Wait for process to exit
+     */
+    private waitForExit;
+    /**
+     * Start health monitoring
+     */
+    private startHealthMonitoring;
+    /**
+     * Write PID file
+     */
+    private writePidFile;
+    /**
+     * Read PID file
+     */
+    private readPidFile;
+    /**
+     * Remove PID file
+     */
+    private removePidFile;
+    /**
+     * Check if process is running AND is a node/monomind process.
+     * Plain `kill -0` returns true for any process with the same owner,
+     * which causes false positives when the OS recycles the PID.
+     */
+    private isProcessRunning;
+    /**
+     * Make HTTP request
+     */
+    private httpRequest;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+}
+/**
+ * Create MCP server manager
+ */
+export declare function createMCPServerManager(options?: MCPServerOptions): MCPServerManager;
+/**
+ * Get or create server manager singleton
+ *
+ * FIX for issue #942: Recreate singleton if transport type changes
+ * Previously, once created with stdio (default), HTTP options were ignored
+ */
+export declare function getServerManager(options?: MCPServerOptions): MCPServerManager;
+/**
+ * Quick start MCP server
+ */
+export declare function startMCPServer(options?: MCPServerOptions): Promise<MCPServerStatus>;
+/**
+ * Quick stop MCP server
+ */
+export declare function stopMCPServer(force?: boolean): Promise<void>;
+/**
+ * Get MCP server status
+ */
+export declare function getMCPServerStatus(): Promise<MCPServerStatus>;
+export default MCPServerManager;
+//# sourceMappingURL=mcp-server.d.ts.map