opensentinel 2.1.1

package/dist/chunk-L3F43VPB.js

@@ -0,0 +1,652 @@
+// src/core/mcp/client.ts
+import { spawn } from "child_process";
+import { nanoid } from "nanoid";
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var MCPClient = class {
+  config;
+  state;
+  process = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  messageBuffer = "";
+  requestTimeout;
+  constructor(config, timeout = 3e4) {
+    this.config = config;
+    this.requestTimeout = timeout;
+    this.state = {
+      config,
+      status: "disconnected",
+      tools: []
+    };
+  }
+  get id() {
+    return this.config.id;
+  }
+  get name() {
+    return this.config.name;
+  }
+  get status() {
+    return this.state.status;
+  }
+  get tools() {
+    return this.state.tools;
+  }
+  get serverInfo() {
+    return this.state.serverInfo;
+  }
+  // ============================================
+  // CONNECTION MANAGEMENT
+  // ============================================
+  async connect() {
+    if (this.state.status === "connected") {
+      return;
+    }
+    this.state.status = "connecting";
+    try {
+      if (this.config.transport === "stdio") {
+        await this.connectStdio();
+      } else if (this.config.transport === "http+sse") {
+        await this.connectHttpSse();
+      } else {
+        throw new Error(`Unsupported transport: ${this.config.transport}`);
+      }
+      const initResult = await this.initialize();
+      this.state.capabilities = initResult.capabilities;
+      this.state.serverInfo = initResult.serverInfo;
+      await this.refreshTools();
+      this.state.status = "connected";
+      this.state.lastActivity = /* @__PURE__ */ new Date();
+      console.log(`[MCP] Connected to ${this.name} (${this.state.tools.length} tools)`);
+    } catch (error) {
+      this.state.status = "error";
+      this.state.lastError = error instanceof Error ? error.message : "Unknown error";
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.state.status === "disconnected") {
+      return;
+    }
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingRequests.clear();
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+    this.state.status = "disconnected";
+    this.state.tools = [];
+    console.log(`[MCP] Disconnected from ${this.name}`);
+  }
+  // ============================================
+  // STDIO TRANSPORT
+  // ============================================
+  async connectStdio() {
+    if (!this.config.command) {
+      throw new Error("STDIO transport requires a command");
+    }
+    const env = {
+      ...process.env,
+      ...this.config.env
+    };
+    this.process = spawn(
+      this.config.command,
+      this.config.args || [],
+      {
+        cwd: this.config.cwd || process.cwd(),
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    this.readStdout();
+    this.readStderr();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  readStdout() {
+    if (!this.process?.stdout) return;
+    this.process.stdout.on("data", (chunk) => {
+      this.messageBuffer += chunk.toString();
+      this.processMessageBuffer();
+    });
+    this.process.stdout.on("error", (error) => {
+      if (this.state.status === "connected" || this.state.status === "connecting") {
+        console.error(`[MCP] ${this.name} stdout error:`, error);
+      }
+    });
+  }
+  readStderr() {
+    if (!this.process?.stderr) return;
+    this.process.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (text.trim()) {
+        console.log(`[MCP] ${this.name} stderr: ${text.trim()}`);
+      }
+    });
+  }
+  processMessageBuffer() {
+    const lines = this.messageBuffer.split("\n");
+    this.messageBuffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        this.handleResponse(message);
+      } catch {
+        console.warn(`[MCP] ${this.name} failed to parse message: ${line.slice(0, 100)}`);
+      }
+    }
+  }
+  handleResponse(response) {
+    if (response.id === void 0 || response.id === null) {
+      return;
+    }
+    const pending = this.pendingRequests.get(response.id);
+    if (!pending) {
+      console.warn(`[MCP] ${this.name} received response for unknown request: ${response.id}`);
+      return;
+    }
+    clearTimeout(pending.timeout);
+    this.pendingRequests.delete(response.id);
+    if (response.error) {
+      pending.reject(new Error(response.error.message));
+    } else {
+      pending.resolve(response.result);
+    }
+  }
+  async sendRequest(method, params) {
+    if (!this.process?.stdin) {
+      throw new Error("Not connected");
+    }
+    const id = nanoid();
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    const promise = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${method}`));
+      }, this.requestTimeout);
+      this.pendingRequests.set(id, { resolve, reject, timeout });
+    });
+    const data = JSON.stringify(request) + "\n";
+    this.process.stdin.write(data);
+    return promise;
+  }
+  // ============================================
+  // HTTP+SSE TRANSPORT
+  // ============================================
+  async connectHttpSse() {
+    if (!this.config.url) {
+      throw new Error("HTTP+SSE transport requires a URL");
+    }
+    try {
+      const response = await fetch(`${this.config.url}/health`, {
+        headers: this.config.headers
+      });
+      if (!response.ok) {
+        throw new Error(`Server health check failed: ${response.status}`);
+      }
+    } catch (error) {
+      const response = await fetch(this.config.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: "ping",
+          method: "ping"
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Server connection failed: ${response.status}`);
+      }
+    }
+  }
+  async sendHttpRequest(method, params) {
+    if (!this.config.url) {
+      throw new Error("HTTP+SSE transport requires a URL");
+    }
+    const request = {
+      jsonrpc: "2.0",
+      id: nanoid(),
+      method,
+      params
+    };
+    const response = await fetch(this.config.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.headers
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP request failed: ${response.status}`);
+    }
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message);
+    }
+    return result.result;
+  }
+  // ============================================
+  // MCP PROTOCOL METHODS
+  // ============================================
+  async initialize() {
+    const params = {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {
+        roots: { listChanged: true }
+      },
+      clientInfo: {
+        name: "OpenSentinel",
+        version: "2.0.0"
+      }
+    };
+    const result = await this.request("initialize", params);
+    await this.notify("notifications/initialized", {});
+    return result;
+  }
+  async refreshTools() {
+    const result = await this.request("tools/list", {});
+    this.state.tools = result.tools || [];
+    return this.state.tools;
+  }
+  async callTool(name, args) {
+    const params = {
+      name,
+      arguments: args
+    };
+    try {
+      const result = await this.request("tools/call", params);
+      this.state.lastActivity = /* @__PURE__ */ new Date();
+      const textContent = result.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+      return {
+        success: !result.isError,
+        output: textContent || JSON.stringify(result.content),
+        isError: result.isError
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  // ============================================
+  // GENERIC REQUEST/NOTIFY
+  // ============================================
+  async request(method, params) {
+    if (this.config.transport === "stdio") {
+      return this.sendRequest(method, params);
+    } else {
+      return this.sendHttpRequest(method, params);
+    }
+  }
+  async notify(method, params) {
+    if (this.config.transport === "stdio" && this.process?.stdin) {
+      const notification = {
+        jsonrpc: "2.0",
+        method,
+        params
+      };
+      this.process.stdin.write(JSON.stringify(notification) + "\n");
+    }
+  }
+  // ============================================
+  // STATE ACCESS
+  // ============================================
+  getState() {
+    return { ...this.state };
+  }
+};
+
+// src/core/mcp/registry.ts
+var MCPRegistry = class {
+  clients = /* @__PURE__ */ new Map();
+  config;
+  defaultTimeout;
+  constructor(config) {
+    this.config = config;
+    this.defaultTimeout = config.settings?.timeout || 3e4;
+  }
+  // ============================================
+  // INITIALIZATION
+  // ============================================
+  /**
+   * Connect to all enabled MCP servers
+   */
+  async initialize() {
+    const enabledServers = this.config.servers.filter((s) => s.enabled);
+    console.log(`[MCP] Initializing ${enabledServers.length} server(s)...`);
+    const results = await Promise.allSettled(
+      enabledServers.map((config) => this.connectServer(config))
+    );
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        console.error(
+          `[MCP] Failed to connect to ${enabledServers[index].name}:`,
+          result.reason
+        );
+      }
+    });
+    const connected = results.filter((r) => r.status === "fulfilled").length;
+    console.log(`[MCP] Connected to ${connected}/${enabledServers.length} servers`);
+  }
+  /**
+   * Connect to a single MCP server
+   */
+  async connectServer(config) {
+    if (this.clients.has(config.id)) {
+      throw new Error(`Server ${config.id} already connected`);
+    }
+    const client = new MCPClient(config, this.defaultTimeout);
+    await client.connect();
+    this.clients.set(config.id, client);
+  }
+  /**
+   * Disconnect from a specific server
+   */
+  async disconnectServer(id) {
+    const client = this.clients.get(id);
+    if (client) {
+      await client.disconnect();
+      this.clients.delete(id);
+    }
+  }
+  /**
+   * Disconnect from all servers
+   */
+  async shutdown() {
+    console.log("[MCP] Shutting down all connections...");
+    await Promise.all(
+      Array.from(this.clients.values()).map((client) => client.disconnect())
+    );
+    this.clients.clear();
+  }
+  // ============================================
+  // TOOL MANAGEMENT
+  // ============================================
+  /**
+   * Get all tools from all connected servers
+   * Tools are prefixed with "mcp_{serverId}_" for routing
+   */
+  getAllTools() {
+    const tools = [];
+    for (const [serverId, client] of this.clients) {
+      if (client.status === "connected") {
+        for (const tool of client.tools) {
+          tools.push({ serverId, tool });
+        }
+      }
+    }
+    return tools;
+  }
+  /**
+   * Get tools from a specific server
+   */
+  getServerTools(serverId) {
+    const client = this.clients.get(serverId);
+    return client?.tools || [];
+  }
+  /**
+   * Call a tool on a specific server
+   */
+  async callTool(serverId, toolName, args) {
+    const client = this.clients.get(serverId);
+    if (!client) {
+      return {
+        success: false,
+        error: `MCP server not found: ${serverId}`
+      };
+    }
+    if (client.status !== "connected") {
+      return {
+        success: false,
+        error: `MCP server not connected: ${serverId}`
+      };
+    }
+    console.log(`[MCP] Calling ${serverId}:${toolName}`);
+    return client.callTool(toolName, args);
+  }
+  // ============================================
+  // SERVER MANAGEMENT
+  // ============================================
+  /**
+   * Get status of all servers
+   */
+  getServerStates() {
+    return Array.from(this.clients.values()).map((client) => client.getState());
+  }
+  /**
+   * Get status of a specific server
+   */
+  getServerState(serverId) {
+    return this.clients.get(serverId)?.getState();
+  }
+  /**
+   * Check if a server is connected
+   */
+  isConnected(serverId) {
+    const client = this.clients.get(serverId);
+    return client?.status === "connected";
+  }
+  /**
+   * Refresh tools from all connected servers
+   */
+  async refreshAllTools() {
+    await Promise.all(
+      Array.from(this.clients.values()).filter((client) => client.status === "connected").map((client) => client.refreshTools())
+    );
+  }
+  /**
+   * Add a new server configuration and optionally connect
+   */
+  async addServer(config, connect = true) {
+    if (this.clients.has(config.id)) {
+      throw new Error(`Server ${config.id} already exists`);
+    }
+    this.config.servers.push(config);
+    if (connect && config.enabled) {
+      await this.connectServer(config);
+    }
+  }
+  /**
+   * Remove a server
+   */
+  async removeServer(serverId) {
+    await this.disconnectServer(serverId);
+    this.config.servers = this.config.servers.filter((s) => s.id !== serverId);
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get count of connected servers
+   */
+  get connectedCount() {
+    return Array.from(this.clients.values()).filter(
+      (c) => c.status === "connected"
+    ).length;
+  }
+  /**
+   * Get total tool count across all servers
+   */
+  get totalToolCount() {
+    return this.getAllTools().length;
+  }
+};
+async function loadMCPConfig(path) {
+  try {
+    const { readFile, access } = await import("fs/promises");
+    try {
+      await access(path);
+    } catch {
+      console.log(`[MCP] Config file not found: ${path}, using empty config`);
+      return { servers: [] };
+    }
+    const content = await readFile(path, "utf-8");
+    const config = JSON.parse(content);
+    if (!Array.isArray(config.servers)) {
+      console.warn("[MCP] Invalid config: servers must be an array");
+      return { servers: [] };
+    }
+    return config;
+  } catch (error) {
+    console.error("[MCP] Failed to load config:", error);
+    return { servers: [] };
+  }
+}
+async function initMCPRegistry(configPath) {
+  const config = await loadMCPConfig(configPath);
+  const registry = new MCPRegistry(config);
+  await registry.initialize();
+  return registry;
+}
+
+// src/core/mcp/tool-bridge.ts
+var MCP_TOOL_PREFIX = "mcp_";
+function createMCPToolName(serverId, toolName) {
+  const safeServerId = serverId.replace(/[^a-zA-Z0-9_]/g, "_");
+  const safeToolName = toolName.replace(/[^a-zA-Z0-9_]/g, "_");
+  return `${MCP_TOOL_PREFIX}${safeServerId}__${safeToolName}`;
+}
+function isMCPTool(name) {
+  return name.startsWith(MCP_TOOL_PREFIX);
+}
+function parseMCPToolName(name) {
+  if (!isMCPTool(name)) {
+    return null;
+  }
+  const withoutPrefix = name.slice(MCP_TOOL_PREFIX.length);
+  const separatorIndex = withoutPrefix.indexOf("__");
+  if (separatorIndex === -1) {
+    return null;
+  }
+  return {
+    serverId: withoutPrefix.slice(0, separatorIndex),
+    toolName: withoutPrefix.slice(separatorIndex + 2)
+  };
+}
+function convertProperty(prop) {
+  const result = {
+    type: prop.type
+  };
+  if (prop.description) {
+    result.description = prop.description;
+  }
+  if (prop.enum) {
+    result.enum = prop.enum;
+  }
+  if (prop.items) {
+    result.items = convertProperty(prop.items);
+  }
+  if (prop.properties) {
+    result.properties = Object.fromEntries(
+      Object.entries(prop.properties).map(([key, value]) => [
+        key,
+        convertProperty(value)
+      ])
+    );
+  }
+  if (prop.required) {
+    result.required = prop.required;
+  }
+  return result;
+}
+function mcpToolToAnthropicTool(serverId, serverName, tool) {
+  const properties = {};
+  if (tool.inputSchema.properties) {
+    for (const [key, value] of Object.entries(tool.inputSchema.properties)) {
+      properties[key] = convertProperty(value);
+    }
+  }
+  const inputSchema = {
+    type: "object",
+    properties,
+    required: tool.inputSchema.required || []
+  };
+  const name = createMCPToolName(serverId, tool.name);
+  const description = tool.description ? `[${serverName}] ${tool.description}` : `[${serverName}] ${tool.name}`;
+  return {
+    name,
+    description,
+    input_schema: inputSchema
+  };
+}
+function mcpToolsToAnthropicTools(registry) {
+  const tools = [];
+  const serverStates = registry.getServerStates();
+  for (const state of serverStates) {
+    if (state.status !== "connected") continue;
+    const serverName = state.serverInfo?.name || state.config.name;
+    for (const tool of state.tools) {
+      tools.push(mcpToolToAnthropicTool(state.config.id, serverName, tool));
+    }
+  }
+  return tools;
+}
+async function executeMCPTool(registry, toolName, args) {
+  const parsed = parseMCPToolName(toolName);
+  if (!parsed) {
+    return {
+      success: false,
+      error: `Invalid MCP tool name: ${toolName}`
+    };
+  }
+  return registry.callTool(parsed.serverId, parsed.toolName, args);
+}
+function getMCPToolSummary(registry) {
+  const states = registry.getServerStates();
+  const lines = [];
+  for (const state of states) {
+    const status = state.status === "connected" ? "\u2713" : "\u2717";
+    const serverName = state.serverInfo?.name || state.config.name;
+    const toolCount = state.tools.length;
+    lines.push(`  ${status} ${serverName}: ${toolCount} tools`);
+    if (state.status === "connected" && state.tools.length > 0) {
+      const toolNames = state.tools.map((t) => t.name).join(", ");
+      lines.push(`    Tools: ${toolNames}`);
+    } else if (state.lastError) {
+      lines.push(`    Error: ${state.lastError}`);
+    }
+  }
+  if (lines.length === 0) {
+    return "  No MCP servers configured";
+  }
+  return lines.join("\n");
+}
+function findMCPTool(registry, toolName) {
+  const allTools = registry.getAllTools();
+  for (const { serverId, tool } of allTools) {
+    if (tool.name === toolName) {
+      return { serverId, tool };
+    }
+  }
+  return null;
+}
+
+export {
+  MCPClient,
+  MCPRegistry,
+  loadMCPConfig,
+  initMCPRegistry,
+  createMCPToolName,
+  isMCPTool,
+  parseMCPToolName,
+  mcpToolToAnthropicTool,
+  mcpToolsToAnthropicTools,
+  executeMCPTool,
+  getMCPToolSummary,
+  findMCPTool
+};
+//# sourceMappingURL=chunk-L3F43VPB.js.map