@miphamai/cli 0.6.3 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/core/engine.ts

@@ -431,6 +431,27 @@ export class QueryEngine {
     return this.tools
   }
 
+  /** Register a tool dynamically (used by MCP auto-registration). */
+  registerTool(tool: ToolDefinition): void {
+    if (this.tools.has(tool.name)) {
+      process.stderr.write(`[mcp] Tool collision: "${tool.name}" already registered. Skipping.\n`)
+      return
+    }
+    this.tools.set(tool.name, tool)
+  }
+
+  /** Remove a dynamically registered tool by name. */
+  unregisterTool(name: string): void {
+    this.tools.delete(name)
+  }
+
+  /** Register multiple tools at once. */
+  registerTools(tools: ToolDefinition[]): void {
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool)
+    }
+  }
+
   switchProvider(providerId: string, modelId?: string): void {
     this.registry.switchProvider(providerId, modelId)
   }

package/src/index.tsx

@@ -11,6 +11,7 @@ import { SkillsLoader } from './skills/loader'
 import { PluginManager } from './plugin/plugin-manager'
 import { createToolRegistry } from './tools'
 import { McpClient } from './mcp/client'
+import { registerMcpServerTools } from './mcp/registry'
 import { HookEngine } from './core/hooks'
 import { ArtifactServer } from './artifacts/server'
 import { ARTIFACTS_DIR, ARTIFACT_PORT, MIPHAM_DIR } from './shared/constants'
@@ -50,17 +51,6 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Load configuration
   const config = loadConfig()
 
-  // Connect MCP servers (fire-and-forget — do not block startup)
-  const mcpServers = config.skills?.mcpServers ?? []
-  if (mcpServers.length > 0) {
-    const mcp = McpClient.getInstance()
-    for (const server of mcpServers) {
-      mcp.connect(server).catch((err) => {
-        process.stderr.write(`[mcp] Failed to connect "${server.name}": ${String(err)}\n`)
-      })
-    }
-  }
-
   // Bootstrap providers
   const defaultProvider = options.provider || config.defaultProvider
   const defaultModel = options.model || config.defaultModel
@@ -97,9 +87,34 @@ export async function runApp(options: RunOptions): Promise<void> {
     context.setSystemPrompt(instructions.buildSystemPrompt())
   }
 
-  // Create tool registry with all 16 tools
+  // Create tool registry with all built-in tools
   const tools = createToolRegistry()
 
+  // Connect MCP servers and register their tools into the tool registry.
+  // Uses Promise.allSettled for parallel connection — failures are non-fatal.
+  const mcpServers = config.skills?.mcpServers ?? []
+  if (mcpServers.length > 0) {
+    const mcp = McpClient.getInstance()
+    const results = await Promise.allSettled(
+      mcpServers.map(async (server) => {
+        await mcp.connect(server)
+        const count = registerMcpServerTools(server.name, tools)
+        if (count > 0) {
+          process.stderr.write(`[mcp] "${server.name}": registered ${count} tools\n`)
+        }
+      }),
+    )
+    // Log failures (non-fatal — app starts without that server's tools)
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]!
+      if (result.status === 'rejected') {
+        process.stderr.write(
+          `[mcp] Failed to connect "${mcpServers[i]!.name}": ${String(result.reason)}\n`,
+        )
+      }
+    }
+  }
+
   // Initialize hook engine — register skill-defined hooks
   const hookEngine = new HookEngine()
   for (const skill of skillsLoader.list()) {

package/src/mcp/registry.ts

@@ -0,0 +1,142 @@
+/**
+ * MCP Tool Registry — converts MCP server tools into main ToolDefinitions
+ * and registers them into the central tool registry.
+ *
+ * Naming convention: mcp__<sanitizedServerName>__<sanitizedToolName>
+ * Example: server "chrome-devtools-mcp" tool "click" → "mcp__chrome_devtools_mcp__click"
+ */
+
+import type { ToolDefinition as McpToolDefinition, ToolCallResult } from './types'
+import type { ToolDefinition, ToolResult, ToolContext } from '../shared/types'
+import { McpClient } from './client'
+
+const MCP_TOOL_PREFIX = 'mcp__'
+const MAX_NAME_LENGTH = 128
+
+/**
+ * Sanitize a name for use in a tool identifier.
+ * Lowercases and replaces non-alphanumeric characters (except hyphens) with underscores.
+ */
+function sanitizeName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+}
+
+/**
+ * Build a namespaced MCP tool name.
+ * Format: mcp__<sanitizedServerName>__<sanitizedToolName>
+ */
+function buildToolName(serverName: string, toolName: string): string {
+  const base = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__${sanitizeName(toolName)}`
+  if (base.length <= MAX_NAME_LENGTH) return base
+  const prefix = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__`
+  const maxToolLen = MAX_NAME_LENGTH - prefix.length
+  return prefix + sanitizeName(toolName).slice(0, maxToolLen)
+}
+
+/**
+ * Convert an MCP server ToolDefinition into the main ToolDefinition format
+ * that can be registered in the central tool registry.
+ */
+export function convertMcpTool(serverName: string, mcpTool: McpToolDefinition): ToolDefinition {
+  const toolName = buildToolName(serverName, mcpTool.name)
+
+  // Build parameters schema — pass through MCP inputSchema as-is
+  const parameters: Record<string, unknown> = {
+    type: 'object',
+    properties: (mcpTool.inputSchema.properties as Record<string, unknown>) ?? {},
+  }
+  if (mcpTool.inputSchema.required) {
+    parameters.required = mcpTool.inputSchema.required
+  }
+
+  return {
+    name: toolName,
+    description: `[MCP:${serverName}] ${mcpTool.description || mcpTool.name}`,
+    category: 'system',
+    permission: 'ask',
+    parameters,
+    async execute(params: Record<string, unknown>, _ctx: ToolContext): Promise<ToolResult> {
+      const client = McpClient.getInstance()
+
+      const conn = client.getConnection(serverName)
+      if (!conn || conn.status !== 'connected') {
+        return {
+          success: false,
+          content: '',
+          error: `MCP server "${serverName}" is not connected (status: ${conn?.status || 'unknown'}). The server may have crashed or been disconnected.`,
+        }
+      }
+
+      const result: ToolCallResult = await client.callTool(serverName, mcpTool.name, params)
+
+      const text = result.content
+        .map((c) => {
+          if (c.type === 'text' && c.text) return c.text
+          if (c.type === 'image') return `[Image: ${c.mimeType || 'unknown'}]`
+          return JSON.stringify(c)
+        })
+        .join('\n')
+
+      return {
+        success: !result.isError,
+        content: text || '(empty result)',
+        error: result.isError ? text : undefined,
+      }
+    },
+  }
+}
+
+/**
+ * Register all tools from a connected MCP server into the tool registry.
+ * Returns the number of tools registered.
+ */
+export function registerMcpServerTools(
+  serverName: string,
+  toolsMap: Map<string, ToolDefinition>,
+): number {
+  const client = McpClient.getInstance()
+  const mcpTools = client.getTools(serverName)
+  let registered = 0
+
+  for (const mcpTool of mcpTools) {
+    try {
+      const tool = convertMcpTool(serverName, mcpTool)
+
+      if (toolsMap.has(tool.name)) {
+        process.stderr.write(
+          `[mcp] Tool collision: "${tool.name}" (from server "${serverName}") conflicts with existing tool. Skipping.\n`,
+        )
+        continue
+      }
+
+      toolsMap.set(tool.name, tool)
+      registered++
+    } catch (err) {
+      process.stderr.write(
+        `[mcp] Failed to register tool "${mcpTool.name}" from server "${serverName}": ${String(err)}\n`,
+      )
+    }
+  }
+
+  return registered
+}
+
+/**
+ * Unregister all tools previously registered from a specific MCP server.
+ * Tools are identified by the mcp__<serverName>__ prefix.
+ */
+export function unregisterMcpServerTools(
+  serverName: string,
+  toolsMap: Map<string, ToolDefinition>,
+): void {
+  const prefix = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__`
+  for (const name of toolsMap.keys()) {
+    if (name.startsWith(prefix)) {
+      toolsMap.delete(name)
+    }
+  }
+}