@hileeon/mcc 0.1.0

package/lib/shared/logger.cjs

@@ -0,0 +1,138 @@
+/**
+ * MCC Logger — 单文件，零依赖
+ *
+ * 设计原则：
+ * - session 隔离：每次 mcc <profile> 生成独立 session，所有子进程写同一文件
+ * - 确定性路径：MCC_LOG_DIR / MCC_LOG_SESSION_ID 两个 env 确定路径
+ * - 最小 API：init(sessionId, logDir) + logger(component).error/info/debug(msg)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+
+function env(key, fallback) {
+  return process.env[key] ?? fallback;
+}
+
+function levelValue(level) {
+  return LEVELS[level?.toLowerCase()] ?? LEVELS.info;
+}
+
+let _sessionId = '';
+let _logDir = '';
+let _currentFile = '';
+let _currentSize = 0;
+let _maxSize = 5 * 1024 * 1024;
+let _maxFiles = 3;
+let _minLevel = LEVELS.info;
+
+function getLogDir() {
+  if (_logDir) return _logDir;
+  const logDirEnv = env('MCC_LOG_DIR', '');
+  if (logDirEnv) return logDirEnv;
+  const mccHome = env('MCC_HOME', path.join(os.homedir(), '.mcc'));
+  const profile = env('MCC_CURRENT_PROFILE', 'default');
+  return path.join(mccHome, 'logs', profile, _sessionId || 'nosession');
+}
+
+function getLogPath() {
+  return path.join(getLogDir(), 'mcc.log');
+}
+
+function rotate() {
+  const logPath = getLogPath();
+  if (!fs.existsSync(logPath)) return;
+  try { fs.unlinkSync(`${logPath}.${_maxFiles}`); } catch {}
+  for (let i = _maxFiles - 1; i >= 1; i--) {
+    const from = `${logPath}.${i}`;
+    const to = `${logPath}.${i + 1}`;
+    try { if (fs.existsSync(from)) fs.renameSync(from, to); } catch {}
+  }
+  try { fs.renameSync(logPath, `${logPath}.1`); } catch {}
+  _currentSize = 0;
+  _currentFile = '';
+}
+
+function ensureDir() {
+  const dir = getLogDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o755 });
+  return dir;
+}
+
+function writeFile(line) {
+  if (!_sessionId) return;
+  ensureDir();
+  const logPath = getLogPath();
+  const lineBytes = Buffer.byteLength(line, 'utf8') + 1;
+  if (_currentFile !== logPath || _currentSize + lineBytes > _maxSize) {
+    rotate();
+  }
+  try {
+    fs.appendFileSync(logPath, line + '\n', { mode: 0o644 });
+    _currentFile = logPath;
+    _currentSize += lineBytes;
+  } catch (err) {
+    process.stderr.write(`[logger] write failed: ${err.message}\n`);
+  }
+}
+
+function timestamp() {
+  const now = new Date();
+  const p = (n, l = 2) => String(n).padStart(l, '0');
+  return `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())} ` +
+    `${p(now.getHours())}:${p(now.getMinutes())}:${p(now.getSeconds())}.${p(now.getMilliseconds(), 3)}`;
+}
+
+function format(level, message, component) {
+  const sid = _sessionId ? `[${_sessionId}]` : '';
+  const comp = component ? `[${component}]` : '';
+  return `${timestamp()} ${(level || 'info').toUpperCase().padEnd(5)} ${sid}${comp} ${message}`;
+}
+
+function write(level, message, component) {
+  if (levelValue(level) > _minLevel) return;
+  const line = format(level, message, component);
+  process.stderr.write(line + '\n');
+  writeFile(line);
+}
+
+// --- 导出---
+
+function init(sessionId, logDir) {
+  _sessionId = sessionId || '';
+  _logDir = logDir || '';
+  _currentFile = '';
+  _currentSize = 0;
+  _minLevel = levelValue(env('MCC_LOG_LEVEL', 'info'));
+  _maxSize = parseInt(env('MCC_LOG_MAX_SIZE', ''), 10) || 5 * 1024 * 1024;
+  _maxFiles = parseInt(env('MCC_LOG_MAX_FILES', ''), 10) || 3;
+  const dir = ensureDir();
+  try { fs.writeFileSync(path.join(dir, '.session'), `${sessionId}\n${Date.now()}\n`, { mode: 0o644 }); } catch {}
+  return dir;
+}
+
+function initFromEnv() {
+  const sid = env('MCC_LOG_SESSION_ID', '');
+  const dir = env('MCC_LOG_DIR', '');
+  if (sid) init(sid, dir);
+}
+
+// 统一 API：log.info(component, message) — 两参数风格
+const log = {
+  error:   (c, m) => write('error', m, c),
+  warn:    (c, m) => write('warn',  m, c),
+  info:    (c, m) => write('info',  m, c),
+  debug:   (c, m) => write('debug', m, c),
+  init,
+  initFromEnv,
+  getSessionId: () => _sessionId,
+  getLogDir,
+};
+
+// --- 自动从 env 初始化 ---
+initFromEnv();
+
+module.exports = log;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@hileeon/mcc",
+  "version": "0.1.0",
+  "description": "My Cloud Code - Multi-provider account and model switching for Claude Code",
+  "license": "MIT",
+  "author": "Zhang Chicheng",
+  "repository": "https://github.com/leeon917/mcc",
+  "main": "dist/mcc.js",
+  "types": "dist/mcc.d.ts",
+  "bin": {
+    "mcc": "dist/mcc.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "dev": "node dist/mcc.js",
+    "build:ui": "cd ui && npm install && npm run build",
+    "dashboard": "npm run build && npm run build:ui && node dist/dashboard-server.js"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/accounts/instance-manager.ts

@@ -0,0 +1,58 @@
+/**
+ * Instance Manager - Account isolation via CLAUDE_CONFIG_DIR
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { SharedManager } from './shared-manager';
+
+function getMccHome(): string {
+  return process.env.MCC_HOME ?? path.join(process.env.HOME ?? process.env.USERPROFILE ?? '~', '.mcc');
+}
+
+function getInstancesDir(): string {
+  return path.join(getMccHome(), 'instances');
+}
+
+const sharedManager = new SharedManager();
+
+export class MCCInstanceManager {
+  async ensureInstance(accountName: string): Promise<string> {
+    const instancePath = this.getInstancePath(accountName);
+    if (!fs.existsSync(instancePath)) {
+      fs.mkdirSync(instancePath, { recursive: true, mode: 0o700 });
+      const subdirs = ['session-env', 'todos', 'logs', 'file-history', 'shell-snapshots', 'debug', '.anthropic'];
+      for (const dir of subdirs) {
+        fs.mkdirSync(path.join(instancePath, dir), { recursive: true, mode: 0o700 });
+      }
+    }
+    // Always re-link shared directories (skills, commands, agents, plugins, settings)
+    sharedManager.linkSharedDirectories(instancePath);
+    return instancePath;
+  }
+
+  getInstancePath(accountName: string): string {
+    const safeName = accountName.replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
+    return path.join(getInstancesDir(), safeName);
+  }
+
+  async deleteInstance(accountName: string): Promise<void> {
+    const instancePath = this.getInstancePath(accountName);
+    if (fs.existsSync(instancePath)) {
+      fs.rmSync(instancePath, { recursive: true, force: true });
+    }
+  }
+
+  listInstances(): string[] {
+    const instancesDir = getInstancesDir();
+    if (!fs.existsSync(instancesDir)) return [];
+    return fs.readdirSync(instancesDir).filter((name) => {
+      if (name.startsWith('.')) return false;
+      return fs.statSync(path.join(instancesDir, name)).isDirectory();
+    });
+  }
+
+  hasInstance(accountName: string): boolean {
+    return fs.existsSync(this.getInstancePath(accountName));
+  }
+}

package/src/accounts/shared-manager.ts

@@ -0,0 +1,154 @@
+/**
+ * SharedManager - Symlink management for shared directories
+ * Ported from CCS management/shared-manager.js (simplified)
+ *
+ * Creates symlinks: ~/.mcc/instances/<name>/<item> -> ~/.claude/<item>
+ * so that skills, commands, agents, plugins, and settings are shared across instances.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import pc from 'picocolors';
+
+function getHome(): string {
+  return process.env.HOME ?? process.env.USERPROFILE ?? '~';
+}
+
+interface SharedItem {
+  name: string;
+  type: 'directory' | 'file';
+}
+
+const SHARED_ITEMS: readonly SharedItem[] = [
+  { name: 'commands', type: 'directory' },
+  { name: 'skills', type: 'directory' },
+  { name: 'agents', type: 'directory' },
+  { name: 'plugins', type: 'directory' },
+  { name: 'settings.json', type: 'file' },
+];
+
+export class SharedManager {
+  private claudeDir: string;
+
+  constructor() {
+    this.claudeDir = path.join(getHome(), '.claude');
+  }
+
+  /**
+   * Link shared directories to an instance.
+   * Creates symlinks from instance/<item> -> ~/.claude/<item>
+   */
+  linkSharedDirectories(instancePath: string): void {
+    const linked: string[] = [];
+    for (const item of SHARED_ITEMS) {
+      const claudePath = path.join(this.claudeDir, item.name);
+      const linkPath = path.join(instancePath, item.name);
+
+      // Ensure source exists in ~/.claude/
+      if (!this.pathExists(claudePath)) {
+        if (item.type === 'directory') {
+          fs.mkdirSync(claudePath, { recursive: true, mode: 0o700 });
+        } else {
+          fs.writeFileSync(claudePath, '{}', 'utf8');
+        }
+      }
+
+      // Skip if already a symlink pointing to the correct target
+      if (this.isCorrectSymlink(linkPath, claudePath)) {
+        continue;
+      }
+
+      // Remove existing path (file, dir, or stale symlink)
+      this.removeExisting(linkPath, item.type);
+
+      // Create symlink
+      try {
+        const symlinkType = item.type === 'directory' ? 'dir' : 'file';
+        fs.symlinkSync(claudePath, linkPath, symlinkType);
+        linked.push(item.name);
+      } catch (_err) {
+        // Windows fallback: copy if symlink fails (Developer Mode not enabled)
+        if (process.platform === 'win32') {
+          if (item.type === 'directory') {
+            this.copyDirectoryFallback(claudePath, linkPath);
+          } else {
+            fs.copyFileSync(claudePath, linkPath);
+          }
+          console.warn(`[!] Symlink failed for ${item.name}, copied instead (enable Developer Mode for symlinks)`);
+          linked.push(`${item.name} (copied)`);
+        } else {
+          throw _err;
+        }
+      }
+    }
+    if (linked.length > 0) {
+      console.log(`  ${pc.dim('shared')}   ${pc.dim(linked.join(', '))}`);
+    }
+  }
+
+  /**
+   * Remove symlinks from an instance (cleanup).
+   */
+  unlinkSharedDirectories(instancePath: string): void {
+    for (const item of SHARED_ITEMS) {
+      const linkPath = path.join(instancePath, item.name);
+      if (!this.pathExists(linkPath)) continue;
+
+      try {
+        const stats = fs.lstatSync(linkPath);
+        if (stats.isSymbolicLink()) {
+          fs.unlinkSync(linkPath);
+        }
+      } catch {
+        // Best-effort
+      }
+    }
+  }
+
+  private pathExists(p: string): boolean {
+    try {
+      fs.lstatSync(p);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private isCorrectSymlink(linkPath: string, expectedTarget: string): boolean {
+    try {
+      const stats = fs.lstatSync(linkPath);
+      if (!stats.isSymbolicLink()) return false;
+      const currentTarget = fs.readlinkSync(linkPath);
+      const resolved = path.resolve(path.dirname(linkPath), currentTarget);
+      return resolved === expectedTarget;
+    } catch {
+      return false;
+    }
+  }
+
+  private removeExisting(p: string, type: 'directory' | 'file'): void {
+    if (!this.pathExists(p)) return;
+    if (type === 'directory') {
+      fs.rmSync(p, { recursive: true, force: true });
+    } else {
+      try {
+        fs.unlinkSync(p);
+      } catch {
+        fs.rmSync(p, { force: true });
+      }
+    }
+  }
+
+  private copyDirectoryFallback(src: string, dest: string): void {
+    fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        this.copyDirectoryFallback(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}

package/src/accounts/store.ts

@@ -0,0 +1,111 @@
+/**
+ * Profile Store - File-based profile management
+ *
+ * Storage structure:
+ *   ~/.mcc/
+ *   ├── profiles.json          # Profile metadata + tiered model config
+ *   └── profiles/
+ *       └── <profile-name>/
+ *           └── .key          # API key (plain text)
+ */
+
+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');
+}
+
+function getProfilesDir(): string {
+  return path.join(getMccHome(), 'profiles');
+}
+
+function getProfilesJsonPath(): string {
+  return path.join(getMccHome(), 'profiles.json');
+}
+
+export interface Profile {
+  name: string;
+  baseUrl: string;
+  model: string;           // Default model
+  opusModel?: string;       // Tier 1 (Opus)
+  sonnetModel?: string;     // Tier 2 (Sonnet)
+  haikuModel?: string;      // Tier 3 (Haiku / small-fast)
+  protocol?: 'anthropic' | 'openai';  // 'anthropic' = direct, 'openai' = needs translation proxy
+  createdAt: string;
+  lastUsedAt?: string;
+}
+
+interface ProfilesJson {
+  version: number;
+  profiles: Record<string, Profile>;
+  defaultProfile?: string;
+}
+
+function readProfilesJson(): ProfilesJson {
+  const jsonPath = getProfilesJsonPath();
+  if (!fs.existsSync(jsonPath)) {
+    return { version: 1, profiles: {} };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+  } catch {
+    return { version: 1, profiles: {} };
+  }
+}
+
+function writeProfilesJson(data: ProfilesJson): void {
+  const jsonPath = getProfilesJsonPath();
+  fs.mkdirSync(path.dirname(jsonPath), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 });
+}
+
+export function listProfiles(): Profile[] {
+  return Object.values(readProfilesJson().profiles);
+}
+
+export function getProfile(name: string): Profile | undefined {
+  return readProfilesJson().profiles[name];
+}
+
+export function getDefaultProfile(): string | undefined {
+  return readProfilesJson().defaultProfile;
+}
+
+export function saveProfile(profile: Profile, apiKey: string): void {
+  const data = readProfilesJson();
+  const profileDir = path.join(getProfilesDir(), profile.name);
+  fs.mkdirSync(profileDir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(path.join(profileDir, '.key'), apiKey, { encoding: 'utf8', mode: 0o600 });
+  data.profiles[profile.name] = { ...profile, lastUsedAt: new Date().toISOString() };
+  writeProfilesJson(data);
+}
+
+export function getProfileApiKey(name: string): string | undefined {
+  const keyPath = path.join(getProfilesDir(), name, '.key');
+  if (!fs.existsSync(keyPath)) return undefined;
+  return fs.readFileSync(keyPath, 'utf8').trim();
+}
+
+export function deleteProfile(name: string): void {
+  const data = readProfilesJson();
+  if (!data.profiles[name]) return;
+  delete data.profiles[name];
+  if (data.defaultProfile === name) {
+    data.defaultProfile = Object.keys(data.profiles)[0];
+  }
+  writeProfilesJson(data);
+  const profileDir = path.join(getProfilesDir(), name);
+  if (fs.existsSync(profileDir)) fs.rmSync(profileDir, { recursive: true, force: true });
+}
+
+export function setDefaultProfile(name: string): void {
+  const data = readProfilesJson();
+  if (!data.profiles[name]) throw new Error(`Profile not found: ${name}`);
+  data.defaultProfile = name;
+  writeProfilesJson(data);
+}
+
+export function hasProfile(name: string): boolean {
+  return name in readProfilesJson().profiles;
+}

package/src/core/model-router.ts

@@ -0,0 +1,82 @@
+/**
+ * Model Router - Builds Claude Code env vars from a Profile
+ *
+ * Mirrors CCS's tiered model mapping:
+ *   ANTHROPIC_MODEL                  = Default model
+ *   ANTHROPIC_DEFAULT_OPUS_MODEL    = Opus tier
+ *   ANTHROPIC_DEFAULT_SONNET_MODEL  = Sonnet tier
+ *   ANTHROPIC_DEFAULT_HAIKU_MODEL   = Haiku tier
+ *   ANTHROPIC_SMALL_FAST_MODEL      = Alias for Haiku tier
+ */
+
+import type { Profile } from '../accounts/store';
+import { readMcpConfig, getActiveImageAnalysisProvider, getEnabledWebSearchProviders } from '../mcp/mcp-config';
+
+export interface ProfileEnv {
+  ANTHROPIC_BASE_URL: string;
+  ANTHROPIC_AUTH_TOKEN: string;
+  ANTHROPIC_MODEL: string;
+  ANTHROPIC_DEFAULT_OPUS_MODEL: string;
+  ANTHROPIC_DEFAULT_SONNET_MODEL: string;
+  ANTHROPIC_DEFAULT_HAIKU_MODEL: string;
+  ANTHROPIC_SMALL_FAST_MODEL: string;
+  DISABLE_TELEMETRY: '1';
+  DISABLE_COST_WARNINGS: '1';
+  CLAUDE_CONFIG_DIR: string;
+  [key: string]: string; // Allow MCP env vars
+}
+
+/**
+ * Build env vars for launching Claude Code with a profile.
+ * Falls back to profile.model for any missing tier.
+ */
+export function buildProfileEnv(profile: Profile, apiKey: string, claudeConfigDir: string): ProfileEnv {
+  const model = profile.model;
+
+  // Read MCP config for provider settings
+  const mcpConfig = readMcpConfig();
+  const wsProviders = getEnabledWebSearchProviders(mcpConfig);
+  const iaProvider = getActiveImageAnalysisProvider(mcpConfig);
+
+  const env: Record<string, string> = {
+    ANTHROPIC_BASE_URL: profile.baseUrl,
+    ANTHROPIC_AUTH_TOKEN: apiKey,
+    ANTHROPIC_MODEL: model,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: profile.opusModel ?? model,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: profile.sonnetModel ?? model,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: profile.haikuModel ?? model,
+    ANTHROPIC_SMALL_FAST_MODEL: profile.haikuModel ?? model,
+    DISABLE_TELEMETRY: '1',
+    DISABLE_COST_WARNINGS: '1',
+    CLAUDE_CONFIG_DIR: claudeConfigDir,
+  };
+
+  // MCP: WebSearch
+  env.MCC_WEBSEARCH_ENABLED = mcpConfig.websearch.enabled ? '1' : '0';
+  for (const p of wsProviders) {
+    env[`MCC_WEBSEARCH_${p.toUpperCase()}`] = '1';
+    // Set API key env vars for providers that need them
+    const providerConfig = mcpConfig.websearch.providers[p];
+    if (providerConfig?.apiKey) {
+      const keyEnvMap: Record<string, string> = {
+        exa: 'MCC_WEBSEARCH_EXA_API_KEY',
+        tavily: 'MCC_WEBSEARCH_TAVILY_API_KEY',
+        brave: 'MCC_WEBSEARCH_BRAVE_API_KEY',
+      };
+      if (keyEnvMap[p]) {
+        env[keyEnvMap[p]] = providerConfig.apiKey;
+      }
+    }
+  }
+
+  // MCP: Image Analysis
+  if (mcpConfig.imageAnalysis.enabled && iaProvider) {
+    env.MCC_IMAGE_ANALYSIS_ENABLED = '1';
+    env.MCC_IMAGE_ANALYSIS_RUNTIME_BASE_URL = iaProvider.baseUrl;
+    env.MCC_IMAGE_ANALYSIS_RUNTIME_API_KEY = iaProvider.apiKey;
+    env.MCC_IMAGE_ANALYSIS_MODEL = iaProvider.model;
+    env.MCC_IMAGE_ANALYSIS_FORMAT = iaProvider.format;
+  }
+
+  return env as unknown as ProfileEnv;
+}