@kirosnn/mosaic 0.0.91 → 0.73.0

package/src/mcp/cli/add.ts

@@ -0,0 +1,185 @@
+import { createInterface } from 'readline';
+import { saveServerConfig, loadMcpConfig } from '../config';
+import { MCP_REGISTRY, findRegistryEntry, type McpRegistryEntry } from '../registry';
+import type { McpServerConfig } from '../types';
+
+function ask(rl: ReturnType<typeof createInterface>, question: string, defaultValue?: string): Promise<string> {
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  return new Promise(resolve => {
+    rl.question(`${question}${suffix}: `, (answer: string) => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+export async function mcpAdd(nameArg?: string): Promise<void> {
+  const existing = loadMcpConfig();
+  const existingIds = new Set(existing.map(c => c.id));
+
+  if (nameArg) {
+    const entry = findRegistryEntry(nameArg);
+    if (entry) {
+      if (existingIds.has(entry.id)) {
+        console.log(`Server "${entry.id}" is already configured.`);
+        return;
+      }
+      await addFromRegistry(entry);
+      return;
+    }
+    console.log(`"${nameArg}" not found in the registry.\n`);
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    console.log('Available MCP servers:\n');
+
+    for (let i = 0; i < MCP_REGISTRY.length; i++) {
+      const entry = MCP_REGISTRY[i]!;
+      const installed = existingIds.has(entry.id) ? ' (installed)' : '';
+      console.log(`  ${String(i + 1).padStart(2)}. ${entry.name.padEnd(22)} ${entry.description}${installed}`);
+    }
+
+    console.log(`\n   0. Custom server`);
+
+    const choice = await ask(rl, '\nChoose a server (number or name)', '');
+    rl.close();
+
+    if (!choice) return;
+
+    if (choice === '0' || choice.toLowerCase() === 'custom') {
+      await addCustom();
+      return;
+    }
+
+    const num = parseInt(choice, 10);
+    let entry: McpRegistryEntry | null = null;
+
+    if (!isNaN(num) && num >= 1 && num <= MCP_REGISTRY.length) {
+      entry = MCP_REGISTRY[num - 1]!;
+    } else {
+      entry = findRegistryEntry(choice);
+    }
+
+    if (!entry) {
+      console.log(`"${choice}" not found.`);
+      return;
+    }
+
+    if (existingIds.has(entry.id)) {
+      console.log(`Server "${entry.id}" is already configured.`);
+      return;
+    }
+
+    await addFromRegistry(entry);
+  } catch (error) {
+    if ((error as any)?.code === 'ERR_USE_AFTER_CLOSE') return;
+    throw error;
+  } finally {
+    try { rl.close(); } catch {}
+  }
+}
+
+async function addFromRegistry(entry: McpRegistryEntry): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    console.log(`\nAdding ${entry.name}: ${entry.description}\n`);
+
+    const args = [...entry.args];
+    const env: Record<string, string> = {};
+
+    if (entry.prompts) {
+      for (const prompt of entry.prompts) {
+        const value = await ask(rl, prompt.question);
+        if (!value) {
+          console.log('Cancelled.');
+          return;
+        }
+        if (prompt.argIndex !== undefined) {
+          args[prompt.argIndex] = value;
+        }
+      }
+    }
+
+    if (entry.env) {
+      for (const [key, meta] of Object.entries(entry.env)) {
+        const existing = process.env[key];
+        if (existing) {
+          console.log(`  ${key}: using value from environment`);
+          env[key] = existing;
+          continue;
+        }
+
+        const suffix = meta.required ? '' : ' (optional, press Enter to skip)';
+        const value = await ask(rl, `${meta.description}${suffix}`);
+
+        if (!value && meta.required) {
+          console.log(`${key} is required. Cancelled.`);
+          return;
+        }
+
+        if (value) {
+          env[key] = value;
+        }
+      }
+    }
+
+    const config: Partial<McpServerConfig> = {
+      id: entry.id,
+      name: entry.name,
+      command: entry.command,
+      args,
+      enabled: true,
+      autostart: 'startup',
+      approval: 'always',
+      ...(Object.keys(env).length > 0 && { env }),
+    };
+
+    saveServerConfig(config);
+    console.log(`\n"${entry.id}" added successfully.`);
+    console.log(`Run "mosaic mcp doctor" to test connectivity.`);
+  } finally {
+    rl.close();
+  }
+}
+
+async function addCustom(): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    console.log('\nCustom MCP server\n');
+
+    const id = await ask(rl, 'Server ID');
+    if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+      console.log('Invalid server ID.');
+      return;
+    }
+
+    const name = await ask(rl, 'Display name', id);
+    const command = await ask(rl, 'Command (e.g., npx, node, python)');
+    if (!command) {
+      console.log('Command is required.');
+      return;
+    }
+
+    const argsStr = await ask(rl, 'Arguments (space-separated)', '');
+    const args = argsStr ? argsStr.split(/\s+/) : [];
+
+    const config: Partial<McpServerConfig> = {
+      id,
+      name,
+      command,
+      args,
+      enabled: true,
+      autostart: 'startup',
+      approval: 'always',
+    };
+
+    saveServerConfig(config);
+    console.log(`\n"${id}" added successfully.`);
+    console.log(`Run "mosaic mcp doctor" to test connectivity.`);
+  } finally {
+    rl.close();
+  }
+}

package/src/mcp/cli/doctor.ts

@@ -0,0 +1,77 @@
+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}) ---`);
+
+    // 1. Config validation
+    console.log('  [config] OK');
+
+    // 2. Check command resolves
+    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;
+    }
+
+    // 3. Try start + init + list tools
+    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);
+}