claude-codex-proxy 1.0.0

package/src/routes/claude-config-route.js

@@ -0,0 +1,114 @@
+/**
+ * Claude Config Route
+ * Handles Claude CLI configuration endpoints:
+ *   GET  /claude/config
+ *   POST /claude/config/proxy
+ *   POST /claude/config/direct
+ *   POST /claude/config/set
+ */
+
+import {
+  readClaudeConfig,
+  setProxyMode,
+  setDirectMode,
+  setApiEndpoint,
+  getClaudeConfigPath
+} from '../claude-config.js';
+
+/**
+ * GET /claude/config
+ * Returns the current Claude CLI configuration.
+ */
+export async function handleGetClaudeConfig(req, res) {
+  try {
+    const config = await readClaudeConfig();
+    const configPath = getClaudeConfigPath();
+    res.json({ success: true, configPath, config });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+}
+
+/**
+ * POST /claude/config/proxy
+ * Configures Claude CLI to use this proxy server.
+ */
+export async function handleSetProxyMode(req, res, { port }) {
+  try {
+    const proxyUrl = `http://localhost:${port}`;
+    const models = {
+      opus: 'claude-opus',
+      sonnet: 'claude-sonnet',
+      haiku: 'claude-haiku'
+    };
+    const config = await setProxyMode(proxyUrl, models);
+    res.json({
+      success: true,
+      message: `Claude CLI configured to use proxy at ${proxyUrl}`,
+      config
+    });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+}
+
+/**
+ * POST /claude/config/direct
+ * Configures Claude CLI to use the Anthropic API directly.
+ */
+export async function handleSetDirectMode(req, res) {
+  const { apiKey } = req.body || {};
+  if (!apiKey) {
+    return res.status(400).json({ success: false, error: 'API key required' });
+  }
+  try {
+    const config = await setDirectMode(apiKey);
+    res.json({
+      success: true,
+      message: 'Claude CLI configured to use direct Anthropic API',
+      config
+    });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+}
+
+export async function handleSetClaudeApiEndpoint(req, res) {
+  const { apiUrl, apiKey } = req.body || {};
+
+  if (typeof apiUrl !== 'string' || !apiUrl.trim()) {
+    return res.status(400).json({ success: false, error: 'apiUrl is required' });
+  }
+  if (typeof apiKey !== 'string' || !apiKey.trim()) {
+    return res.status(400).json({ success: false, error: 'apiKey is required' });
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(apiUrl);
+  } catch {
+    return res.status(400).json({ success: false, error: 'apiUrl must be a valid URL' });
+  }
+
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return res.status(400).json({ success: false, error: 'apiUrl must use http or https' });
+  }
+
+  try {
+    const config = await setApiEndpoint({ apiUrl: parsed.toString().replace(/\/$/, ''), apiKey });
+    res.json({
+      success: true,
+      message: 'Claude CLI API endpoint updated',
+      config
+    });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+}
+
+export default {
+  handleGetClaudeConfig,
+  handleSetProxyMode,
+  handleSetDirectMode,
+  handleSetClaudeApiEndpoint
+};

package/src/routes/logs-route.js

@@ -0,0 +1,43 @@
+/**
+ * Logs Route
+ * Handles log retrieval and live streaming:
+ *   GET /api/logs
+ *   GET /api/logs/stream
+ */
+
+import { logger } from '../utils/logger.js';
+
+/**
+ * GET /api/logs
+ * Returns the in-memory log history as JSON.
+ */
+export function handleGetLogs(req, res) {
+  res.json({ status: 'ok', logs: logger.getHistory() });
+}
+
+/**
+ * GET /api/logs/stream
+ * Streams live log events as Server-Sent Events.
+ * Pass ?history=true to replay existing log history before streaming live events.
+ */
+export function handleStreamLogs(req, res) {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+
+  const sendLog = (log) => {
+    res.write(`data: ${JSON.stringify(log)}\n\n`);
+  };
+
+  if (req.query.history === 'true') {
+    logger.getHistory().forEach(sendLog);
+  }
+
+  logger.on('log', sendLog);
+
+  req.on('close', () => {
+    logger.off('log', sendLog);
+  });
+}
+
+export default { handleGetLogs, handleStreamLogs };

package/src/routes/messages-route.js

@@ -0,0 +1,164 @@
+import { createMessageStream, sendMessage } from '../direct-api.js';
+import { resolveModelRouting } from '../model-mapper.js';
+import { sendAuthError, getCredentialsForAccount } from '../middleware/credentials.js';
+import { initSSEResponse, pipeSSEStream, handleStreamError } from '../middleware/sse.js';
+import { logger } from '../utils/logger.js';
+import { AccountRotator } from '../account-rotation/index.js';
+import { listAccounts, getActiveAccount, save } from '../account-manager.js';
+import { getServerSettings } from '../server-settings.js';
+
+const MAX_RETRIES = 5;
+const MAX_WAIT_BEFORE_ERROR_MS = 120000;
+const SHORT_RATE_LIMIT_THRESHOLD_MS = 5000;
+
+let accountRotator = null;
+let currentStrategy = null;
+
+function getRequestContext(req) {
+    try {
+        const metadata = JSON.parse(req.body?.metadata?.user_id || '{}');
+        return { sessionId: metadata.session_id };
+    } catch (_) {
+        return { sessionId: undefined };
+    }
+}
+
+function getAccountRotator() {
+    const settings = getServerSettings();
+    const strategy = settings.accountStrategy || 'sticky';
+    
+    if (!accountRotator || currentStrategy !== strategy) {
+        accountRotator = new AccountRotator({
+            listAccounts,
+            save,
+            getActiveAccount
+        }, strategy);
+        currentStrategy = strategy;
+        logger.info(`[Messages] Account strategy: ${strategy}`);
+    }
+    return accountRotator;
+}
+
+export async function handleMessages(req, res) {
+    const startTime = Date.now();
+    const body = req.body;
+    const settings = getServerSettings();
+    if (settings.logRawProxyPayloads === true) {
+        logger.info('[Claude Request]', body);
+    }
+    const requestedModel = body.model || 'gpt-5.2';
+    const isStreaming = body.stream !== false;
+    
+    const { upstreamModel } = resolveModelRouting(requestedModel);
+
+    const rotator = getAccountRotator();
+    
+    rotator.clearExpiredLimits();
+    
+    const maxAttempts = Math.max(MAX_RETRIES, listAccounts().total);
+    
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (rotator.isAllRateLimited(upstreamModel)) {
+            const minWait = rotator.getMinWaitTimeMs(upstreamModel);
+            
+            if (minWait > MAX_WAIT_BEFORE_ERROR_MS) {
+                return handleStreamError(res, new Error(`RESOURCE_EXHAUSTED: All accounts rate-limited. Wait ${Math.round(minWait/1000)}s`), upstreamModel, startTime);
+            }
+            
+            logger.info(`[Messages] All accounts rate-limited, waiting ${Math.round(minWait/1000)}s...`);
+            await sleep(minWait + 500);
+            rotator.clearExpiredLimits();
+            attempt--;
+            continue;
+        }
+        
+        const { account, waitMs } = rotator.selectAccount(upstreamModel);
+        
+        if (!account) {
+            if (waitMs > 0) {
+                await sleep(waitMs);
+                attempt--;
+                continue;
+            }
+            return sendAuthError(res, 'No available accounts');
+        }
+        
+        const creds = await getCredentialsForAccount(account.email);
+        if (!creds) {
+            rotator.markInvalid(account.email, 'Failed to get credentials');
+            continue;
+        }
+        
+        const anthropicRequest = { ...body, model: upstreamModel };
+        const requestContext = getRequestContext(req);
+
+        try {
+            if (isStreaming) {
+                await _streamDirectWithRotation(res, anthropicRequest, creds, requestedModel, startTime, rotator, requestContext);
+            } else {
+                await _sendDirectWithRotation(res, anthropicRequest, creds, requestedModel, startTime, rotator, requestContext);
+            }
+            rotator.notifySuccess(account, upstreamModel);
+            return;
+        } catch (error) {
+            if (error.message.startsWith('RATE_LIMITED:')) {
+                const parts = error.message.split(':');
+                const resetMs = parseInt(parts[1], 10);
+                const errorText = parts.slice(2).join(':');
+                
+                rotator.notifyRateLimit(account, upstreamModel);
+                
+                if (resetMs <= SHORT_RATE_LIMIT_THRESHOLD_MS) {
+                    logger.info(`[Messages] Short rate limit on ${account.email}, waiting ${resetMs}ms...`);
+                    await sleep(resetMs);
+                    attempt--;
+                    continue;
+                }
+                
+                logger.info(`[Messages] Rate limit on ${account.email}, switching account...`);
+                continue;
+            }
+            
+            if (error.message.includes('AUTH_EXPIRED')) {
+                rotator.markInvalid(account.email, 'Auth expired');
+                continue;
+            }
+            
+            return handleStreamError(res, error, upstreamModel, startTime);
+        }
+    }
+    
+    return handleStreamError(res, new Error('Max retries exceeded'), upstreamModel, startTime);
+}
+
+async function _streamDirectWithRotation(res, anthropicRequest, creds, responseModel, startTime, rotator, requestContext) {
+    const stream = await createMessageStream(anthropicRequest, creds.accessToken, creds.accountId, rotator, creds.email, requestContext, responseModel);
+    initSSEResponse(res);
+    const usage = await pipeSSEStream(res, stream);
+    logger.response(200, { model: anthropicRequest.model, ...getTokenDetails(usage), duration: Date.now() - startTime });
+}
+
+async function _sendDirectWithRotation(res, anthropicRequest, creds, responseModel, startTime, rotator, requestContext) {
+    const response = await sendMessage(anthropicRequest, creds.accessToken, creds.accountId, requestContext);
+    const duration = Date.now() - startTime;
+    logger.response(200, { model: anthropicRequest.model, ...getTokenDetails(response.usage), duration });
+    res.json({ ...response, model: responseModel });
+}
+
+function getTokenDetails(usage = {}) {
+    const inputTokens = usage?.input_tokens || 0;
+    const outputTokens = usage?.output_tokens || 0;
+    const cacheReadInputTokens = usage?.cache_read_input_tokens || 0;
+    return {
+        tokens: inputTokens + outputTokens,
+        inputTokens,
+        outputTokens,
+        cacheReadInputTokens
+    };
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export default { handleMessages };

package/src/routes/models-route.js

@@ -0,0 +1,115 @@
+/**
+ * Models Route
+ * Handles:
+ *   GET /v1/models            — OpenAI-compatible model list
+ *   GET /accounts/models      — Raw model list for the active/specified account
+ *   GET /accounts/usage       — Usage stats for the active/specified account
+ */
+
+import { fetchModels, fetchUsage } from '../model-api.js';
+import { getActiveAccount, loadAccounts } from '../account-manager.js';
+import { logger } from '../utils/logger.js';
+import { getCredentialsOrError } from '../middleware/credentials.js';
+
+const FALLBACK_MODELS = [
+  // OpenAI upstream models
+  { id: 'gpt-5.3-codex', object: 'model', owned_by: 'openai' },
+  { id: 'gpt-5.2-codex', object: 'model', owned_by: 'openai' },
+  { id: 'gpt-5.1-codex', object: 'model', owned_by: 'openai' },
+  { id: 'gpt-5.2', object: 'model', owned_by: 'openai' },
+  // Current Claude 4.6 models
+  { id: 'claude-opus-4-6', object: 'model', owned_by: 'anthropic' },
+  { id: 'claude-sonnet-4-6', object: 'model', owned_by: 'anthropic' },
+  { id: 'claude-haiku-4-5', object: 'model', owned_by: 'anthropic' },
+  // 1M context variants
+  { id: 'claude-opus-4-6-1m', object: 'model', owned_by: 'anthropic' },
+  { id: 'claude-sonnet-4-6-1m', object: 'model', owned_by: 'anthropic' },
+  // Legacy models (still supported)
+  { id: 'claude-opus-4-5', object: 'model', owned_by: 'anthropic' },
+  { id: 'claude-sonnet-4-5', object: 'model', owned_by: 'anthropic' }
+];
+
+/**
+ * GET /v1/models
+ * Returns an OpenAI-compatible model list. Falls back to a static list on error.
+ */
+export async function handleListModels(req, res) {
+  const creds = await getCredentialsOrError();
+
+  if (!creds) {
+    return res.json({ object: 'list', data: FALLBACK_MODELS });
+  }
+
+  try {
+    const models = await fetchModels(creds.accessToken, creds.accountId);
+    const modelList = models.map(m => ({
+      id: m.id,
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: 'openai',
+      description: m.description
+    }));
+    res.json({ object: 'list', data: modelList });
+  } catch (error) {
+    logger.error(`Failed to fetch models: ${error.message}`);
+    res.json({ object: 'list', data: FALLBACK_MODELS });
+  }
+}
+
+/**
+ * GET /accounts/models
+ * Returns the raw model list for the active or specified account.
+ */
+export async function handleAccountModels(req, res) {
+  const account = _resolveAccount(req.query.email);
+
+  if (!account) {
+    return res.status(404).json({
+      success: false,
+      error: req.query.email ? `Account not found: ${req.query.email}` : 'No active account'
+    });
+  }
+
+  try {
+    const models = await fetchModels(account.accessToken, account.accountId);
+    res.json({ success: true, email: account.email, models });
+  } catch (error) {
+    logger.error(`Failed to fetch models: ${error.message}`);
+    res.status(500).json({ success: false, error: error.message });
+  }
+}
+
+/**
+ * GET /accounts/usage
+ * Returns usage stats for the active or specified account.
+ */
+export async function handleAccountUsage(req, res) {
+  const account = _resolveAccount(req.query.email);
+
+  if (!account) {
+    return res.status(404).json({
+      success: false,
+      error: req.query.email ? `Account not found: ${req.query.email}` : 'No active account'
+    });
+  }
+
+  try {
+    const usage = await fetchUsage(account.accessToken, account.accountId);
+    res.json({ success: true, email: account.email, usage });
+  } catch (error) {
+    logger.error(`Failed to fetch usage: ${error.message}`);
+    res.status(500).json({ success: false, error: error.message });
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function _resolveAccount(email) {
+  if (email) {
+    const data = loadAccounts();
+    return data.accounts.find(a => a.email === email) || null;
+  }
+  return getActiveAccount();
+}
+
+export default { handleListModels, handleAccountModels, handleAccountUsage };

package/src/routes/settings-route.js

@@ -0,0 +1,154 @@
+/**
+ * Settings Route
+ * Handles server settings endpoints:
+ *   GET  /settings/account-strategy
+ *   POST /settings/account-strategy
+ *   GET  /settings/model-map
+ *   POST /settings/model-map
+ *   GET  /settings/raw-proxy-logs
+ *   POST /settings/raw-proxy-logs
+ */
+
+import { getServerSettings, setServerSettings, DEFAULT_MODEL_MAP } from '../server-settings.js';
+
+const VALID_STRATEGIES = ['sticky', 'round-robin'];
+
+/**
+ * GET /settings/account-strategy
+ * Returns the current account selection strategy.
+ */
+export function handleGetAccountStrategy(req, res) {
+  const settings = getServerSettings();
+  res.json({ success: true, accountStrategy: settings.accountStrategy });
+}
+
+/**
+ * POST /settings/account-strategy
+ * Updates the account selection strategy.
+ */
+export function handleSetAccountStrategy(req, res) {
+  const { accountStrategy } = req.body || {};
+
+  if (!VALID_STRATEGIES.includes(accountStrategy)) {
+    return res.status(400).json({
+      success: false,
+      error: `Invalid accountStrategy. Use one of: ${VALID_STRATEGIES.join(', ')}`
+    });
+  }
+
+  const settings = setServerSettings({ accountStrategy });
+  res.json({ success: true, accountStrategy: settings.accountStrategy });
+}
+
+/**
+ * GET /settings/model-map
+ * Returns the current model mapping configuration.
+ */
+export function handleGetModelMap(req, res) {
+  const settings = getServerSettings();
+
+  res.json({
+    success: true,
+    modelMap: settings.modelMap,
+    defaultCodexModel: settings.defaultCodexModel
+  });
+}
+
+/**
+ * POST /settings/model-map
+ * Updates model mapping configuration.
+ *
+ * Body:
+ * {
+ *   "modelMap": { "sonnet": "gpt-5.5", "opus": "gpt-5.5" },
+ *   "defaultCodexModel": "gpt-5.2",
+ *   "reset": false
+ * }
+ *
+ * By default, modelMap is merged into the existing map. Use reset=true to
+ * reset to built-in defaults before applying the provided modelMap.
+ */
+export function handleSetModelMap(req, res) {
+  const { modelMap, defaultCodexModel, reset = false } = req.body || {};
+  const current = getServerSettings();
+  const patch = {};
+
+  if (defaultCodexModel !== undefined) {
+    if (!defaultCodexModel || typeof defaultCodexModel !== 'string') {
+      return res.status(400).json({
+        success: false,
+        error: 'defaultCodexModel must be a non-empty string'
+      });
+    }
+    patch.defaultCodexModel = defaultCodexModel;
+  }
+
+  if (modelMap !== undefined) {
+    if (typeof modelMap !== 'object' || modelMap === null || Array.isArray(modelMap)) {
+      return res.status(400).json({
+        success: false,
+        error: 'modelMap must be an object of { requestedModel: upstreamModel }'
+      });
+    }
+
+    for (const [key, value] of Object.entries(modelMap)) {
+      if (!key || typeof key !== 'string' || !value || typeof value !== 'string') {
+        return res.status(400).json({
+          success: false,
+          error: 'modelMap keys and values must be non-empty strings'
+        });
+      }
+    }
+
+    patch.modelMap = {
+      ...(reset ? DEFAULT_MODEL_MAP : current.modelMap),
+      ...modelMap
+    };
+  } else if (reset) {
+    patch.modelMap = DEFAULT_MODEL_MAP;
+  }
+
+  const settings = setServerSettings(patch);
+
+  res.json({
+    success: true,
+    modelMap: settings.modelMap,
+    defaultCodexModel: settings.defaultCodexModel
+  });
+}
+
+/**
+ * GET /settings/raw-proxy-logs
+ * Returns whether raw proxy payload logging is enabled.
+ */
+export function handleGetRawProxyLogs(req, res) {
+  const settings = getServerSettings();
+  res.json({ success: true, logRawProxyPayloads: settings.logRawProxyPayloads === true });
+}
+
+/**
+ * POST /settings/raw-proxy-logs
+ * Enables or disables raw proxy payload logging.
+ */
+export function handleSetRawProxyLogs(req, res) {
+  const { enabled } = req.body || {};
+
+  if (typeof enabled !== 'boolean') {
+    return res.status(400).json({
+      success: false,
+      error: 'enabled must be a boolean'
+    });
+  }
+
+  const settings = setServerSettings({ logRawProxyPayloads: enabled });
+  res.json({ success: true, logRawProxyPayloads: settings.logRawProxyPayloads === true });
+}
+
+export default {
+  handleGetAccountStrategy,
+  handleSetAccountStrategy,
+  handleGetModelMap,
+  handleSetModelMap,
+  handleGetRawProxyLogs,
+  handleSetRawProxyLogs
+};

package/src/server-settings.js

@@ -0,0 +1,70 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { CONFIG_DIR } from './account-manager.js';
+
+const SETTINGS_FILE = join(CONFIG_DIR, 'settings.json');
+
+export const DEFAULT_MODEL_MAP = {
+    sonnet: 'gpt-5.5',
+    opus: 'gpt-5.5',
+    haiku: 'gpt-5.4-mini'
+};
+
+export const DEFAULT_SETTINGS = {
+    accountStrategy: 'sticky',
+    defaultCodexModel: 'gpt-5.5',
+    logRawProxyPayloads: false,
+    modelMap: DEFAULT_MODEL_MAP
+};
+
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+
+function mergeSettings(data = {}) {
+    return {
+        ...DEFAULT_SETTINGS,
+        ...data,
+        modelMap: {
+            ...DEFAULT_MODEL_MAP,
+            ...(data.modelMap || {})
+        }
+    };
+}
+
+export function getServerSettings() {
+    ensureConfigDir();
+
+    if (!existsSync(SETTINGS_FILE)) {
+        return mergeSettings();
+    }
+
+    try {
+        const data = JSON.parse(readFileSync(SETTINGS_FILE, 'utf8'));
+        return mergeSettings(data);
+    } catch (error) {
+        console.error('[ServerSettings] Failed to read settings:', error.message);
+        return mergeSettings();
+    }
+}
+
+export function setServerSettings(patch = {}) {
+    const current = getServerSettings();
+    const next = mergeSettings({ ...current, ...patch });
+
+    ensureConfigDir();
+    writeFileSync(SETTINGS_FILE, JSON.stringify(next, null, 2), { mode: 0o600 });
+    return next;
+}
+
+export { SETTINGS_FILE };
+
+export default {
+    getServerSettings,
+    setServerSettings,
+    SETTINGS_FILE,
+    DEFAULT_SETTINGS,
+    DEFAULT_MODEL_MAP
+};