@kirosnn/mosaic 0.0.91 → 0.73.0

package/src/mcp/config.ts

@@ -0,0 +1,223 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import type { McpServerConfig, McpGlobalConfig } from './types';
+
+const MCP_DIR = join(homedir(), '.mosaic', 'mcp');
+const CONFIG_FILE = join(MCP_DIR, 'config.json');
+const SERVERS_DIR = join(MCP_DIR, 'servers');
+
+function ensureDirs(): void {
+  if (!existsSync(MCP_DIR)) mkdirSync(MCP_DIR, { recursive: true });
+  if (!existsSync(SERVERS_DIR)) mkdirSync(SERVERS_DIR, { recursive: true });
+}
+
+export function getDefaultServerConfig(): Partial<McpServerConfig> {
+  return {
+    enabled: true,
+    transport: { type: 'stdio' },
+    args: [],
+    autostart: 'startup',
+    timeouts: {
+      initialize: 30000,
+      call: 60000,
+    },
+    limits: {
+      maxCallsPerMinute: 60,
+      maxPayloadBytes: 1024 * 1024,
+    },
+    logs: {
+      persist: false,
+      bufferSize: 200,
+    },
+    tools: {},
+    approval: 'always',
+  };
+}
+
+function getNavigationServerConfig(): Partial<McpServerConfig> {
+  const serverPath = fileURLToPath(new URL('./servers/navigation.ts', import.meta.url));
+  return {
+    id: 'navigation',
+    name: 'Navigation',
+    command: 'bun',
+    args: ['run', serverPath],
+    enabled: true,
+    autostart: 'startup',
+    approval: 'always',
+  };
+}
+
+export function validateServerConfig(config: Partial<McpServerConfig>): string[] {
+  const errors: string[] = [];
+
+  if (!config.id || typeof config.id !== 'string') {
+    errors.push('Server id is required and must be a string');
+  } else if (!/^[a-zA-Z0-9_-]+$/.test(config.id)) {
+    errors.push('Server id must contain only alphanumeric characters, hyphens, and underscores');
+  }
+
+  if (!config.name || typeof config.name !== 'string') {
+    errors.push('Server name is required and must be a string');
+  }
+
+  if (!config.command || typeof config.command !== 'string') {
+    errors.push('Server command is required and must be a string');
+  }
+
+  if (config.args && !Array.isArray(config.args)) {
+    errors.push('Server args must be an array of strings');
+  }
+
+  if (config.autostart && !['startup', 'on-demand', 'never'].includes(config.autostart)) {
+    errors.push('Server autostart must be "startup", "on-demand", or "never"');
+  }
+
+  if (config.approval && !['always', 'once-per-tool', 'once-per-server', 'never'].includes(config.approval)) {
+    errors.push('Server approval must be "always", "once-per-tool", "once-per-server", or "never"');
+  }
+
+  return errors;
+}
+
+function mergeWithDefaults(partial: Partial<McpServerConfig>): McpServerConfig {
+  const defaults = getDefaultServerConfig();
+  return {
+    id: partial.id!,
+    name: partial.name || partial.id!,
+    enabled: partial.enabled ?? defaults.enabled!,
+    transport: partial.transport || defaults.transport!,
+    command: partial.command!,
+    args: partial.args || defaults.args!,
+    cwd: partial.cwd,
+    env: partial.env,
+    autostart: partial.autostart || defaults.autostart!,
+    timeouts: { ...defaults.timeouts!, ...partial.timeouts },
+    limits: { ...defaults.limits!, ...partial.limits },
+    logs: { ...defaults.logs!, ...partial.logs },
+    tools: { ...defaults.tools, ...partial.tools },
+    approval: partial.approval || defaults.approval!,
+  };
+}
+
+function loadGlobalConfigFile(): Partial<McpGlobalConfig> {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+
+function loadServerFiles(): Partial<McpServerConfig>[] {
+  if (!existsSync(SERVERS_DIR)) return [];
+  const files = readdirSync(SERVERS_DIR).filter(f => f.endsWith('.json'));
+  const configs: Partial<McpServerConfig>[] = [];
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(SERVERS_DIR, file), 'utf-8');
+      const parsed = JSON.parse(content);
+      if (!parsed.id) {
+        parsed.id = file.replace(/\.json$/, '');
+      }
+      configs.push(parsed);
+    } catch {
+      // skip invalid files
+    }
+  }
+
+  return configs;
+}
+
+export function loadMcpConfig(): McpServerConfig[] {
+  ensureDirs();
+
+  const globalConfig = loadGlobalConfigFile();
+  const serverFiles = loadServerFiles();
+
+  const configMap = new Map<string, Partial<McpServerConfig>>();
+
+  if (globalConfig.servers) {
+    for (const server of globalConfig.servers) {
+      if (server.id) {
+        configMap.set(server.id, server);
+      }
+    }
+  }
+
+  for (const server of serverFiles) {
+    if (server.id) {
+      const existing = configMap.get(server.id);
+      if (existing) {
+        configMap.set(server.id, { ...existing, ...server });
+      } else {
+        configMap.set(server.id, server);
+      }
+    }
+  }
+
+  if (!configMap.has('navigation')) {
+    configMap.set('navigation', getNavigationServerConfig());
+  }
+
+  const results: McpServerConfig[] = [];
+  for (const [, partial] of configMap) {
+    const errors = validateServerConfig(partial);
+    if (errors.length === 0) {
+      results.push(mergeWithDefaults(partial));
+    }
+  }
+
+  return results;
+}
+
+export function saveServerConfig(config: Partial<McpServerConfig>): void {
+  ensureDirs();
+  const errors = validateServerConfig(config);
+  if (errors.length > 0) {
+    throw new Error(`Invalid server config: ${errors.join(', ')}`);
+  }
+  const filePath = join(SERVERS_DIR, `${config.id}.json`);
+  writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export function removeServerConfig(id: string): boolean {
+  const filePath = join(SERVERS_DIR, `${id}.json`);
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+    return true;
+  }
+
+  const globalConfig = loadGlobalConfigFile();
+  if (globalConfig.servers) {
+    const idx = globalConfig.servers.findIndex(s => s.id === id);
+    if (idx !== -1) {
+      globalConfig.servers.splice(idx, 1);
+      writeFileSync(CONFIG_FILE, JSON.stringify(globalConfig, null, 2), 'utf-8');
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function updateServerConfig(id: string, updates: Partial<McpServerConfig>): McpServerConfig | null {
+  const configs = loadMcpConfig();
+  const existing = configs.find(c => c.id === id);
+  if (!existing) return null;
+
+  const updated = { ...existing, ...updates, id };
+  saveServerConfig(updated);
+  return updated;
+}
+
+export function getMcpConfigDir(): string {
+  return MCP_DIR;
+}
+
+export function getServersDir(): string {
+  return SERVERS_DIR;
+}

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;
+  }
+}