@hileeon/mcc 0.1.4 → 0.1.6

package/src/mcp/installer.ts

@@ -1,258 +0,0 @@
-/**
- * MCP Server Installer
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import pc from 'picocolors';
-import {
-  getBuiltinServerPath,
-  BUILTIN_MCP_SERVERS,
-  getServerByName,
-  type McpServerConfig,
-} from './registry';
-import {
-  readExternalMcpRegistry,
-  type ExternalMcpServer,
-} from './external-registry';
-import { readMcpConfig } from './mcp-config';
-
-function getMccHome(): string {
-  return process.env.MCC_HOME ?? path.join(process.env.HOME ?? process.env.USERPROFILE ?? '~', '.mcc');
-}
-
-function getMcpInstallDir(): string {
-  return path.join(getMccHome(), 'mcp');
-}
-
-export function installBuiltinServers(): void {
-  const installDir = getMcpInstallDir();
-  fs.mkdirSync(installDir, { recursive: true, mode: 0o700 });
-  const copied: string[] = [];
-
-  // Install MCP server entry points
-  for (const server of BUILTIN_MCP_SERVERS) {
-    const sourcePath = getBuiltinServerPath(server.name);
-    if (!sourcePath) {
-      console.warn(`[!] Built-in server not found: ${server.name}`);
-      continue;
-    }
-    const destPath = path.join(installDir, path.basename(sourcePath));
-    if (fs.existsSync(destPath)) {
-      const sourceContent = fs.readFileSync(sourcePath);
-      const destContent = fs.readFileSync(destPath);
-      if (sourceContent.equals(destContent)) continue;
-    }
-    fs.copyFileSync(sourcePath, destPath);
-    fs.chmodSync(destPath, 0o700);
-    copied.push(server.name);
-  }
-
-  // Install mcp-hooks/ (runtime files referenced by MCP servers)
-  const hooksSourceDir = path.join(__dirname, '..', '..', 'lib', 'mcp-hooks');
-  const hooksInstallDir = path.join(getMccHome(), 'mcp-hooks');
-  if (fs.existsSync(hooksSourceDir)) {
-    fs.mkdirSync(hooksInstallDir, { recursive: true, mode: 0o700 });
-    for (const entry of fs.readdirSync(hooksSourceDir)) {
-      if (!entry.endsWith('.cjs')) continue;
-      const src = path.join(hooksSourceDir, entry);
-      const dest = path.join(hooksInstallDir, entry);
-      if (fs.existsSync(dest)) {
-        if (fs.readFileSync(src).equals(fs.readFileSync(dest))) continue;
-      }
-      fs.copyFileSync(src, dest);
-      fs.chmodSync(dest, 0o700);
-      copied.push(`hooks/${entry}`);
-    }
-  }
-
-  // Install shared logger to ~/.mcc/shared/logger.cjs
-  const sharedSource = path.join(__dirname, '..', '..', 'lib', 'shared', 'logger.cjs');
-  const sharedDestDir = path.join(getMccHome(), 'shared');
-  if (fs.existsSync(sharedSource)) {
-    fs.mkdirSync(sharedDestDir, { recursive: true, mode: 0o700 });
-    const sharedDest = path.join(sharedDestDir, 'logger.cjs');
-    if (!fs.existsSync(sharedDest) || !fs.readFileSync(sharedSource).equals(fs.readFileSync(sharedDest))) {
-      fs.copyFileSync(sharedSource, sharedDest);
-      fs.chmodSync(sharedDest, 0o700);
-      copied.push('shared/logger.cjs');
-    }
-  }
-
-  if (copied.length > 0) {
-    console.log(`  ${pc.dim('install')}  ${pc.dim(copied.join(', '))}`);
-  }
-}
-
-export function readInstanceMcpConfig(instancePath: string): Record<string, McpServerConfig> {
-  // Read from .claude.json (where Claude Code actually reads MCP config)
-  const claudeJsonPath = path.join(instancePath, '.claude.json');
-  if (fs.existsSync(claudeJsonPath)) {
-    try {
-      const data = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
-      if (data.mcpServers) return data.mcpServers;
-    } catch { /* ignore */ }
-  }
-  return {};
-}
-
-function readClaudeJson(instancePath: string): Record<string, unknown> {
-  const claudeJsonPath = path.join(instancePath, '.claude.json');
-  if (fs.existsSync(claudeJsonPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
-    } catch { /* ignore */ }
-  }
-  return {};
-}
-
-function writeClaudeJson(instancePath: string, data: Record<string, unknown>): void {
-  const claudeJsonPath = path.join(instancePath, '.claude.json');
-  fs.writeFileSync(claudeJsonPath, JSON.stringify(data, null, 2) + '\n', {
-    encoding: 'utf8',
-    mode: 0o600,
-  });
-}
-
-/**
- * Read which external MCPs are enabled for a given instance.
- */
-export function readInstanceExternalEnabled(instancePath: string): string[] {
-  const filePath = path.join(instancePath, 'external-mcp-enabled.json');
-  if (!fs.existsSync(filePath)) return [];
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Write which external MCPs are enabled for a given instance.
- */
-function writeInstanceExternalEnabled(instancePath: string, names: string[]): void {
-  const filePath = path.join(instancePath, 'external-mcp-enabled.json');
-  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(filePath, JSON.stringify(names, null, 2) + '\n', {
-    encoding: 'utf8',
-    mode: 0o600,
-  });
-}
-
-/**
- * Resolve ${MCC_PROVIDER_KEY:<providerId>} placeholders from mcp-config.json.
- */
-function resolveEnvVar(value: string): string {
-  const match = value.match(/^\$\{MCC_PROVIDER_KEY:([^}]+)\}$/);
-  if (!match) return value;
-
-  const providerId = match[1];
-  const mcpConfig = readMcpConfig();
-
-  // Check imageAnalysis providers first
-  const iaProvider = mcpConfig.imageAnalysis.providers[providerId];
-  if (iaProvider?.apiKey) return iaProvider.apiKey;
-
-  // Check websearch providers
-  const wsProvider = mcpConfig.websearch.providers[providerId];
-  if (wsProvider?.apiKey) return wsProvider.apiKey;
-
-  return value; // Return placeholder if not resolved
-}
-
-/**
- * Resolve all env vars for an external MCP server.
- */
-function resolveExternalServerEnv(server: ExternalMcpServer): Record<string, string> {
-  const resolved: Record<string, string> = {};
-  for (const [key, value] of Object.entries(server.envVars)) {
-    resolved[key] = resolveEnvVar(value);
-  }
-  return resolved;
-}
-
-/**
- * Sync MCP servers for an instance into .claude.json.
- *
- * @param instancePath - Path to the instance directory
- * @param enabledServerNames - Names of servers to enable (from built-in + external)
- * @param profileName - Profile name, used to look up provider API keys
- */
-export function syncInstanceMcpServers(
-  instancePath: string,
-  enabledServerNames: string[],
-  _profileName?: string,
-): void {
-  const mcpServers: Record<string, McpServerConfig> = {};
-  const instanceExternalEnabled = readInstanceExternalEnabled(instancePath);
-
-  // Collect all enabled names: explicit list + per-instance external enables
-  const allEnabled = new Set([...enabledServerNames, ...instanceExternalEnabled]);
-
-  for (const name of allEnabled) {
-    const server = getServerByName(name);
-    if (!server) continue;
-
-    if ('config' in server) {
-      // Built-in server (has config field)
-      mcpServers[name] = server.config;
-    } else {
-      // External server (ExternalMcpServer)
-      const external = server as ExternalMcpServer;
-      mcpServers[name] = {
-        type: 'stdio',
-        command: external.command,
-        args: external.args,
-        env: resolveExternalServerEnv(external),
-      };
-    }
-  }
-
-  // Write to .claude.json (Claude Code reads MCP config from here)
-  const claudeJson = readClaudeJson(instancePath);
-  claudeJson.mcpServers = mcpServers;
-  writeClaudeJson(instancePath, claudeJson);
-
-  // Also write to .mcp/mcpServers.json (for reference/compatibility)
-  const mcpDir = path.join(instancePath, '.mcp');
-  fs.mkdirSync(mcpDir, { recursive: true, mode: 0o700 });
-  const configPath = path.join(mcpDir, 'mcpServers.json');
-  fs.writeFileSync(configPath, JSON.stringify(mcpServers, null, 2), {
-    encoding: 'utf8',
-    mode: 0o600,
-  });
-
-  const count = Object.keys(mcpServers).length;
-  console.log(`  ${pc.dim('mcp')}       ${pc.dim(`${count} server(s) synced`)}`);
-}
-
-/**
- * Enable an external MCP for a specific instance.
- */
-export function enableInstanceExternalMcp(instancePath: string, name: string): void {
-  const enabled = readInstanceExternalEnabled(instancePath);
-  if (!enabled.includes(name)) {
-    enabled.push(name);
-    writeInstanceExternalEnabled(instancePath, enabled);
-  }
-}
-
-/**
- * Disable an external MCP for a specific instance.
- */
-export function disableInstanceExternalMcp(instancePath: string, name: string): void {
-  const enabled = readInstanceExternalEnabled(instancePath);
-  writeInstanceExternalEnabled(
-    instancePath,
-    enabled.filter((n) => n !== name),
-  );
-}
-
-/**
- * Get all known server names (built-in + external).
- */
-export function getAllServerNames(): string[] {
-  const builtinNames = BUILTIN_MCP_SERVERS.map((s) => s.name);
-  const externalNames = readExternalMcpRegistry().map((s) => s.name);
-  return [...builtinNames, ...externalNames];
-}

package/src/mcp/mcp-config.ts

@@ -1,168 +0,0 @@
-/**
- * MCP Config - Provider configuration for WebSearch and ImageAnalysis
- *
- * Storage: ~/.mcc/mcp-config.json
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-function getMccHome(): string {
-  return process.env.MCC_HOME ?? path.join(process.env.HOME ?? process.env.USERPROFILE ?? '~', '.mcc');
-}
-
-export function getMcpConfigPath(): string {
-  return path.join(getMccHome(), 'mcp-config.json');
-}
-
-export interface WebSearchProvider {
-  enabled: boolean;
-  apiKey?: string;
-}
-
-export interface ImageAnalysisProvider {
-  enabled: boolean;
-  baseUrl: string;
-  apiKey: string;
-  model: string;
-  format: 'anthropic' | 'openai';
-}
-
-export interface McpConfig {
-  websearch: {
-    enabled: boolean;
-    providers: Record<string, WebSearchProvider>;
-  };
-  imageAnalysis: {
-    enabled: boolean;
-    providers: Record<string, ImageAnalysisProvider>;
-  };
-}
-
-const DEFAULT_CONFIG: McpConfig = {
-  websearch: {
-    enabled: true,
-    providers: {
-      duckduckgo: { enabled: true },
-      exa: { enabled: false, apiKey: '' },
-      tavily: { enabled: false, apiKey: '' },
-      brave: { enabled: false, apiKey: '' },
-    },
-  },
-  imageAnalysis: {
-    enabled: true,
-    providers: {
-      ali: {
-        enabled: false,
-        baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
-        apiKey: '',
-        model: 'qwen-vl-plus',
-        format: 'openai',
-      },
-      kimi: {
-        enabled: false,
-        baseUrl: 'https://api.moonshot.cn/v1',
-        apiKey: '',
-        model: 'moonshot-v1-128k-vision-preview',
-        format: 'openai',
-      },
-      minimax: {
-        enabled: false,
-        baseUrl: 'https://api.minimaxi.com/anthropic',
-        apiKey: '',
-        model: 'MiniMax-VL-01',
-        format: 'anthropic',
-      },
-      deepseek: {
-        enabled: false,
-        baseUrl: 'https://api.deepseek.com/anthropic',
-        apiKey: '',
-        model: 'deepseek-v4-pro[1m]',
-        format: 'anthropic',
-      },
-    },
-  },
-};
-
-export function readMcpConfig(): McpConfig {
-  const configPath = getMcpConfigPath();
-  if (!fs.existsSync(configPath)) {
-    return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
-  }
-  try {
-    const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    // Merge with defaults to ensure all fields exist
-    return {
-      websearch: {
-        enabled: raw.websearch?.enabled ?? DEFAULT_CONFIG.websearch.enabled,
-        providers: { ...DEFAULT_CONFIG.websearch.providers, ...raw.websearch?.providers },
-      },
-      imageAnalysis: {
-        enabled: raw.imageAnalysis?.enabled ?? DEFAULT_CONFIG.imageAnalysis.enabled,
-        providers: { ...DEFAULT_CONFIG.imageAnalysis.providers, ...raw.imageAnalysis?.providers },
-      },
-    };
-  } catch {
-    return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
-  }
-}
-
-export function writeMcpConfig(config: McpConfig): void {
-  const configPath = getMcpConfigPath();
-  fs.mkdirSync(path.dirname(configPath), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
-}
-
-export function getProviderPresets() {
-  return {
-    websearch: {
-      duckduckgo: { name: 'DuckDuckGo', needsApiKey: false, description: 'Free, no API key needed' },
-      exa: { name: 'Exa', needsApiKey: true, description: 'AI-powered search' },
-      tavily: { name: 'Tavily', needsApiKey: true, description: 'Search API for AI' },
-      brave: { name: 'Brave Search', needsApiKey: true, description: 'Privacy-focused search' },
-    },
-    imageAnalysis: {
-      ali: {
-        name: '阿里 DashScope',
-        format: 'openai' as const,
-        baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
-        models: ['qwen-vl-plus', 'qwen3-vl-flash', 'qwen-vl-max', 'qwen-vl-ocr', 'qvq-max', 'qvq-plus'],
-      },
-      kimi: {
-        name: 'Kimi (Moonshot)',
-        format: 'openai' as const,
-        baseUrl: 'https://api.moonshot.cn/v1',
-        models: ['moonshot-v1-128k-vision-preview', 'moonshot-v1-32k-vision-preview'],
-      },
-      minimax: {
-        name: 'MiniMax',
-        format: 'anthropic' as const,
-        baseUrl: 'https://api.minimaxi.com/anthropic',
-        models: ['MiniMax-VL-01'],
-      },
-      deepseek: {
-        name: 'DeepSeek',
-        format: 'anthropic' as const,
-        baseUrl: 'https://api.deepseek.com/anthropic',
-        models: ['deepseek-v4-pro[1m]', 'deepseek-v4-pro'],
-      },
-    },
-  };
-}
-
-/** Get the first enabled image analysis provider config, or null */
-export function getActiveImageAnalysisProvider(config: McpConfig): (ImageAnalysisProvider & { id: string }) | null {
-  for (const [id, provider] of Object.entries(config.imageAnalysis.providers)) {
-    if (provider.enabled && provider.apiKey && provider.baseUrl) {
-      return { id, ...provider };
-    }
-  }
-  return null;
-}
-
-/** Get all enabled websearch provider IDs */
-export function getEnabledWebSearchProviders(config: McpConfig): string[] {
-  return Object.entries(config.websearch.providers)
-    .filter(([, p]) => p.enabled)
-    .map(([id]) => id);
-}

package/src/mcp/registry.ts

@@ -1,89 +0,0 @@
-/**
- * MCP Server Registry
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import type { ExternalMcpServer } from './external-registry';
-
-export interface McpServerConfig {
-  type: 'stdio' | 'http';
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-  builtin?: boolean;
-}
-
-export interface McpRegistryEntry {
-  name: string;
-  displayName: string;
-  description: string;
-  config: McpServerConfig;
-  enabledByDefault: boolean;
-}
-
-function getMccHome(): string {
-  return process.env.MCC_HOME ?? path.join(process.env.HOME ?? process.env.USERPROFILE ?? '~', '.mcc');
-}
-
-export const BUILTIN_MCP_SERVERS: readonly McpRegistryEntry[] = [
-  {
-    name: 'mcc-websearch',
-    displayName: 'WebSearch',
-    description:
-      'Multi-provider web search (Exa, Tavily, Brave Search, DuckDuckGo).',
-    config: {
-      type: 'stdio',
-      command: 'node',
-      args: [path.join(getMccHome(), 'mcp', 'mcc-websearch-server.cjs')],
-      env: {},
-      builtin: true,
-    },
-    enabledByDefault: true,
-  },
-  {
-    name: 'mcc-image-analysis',
-    displayName: 'Image Analysis',
-    description: 'Image and PDF analysis via vision models.',
-    config: {
-      type: 'stdio',
-      command: 'node',
-      args: [path.join(getMccHome(), 'mcp', 'mcc-image-analysis-server.cjs')],
-      env: {},
-      builtin: true,
-    },
-    enabledByDefault: true,
-  },
-];
-
-export function getBuiltinServerPath(serverName: string): string | null {
-  const libDir = path.join(__dirname, '..', '..', 'lib', 'mcp');
-  const fileName =
-    serverName === 'mcc-websearch'
-      ? 'mcc-websearch-server.cjs'
-      : serverName === 'mcc-image-analysis'
-        ? 'mcc-image-analysis-server.cjs'
-        : null;
-  if (!fileName) return null;
-  const candidate = path.join(libDir, fileName);
-  return fs.existsSync(candidate) ? candidate : null;
-}
-
-export function getServerByName(
-  name: string,
-): McpRegistryEntry | ExternalMcpServer | undefined {
-  const builtin = BUILTIN_MCP_SERVERS.find((s) => s.name === name);
-  if (builtin) return builtin;
-  // Avoid circular import at module level — require at runtime
-  const { readExternalMcpRegistry } = require('./external-registry') as {
-    readExternalMcpRegistry: () => ExternalMcpServer[];
-  };
-  return readExternalMcpRegistry().find((s) => s.name === name);
-}
-
-export function getAllServers(): Array<McpRegistryEntry | ExternalMcpServer> {
-  const { readExternalMcpRegistry } = require('./external-registry') as {
-    readExternalMcpRegistry: () => ExternalMcpServer[];
-  };
-  return [...BUILTIN_MCP_SERVERS, ...readExternalMcpRegistry()];
-}

package/src/proxy/proxy-daemon.ts

@@ -1,184 +0,0 @@
-/**
- * Proxy Daemon - Lifecycle management for the translation proxy
- *
- * Manages starting/stopping the proxy as a detached child process.
- * Ported from CCS proxy/proxy-daemon.js (simplified for single-profile MCC).
- */
-
-import * as crypto from 'crypto';
-import * as http from 'http';
-import { spawn } from 'child_process';
-import * as path from 'path';
-import {
-  resolveAdaptivePort,
-  readProxyPid,
-  writeProxyPid,
-  removeProxyPid,
-  readProxySession,
-  writeProxySession,
-  removeProxySession,
-  PROXY_SERVICE_NAME,
-  type ProxySession,
-} from './proxy-paths';
-
-const PROXY_ENTRY_CANDIDATES = [
-  path.join(__dirname, 'proxy-entry.js'),
-  path.join(__dirname, 'proxy-entry.cjs'),
-];
-
-function generateAuthToken(): string {
-  return crypto.randomBytes(24).toString('hex');
-}
-
-async function isProxyRunning(port: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const req = http.request(
-      { hostname: '127.0.0.1', port, path: '/health', method: 'GET', timeout: 3000 },
-      (res) => {
-        let body = '';
-        res.setEncoding('utf8');
-        res.on('data', (chunk) => (body += chunk));
-        res.on('end', () => {
-          if (res.statusCode !== 200) { resolve(false); return; }
-          try {
-            const payload = JSON.parse(body);
-            resolve(payload.service === PROXY_SERVICE_NAME);
-          } catch {
-            resolve(false);
-          }
-        });
-      },
-    );
-    req.on('error', () => resolve(false));
-    req.on('timeout', () => { req.destroy(); resolve(false); });
-    req.end();
-  });
-}
-
-async function terminateProcess(pid: number): Promise<void> {
-  try {
-    process.kill(pid, 'SIGTERM');
-    let attempts = 0;
-    while (attempts < 10) {
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      try {
-        process.kill(pid, 0);
-        attempts++;
-      } catch {
-        return; // Process exited
-      }
-    }
-    process.kill(pid, 'SIGKILL');
-  } catch {
-    // Best-effort
-  }
-}
-
-export interface ProxyStartResult {
-  port: number;
-  authToken: string;
-}
-
-/**
- * Start the translation proxy for a profile.
- * If a proxy is already running for this profile, returns its existing session.
- */
-export async function startProxy(
-  profileName: string,
-  baseUrl: string,
-  apiKey: string,
-  model?: string,
-): Promise<ProxyStartResult> {
-  // Check if already running
-  const existingSession = readProxySession(profileName);
-  if (existingSession && await isProxyRunning(existingSession.port)) {
-    return { port: existingSession.port, authToken: existingSession.authToken };
-  }
-
-  // Clean up stale state
-  stopProxy(profileName).catch(() => {});
-
-  const port = resolveAdaptivePort(profileName);
-  const authToken = generateAuthToken();
-
-  // Find the entry script
-  let entryScript: string | null = null;
-  for (const candidate of PROXY_ENTRY_CANDIDATES) {
-    try {
-      const fs = await import('fs');
-      fs.accessSync(candidate, fs.constants.R_OK);
-      entryScript = candidate;
-      break;
-    } catch {
-      // Try next
-    }
-  }
-  if (!entryScript) {
-    throw new Error('Proxy entry script not found. Run: npm run build');
-  }
-
-  // Spawn the proxy as a detached child process
-  const child = spawn(process.execPath, [
-    entryScript,
-    '--port', String(port),
-    '--host', '127.0.0.1',
-    '--base-url', baseUrl,
-    '--api-key', apiKey,
-    '--auth-token', authToken,
-    ...(model ? ['--model', model] : []),
-  ], {
-    detached: true,
-    stdio: 'ignore',
-    env: { ...process.env },
-  });
-  child.unref();
-
-  const pid = child.pid;
-  if (!pid) {
-    throw new Error('Failed to spawn proxy process');
-  }
-
-  // Write PID and session files
-  writeProxyPid(profileName, pid);
-  const session: ProxySession = {
-    profileName,
-    port,
-    host: '127.0.0.1',
-    authToken,
-    baseUrl,
-    startedAt: new Date().toISOString(),
-  };
-  writeProxySession(session);
-
-  // Wait for the proxy to be ready (up to 5 seconds)
-  for (let i = 0; i < 25; i++) {
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    if (await isProxyRunning(port)) {
-      return { port, authToken };
-    }
-  }
-
-  throw new Error(`Proxy failed to start within 5 seconds (PID: ${pid}, port: ${port})`);
-}
-
-/**
- * Stop the translation proxy for a profile.
- */
-export async function stopProxy(profileName: string): Promise<void> {
-  const pid = readProxyPid(profileName);
-  if (pid) {
-    await terminateProcess(pid);
-  }
-  removeProxyPid(profileName);
-  removeProxySession(profileName);
-}
-
-/**
- * Check if a proxy is running for a profile.
- */
-export async function getProxyStatus(profileName: string): Promise<{ running: boolean; port?: number }> {
-  const session = readProxySession(profileName);
-  if (!session) return { running: false };
-  const running = await isProxyRunning(session.port);
-  return { running, port: running ? session.port : undefined };
-}