@deimoscloud/coreai 0.1.9 → 0.1.10

package/src/adapters/mcp/discovery.test.ts

@@ -1,315 +0,0 @@
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  discoverMcpServers,
-  loadServersFromFile,
-  parseServersFromConfig,
-  validateServerConfig,
-  findMcpConfigFile,
-  getDefaultMcpConfigPath,
-} from './discovery.js';
-import { McpError } from './types.js';
-
-describe('MCP Discovery', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'mcp-discovery-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('validateServerConfig', () => {
-    it('should validate stdio config with command', () => {
-      const config = validateServerConfig(
-        {
-          command: 'node',
-          args: ['server.js'],
-        },
-        'test-server'
-      );
-
-      expect(config.transport).toBe('stdio');
-      expect(config).toEqual({
-        transport: 'stdio',
-        command: 'node',
-        args: ['server.js'],
-      });
-    });
-
-    it('should validate stdio config with explicit transport', () => {
-      const config = validateServerConfig(
-        {
-          transport: 'stdio',
-          command: 'npx',
-          args: ['-y', '@modelcontextprotocol/server-github'],
-          env: { GITHUB_TOKEN: 'xxx' },
-        },
-        'github'
-      );
-
-      expect(config.transport).toBe('stdio');
-      expect((config as { command: string }).command).toBe('npx');
-      expect((config as { args: string[] }).args).toEqual([
-        '-y',
-        '@modelcontextprotocol/server-github',
-      ]);
-      expect((config as { env: Record<string, string> }).env).toEqual({ GITHUB_TOKEN: 'xxx' });
-    });
-
-    it('should validate http config with url', () => {
-      const config = validateServerConfig(
-        {
-          url: 'https://api.example.com/mcp',
-        },
-        'remote-server'
-      );
-
-      expect(config.transport).toBe('http');
-      expect((config as { url: string }).url).toBe('https://api.example.com/mcp');
-    });
-
-    it('should validate sse config with explicit transport', () => {
-      const config = validateServerConfig(
-        {
-          transport: 'sse',
-          url: 'https://api.example.com/sse',
-          headers: { Authorization: 'Bearer xxx' },
-        },
-        'sse-server'
-      );
-
-      expect(config.transport).toBe('sse');
-    });
-
-    it('should throw for missing command or url', () => {
-      expect(() => validateServerConfig({}, 'test')).toThrow(McpError);
-    });
-
-    it('should throw for invalid url', () => {
-      expect(() => validateServerConfig({ url: 'not-a-url' }, 'test')).toThrow(McpError);
-    });
-
-    it('should throw for invalid args type', () => {
-      expect(() => validateServerConfig({ command: 'node', args: 'invalid' }, 'test')).toThrow(
-        McpError
-      );
-    });
-  });
-
-  describe('parseServersFromConfig', () => {
-    it('should parse servers from config object', () => {
-      const config = {
-        mcpServers: {
-          github: {
-            command: 'npx',
-            args: ['-y', '@modelcontextprotocol/server-github'],
-          },
-          filesystem: {
-            command: 'npx',
-            args: ['-y', '@modelcontextprotocol/server-filesystem'],
-          },
-        },
-      };
-
-      const servers = parseServersFromConfig(config);
-
-      expect(servers).toHaveLength(2);
-      expect(servers.map((s) => s.name)).toContain('github');
-      expect(servers.map((s) => s.name)).toContain('filesystem');
-    });
-
-    it('should return empty array for config without mcpServers', () => {
-      const servers = parseServersFromConfig({});
-      expect(servers).toHaveLength(0);
-    });
-
-    it('should skip invalid server configs', () => {
-      const config = {
-        mcpServers: {
-          valid: { command: 'node' },
-          invalid: { invalid: true },
-        },
-      };
-
-      const servers = parseServersFromConfig(config);
-      expect(servers).toHaveLength(1);
-      expect(servers[0].name).toBe('valid');
-    });
-  });
-
-  describe('loadServersFromFile', () => {
-    it('should load servers from JSON file', () => {
-      const configPath = join(tempDir, 'mcp.json');
-      writeFileSync(
-        configPath,
-        JSON.stringify({
-          mcpServers: {
-            'test-server': {
-              command: 'node',
-              args: ['server.js'],
-            },
-          },
-        })
-      );
-
-      const servers = loadServersFromFile(configPath);
-
-      expect(servers).toHaveLength(1);
-      expect(servers[0].name).toBe('test-server');
-      expect(servers[0].config.transport).toBe('stdio');
-    });
-
-    it('should throw for non-existent file', () => {
-      expect(() => loadServersFromFile('/nonexistent/file.json')).toThrow(McpError);
-    });
-
-    it('should throw for invalid JSON', () => {
-      const configPath = join(tempDir, 'invalid.json');
-      writeFileSync(configPath, 'not valid json');
-
-      expect(() => loadServersFromFile(configPath)).toThrow(McpError);
-    });
-  });
-
-  describe('discoverMcpServers', () => {
-    it('should discover servers from project directory', () => {
-      // Create project with .claude/mcp.json
-      const claudeDir = join(tempDir, '.claude');
-      mkdirSync(claudeDir);
-      writeFileSync(
-        join(claudeDir, 'mcp.json'),
-        JSON.stringify({
-          mcpServers: {
-            project: { command: 'node', args: ['project-server.js'] },
-          },
-        })
-      );
-
-      const servers = discoverMcpServers({
-        projectRoot: tempDir,
-        includeGlobal: false,
-      });
-
-      expect(servers).toHaveLength(1);
-      expect(servers[0].name).toBe('project');
-    });
-
-    it('should discover from root mcp.json', () => {
-      writeFileSync(
-        join(tempDir, 'mcp.json'),
-        JSON.stringify({
-          mcpServers: {
-            root: { command: 'node' },
-          },
-        })
-      );
-
-      const servers = discoverMcpServers({
-        projectRoot: tempDir,
-        includeGlobal: false,
-      });
-
-      expect(servers).toHaveLength(1);
-      expect(servers[0].name).toBe('root');
-    });
-
-    it('should prioritize project config over root config', () => {
-      // Create both configs with same server name
-      const claudeDir = join(tempDir, '.claude');
-      mkdirSync(claudeDir);
-      writeFileSync(
-        join(claudeDir, 'mcp.json'),
-        JSON.stringify({
-          mcpServers: {
-            shared: { command: 'project-cmd' },
-          },
-        })
-      );
-      writeFileSync(
-        join(tempDir, 'mcp.json'),
-        JSON.stringify({
-          mcpServers: {
-            shared: { command: 'root-cmd' },
-          },
-        })
-      );
-
-      const servers = discoverMcpServers({
-        projectRoot: tempDir,
-        includeGlobal: false,
-      });
-
-      expect(servers).toHaveLength(1);
-      expect((servers[0].config as { command: string }).command).toBe('project-cmd');
-    });
-
-    it('should discover from additional paths', () => {
-      const customPath = join(tempDir, 'custom', 'config.json');
-      mkdirSync(join(tempDir, 'custom'));
-      writeFileSync(
-        customPath,
-        JSON.stringify({
-          mcpServers: {
-            custom: { command: 'custom-cmd' },
-          },
-        })
-      );
-
-      const servers = discoverMcpServers({
-        projectRoot: tempDir,
-        includeGlobal: false,
-        additionalPaths: [customPath],
-      });
-
-      expect(servers.some((s) => s.name === 'custom')).toBe(true);
-    });
-
-    it('should return empty array when no configs found', () => {
-      const servers = discoverMcpServers({
-        projectRoot: tempDir,
-        includeGlobal: false,
-      });
-
-      expect(servers).toHaveLength(0);
-    });
-  });
-
-  describe('findMcpConfigFile', () => {
-    it('should find config in .claude directory', () => {
-      const claudeDir = join(tempDir, '.claude');
-      mkdirSync(claudeDir);
-      writeFileSync(join(claudeDir, 'mcp.json'), '{}');
-
-      const found = findMcpConfigFile(tempDir);
-      expect(found).toBe(join(claudeDir, 'mcp.json'));
-    });
-
-    it('should find config in root directory', () => {
-      writeFileSync(join(tempDir, 'mcp.json'), '{}');
-
-      const found = findMcpConfigFile(tempDir);
-      expect(found).toBe(join(tempDir, 'mcp.json'));
-    });
-
-    it('should return null when no config found', () => {
-      const found = findMcpConfigFile(tempDir);
-      expect(found).toBeNull();
-    });
-  });
-
-  describe('getDefaultMcpConfigPath', () => {
-    it('should return .claude/mcp.json path', () => {
-      const path = getDefaultMcpConfigPath(tempDir);
-      expect(path).toBe(join(tempDir, '.claude', 'mcp.json'));
-    });
-
-    it('should use cwd when no root provided', () => {
-      const path = getDefaultMcpConfigPath();
-      expect(path).toBe(join(process.cwd(), '.claude', 'mcp.json'));
-    });
-  });
-});

package/src/adapters/mcp/discovery.ts

@@ -1,340 +0,0 @@
-/**
- * MCP Server Discovery
- *
- * Discovers and loads MCP server configurations from various sources.
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-import type {
-  McpConfigFile,
-  McpServerConfig,
-  McpServerDefinition,
-  StdioServerConfig,
-  HttpServerConfig,
-} from './types.js';
-import { McpError } from './types.js';
-
-/**
- * Options for discovering MCP servers
- */
-export interface DiscoveryOptions {
-  /**
-   * Project root directory to search from
-   */
-  projectRoot?: string;
-
-  /**
-   * Whether to include global config from home directory
-   */
-  includeGlobal?: boolean;
-
-  /**
-   * Additional config file paths to check
-   */
-  additionalPaths?: string[];
-}
-
-/**
- * Known config file locations
- */
-const CONFIG_FILENAMES = ['mcp.json', '.mcp.json', 'claude_desktop_config.json'];
-
-const PROJECT_CONFIG_DIRS = ['.claude', '.config', ''];
-
-/**
- * Discover MCP servers from configuration files
- */
-export function discoverMcpServers(options: DiscoveryOptions = {}): McpServerDefinition[] {
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const includeGlobal = options.includeGlobal ?? true;
-  const additionalPaths = options.additionalPaths ?? [];
-
-  const servers: McpServerDefinition[] = [];
-  const seenServers = new Set<string>();
-
-  // Build list of config file paths to check
-  const configPaths: string[] = [];
-
-  // Project-level configs (highest priority)
-  for (const dir of PROJECT_CONFIG_DIRS) {
-    for (const filename of CONFIG_FILENAMES) {
-      const path = dir ? join(projectRoot, dir, filename) : join(projectRoot, filename);
-      configPaths.push(path);
-    }
-  }
-
-  // Additional paths
-  configPaths.push(...additionalPaths);
-
-  // Global config (lowest priority)
-  if (includeGlobal) {
-    const homeDir = homedir();
-    const globalPaths = [
-      join(homeDir, '.config', 'claude', 'mcp.json'),
-      join(homeDir, '.claude', 'mcp.json'),
-      join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
-    ];
-    configPaths.push(...globalPaths);
-  }
-
-  // Load servers from each config file (earlier files take precedence)
-  for (const configPath of configPaths) {
-    if (!existsSync(configPath)) continue;
-
-    try {
-      const fileServers = loadServersFromFile(configPath);
-
-      for (const server of fileServers) {
-        // Skip if we already have a server with this name
-        if (seenServers.has(server.name)) continue;
-
-        seenServers.add(server.name);
-        servers.push(server);
-      }
-    } catch (error) {
-      // Log warning but continue with other files
-      console.warn(
-        `Warning: Failed to load MCP config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  return servers;
-}
-
-/**
- * Load MCP servers from a config file
- */
-export function loadServersFromFile(filePath: string): McpServerDefinition[] {
-  if (!existsSync(filePath)) {
-    throw new McpError(`Config file not found: ${filePath}`, 'invalid_config');
-  }
-
-  const content = readFileSync(filePath, 'utf-8');
-  let config: McpConfigFile;
-
-  try {
-    config = JSON.parse(content);
-  } catch (error) {
-    throw new McpError(
-      `Invalid JSON in config file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
-      'invalid_config',
-      undefined,
-      error instanceof Error ? error : undefined
-    );
-  }
-
-  return parseServersFromConfig(config, filePath);
-}
-
-/**
- * Parse server definitions from config object
- */
-export function parseServersFromConfig(
-  config: McpConfigFile,
-  sourcePath?: string
-): McpServerDefinition[] {
-  const servers: McpServerDefinition[] = [];
-
-  if (!config.mcpServers) {
-    return servers;
-  }
-
-  for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-    try {
-      const validConfig = validateServerConfig(serverConfig, name);
-
-      // Resolve relative paths for stdio commands
-      if (validConfig.transport === 'stdio' && sourcePath) {
-        validConfig.cwd = validConfig.cwd ?? dirname(sourcePath);
-      }
-
-      servers.push({
-        name,
-        config: validConfig,
-        enabled: true,
-      });
-    } catch (error) {
-      console.warn(
-        `Warning: Invalid server config for "${name}": ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  return servers;
-}
-
-/**
- * Validate and normalize a server configuration
- */
-export function validateServerConfig(config: unknown, serverName: string): McpServerConfig {
-  if (!config || typeof config !== 'object') {
-    throw new McpError(
-      `Server config for "${serverName}" must be an object`,
-      'invalid_config',
-      serverName
-    );
-  }
-
-  const cfg = config as Record<string, unknown>;
-
-  // Determine transport type
-  // If 'command' exists, it's stdio
-  // If 'url' exists, it's http/sse
-  // Otherwise check explicit 'transport' field
-
-  if ('command' in cfg && typeof cfg.command === 'string') {
-    return validateStdioConfig(cfg, serverName);
-  }
-
-  if ('url' in cfg && typeof cfg.url === 'string') {
-    return validateHttpConfig(cfg, serverName);
-  }
-
-  // Check explicit transport
-  if ('transport' in cfg) {
-    const transport = cfg.transport;
-    if (transport === 'stdio') {
-      return validateStdioConfig(cfg, serverName);
-    }
-    if (transport === 'http' || transport === 'sse') {
-      return validateHttpConfig(cfg, serverName);
-    }
-    throw new McpError(
-      `Unknown transport type "${transport}" for server "${serverName}"`,
-      'invalid_config',
-      serverName
-    );
-  }
-
-  throw new McpError(
-    `Server config for "${serverName}" must have either 'command' (stdio) or 'url' (http)`,
-    'invalid_config',
-    serverName
-  );
-}
-
-/**
- * Validate stdio server configuration
- */
-function validateStdioConfig(cfg: Record<string, unknown>, serverName: string): StdioServerConfig {
-  if (!cfg.command || typeof cfg.command !== 'string') {
-    throw new McpError(
-      `Server "${serverName}" requires a 'command' string`,
-      'invalid_config',
-      serverName
-    );
-  }
-
-  const config: StdioServerConfig = {
-    transport: 'stdio',
-    command: cfg.command,
-  };
-
-  if (cfg.args !== undefined) {
-    if (!Array.isArray(cfg.args) || !cfg.args.every((a) => typeof a === 'string')) {
-      throw new McpError(
-        `Server "${serverName}" 'args' must be an array of strings`,
-        'invalid_config',
-        serverName
-      );
-    }
-    config.args = cfg.args;
-  }
-
-  if (cfg.env !== undefined) {
-    if (typeof cfg.env !== 'object' || cfg.env === null) {
-      throw new McpError(
-        `Server "${serverName}" 'env' must be an object`,
-        'invalid_config',
-        serverName
-      );
-    }
-    config.env = cfg.env as Record<string, string>;
-  }
-
-  if (cfg.cwd !== undefined) {
-    if (typeof cfg.cwd !== 'string') {
-      throw new McpError(
-        `Server "${serverName}" 'cwd' must be a string`,
-        'invalid_config',
-        serverName
-      );
-    }
-    config.cwd = cfg.cwd;
-  }
-
-  return config;
-}
-
-/**
- * Validate HTTP/SSE server configuration
- */
-function validateHttpConfig(cfg: Record<string, unknown>, serverName: string): HttpServerConfig {
-  if (!cfg.url || typeof cfg.url !== 'string') {
-    throw new McpError(
-      `Server "${serverName}" requires a 'url' string`,
-      'invalid_config',
-      serverName
-    );
-  }
-
-  // Validate URL
-  try {
-    new URL(cfg.url);
-  } catch {
-    throw new McpError(
-      `Server "${serverName}" has invalid URL: ${cfg.url}`,
-      'invalid_config',
-      serverName
-    );
-  }
-
-  const transport = cfg.transport === 'sse' ? 'sse' : 'http';
-
-  const config: HttpServerConfig = {
-    transport,
-    url: cfg.url,
-  };
-
-  if (cfg.headers !== undefined) {
-    if (typeof cfg.headers !== 'object' || cfg.headers === null) {
-      throw new McpError(
-        `Server "${serverName}" 'headers' must be an object`,
-        'invalid_config',
-        serverName
-      );
-    }
-    config.headers = cfg.headers as Record<string, string>;
-  }
-
-  return config;
-}
-
-/**
- * Find an MCP config file in the project
- */
-export function findMcpConfigFile(projectRoot?: string): string | null {
-  const root = projectRoot ?? process.cwd();
-
-  for (const dir of PROJECT_CONFIG_DIRS) {
-    for (const filename of CONFIG_FILENAMES) {
-      const path = dir ? join(root, dir, filename) : join(root, filename);
-      if (existsSync(path)) {
-        return path;
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Get the default MCP config path for a project
- */
-export function getDefaultMcpConfigPath(projectRoot?: string): string {
-  const root = projectRoot ?? process.cwd();
-  return join(root, '.claude', 'mcp.json');
-}

package/src/adapters/mcp/index.ts

@@ -1,66 +0,0 @@
-/**
- * MCP Integration Module
- *
- * Provides MCP (Model Context Protocol) integration for adapters.
- */
-
-// Types
-export type {
-  McpTransportType,
-  StdioServerConfig,
-  HttpServerConfig,
-  McpServerConfig,
-  McpServerDefinition,
-  McpConfigFile,
-  McpServerInfo,
-  McpCapabilities,
-  McpTool,
-  McpResource,
-  McpToolResult,
-  McpContent,
-  McpTextContent,
-  McpImageContent,
-  McpResourceContent,
-  McpErrorCode,
-} from './types.js';
-
-export { McpError } from './types.js';
-
-// Client
-export type { McpClientOptions } from './client.js';
-
-export { McpClient, createMockMcpClient } from './client.js';
-
-// Discovery
-export type { DiscoveryOptions } from './discovery.js';
-
-export {
-  discoverMcpServers,
-  loadServersFromFile,
-  parseServersFromConfig,
-  validateServerConfig,
-  findMcpConfigFile,
-  getDefaultMcpConfigPath,
-} from './discovery.js';
-
-// Mapper
-export type { ToolMapping, ServerMapping } from './mapper.js';
-
-export {
-  findKnownServerMappings,
-  autoDiscoverMappings,
-  getMappingsForServer,
-  groupMappingsByAdapter,
-} from './mapper.js';
-
-// Registry
-export type {
-  ServerEntry,
-  ServerStatus,
-  RegistryEvents,
-  RegistryOptions,
-  ServerStatusSummary,
-  RegistryStatus,
-} from './registry.js';
-
-export { McpRegistry, createRegistry } from './registry.js';