@hileeon/mcc 0.1.3 → 0.1.5

package/src/proxy/proxy-entry.ts

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-/**
- * Proxy Daemon Entrypoint
- *
- * This file is spawned as a detached child process by proxy-daemon.ts.
- * It parses CLI args and starts the proxy server.
- *
- * Ported from CCS proxy/proxy-daemon-entry.js (simplified for single-profile MCC).
- */
-
-import { startProxyServer, type ProxyServerOptions } from './proxy-server';
-
-function parseArgs(argv: string[]): ProxyServerOptions {
-  let port = 43456;
-  let host = '127.0.0.1';
-  let baseUrl = '';
-  let apiKey = '';
-  let model = '';
-  let authToken = '';
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === '--port' && argv[i + 1]) { port = Number.parseInt(argv[++i] || '', 10) || port; continue; }
-    if (arg === '--host' && argv[i + 1]) { host = argv[++i] || host; continue; }
-    if (arg === '--base-url' && argv[i + 1]) { baseUrl = argv[++i] || ''; continue; }
-    if (arg === '--api-key' && argv[i + 1]) { apiKey = argv[++i] || ''; continue; }
-    if (arg === '--model' && argv[i + 1]) { model = argv[++i] || ''; continue; }
-    if (arg === '--auth-token' && argv[i + 1]) { authToken = argv[++i] || ''; continue; }
-  }
-
-  if (!authToken.trim()) {
-    throw new Error('Missing local proxy auth token');
-  }
-  if (!baseUrl.trim()) {
-    throw new Error('Missing upstream base URL');
-  }
-  if (!apiKey.trim()) {
-    throw new Error('Missing upstream API key');
-  }
-
-  return { port, host, baseUrl, apiKey, model: model || undefined, authToken };
-}
-
-function main(): void {
-  const options = parseArgs(process.argv.slice(2));
-  const server = startProxyServer(options);
-
-  server.once('error', (error) => {
-    console.error(`[MCC Proxy] Server error: ${error.message}`);
-    process.exit(1);
-  });
-
-  console.log(`[MCC Proxy] Listening on http://${options.host}:${options.port}`);
-
-  const shutdown = () => {
-    console.log('[MCC Proxy] Shutting down...');
-    server.close();
-  };
-  process.on('SIGTERM', shutdown);
-  process.on('SIGINT', shutdown);
-}
-
-main();

package/src/proxy/proxy-paths.ts

@@ -1,97 +0,0 @@
-/**
- * Proxy path constants and session/PID file management
- * Ported from CCS proxy-daemon-paths.js + proxy-daemon-state.js
- */
-
-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 const PROXY_PORT_START = 43456;
-export const PROXY_PORT_END = 43555;
-export const PROXY_SERVICE_NAME = 'mcc-openai-compat-proxy';
-
-export function getProxyDir(): string {
-  return path.join(getMccHome(), 'proxy');
-}
-
-export function getProxyPidPath(profileName: string): string {
-  return path.join(getProxyDir(), `${encodeURIComponent(profileName)}.daemon.pid`);
-}
-
-export function getProxySessionPath(profileName: string): string {
-  return path.join(getProxyDir(), `${encodeURIComponent(profileName)}.session.json`);
-}
-
-export interface ProxySession {
-  profileName: string;
-  port: number;
-  host: string;
-  authToken: string;
-  baseUrl: string;
-  startedAt: string;
-}
-
-function ensureProxyDir(): void {
-  fs.mkdirSync(getProxyDir(), { recursive: true, mode: 0o700 });
-}
-
-export function readProxyPid(profileName: string): number | null {
-  try {
-    const raw = fs.readFileSync(getProxyPidPath(profileName), 'utf8').trim();
-    const pid = Number.parseInt(raw, 10);
-    return Number.isInteger(pid) ? pid : null;
-  } catch {
-    return null;
-  }
-}
-
-export function writeProxyPid(profileName: string, pid: number): void {
-  ensureProxyDir();
-  fs.writeFileSync(getProxyPidPath(profileName), String(pid), 'utf8');
-}
-
-export function removeProxyPid(profileName: string): void {
-  try {
-    fs.unlinkSync(getProxyPidPath(profileName));
-  } catch {
-    // Best-effort cleanup
-  }
-}
-
-export function readProxySession(profileName: string): ProxySession | null {
-  try {
-    return JSON.parse(fs.readFileSync(getProxySessionPath(profileName), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-export function writeProxySession(session: ProxySession): void {
-  ensureProxyDir();
-  fs.writeFileSync(getProxySessionPath(session.profileName), JSON.stringify(session, null, 2) + '\n', 'utf8');
-}
-
-export function removeProxySession(profileName: string): void {
-  try {
-    fs.unlinkSync(getProxySessionPath(profileName));
-  } catch {
-    // Best-effort cleanup
-  }
-}
-
-export function hashProfileName(profileName: string): number {
-  let hash = 0;
-  for (const char of profileName.trim()) {
-    hash = (hash * 31 + char.charCodeAt(0)) >>> 0;
-  }
-  return hash;
-}
-
-export function resolveAdaptivePort(profileName: string): number {
-  const rangeSize = PROXY_PORT_END - PROXY_PORT_START + 1;
-  return PROXY_PORT_START + (hashProfileName(profileName) % rangeSize);
-}

package/src/proxy/proxy-server.ts

@@ -1,278 +0,0 @@
-/**
- * Proxy Server - Simplified translation proxy for MCC
- *
- * Accepts Anthropic /v1/messages requests, translates to OpenAI chat/completions,
- * forwards to upstream provider, translates response back.
- *
- * Ported from CCS proxy/server/proxy-server.js + messages-route.js + http-helpers.js
- * Simplified: single-profile, no multi-profile routing, no CCS logging, native fetch.
- */
-
-import * as http from 'http';
-import * as stream from 'stream';
-import { createRequire } from 'module';
-import * as path from 'path';
-import { resolveOpenAIChatCompletionsUrl } from './upstream-url';
-import { PROXY_SERVICE_NAME } from './proxy-paths';
-
-// Load compiled JS modules from CCS (copied to lib/proxy/)
-const libProxyDir = path.resolve(__dirname, '..', '..', 'lib', 'proxy');
-const requireFromLib = createRequire(path.join(libProxyDir, 'noop.js'));
-const { ProxyRequestTransformer } = requireFromLib('./transformers/request-transformer');
-const { ProxySseStreamTransformer } = requireFromLib('./transformers/sse-stream-transformer');
-
-const REQUEST_TIMEOUT_MS = 600_000; // 10 minutes
-
-export interface ProxyServerOptions {
-  host: string;
-  port: number;
-  authToken: string;
-  baseUrl: string;
-  apiKey: string;
-  model?: string;
-}
-
-// --- HTTP Helpers (from CCS http-helpers.js) ---
-
-function writeJson(res: http.ServerResponse, statusCode: number, payload: unknown): void {
-  res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-  res.end(JSON.stringify(payload));
-}
-
-const MAX_BODY_SIZE = 10 * 1024 * 1024;
-
-function readJsonBody(req: http.IncomingMessage): Promise<Record<string, unknown>> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    let total = 0;
-    let settled = false;
-
-    const resolveOnce = (payload: Record<string, unknown>) => {
-      if (!settled) { settled = true; resolve(payload); }
-    };
-    const rejectOnce = (error: Error) => {
-      if (!settled) { settled = true; reject(error); }
-    };
-
-    req.on('data', (chunk: Buffer) => {
-      total += chunk.length;
-      if (total > MAX_BODY_SIZE) {
-        req.pause();
-        rejectOnce(new Error('Request body too large (max 10MB)'));
-        return;
-      }
-      chunks.push(chunk);
-    });
-
-    req.on('end', () => {
-      const raw = Buffer.concat(chunks).toString('utf8').trim();
-      if (!raw) { resolveOnce({}); return; }
-      try { resolveOnce(JSON.parse(raw)); }
-      catch { rejectOnce(new Error('Invalid JSON in request body')); }
-    });
-
-    req.on('error', (error: Error) => { rejectOnce(error); });
-  });
-}
-
-async function pipeWebResponseToNode(response: Response, res: http.ServerResponse): Promise<void> {
-  res.statusCode = response.status;
-  response.headers.forEach((value, key) => { res.setHeader(key, value); });
-  if (!response.body) { res.end(); return; }
-  const nodeStream = stream.Readable.fromWeb(response.body as any);
-  await new Promise<void>((resolve, reject) => {
-    nodeStream.on('error', reject);
-    nodeStream.on('end', resolve);
-    nodeStream.pipe(res);
-  });
-}
-
-// --- Auth ---
-
-function extractIncomingToken(headers: http.IncomingHttpHeaders): string | null {
-  const xApiKey = headers['x-api-key'];
-  if (typeof xApiKey === 'string' && xApiKey.trim().length > 0) return xApiKey.trim();
-
-  const anthropicApiKey = headers['anthropic-api-key'];
-  if (typeof anthropicApiKey === 'string' && anthropicApiKey.trim().length > 0) return anthropicApiKey.trim();
-
-  const authHeader = headers.authorization;
-  if (typeof authHeader === 'string' && authHeader.trim().length > 0) {
-    const trimmed = authHeader.trim();
-    const bearerPrefix = 'Bearer ';
-    return trimmed.startsWith(bearerPrefix) ? trimmed.slice(bearerPrefix.length).trim() : trimmed;
-  }
-  return null;
-}
-
-function validateAuth(headers: http.IncomingHttpHeaders, expectedToken: string): boolean {
-  return extractIncomingToken(headers) === expectedToken;
-}
-
-// --- Request Translation ---
-
-function buildUpstreamRequest(rawBody: Record<string, unknown>, options: ProxyServerOptions): string {
-  const transformer = new ProxyRequestTransformer();
-  const transformed = transformer.transform(rawBody);
-  const body = {
-    ...transformed,
-    model: (transformed as any).model || options.model || 'gpt-4',
-    stream: (transformed as any).stream === true,
-  };
-  return JSON.stringify(body);
-}
-
-// --- Server ---
-
-export function startProxyServer(options: ProxyServerOptions): http.Server {
-  const server = http.createServer(async (req, res) => {
-    const method = req.method || 'GET';
-    const requestUrl = req.url || '/';
-    const parsedUrl = new URL(requestUrl, 'http://127.0.0.1');
-    const pathname = parsedUrl.pathname.length > 1
-      ? parsedUrl.pathname.replace(/\/+$/, '')
-      : parsedUrl.pathname;
-
-    try {
-      await handleRequest(req, res, method, pathname, options);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Unknown error';
-      if (!res.headersSent) {
-        writeJson(res, 500, { type: 'error', error: { type: 'api_error', message } });
-      }
-    }
-  });
-
-  server.listen(options.port, options.host);
-  return server;
-}
-
-async function handleRequest(
-  req: http.IncomingMessage,
-  res: http.ServerResponse,
-  method: string,
-  pathname: string,
-  options: ProxyServerOptions,
-): Promise<void> {
-  // Health check
-  if ((method === 'GET' || method === 'HEAD') && pathname === '/health') {
-    if (method === 'HEAD') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end();
-    } else {
-      writeJson(res, 200, {
-        ok: true,
-        service: PROXY_SERVICE_NAME,
-        host: options.host,
-        port: options.port,
-      });
-    }
-    return;
-  }
-
-  // Root info
-  if ((method === 'GET' || method === 'HEAD') && pathname === '/') {
-    if (method === 'HEAD') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end();
-    } else {
-      writeJson(res, 200, {
-        ok: true,
-        service: PROXY_SERVICE_NAME,
-        bind: { host: options.host, port: options.port },
-        endpoints: ['/health', '/v1/messages', '/v1/models'],
-      });
-    }
-    return;
-  }
-
-  // Models endpoint
-  if (method === 'GET' && pathname === '/v1/models') {
-    if (!validateAuth(req.headers, options.authToken)) {
-      writeJson(res, 401, {
-        type: 'error',
-        error: { type: 'authentication_error', message: 'Missing or invalid local proxy token' },
-      });
-      return;
-    }
-    const models = [options.model].filter(Boolean).map((id) => ({
-      id,
-      object: 'model',
-      created: 0,
-      owned_by: 'mcc-proxy',
-    }));
-    writeJson(res, 200, { object: 'list', data: models });
-    return;
-  }
-
-  // Messages endpoint (main translation)
-  if (method === 'POST' && pathname === '/v1/messages') {
-    await handleMessages(req, res, options);
-    return;
-  }
-
-  writeJson(res, 404, { error: 'Not found' });
-}
-
-async function handleMessages(
-  req: http.IncomingMessage,
-  res: http.ServerResponse,
-  options: ProxyServerOptions,
-): Promise<void> {
-  const transformer = new ProxySseStreamTransformer();
-
-  if (!validateAuth(req.headers, options.authToken)) {
-    await pipeWebResponseToNode(
-      transformer.error(401, 'authentication_error', 'Missing or invalid local proxy token'),
-      res,
-    );
-    return;
-  }
-
-  let timeoutMs = REQUEST_TIMEOUT_MS;
-  try {
-    const rawBody = await readJsonBody(req);
-    const upstreamBody = buildUpstreamRequest(rawBody, options);
-    const upstreamUrl = resolveOpenAIChatCompletionsUrl(options.baseUrl);
-
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-    // Client disconnect detection
-    const abortOnDisconnect = (_source: string) => {
-      if (!controller.signal.aborted && !res.writableEnded) {
-        controller.abort();
-      }
-    };
-    req.on('aborted', () => abortOnDisconnect('req.aborted'));
-    req.socket?.on('close', () => abortOnDisconnect('socket.close'));
-
-    try {
-      const upstreamResponse = await fetch(upstreamUrl, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${options.apiKey}`,
-          'User-Agent': 'MCC-OpenAI-Compat-Proxy/1.0',
-        },
-        body: upstreamBody,
-        signal: controller.signal,
-      });
-
-      const response = await transformer.transform(upstreamResponse);
-      await pipeWebResponseToNode(response, res);
-    } finally {
-      clearTimeout(timeout);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown proxy error';
-    const isAbort = error instanceof Error && error.name === 'AbortError';
-    const status = isAbort ? 502 : message.includes('Request body too large') ? 413 : message.includes('Invalid JSON') ? 400 : 502;
-    const type = status >= 500 ? 'api_error' : 'invalid_request_error';
-    const errorMessage = isAbort
-      ? `The upstream provider did not respond within ${timeoutMs / 1000} seconds`
-      : message;
-
-    await pipeWebResponseToNode(transformer.error(status, type, errorMessage), res);
-  }
-}

package/src/proxy/upstream-url.ts

@@ -1,38 +0,0 @@
-/**
- * Upstream URL resolution
- * Ported from CCS proxy/upstream-url.js
- */
-
-function normalizePathname(pathname: string): string {
-  const trimmed = pathname.replace(/\/+$/, '');
-  return trimmed || '';
-}
-
-function ensureSupportedProtocol(parsed: URL): void {
-  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-    throw new Error(`Unsupported upstream protocol: ${parsed.protocol}`);
-  }
-}
-
-function buildResolvedUrl(baseUrl: string, suffix: string): string {
-  const parsed = new URL(baseUrl);
-  ensureSupportedProtocol(parsed);
-  const pathname = normalizePathname(parsed.pathname);
-  if (pathname.endsWith(suffix)) {
-    return parsed.toString();
-  }
-  if (pathname.endsWith('/v1') || pathname.endsWith('/api')) {
-    parsed.pathname = `${pathname}${suffix.startsWith('/') ? suffix : `/${suffix}`}`;
-    return parsed.toString();
-  }
-  parsed.pathname = pathname ? `${pathname}/v1${suffix}` : `/v1${suffix}`;
-  return parsed.toString();
-}
-
-export function resolveOpenAIChatCompletionsUrl(baseUrl: string): string {
-  return buildResolvedUrl(baseUrl, '/chat/completions');
-}
-
-export function resolveOpenAIModelsUrl(baseUrl: string): string {
-  return buildResolvedUrl(baseUrl, '/models');
-}

package/src/shared/logger.ts

@@ -1,140 +0,0 @@
-/**
- * MCC Logger (TypeScript)
- *
- * lib/shared/logger.cjs 的 TS 版本，编译到 dist/shared/logger.js
- * 逻辑完全一致，只是加了类型。
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-const LEVELS: Record<string, number> = { error: 0, warn: 1, info: 2, debug: 3 };
-
-function env(key: string, fallback: string): string {
-  return process.env[key] ?? fallback;
-}
-
-function levelValue(level: string): number {
-  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(): string {
-  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(): string {
-  return path.join(getLogDir(), 'mcc.log');
-}
-
-function rotate(): void {
-  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(): string {
-  const dir = getLogDir();
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o755 });
-  return dir;
-}
-
-function writeFile(line: string): void {
-  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 as Error).message}\n`);
-  }
-}
-
-function timestamp(): string {
-  const now = new Date();
-  const p = (n: number, 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: string, message: string, component: string): string {
-  const sid = _sessionId ? `[${_sessionId}]` : '';
-  const comp = component ? `[${component}]` : '';
-  return `${timestamp()} ${(level || 'info').toUpperCase().padEnd(5)} ${sid}${comp} ${message}`;
-}
-
-function write(level: string, component: string, message: string): void {
-  if (levelValue(level) > _minLevel) return;
-  const line = format(level, message, component);
-  process.stderr.write(line + '\n');
-  writeFile(line);
-}
-
-export function init(sessionId: string, logDir?: string): string {
-  _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;
-}
-
-export function initFromEnv(): void {
-  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: string, m: string) => write('error', m, c),
-  warn:    (c: string, m: string) => write('warn',  m, c),
-  info:    (c: string, m: string) => write('info',  m, c),
-  debug:   (c: string, m: string) => write('debug', m, c),
-  init,
-  initFromEnv,
-  getSessionId: () => _sessionId,
-  getLogDir,
-};
-export { log };
-
-export function isDebugEnabled(): boolean {
-  return _minLevel >= LEVELS.debug;
-}
-
-export function makeSessionId(): string {
-  const now = new Date();
-  const p = (n: number, 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())}`;
-}