@tyvm/knowhow 0.0.158 → 0.0.160

package/src/services/Mcp.ts

@@ -1,727 +0,0 @@
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import Anthropic from "@anthropic-ai/sdk";
-import { spawn } from "child_process";
-
-import fs from "fs";
-import path from "path";
-import { McpConfig } from "../types";
-import { Tool } from "../clients";
-import { getConfig } from "../config";
-import { loadJwtFromDisk } from "../auth/jwtStore";
-import { TraceAll } from "../util/Trace";
-import { ToolsService } from "./Tools";
-import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
-import { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { MCPWebSocketTransport } from "./McpWebsocketTransport";
-
-type CachedTool = Anthropic.Tool;
-export type McpTool = CachedTool & {
-  inputSchema: CachedTool["input_schema"];
-};
-
-export const knowhowMcpClient = {
-  name: "knowhow-mcp-client",
-  version: "1.0.0",
-};
-export const knowhowConfig = {
-  capabilities: {},
-};
-
-export * from "./McpServer";
-export * from "./McpWebsocketTransport";
-
-/*
- * Returns true if the given URL string points to localhost / 127.x / ::1.
- */
-function isLocalhostUrl(url: string): boolean {
-  try {
-    const parsed = new URL(url);
-    const host = parsed.hostname;
-    return (
-      host === "localhost" ||
-      host === "127.0.0.1" ||
-      host === "::1" ||
-      /^127\./.test(host)
-    );
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check if a URL is reachable by making a simple HTTP GET/HEAD request.
- * Resolves true if we get any HTTP response (even 4xx), false on network error.
- */
-async function isUrlReachable(url: string, timeoutMs = 2000): Promise<boolean> {
-  return new Promise((resolve) => {
-    const parsed = new URL(url);
-    const lib = parsed.protocol === "https:" ? require("https") : require("http");
-    const req = lib.request(
-      { hostname: parsed.hostname, port: parsed.port || (parsed.protocol === "https:" ? 443 : 80), path: parsed.pathname || "/", method: "GET", timeout: timeoutMs },
-      () => { resolve(true); req.destroy(); }
-    );
-    req.on("error", () => resolve(false));
-    req.on("timeout", () => { req.destroy(); resolve(false); });
-    req.end();
-  });
-}
-
-/**
- * If an MCP config has both a localhost `url` and a `command`, this function
- * ensures the server is running: checks reachability, and if not up, spawns
- * the command and waits until the URL is reachable (or timeout expires).
- */
-async function ensureLocalServer(mcp: McpConfig): Promise<void> {
-  if (!mcp.url || !mcp.command || !isLocalhostUrl(mcp.url)) return;
-
-  const alreadyUp = await isUrlReachable(mcp.url);
-  if (alreadyUp) {
-    console.log(`MCP '${mcp.name}': server already running at ${mcp.url}`);
-    return;
-  }
-
-  console.log(`MCP '${mcp.name}': starting server with command: ${mcp.command} ${(mcp.args || []).join(" ")}`);
-
-  const child = spawn(mcp.command, mcp.args || [], {
-    detached: true,
-    stdio: "ignore",
-    env: mcp.env ? { ...process.env, ...mcp.env } : process.env,
-  });
-  child.unref(); // don't keep the knowhow process alive just for this child
-
-  // Wait up to 30s for the server to become reachable
-  const maxWait = 30_000;
-  const interval = 500;
-  const started = Date.now();
-
-  while (Date.now() - started < maxWait) {
-    await new Promise((r) => setTimeout(r, interval));
-    const up = await isUrlReachable(mcp.url!);
-    if (up) {
-      console.log(`MCP '${mcp.name}': server is up at ${mcp.url}`);
-      return;
-    }
-  }
-
-  throw new Error(
-    `MCP '${mcp.name}': timed out waiting for server to start at ${mcp.url} (command: ${mcp.command} ${(mcp.args || []).join(" ")})`
-  );
-}
-
-/*
- *
- * McpService is a service that manages connections to multiple MCP servers.
- * Allows us to connect the tools exposed by MCP servers to our internal ToolService, which agents can use.
- * Each of the tools are namespaced with a prefix: mcp_index_servername_toolName
- * This services handles calls made to the namespaced function name, and finds the proper client to call the tool on.
- */
-@TraceAll()
-export class McpService {
-  connected = [];
-  transports: Transport[] = [];
-  clients: Client[] = [];
-  config: McpConfig[] = [];
-  tools: Tool[] = [];
-  mcpPrefix = "mcp";
-  toolAliases: Record<string, string> = {};
-
-  async createStdioClients(mcpServers: McpConfig[] = []) {
-    if (this.clients.length) {
-      return this.clients;
-    }
-
-    this.config = mcpServers;
-    this.transports = await Promise.all(mcpServers.map((mcp) => this.createTransport(mcp)));
-    this.clients = this.transports.map(() => new Client(knowhowMcpClient, knowhowConfig));
-
-    return this.clients;
-  }
-
-  /**
-   * Create a fresh Transport for a given McpConfig entry.
-   * Re-reads authorization_token_file every time so that token refreshes
-   * are picked up without restarting the agent process.
-   */
-  async createTransport(mcp: McpConfig): Promise<Transport> {
-    await ensureLocalServer(mcp);
-    if (mcp.command && !mcp.url) {
-      const stdioParams: StdioServerParameters = {
-        command: mcp.command,
-        args: mcp.args,
-        env: mcp.env ? { ...process.env, ...mcp.env } : undefined,
-      };
-      return new StdioClientTransport(stdioParams);
-    }
-    if (mcp?.params?.socket) {
-      return new MCPWebSocketTransport(mcp.params.socket);
-    }
-    if (mcp.url) {
-      // Always re-read the token file so refreshed tokens are picked up
-      if (mcp.authorization_token_file) {
-        if (path.basename(mcp.authorization_token_file) === ".jwt") {
-          const apiUrl = process.env.KNOWHOW_API_URL || "https://api.knowhow.tyvm.ai";
-          mcp.authorization_token = loadJwtFromDisk(apiUrl, mcp.authorization_token_file);
-        } else {
-          const token = fs.readFileSync(mcp.authorization_token_file, "utf-8");
-          mcp.authorization_token = token.trim();
-        }
-      }
-      const scheme = mcp.authorization_scheme === "basic" ? "Basic" : "Bearer";
-      const transport = new StreamableHTTPClientTransport(new URL(mcp.url), {
-        requestInit: {
-          headers: {
-            "User-Agent": knowhowMcpClient.name,
-            ...(mcp.authorization_token && {
-              Authorization: `${scheme} ${mcp.authorization_token}`,
-            }),
-          },
-        },
-      });
-      // Fix SDK bug: close() aborts _abortController but never resets it to
-      // undefined, so start() throws "already started" on reconnect.
-      // Patch the instance directly so it works regardless of which SDK
-      // copy is loaded at runtime (knowhow vs knowhow-web node_modules).
-      const t = transport as any;
-      const origClose = t.close.bind(t);
-      t.close = async () => {
-        await origClose();
-        t._abortController = undefined;
-      };
-      return transport;
-    }
-    throw new Error(`Cannot create transport for MCP '${mcp.name}': no command, socket, or url configured`);
-  }
-
-  setMcpPrefix(prefix: string) {
-    this.mcpPrefix = prefix;
-  }
-
-  createClient(mcp: McpConfig, transport: Transport) {
-    this.config.push(mcp);
-    this.clients.push(new Client(knowhowMcpClient, knowhowConfig));
-    this.transports.push(transport);
-  }
-
-  async connectToConfigured(tools?: ToolsService) {
-    const config = await getConfig();
-
-    return this.connectTo(config.mcps, tools);
-  }
-
-  async connectTo(mcpServers: McpConfig[] = [], tools?: ToolsService) {
-    const clients = await this.createStdioClients(mcpServers);
-    await this.connectAutoServers();
-
-    if (tools) {
-      await this.addTools(tools);
-    }
-  }
-
-  // Connect only servers with autoConnect !== false
-  async connectAutoServers() {
-    const results = await Promise.allSettled(
-      this.clients.map(async (client, index) => {
-        const config = this.config[index];
-        const shouldAutoConnect = config.autoConnect !== false;
-
-        if (shouldAutoConnect && !this.connected[index]) {
-          console.log(`Connecting to MCP server: ${config.name}`);
-          try {
-            // Wrap connect in a race with a timeout to prevent hanging,
-            // and use a wrapping Promise to catch errors that may come
-            // from event-emitter callbacks (unhandled rejection pattern in MCP SDK)
-            await new Promise<void>(async (resolve, reject) => {
-              try {
-                await client.connect(this.transports[index]);
-                resolve();
-              } catch (err) {
-                reject(err);
-              }
-            });
-          } catch (error) {
-            console.error(
-              `Failed to connect to MCP server '${config.name}':`,
-              error.message || error
-            );
-            // Don't re-throw — just log and continue so other servers can still connect
-            return;
-          }
-          this.connected[index] = true;
-        } else if (!shouldAutoConnect) {
-          console.log(
-            `Skipping auto-connect for MCP server: ${config.name} (autoConnect: false)`
-          );
-        }
-      })
-    );
-
-    // Log summary of auto-connection results
-    const successful = results.filter((r) => r.status === "fulfilled").length;
-    // Since we no longer re-throw, count servers that are NOT connected after the attempt
-    const failed = this.clients.filter(
-      (_, i) => this.config[i]?.autoConnect !== false && !this.connected[i]
-    ).length;
-    if (failed > 0) {
-      console.warn(
-        `Auto-connected ${successful}/${this.clients.length} MCP servers (${failed} failed)`
-      );
-    }
-  }
-
-  // Connect to a specific MCP server by name
-  async connectSingle(
-    serverName: string,
-    timeout: number = 30000
-  ): Promise<{
-    success: boolean;
-    toolsAdded: string[];
-    error?: string;
-  }> {
-
-    const index = this.getClientIndex(serverName);
-
-    if (index < 0) {
-      return {
-        success: false,
-        toolsAdded: [],
-        error: `MCP server '${serverName}' not found in configuration`,
-      };
-    }
-
-    if (this.connected[index]) {
-      return {
-        success: true,
-        toolsAdded: [],
-        error: `MCP server '${serverName}' already connected`,
-      };
-    }
-
-    try {
-      // Always create a fresh transport + client before connecting.
-      // This handles cases where a previous connection attempt failed and left
-      // the transport in a started-but-not-connected state.
-      this.transports[index] = await this.createTransport(this.config[index]);
-      this.clients[index] = new Client(knowhowMcpClient, knowhowConfig);
-
-      const client = this.clients[index];
-      const transport = this.transports[index];
-
-      // Connect with timeout
-      await Promise.race([
-        client.connect(transport),
-        new Promise((_, reject) =>
-          setTimeout(() => reject(new Error("Connection timeout")), timeout)
-        ),
-      ]);
-
-      this.connected[index] = true;
-
-      // Get tools from this server
-      const clientTools = await client.listTools();
-      const toolNames: string[] = [];
-
-      for (const tool of clientTools.tools) {
-        const transformed = this.toOpenAiTool(index, tool as any);
-        if (transformed.function.name !== tool.name) {
-          this.toolAliases[transformed.function.name] = tool.name;
-        }
-        toolNames.push(transformed.function.name);
-
-        // Add to cache if not already present
-        if (
-          !this.tools.find((t) => t.function.name === transformed.function.name)
-        ) {
-          this.tools.push(transformed);
-        }
-      }
-
-      return {
-        success: true,
-        toolsAdded: toolNames,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        toolsAdded: [],
-        error: error.message,
-      };
-    }
-  }
-
-  // Disconnect a specific MCP server
-  async disconnectSingle(serverName: string): Promise<{
-    success: boolean;
-    toolsRemoved: string[];
-    error?: string;
-  }> {
-    const index = this.getClientIndex(serverName);
-
-    if (index < 0) {
-      return {
-        success: false,
-        toolsRemoved: [],
-        error: `MCP server '${serverName}' not found`,
-      };
-    }
-
-    if (!this.connected[index]) {
-      return {
-        success: true,
-        toolsRemoved: [],
-        error: `MCP server '${serverName}' not connected`,
-      };
-    }
-
-    try {
-      const toolsToRemove = this.tools
-        .filter((t) => this.getToolClientIndex(t.function.name) === index)
-        .map((t) => t.function.name);
-
-      // Close client first (resets Protocol._transport = undefined)
-      // then close transport (aborts the SSE/HTTP connection).
-      // Closing client before transport prevents the "Already connected to a
-      // transport" error on the next connectSingle call.
-      try { await this.clients[index]?.close(); } catch (_) {}
-      try { await this.transports[index]?.close(); } catch (_) {}
-
-      // Patch old transport to prevent any async SSE reconnection from
-      // firing start() after we've already replaced the transport instance.
-      // This avoids "StreamableHTTPClientTransport already started" errors.
-      const oldTransport = this.transports[index] as any;
-      if (oldTransport) {
-        oldTransport._abortController = undefined;
-        oldTransport._startOrAuthSse = async () => {};
-        oldTransport._scheduleReconnection = () => {};
-      }
-
-      this.connected[index] = false;
-
-      // Replace with a fresh transport + client so connectSingle() can reconnect
-      // without hitting "StreamableHTTPClientTransport already started".
-      // createTransport() re-reads authorization_token_file, picking up refreshed tokens.
-      this.transports[index] = await this.createTransport(this.config[index]);
-      this.clients[index] = new Client(knowhowMcpClient, knowhowConfig);
-
-      // Remove tools from cache
-      this.tools = this.tools.filter(
-        (t) => this.getToolClientIndex(t.function.name) !== index
-      );
-
-      return {
-        success: true,
-        toolsRemoved: toolsToRemove,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        toolsRemoved: [],
-        error: error.message,
-      };
-    }
-  }
-
-  // Get available servers (connected and disconnected)
-  getAvailableServers() {
-    return this.config.map((config, index) => {
-      const toolCount = this.connected[index]
-        ? this.tools.filter(
-            (t) => this.getToolClientIndex(t.function.name) === index
-          ).length
-        : 0;
-
-      return {
-        name: config.name,
-        connected: this.connected[index] || false,
-        autoConnect: config.autoConnect !== false,
-        toolCount,
-      };
-    });
-  }
-
-  async addTools(tools: ToolsService) {
-    tools.addTools(await this.getTools());
-    tools.addFunctions(await this.getToolMap());
-  }
-
-  async copyFrom(mcp: McpService) {
-    this.clients.push(...mcp.clients);
-    this.transports.push(...mcp.transports);
-    this.config.push(...mcp.config);
-    this.connected.push(...mcp.connected);
-  }
-
-  async closeTransports() {
-    await Promise.all(
-      this.transports.map(async (transport, index) => {
-        this.connected[index] = false;
-        return transport && transport.close();
-      })
-    );
-
-    // this.transports = [];
-    this.connected = [];
-  }
-
-  async closeClients() {
-    await Promise.all(
-      this.clients.map((client) => {
-        return client.close();
-      })
-    );
-
-    this.clients = [];
-    this.connected = [];
-  }
-
-  async closeAll() {
-    await Promise.allSettled([this.closeTransports()]);
-    await Promise.allSettled([this.closeClients()]);
-    // Connections are recreated from freshly-read configuration after reload.
-    this.clients = [];
-    this.transports = [];
-    this.connected = [];
-    this.config = [];
-    this.tools = [];
-    this.toolAliases = {};
-  }
-
-  getClientIndex(clientName: string) {
-    const index = this.config.findIndex((mcp) => mcp.name === clientName);
-    return index;
-  }
-
-  parseToolName(wrappedName: string) {
-    return this.toolAliases[wrappedName] || wrappedName;
-  }
-
-  getToolClientIndex(toolName: string) {
-    if (this.clients.length <= 1) {
-      return 0;
-    }
-
-    const split = toolName.split("_");
-
-    if (split.length < 2) {
-      return -1;
-    }
-
-    const index = Number(split[1]);
-    return index;
-  }
-
-  getToolClient(toolName: string) {
-    const index = this.getToolClientIndex(toolName);
-
-    if (index < 0) {
-      throw new Error(`Invalid tool name ${toolName}`);
-    }
-
-    return this.clients[index];
-  }
-
-  getFunction(toolName: string, timeout?: number) {
-    const client = this.getToolClient(toolName);
-
-    // Handle unwrapped tool names if we have 1 client
-    if (
-      !this.toolAliases[toolName] &&
-      !toolName.startsWith(this.mcpPrefix) &&
-      this.clients.length === 1
-    ) {
-      // Assume first client if no index is specified
-      const wrappedName = this.getWrappedFunctionName(toolName, 0);
-      toolName = this.toolAliases[wrappedName] ? wrappedName : toolName;
-    }
-
-    const realName = this.parseToolName(toolName);
-    return async (args: any) => {
-      // MCP tools are registered without `usesContext`, so ToolsService.callTool
-      // never injects the per-call `_ctx` here — the args we receive are already
-      // safe to serialize over the wire (no circular BaseAgent/AI-client refs).
-      console.log("Calling tool via mcp client", realName, "with args", args);
-      const tool = await client.callTool(
-        {
-          name: realName,
-          arguments: args,
-        },
-        CallToolResultSchema,
-        {
-          timeout: timeout || 10 * 60 * 1000,
-          maxTotalTimeout: timeout || 10 * 60 * 1000,
-        }
-      );
-      return tool;
-    };
-  }
-
-  /**
-   * Call a function and unwrap the MCP response content array with type casting
-   * @param toolName The name of the tool/function to call
-   * @param args The arguments to pass to the function
-   * @returns The parsed result with type T
-   */
-  async callFunction<T = any>(toolName: string, args: any = {}): Promise<T> {
-    try {
-      const fn = this.getFunction(toolName);
-      const result = await fn(args);
-
-      // Parse the MCP result
-      if (result.content && Array.isArray(result.content)) {
-        const textContent = result.content.find((c: any) => c.type === "text");
-        if (textContent && textContent.text) {
-          const parsedResult = JSON.parse(textContent.text);
-          return parsedResult as T;
-        }
-      }
-
-      throw new Error(
-        `Invalid response format from MCP service for tool ${toolName}`
-      );
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `Failed to call MCP function ${toolName}: ${errorMessage}`
-      );
-    }
-  }
-
-  async getFunctions() {
-    const tools = await this.getTools();
-    return tools.map((tool) => {
-      return this.getFunction(tool.function.name);
-    });
-  }
-
-  async getToolMap() {
-    const tools = await this.getTools();
-    return tools.reduce((acc, tool) => {
-      acc[tool.function.name] = this.getFunction(tool.function.name);
-      return acc;
-    }, {});
-  }
-
-  async connectAll() {
-    const results = await Promise.allSettled(
-      this.clients.map(async (client, index) => {
-        const config = this.config[index];
-        if (this.connected[index]) {
-          return;
-        }
-        try {
-          await client.connect(this.transports[index]);
-        } catch (error) {
-          console.error(
-            `Failed to connect to MCP server '${config?.name || `index ${index}`}':`,
-            error.message || error
-          );
-          throw error; // Re-throw to mark as rejected in Promise.allSettled
-        }
-        this.connected[index] = true;
-      })
-    );
-
-    // Log summary of connection results
-    const successful = results.filter((r) => r.status === "fulfilled").length;
-    const failed = results.filter((r) => r.status === "rejected").length;
-    if (failed > 0) {
-      console.warn(
-        `Connected ${successful}/${this.clients.length} MCP servers (${failed} failed)`
-      );
-    }
-  }
-
-  async getClient() {
-    if (this.clients.length) {
-      return this.clients;
-    }
-
-    this.clients = await this.createStdioClients(this.config);
-
-    return this.clients;
-  }
-
-  async getTools() {
-    if (this.tools.length) {
-      return this.tools;
-    }
-
-    const tools = [] as Tool[];
-
-    for (let i = 0; i < this.config.length; i++) {
-      const config = this.config[i];
-      const client = this.clients[i];
-
-      if (!this.connected[i]) {
-        // skip adding tools for unconnected clients
-        continue;
-      }
-
-      let clientTools: Awaited<ReturnType<typeof client.listTools>>;
-      try {
-        clientTools = await client.listTools();
-      } catch (error) {
-        // The MCP server connected at the transport level but the underlying
-        // server returned an error (e.g. -32603 "Not connected" from the proxy).
-        // Mark it as disconnected and skip — don't crash the worker.
-        console.warn(
-          `⚠ MCP server '${config.name}' failed to list tools (marking as disconnected): ${error instanceof Error ? error.message : error}`
-        );
-        this.connected[i] = false;
-        continue;
-      }
-
-      for (const tool of clientTools.tools) {
-        const transformed = this.toOpenAiTool(i, tool as any as McpTool);
-        if (transformed.function.name !== tool.name) {
-          this.toolAliases[transformed.function.name] = tool.name;
-        }
-        tools.push(transformed);
-      }
-    }
-
-    this.tools = tools;
-    return tools;
-  }
-
-  getToolPrefix(index = 0) {
-    const mcpName = this.config[index]?.name
-      ?.toLowerCase()
-      ?.replaceAll(" ", "_");
-
-    const prefix = mcpName
-      ? `${this.mcpPrefix}_${index}_${mcpName}`
-      : `${this.mcpPrefix}_${index}`;
-
-    return prefix;
-  }
-
-  // Wrapping tools with a prefix to avoid name collisions across many mcp servers
-  getWrappedFunctionName(toolName: string, index = 0) {
-    const prefix = this.getToolPrefix(index);
-    return `${prefix}_${toolName}`;
-  }
-
-  toOpenAiTool(index: number, tool: McpTool) {
-    const name = this.getWrappedFunctionName(tool.name, index);
-
-    const transformed: Tool = {
-      type: "function",
-      function: {
-        name,
-        description: tool.description,
-        parameters: {
-          type: "object",
-          positional: Boolean(tool.inputSchema.positional),
-          properties: tool.inputSchema.properties as any,
-          required: tool.inputSchema.required as string[],
-        },
-      },
-    };
-
-    return transformed;
-  }
-}