@kirosnn/mosaic 0.71.0 → 0.74.0

package/src/mcp/cli/doctor.ts

@@ -0,0 +1,74 @@
+import { loadMcpConfig } from '../config';
+import { McpProcessManager } from '../processManager';
+import { platform } from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export async function mcpDoctor(): Promise<void> {
+  const configs = loadMcpConfig();
+
+  if (configs.length === 0) {
+    console.log('No MCP servers configured. Nothing to diagnose.');
+    return;
+  }
+
+  console.log(`Diagnosing ${configs.length} MCP server(s)...\n`);
+
+  const manager = new McpProcessManager();
+  let pass = 0;
+  let fail = 0;
+
+  for (const config of configs) {
+    console.log(`--- ${config.id} (${config.name}) ---`);
+
+    console.log('  [config] OK');
+
+    const commandExists = await checkCommand(config.command);
+    if (commandExists) {
+      console.log(`  [command] "${config.command}" found`);
+    } else {
+      console.log(`  [command] WARNING: "${config.command}" not found on PATH`);
+    }
+
+    if (!config.enabled) {
+      console.log('  [status] DISABLED - skipping connectivity test');
+      console.log('');
+      continue;
+    }
+
+    try {
+      const state = await manager.startServer(config);
+
+      if (state.status === 'running') {
+        console.log(`  [connect] OK (${state.initLatencyMs}ms)`);
+        console.log(`  [tools] ${state.toolCount} tool(s) discovered`);
+        pass++;
+      } else {
+        console.log(`  [connect] FAILED: ${state.lastError || 'unknown error'}`);
+        fail++;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`  [connect] FAILED: ${message}`);
+      fail++;
+    }
+
+    console.log('');
+  }
+
+  await manager.shutdownAll();
+
+  console.log(`\nResults: ${pass} passed, ${fail} failed, ${configs.length - pass - fail} skipped`);
+}
+
+async function checkCommand(command: string): Promise<boolean> {
+  const which = platform() === 'win32' ? 'where' : 'which';
+  try {
+    await execAsync(`${which} ${command}`);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/mcp/cli/index.ts

@@ -0,0 +1,85 @@
+export async function runMcpCli(args: string[]): Promise<void> {
+  const command = args[0] || 'help';
+  const rest = args.slice(1);
+
+  switch (command) {
+    case 'list':
+    case 'ls': {
+      const { mcpList } = await import('./list');
+      await mcpList();
+      break;
+    }
+
+    case 'tools': {
+      const { mcpTools } = await import('./tools');
+      await mcpTools(rest[0]);
+      break;
+    }
+
+    case 'doctor': {
+      const { mcpDoctor } = await import('./doctor');
+      await mcpDoctor();
+      break;
+    }
+
+    case 'logs': {
+      const { mcpLogs } = await import('./logs');
+      await mcpLogs(rest[0]);
+      break;
+    }
+
+    case 'show': {
+      const { mcpShow } = await import('./show');
+      await mcpShow(rest[0]);
+      break;
+    }
+
+    case 'add': {
+      const { mcpAdd } = await import('./add');
+      await mcpAdd(rest[0]);
+      break;
+    }
+
+    case 'remove':
+    case 'enable':
+    case 'disable':
+    case 'restart':
+    case 'start':
+    case 'stop':
+    case 'refresh': {
+      const { mcpManage } = await import('./manage');
+      await mcpManage(command, rest[0]);
+      break;
+    }
+
+    case 'help':
+    default:
+      showMcpHelp();
+      break;
+  }
+}
+
+function showMcpHelp(): void {
+  console.log(`
+Mosaic MCP - Model Context Protocol client
+
+Usage:
+  mosaic mcp <command> [options]
+
+Commands:
+  list                 List configured MCP servers
+  tools [serverId]     List available MCP tools
+  doctor               Run diagnostics on MCP servers
+  logs <serverId>      Show server logs
+  show <serverId>      Show server config and state
+  add [name]           Add an MCP server (by name or from the list)
+  remove <serverId>    Remove a server
+  enable <serverId>    Enable a server
+  disable <serverId>   Disable a server
+  start <serverId>     Start a server
+  stop <serverId>      Stop a server
+  restart <serverId>   Restart a server
+  refresh [serverId]   Refresh tool catalog
+  help                 Show this help
+`);
+}

package/src/mcp/cli/list.ts

@@ -0,0 +1,50 @@
+import { loadMcpConfig } from '../config';
+import { getMcpManager } from '../index';
+
+export async function mcpList(): Promise<void> {
+  const configs = loadMcpConfig();
+
+  if (configs.length === 0) {
+    console.log('No MCP servers configured.');
+    console.log('Use "mosaic mcp add" to add a server.');
+    return;
+  }
+
+  const manager = getMcpManager();
+
+  const header = [
+    pad('ID', 20),
+    pad('Name', 20),
+    pad('Enabled', 8),
+    pad('Autostart', 10),
+    pad('Status', 10),
+    pad('Tools', 6),
+    'Last Error',
+  ].join(' | ');
+
+  console.log(header);
+  console.log('-'.repeat(header.length));
+
+  for (const config of configs) {
+    const state = manager.getState(config.id);
+    const status = state?.status || 'stopped';
+    const toolCount = state?.toolCount ?? 0;
+    const lastError = state?.lastError || '';
+
+    const row = [
+      pad(config.id, 20),
+      pad(config.name, 20),
+      pad(config.enabled ? 'yes' : 'no', 8),
+      pad(config.autostart, 10),
+      pad(status, 10),
+      pad(String(toolCount), 6),
+      lastError.length > 40 ? lastError.slice(0, 40) + '...' : lastError,
+    ].join(' | ');
+
+    console.log(row);
+  }
+}
+
+function pad(str: string, len: number): string {
+  return str.length >= len ? str.slice(0, len) : str + ' '.repeat(len - str.length);
+}

package/src/mcp/cli/logs.ts

@@ -0,0 +1,24 @@
+import { getMcpManager } from '../index';
+
+export async function mcpLogs(serverId?: string): Promise<void> {
+  if (!serverId) {
+    console.log('Usage: mosaic mcp logs <serverId>');
+    return;
+  }
+
+  const manager = getMcpManager();
+  const logs = manager.getLogs(serverId);
+
+  if (logs.length === 0) {
+    console.log(`No logs for server "${serverId}".`);
+    return;
+  }
+
+  console.log(`Logs for ${serverId} (${logs.length} entries):\n`);
+
+  for (const entry of logs) {
+    const time = new Date(entry.timestamp).toISOString().slice(11, 23);
+    const level = entry.level.toUpperCase().padEnd(5);
+    console.log(`[${time}] ${level} ${entry.message}`);
+  }
+}

package/src/mcp/cli/manage.ts

@@ -0,0 +1,99 @@
+import { loadMcpConfig, removeServerConfig, updateServerConfig } from '../config';
+import { getMcpManager, initializeMcp } from '../index';
+
+export async function mcpManage(command: string, serverId?: string): Promise<void> {
+  if (!serverId && command !== 'refresh') {
+    console.log(`Usage: mosaic mcp ${command} <serverId>`);
+    return;
+  }
+
+  switch (command) {
+    case 'remove': {
+      const removed = removeServerConfig(serverId!);
+      if (removed) {
+        console.log(`Server "${serverId}" removed.`);
+      } else {
+        console.log(`Server "${serverId}" not found.`);
+      }
+      break;
+    }
+
+    case 'enable': {
+      const result = updateServerConfig(serverId!, { enabled: true });
+      if (result) {
+        console.log(`Server "${serverId}" enabled.`);
+      } else {
+        console.log(`Server "${serverId}" not found.`);
+      }
+      break;
+    }
+
+    case 'disable': {
+      const result = updateServerConfig(serverId!, { enabled: false });
+      if (result) {
+        console.log(`Server "${serverId}" disabled.`);
+      } else {
+        console.log(`Server "${serverId}" not found.`);
+      }
+      break;
+    }
+
+    case 'start': {
+      const configs = loadMcpConfig();
+      const config = configs.find(c => c.id === serverId);
+      if (!config) {
+        console.log(`Server "${serverId}" not found.`);
+        return;
+      }
+
+      const manager = getMcpManager();
+      console.log(`Starting server "${serverId}"...`);
+      const state = await manager.startServer(config);
+      console.log(`Status: ${state.status}`);
+      if (state.lastError) console.log(`Error: ${state.lastError}`);
+      if (state.toolCount > 0) console.log(`Tools: ${state.toolCount}`);
+      break;
+    }
+
+    case 'stop': {
+      const manager = getMcpManager();
+      console.log(`Stopping server "${serverId}"...`);
+      await manager.stopServer(serverId!);
+      console.log(`Server "${serverId}" stopped.`);
+      break;
+    }
+
+    case 'restart': {
+      const manager = getMcpManager();
+      console.log(`Restarting server "${serverId}"...`);
+      const state = await manager.restartServer(serverId!);
+      if (state) {
+        console.log(`Status: ${state.status}`);
+        if (state.toolCount > 0) console.log(`Tools: ${state.toolCount}`);
+      } else {
+        console.log(`Server "${serverId}" not found.`);
+      }
+      break;
+    }
+
+    case 'refresh': {
+      await initializeMcp();
+      const { getMcpCatalog } = await import('../index');
+      try {
+        const catalog = getMcpCatalog();
+        catalog.refreshTools(serverId);
+        const tools = catalog.getMcpToolInfos();
+        const count = serverId
+          ? tools.filter(t => t.serverId === serverId).length
+          : tools.length;
+        console.log(`Refreshed. ${count} MCP tool(s) available.`);
+      } catch {
+        console.log('MCP not initialized. No servers configured or all failed.');
+      }
+      break;
+    }
+
+    default:
+      console.log(`Unknown command: ${command}`);
+  }
+}

package/src/mcp/cli/show.ts

@@ -0,0 +1,53 @@
+import { loadMcpConfig } from '../config';
+import { getMcpManager } from '../index';
+
+export async function mcpShow(serverId?: string): Promise<void> {
+  if (!serverId) {
+    console.log('Usage: mosaic mcp show <serverId>');
+    return;
+  }
+
+  const configs = loadMcpConfig();
+  const config = configs.find(c => c.id === serverId);
+
+  if (!config) {
+    console.log(`Server "${serverId}" not found.`);
+    return;
+  }
+
+  console.log(`Server: ${config.id}`);
+  console.log(`  Name:      ${config.name}`);
+  console.log(`  Enabled:   ${config.enabled}`);
+  console.log(`  Command:   ${config.command} ${config.args.join(' ')}`);
+  if (config.cwd) console.log(`  CWD:       ${config.cwd}`);
+  console.log(`  Autostart: ${config.autostart}`);
+  console.log(`  Approval:  ${config.approval}`);
+  console.log(`  Timeouts:  init=${config.timeouts.initialize}ms, call=${config.timeouts.call}ms`);
+  console.log(`  Limits:    ${config.limits.maxCallsPerMinute} calls/min, ${config.limits.maxPayloadBytes} bytes max`);
+  console.log(`  Logs:      persist=${config.logs.persist}, buffer=${config.logs.bufferSize}`);
+
+  if (config.tools.allow) console.log(`  Allow:     ${config.tools.allow.join(', ')}`);
+  if (config.tools.deny) console.log(`  Deny:      ${config.tools.deny.join(', ')}`);
+
+  if (config.env) {
+    console.log(`  Env:`);
+    for (const [key, value] of Object.entries(config.env)) {
+      console.log(`    ${key}=${value.length > 30 ? value.slice(0, 30) + '...' : value}`);
+    }
+  }
+
+  const manager = getMcpManager();
+  const state = manager.getState(serverId);
+
+  if (state) {
+    console.log(`\nRuntime State:`);
+    console.log(`  Status:     ${state.status}`);
+    if (state.pid) console.log(`  PID:        ${state.pid}`);
+    if (state.initLatencyMs) console.log(`  Init:       ${state.initLatencyMs}ms`);
+    console.log(`  Tools:      ${state.toolCount}`);
+    if (state.lastError) console.log(`  Last Error: ${state.lastError}`);
+    if (state.lastCallAt) console.log(`  Last Call:  ${new Date(state.lastCallAt).toISOString()}`);
+  } else {
+    console.log(`\nRuntime State: not started`);
+  }
+}

package/src/mcp/cli/tools.ts

@@ -0,0 +1,77 @@
+import { loadMcpConfig } from '../config';
+import { getMcpManager } from '../index';
+
+export async function mcpTools(serverId?: string): Promise<void> {
+  const configs = loadMcpConfig();
+
+  if (configs.length === 0) {
+    console.log('No MCP servers configured.');
+    return;
+  }
+
+  const manager = getMcpManager();
+  const targetConfigs = serverId ? configs.filter(c => c.id === serverId) : configs;
+
+  if (serverId && targetConfigs.length === 0) {
+    console.log(`Server "${serverId}" not found.`);
+    return;
+  }
+
+  let totalTools = 0;
+
+  for (const config of targetConfigs) {
+    const state = manager.getState(config.id);
+    if (!state || state.status !== 'running') {
+      console.log(`\n[${config.id}] (${state?.status || 'not started'})`);
+      continue;
+    }
+
+    const tools = manager.listTools(config.id);
+    console.log(`\n[${config.id}] ${config.name} - ${tools.length} tools`);
+
+    if (tools.length === 0) {
+      console.log('  (no tools)');
+      continue;
+    }
+
+    const deny = config.tools.deny || [];
+    const allow = config.tools.allow || [];
+
+    for (const t of tools) {
+      let status = 'exposed';
+      if (deny.length > 0 && deny.some(p => matchPattern(t.name, p))) {
+        status = 'denied';
+      } else if (allow.length > 0 && !allow.some(p => matchPattern(t.name, p))) {
+        status = 'denied';
+      }
+
+      const desc = t.description ? ` - ${t.description.slice(0, 60)}` : '';
+      console.log(`  ${status === 'denied' ? 'x' : '+'} ${t.canonicalId}${desc}`);
+
+      if (t.inputSchema && typeof t.inputSchema === 'object') {
+        const props = (t.inputSchema as any).properties;
+        if (props && typeof props === 'object') {
+          const required = ((t.inputSchema as any).required || []) as string[];
+          for (const [key, schema] of Object.entries(props as Record<string, any>)) {
+            const type = schema.type || 'unknown';
+            const req = required.includes(key) ? 'required' : 'optional';
+            console.log(`    - ${key} (${type}, ${req})`);
+          }
+        }
+      }
+
+      totalTools++;
+    }
+  }
+
+  console.log(`\nTotal: ${totalTools} tools`);
+}
+
+function matchPattern(name: string, pattern: string): boolean {
+  if (pattern === '*') return true;
+  if (pattern === name) return true;
+  const regex = new RegExp(
+    '^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+  );
+  return regex.test(name);
+}

package/src/mcp/config.ts

@@ -0,0 +1,234 @@
+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/index.ts', import.meta.url));
+  return {
+    id: 'navigation',
+    name: 'Navigation',
+    native: true,
+    command: 'npx',
+    args: ['tsx', serverPath],
+    enabled: true,
+    autostart: 'startup',
+    approval: 'never',
+    toolApproval: {
+      navigation_cookies: 'always',
+      navigation_headers: 'always',
+    },
+    timeouts: {
+      initialize: 30000,
+      call: 60000,
+    },
+  };
+}
+
+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!,
+    native: partial.native,
+    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!,
+    toolApproval: partial.toolApproval,
+  };
+}
+
+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;
+}