@kirosnn/mosaic 0.71.0 → 0.73.0

package/src/mcp/index.ts

@@ -0,0 +1,80 @@
+import { loadMcpConfig } from './config';
+import { McpProcessManager } from './processManager';
+import { McpApprovalPolicy } from './approvalPolicy';
+import { McpToolCatalog } from './toolCatalog';
+
+export type { McpServerConfig, McpServerState, McpToolInfo, McpRiskHint, McpGlobalConfig } from './types';
+export { toCanonicalId, toSafeId, parseSafeId, parseCanonicalId } from './types';
+
+let manager: McpProcessManager | null = null;
+let catalog: McpToolCatalog | null = null;
+let approvalPolicy: McpApprovalPolicy | null = null;
+let initialized = false;
+
+export function getMcpManager(): McpProcessManager {
+  if (!manager) {
+    manager = new McpProcessManager();
+  }
+  return manager;
+}
+
+export function getMcpCatalog(): McpToolCatalog {
+  if (!catalog) {
+    throw new Error('MCP not initialized. Call initializeMcp() first.');
+  }
+  return catalog;
+}
+
+export function getMcpApprovalPolicy(): McpApprovalPolicy {
+  if (!approvalPolicy) {
+    approvalPolicy = new McpApprovalPolicy();
+  }
+  return approvalPolicy;
+}
+
+export async function initializeMcp(): Promise<string[]> {
+  if (initialized) return [];
+
+  const configs = loadMcpConfig();
+  if (configs.length === 0) {
+    initialized = true;
+    return [];
+  }
+
+  manager = new McpProcessManager();
+  approvalPolicy = new McpApprovalPolicy();
+  catalog = new McpToolCatalog(manager, approvalPolicy, configs);
+
+  const startupServers = configs.filter(c => c.enabled && c.autostart === 'startup');
+  const failedServers: string[] = [];
+
+  for (const config of startupServers) {
+    try {
+      await manager.startServer(config);
+    } catch {
+      failedServers.push(config.id || config.command || 'unknown');
+    }
+  }
+
+  if (failedServers.length > 0) {
+    console.error(`MCP: failed to start servers: ${failedServers.join(', ')}`);
+  }
+
+  catalog.refreshTools();
+  initialized = true;
+  return failedServers;
+}
+
+export async function shutdownMcp(): Promise<void> {
+  if (manager) {
+    await manager.shutdownAll();
+  }
+  manager = null;
+  catalog = null;
+  approvalPolicy = null;
+  initialized = false;
+}
+
+export function isMcpInitialized(): boolean {
+  return initialized;
+}

package/src/mcp/processManager.ts

@@ -0,0 +1,299 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import type { McpServerConfig, McpServerState, McpToolInfo } from './types';
+import { toCanonicalId, toSafeId } from './types';
+import { McpRateLimiter } from './rateLimiter';
+
+interface LogEntry {
+  timestamp: number;
+  level: 'info' | 'error' | 'debug';
+  message: string;
+}
+
+interface ServerInstance {
+  config: McpServerConfig;
+  client: Client;
+  transport: StdioClientTransport;
+  state: McpServerState;
+  tools: McpToolInfo[];
+  logBuffer: LogEntry[];
+  restartCount: number;
+  lastRestartAt: number;
+}
+
+const MAX_RESTART_COUNT = 5;
+const BACKOFF_DELAYS = [1000, 2000, 4000, 8000, 16000, 30000];
+
+export class McpProcessManager {
+  private servers = new Map<string, ServerInstance>();
+  private rateLimiter = new McpRateLimiter();
+
+  async startServer(config: McpServerConfig): Promise<McpServerState> {
+    const existing = this.servers.get(config.id);
+    if (existing && existing.state.status === 'running') {
+      return existing.state;
+    }
+
+    const state: McpServerState = {
+      status: 'starting',
+      toolCount: 0,
+    };
+
+    const logBuffer: LogEntry[] = [];
+
+    const addLog = (level: LogEntry['level'], message: string) => {
+      logBuffer.push({ timestamp: Date.now(), level, message });
+      if (logBuffer.length > config.logs.bufferSize) {
+        logBuffer.shift();
+      }
+    };
+
+    addLog('info', `Starting server ${config.id} (${config.command})`);
+
+    try {
+      const startTime = Date.now();
+
+      const transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: config.env ? { ...process.env, ...config.env } as Record<string, string> : undefined,
+        cwd: config.cwd,
+      });
+
+      const client = new Client(
+        { name: 'mosaic', version: '1.0.0' },
+        { capabilities: {} }
+      );
+
+      await client.connect(transport);
+
+      const initLatencyMs = Date.now() - startTime;
+      addLog('info', `Connected in ${initLatencyMs}ms`);
+
+      const toolsResult = await client.listTools();
+      const tools: McpToolInfo[] = (toolsResult.tools || []).map(t => ({
+        serverId: config.id,
+        name: t.name,
+        description: t.description || '',
+        inputSchema: (t.inputSchema || {}) as Record<string, unknown>,
+        canonicalId: toCanonicalId(config.id, t.name),
+        safeId: toSafeId(config.id, t.name),
+      }));
+
+      state.status = 'running';
+      state.initLatencyMs = initLatencyMs;
+      state.toolCount = tools.length;
+
+      addLog('info', `Listed ${tools.length} tools`);
+
+      this.rateLimiter.configure(config.id, config.limits.maxCallsPerMinute);
+
+      const instance: ServerInstance = {
+        config,
+        client,
+        transport,
+        state,
+        tools,
+        logBuffer,
+        restartCount: existing?.restartCount ?? 0,
+        lastRestartAt: existing?.lastRestartAt ?? 0,
+      };
+
+      this.servers.set(config.id, instance);
+
+      transport.onclose = () => {
+        const srv = this.servers.get(config.id);
+        if (srv && srv.state.status === 'running') {
+          srv.state.status = 'error';
+          srv.state.lastError = 'Transport closed unexpectedly';
+          addLog('error', 'Transport closed unexpectedly');
+          this.attemptRestart(config.id);
+        }
+      };
+
+      transport.onerror = (error: Error) => {
+        addLog('error', `Transport error: ${error.message}`);
+      };
+
+      return state;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      state.status = 'error';
+      state.lastError = message;
+      addLog('error', `Failed to start: ${message}`);
+
+      this.servers.set(config.id, {
+        config,
+        client: null!,
+        transport: null!,
+        state,
+        tools: [],
+        logBuffer,
+        restartCount: existing?.restartCount ?? 0,
+        lastRestartAt: existing?.lastRestartAt ?? 0,
+      });
+
+      return state;
+    }
+  }
+
+  async stopServer(id: string): Promise<void> {
+    const instance = this.servers.get(id);
+    if (!instance) return;
+
+    instance.state.status = 'stopped';
+
+    try {
+      if (instance.client) {
+        await instance.client.close();
+      }
+    } catch {
+      // best effort
+    }
+
+    this.rateLimiter.remove(id);
+  }
+
+  async restartServer(id: string): Promise<McpServerState | null> {
+    const instance = this.servers.get(id);
+    if (!instance) return null;
+
+    await this.stopServer(id);
+    return this.startServer(instance.config);
+  }
+
+  async callTool(serverId: string, toolName: string, args: Record<string, unknown>): Promise<{ content: string; isError: boolean }> {
+    const instance = this.servers.get(serverId);
+    if (!instance) {
+      return { content: `Server ${serverId} not found`, isError: true };
+    }
+
+    if (instance.state.status !== 'running') {
+      return { content: `Server ${serverId} is not running (status: ${instance.state.status})`, isError: true };
+    }
+
+    const payloadSize = JSON.stringify(args).length;
+    if (payloadSize > instance.config.limits.maxPayloadBytes) {
+      return {
+        content: `Payload too large: ${payloadSize} bytes (max: ${instance.config.limits.maxPayloadBytes})`,
+        isError: true,
+      };
+    }
+
+    await this.rateLimiter.acquire(serverId);
+
+    try {
+      const timeout = instance.config.timeouts.call;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+
+      const result = await instance.client.callTool(
+        { name: toolName, arguments: args },
+        undefined,
+        { signal: controller.signal }
+      );
+
+      clearTimeout(timer);
+      instance.state.lastCallAt = Date.now();
+
+      const contentParts = result.content as Array<{ type: string; text?: string }>;
+      const text = contentParts
+        .filter(p => p.type === 'text')
+        .map(p => p.text || '')
+        .join('\n');
+
+      return {
+        content: text || JSON.stringify(result.content),
+        isError: result.isError === true,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      instance.logBuffer.push({
+        timestamp: Date.now(),
+        level: 'error',
+        message: `callTool ${toolName} failed: ${message}`,
+      });
+      return { content: `Tool call failed: ${message}`, isError: true };
+    }
+  }
+
+  listTools(serverId: string): McpToolInfo[] {
+    const instance = this.servers.get(serverId);
+    if (!instance) return [];
+    return [...instance.tools];
+  }
+
+  getAllTools(): McpToolInfo[] {
+    const all: McpToolInfo[] = [];
+    for (const instance of this.servers.values()) {
+      if (instance.state.status === 'running') {
+        all.push(...instance.tools);
+      }
+    }
+    return all;
+  }
+
+  getState(serverId: string): McpServerState | null {
+    const instance = this.servers.get(serverId);
+    return instance ? { ...instance.state } : null;
+  }
+
+  getAllStates(): Map<string, McpServerState> {
+    const states = new Map<string, McpServerState>();
+    for (const [id, instance] of this.servers) {
+      states.set(id, { ...instance.state });
+    }
+    return states;
+  }
+
+  getLogs(serverId: string): LogEntry[] {
+    const instance = this.servers.get(serverId);
+    if (!instance) return [];
+    return [...instance.logBuffer];
+  }
+
+  getConfig(serverId: string): McpServerConfig | null {
+    const instance = this.servers.get(serverId);
+    return instance ? instance.config : null;
+  }
+
+  async shutdownAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
+    for (const id of this.servers.keys()) {
+      promises.push(this.stopServer(id));
+    }
+    await Promise.allSettled(promises);
+    this.servers.clear();
+  }
+
+  private async attemptRestart(id: string): Promise<void> {
+    const instance = this.servers.get(id);
+    if (!instance) return;
+
+    if (instance.restartCount >= MAX_RESTART_COUNT) {
+      instance.logBuffer.push({
+        timestamp: Date.now(),
+        level: 'error',
+        message: `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`,
+      });
+      return;
+    }
+
+    const delay = BACKOFF_DELAYS[Math.min(instance.restartCount, BACKOFF_DELAYS.length - 1)]!;
+    instance.restartCount++;
+    instance.lastRestartAt = Date.now();
+
+    instance.logBuffer.push({
+      timestamp: Date.now(),
+      level: 'info',
+      message: `Scheduling restart #${instance.restartCount} in ${delay}ms`,
+    });
+
+    await new Promise(resolve => setTimeout(resolve, delay));
+
+    const current = this.servers.get(id);
+    if (current && current.state.status !== 'running' && current.state.status !== 'stopped') {
+      await this.startServer(instance.config);
+    }
+  }
+}

package/src/mcp/rateLimiter.ts

@@ -0,0 +1,50 @@
+interface TokenBucket {
+  tokens: number;
+  maxTokens: number;
+  refillRate: number;
+  lastRefill: number;
+}
+
+export class McpRateLimiter {
+  private buckets = new Map<string, TokenBucket>();
+
+  configure(serverId: string, maxCallsPerMinute: number): void {
+    this.buckets.set(serverId, {
+      tokens: maxCallsPerMinute,
+      maxTokens: maxCallsPerMinute,
+      refillRate: maxCallsPerMinute / 60,
+      lastRefill: Date.now(),
+    });
+  }
+
+  tryAcquire(serverId: string): boolean {
+    const bucket = this.buckets.get(serverId);
+    if (!bucket) return true;
+
+    this.refill(bucket);
+
+    if (bucket.tokens >= 1) {
+      bucket.tokens -= 1;
+      return true;
+    }
+
+    return false;
+  }
+
+  async acquire(serverId: string): Promise<void> {
+    while (!this.tryAcquire(serverId)) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+
+  remove(serverId: string): void {
+    this.buckets.delete(serverId);
+  }
+
+  private refill(bucket: TokenBucket): void {
+    const now = Date.now();
+    const elapsed = (now - bucket.lastRefill) / 1000;
+    bucket.tokens = Math.min(bucket.maxTokens, bucket.tokens + elapsed * bucket.refillRate);
+    bucket.lastRefill = now;
+  }
+}

package/src/mcp/registry.ts

@@ -0,0 +1,151 @@
+export interface McpRegistryEntry {
+  id: string;
+  name: string;
+  description: string;
+  command: string;
+  args: string[];
+  env?: Record<string, { description: string; required: boolean }>;
+  prompts?: { key: string; question: string; argIndex?: number }[];
+}
+
+export const MCP_REGISTRY: McpRegistryEntry[] = [
+  {
+    id: 'filesystem',
+    name: 'Filesystem',
+    description: 'Read/write access to the local filesystem',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-filesystem', '{path}'],
+    prompts: [{ key: 'path', question: 'Directory path to expose', argIndex: 2 }],
+  },
+  {
+    id: 'memory',
+    name: 'Memory',
+    description: 'Persistent knowledge graph memory for the agent',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-memory'],
+  },
+  {
+    id: 'fetch',
+    name: 'Fetch',
+    description: 'Fetch and convert web content to markdown',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-fetch'],
+  },
+  {
+    id: 'brave-search',
+    name: 'Brave Search',
+    description: 'Web search via Brave Search API',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-brave-search'],
+    env: { BRAVE_API_KEY: { description: 'Brave Search API key', required: true } },
+  },
+  {
+    id: 'github',
+    name: 'GitHub',
+    description: 'GitHub API access (repos, issues, PRs, etc.)',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-github'],
+    env: { GITHUB_PERSONAL_ACCESS_TOKEN: { description: 'GitHub personal access token', required: true } },
+  },
+  {
+    id: 'gitlab',
+    name: 'GitLab',
+    description: 'GitLab API access (repos, issues, MRs, etc.)',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-gitlab'],
+    env: {
+      GITLAB_PERSONAL_ACCESS_TOKEN: { description: 'GitLab personal access token', required: true },
+      GITLAB_API_URL: { description: 'GitLab API URL (for self-hosted)', required: false },
+    },
+  },
+  {
+    id: 'google-maps',
+    name: 'Google Maps',
+    description: 'Google Maps geocoding, directions, places, and elevation',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-google-maps'],
+    env: { GOOGLE_MAPS_API_KEY: { description: 'Google Maps API key', required: true } },
+  },
+  {
+    id: 'slack',
+    name: 'Slack',
+    description: 'Slack workspace access (channels, messages, users)',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-slack'],
+    env: {
+      SLACK_BOT_TOKEN: { description: 'Slack bot token (xoxb-...)', required: true },
+      SLACK_TEAM_ID: { description: 'Slack workspace/team ID', required: true },
+    },
+  },
+  {
+    id: 'postgres',
+    name: 'PostgreSQL',
+    description: 'Read-only access to a PostgreSQL database',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-postgres', '{connection_string}'],
+    prompts: [{ key: 'connection_string', question: 'PostgreSQL connection string (postgresql://...)', argIndex: 2 }],
+  },
+  {
+    id: 'sqlite',
+    name: 'SQLite',
+    description: 'Read/write access to a SQLite database',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-sqlite', '--db-path', '{db_path}'],
+    prompts: [{ key: 'db_path', question: 'Path to the SQLite database file', argIndex: 3 }],
+  },
+  {
+    id: 'puppeteer',
+    name: 'Puppeteer',
+    description: 'Browser automation and web scraping via Puppeteer',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-puppeteer'],
+  },
+  {
+    id: 'sequential-thinking',
+    name: 'Sequential Thinking',
+    description: 'Dynamic problem-solving through structured sequential thinking',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+  },
+  {
+    id: 'everything',
+    name: 'Everything',
+    description: 'MCP test server with sample tools, resources, and prompts',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-everything'],
+  },
+  {
+    id: 'browser-use',
+    name: 'Browser Use',
+    description: 'AI-powered browser automation, web search, and data extraction',
+    command: 'npx',
+    args: ['-y', 'browser-use-mcp'],
+    env: { BROWSER_USE_API_KEY: { description: 'Browser Use API key (from cloud.browser-use.com)', required: true } },
+  },
+  {
+    id: 'sentry',
+    name: 'Sentry',
+    description: 'Sentry error tracking access',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-sentry'],
+    env: { SENTRY_AUTH_TOKEN: { description: 'Sentry auth token', required: true } },
+  },
+];
+
+export function findRegistryEntry(nameOrId: string): McpRegistryEntry | null {
+  const lower = nameOrId.toLowerCase().replace(/\s+/g, '-');
+  return MCP_REGISTRY.find(e =>
+    e.id === lower ||
+    e.name.toLowerCase() === nameOrId.toLowerCase() ||
+    e.name.toLowerCase().replace(/\s+/g, '-') === lower
+  ) || null;
+}
+
+export function searchRegistry(query: string): McpRegistryEntry[] {
+  const lower = query.toLowerCase();
+  return MCP_REGISTRY.filter(e =>
+    e.id.includes(lower) ||
+    e.name.toLowerCase().includes(lower) ||
+    e.description.toLowerCase().includes(lower)
+  );
+}

package/src/mcp/schemaConverter.ts

@@ -0,0 +1,100 @@
+import { z, type ZodTypeAny } from 'zod';
+
+export function jsonSchemaToZod(schema: Record<string, unknown>): ZodTypeAny {
+  if (!schema || typeof schema !== 'object') {
+    return z.unknown();
+  }
+
+  if (schema.enum && Array.isArray(schema.enum)) {
+    const values = schema.enum as [string, ...string[]];
+    if (values.length > 0) {
+      return z.enum(values as [string, ...string[]]);
+    }
+    return z.string();
+  }
+
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const schemas = (schema.oneOf as Record<string, unknown>[]).map(s => jsonSchemaToZod(s));
+    if (schemas.length === 0) return z.unknown();
+    if (schemas.length === 1) return schemas[0]!;
+    return z.union([schemas[0]!, schemas[1]!, ...schemas.slice(2)]);
+  }
+
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const schemas = (schema.anyOf as Record<string, unknown>[]).map(s => jsonSchemaToZod(s));
+    if (schemas.length === 0) return z.unknown();
+    if (schemas.length === 1) return schemas[0]!;
+    return z.union([schemas[0]!, schemas[1]!, ...schemas.slice(2)]);
+  }
+
+  const type = schema.type as string | undefined;
+  const description = schema.description as string | undefined;
+
+  let result: ZodTypeAny;
+
+  switch (type) {
+    case 'string': {
+      let s = z.string();
+      if (typeof schema.minLength === 'number') s = s.min(schema.minLength);
+      if (typeof schema.maxLength === 'number') s = s.max(schema.maxLength);
+      result = s;
+      break;
+    }
+
+    case 'number':
+    case 'integer': {
+      let n = type === 'integer' ? z.number().int() : z.number();
+      if (typeof schema.minimum === 'number') n = n.min(schema.minimum);
+      if (typeof schema.maximum === 'number') n = n.max(schema.maximum);
+      result = n;
+      break;
+    }
+
+    case 'boolean':
+      result = z.boolean();
+      break;
+
+    case 'array': {
+      const items = schema.items as Record<string, unknown> | undefined;
+      const itemSchema = items ? jsonSchemaToZod(items) : z.unknown();
+      result = z.array(itemSchema);
+      break;
+    }
+
+    case 'object': {
+      result = jsonSchemaObjectToZodObject(schema);
+      break;
+    }
+
+    case 'null':
+      result = z.null();
+      break;
+
+    default:
+      result = z.unknown();
+      break;
+  }
+
+  if (description) {
+    result = result.describe(description);
+  }
+
+  return result;
+}
+
+export function jsonSchemaObjectToZodObject(schema: Record<string, unknown>): z.ZodObject<any> {
+  const properties = (schema.properties || {}) as Record<string, Record<string, unknown>>;
+  const required = (schema.required || []) as string[];
+
+  const shape: Record<string, ZodTypeAny> = {};
+
+  for (const [key, propSchema] of Object.entries(properties)) {
+    let zodProp = jsonSchemaToZod(propSchema);
+    if (!required.includes(key)) {
+      zodProp = zodProp.optional();
+    }
+    shape[key] = zodProp;
+  }
+
+  return z.object(shape).passthrough();
+}