daemora 1.0.0

package/src/mcp/MCPClient.js

@@ -0,0 +1,186 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+/**
+ * Expand ${VAR_NAME} patterns in string values using process.env.
+ * Works recursively on objects: values only, keys are left untouched.
+ *
+ * This lets users write:
+ *   "Authorization": "Bearer ${MY_API_TOKEN}"
+ *   "url": "https://api.example.com/${TENANT_ID}/mcp"
+ * without storing the actual secret in mcp.json.
+ */
+function expandEnvVars(value) {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? "");
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = expandEnvVars(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * MCP Client — connects to a single MCP server.
+ *
+ * Supports three transports:
+ *
+ *   stdio  — local subprocess. Auth via `env` (merged into process.env for the child).
+ *            config: { command, args, env }
+ *
+ *   http   — Streamable HTTP (MCP 2025-03-26 spec). Auth via `headers`.
+ *            config: { url, headers: { "Authorization": "Bearer ${TOKEN}", ... } }
+ *
+ *   sse    — Legacy SSE transport. Auth via `headers` (applied to both the SSE GET
+ *            stream and POST calls). Prefer http for new servers.
+ *            config: { url, transport: "sse", headers: { "Authorization": "Bearer ${TOKEN}", ... } }
+ *
+ * Header values support ${VAR_NAME} expansion from process.env at connect time.
+ */
+export class MCPClient {
+  constructor(name, serverConfig) {
+    this.name = name;
+    this.serverConfig = serverConfig;
+    this.client = null;
+    this.transport = null;
+    this.tools = [];
+    this.connected = false;
+  }
+
+  /**
+   * Connect to the MCP server.
+   */
+  async connect() {
+    try {
+      this.client = new Client(
+        { name: `daemora-${this.name}`, version: "1.0.0" },
+        { capabilities: { tools: {} } }
+      );
+
+      this.transport = this.createTransport();
+      await this.client.connect(this.transport);
+      this.connected = true;
+
+      const toolsResult = await this.client.listTools();
+      this.tools = toolsResult.tools || [];
+
+      console.log(
+        `[MCP:${this.name}] Connected — ${this.tools.length} tools: ${this.tools.map((t) => t.name).join(", ")}`
+      );
+
+      return this.tools;
+    } catch (error) {
+      console.log(`[MCP:${this.name}] Connection failed: ${error.message}`);
+      this.connected = false;
+      return [];
+    }
+  }
+
+  /**
+   * Create the transport based on config.
+   *
+   * stdio  → StdioClientTransport  — env vars merged into subprocess environment
+   * sse    → SSEClientTransport    — headers in requestInit + eventSourceInit
+   * http   → StreamableHTTPClientTransport — headers in requestInit
+   */
+  createTransport() {
+    const cfg = this.serverConfig;
+
+    // ── stdio ─────────────────────────────────────────────────────────────────
+    if (cfg.command) {
+      return new StdioClientTransport({
+        command: cfg.command,
+        args: cfg.args || [],
+        // Env vars are merged into the child process environment.
+        // Values support ${VAR} expansion so users can reference existing env vars.
+        env: { ...process.env, ...expandEnvVars(cfg.env || {}) },
+      });
+    }
+
+    if (!cfg.url) {
+      throw new Error(`Invalid MCP config for ${this.name}: need 'command' (stdio) or 'url' (http/sse)`);
+    }
+
+    const url = new URL(expandEnvVars(cfg.url));
+
+    // Expand ${VAR} in header values at connect time.
+    // This keeps actual secrets out of mcp.json — store them in .env / vault,
+    // reference them as ${MY_SECRET} in the headers config.
+    const rawHeaders = cfg.headers || {};
+    const headers = expandEnvVars(rawHeaders);
+
+    // ── SSE ───────────────────────────────────────────────────────────────────
+    if (cfg.transport === "sse") {
+      // requestInit covers POST requests (messages sent to server).
+      // eventSourceInit covers the GET SSE stream (messages received from server).
+      // Both need the auth headers.
+      return new SSEClientTransport(url, {
+        requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+        eventSourceInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+      });
+    }
+
+    // ── Streamable HTTP (default) ─────────────────────────────────────────────
+    return new StreamableHTTPClientTransport(url, {
+      requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+    });
+  }
+
+  /**
+   * Call a tool on this server.
+   */
+  async callTool(toolName, args) {
+    if (!this.connected || !this.client) {
+      throw new Error(`MCP server ${this.name} not connected`);
+    }
+
+    const result = await this.client.callTool({
+      name: toolName,
+      arguments: args,
+    });
+
+    if (result.content && Array.isArray(result.content)) {
+      return result.content
+        .map((c) => {
+          if (c.type === "text") return c.text;
+          if (c.type === "image") return `[Image: ${c.mimeType}]`;
+          return JSON.stringify(c);
+        })
+        .join("\n");
+    }
+
+    return JSON.stringify(result);
+  }
+
+  /**
+   * Disconnect from the server.
+   */
+  async disconnect() {
+    if (this.client) {
+      try {
+        await this.client.close();
+      } catch {
+        // ignore close errors
+      }
+      this.connected = false;
+      console.log(`[MCP:${this.name}] Disconnected`);
+    }
+  }
+
+  /**
+   * Get tool list for this server.
+   */
+  getTools() {
+    return this.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema,
+    }));
+  }
+}

package/src/mcp/MCPManager.js

@@ -0,0 +1,412 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { config } from "../config/default.js";
+import { MCPClient } from "./MCPClient.js";
+
+/**
+ * MCP Manager — manages multiple MCP server connections.
+ *
+ * Reads config from config/mcp.json (same format as Claude Code's .mcp.json).
+ * Each server's tools are exposed as `mcp__{serverName}__{toolName}` in the agent.
+ *
+ * Config format:
+ * ```json
+ * {
+ *   "mcpServers": {
+ *     "github": {
+ *       "command": "npx",
+ *       "args": ["-y", "@modelcontextprotocol/server-github"],
+ *       "env": { "GITHUB_TOKEN": "..." }
+ *     },
+ *     "memory": {
+ *       "url": "http://localhost:3100/mcp",
+ *       "transport": "sse"
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class MCPManager {
+  constructor() {
+    this.clients = new Map();
+    this.toolMap = new Map(); // mcp__server__tool -> { client, toolName }
+    this.mcpConfigPath = join(config.rootDir, "config", "mcp.json");
+  }
+
+  /**
+   * Read and parse the current mcp.json config.
+   */
+  readConfig() {
+    if (!existsSync(this.mcpConfigPath)) return { mcpServers: {} };
+    try {
+      return JSON.parse(readFileSync(this.mcpConfigPath, "utf-8"));
+    } catch {
+      return { mcpServers: {} };
+    }
+  }
+
+  /**
+   * Write the config back to mcp.json.
+   */
+  writeConfig(mcpConfig) {
+    writeFileSync(this.mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+  }
+
+  /**
+   * Connect a single server and register its tools.
+   */
+  async connectServer(name, serverConfig) {
+    // Disconnect existing if present
+    if (this.clients.has(name)) {
+      await this.disconnectServer(name);
+    }
+
+    const client = new MCPClient(name, serverConfig);
+    this.clients.set(name, client);
+
+    const tools = await client.connect();
+
+    for (const tool of tools) {
+      const fullName = `mcp__${name}__${tool.name}`;
+      this.toolMap.set(fullName, {
+        client,
+        toolName: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+      });
+    }
+
+    return tools;
+  }
+
+  /**
+   * Disconnect a server and remove its tools.
+   */
+  async disconnectServer(name) {
+    const client = this.clients.get(name);
+    if (!client) return;
+
+    await client.disconnect();
+    this.clients.delete(name);
+
+    // Remove all tools from this server
+    const prefix = `mcp__${name}__`;
+    for (const key of this.toolMap.keys()) {
+      if (key.startsWith(prefix)) this.toolMap.delete(key);
+    }
+  }
+
+  /**
+   * Dynamically add a new MCP server — saves to config and connects.
+   * @param {string} name - Server name (e.g. "github")
+   * @param {object} serverConfig - Config object (command+args or url+transport)
+   * @returns {string} Result message
+   */
+  async addServer(name, serverConfig) {
+    if (!name || typeof name !== "string") throw new Error("name is required");
+    if (!serverConfig || typeof serverConfig !== "object") throw new Error("serverConfig is required");
+    if (!serverConfig.command && !serverConfig.url) throw new Error("serverConfig must have 'command' (stdio) or 'url' (SSE/HTTP)");
+
+    // Write to config
+    const mcpConfig = this.readConfig();
+    mcpConfig.mcpServers = mcpConfig.mcpServers || {};
+    mcpConfig.mcpServers[name] = { ...serverConfig, enabled: true };
+    this.writeConfig(mcpConfig);
+
+    // Connect immediately
+    const tools = await this.connectServer(name, serverConfig);
+    return `Server "${name}" added and connected — ${tools.length} tools: ${tools.map(t => t.name).join(", ") || "(none)"}`;
+  }
+
+  /**
+   * Dynamically remove an MCP server — disconnects and removes from config.
+   * @param {string} name - Server name
+   * @returns {string} Result message
+   */
+  async removeServer(name) {
+    await this.disconnectServer(name);
+
+    const mcpConfig = this.readConfig();
+    if (mcpConfig.mcpServers && mcpConfig.mcpServers[name]) {
+      delete mcpConfig.mcpServers[name];
+      this.writeConfig(mcpConfig);
+    }
+
+    return `Server "${name}" removed.`;
+  }
+
+  /**
+   * Enable or disable a server in config (does not reconnect — use reload).
+   */
+  async setEnabled(name, enabled) {
+    const mcpConfig = this.readConfig();
+    if (!mcpConfig.mcpServers?.[name]) {
+      throw new Error(`Server "${name}" not found in config`);
+    }
+    mcpConfig.mcpServers[name].enabled = enabled;
+    this.writeConfig(mcpConfig);
+
+    if (enabled) {
+      const tools = await this.connectServer(name, mcpConfig.mcpServers[name]);
+      return `Server "${name}" enabled and connected — ${tools.length} tools.`;
+    } else {
+      await this.disconnectServer(name);
+      return `Server "${name}" disabled and disconnected.`;
+    }
+  }
+
+  /**
+   * Reload a server — disconnect, re-read config, reconnect.
+   */
+  async reloadServer(name) {
+    const mcpConfig = this.readConfig();
+    const serverConfig = mcpConfig.mcpServers?.[name];
+    if (!serverConfig) throw new Error(`Server "${name}" not found in config`);
+    if (serverConfig.enabled === false) {
+      await this.disconnectServer(name);
+      return `Server "${name}" is disabled — not reconnected.`;
+    }
+
+    const tools = await this.connectServer(name, serverConfig);
+    return `Server "${name}" reloaded — ${tools.length} tools.`;
+  }
+
+  /**
+   * Initialize and connect to all configured MCP servers.
+   */
+  async init() {
+    const mcpConfigPath = this.mcpConfigPath;
+
+    if (!existsSync(mcpConfigPath)) {
+      console.log(`[MCPManager] No config/mcp.json — MCP disabled`);
+      return;
+    }
+
+    let mcpConfig;
+    try {
+      mcpConfig = JSON.parse(readFileSync(mcpConfigPath, "utf-8"));
+    } catch (error) {
+      console.log(`[MCPManager] Error reading mcp.json: ${error.message}`);
+      return;
+    }
+
+    const servers = mcpConfig.mcpServers || {};
+
+    // Filter to only real, enabled servers
+    const enabledServers = Object.entries(servers).filter(
+      ([name, cfg]) => !name.startsWith("_comment") && typeof cfg === "object" && cfg.enabled !== false
+    );
+
+    if (enabledServers.length === 0) {
+      console.log(`[MCPManager] No MCP servers enabled`);
+      return;
+    }
+
+    console.log(
+      `[MCPManager] Connecting to ${enabledServers.length} server(s) in background...`
+    );
+
+    // Connect all servers in parallel, non-blocking
+    const connectAll = Promise.allSettled(
+      enabledServers.map(async ([serverName, serverConfig]) => {
+        const tools = await this.connectServer(serverName, serverConfig);
+        return { name: serverName, toolCount: tools.length };
+      })
+    );
+
+    // Don't block startup — log results when ready
+    connectAll.then((results) => {
+      const succeeded = results.filter((r) => r.status === "fulfilled");
+      const failed = results.filter((r) => r.status === "rejected");
+
+      for (const f of failed) {
+        console.log(`[MCPManager] Failed to connect: ${f.reason?.message || f.reason}`);
+      }
+
+      console.log(
+        `[MCPManager] Ready — ${succeeded.length}/${enabledServers.length} servers, ${this.toolMap.size} tools`
+      );
+    });
+  }
+
+  /**
+   * Get all MCP tools as functions + descriptions for the tool registry.
+   * Returns { functions: { name: fn }, descriptions: [string] }
+   */
+  getToolsForAgent() {
+    const functions = {};
+    const descriptions = [];
+
+    for (const [fullName, entry] of this.toolMap) {
+      // Create a wrapper function that calls the MCP tool
+      functions[fullName] = async (...args) => {
+        // Parse args: first arg is JSON string of arguments
+        let toolArgs = {};
+        if (args[0]) {
+          try {
+            toolArgs = typeof args[0] === "string" ? JSON.parse(args[0]) : args[0];
+          } catch {
+            // If not JSON, try to map positionally based on schema
+            const props = entry.inputSchema?.properties || {};
+            const keys = Object.keys(props);
+            toolArgs = {};
+            for (let i = 0; i < keys.length && i < args.length; i++) {
+              toolArgs[keys[i]] = args[i];
+            }
+          }
+        }
+
+        console.log(
+          `      [MCP:${fullName}] Calling with: ${JSON.stringify(toolArgs).slice(0, 200)}`
+        );
+        try {
+          const result = await entry.client.callTool(entry.toolName, toolArgs);
+          return result;
+        } catch (error) {
+          return `MCP tool error: ${error.message}`;
+        }
+      };
+
+      // Build description
+      const schema = entry.inputSchema?.properties || {};
+      const params = Object.entries(schema)
+        .map(([k, v]) => `${k}: ${v.type || "any"}`)
+        .join(", ");
+      descriptions.push(
+        `${fullName}(argsJson: string) - [MCP] ${entry.description || entry.toolName}. Params as JSON: {${params}}`
+      );
+    }
+
+    return { functions, descriptions };
+  }
+
+  /**
+   * Get built-in tools merged with all connected MCP tools.
+   * Called fresh at each task execution — always reflects current connection state.
+   * @param {object} builtinTools - The base toolFunctions map
+   * @returns {object} Merged tool functions map
+   */
+  getMergedTools(builtinTools) {
+    if (this.toolMap.size === 0) return builtinTools;
+    const { functions } = this.getToolsForAgent();
+    return { ...builtinTools, ...functions };
+  }
+
+  /**
+   * Get MCP tool descriptions for the system prompt.
+   * Returns empty string if no MCP servers connected.
+   */
+  getToolDocs() {
+    if (this.toolMap.size === 0) return "";
+
+    const lines = ["## MCP Server Tools\n"];
+    lines.push("These tools come from connected MCP servers. All params passed as a JSON string.");
+    lines.push("");
+
+    // Group by server
+    const byServer = new Map();
+    for (const [fullName, entry] of this.toolMap) {
+      const serverName = fullName.split("__")[1];
+      if (!byServer.has(serverName)) byServer.set(serverName, []);
+      byServer.get(serverName).push({ fullName, entry });
+    }
+
+    for (const [serverName, tools] of byServer) {
+      lines.push(`### Server: ${serverName}`);
+      for (const { fullName, entry } of tools) {
+        const schema = entry.inputSchema?.properties || {};
+        const required = entry.inputSchema?.required || [];
+        const params = Object.entries(schema)
+          .map(([k, v]) => `${k}${required.includes(k) ? "" : "?"}: ${v.type || "any"}`)
+          .join(", ");
+        const desc = entry.description || entry.toolName;
+        lines.push(`#### ${fullName}(argsJson: string)`);
+        lines.push(`${desc}`);
+        if (params) lines.push(`- argsJson: {${params}}`);
+        lines.push("");
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Get callable tool functions for a specific MCP server only.
+   * Used by MCPAgentRunner to give specialist agents only their server's tools.
+   * @param {string} serverName - e.g. "github"
+   * @returns {object} { "mcp__server__tool": fn, ... }
+   */
+  getServerTools(serverName) {
+    const prefix = `mcp__${serverName}__`;
+    const serverTools = {};
+
+    for (const [fullName, entry] of this.toolMap) {
+      if (!fullName.startsWith(prefix)) continue;
+
+      serverTools[fullName] = async (...args) => {
+        let toolArgs = {};
+        if (args[0]) {
+          try {
+            toolArgs = typeof args[0] === "string" ? JSON.parse(args[0]) : args[0];
+          } catch {
+            const props = entry.inputSchema?.properties || {};
+            const keys = Object.keys(props);
+            toolArgs = {};
+            for (let i = 0; i < keys.length && i < args.length; i++) {
+              toolArgs[keys[i]] = args[i];
+            }
+          }
+        }
+        console.log(`      [MCP:${fullName}] Calling with: ${JSON.stringify(toolArgs).slice(0, 200)}`);
+        try {
+          return await entry.client.callTool(entry.toolName, toolArgs);
+        } catch (error) {
+          return `MCP tool error: ${error.message}`;
+        }
+      };
+    }
+
+    return serverTools;
+  }
+
+  /**
+   * Get info about all connected servers — used for system prompt listing.
+   * @returns {Array<{name, toolCount, toolNames}>}
+   */
+  getConnectedServersInfo() {
+    const configServers = this.readConfig().mcpServers || {};
+    return [...this.clients.entries()]
+      .filter(([, client]) => client.connected)
+      .map(([name, client]) => ({
+        name,
+        description: configServers[name]?.description || "",
+        toolCount: client.getTools().length,
+        toolNames: client.getTools().map((t) => t.name),
+      }));
+  }
+
+  /**
+   * Disconnect all servers.
+   */
+  async shutdown() {
+    for (const [name, client] of this.clients) {
+      await client.disconnect();
+    }
+    this.clients.clear();
+    this.toolMap.clear();
+  }
+
+  /**
+   * List connected servers and tools.
+   */
+  list() {
+    return [...this.clients.entries()].map(([name, client]) => ({
+      name,
+      connected: client.connected,
+      tools: client.getTools().map((t) => t.name),
+    }));
+  }
+}
+
+const mcpManager = new MCPManager();
+export default mcpManager;