codex-claude-proxy 1.0.0

package/src/server-settings.js

@@ -0,0 +1,48 @@
+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');
+
+const DEFAULT_SETTINGS = {
+    haikuKiloModel: 'glm-5'
+};
+
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+
+export function getServerSettings() {
+    ensureConfigDir();
+
+    if (!existsSync(SETTINGS_FILE)) {
+        return { ...DEFAULT_SETTINGS };
+    }
+
+    try {
+        const data = JSON.parse(readFileSync(SETTINGS_FILE, 'utf8'));
+        return { ...DEFAULT_SETTINGS, ...data };
+    } catch (error) {
+        console.error('[ServerSettings] Failed to read settings:', error.message);
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+
+export function setServerSettings(patch = {}) {
+    const current = getServerSettings();
+    const next = { ...current, ...patch };
+
+    ensureConfigDir();
+    writeFileSync(SETTINGS_FILE, JSON.stringify(next, null, 2));
+    return next;
+}
+
+export { SETTINGS_FILE };
+
+export default {
+    getServerSettings,
+    setServerSettings,
+    SETTINGS_FILE
+};

package/src/server.js

@@ -0,0 +1,30 @@
+/**
+ * Server bootstrap
+ * Creates the Express app, middleware, and registers API routes.
+ */
+
+import express from 'express';
+import cors from 'cors';
+
+import { ensureAccountsPersist, startAutoRefresh } from './account-manager.js';
+import { registerApiRoutes } from './routes/api-routes.js';
+
+export function createServer({ port }) {
+  ensureAccountsPersist();
+  startAutoRefresh();
+
+  const app = express();
+  app.use(cors());
+  app.use(express.json({ limit: '10mb' }));
+
+  registerApiRoutes(app, { port });
+
+  return app;
+}
+
+export function startServer({ port }) {
+  const app = createServer({ port });
+  return app.listen(port);
+}
+
+export default { createServer, startServer };

package/src/utils/logger.js

@@ -0,0 +1,156 @@
+import EventEmitter from 'events';
+
+const COLORS = {
+    reset: '\x1b[0m',
+    blue: '\x1b[34m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    dim: '\x1b[2m'
+};
+
+const LEVEL_ICONS = {
+    INFO: 'ℹ',
+    SUCCESS: '✓',
+    WARN: '⚠',
+    ERROR: '✗',
+    DEBUG: '•'
+};
+
+class Logger extends EventEmitter {
+    constructor() {
+        super();
+        this.debugEnabled = false;
+        this.history = [];
+        this.maxHistory = 1000;
+    }
+
+    setDebug(enabled) {
+        this.debugEnabled = enabled;
+    }
+
+    get isDebugEnabled() {
+        return this.debugEnabled;
+    }
+
+    getHistory() {
+        return [...this.history];
+    }
+
+    clear() {
+        this.history = [];
+    }
+
+    _formatTimestamp() {
+        return new Date().toISOString().replace('T', ' ').slice(0, 19);
+    }
+
+    _formatMessage(args) {
+        return args.map(arg => {
+            if (arg === null) return 'null';
+            if (arg === undefined) return 'undefined';
+            if (typeof arg === 'object') {
+                try {
+                    return JSON.stringify(arg, null, 2);
+                } catch (e) {
+                    return String(arg);
+                }
+            }
+            return String(arg);
+        }).join(' ');
+    }
+
+    _log(level, ...args) {
+        const timestamp = this._formatTimestamp();
+        const icon = LEVEL_ICONS[level] || '•';
+        const color = {
+            INFO: COLORS.blue,
+            SUCCESS: COLORS.green,
+            WARN: COLORS.yellow,
+            ERROR: COLORS.red,
+            DEBUG: COLORS.magenta
+        }[level] || COLORS.reset;
+
+        const message = this._formatMessage(args);
+
+        if (level === 'DEBUG' && !this.debugEnabled) {
+            return;
+        }
+
+        const logEntry = {
+            timestamp,
+            level,
+            message,
+            icon
+        };
+
+        this.history.push(logEntry);
+        if (this.history.length > this.maxHistory) {
+            this.history.shift();
+        }
+
+        this.emit('log', logEntry);
+
+        const consoleMessage = `${COLORS.gray}${timestamp}${COLORS.reset} ${color}${icon}${COLORS.reset} ${message}`;
+
+        switch (level) {
+            case 'ERROR':
+                console.error(consoleMessage);
+                break;
+            case 'WARN':
+                console.warn(consoleMessage);
+                break;
+            default:
+                console.log(consoleMessage);
+        }
+    }
+
+    info(...args) {
+        this._log('INFO', ...args);
+    }
+
+    success(...args) {
+        this._log('SUCCESS', ...args);
+    }
+
+    warn(...args) {
+        this._log('WARN', ...args);
+    }
+
+    error(...args) {
+        this._log('ERROR', ...args);
+    }
+
+    debug(...args) {
+        this._log('DEBUG', ...args);
+    }
+
+    request(method, path, details = {}) {
+        const parts = [`${method}`, path];
+        if (details.model) parts.push(`model=${details.model}`);
+        if (details.account) parts.push(`account=${details.account}`);
+        if (details.stream !== undefined) parts.push(`stream=${details.stream}`);
+        if (details.messages) parts.push(`messages=${details.messages}`);
+        if (details.tools) parts.push(`tools=${details.tools}`);
+        this.info(`[Request] ${parts.join(' | ')}`);
+    }
+
+    response(status, details = {}) {
+        const parts = [`status=${status}`];
+        if (details.model) parts.push(`model=${details.model}`);
+        if (details.tokens) parts.push(`tokens=${details.tokens}`);
+        if (details.duration) parts.push(`${details.duration}ms`);
+        if (details.error) parts.push(`error=${details.error}`);
+        
+        if (status >= 400) {
+            this.error(`[Response] ${parts.join(' | ')}`);
+        } else {
+            this.success(`[Response] ${parts.join(' | ')}`);
+        }
+    }
+}
+
+export const logger = new Logger();