@meowlynxsea/koi 0.1.0

package/src/services/mcp/client.ts

@@ -0,0 +1,194 @@
+/**
+ * MCP Client Connection
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Tool, Resource, ServerCapabilities } from "@modelcontextprotocol/sdk/types.js";
+import type { ScopedMcpConfig, ConnectedMCPServer } from "./types.js";
+import { FilteredStdioClientTransport } from "./stdio-transport.js";
+
+const CONNECTION_TIMEOUT = 60000;
+
+async function createTransport(config: ScopedMcpConfig) {
+  if (config.type === "stdio" && config.command) {
+    return new FilteredStdioClientTransport({
+      command: config.command,
+      args: config.args ?? [],
+      env: config.env,
+    });
+  }
+
+  if (config.url) {
+    const type = config.type ?? "http";
+    const headers: Record<string, string> = { ...(config.headers ?? {}) };
+    if (config.authToken) {
+      headers["Authorization"] = `Bearer ${config.authToken}`;
+    }
+    const url = new URL(config.url);
+
+    switch (type) {
+      case "sse":
+        return new SSEClientTransport(url);
+      default:
+        return new StreamableHTTPClientTransport(url);
+    }
+  }
+
+  throw new Error("Invalid MCP server configuration");
+}
+
+export interface ConnectResult {
+  success: boolean;
+  server?: ConnectedMCPServer;
+  error?: string;
+}
+
+export async function connectToServer(
+  name: string,
+  config: ScopedMcpConfig,
+  options?: { timeout?: number; onProgress?: (message: string) => void }
+): Promise<ConnectResult> {
+  const timeout = options?.timeout ?? CONNECTION_TIMEOUT;
+
+  try {
+    options?.onProgress?.(`Connecting to ${name}...`);
+    const transport = await createTransport(config);
+
+    const client = new Client(
+      { name: "koi", version: "1.0.0" },
+      { capabilities: {} }
+    );
+
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(() => abortController.abort(), timeout);
+
+    try {
+      await client.connect(transport);
+      clearTimeout(timeoutId);
+      options?.onProgress?.(`Connected to ${name}`);
+
+      // Make these optional - not all MCP servers support all methods
+      let serverInfo: Record<string, unknown> = { name: "unknown", version: "0.0.0" };
+      try {
+        const versionResult = client.getServerVersion();
+        // Handle both sync and async versions
+        if (versionResult instanceof Promise) {
+          serverInfo = await versionResult as Record<string, unknown>;
+        } else {
+          serverInfo = versionResult as Record<string, unknown>;
+        }
+      } catch {
+        // Server may not support getServerVersion
+      }
+
+      let toolsResponse = { tools: [] as Tool[] };
+      try {
+        const result = client.listTools();
+        toolsResponse = "then" in result ? await result : result;
+      } catch {
+        // Server may not support tools
+      }
+
+      let resourcesResponse = { resources: [] as Resource[] };
+      try {
+        const result = client.listResources();
+        resourcesResponse = "then" in result ? await result : result;
+      } catch {
+        // Server may not support resources
+      }
+
+      let instructions: string | undefined;
+      try {
+        instructions = client.getInstructions();
+      } catch {
+        // Instructions not available
+      }
+
+      const cleanup = async () => {
+        try {
+          await client.close();
+        } catch {
+          // Ignore cleanup errors
+        }
+      };
+
+      // Access properties using bracket notation to avoid TS errors
+      const info = serverInfo as Record<string, unknown>;
+      const capabilities = (info["capabilities"] as ServerCapabilities | undefined) ?? {};
+      const infoName = (info["name"] as string | undefined) ?? "unknown";
+      const infoVersion = (info["version"] as string | undefined) ?? "0.0.0";
+
+      const server: ConnectedMCPServer = {
+        client,
+        name,
+        status: "connected",
+        capabilities,
+        serverInfo: { name: infoName, version: infoVersion },
+        instructions,
+        config,
+        tools: (toolsResponse.tools ?? []) as Tool[],
+        resources: (resourcesResponse.resources ?? []) as Resource[],
+        cleanup,
+      };
+
+      return { success: true, server };
+    } catch (connectError) {
+      clearTimeout(timeoutId);
+      throw connectError;
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    options?.onProgress?.(`Failed to connect to ${name}: ${errorMessage}`);
+    return { success: false, error: errorMessage };
+  }
+}
+
+export async function disconnectFromServer(server: ConnectedMCPServer): Promise<void> {
+  await server.cleanup();
+}
+
+export async function callMcpTool(
+  server: ConnectedMCPServer,
+  toolName: string,
+  args: Record<string, unknown>
+): Promise<{ success: boolean; content?: Array<Record<string, unknown>>; error?: string }> {
+  try {
+    const result = await server.client.callTool({ name: toolName, arguments: args });
+    return { success: true, content: result.content as Array<Record<string, unknown>> };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, error: errorMessage };
+  }
+}
+
+export async function listMcpResources(server: ConnectedMCPServer) {
+  const response = await server.client.listResources();
+  return response.resources ?? [];
+}
+
+export async function readMcpResource(server: ConnectedMCPServer, uri: string) {
+  try {
+    return await server.client.readResource({ uri });
+  } catch {
+    return null;
+  }
+}
+
+export async function listMcpPrompts(server: ConnectedMCPServer) {
+  const response = await server.client.listPrompts();
+  return response.prompts ?? [];
+}
+
+export async function executeMcpPrompt(
+  server: ConnectedMCPServer,
+  promptName: string,
+  args?: Record<string, string>
+) {
+  try {
+    return await server.client.getPrompt({ name: promptName, arguments: args });
+  } catch {
+    return null;
+  }
+}

package/src/services/mcp/config.ts

@@ -0,0 +1,232 @@
+/**
+ * MCP Configuration Management
+ */
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import type { McpJsonConfig, ScopedMcpConfig, McpServerConfig, ConnectionStatus } from "./types.js";
+
+const KOI_CONFIG_DIR = path.join(os.homedir(), ".config", "koi");
+const MCP_CONFIG_FILE = path.join(KOI_CONFIG_DIR, "mcp.json");
+
+const mcpConfigs: Map<string, ScopedMcpConfig> = new Map();
+const disabledServers: Set<string> = new Set();
+let configsLoaded = false;
+
+function ensureConfigDir(): void {
+  if (!fs.existsSync(KOI_CONFIG_DIR)) {
+    fs.mkdirSync(KOI_CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+function loadConfigFile(): void {
+  if (!fs.existsSync(MCP_CONFIG_FILE)) return;
+  try {
+    const raw = fs.readFileSync(MCP_CONFIG_FILE, "utf-8");
+    const data = JSON.parse(raw) as McpJsonConfig;
+    if (data.mcpServers) {
+      for (const [name, config] of Object.entries(data.mcpServers)) {
+        const cfg = config as McpServerConfig;
+        if (cfg.command || cfg.url) {
+          const scopedConfig: ScopedMcpConfig = { ...cfg, scope: "user" };
+          mcpConfigs.set(name, scopedConfig);
+          // Load disabled state from config
+          if (cfg.enabled === false) {
+            disabledServers.add(name);
+          }
+        }
+      }
+    }
+  } catch {
+    // Ignore corrupt config files
+  }
+}
+
+function saveConfigFile(): void {
+  ensureConfigDir();
+  const servers: Record<string, McpServerConfig> = {};
+  for (const [name, scopedConfig] of mcpConfigs) {
+    if (scopedConfig.scope === "user") {
+      const { scope: _scope, description: _desc, ...config } = scopedConfig;
+      // Preserve the enabled field for disabled servers
+      if (disabledServers.has(name)) {
+        servers[name] = { ...config, enabled: false };
+      } else {
+        servers[name] = config;
+      }
+    }
+  }
+  fs.writeFileSync(MCP_CONFIG_FILE, JSON.stringify({ mcpServers: servers }, null, 2) + "\n", { mode: 0o600 });
+}
+
+export function loadMcpConfigs(): void {
+  if (configsLoaded) return;
+  loadConfigFile();
+  configsLoaded = true;
+}
+
+export function loadProjectMcpConfig(cwd: string): ScopedMcpConfig[] {
+  const configPath = path.join(cwd, ".mcp.json");
+  if (!fs.existsSync(configPath)) return [];
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const data = JSON.parse(raw) as McpJsonConfig;
+    const configs: ScopedMcpConfig[] = [];
+    if (data.mcpServers) {
+      for (const [, config] of Object.entries(data.mcpServers)) {
+        const cfg = config as McpServerConfig;
+        if (cfg.command || cfg.url) {
+          configs.push({ ...cfg, scope: "project" });
+        }
+      }
+    }
+    return configs;
+  } catch {
+    return [];
+  }
+}
+
+export function loadLocalMcpConfig(cwd: string): ScopedMcpConfig[] {
+  const configPath = path.join(cwd, ".mcp.json.local");
+  if (!fs.existsSync(configPath)) return [];
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const data = JSON.parse(raw) as McpJsonConfig;
+    const configs: ScopedMcpConfig[] = [];
+    if (data.mcpServers) {
+      for (const [, config] of Object.entries(data.mcpServers)) {
+        const cfg = config as McpServerConfig;
+        if (cfg.command || cfg.url) {
+          configs.push({ ...cfg, scope: "local" });
+        }
+      }
+    }
+    return configs;
+  } catch {
+    return [];
+  }
+}
+
+export function setMcpConfig(name: string, config: McpServerConfig, scope: "user" | "project" | "local" = "user"): void {
+  mcpConfigs.set(name, { ...config, scope });
+  if (scope === "user") saveConfigFile();
+}
+
+export function getMcpConfig(name: string): ScopedMcpConfig | undefined {
+  return mcpConfigs.get(name);
+}
+
+export function getAllMcpConfigs(): Map<string, ScopedMcpConfig> {
+  return new Map(mcpConfigs);
+}
+
+export function getMcpConfigsByScope(scope: "user" | "project" | "local"): ScopedMcpConfig[] {
+  return Array.from(mcpConfigs.values()).filter(c => c.scope === scope);
+}
+
+export function removeMcpConfig(name: string): boolean {
+  const config = mcpConfigs.get(name);
+  if (!config) return false;
+  mcpConfigs.delete(name);
+  disabledServers.delete(name);
+  if (config.scope === "user") saveConfigFile();
+  return true;
+}
+
+export function isMcpServerDisabled(name: string): boolean {
+  return disabledServers.has(name);
+}
+
+export function setMcpServerEnabled(name: string, enabled: boolean): void {
+  if (enabled) {
+    disabledServers.delete(name);
+  } else {
+    disabledServers.add(name);
+  }
+  // Persist the disabled state to disk
+  const config = mcpConfigs.get(name);
+  if (config && config.scope === "user") {
+    saveConfigFile();
+  }
+}
+
+export function getMcpServerNames(): string[] {
+  return Array.from(mcpConfigs.keys());
+}
+
+const serverStatuses: Map<string, ConnectionStatus> = new Map();
+
+export function updateServerStatus(name: string, status: ConnectionStatus): void {
+  serverStatuses.set(name, status);
+}
+
+export function getServerStatus(name: string): ConnectionStatus | undefined {
+  return serverStatuses.get(name);
+}
+
+export function getAllServerStatuses(): Map<string, ConnectionStatus> {
+  return new Map(serverStatuses);
+}
+
+export interface McpConfigValidationResult {
+  valid: boolean;
+  errors?: string[];
+  warnings?: string[];
+}
+
+export function validateMcpConfig(name: string, config: unknown): McpConfigValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (!name || typeof name !== "string") {
+    errors.push("Server name is required");
+  } else if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    errors.push("Server name must contain only alphanumeric characters, hyphens, and underscores");
+  }
+
+  if (!config || typeof config !== "object") {
+    errors.push("Invalid MCP server configuration");
+    return { valid: false, errors, warnings };
+  }
+
+  const serverConfig = config as McpServerConfig;
+  if (serverConfig.command) {
+    // stdio config
+  } else if (serverConfig.url) {
+    try { new URL(serverConfig.url); }
+    catch { errors.push("Invalid URL format"); }
+    if (serverConfig.url.startsWith("http://") && !serverConfig.url.includes("localhost")) {
+      warnings.push("Using HTTP instead of HTTPS may expose credentials");
+    }
+  } else {
+    errors.push("Either command or url is required");
+  }
+
+  return { valid: errors.length === 0, errors: errors.length > 0 ? errors : undefined, warnings: warnings.length > 0 ? warnings : undefined };
+}
+
+export interface McpConfigExport {
+  version: number;
+  servers: Record<string, McpServerConfig>;
+}
+
+export function exportMcpConfigs(): McpConfigExport {
+  const servers: Record<string, McpServerConfig> = {};
+  for (const [name, scopedConfig] of mcpConfigs) {
+    const { scope: _scope, description: _desc, enabled: _enabled, ...config } = scopedConfig;
+    servers[name] = config;
+  }
+  return { version: 1, servers };
+}
+
+export function importMcpConfigs(exported: McpConfigExport): number {
+  let imported = 0;
+  for (const [name, config] of Object.entries(exported.servers)) {
+    if (config.command || config.url) {
+      setMcpConfig(name, config, "user");
+      imported++;
+    }
+  }
+  return imported;
+}

package/src/services/mcp/connection-manager.ts

@@ -0,0 +1,258 @@
+/**
+ * MCP Connection Manager
+ */
+
+import { connectToServer, disconnectFromServer, type ConnectResult } from "./client.js";
+import type { MCPServerConnection, ConnectedMCPServer, FailedMCPServer, SerializedTool, ServerResource, ScopedMcpConfig } from "./types.js";
+import { getAllMcpConfigs, isMcpServerDisabled, setMcpServerEnabled, loadMcpConfigs } from "./config.js";
+
+interface ConnectionManagerState {
+  connections: Map<string, MCPServerConnection>;
+  isConnecting: boolean;
+  error: string | null;
+}
+
+let connectionManager: ConnectionManagerState = {
+  connections: new Map(),
+  isConnecting: false,
+  error: null,
+};
+
+export interface McpConnectionProgress {
+  total: number;
+  completed: number;
+  currentServer: string;
+  status: "connecting" | "connected" | "failed" | "disabled";
+  error?: string;
+}
+
+export type McpProgressCallback = (progress: McpConnectionProgress) => void;
+
+export async function initializeMcpConnections(options?: { onProgress?: (message: string) => void; onProgressUpdate?: McpProgressCallback }): Promise<MCPServerConnection[]> {
+  loadMcpConfigs();
+  connectionManager.isConnecting = true;
+  connectionManager.error = null;
+
+  const configs = getAllMcpConfigs();
+  const connections: MCPServerConnection[] = [];
+  const total = configs.size;
+  let completed = 0;
+
+  // Separate disabled and active configs
+  const disabledServers: Array<{ name: string; config: ScopedMcpConfig }> = [];
+  const activeConfigs: Array<{ name: string; config: ScopedMcpConfig }> = [];
+
+  for (const [name, config] of configs) {
+    if (isMcpServerDisabled(name)) {
+      disabledServers.push({ name, config });
+    } else {
+      activeConfigs.push({ name, config });
+    }
+  }
+
+  // Set disabled servers immediately
+  for (const { name, config } of disabledServers) {
+    connectionManager.connections.set(name, { name, status: "disabled", config });
+    completed++;
+    options?.onProgress?.(`[${completed}/${total}] ${name} (disabled)`);
+    options?.onProgressUpdate?.({
+      total,
+      completed,
+      currentServer: name,
+      status: "disabled",
+    });
+  }
+
+  options?.onProgress?.(`Connecting to ${activeConfigs.length} MCP servers in parallel...`);
+
+  // Connect to active servers in parallel
+  const connectPromises = activeConfigs.map(async ({ name, config }) => {
+    options?.onProgress?.(`[${completed + 1}/${total}] Connecting to ${name}...`);
+    options?.onProgressUpdate?.({
+      total,
+      completed,
+      currentServer: name,
+      status: "connecting",
+    });
+
+    const result = await connectToServer(name, config, { onProgress: options?.onProgress });
+
+    completed++;
+    
+    if (result.success && result.server) {
+      connectionManager.connections.set(name, result.server);
+      connections.push(result.server);
+      options?.onProgress?.(`[${completed}/${total}] ✓ ${name} connected`);
+      options?.onProgressUpdate?.({
+        total,
+        completed,
+        currentServer: name,
+        status: "connected",
+      });
+    } else {
+      const failedServer: FailedMCPServer = {
+        name,
+        status: "failed",
+        config,
+        error: result.error,
+        lastAttempt: Date.now(),
+      };
+      connectionManager.connections.set(name, failedServer);
+      options?.onProgress?.(`[${completed}/${total}] ✗ ${name} failed: ${result.error}`);
+      options?.onProgressUpdate?.({
+        total,
+        completed,
+        currentServer: name,
+        status: "failed",
+        error: result.error,
+      });
+    }
+  });
+
+  await Promise.all(connectPromises);
+
+  connectionManager.isConnecting = false;
+  return connections;
+}
+
+export async function connectMcpServer(name: string, options?: { timeout?: number; onProgress?: (message: string) => void }): Promise<ConnectResult> {
+  const configs = getAllMcpConfigs();
+  const config = configs.get(name);
+
+  if (!config) return { success: false, error: `Server '${name}' not found` };
+  if (isMcpServerDisabled(name)) return { success: false, error: `Server '${name}' is disabled` };
+
+  const result = await connectToServer(name, config, options);
+
+  if (result.success && result.server) {
+    connectionManager.connections.set(name, result.server);
+  }
+
+  return result;
+}
+
+export async function disconnectMcpServer(name: string): Promise<void> {
+  const connection = connectionManager.connections.get(name);
+  if (connection && connection.status === "connected") {
+    await disconnectFromServer(connection);
+    connectionManager.connections.delete(name);
+  }
+}
+
+export async function toggleMcpServer(name: string, enabled: boolean): Promise<void> {
+  const connection = connectionManager.connections.get(name);
+
+  if (enabled) {
+    // 启用服务器
+    setMcpServerEnabled(name, true);
+    if (connection && connection.status === "disabled") {
+      connectionManager.connections.set(name, {
+        ...connection,
+        status: "disconnected",
+      });
+    }
+  } else {
+    // 禁用服务器
+    setMcpServerEnabled(name, false);
+    if (connection && connection.status === "connected") {
+      await disconnectFromServer(connection);
+    }
+    connectionManager.connections.set(name, {
+      name,
+      status: "disabled",
+      config: connection?.config ?? getAllMcpConfigs().get(name)!,
+    });
+  }
+}
+
+export async function reconnectMcpServer(name: string, options?: { timeout?: number; onProgress?: (message: string) => void }): Promise<ConnectResult> {
+  await disconnectMcpServer(name);
+  setMcpServerEnabled(name, true);
+  const result = await connectMcpServer(name, options);
+  if (!result.success) setMcpServerEnabled(name, false);
+  return result;
+}
+
+export function getMcpConnections(): Map<string, MCPServerConnection> {
+  return new Map(connectionManager.connections);
+}
+
+export function getMcpConnection(name: string): MCPServerConnection | undefined {
+  return connectionManager.connections.get(name);
+}
+
+export function getConnectedServers(): ConnectedMCPServer[] {
+  return Array.from(connectionManager.connections.values()).filter(c => c.status === "connected") as ConnectedMCPServer[];
+}
+
+export function getAllMcpTools(): SerializedTool[] {
+  const tools: SerializedTool[] = [];
+  for (const connection of connectionManager.connections.values()) {
+    if (connection.status === "connected") {
+      for (const tool of connection.tools) {
+        tools.push({
+          name: `mcp__${connection.name}__${tool.name}`,
+          description: tool.description,
+          inputSchema: tool.inputSchema,
+          isMcp: true,
+          serverName: connection.name,
+          originalToolName: tool.name,
+        });
+      }
+    }
+  }
+  return tools;
+}
+
+export function getAllMcpResources(): ServerResource[] {
+  const resources: ServerResource[] = [];
+  for (const connection of connectionManager.connections.values()) {
+    if (connection.status === "connected") {
+      for (const resource of connection.resources) {
+        resources.push({ ...resource, server: connection.name });
+      }
+    }
+  }
+  return resources;
+}
+
+export function getMcpStatusSummary(): { total: number; connected: number; failed: number; disabled: number; pending: number } {
+  let connected = 0;
+  let failed = 0;
+  let disabled = 0;
+  let pending = 0;
+
+  for (const connection of connectionManager.connections.values()) {
+    switch (connection.status) {
+      case "connected": connected++; break;
+      case "failed": failed++; break;
+      case "disabled": disabled++; break;
+      case "pending": pending++; break;
+    }
+  }
+
+  return { total: connectionManager.connections.size, connected, failed, disabled, pending };
+}
+
+export function isMcpConnecting(): boolean {
+  return connectionManager.isConnecting;
+}
+
+export function getMcpError(): string | null {
+  return connectionManager.error;
+}
+
+export async function disconnectAllMcpServers(): Promise<void> {
+  const promises: Promise<void>[] = [];
+  for (const connection of connectionManager.connections.values()) {
+    if (connection.status === "connected") {
+      promises.push(disconnectFromServer(connection));
+    }
+  }
+  await Promise.all(promises);
+  connectionManager.connections.clear();
+}
+
+export function resetMcpConnectionManager(): void {
+  connectionManager = { connections: new Map(), isConnecting: false, error: null };
+}