unified-server.js

// unified-server.js (v16 - API Key Sanitization Fix)

// --- 核心依赖 ---
const express = require('express');
const WebSocket = require('ws');
const http = require('http');
const { EventEmitter } = require('events');
const fs = require('fs');
const path = require('path');
const { firefox } = require('playwright');
const os = require('os');


// ===================================================================================
// AUTH SOURCE MANAGEMENT MODULE
// ===================================================================================

class AuthSource {
  constructor(logger) {
    this.logger = logger;
    this.authMode = 'file'; // Default mode
    this.maxIndex = 0;

    if (process.env.AUTH_JSON_1) {
      this.authMode = 'env';
      this.logger.info('[Auth] 检测到 AUTH_JSON_1 环境变量，切换到环境变量认证模式。');
    } else {
      this.logger.info('[Auth] 未检测到环境变量认证，将使用 "auth/" 目录下的文件。');
    }
    
    this._calculateMaxIndex();
    
    if (this.maxIndex === 0) {
      this.logger.error(`[Auth] 致命错误：在 '${this.authMode}' 模式下未找到任何有效的认证源。`);
      throw new Error("No valid authentication sources found.");
    }
  }

  _calculateMaxIndex() {
    if (this.authMode === 'env') {
      let i = 1;
      while (process.env[`AUTH_JSON_${i}`]) {
        i++;
      }
      this.maxIndex = i - 1;
    } else { // 'file' mode
      const authDir = path.join(__dirname, 'auth');
      if (!fs.existsSync(authDir)) {
        this.logger.warn('[Auth] "auth/" 目录不存在。');
        this.maxIndex = 0;
        return;
      }
      try {
        const files = fs.readdirSync(authDir);
        const authFiles = files.filter(file => /^auth-\d+\.json$/.test(file));
        const indices = authFiles.map(file => parseInt(file.match(/^auth-(\d+)\.json$/)[1], 10));
        this.maxIndex = indices.length > 0 ? Math.max(...indices) : 0;
      } catch (error) {
        this.logger.error(`[Auth] 扫描 "auth/" 目录失败: ${error.message}`);
        this.maxIndex = 0;
      }
    }
    this.logger.info(`[Auth] 在 '${this.authMode}' 模式下，检测到 ${this.maxIndex} 个认证源。`);
  }

  getMaxIndex() {
    return this.maxIndex;
  }

  getAuth(index) {
    if (index > this.maxIndex || index < 1) {
      this.logger.error(`[Auth] 请求了无效的认证索引: ${index}`);
      return null;
    }

    let jsonString;
    let sourceDescription;

    if (this.authMode === 'env') {
      jsonString = process.env[`AUTH_JSON_${index}`];
      sourceDescription = `环境变量 AUTH_JSON_${index}`;
    } else { // 'file' mode
      const authFilePath = path.join(__dirname, 'auth', `auth-${index}.json`);
      sourceDescription = `文件 ${authFilePath}`;
      if (!fs.existsSync(authFilePath)) {
          this.logger.error(`[Auth] ${sourceDescription} 不存在。`);
          return null;
      }
      try {
        jsonString = fs.readFileSync(authFilePath, 'utf-8');
      } catch (e) {
        this.logger.error(`[Auth] 读取 ${sourceDescription} 失败: ${e.message}`);
        return null;
      }
    }
    
    try {
      return JSON.parse(jsonString);
    } catch (e) {
      this.logger.error(`[Auth] 解析来自 ${sourceDescription} 的JSON内容失败: ${e.message}`);
      return null;
    }
  }
}


// ===================================================================================
// BROWSER MANAGEMENT MODULE
// ===================================================================================

class BrowserManager {
  constructor(logger, config, authSource) {
    this.logger = logger;
    this.config = config;
    this.authSource = authSource;
    this.browser = null;
    this.context = null;
    this.page = null;
    this.currentAuthIndex = 0;
    this.scriptFileName = 'dark-browser.js';
    
    if (this.config.browserExecutablePath) {
      this.browserExecutablePath = this.config.browserExecutablePath;
      this.logger.info(`[System] 使用环境变量 CAMOUFOX_EXECUTABLE_PATH 指定的浏览器路径。`);
    } else {
      const platform = os.platform();
      if (platform === 'win32') {
        this.browserExecutablePath = path.join(__dirname, 'camoufox', 'camoufox.exe');
        this.logger.info(`[System] 检测到操作系统: Windows. 将使用 'camoufox' 目录下的浏览器。`);
      } else if (platform === 'linux') {
        this.browserExecutablePath = path.join(__dirname, 'camoufox-linux', 'camoufox');
        this.logger.info(`[System] 检测到操作系统: Linux. 将使用 'camoufox-linux' 目录下的浏览器。`);
      } else {
        this.logger.error(`[System] 不支持的操作系统: ${platform}.`);
        throw new Error(`Unsupported operating system: ${platform}`);
      }
    }
  }

  async launchBrowser(authIndex) {
    if (this.browser) {
      this.logger.warn('尝试启动一个已在运行的浏览器实例，操作已取消。');
      return;
    }
    
    const sourceDescription = this.authSource.authMode === 'env' ? `环境变量 AUTH_JSON_${authIndex}` : `文件 auth-${authIndex}.json`;
    this.logger.info('==================================================');
    this.logger.info(`🚀 [Browser] 准备启动浏览器`);
    this.logger.info(`   • 认证源: ${sourceDescription}`);
    this.logger.info(`   • 浏览器路径: ${this.browserExecutablePath}`);
    this.logger.info('==================================================');

    if (!fs.existsSync(this.browserExecutablePath)) {
        this.logger.error(`❌ [Browser] 找不到浏览器可执行文件: ${this.browserExecutablePath}`);
        throw new Error(`Browser executable not found at path: ${this.browserExecutablePath}`);
    }
    
    const storageStateObject = this.authSource.getAuth(authIndex);
    if (!storageStateObject) {
        this.logger.error(`❌ [Browser] 无法获取或解析索引为 ${authIndex} 的认证信息。`);
        throw new Error(`Failed to get or parse auth source for index ${authIndex}.`);
    }

    let buildScriptContent;
    try {
      const scriptFilePath = path.join(__dirname, this.scriptFileName);
      buildScriptContent = fs.readFileSync(scriptFilePath, 'utf-8');
      this.logger.info(`✅ [Browser] 成功读取注入脚本 "${this.scriptFileName}"`);
    } catch (error) {
      this.logger.error(`❌ [Browser] 无法读取注入脚本 "${this.scriptFileName}"！`);
      throw error;
    }

    try {
      this.browser = await firefox.launch({
        headless: true,
        executablePath: this.browserExecutablePath,
      });
      this.browser.on('disconnected', () => {
        this.logger.error('❌ [Browser] 浏览器意外断开连接！服务器可能需要重启。');
        this.browser = null; this.context = null; this.page = null;
      });
      this.context = await this.browser.newContext({
        storageState: storageStateObject,
        viewport: { width: 1920, height: 1080 },
      });
      this.page = await this.context.newPage();
      this.logger.info(`[Browser] 正在加载账户 ${authIndex} 并访问目标网页...`);
      const targetUrl = 'https://aistudio.google.com/u/0/apps/bundled/blank?showPreview=true&showCode=true&showAssistant=true';
      await this.page.goto(targetUrl, { timeout: 60000, waitUntil: 'networkidle' });
      this.logger.info('[Browser] 网页加载完成，正在注入客户端脚本...');
      
      const editorContainerLocator = this.page.locator('div.monaco-editor').first();
      
      this.logger.info('[Browser] 等待编辑器出现，最长60秒...');
      await editorContainerLocator.waitFor({ state: 'visible', timeout: 60000 });
      this.logger.info('[Browser] 编辑器已出现，准备粘贴脚本。');

      await editorContainerLocator.click();
      await this.page.evaluate(text => navigator.clipboard.writeText(text), buildScriptContent);
      const isMac = os.platform() === 'darwin';
      const pasteKey = isMac ? 'Meta+V' : 'Control+V';
      await this.page.keyboard.press(pasteKey);
      this.logger.info('[Browser] 脚本已粘贴。浏览器端初始化完成。');


      this.currentAuthIndex = authIndex;
      this.logger.info('==================================================');
      this.logger.info(`✅ [Browser] 账户 ${authIndex} 初始化成功！`);
      this.logger.info('✅ [Browser] 浏览器客户端已准备就绪。');
      this.logger.info('==================================================');
    } catch (error) {
        this.logger.error(`❌ [Browser] 账户 ${authIndex} 初始化失败: ${error.message}`);
        if (this.browser) {
            await this.browser.close();
            this.browser = null;
        }
        throw error;
    }
  }

  async closeBrowser() {
    if (this.browser) {
      this.logger.info('[Browser] 正在关闭当前浏览器实例...');
      await this.browser.close();
      this.browser = null; this.context = null; this.page = null;
      this.logger.info('[Browser] 浏览器已关闭。');
    }
  }

  async switchAccount(newAuthIndex) {
    this.logger.info(`🔄 [Browser] 开始账号切换: 从 ${this.currentAuthIndex} 到 ${newAuthIndex}`);
    await this.closeBrowser();
    await this.launchBrowser(newAuthIndex);
    this.logger.info(`✅ [Browser] 账号切换完成，当前账号: ${this.currentAuthIndex}`);
  }
}

// ===================================================================================
// PROXY SERVER MODULE
// ===================================================================================

class LoggingService {
  constructor(serviceName = 'ProxyServer') {
    this.serviceName = serviceName;
  }
  _formatMessage(level, message) {
    const timestamp = new Date().toISOString();
    return `[${level}] ${timestamp} [${this.serviceName}] - ${message}`;
  }
  info(message) { console.log(this._formatMessage('INFO', message)); }
  error(message) { console.error(this._formatMessage('ERROR', message)); }
  warn(message) { console.warn(this._formatMessage('WARN', message)); }
  debug(message) { console.debug(this._formatMessage('DEBUG', message)); }
}

class MessageQueue extends EventEmitter {
  constructor(timeoutMs = 600000) {
    super();
    this.messages = [];
    this.waitingResolvers = [];
    this.defaultTimeout = timeoutMs;
    this.closed = false;
  }
  enqueue(message) {
    if (this.closed) return;
    if (this.waitingResolvers.length > 0) {
      const resolver = this.waitingResolvers.shift();
      resolver.resolve(message);
    } else {
      this.messages.push(message);
    }
  }
  async dequeue(timeoutMs = this.defaultTimeout) {
    if (this.closed) {
      throw new Error('Queue is closed');
    }
    return new Promise((resolve, reject) => {
      if (this.messages.length > 0) {
        resolve(this.messages.shift());
        return;
      }
      const resolver = { resolve, reject };
      this.waitingResolvers.push(resolver);
      const timeoutId = setTimeout(() => {
        const index = this.waitingResolvers.indexOf(resolver);
        if (index !== -1) {
          this.waitingResolvers.splice(index, 1);
          reject(new Error('Queue timeout'));
        }
      }, timeoutMs);
      resolver.timeoutId = timeoutId;
    });
  }
  close() {
    this.closed = true;
    this.waitingResolvers.forEach(resolver => {
      clearTimeout(resolver.timeoutId);
      resolver.reject(new Error('Queue closed'));
    });
    this.waitingResolvers = [];
    this.messages = [];
  }
}

class ConnectionRegistry extends EventEmitter {
  constructor(logger) {
    super();
    this.logger = logger;
    this.connections = new Set();
    this.messageQueues = new Map();
  }
  addConnection(websocket, clientInfo) {
    this.connections.add(websocket);
    this.logger.info(`[Server] 内部WebSocket客户端已连接 (来自: ${clientInfo.address})`);
    websocket.on('message', (data) => this._handleIncomingMessage(data.toString()));
    websocket.on('close', () => this._removeConnection(websocket));
    websocket.on('error', (error) => this.logger.error(`[Server] 内部WebSocket连接错误: ${error.message}`));
    this.emit('connectionAdded', websocket);
  }
  _removeConnection(websocket) {
    this.connections.delete(websocket);
    this.logger.warn('[Server] 内部WebSocket客户端连接断开');
    this.messageQueues.forEach(queue => queue.close());
    this.messageQueues.clear();
    this.emit('connectionRemoved', websocket);
  }
  _handleIncomingMessage(messageData) {
    try {
      const parsedMessage = JSON.parse(messageData);
      const requestId = parsedMessage.request_id;
      if (!requestId) {
        this.logger.warn('[Server] 收到无效消息：缺少request_id');
        return;
      }
      const queue = this.messageQueues.get(requestId);
      if (queue) {
        this._routeMessage(parsedMessage, queue);
      } else {
        this.logger.warn(`[Server] 收到未知请求ID的消息: ${requestId}`);
      }
    } catch (error) {
      this.logger.error('[Server] 解析内部WebSocket消息失败');
    }
  }
  _routeMessage(message, queue) {
    const { event_type } = message;
    switch (event_type) {
      case 'response_headers': case 'chunk': case 'error':
        queue.enqueue(message);
        break;
      case 'stream_close':
        queue.enqueue({ type: 'STREAM_END' });
        break;
      default:
        this.logger.warn(`[Server] 未知的内部事件类型: ${event_type}`);
    }
  }
  hasActiveConnections() { return this.connections.size > 0; }
  getFirstConnection() { return this.connections.values().next().value; }
  createMessageQueue(requestId) {
    const queue = new MessageQueue();
    this.messageQueues.set(requestId, queue);
    return queue;
  }
  removeMessageQueue(requestId) {
    const queue = this.messageQueues.get(requestId);
    if (queue) {
      queue.close();
      this.messageQueues.delete(requestId);
    }
  }
}

class RequestHandler {
  constructor(serverSystem, connectionRegistry, logger, browserManager, config, authSource) {
    this.serverSystem = serverSystem;
    this.connectionRegistry = connectionRegistry;
    this.logger = logger;
    this.browserManager = browserManager;
    this.config = config;
    this.authSource = authSource;
    this.maxRetries = this.config.maxRetries;
    this.retryDelay = this.config.retryDelay;
    this.failureCount = 0;
    this.isAuthSwitching = false;
  }
  
  get currentAuthIndex() {
    return this.browserManager.currentAuthIndex;
  }
  
  _getMaxAuthIndex() {
    return this.authSource.getMaxIndex();
  }
  
  _getNextAuthIndex() {
    const maxIndex = this._getMaxAuthIndex();
    if (maxIndex === 0) return 0; // Should not happen if initial check passes
    return this.currentAuthIndex >= maxIndex ? 1 : this.currentAuthIndex + 1;
  }
  
  async _switchToNextAuth() {
    if (this.isAuthSwitching) {
      this.logger.info('🔄 [Auth] 正在切换auth文件，跳过重复切换');
      return;
    }
    
    this.isAuthSwitching = true;
    const nextAuthIndex = this._getNextAuthIndex();
    const maxAuthIndex = this._getMaxAuthIndex();
    
    this.logger.info('==================================================');
    this.logger.info(`🔄 [Auth] 开始账号切换流程`);
    this.logger.info(`   • 失败次数: ${this.failureCount}/${this.config.failureThreshold}`);
    this.logger.info(`   • 当前账号索引: ${this.currentAuthIndex}`);
    this.logger.info(`   • 目标账号索引: ${nextAuthIndex}`);
    this.logger.info(`   • 可用账号总数: ${maxAuthIndex}`);
    this.logger.info('==================================================');
    
    try {
      await this.browserManager.switchAccount(nextAuthIndex);
      this.failureCount = 0;
      this.logger.info('==================================================');
      this.logger.info(`✅ [Auth] 成功切换到账号索引 ${this.currentAuthIndex}`);
      this.logger.info(`✅ [Auth] 失败计数已重置为0`);
      this.logger.info('==================================================');
    } catch (error) {
      this.logger.error('==================================================');
      this.logger.error(`❌ [Auth] 切换账号失败: ${error.message}`);
      this.logger.error('==================================================');
      throw error;
    } finally {
      this.isAuthSwitching = false;
    }
  }

  async processRequest(req, res) {
    this.logger.info(`[Request] 处理请求: ${req.method} ${req.path}`);
    if (!this.connectionRegistry.hasActiveConnections()) {
      return this._sendErrorResponse(res, 503, '没有可用的浏览器连接');
    }
    const requestId = this._generateRequestId();
    const proxyRequest = this._buildProxyRequest(req, requestId);
    const messageQueue = this.connectionRegistry.createMessageQueue(requestId);
    try {
      if (this.serverSystem.streamingMode === 'fake') {
        await this._handlePseudoStreamResponse(proxyRequest, messageQueue, req, res);
      } else {
        await this._handleRealStreamResponse(proxyRequest, messageQueue, res);
      }
    } catch (error) {
      this._handleRequestError(error, res);
    } finally {
      this.connectionRegistry.removeMessageQueue(requestId);
    }
  }
  _generateRequestId() { return `${Date.now()}_${Math.random().toString(36).substring(2, 11)}`; }
  _buildProxyRequest(req, requestId) {
    let requestBody = '';
    if (Buffer.isBuffer(req.body)) requestBody = req.body.toString('utf-8');
    else if (typeof req.body === 'string') requestBody = req.body;
    else if (req.body) requestBody = JSON.stringify(req.body);
    return {
      path: req.path, method: req.method, headers: req.headers, query_params: req.query,
      body: requestBody, request_id: requestId, streaming_mode: this.serverSystem.streamingMode
    };
  }
  _forwardRequest(proxyRequest) {
    const connection = this.connectionRegistry.getFirstConnection();
    if (connection) {
      connection.send(JSON.stringify(proxyRequest));
    } else {
      throw new Error("无法转发请求：没有可用的WebSocket连接。");
    }
  }
  _sendErrorChunkToClient(res, errorMessage) {
    const errorPayload = {
      error: { message: `[代理系统提示] ${errorMessage}`, type: 'proxy_error', code: 'proxy_error' }
    };
    const chunk = `data: ${JSON.stringify(errorPayload)}\n\n`;
    if (res && !res.writableEnded) {
      res.write(chunk);
      this.logger.info(`[Request] 已向客户端发送标准错误信号: ${errorMessage}`);
    }
  }
  async _handlePseudoStreamResponse(proxyRequest, messageQueue, req, res) {
    res.status(200).set({ 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
    this.logger.info('[Request] 已向客户端发送初始响应头，假流式计时器已启动。');
    let connectionMaintainer = null;
    try {
      const keepAliveChunk = this._getKeepAliveChunk(req);
      connectionMaintainer = setInterval(() => { if (!res.writableEnded) { res.write(keepAliveChunk); } }, 1000);
      let lastMessage, requestFailed = false;
      for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
        this.logger.info(`[Request] 请求尝试 #${attempt}/${this.maxRetries}...`);
        this._forwardRequest(proxyRequest);
        lastMessage = await messageQueue.dequeue();
        if (lastMessage.event_type === 'error' && lastMessage.status >= 400 && lastMessage.status <= 599) {
          const errorText = `收到 ${lastMessage.status} 错误。${attempt < this.maxRetries ? `将在 ${this.retryDelay / 1000}秒后重试...` : '已达到最大重试次数。'}`;
          this._sendErrorChunkToClient(res, errorText);
          if (attempt < this.maxRetries) {
            await new Promise(resolve => setTimeout(resolve, this.retryDelay));
            continue;
          }
          requestFailed = true;
        }
        break;
      }
      if (lastMessage.event_type === 'error' || requestFailed) {
        this.failureCount++;
        this.logger.warn(`⚠️ [Auth] 请求失败 - 失败计数: ${this.failureCount}/${this.config.failureThreshold} (当前账号索引: ${this.currentAuthIndex})`);
        if (this.failureCount >= this.config.failureThreshold) {
          this.logger.warn(`🔴 [Auth] 达到失败阈值！准备切换账号...`);
          this._sendErrorChunkToClient(res, `连续失败${this.failureCount}次，正在尝试切换账号...`);
          try {
            await this._switchToNextAuth();
            this._sendErrorChunkToClient(res, `已切换到账号索引 ${this.currentAuthIndex}，请重试`);
          } catch (switchError) {
            this.logger.error(`🔴 [Auth] 账号切换失败: ${switchError.message}`);
            this._sendErrorChunkToClient(res, `切换账号失败: ${switchError.message}`);
          }
        }
        throw new Error(lastMessage.message || '请求失败');
      }
      if (this.failureCount > 0) {
        this.logger.info(`✅ [Auth] 请求成功 - 失败计数已从 ${this.failureCount} 重置为 0`);
      }
      this.failureCount = 0;
      const dataMessage = await messageQueue.dequeue();
      const endMessage = await messageQueue.dequeue();
      if (dataMessage.data) {
        res.write(`data: ${dataMessage.data}\n\n`);
        this.logger.info('[Request] 已将完整响应体作为SSE事件发送。');
      }
      if (endMessage.type !== 'STREAM_END') this.logger.warn('[Request] 未收到预期的流结束信号。');
    } finally {
      if (connectionMaintainer) clearInterval(connectionMaintainer);
      if (!res.writableEnded) res.end();
      this.logger.info('[Request] 假流式响应处理结束。');
    }
  }
  async _handleRealStreamResponse(proxyRequest, messageQueue, res) {
    let headerMessage, requestFailed = false;
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      this.logger.info(`[Request] 请求尝试 #${attempt}/${this.maxRetries}...`);
      this._forwardRequest(proxyRequest);
      headerMessage = await messageQueue.dequeue();
      if (headerMessage.event_type === 'error' && headerMessage.status >= 400 && headerMessage.status <= 599) {
        this.logger.warn(`[Request] 收到 ${headerMessage.status} 错误，将在 ${this.retryDelay / 1000}秒后重试...`);
        if (attempt < this.maxRetries) {
          await new Promise(resolve => setTimeout(resolve, this.retryDelay));
          continue;
        }
        requestFailed = true;
      }
      break;
    }
    if (headerMessage.event_type === 'error' || requestFailed) {
      this.failureCount++;
      this.logger.warn(`⚠️ [Auth] 请求失败 - 失败计数: ${this.failureCount}/${this.config.failureThreshold} (当前账号索引: ${this.currentAuthIndex})`);
      if (this.failureCount >= this.config.failureThreshold) {
        this.logger.warn(`🔴 [Auth] 达到失败阈值！准备切换账号...`);
        try {
          await this._switchToNextAuth();
        } catch (switchError) {
          this.logger.error(`🔴 [Auth] 账号切换失败: ${switchError.message}`);
        }
      }
      return this._sendErrorResponse(res, headerMessage.status, headerMessage.message);
    }
    if (this.failureCount > 0) {
      this.logger.info(`✅ [Auth] 请求成功 - 失败计数已从 ${this.failureCount} 重置为 0`);
    }
    this.failureCount = 0;
    this._setResponseHeaders(res, headerMessage);
    this.logger.info('[Request] 已向客户端发送真实响应头，开始流式传输...');
    try {
      while (true) {
        const dataMessage = await messageQueue.dequeue(30000);
        if (dataMessage.type === 'STREAM_END') { this.logger.info('[Request] 收到流结束信号。'); break; }
        if (dataMessage.data) res.write(dataMessage.data);
      }
    } catch (error) {
      if (error.message !== 'Queue timeout') throw error;
      this.logger.warn('[Request] 真流式响应超时，可能流已正常结束。');
    } finally {
      if (!res.writableEnded) res.end();
      this.logger.info('[Request] 真流式响应连接已关闭。');
    }
  }
  _getKeepAliveChunk(req) {
    if (req.path.includes('chat/completions')) {
      const payload = { id: `chatcmpl-${this._generateRequestId()}`, object: "chat.completion.chunk", created: Math.floor(Date.now() / 1000), model: "gpt-4", choices: [{ index: 0, delta: {}, finish_reason: null }] };
      return `data: ${JSON.stringify(payload)}\n\n`;
    }
    if (req.path.includes('generateContent') || req.path.includes('streamGenerateContent')) {
      const payload = { candidates: [{ content: { parts: [{ text: "" }], role: "model" }, finishReason: null, index: 0, safetyRatings: [] }] };
      return `data: ${JSON.stringify(payload)}\n\n`;
    }
    return 'data: {}\n\n';
  }
  _setResponseHeaders(res, headerMessage) {
    res.status(headerMessage.status || 200);
    const headers = headerMessage.headers || {};
    Object.entries(headers).forEach(([name, value]) => {
      if (name.toLowerCase() !== 'content-length') res.set(name, value);
    });
  }
  _handleRequestError(error, res) {
    if (res.headersSent) {
      this.logger.error(`[Request] 请求处理错误 (头已发送): ${error.message}`);
      if (this.serverSystem.streamingMode === 'fake') this._sendErrorChunkToClient(res, `处理失败: ${error.message}`);
      if (!res.writableEnded) res.end();
    } else {
      this.logger.error(`[Request] 请求处理错误: ${error.message}`);
      const status = error.message.includes('超时') ? 504 : 500;
      this._sendErrorResponse(res, status, `代理错误: ${error.message}`);
    }
  }
  _sendErrorResponse(res, status, message) {
    if (!res.headersSent) res.status(status || 500).type('text/plain').send(message);
  }
}

class ProxyServerSystem extends EventEmitter {
  constructor() {
    super();
    this.logger = new LoggingService('ProxySystem');
    this._loadConfiguration();
    this.streamingMode = this.config.streamingMode;
    
    this.authSource = new AuthSource(this.logger);
    this.browserManager = new BrowserManager(this.logger, this.config, this.authSource);
    this.connectionRegistry = new ConnectionRegistry(this.logger);
    this.requestHandler = new RequestHandler(this, this.connectionRegistry, this.logger, this.browserManager, this.config, this.authSource);
    
    this.httpServer = null;
    this.wsServer = null;
  }
  
  _loadConfiguration() {
    let config = {
      httpPort: 7860, host: '0.0.0.0', wsPort: 9998, streamingMode: 'real',
      failureThreshold: 3, maxRetries: 3, retryDelay: 2000, browserExecutablePath: null,
      apiKeys: [],
    };
    
    const configPath = path.join(__dirname, 'config.json');
    try {
      if (fs.existsSync(configPath)) {
        const fileConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
        config = { ...config, ...fileConfig };
        this.logger.info('[System] 已从 config.json 加载配置。');
      }
    } catch (error) {
      this.logger.warn(`[System] 无法读取或解析 config.json: ${error.message}`);
    }

    if (process.env.PORT) config.httpPort = parseInt(process.env.PORT, 10) || config.httpPort;
    if (process.env.HOST) config.host = process.env.HOST;
    if (process.env.STREAMING_MODE) config.streamingMode = process.env.STREAMING_MODE;
    if (process.env.FAILURE_THRESHOLD) config.failureThreshold = parseInt(process.env.FAILURE_THRESHOLD, 10) || config.failureThreshold;
    if (process.env.MAX_RETRIES) config.maxRetries = parseInt(process.env.MAX_RETRIES, 10) || config.maxRetries;
    if (process.env.RETRY_DELAY) config.retryDelay = parseInt(process.env.RETRY_DELAY, 10) || config.retryDelay;
    if (process.env.CAMOUFOX_EXECUTABLE_PATH) config.browserExecutablePath = process.env.CAMOUFOX_EXECUTABLE_PATH;
    if (process.env.API_KEYS) {
        config.apiKeys = process.env.API_KEYS.split(',');
    }

    // --- CRITICAL FIX: Sanitize the apiKeys array to remove empty/whitespace-only keys ---
    if (Array.isArray(config.apiKeys)) {
        config.apiKeys = config.apiKeys.map(k => String(k).trim()).filter(k => k);
    } else {
        config.apiKeys = []; // Ensure it's always an array
    }
    
    this.config = config;
    this.logger.info('================ [ EFFECTIVE CONFIGURATION ] ================');
    this.logger.info(`  HTTP Port: ${this.config.httpPort}`);
    this.logger.info(`  Host: ${this.config.host}`);
    this.logger.info(`  Streaming Mode: ${this.config.streamingMode}`);
    this.logger.info(`  Failure Threshold: ${this.config.failureThreshold}`);
    this.logger.info(`  Max Retries: ${this.config.maxRetries}`);
    this.logger.info(`  Retry Delay: ${this.config.retryDelay}ms`);
    if (this.config.apiKeys && this.config.apiKeys.length > 0) {
        this.logger.info(`  API Key Auth: Enabled (${this.config.apiKeys.length} keys loaded)`);
    } else {
        this.logger.info(`  API Key Auth: Disabled`);
    }
    this.logger.info('=============================================================');
  }
  
  async start(initialAuthIndex = 1) {
    try {
      await this.browserManager.launchBrowser(initialAuthIndex);
      await this._startHttpServer();
      await this._startWebSocketServer();
      this.logger.info(`[System] 代理服务器系统启动完成。`);
      this.emit('started');
    } catch (error) {
      this.logger.error(`[System] 启动失败: ${error.message}`);
      this.emit('error', error);
      throw error;
    }
  }
  
  _createAuthMiddleware() {
    return (req, res, next) => {
      const serverApiKeys = this.config.apiKeys;
      if (!serverApiKeys || serverApiKeys.length === 0) {
        return next();
      }

      let clientKey = null;
      let keySource = null;
      
      const headers = req.headers;

      if (headers['x-goog-api-key']) {
        clientKey = headers['x-goog-api-key'];
        keySource = 'x-goog-api-key Header';
      } else if (headers.authorization && headers.authorization.startsWith('Bearer ')) {
        clientKey = headers.authorization.substring(7);
        keySource = 'Authorization Header';
      } else if (headers['x-api-key']) {
        clientKey = headers['x-api-key'];
        keySource = 'X-API-Key Header';
      } else if (req.query.key) {
        clientKey = req.query.key;
        keySource = 'Query Parameter';
      }
      
      if (clientKey) {
        if (serverApiKeys.includes(clientKey)) {
          this.logger.info(`[Auth] API Key 在 '${keySource}' 中找到，验证通过。`);
          
          // --- CRITICAL FIX: Clean up the request object if key was in query ---
          if (keySource === 'Query Parameter') {
              delete req.query.key;
              this.logger.debug(`[Auth-Cleanup] 已从 req.query 中移除 API Key，以确保请求纯净。`);
          }
          return next();
        } else {
          this.logger.warn(`[Auth] 拒绝请求: 无效的 API Key。IP: ${req.ip}, Source: ${keySource}, Key: '${clientKey}'`);
          return res.status(401).json({ error: { message: "Invalid API key provided." } });
        }
      }

      this.logger.warn(`[Auth] 拒绝受保护的请求: 缺少 API Key。IP: ${req.ip}, Path: ${req.path}`);
      this.logger.debug(`[Auth-Debug] 未在任何标准位置找到API Key。`);
      this.logger.debug(`[Auth-Debug] 搜索的Headers: ${JSON.stringify(headers)}`);
      this.logger.debug(`[Auth-Debug] 搜索的Query: ${JSON.stringify(req.query)}`);
      this.logger.debug(`[Auth-Debug] 已加载的API Keys: [${serverApiKeys.join(', ')}]`);

      return res.status(401).json({ error: { message: "Access denied. A valid API key was not found in headers or query parameters." } });
    };
  }
  
  async _startHttpServer() {
    const app = this._createExpressApp();
    this.httpServer = http.createServer(app);
    return new Promise((resolve) => {
      this.httpServer.listen(this.config.httpPort, this.config.host, () => {
        this.logger.info(`[System] HTTP服务器已在 http://${this.config.host}:${this.config.httpPort} 上监听`);
        resolve();
      });
    });
  }
  
  _createExpressApp() {
    const app = express();
    app.use(express.json({ limit: '100mb' }));
    app.use(express.raw({ type: '*/*', limit: '100mb' }));

    app.get('/admin/set-mode', (req, res) => {
      const newMode = req.query.mode;
      if (newMode === 'fake' || newMode === 'real') {
        this.streamingMode = newMode;
        res.status(200).send(`流式模式已切换为: ${this.streamingMode}`);
      } else {
        res.status(400).send('无效模式. 请用 "fake" 或 "real".');
      }
    });
    
    app.get('/health', (req, res) => {
      res.status(200).json({
        status: 'healthy',
        uptime: process.uptime(),
        config: {
            streamingMode: this.streamingMode,
            failureThreshold: this.config.failureThreshold,
            maxRetries: this.config.maxRetries,
            authMode: this.authSource.authMode,
            apiKeyAuth: (this.config.apiKeys && this.config.apiKeys.length > 0) ? 'Enabled' : 'Disabled',
        },
        auth: {
          currentAuthIndex: this.requestHandler.currentAuthIndex,
          maxAuthIndex: this.authSource.getMaxIndex(),
          failureCount: this.requestHandler.failureCount,
          isAuthSwitching: this.requestHandler.isAuthSwitching,
        },
        browser: {
          connected: !!this.browserManager.browser,
        },
        websocket: {
          internalClients: this.connectionRegistry.connections.size
        }
      });
    });
    
    app.use(this._createAuthMiddleware());
    
    app.all(/(.*)/, (req, res) => {
      if (req.path === '/favicon.ico') return res.status(204).send();
      this.requestHandler.processRequest(req, res);
    });
    
    return app;
  }
  
  async _startWebSocketServer() {
    this.wsServer = new WebSocket.Server({ port: this.config.wsPort, host: this.config.host });
    this.wsServer.on('connection', (ws, req) => {
      this.connectionRegistry.addConnection(ws, { address: req.socket.remoteAddress });
    });
  }
}

// ===================================================================================
// MAIN INITIALIZATION
// ===================================================================================

async function initializeServer() {
  const initialAuthIndex = parseInt(process.env.INITIAL_AUTH_INDEX, 10) || 1;
  try {
    const serverSystem = new ProxyServerSystem();
    await serverSystem.start(initialAuthIndex);
  } catch (error) {
    console.error('❌ 服务器启动失败:', error.message);
    process.exit(1);
  }
}

if (require.main === module) {
  initializeServer();
}

module.exports = { ProxyServerSystem, BrowserManager, initializeServer };