@sifwenf/cc-proxy 0.1.0

package/src/config.ts

@@ -0,0 +1,86 @@
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import type { Config } from './types.js';
+
+let configCache: Config | null = null;
+let configPath: string | null = null;
+
+// Get user home directory
+function getUserHome(): string {
+  return process.env.HOME || process.env.USERPROFILE || '';
+}
+
+// Get the proxy data directory in user home
+function getDataDir(): string {
+  return join(getUserHome(), '.claude-code-proxy');
+}
+
+// Ensure all necessary directories exist
+function ensureDirectories(): void {
+  const dataDir = getDataDir();
+  const logsDir = join(dataDir, 'logs');
+
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+
+  if (!existsSync(logsDir)) {
+    mkdirSync(logsDir, { recursive: true });
+  }
+}
+
+// Get default config path
+export function getDefaultConfigPath(): string {
+  return join(getDataDir(), 'config.json');
+}
+
+export function loadConfig(customConfigPath?: string): Config {
+  if (configCache && configPath === (customConfigPath || null)) {
+    return configCache;
+  }
+
+  const path = customConfigPath || getDefaultConfigPath();
+  configPath = path;
+
+  ensureDirectories();
+
+  try {
+    const content = readFileSync(path, 'utf-8');
+    configCache = JSON.parse(content);
+    return configCache;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(
+        `Config file not found: ${path}\n` +
+        `Please create a config.json file. See config.example.json for reference.`
+      );
+    }
+    throw error;
+  }
+}
+
+export function reloadConfig(customConfigPath?: string): Config {
+  const path = customConfigPath || getDefaultConfigPath();
+
+  try {
+    const content = readFileSync(path, 'utf-8');
+    configCache = JSON.parse(content);
+    return configCache;
+  } catch (error) {
+    console.error('Failed to reload config:', error);
+    return configCache || {} as Config;
+  }
+}
+
+export function getConfig(): Config | null {
+  return configCache;
+}
+
+export function getConfigDir(): string {
+  return getDataDir();
+}
+
+export function getLogsDir(): string {
+  return join(getDataDir(), 'logs');
+}

package/src/format-converter.ts

@@ -0,0 +1,168 @@
+/**
+ * Format converter for OpenRouter (OpenAI format) <-> Anthropic format
+ */
+
+// OpenAI-compatible format (used by OpenRouter)
+export interface OpenAIMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface OpenAIRequest {
+  model: string;
+  messages: OpenAIMessage[];
+  max_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  stream?: boolean;
+}
+
+export interface OpenAIResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: string;
+      content: string;
+    };
+    finish_reason: string;
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+// Anthropic format
+export interface AnthropicContentBlock {
+  type: 'text' | 'image';
+  text?: string;
+  source?: any;
+}
+
+export interface AnthropicMessage {
+  role: 'user' | 'assistant';
+  content: string | AnthropicContentBlock[];
+}
+
+export interface AnthropicRequest {
+  model: string;
+  messages: AnthropicMessage[];
+  max_tokens: number;
+  temperature?: number;
+  top_p?: number;
+  stream?: boolean;
+  system?: string;
+  tools?: any;
+  tool_choice?: any;
+}
+
+export interface AnthropicResponse {
+  id: string;
+  type: string;
+  role: string;
+  content: Array<{ type: string; text: string }>;
+  model: string;
+  stop_reason: string;
+  usage: {
+    input_tokens: number;
+    output_tokens: number;
+  };
+}
+
+/**
+ * Detect if provider uses OpenAI format (deprecated - use provider.format instead)
+ */
+export function isOpenAIFormat(baseUrl: string): boolean {
+  return baseUrl.includes('/chat/completions') || baseUrl.includes('openrouter');
+}
+
+/**
+ * Convert Anthropic format request to OpenAI format
+ */
+export function convertAnthropicToOpenAI(anthropic: AnthropicRequest): OpenAIRequest {
+  const messages: OpenAIMessage[] = [];
+
+  // Add system message first if present
+  if (anthropic.system) {
+    messages.push({
+      role: 'system',
+      content: anthropic.system,
+    });
+  }
+
+  // Convert messages
+  for (const msg of anthropic.messages) {
+    let content = '';
+
+    // Handle content as string or array of blocks
+    if (typeof msg.content === 'string') {
+      content = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      // Concatenate text blocks
+      content = msg.content
+        .map(block => block.type === 'text' ? (block.text || '') : '')
+        .filter(Boolean)
+        .join('\n');
+    }
+
+    messages.push({
+      role: msg.role === 'user' ? 'user' : 'assistant',
+      content,
+    });
+  }
+
+  return {
+    model: anthropic.model,
+    messages,
+    max_tokens: anthropic.max_tokens,
+    temperature: anthropic.temperature,
+    top_p: anthropic.top_p,
+    stream: anthropic.stream,
+  };
+}
+
+/**
+ * Convert OpenAI format response to Anthropic format
+ */
+export function convertOpenAIToAnthropic(openai: OpenAIResponse, originalModel: string): AnthropicResponse {
+  const choice = openai.choices[0];
+  if (!choice) {
+    throw new Error('No choices in OpenAI response');
+  }
+
+  return {
+    id: `msg_${openai.id}`,
+    type: 'message',
+    role: 'assistant',
+    content: [
+      {
+        type: 'text',
+        text: choice.message.content,
+      },
+    ],
+    model: originalModel,
+    stop_reason: choice.finish_reason === 'stop' ? 'end_turn' : choice.finish_reason,
+    usage: {
+      input_tokens: openai.usage.prompt_tokens,
+      output_tokens: openai.usage.completion_tokens,
+    },
+  };
+}
+
+/**
+ * Extract content from Anthropic message for OpenAI format
+ */
+function extractContent(content: string | Array<{ type: string; text?: string; source?: any }>): string {
+  if (typeof content === 'string') {
+    return content;
+  }
+  return content
+    .map(block => block.type === 'text' ? (block.text || '') : '')
+    .filter(Boolean)
+    .join('\n');
+}

package/src/logger.ts

@@ -0,0 +1,213 @@
+import { mkdirSync, appendFileSync, existsSync } from 'fs';
+import { appendFile } from 'fs/promises';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import type { LogEntry, LoggingConfig } from './types.js';
+import { getLogsDir } from './config.js';
+
+export class Logger {
+  private config: LoggingConfig;
+  private requestId: string | null = null;
+  private requestStartTime: number = 0;
+  private logFile: string;
+  private logBuffer: string[] = [];
+  private flushTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(config: LoggingConfig) {
+    this.config = config;
+    const logsDir = getLogsDir();
+    this.logFile = join(logsDir, 'requests.jsonl');
+
+    if (config.enabled) {
+      this.ensureLogDir();
+      this.setupBufferFlush();
+    }
+  }
+
+  private ensureLogDir(): void {
+    const logsDir = getLogsDir();
+    if (!existsSync(logsDir)) {
+      mkdirSync(logsDir, { recursive: true });
+    }
+  }
+
+  private setupBufferFlush(): void {
+    // Flush buffer every 100ms to batch writes
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, 100);
+  }
+
+  private flush(): void {
+    if (this.logBuffer.length === 0) return;
+
+    const lines = this.logBuffer.splice(0);
+    const logData = lines.join('');
+
+    // Use async write in Bun for better performance
+    if (typeof Bun !== 'undefined') {
+      appendFile(this.logFile, logData).catch(() => {});
+    } else {
+      // Fallback to sync for Node.js
+      appendFileSync(this.logFile, logData, 'utf-8');
+    }
+  }
+
+  private writeLog(entry: LogEntry): void {
+    if (!this.config.enabled) return;
+
+    const logLine = JSON.stringify(entry) + '\n';
+    this.logBuffer.push(logLine);
+
+    // Flush immediately if buffer gets too large (prevent memory bloat)
+    if (this.logBuffer.length >= 50) {
+      this.flush();
+    }
+  }
+
+  startRequest(method: string, path: string, headers: Record<string, string>, body?: any): string {
+    this.requestId = randomUUID();
+    this.requestStartTime = Date.now();
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      id: this.requestId,
+      type: 'request',
+      method,
+      path,
+      headers: this.config.level === 'verbose' ? headers : this.sanitizeHeaders(headers),
+      body: this.config.level === 'verbose' ? body : undefined,
+    };
+
+    this.writeLog(entry);
+    return this.requestId;
+  }
+
+  logForward(
+    providerName: string,
+    modelName: string,
+    requestFormat: string,
+    actualRequest: any,
+    actualResponse?: any
+  ): void {
+    if (!this.requestId || !this.config.enabled) return;
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      id: this.requestId,
+      type: 'forward',
+      method: 'POST',
+      path: '/v1/messages',
+      provider: providerName,
+      mappedModel: modelName,
+      requestFormat,
+      actualRequest: this.config.level === 'verbose' ? actualRequest : undefined,
+      actualResponse: this.config.level === 'verbose' ? actualResponse : undefined,
+    };
+
+    this.writeLog(entry);
+  }
+
+  logResponse(
+    statusCode: number,
+    headers: Record<string, string>,
+    body?: any,
+    provider?: string,
+    mappedModel?: string,
+    originalModel?: string
+  ): void {
+    if (!this.requestId) return;
+
+    const duration = Date.now() - this.requestStartTime;
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      id: this.requestId,
+      type: 'response',
+      method: 'POST',
+      path: '/v1/messages',
+      statusCode,
+      headers: this.config.level === 'verbose' ? headers : this.sanitizeHeaders(headers),
+      body: this.config.level === 'verbose' ? body : undefined,
+      provider,
+      mappedModel,
+      originalModel,
+      duration,
+    };
+
+    this.writeLog(entry);
+    this.requestId = null;
+  }
+
+  logStreamChunk(
+    chunkIndex: number,
+    chunkType: string,
+    data: any,
+    provider?: string
+  ): void {
+    if (!this.requestId) return;
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      id: this.requestId,
+      type: 'stream_chunk',
+      method: 'POST',
+      path: '/v1/messages',
+      chunkIndex,
+      headers: { 'x-chunk-type': chunkType },
+      body: this.config.level === 'verbose' ? data : undefined,
+      provider,
+    };
+
+    this.writeLog(entry);
+  }
+
+  logError(error: string, details?: any): void {
+    if (!this.requestId) return;
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      id: this.requestId,
+      type: 'error',
+      method: 'POST',
+      path: '/v1/messages',
+      error,
+      body: details,
+    };
+
+    this.writeLog(entry);
+    this.requestId = null;
+  }
+
+  private sanitizeHeaders(headers: Record<string, string>): Record<string, string> {
+    const sanitized: Record<string, string> = {};
+
+    for (const [key, value] of Object.entries(headers)) {
+      if (key.toLowerCase() === 'authorization') {
+        sanitized[key] = 'Bearer ***REDACTED***';
+      } else if (key.toLowerCase() === 'x-api-key') {
+        sanitized[key] = '***REDACTED***';
+      } else {
+        sanitized[key] = value;
+      }
+    }
+
+    return sanitized;
+  }
+
+  // Flush buffer on cleanup
+  destroy(): void {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+  }
+
+  /**
+   * Update logging configuration (for hot reload)
+   */
+  updateConfig(config: LoggingConfig): void {
+    this.config = config;
+  }
+}

package/src/proxy.ts

@@ -0,0 +1,83 @@
+import type { ProviderConfig, RouterConfig } from './types.js';
+
+export interface ProxyContext {
+  provider: ProviderConfig;
+  modelName: string;
+}
+
+export class RequestMapper {
+  private providers: ProviderConfig[];
+  private router: RouterConfig;
+
+  constructor(providers: ProviderConfig[], router: RouterConfig) {
+    this.providers = providers;
+    this.router = router;
+  }
+
+  /**
+   * Parse route string like "zp,glm-4.7" into provider name and model name
+   */
+  private parseRoute(routeStr: string): { providerName: string; modelName: string } | null {
+    const parts = routeStr.split(',');
+    if (parts.length !== 2) {
+      return null;
+    }
+    return {
+      providerName: parts[0].trim(),
+      modelName: parts[1].trim()
+    };
+  }
+
+  /**
+   * Find provider by name
+   */
+  private findProvider(providerName: string): ProviderConfig | null {
+    return this.providers.find(p => p.name === providerName) || null;
+  }
+
+  /**
+   * Map Claude model to provider and model based on router config
+   */
+  resolveProvider(claudeModel: string): ProxyContext {
+    let routeStr: string;
+
+    // Determine which route to use based on model name
+    if (claudeModel.includes('haiku')) {
+      routeStr = this.router.haiku;
+    } else if (claudeModel.includes('opus')) {
+      routeStr = this.router.opus;
+    } else {
+      // Default to sonnet for anything else
+      routeStr = this.router.sonnet;
+    }
+
+    const parsed = this.parseRoute(routeStr);
+    if (!parsed) {
+      throw new Error(`Invalid route configuration: ${routeStr}`);
+    }
+
+    const provider = this.findProvider(parsed.providerName);
+    if (!provider) {
+      throw new Error(`Provider not found: ${parsed.providerName}`);
+    }
+
+    return {
+      provider,
+      modelName: parsed.modelName,
+    };
+  }
+
+  /**
+   * Update providers configuration (for hot reload)
+   */
+  updateProviders(providers: ProviderConfig[]): void {
+    this.providers = providers;
+  }
+
+  /**
+   * Update router configuration (for hot reload)
+   */
+  updateRouter(router: RouterConfig): void {
+    this.router = router;
+  }
+}

package/src/scripts/init.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env bun
+/**
+ * Initialize cc-proxy configuration in user home directory
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface Config {
+  server: {
+    port: number;
+    host: string;
+  };
+  logging: {
+    enabled: boolean;
+    level: 'basic' | 'standard' | 'verbose';
+    dir: string;
+  };
+  providers: Array<{
+    name: string;
+    baseUrl: string;
+    apiKey: string;
+    format?: string;
+  }>;
+  router: {
+    haiku: string;
+    sonnet: string;
+    opus: string;
+    image?: string;
+    webSearch?: string | number;
+  };
+}
+
+function getOldConfigPath(): string {
+  return join(process.cwd(), 'config.json');
+}
+
+function getNewConfigPath(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  return join(home, '.claude-code-proxy', 'config.json');
+}
+
+function getNewLogsDir(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  return join(home, '.claude-code-proxy', 'logs');
+}
+
+function migrateConfig(): void {
+  const oldConfigPath = getOldConfigPath();
+  const newConfigPath = getNewConfigPath();
+
+  // Check if new config already exists - protect existing config
+  if (existsSync(newConfigPath)) {
+    console.log('✅ Config already exists at:', newConfigPath);
+    console.log('   Server is using this config file.\n');
+
+    // Migrate old config if it exists
+    if (existsSync(oldConfigPath)) {
+      console.log('📖 Project config.json found at:', oldConfigPath);
+      console.log('💡 You can delete project config.json - it\'s no longer used');
+      console.log('   Server uses: ~/.claude-code-proxy/config.json\n');
+    }
+    return;
+  }
+
+  // Check if old config exists
+  if (!existsSync(oldConfigPath)) {
+    console.log('❌ No config.json found in current directory');
+    console.log('Creating default config in user directory...');
+    createDefaultConfig(newConfigPath);
+    return;
+  }
+
+  // Read old config
+  console.log(`📖 Reading config from: ${oldConfigPath}`);
+  const oldConfig: Config = JSON.parse(readFileSync(oldConfigPath, 'utf-8'));
+
+  // Ensure new directory exists
+  const newDir = dirname(newConfigPath);
+  if (!existsSync(newDir)) {
+    mkdirSync(newDir, { recursive: true });
+  }
+
+  // Ensure logs directory exists
+  const newLogsDir = getNewLogsDir();
+  if (!existsSync(newLogsDir)) {
+    mkdirSync(newLogsDir, { recursive: true });
+  }
+
+  // Write new config
+  writeFileSync(newConfigPath, JSON.stringify(oldConfig, null, 2), 'utf-8');
+  console.log(`✅ Config migrated to: ${newConfigPath}`);
+
+  // Ask if user wants to delete old config
+  console.log('\n⚠️  Old config.json still exists in project directory');
+  console.log('You can now delete the project config.json and use the one in ~/.claude-code-proxy');
+}
+
+function createDefaultConfig(configPath: string): void {
+  const defaultConfig: Config = {
+    server: {
+      port: 3457,
+      host: '127.0.0.1'
+    },
+    logging: {
+      enabled: true,
+      level: 'verbose',
+      dir: join(process.env.HOME || process.env.USERPROFILE || '', '.claude-code-proxy', 'logs')
+    },
+    providers: [
+      {
+        name: 'openrouter',
+        baseUrl: 'https://openrouter.ai/api/v1/chat/completions',
+        apiKey: ''
+      },
+      {
+        name: 'zp',
+        baseUrl: 'https://api.z.ai/api/anthropic/v1/messages',
+        apiKey: ''
+      },
+      {
+        name: 'yescode',
+        baseUrl: 'https://co.yes.vg/v1/messages',
+        apiKey: ''
+      }
+    ],
+    router: {
+      haiku: 'zp,glm-4.7',
+      sonnet: 'zp,glm-4.7',
+      opus: 'zp,glm-4.7',
+      image: 'zp,glm-4.7',
+      webSearch: 200000
+    }
+  };
+
+  writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2), 'utf-8');
+  console.log(`✅ Default config created at: ${configPath}`);
+}
+
+function main() {
+  console.log('🚀 Initializing cc-proxy...\n');
+
+  try {
+    migrateConfig();
+
+    console.log('\n✅ Initialization complete!');
+    console.log('\n📝 Next steps:');
+    console.log('1. Review your config at: ~/.claude-code-proxy/config.json');
+    console.log('2. Add your API keys to provider configurations');
+    console.log('3. Start the server: npm start');
+    console.log('\n💡 Config hot reload is enabled - changes will be applied automatically!');
+  } catch (error) {
+    console.error('❌ Initialization failed:', error);
+    process.exit(1);
+  }
+}
+
+main();