|
|
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'); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class AuthSource { |
|
|
constructor(logger) { |
|
|
this.logger = logger; |
|
|
this.authMode = 'file'; |
|
|
this.initialIndices = []; |
|
|
this.runtimeAuths = new Map(); |
|
|
|
|
|
if (process.env.AUTH_JSON_1) { |
|
|
this.authMode = 'env'; |
|
|
this.logger.info('[认证] 检测到 AUTH_JSON_1 环境变量，切换到环境变量认证模式。'); |
|
|
} else { |
|
|
this.logger.info('[认证] 未检测到环境变量认证，将使用 "auth/" 目录下的文件。'); |
|
|
} |
|
|
|
|
|
this._discoverAvailableIndices(); |
|
|
|
|
|
if (this.getAvailableIndices().length === 0) { |
|
|
this.logger.error(`[认证] 致命错误：在 '${this.authMode}' 模式下未找到任何有效的认证源。`); |
|
|
throw new Error("未找到有效的认证源。"); |
|
|
} |
|
|
} |
|
|
|
|
|
_discoverAvailableIndices() { |
|
|
let indices = []; |
|
|
if (this.authMode === 'env') { |
|
|
const regex = /^AUTH_JSON_(\d+)$/; |
|
|
for (const key in process.env) { |
|
|
const match = key.match(regex); |
|
|
|
|
|
if (match && match[1]) { |
|
|
indices.push(parseInt(match[1], 10)); |
|
|
} |
|
|
} |
|
|
} else { |
|
|
const authDir = path.join(__dirname, 'auth'); |
|
|
if (!fs.existsSync(authDir)) { |
|
|
this.logger.warn('[认证] "auth/" 目录不存在。'); |
|
|
this.initialIndices = []; |
|
|
return; |
|
|
} |
|
|
try { |
|
|
const files = fs.readdirSync(authDir); |
|
|
const authFiles = files.filter(file => /^auth-\d+\.json$/.test(file)); |
|
|
|
|
|
indices = authFiles.map(file => { |
|
|
const match = file.match(/^auth-(\d+)\.json$/); |
|
|
return parseInt(match[1], 10); |
|
|
}); |
|
|
} catch (error) { |
|
|
this.logger.error(`[认证] 扫描 "auth/" 目录失败: ${error.message}`); |
|
|
this.initialIndices = []; |
|
|
return; |
|
|
} |
|
|
} |
|
|
this.initialIndices = [...new Set(indices)].sort((a, b) => a - b); |
|
|
this.logger.info(`[认证] 在 '${this.authMode}' 模式下，检测到 ${this.initialIndices.length} 个认证源。`); |
|
|
if (this.initialIndices.length > 0) { |
|
|
this.logger.info(`[认证] 可用初始索引: [${this.initialIndices.join(', ')}]`); |
|
|
} |
|
|
} |
|
|
|
|
|
getAvailableIndices() { |
|
|
const runtimeIndices = Array.from(this.runtimeAuths.keys()); |
|
|
const allIndices = [...new Set([...this.initialIndices, ...runtimeIndices])].sort((a, b) => a - b); |
|
|
return allIndices; |
|
|
} |
|
|
|
|
|
|
|
|
getAccountDetails() { |
|
|
const allIndices = this.getAvailableIndices(); |
|
|
return allIndices.map(index => ({ |
|
|
index, |
|
|
source: this.runtimeAuths.has(index) ? 'temporary' : this.authMode |
|
|
})); |
|
|
} |
|
|
|
|
|
|
|
|
getFirstAvailableIndex() { |
|
|
const indices = this.getAvailableIndices(); |
|
|
return indices.length > 0 ? indices[0] : null; |
|
|
} |
|
|
|
|
|
getAuth(index) { |
|
|
if (!this.getAvailableIndices().includes(index)) { |
|
|
this.logger.error(`[认证] 请求了无效或不存在的认证索引: ${index}`); |
|
|
return null; |
|
|
} |
|
|
|
|
|
|
|
|
if (this.runtimeAuths.has(index)) { |
|
|
this.logger.info(`[认证] 使用索引 ${index} 的临时认证源。`); |
|
|
return this.runtimeAuths.get(index); |
|
|
} |
|
|
|
|
|
let jsonString; |
|
|
let sourceDescription; |
|
|
|
|
|
if (this.authMode === 'env') { |
|
|
jsonString = process.env[`AUTH_JSON_${index}`]; |
|
|
sourceDescription = `环境变量 AUTH_JSON_${index}`; |
|
|
} else { |
|
|
const authFilePath = path.join(__dirname, 'auth', `auth-${index}.json`); |
|
|
sourceDescription = `文件 ${authFilePath}`; |
|
|
if (!fs.existsSync(authFilePath)) { |
|
|
this.logger.error(`[认证] ${sourceDescription} 在读取时突然消失。`); |
|
|
return null; |
|
|
} |
|
|
try { |
|
|
jsonString = fs.readFileSync(authFilePath, 'utf-8'); |
|
|
} catch (e) { |
|
|
this.logger.error(`[认证] 读取 ${sourceDescription} 失败: ${e.message}`); |
|
|
return null; |
|
|
} |
|
|
} |
|
|
|
|
|
try { |
|
|
return JSON.parse(jsonString); |
|
|
} catch (e) { |
|
|
this.logger.error(`[认证] 解析来自 ${sourceDescription} 的JSON内容失败: ${e.message}`); |
|
|
return null; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
addAccount(index, authData) { |
|
|
if (typeof index !== 'number' || index <= 0) { |
|
|
return { success: false, message: "索引必须是一个正数。" }; |
|
|
} |
|
|
if (this.initialIndices.includes(index)) { |
|
|
return { success: false, message: `索引 ${index} 已作为永久账号存在。` }; |
|
|
} |
|
|
try { |
|
|
|
|
|
if (typeof authData !== 'object' || authData === null) { |
|
|
throw new Error("提供的数据不是一个有效的对象。"); |
|
|
} |
|
|
this.runtimeAuths.set(index, authData); |
|
|
this.logger.info(`[认证] 成功添加索引为 ${index} 的临时账号。`); |
|
|
return { success: true, message: `账号 ${index} 已临时添加。` }; |
|
|
} catch (e) { |
|
|
this.logger.error(`[认证] 添加临时账号 ${index} 失败: ${e.message}`); |
|
|
return { success: false, message: `添加账号失败: ${e.message}` }; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
removeAccount(index) { |
|
|
if (!this.runtimeAuths.has(index)) { |
|
|
return { success: false, message: `索引 ${index} 不是一个临时账号，无法移除。` }; |
|
|
} |
|
|
this.runtimeAuths.delete(index); |
|
|
this.logger.info(`[认证] 成功移除索引为 ${index} 的临时账号。`); |
|
|
return { success: true, message: `账号 ${index} 已移除。` }; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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(`[系统] 使用环境变量 CAMOUFOX_EXECUTABLE_PATH 指定的浏览器路径。`); |
|
|
} else { |
|
|
const platform = os.platform(); |
|
|
if (platform === 'win32') { |
|
|
this.browserExecutablePath = path.join(__dirname, 'camoufox', 'camoufox.exe'); |
|
|
this.logger.info(`[系统] 检测到操作系统: Windows. 将使用 'camoufox' 目录下的浏览器。`); |
|
|
} else if (platform === 'linux') { |
|
|
this.browserExecutablePath = path.join(__dirname, 'camoufox-linux', 'camoufox'); |
|
|
this.logger.info(`[系统] 检测到操作系统: Linux. 将使用 'camoufox-linux' 目录下的浏览器。`); |
|
|
} else { |
|
|
this.logger.error(`[系统] 不支持的操作系统: ${platform}.`); |
|
|
throw new Error(`不支持的操作系统: ${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(`🚀 [浏览器] 准备启动浏览器`); |
|
|
this.logger.info(` • 认证源: ${sourceDescription}`); |
|
|
this.logger.info(` • 浏览器路径: ${this.browserExecutablePath}`); |
|
|
this.logger.info('=================================================='); |
|
|
|
|
|
if (!fs.existsSync(this.browserExecutablePath)) { |
|
|
this.logger.error(`❌ [浏览器] 找不到浏览器可执行文件: ${this.browserExecutablePath}`); |
|
|
throw new Error(`找不到浏览器可执行文件路径: ${this.browserExecutablePath}`); |
|
|
} |
|
|
|
|
|
const storageStateObject = this.authSource.getAuth(authIndex); |
|
|
if (!storageStateObject) { |
|
|
this.logger.error(`❌ [浏览器] 无法获取或解析索引为 ${authIndex} 的认证信息。`); |
|
|
throw new Error(`获取或解析索引 ${authIndex} 的认证源失败。`); |
|
|
} |
|
|
|
|
|
if (storageStateObject.cookies && Array.isArray(storageStateObject.cookies)) { |
|
|
let fixedCount = 0; |
|
|
const validSameSiteValues = ['Lax', 'Strict', 'None']; |
|
|
storageStateObject.cookies.forEach(cookie => { |
|
|
if (!validSameSiteValues.includes(cookie.sameSite)) { |
|
|
this.logger.warn(`[认证] 发现无效的 sameSite 值: '${cookie.sameSite}'，正在自动修正为 'None'。`); |
|
|
cookie.sameSite = 'None'; |
|
|
fixedCount++; |
|
|
} |
|
|
}); |
|
|
if (fixedCount > 0) { |
|
|
this.logger.info(`[认证] 自动修正了 ${fixedCount} 个无效的 Cookie 'sameSite' 属性。`); |
|
|
} |
|
|
} |
|
|
|
|
|
let buildScriptContent; |
|
|
try { |
|
|
const scriptFilePath = path.join(__dirname, this.scriptFileName); |
|
|
if (fs.existsSync(scriptFilePath)) { |
|
|
buildScriptContent = fs.readFileSync(scriptFilePath, 'utf-8'); |
|
|
this.logger.info(`✅ [浏览器] 成功读取注入脚本 "${this.scriptFileName}"`); |
|
|
} else { |
|
|
this.logger.warn(`[浏览器] 未找到注入脚本 "${this.scriptFileName}"。将无注入继续运行。`); |
|
|
buildScriptContent = "console.log('dark-browser.js not found, running without injection.');"; |
|
|
} |
|
|
} catch (error) { |
|
|
this.logger.error(`❌ [浏览器] 无法读取注入脚本 "${this.scriptFileName}"！`); |
|
|
throw error; |
|
|
} |
|
|
|
|
|
try { |
|
|
this.browser = await firefox.launch({ |
|
|
headless: true, |
|
|
executablePath: this.browserExecutablePath, |
|
|
}); |
|
|
this.browser.on('disconnected', () => { |
|
|
this.logger.error('❌ [浏览器] 浏览器意外断开连接！服务器可能需要重启。'); |
|
|
this.browser = null; this.context = null; this.page = null; |
|
|
}); |
|
|
this.context = await this.browser.newContext({ |
|
|
storageState: storageStateObject, |
|
|
viewport: { width: 1280, height: 720 }, |
|
|
}); |
|
|
this.page = await this.context.newPage(); |
|
|
this.logger.info(`[浏览器] 正在加载账号 ${authIndex} 并访问目标网页...`); |
|
|
const targetUrl = 'https://aistudio.google.com/u/0/apps/bundled/blank?showPreview=true&showCode=true&showAssistant=true'; |
|
|
await this.page.goto(targetUrl, { timeout: 120000, waitUntil: 'networkidle' }); |
|
|
this.logger.info('[浏览器] 网页加载完成，正在注入客户端脚本...'); |
|
|
|
|
|
const editorContainerLocator = this.page.locator('div.monaco-editor').first(); |
|
|
|
|
|
this.logger.info('[浏览器] 等待编辑器出现，最长120秒...'); |
|
|
await editorContainerLocator.waitFor({ state: 'visible', timeout: 120000 }); |
|
|
this.logger.info('[浏览器] 编辑器已出现，准备粘贴脚本。'); |
|
|
|
|
|
this.logger.info('[浏览器] 等待5秒，之后将在页面下方执行一次模拟点击以确保页面激活...'); |
|
|
await this.page.waitForTimeout(5000); |
|
|
|
|
|
const viewport = this.page.viewportSize(); |
|
|
if (viewport) { |
|
|
const clickX = viewport.width / 2; |
|
|
const clickY = viewport.height - 120; |
|
|
this.logger.info(`[浏览器] 在页面底部中心位置 (x≈${Math.round(clickX)}, y=${clickY}) 执行点击。`); |
|
|
await this.page.mouse.click(clickX, clickY); |
|
|
} else { |
|
|
this.logger.warn('[浏览器] 无法获取视窗大小，跳过页面底部模拟点击。'); |
|
|
} |
|
|
|
|
|
await editorContainerLocator.click({ timeout: 120000 }); |
|
|
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('[浏览器] 脚本已粘贴。浏览器端初始化完成。'); |
|
|
|
|
|
|
|
|
this.currentAuthIndex = authIndex; |
|
|
this.logger.info('=================================================='); |
|
|
this.logger.info(`✅ [浏览器] 账号 ${authIndex} 初始化成功！`); |
|
|
this.logger.info('✅ [浏览器] 浏览器客户端已准备就绪。'); |
|
|
this.logger.info('=================================================='); |
|
|
} catch (error) { |
|
|
this.logger.error(`❌ [浏览器] 账号 ${authIndex} 初始化失败: ${error.message}`); |
|
|
if (this.browser) { |
|
|
await this.browser.close(); |
|
|
this.browser = null; |
|
|
} |
|
|
throw error; |
|
|
} |
|
|
} |
|
|
|
|
|
async closeBrowser() { |
|
|
if (this.browser) { |
|
|
this.logger.info('[浏览器] 正在关闭当前浏览器实例...'); |
|
|
await this.browser.close(); |
|
|
this.browser = null; this.context = null; this.page = null; |
|
|
this.logger.info('[浏览器] 浏览器已关闭。'); |
|
|
} |
|
|
} |
|
|
|
|
|
async switchAccount(newAuthIndex) { |
|
|
this.logger.info(`🔄 [浏览器] 开始账号切换: 从 ${this.currentAuthIndex} 到 ${newAuthIndex}`); |
|
|
await this.closeBrowser(); |
|
|
await this.launchBrowser(newAuthIndex); |
|
|
this.logger.info(`✅ [浏览器] 账号切换完成，当前账号: ${this.currentAuthIndex}`); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class LoggingService { |
|
|
constructor(serviceName = 'ProxyServer') { |
|
|
this.serviceName = serviceName; |
|
|
} |
|
|
|
|
|
_getFormattedTime() { |
|
|
|
|
|
return new Date().toLocaleTimeString('en-GB', { hour12: false }); |
|
|
} |
|
|
|
|
|
|
|
|
_formatMessage(level, message) { |
|
|
const time = this._getFormattedTime(); |
|
|
return `[${level}] ${time} [${this.serviceName}] - ${message}`; |
|
|
} |
|
|
|
|
|
|
|
|
info(message) { |
|
|
const time = this._getFormattedTime(); |
|
|
console.log(`${time} [${this.serviceName}] - ${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 = 1200000) { |
|
|
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('队列已关闭'); |
|
|
} |
|
|
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('队列超时')); |
|
|
} |
|
|
}, timeoutMs); |
|
|
resolver.timeoutId = timeoutId; |
|
|
}); |
|
|
} |
|
|
close() { |
|
|
this.closed = true; |
|
|
this.waitingResolvers.forEach(resolver => { |
|
|
clearTimeout(resolver.timeoutId); |
|
|
resolver.reject(new Error('队列已关闭')); |
|
|
}); |
|
|
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(`[服务器] 内部WebSocket客户端已连接 (来自: ${clientInfo.address})`); |
|
|
websocket.on('message', (data) => this._handleIncomingMessage(data.toString())); |
|
|
websocket.on('close', () => this._removeConnection(websocket)); |
|
|
websocket.on('error', (error) => this.logger.error(`[服务器] 内部WebSocket连接错误: ${error.message}`)); |
|
|
this.emit('connectionAdded', websocket); |
|
|
} |
|
|
_removeConnection(websocket) { |
|
|
this.connections.delete(websocket); |
|
|
this.logger.warn('[服务器] 内部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('[服务器] 收到无效消息：缺少request_id'); |
|
|
return; |
|
|
} |
|
|
const queue = this.messageQueues.get(requestId); |
|
|
if (queue) { |
|
|
this._routeMessage(parsedMessage, queue); |
|
|
} |
|
|
} catch (error) { |
|
|
this.logger.error('[服务器] 解析内部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(`[服务器] 未知的内部事件类型: ${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; |
|
|
} |
|
|
|
|
|
_getNextAuthIndex() { |
|
|
const available = this.authSource.getAvailableIndices(); |
|
|
if (available.length === 0) return null; |
|
|
if (available.length === 1) return available[0]; |
|
|
|
|
|
const currentIndexInArray = available.indexOf(this.currentAuthIndex); |
|
|
|
|
|
if (currentIndexInArray === -1) { |
|
|
this.logger.warn(`[认证] 当前索引 ${this.currentAuthIndex} 不在可用列表中，将切换到第一个可用索引。`); |
|
|
return available[0]; |
|
|
} |
|
|
|
|
|
const nextIndexInArray = (currentIndexInArray + 1) % available.length; |
|
|
return available[nextIndexInArray]; |
|
|
} |
|
|
|
|
|
async _switchToNextAuth() { |
|
|
if (this.isAuthSwitching) { |
|
|
this.logger.info('🔄 [认证] 正在切换账号，跳过重复切换'); |
|
|
return; |
|
|
} |
|
|
|
|
|
this.isAuthSwitching = true; |
|
|
const nextAuthIndex = this._getNextAuthIndex(); |
|
|
const totalAuthCount = this.authSource.getAvailableIndices().length; |
|
|
|
|
|
if (nextAuthIndex === null) { |
|
|
this.logger.error('🔴 [认证] 无法切换账号，因为没有可用的认证源！'); |
|
|
this.isAuthSwitching = false; |
|
|
throw new Error('没有可用的认证源可以切换。'); |
|
|
} |
|
|
|
|
|
this.logger.info('=================================================='); |
|
|
this.logger.info(`🔄 [认证] 开始账号切换流程`); |
|
|
this.logger.info(` • 失败次数: ${this.failureCount}/${this.config.failureThreshold > 0 ? this.config.failureThreshold : 'N/A'}`); |
|
|
this.logger.info(` • 当前账号索引: ${this.currentAuthIndex}`); |
|
|
this.logger.info(` • 目标账号索引: ${nextAuthIndex}`); |
|
|
this.logger.info(` • 可用账号总数: ${totalAuthCount}`); |
|
|
this.logger.info('=================================================='); |
|
|
|
|
|
try { |
|
|
await this.browserManager.switchAccount(nextAuthIndex); |
|
|
this.failureCount = 0; |
|
|
this.logger.info('=================================================='); |
|
|
this.logger.info(`✅ [认证] 成功切换到账号索引 ${this.currentAuthIndex}`); |
|
|
this.logger.info(`✅ [认证] 失败计数已重置为0`); |
|
|
this.logger.info('=================================================='); |
|
|
} catch (error) { |
|
|
this.logger.error('=================================================='); |
|
|
this.logger.error(`❌ [认证] 切换账号失败: ${error.message}`); |
|
|
this.logger.error('=================================================='); |
|
|
throw error; |
|
|
} finally { |
|
|
this.isAuthSwitching = false; |
|
|
} |
|
|
} |
|
|
|
|
|
_parseAndCorrectErrorDetails(errorDetails) { |
|
|
const correctedDetails = { ...errorDetails }; |
|
|
this.logger.debug(`[错误解析器] 原始错误详情: status=${correctedDetails.status}, message="${correctedDetails.message}"`); |
|
|
|
|
|
if (correctedDetails.message && typeof correctedDetails.message === 'string') { |
|
|
const regex = /(?:HTTP|status code)\s+(\d{3})/; |
|
|
const match = correctedDetails.message.match(regex); |
|
|
|
|
|
if (match && match[1]) { |
|
|
const parsedStatus = parseInt(match[1], 10); |
|
|
if (parsedStatus >= 400 && parsedStatus <= 599) { |
|
|
if (correctedDetails.status !== parsedStatus) { |
|
|
this.logger.warn(`[错误解析器] 修正了错误状态码！原始: ${correctedDetails.status}, 从消息中解析得到: ${parsedStatus}`); |
|
|
correctedDetails.status = parsedStatus; |
|
|
} else { |
|
|
this.logger.debug(`[错误解析器] 解析的状态码 (${parsedStatus}) 与原始状态码一致，无需修正。`); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
return correctedDetails; |
|
|
} |
|
|
|
|
|
async _handleRequestFailureAndSwitch(errorDetails, res) { |
|
|
|
|
|
if (this.config.debugMode) { |
|
|
this.logger.debug(`[认证][调试] 收到来自浏览器的完整错误详情:\n${JSON.stringify(errorDetails, null, 2)}`); |
|
|
} |
|
|
|
|
|
const correctedDetails = { ...errorDetails }; |
|
|
if (correctedDetails.message && typeof correctedDetails.message === 'string') { |
|
|
const regex = /(?:HTTP|status code)\s*(\d{3})|"code"\s*:\s*(\d{3})/; |
|
|
const match = correctedDetails.message.match(regex); |
|
|
const parsedStatusString = match ? (match[1] || match[2]) : null; |
|
|
|
|
|
if (parsedStatusString) { |
|
|
const parsedStatus = parseInt(parsedStatusString, 10); |
|
|
if (parsedStatus >= 400 && parsedStatus <= 599 && correctedDetails.status !== parsedStatus) { |
|
|
this.logger.warn(`[认证] 修正了错误状态码！原始: ${correctedDetails.status}, 从消息中解析得到: ${parsedStatus}`); |
|
|
correctedDetails.status = parsedStatus; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
const isImmediateSwitch = this.config.immediateSwitchStatusCodes.includes(correctedDetails.status); |
|
|
|
|
|
if (isImmediateSwitch) { |
|
|
this.logger.warn(`🔴 [认证] 收到状态码 ${correctedDetails.status} (已修正)，触发立即切换账号...`); |
|
|
if (res) this._sendErrorChunkToClient(res, `收到状态码 ${correctedDetails.status}，正在尝试切换账号...`); |
|
|
try { |
|
|
await this._switchToNextAuth(); |
|
|
if (res) this._sendErrorChunkToClient(res, `已切换到账号索引 ${this.currentAuthIndex}，请重试`); |
|
|
} catch (switchError) { |
|
|
this.logger.error(`🔴 [认证] 账号切换失败: ${switchError.message}`); |
|
|
if (res) this._sendErrorChunkToClient(res, `切换账号失败: ${switchError.message}`); |
|
|
} |
|
|
return; |
|
|
} |
|
|
|
|
|
if (this.config.failureThreshold > 0) { |
|
|
this.failureCount++; |
|
|
this.logger.warn(`⚠️ [认证] 请求失败 - 失败计数: ${this.failureCount}/${this.config.failureThreshold} (当前账号索引: ${this.currentAuthIndex}, 状态码: ${correctedDetails.status})`); |
|
|
if (this.failureCount >= this.config.failureThreshold) { |
|
|
this.logger.warn(`🔴 [认证] 达到失败阈值！准备切换账号...`); |
|
|
if (res) this._sendErrorChunkToClient(res, `连续失败${this.failureCount}次，正在尝试切换账号...`); |
|
|
try { |
|
|
await this._switchToNextAuth(); |
|
|
if (res) this._sendErrorChunkToClient(res, `已切换到账号索引 ${this.currentAuthIndex}，请重试`); |
|
|
} catch (switchError) { |
|
|
this.logger.error(`🔴 [认证] 账号切换失败: ${switchError.message}`); |
|
|
if (res) this._sendErrorChunkToClient(res, `切换账号失败: ${switchError.message}`); |
|
|
} |
|
|
} |
|
|
} else { |
|
|
this.logger.warn(`[认证] 请求失败 (状态码: ${correctedDetails.status})。基于计数的自动切换已禁用 (failureThreshold=0)`); |
|
|
} |
|
|
} |
|
|
|
|
|
_getModelFromRequest(req) { |
|
|
let body = req.body; |
|
|
|
|
|
if (Buffer.isBuffer(body)) { |
|
|
try { |
|
|
body = JSON.parse(body.toString('utf-8')); |
|
|
} catch (e) { body = {}; } |
|
|
} else if (typeof body === 'string') { |
|
|
try { |
|
|
body = JSON.parse(body); |
|
|
} catch (e) { body = {}; } |
|
|
} |
|
|
|
|
|
if (body && typeof body === 'object') { |
|
|
if (body.model) return body.model; |
|
|
if (body.generation_config && body.generation_config.model) return body.generation_config.model; |
|
|
} |
|
|
|
|
|
const match = req.path.match(/\/models\/([^/:]+)/); |
|
|
if (match && match[1]) { |
|
|
return match[1]; |
|
|
} |
|
|
return 'unknown_model'; |
|
|
} |
|
|
|
|
|
async processRequest(req, res) { |
|
|
|
|
|
|
|
|
if ((!this.config.apiKeys || this.config.apiKeys.length === 0) && req.query && req.query.hasOwnProperty('key')) { |
|
|
if (this.config.debugMode) { |
|
|
this.logger.debug(`[请求预处理] 服务器API密钥认证已禁用。检测到并移除了来自客户端的 'key' 查询参数 (值为: '${req.query.key}')。`); |
|
|
} |
|
|
delete req.query.key; |
|
|
} |
|
|
|
|
|
|
|
|
const modelName = this._getModelFromRequest(req); |
|
|
const currentAccount = this.currentAuthIndex; |
|
|
|
|
|
|
|
|
this.logger.info(`[请求] ${req.method} ${req.path} | 账号: ${currentAccount} | 模型: 🤖 ${modelName}`); |
|
|
|
|
|
|
|
|
this.serverSystem.stats.totalCalls++; |
|
|
if (this.serverSystem.stats.accountCalls[currentAccount]) { |
|
|
this.serverSystem.stats.accountCalls[currentAccount].total = (this.serverSystem.stats.accountCalls[currentAccount].total || 0) + 1; |
|
|
this.serverSystem.stats.accountCalls[currentAccount].models[modelName] = (this.serverSystem.stats.accountCalls[currentAccount].models[modelName] || 0) + 1; |
|
|
} else { |
|
|
this.serverSystem.stats.accountCalls[currentAccount] = { |
|
|
total: 1, |
|
|
models: { [modelName]: 1 } |
|
|
}; |
|
|
} |
|
|
|
|
|
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) { |
|
|
const proxyRequest = { |
|
|
path: req.path, |
|
|
method: req.method, |
|
|
headers: req.headers, |
|
|
query_params: req.query, |
|
|
request_id: requestId, |
|
|
streaming_mode: this.serverSystem.streamingMode |
|
|
}; |
|
|
|
|
|
|
|
|
if (req.method !== 'GET' && req.method !== 'HEAD') { |
|
|
let requestBodyString; |
|
|
if (typeof req.body === 'object' && req.body !== null) { |
|
|
requestBodyString = JSON.stringify(req.body); |
|
|
} else if (typeof req.body === 'string') { |
|
|
requestBodyString = req.body; |
|
|
} else if (Buffer.isBuffer(req.body)) { |
|
|
requestBodyString = req.body.toString('utf-8'); |
|
|
} else { |
|
|
requestBodyString = ''; |
|
|
} |
|
|
proxyRequest.body = requestBodyString; |
|
|
} |
|
|
|
|
|
return proxyRequest; |
|
|
} |
|
|
_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(`[请求] 已向客户端发送标准错误信号: ${errorMessage}`); |
|
|
} |
|
|
} |
|
|
|
|
|
_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'; |
|
|
} |
|
|
|
|
|
async _handlePseudoStreamResponse(proxyRequest, messageQueue, req, res) { |
|
|
const originalPath = req.path; |
|
|
const isStreamRequest = originalPath.includes(':stream'); |
|
|
|
|
|
this.logger.info(`[请求] 假流式处理流程启动，路径: "${originalPath}"，判定为: ${isStreamRequest ? '流式请求' : '非流式请求'}`); |
|
|
|
|
|
let connectionMaintainer = null; |
|
|
|
|
|
if (isStreamRequest) { |
|
|
res.status(200).set({ |
|
|
'Content-Type': 'text/event-stream', |
|
|
'Cache-Control': 'no-cache', |
|
|
'Connection': 'keep-alive' |
|
|
}); |
|
|
const keepAliveChunk = this._getKeepAliveChunk(req); |
|
|
connectionMaintainer = setInterval(() => { if (!res.writableEnded) res.write(keepAliveChunk); }, 2000); |
|
|
} |
|
|
|
|
|
try { |
|
|
let lastMessage, requestFailed = false; |
|
|
for (let attempt = 1; attempt <= this.maxRetries; attempt++) { |
|
|
this.logger.info(`[请求] 请求尝试 #${attempt}/${this.maxRetries}...`); |
|
|
this._forwardRequest(proxyRequest); |
|
|
lastMessage = await messageQueue.dequeue(); |
|
|
|
|
|
if (lastMessage.event_type === 'error' && lastMessage.status >= 400 && lastMessage.status <= 599) { |
|
|
const correctedMessage = this._parseAndCorrectErrorDetails(lastMessage); |
|
|
await this._handleRequestFailureAndSwitch(correctedMessage, isStreamRequest ? res : null); |
|
|
|
|
|
const errorText = `收到 ${correctedMessage.status} 错误。${attempt < this.maxRetries ? `将在 ${this.retryDelay / 1000}秒后重试...` : '已达到最大重试次数。'}`; |
|
|
this.logger.warn(`[请求] ${errorText}`); |
|
|
|
|
|
if (isStreamRequest) { |
|
|
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) { |
|
|
const finalError = this._parseAndCorrectErrorDetails(lastMessage); |
|
|
if (!res.headersSent) { |
|
|
this._sendErrorResponse(res, finalError.status, `请求失败: ${finalError.message}`); |
|
|
} else { |
|
|
this._sendErrorChunkToClient(res, `请求最终失败 (状态码: ${finalError.status}): ${finalError.message}`); |
|
|
} |
|
|
return; |
|
|
} |
|
|
|
|
|
if (this.failureCount > 0) { |
|
|
this.logger.info(`✅ [认证] 请求成功 - 失败计数已从 ${this.failureCount} 重置为 0`); |
|
|
} |
|
|
this.failureCount = 0; |
|
|
|
|
|
const dataMessage = await messageQueue.dequeue(); |
|
|
const endMessage = await messageQueue.dequeue(); |
|
|
if (endMessage.type !== 'STREAM_END') this.logger.warn('[请求] 未收到预期的流结束信号。'); |
|
|
|
|
|
if (isStreamRequest) { |
|
|
if (dataMessage.data) { |
|
|
res.write(`data: ${dataMessage.data}\n\n`); |
|
|
} |
|
|
res.write('data: [DONE]\n\n'); |
|
|
this.logger.info('[请求] 已将完整响应作为模拟SSE事件发送。'); |
|
|
} else { |
|
|
this.logger.info('[请求] 准备发送 application/json 响应。'); |
|
|
if (dataMessage.data) { |
|
|
try { |
|
|
const jsonData = JSON.parse(dataMessage.data); |
|
|
res.status(200).json(jsonData); |
|
|
} catch (e) { |
|
|
this.logger.error(`[请求] 无法将来自浏览器的响应解析为JSON: ${e.message}`); |
|
|
this._sendErrorResponse(res, 500, '代理内部错误：无法解析来自后端的响应。'); |
|
|
} |
|
|
} else { |
|
|
this._sendErrorResponse(res, 500, '代理内部错误：后端未返回有效数据。'); |
|
|
} |
|
|
} |
|
|
|
|
|
} catch (error) { |
|
|
this.logger.error(`[请求] 假流式处理期间发生意外错误: ${error.message}`); |
|
|
if (!res.headersSent) { |
|
|
this._handleRequestError(error, res); |
|
|
} else { |
|
|
this._sendErrorChunkToClient(res, `处理失败: ${error.message}`); |
|
|
} |
|
|
} finally { |
|
|
if (connectionMaintainer) clearInterval(connectionMaintainer); |
|
|
if (!res.writableEnded) res.end(); |
|
|
this.logger.info('[请求] 假流式响应处理结束。'); |
|
|
} |
|
|
} |
|
|
|
|
|
async _handleRealStreamResponse(proxyRequest, messageQueue, res) { |
|
|
let headerMessage, requestFailed = false; |
|
|
for (let attempt = 1; attempt <= this.maxRetries; attempt++) { |
|
|
this.logger.info(`[请求] 请求尝试 #${attempt}/${this.maxRetries}...`); |
|
|
this._forwardRequest(proxyRequest); |
|
|
headerMessage = await messageQueue.dequeue(); |
|
|
if (headerMessage.event_type === 'error' && headerMessage.status >= 400 && headerMessage.status <= 599) { |
|
|
|
|
|
const correctedMessage = this._parseAndCorrectErrorDetails(headerMessage); |
|
|
await this._handleRequestFailureAndSwitch(correctedMessage, null); |
|
|
this.logger.warn(`[请求] 收到 ${correctedMessage.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) { |
|
|
const finalError = this._parseAndCorrectErrorDetails(headerMessage); |
|
|
return this._sendErrorResponse(res, finalError.status, finalError.message); |
|
|
} |
|
|
if (this.failureCount > 0) { |
|
|
this.logger.info(`✅ [认证] 请求成功 - 失败计数已从 ${this.failureCount} 重置为 0`); |
|
|
} |
|
|
this.failureCount = 0; |
|
|
this._setResponseHeaders(res, headerMessage); |
|
|
this.logger.info('[请求] 已向客户端发送真实响应头，开始流式传输...'); |
|
|
try { |
|
|
while (true) { |
|
|
const dataMessage = await messageQueue.dequeue(30000); |
|
|
if (dataMessage.type === 'STREAM_END') { this.logger.info('[请求] 收到流结束信号。'); break; } |
|
|
if (dataMessage.data) res.write(dataMessage.data); |
|
|
} |
|
|
} catch (error) { |
|
|
if (error.message !== '队列超时') throw error; |
|
|
this.logger.warn('[请求] 真流式响应超时，可能流已正常结束。'); |
|
|
} finally { |
|
|
if (!res.writableEnded) res.end(); |
|
|
this.logger.info('[请求] 真流式响应连接已关闭。'); |
|
|
} |
|
|
} |
|
|
|
|
|
_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(`[请求] 请求处理错误 (头已发送): ${error.message}`); |
|
|
if (this.serverSystem.streamingMode === 'fake') this._sendErrorChunkToClient(res, `处理失败: ${error.message}`); |
|
|
if (!res.writableEnded) res.end(); |
|
|
} else { |
|
|
this.logger.error(`[请求] 请求处理错误: ${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.stats = { |
|
|
totalCalls: 0, |
|
|
accountCalls: {} |
|
|
}; |
|
|
|
|
|
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: 8889, host: '0.0.0.0', wsPort: 9998, streamingMode: 'real', |
|
|
failureThreshold: 0, |
|
|
maxRetries: 3, retryDelay: 2000, browserExecutablePath: null, |
|
|
apiKeys: [], |
|
|
immediateSwitchStatusCodes: [], |
|
|
initialAuthIndex: null, |
|
|
debugMode: false, |
|
|
}; |
|
|
|
|
|
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('[系统] 已从 config.json 加载配置。'); |
|
|
} |
|
|
} catch (error) { |
|
|
this.logger.warn(`[系统] 无法读取或解析 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(','); |
|
|
} |
|
|
if (process.env.DEBUG_MODE) { |
|
|
config.debugMode = process.env.DEBUG_MODE === 'true'; |
|
|
} |
|
|
if (process.env.INITIAL_AUTH_INDEX) { |
|
|
const envIndex = parseInt(process.env.INITIAL_AUTH_INDEX, 10); |
|
|
if (!isNaN(envIndex) && envIndex > 0) { |
|
|
config.initialAuthIndex = envIndex; |
|
|
} |
|
|
} |
|
|
|
|
|
let rawCodes = process.env.IMMEDIATE_SWITCH_STATUS_CODES; |
|
|
let codesSource = '环境变量'; |
|
|
|
|
|
if (!rawCodes && config.immediateSwitchStatusCodes && Array.isArray(config.immediateSwitchStatusCodes)) { |
|
|
rawCodes = config.immediateSwitchStatusCodes.join(','); |
|
|
codesSource = 'config.json 文件'; |
|
|
} |
|
|
|
|
|
if (rawCodes && typeof rawCodes === 'string') { |
|
|
config.immediateSwitchStatusCodes = rawCodes |
|
|
.split(',') |
|
|
.map(code => parseInt(String(code).trim(), 10)) |
|
|
.filter(code => !isNaN(code) && code >= 400 && code <= 599); |
|
|
if (config.immediateSwitchStatusCodes.length > 0) { |
|
|
this.logger.info(`[系统] 已从 ${codesSource} 加载“立即切换状态码”。`); |
|
|
} |
|
|
} else { |
|
|
config.immediateSwitchStatusCodes = []; |
|
|
} |
|
|
|
|
|
if (Array.isArray(config.apiKeys)) { |
|
|
config.apiKeys = config.apiKeys.map(k => String(k).trim()).filter(k => k); |
|
|
} else { |
|
|
config.apiKeys = []; |
|
|
} |
|
|
|
|
|
this.config = config; |
|
|
this.logger.info('================ [ 生效配置 ] ================'); |
|
|
this.logger.info(` HTTP 服务端口: ${this.config.httpPort}`); |
|
|
this.logger.info(` 监听地址: ${this.config.host}`); |
|
|
this.logger.info(` 流式模式: ${this.config.streamingMode}`); |
|
|
this.logger.info(` 调试模式: ${this.config.debugMode ? '已开启' : '已关闭'}`); |
|
|
if (this.config.initialAuthIndex) { |
|
|
this.logger.info(` 指定初始认证索引: ${this.config.initialAuthIndex}`); |
|
|
} |
|
|
this.logger.info(` 失败计数切换: ${this.config.failureThreshold > 0 ? `连续 ${this.config.failureThreshold} 次失败后切换` : '已禁用'}`); |
|
|
this.logger.info(` 立即切换状态码: ${this.config.immediateSwitchStatusCodes.length > 0 ? this.config.immediateSwitchStatusCodes.join(', ') : '已禁用'}`); |
|
|
this.logger.info(` 单次请求最大重试: ${this.config.maxRetries}次`); |
|
|
this.logger.info(` 重试间隔: ${this.config.retryDelay}ms`); |
|
|
if (this.config.apiKeys && this.config.apiKeys.length > 0) { |
|
|
this.logger.info(` API 密钥认证: 已启用 (${this.config.apiKeys.length} 个密钥)`); |
|
|
} else { |
|
|
this.logger.info(` API 密钥认证: 已禁用`); |
|
|
} |
|
|
this.logger.info('============================================================='); |
|
|
} |
|
|
|
|
|
async start() { |
|
|
try { |
|
|
|
|
|
this.authSource.getAvailableIndices().forEach(index => { |
|
|
this.stats.accountCalls[index] = { total: 0, models: {} }; |
|
|
}); |
|
|
|
|
|
let startupIndex = this.authSource.getFirstAvailableIndex(); |
|
|
const suggestedIndex = this.config.initialAuthIndex; |
|
|
|
|
|
if (suggestedIndex) { |
|
|
if (this.authSource.getAvailableIndices().includes(suggestedIndex)) { |
|
|
this.logger.info(`[系统] 使用配置中指定的有效启动索引: ${suggestedIndex}`); |
|
|
startupIndex = suggestedIndex; |
|
|
} else { |
|
|
this.logger.warn(`[系统] 配置中指定的启动索引 ${suggestedIndex} 无效或不存在，将使用第一个可用索引: ${startupIndex}`); |
|
|
} |
|
|
} else { |
|
|
this.logger.info(`[系统] 未指定启动索引，将自动使用第一个可用索引: ${startupIndex}`); |
|
|
} |
|
|
|
|
|
await this.browserManager.launchBrowser(startupIndex); |
|
|
await this._startHttpServer(); |
|
|
await this._startWebSocketServer(); |
|
|
this.logger.info(`[系统] 代理服务器系统启动完成。`); |
|
|
this.emit('started'); |
|
|
} catch (error) { |
|
|
this.logger.error(`[系统] 启动失败: ${error.message}`); |
|
|
this.emit('error', error); |
|
|
process.exit(1); |
|
|
} |
|
|
} |
|
|
|
|
|
_createDebugLogMiddleware() { |
|
|
return (req, res, next) => { |
|
|
if (!this.config.debugMode) { |
|
|
return next(); |
|
|
} |
|
|
|
|
|
const requestId = this.requestHandler._generateRequestId(); |
|
|
const log = this.logger.info.bind(this.logger); |
|
|
|
|
|
log(`\n\n--- [调试] 开始处理入站请求 (${requestId}) ---`); |
|
|
log(`[调试][${requestId}] 客户端 IP: ${req.ip}`); |
|
|
log(`[调试][${requestId}] 方法: ${req.method}`); |
|
|
log(`[调试][${requestId}] URL: ${req.originalUrl}`); |
|
|
log(`[调试][${requestId}] 请求头: ${JSON.stringify(req.headers, null, 2)}`); |
|
|
|
|
|
let bodyContent = '无或空'; |
|
|
if (req.body) { |
|
|
if (Buffer.isBuffer(req.body) && req.body.length > 0) { |
|
|
try { |
|
|
bodyContent = JSON.stringify(JSON.parse(req.body.toString('utf-8')), null, 2); |
|
|
} catch (e) { |
|
|
bodyContent = `[无法解析为JSON的Buffer, 大小: ${req.body.length} 字节]`; |
|
|
} |
|
|
} else if (typeof req.body === 'object' && Object.keys(req.body).length > 0) { |
|
|
bodyContent = JSON.stringify(req.body, null, 2); |
|
|
} |
|
|
} |
|
|
|
|
|
log(`[调试][${requestId}] 请求体:\n${bodyContent}`); |
|
|
log(`--- [调试] 结束处理入站请求 (${requestId}) ---\n\n`); |
|
|
|
|
|
next(); |
|
|
}; |
|
|
} |
|
|
|
|
|
|
|
|
_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; |
|
|
const xGoogApiKey = headers['x-goog-api-key'] || headers['x_goog_api_key']; |
|
|
const xApiKey = headers['x-api-key'] || headers['x_api_key']; |
|
|
const authHeader = headers.authorization; |
|
|
|
|
|
if (xGoogApiKey) { |
|
|
clientKey = xGoogApiKey; |
|
|
keySource = 'x-goog-api-key 请求头'; |
|
|
} else if (authHeader && authHeader.startsWith('Bearer ')) { |
|
|
clientKey = authHeader.substring(7); |
|
|
keySource = 'Authorization 请求头'; |
|
|
} else if (xApiKey) { |
|
|
clientKey = xApiKey; |
|
|
keySource = 'X-API-Key 请求头'; |
|
|
} else if (req.query.key) { |
|
|
clientKey = req.query.key; |
|
|
keySource = '查询参数'; |
|
|
} |
|
|
|
|
|
if (clientKey) { |
|
|
if (serverApiKeys.includes(clientKey)) { |
|
|
if (this.config.debugMode) { |
|
|
this.logger.debug(`[认证][调试] 在 '${keySource}' 中找到API密钥，验证通过。`); |
|
|
} |
|
|
if (keySource === '查询参数') { |
|
|
delete req.query.key; |
|
|
} |
|
|
return next(); |
|
|
} else { |
|
|
if (this.config.debugMode) { |
|
|
this.logger.warn(`[认证][调试] 拒绝请求: 无效的API密钥。IP: ${req.ip}, 路径: ${req.path}`); |
|
|
this.logger.debug(`[认证][调试] 来源: ${keySource}`); |
|
|
this.logger.debug(`[认证][调试] 提供的错误密钥: '${clientKey}'`); |
|
|
this.logger.debug(`[认证][调试] 已加载的有效密钥: [${serverApiKeys.join(', ')}]`); |
|
|
} else { |
|
|
this.logger.warn(`[认证] 拒绝请求: 无效的API密钥。IP: ${req.ip}, 路径: ${req.path}`); |
|
|
} |
|
|
return res.status(401).json({ error: { message: "提供了无效的API密钥。" } }); |
|
|
} |
|
|
} |
|
|
|
|
|
this.logger.warn(`[认证] 拒绝受保护的请求: 缺少API密钥。IP: ${req.ip}, 路径: ${req.path}`); |
|
|
|
|
|
if (this.config.debugMode) { |
|
|
this.logger.debug(`[认证][调试] 未在任何标准位置找到API密钥。`); |
|
|
this.logger.debug(`[认证][调试] 搜索的请求头: ${JSON.stringify(headers, null, 2)}`); |
|
|
this.logger.debug(`[认证][调试] 搜索的查询参数: ${JSON.stringify(req.query)}`); |
|
|
this.logger.debug(`[认证][调试] 已加载的有效密钥: [${serverApiKeys.join(', ')}]`); |
|
|
} |
|
|
|
|
|
return res.status(401).json({ error: { message: "访问被拒绝。未在请求头或查询参数中找到有效的API密钥。" } }); |
|
|
}; |
|
|
} |
|
|
|
|
|
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(`[系统] HTTP服务器已在 http://${this.config.host}:${this.config.httpPort} 上监听`); |
|
|
this.logger.info(`[系统] 仪表盘可在 http://${this.config.host}:${this.config.httpPort}/dashboard 访问`); |
|
|
resolve(); |
|
|
}); |
|
|
}); |
|
|
} |
|
|
|
|
|
_createExpressApp() { |
|
|
const app = express(); |
|
|
app.use(express.json({ limit: '100mb' })); |
|
|
app.use(express.raw({ type: '*/*', limit: '100mb' })); |
|
|
app.use((req, res, next) => { |
|
|
if (req.is('application/json') && typeof req.body === 'object' && !Buffer.isBuffer(req.body)) { |
|
|
|
|
|
} else if (Buffer.isBuffer(req.body)) { |
|
|
const bodyStr = req.body.toString('utf-8'); |
|
|
if (bodyStr) { |
|
|
try { |
|
|
req.body = JSON.parse(bodyStr); |
|
|
} catch (e) { |
|
|
|
|
|
} |
|
|
} |
|
|
} |
|
|
next(); |
|
|
}); |
|
|
|
|
|
app.use(this._createDebugLogMiddleware()); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
app.get('/', (req, res) => { |
|
|
res.redirect('/dashboard'); |
|
|
}); |
|
|
|
|
|
|
|
|
app.get('/dashboard', (req, res) => { |
|
|
res.send(this._getDashboardHtml()); |
|
|
}); |
|
|
|
|
|
|
|
|
app.post('/dashboard/verify-key', (req, res) => { |
|
|
const { key } = req.body; |
|
|
const serverApiKeys = this.config.apiKeys; |
|
|
|
|
|
if (!serverApiKeys || serverApiKeys.length === 0) { |
|
|
this.logger.info('[管理] 服务器未配置API密钥，自动授予仪表盘访问权限。'); |
|
|
return res.json({ success: true }); |
|
|
} |
|
|
|
|
|
if (key && serverApiKeys.includes(key)) { |
|
|
this.logger.info('[管理] 仪表盘API密钥验证成功。'); |
|
|
return res.json({ success: true }); |
|
|
} |
|
|
|
|
|
this.logger.warn(`[管理] 仪表盘API密钥验证失败。`); |
|
|
res.status(401).json({ success: false, message: '无效的API密钥。' }); |
|
|
}); |
|
|
|
|
|
|
|
|
const dashboardApiAuth = (req, res, next) => { |
|
|
const serverApiKeys = this.config.apiKeys; |
|
|
if (!serverApiKeys || serverApiKeys.length === 0) { |
|
|
return next(); |
|
|
} |
|
|
|
|
|
const clientKey = req.headers['x-dashboard-auth']; |
|
|
if (clientKey && serverApiKeys.includes(clientKey)) { |
|
|
return next(); |
|
|
} |
|
|
|
|
|
this.logger.warn(`[管理] 拒绝未经授权的仪表盘API请求。IP: ${req.ip}, 路径: ${req.path}`); |
|
|
res.status(401).json({ error: { message: 'Unauthorized dashboard access' } }); |
|
|
}; |
|
|
|
|
|
const dashboardApiRouter = express.Router(); |
|
|
dashboardApiRouter.use(dashboardApiAuth); |
|
|
|
|
|
dashboardApiRouter.get('/data', (req, res) => { |
|
|
res.json({ |
|
|
status: { |
|
|
uptime: process.uptime(), |
|
|
streamingMode: this.streamingMode, |
|
|
debugMode: this.config.debugMode, |
|
|
authMode: this.authSource.authMode, |
|
|
apiKeyAuth: (this.config.apiKeys && this.config.apiKeys.length > 0) ? '已启用' : '已禁用', |
|
|
isAuthSwitching: this.requestHandler.isAuthSwitching, |
|
|
browserConnected: !!this.browserManager.browser, |
|
|
internalWsClients: this.connectionRegistry.connections.size |
|
|
}, |
|
|
auth: { |
|
|
currentAuthIndex: this.requestHandler.currentAuthIndex, |
|
|
accounts: this.authSource.getAccountDetails(), |
|
|
failureCount: this.requestHandler.failureCount, |
|
|
}, |
|
|
stats: this.stats, |
|
|
config: this.config |
|
|
}); |
|
|
}); |
|
|
|
|
|
dashboardApiRouter.post('/config', (req, res) => { |
|
|
const newConfig = req.body; |
|
|
try { |
|
|
if (newConfig.hasOwnProperty('streamingMode') && ['real', 'fake'].includes(newConfig.streamingMode)) { |
|
|
this.config.streamingMode = newConfig.streamingMode; |
|
|
this.streamingMode = newConfig.streamingMode; |
|
|
this.requestHandler.serverSystem.streamingMode = newConfig.streamingMode; |
|
|
} |
|
|
if (newConfig.hasOwnProperty('debugMode') && typeof newConfig.debugMode === 'boolean') { |
|
|
this.config.debugMode = newConfig.debugMode; |
|
|
} |
|
|
if (newConfig.hasOwnProperty('failureThreshold')) { |
|
|
this.config.failureThreshold = parseInt(newConfig.failureThreshold, 10) || 0; |
|
|
} |
|
|
if (newConfig.hasOwnProperty('maxRetries')) { |
|
|
const retries = parseInt(newConfig.maxRetries, 10); |
|
|
this.config.maxRetries = retries >= 0 ? retries : 3; |
|
|
this.requestHandler.maxRetries = this.config.maxRetries; |
|
|
} |
|
|
if (newConfig.hasOwnProperty('retryDelay')) { |
|
|
this.config.retryDelay = parseInt(newConfig.retryDelay, 10) || 2000; |
|
|
this.requestHandler.retryDelay = this.config.retryDelay; |
|
|
} |
|
|
if (newConfig.hasOwnProperty('immediateSwitchStatusCodes')) { |
|
|
if (Array.isArray(newConfig.immediateSwitchStatusCodes)) { |
|
|
this.config.immediateSwitchStatusCodes = newConfig.immediateSwitchStatusCodes |
|
|
.map(c => parseInt(c, 10)) |
|
|
.filter(c => !isNaN(c)); |
|
|
} |
|
|
} |
|
|
this.logger.info('[管理] 配置已通过仪表盘动态更新。'); |
|
|
res.status(200).json({ success: true, message: '配置已临时更新。' }); |
|
|
} catch (error) { |
|
|
this.logger.error(`[管理] 更新配置失败: ${error.message}`); |
|
|
res.status(500).json({ success: false, message: error.message }); |
|
|
} |
|
|
}); |
|
|
|
|
|
dashboardApiRouter.post('/accounts', (req, res) => { |
|
|
const { index, authData } = req.body; |
|
|
if (!index || !authData) { |
|
|
return res.status(400).json({ success: false, message: "必须提供索引和认证数据。" }); |
|
|
} |
|
|
|
|
|
let parsedData; |
|
|
try { |
|
|
parsedData = (typeof authData === 'string') ? JSON.parse(authData) : authData; |
|
|
} catch (e) { |
|
|
return res.status(400).json({ success: false, message: "认证数据的JSON格式无效。" }); |
|
|
} |
|
|
|
|
|
const result = this.authSource.addAccount(parseInt(index, 10), parsedData); |
|
|
if (result.success) { |
|
|
if (!this.stats.accountCalls.hasOwnProperty(index)) { |
|
|
this.stats.accountCalls[index] = { total: 0, models: {} }; |
|
|
} |
|
|
} |
|
|
res.status(result.success ? 200 : 400).json(result); |
|
|
}); |
|
|
|
|
|
dashboardApiRouter.delete('/accounts/:index', (req, res) => { |
|
|
const index = parseInt(req.params.index, 10); |
|
|
const result = this.authSource.removeAccount(index); |
|
|
res.status(result.success ? 200 : 400).json(result); |
|
|
}); |
|
|
|
|
|
|
|
|
app.use('/dashboard', dashboardApiRouter); |
|
|
|
|
|
|
|
|
app.post('/switch', dashboardApiAuth, async (req, res) => { |
|
|
this.logger.info('[管理] 接到 /switch 请求，手动触发账号切换。'); |
|
|
if (this.requestHandler.isAuthSwitching) { |
|
|
const msg = '账号切换已在进行中，请稍后。'; |
|
|
this.logger.warn(`[管理] /switch 请求被拒绝: ${msg}`); |
|
|
return res.status(429).send(msg); |
|
|
} |
|
|
const oldIndex = this.requestHandler.currentAuthIndex; |
|
|
try { |
|
|
await this.requestHandler._switchToNextAuth(); |
|
|
const newIndex = this.requestHandler.currentAuthIndex; |
|
|
const message = `成功将账号从索引 ${oldIndex} 切换到 ${newIndex}。`; |
|
|
this.logger.info(`[管理] 手动切换成功。 ${message}`); |
|
|
res.status(200).send(message); |
|
|
} catch (error) { |
|
|
const errorMessage = `切换账号失败: ${error.message}`; |
|
|
this.logger.error(`[管理] 手动切换失败。错误: ${errorMessage}`); |
|
|
res.status(500).send(errorMessage); |
|
|
} |
|
|
}); |
|
|
|
|
|
app.get('/health', (req, res) => { |
|
|
res.status(200).json({ |
|
|
status: 'healthy', |
|
|
uptime: process.uptime(), |
|
|
config: { |
|
|
streamingMode: this.streamingMode, |
|
|
debugMode: this.config.debugMode, |
|
|
failureThreshold: this.config.failureThreshold, |
|
|
immediateSwitchStatusCodes: this.config.immediateSwitchStatusCodes, |
|
|
maxRetries: this.config.maxRetries, |
|
|
authMode: this.authSource.authMode, |
|
|
apiKeyAuth: (this.config.apiKeys && this.config.apiKeys.length > 0) ? '已启用' : '已禁用', |
|
|
}, |
|
|
auth: { |
|
|
currentAuthIndex: this.requestHandler.currentAuthIndex, |
|
|
availableIndices: this.authSource.getAvailableIndices(), |
|
|
totalAuthSources: this.authSource.getAvailableIndices().length, |
|
|
failureCount: this.requestHandler.failureCount, |
|
|
isAuthSwitching: this.requestHandler.isAuthSwitching, |
|
|
}, |
|
|
stats: this.stats, |
|
|
browser: { |
|
|
connected: !!this.browserManager.browser, |
|
|
}, |
|
|
websocket: { |
|
|
internalClients: this.connectionRegistry.connections.size |
|
|
} |
|
|
}); |
|
|
}); |
|
|
|
|
|
|
|
|
app.use(this._createAuthMiddleware()); |
|
|
app.all(/(.*)/, (req, res) => { |
|
|
|
|
|
if (req.path === '/' || req.path === '/favicon.ico' || req.path.startsWith('/dashboard')) { |
|
|
return res.status(204).send(); |
|
|
} |
|
|
this.requestHandler.processRequest(req, res); |
|
|
}); |
|
|
|
|
|
return app; |
|
|
} |
|
|
|
|
|
_getDashboardHtml() { |
|
|
return ` |
|
|
<!DOCTYPE html> |
|
|
<html lang="zh-CN"> |
|
|
<head> |
|
|
<meta charset="UTF-8"> |
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0"> |
|
|
<title>服务器仪表盘</title> |
|
|
<style> |
|
|
:root { |
|
|
--pico-font-size: 16px; |
|
|
--pico-background-color: #11191f; |
|
|
--pico-color: #dce3e9; |
|
|
--pico-card-background-color: #1a242c; |
|
|
--pico-card-border-color: #2b3a47; |
|
|
--pico-primary: #3d8bfd; |
|
|
--pico-primary-hover: #529bff; |
|
|
--pico-primary-focus: rgba(61, 139, 253, 0.25); |
|
|
--pico-primary-inverse: #fff; |
|
|
--pico-form-element-background-color: #1a242c; |
|
|
--pico-form-element-border-color: #2b3a47; |
|
|
--pico-form-element-focus-color: var(--pico-primary); |
|
|
--pico-h1-color: #fff; |
|
|
--pico-h2-color: #f1f1f1; |
|
|
--pico-muted-color: #7a8c99; |
|
|
--pico-border-radius: 0.5rem; |
|
|
--info-color: #17a2b8; /* 天蓝色，用于状态文本 */ |
|
|
} |
|
|
body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"; margin: 0; padding: 2rem; background-color: var(--pico-background-color); color: var(--pico-color); } |
|
|
main.container { max-width: 1200px; margin: 0 auto; padding-top: 30px; display: none; /* Initially hidden */ } |
|
|
.grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(350px, 1fr)); gap: 1.5rem; } |
|
|
article { border: 1px solid var(--pico-card-border-color); border-radius: var(--pico-border-radius); padding: 1.5rem; background: var(--pico-card-background-color); } |
|
|
h1, h2 { margin-top: 0; color: var(--pico-h1-color); } |
|
|
h2 { border-bottom: 1px solid var(--pico-card-border-color); padding-bottom: 0.5rem; margin-bottom: 1rem; color: var(--pico-h2-color); } |
|
|
.status-grid { display: grid; grid-template-columns: auto 1fr; gap: 0.5rem 1rem; align-items: center;} |
|
|
.status-grid strong { color: var(--pico-color); white-space: nowrap;} |
|
|
.status-grid span { color: var(--pico-muted-color); text-align: right; } |
|
|
.status-text-info { color: var(--info-color); font-weight: bold; } |
|
|
.status-text-red { color: #dc3545; font-weight: bold; } |
|
|
.status-text-yellow { color: #ffc107; font-weight: bold; } |
|
|
.status-text-gray { color: var(--pico-muted-color); font-weight: bold; } |
|
|
.tag { display: inline-block; padding: 0.25em 0.6em; font-size: 0.75em; font-weight: 700; line-height: 1; text-align: center; white-space: nowrap; vertical-align: baseline; border-radius: 0.35rem; color: #fff; } |
|
|
.tag-info { background-color: #17a2b8; } |
|
|
.tag-blue { background-color: #007bff; } |
|
|
.tag-yellow { color: #212529; background-color: #ffc107; } |
|
|
ul { list-style: none; padding: 0; margin: 0; } |
|
|
.scrollable-list { max-height: 220px; overflow-y: auto; padding-right: 5px; border: 1px solid var(--pico-form-element-border-color); border-radius: 0.25rem; padding: 0.5rem;} |
|
|
.account-list li { display: flex; justify-content: space-between; align-items: center; padding: 0.5rem; border-radius: 0.25rem; } |
|
|
.account-list li:nth-child(odd) { background-color: rgba(255,255,255,0.03); } |
|
|
.account-list .current { font-weight: bold; color: var(--pico-primary); } |
|
|
details { width: 100%; border-bottom: 1px solid var(--pico-form-element-border-color); } |
|
|
details:last-child { border-bottom: none; } |
|
|
details summary { cursor: pointer; display: flex; justify-content: space-between; align-items: center; padding: 0.5rem 0.2rem; list-style: none; } |
|
|
details summary::-webkit-details-marker { display: none; } |
|
|
details summary:hover { background-color: rgba(255,255,255,0.05); } |
|
|
.model-stats-list { padding: 0.5rem 0 0.5rem 1.5rem; font-size: 0.9em; background-color: rgba(0,0,0,0.1); } |
|
|
.model-stats-list li { display: flex; justify-content: space-between; padding: 0.2rem; } |
|
|
button, input[type="text"], input[type="number"] { background-color: var(--pico-form-element-background-color); border: 1px solid var(--pico-form-element-border-color); color: var(--pico-color); padding: 0.5rem 1rem; border-radius: var(--pico-border-radius); } |
|
|
button { cursor: pointer; background-color: var(--pico-primary); border-color: var(--pico-primary); color: var(--pico-primary-inverse); } |
|
|
button:hover { background-color: var(--pico-primary-hover); } |
|
|
.btn-danger { background-color: #dc3545; border-color: #dc3545; } |
|
|
.btn-sm { font-size: 0.8em; padding: 0.2rem 0.5rem; } |
|
|
.top-banner { position: fixed; top: 0; right: 0; background-color: #ffc107; color: #212529; padding: 5px 15px; font-size: 0.9em; z-index: 1001; border-bottom-left-radius: 0.5rem; } |
|
|
.toast { position: fixed; bottom: 20px; right: 20px; background-color: var(--pico-primary); color: white; padding: 15px; border-radius: 5px; z-index: 1000; opacity: 0; transition: opacity 0.5s; } |
|
|
.toast.show { opacity: 1; } |
|
|
.toast.error { background-color: #dc3545; } |
|
|
form label { display: block; margin-bottom: 0.5rem; } |
|
|
form input { width: 100%; box-sizing: border-box; } |
|
|
.form-group { margin-bottom: 1rem; } |
|
|
.switch-field { display: flex; overflow: hidden; } |
|
|
.switch-field input { position: absolute !important; clip: rect(0, 0, 0, 0); height: 1px; width: 1px; border: 0; overflow: hidden; } |
|
|
.switch-field label { background-color: var(--pico-form-element-background-color); color: var(--pico-muted-color); font-size: 14px; line-height: 1; text-align: center; padding: 8px 16px; margin-right: -1px; border: 1px solid var(--pico-form-element-border-color); transition: all 0.1s ease-in-out; width: 50%; } |
|
|
.switch-field label:hover { cursor: pointer; } |
|
|
.switch-field input:checked + label { background-color: var(--pico-primary); color: var(--pico-primary-inverse); box-shadow: none; } |
|
|
.switch-field label:first-of-type { border-radius: 4px 0 0 4px; } |
|
|
.switch-field label:last-of-type { border-radius: 0 4px 4px 0; } |
|
|
</style> |
|
|
</head> |
|
|
<body data-theme="dark"> |
|
|
<div class="top-banner">注意: 此面板中添加的账号和修改的变量均是临时的，重启后会丢失</div> |
|
|
<main class="container"> |
|
|
<h1>🐢 服务器仪表盘</h1> |
|
|
<div class="grid"> |
|
|
<article> |
|
|
<h2>服务器状态</h2> |
|
|
<div class="status-grid"> |
|
|
<strong>运行时间:</strong> <span id="uptime">--</span> |
|
|
<strong>浏览器:</strong> <span id="browserConnected">--</span> |
|
|
<strong>认证模式:</strong> <span id="authMode">--</span> |
|
|
<strong>API密钥认证:</strong> <span id="apiKeyAuth">--</span> |
|
|
<strong>调试模式:</strong> <span id="debugMode">--</span> |
|
|
<strong>API总调用次数:</strong> <span id="totalCalls">0</span> |
|
|
</div> |
|
|
</article> |
|
|
<article> |
|
|
<h2>调用统计</h2> |
|
|
<div id="accountCalls" class="scrollable-list"></div> |
|
|
</article> |
|
|
|
|
|
<article> |
|
|
<h2>账号管理</h2> |
|
|
<div style="display: flex; gap: 1rem; margin-bottom: 1rem;"> |
|
|
<button id="switchAccountBtn">切换到下一个账号</button> |
|
|
<button id="addAccountBtn">添加临时账号</button> |
|
|
</div> |
|
|
<h3>账号池</h3> |
|
|
<div id="accountPool" class="scrollable-list"></div> |
|
|
</article> |
|
|
|
|
|
<article> |
|
|
<h2>实时配置</h2> |
|
|
<form id="configForm"> |
|
|
<div class="form-group"> |
|
|
<label>流式模式</label> |
|
|
<div class="switch-field"> |
|
|
<input type="radio" id="streamingMode_fake" name="streamingMode" value="fake" /> |
|
|
<label for="streamingMode_fake">Fake</label> |
|
|
<input type="radio" id="streamingMode_real" name="streamingMode" value="real" checked/> |
|
|
<label for="streamingMode_real">Real</label> |
|
|
</div> |
|
|
</div> |
|
|
|
|
|
<div class="form-group"> |
|
|
<label for="configFailureThreshold">几次失败后切换账号 (0为禁用)</label> |
|
|
<input type="number" id="configFailureThreshold" name="failureThreshold"> |
|
|
</div> |
|
|
|
|
|
<div class="form-group"> |
|
|
<label for="configMaxRetries">单次请求内部重试次数</label> |
|
|
<input type="number" id="configMaxRetries" name="maxRetries"> |
|
|
</div> |
|
|
|
|
|
<div class="form-group"> |
|
|
<label for="configRetryDelay">重试间隔 (毫秒)</label> |
|
|
<input type="number" id="configRetryDelay" name="retryDelay"> |
|
|
</div> |
|
|
|
|
|
<div class="form-group"> |
|
|
<label for="configImmediateSwitchStatusCodes">立即切换的状态码 (逗号分隔)</label> |
|
|
<input type="text" id="configImmediateSwitchStatusCodes" name="immediateSwitchStatusCodes"> |
|
|
</div> |
|
|
|
|
|
<button type="submit">应用临时更改</button> |
|
|
</form> |
|
|
</article> |
|
|
</div> |
|
|
</main> |
|
|
<div id="toast" class="toast"></div> |
|
|
<script> |
|
|
document.addEventListener('DOMContentLoaded', () => { |
|
|
const API_KEY_SESSION_STORAGE = 'dashboard_api_key'; |
|
|
const API_BASE = '/dashboard'; |
|
|
|
|
|
// DOM Elements |
|
|
const mainContainer = document.querySelector('main.container'); |
|
|
const uptimeEl = document.getElementById('uptime'); |
|
|
const debugModeEl = document.getElementById('debugMode'); |
|
|
const browserConnectedEl = document.getElementById('browserConnected'); |
|
|
const authModeEl = document.getElementById('authMode'); |
|
|
const apiKeyAuthEl = document.getElementById('apiKeyAuth'); |
|
|
const totalCallsEl = document.getElementById('totalCalls'); |
|
|
const accountCallsEl = document.getElementById('accountCalls'); |
|
|
const accountPoolEl = document.getElementById('accountPool'); |
|
|
const switchAccountBtn = document.getElementById('switchAccountBtn'); |
|
|
const addAccountBtn = document.getElementById('addAccountBtn'); |
|
|
const configForm = document.getElementById('configForm'); |
|
|
const toastEl = document.getElementById('toast'); |
|
|
|
|
|
function getAuthHeaders(hasBody = false) { |
|
|
const headers = { |
|
|
'X-Dashboard-Auth': sessionStorage.getItem(API_KEY_SESSION_STORAGE) || '' |
|
|
}; |
|
|
if (hasBody) { |
|
|
headers['Content-Type'] = 'application/json'; |
|
|
} |
|
|
return headers; |
|
|
} |
|
|
|
|
|
function showToast(message, isError = false) { |
|
|
toastEl.textContent = message; |
|
|
toastEl.className = isError ? 'toast show error' : 'toast show'; |
|
|
setTimeout(() => { toastEl.className = 'toast'; }, 3000); |
|
|
} |
|
|
|
|
|
function formatUptime(seconds) { |
|
|
const d = Math.floor(seconds / (3600*24)); |
|
|
const h = Math.floor(seconds % (3600*24) / 3600); |
|
|
const m = Math.floor(seconds % 3600 / 60); |
|
|
const s = Math.floor(seconds % 60); |
|
|
return \`\${d}天 \${h}小时 \${m}分钟 \${s}秒\`; |
|
|
} |
|
|
|
|
|
function handleAuthFailure() { |
|
|
sessionStorage.removeItem(API_KEY_SESSION_STORAGE); |
|
|
mainContainer.style.display = 'none'; |
|
|
document.body.insertAdjacentHTML('afterbegin', '<h1>认证已过期或无效，请刷新页面重试。</h1>'); |
|
|
showToast('认证失败', true); |
|
|
} |
|
|
|
|
|
async function fetchData() { |
|
|
try { |
|
|
const response = await fetch(\`\${API_BASE}/data\`, { headers: getAuthHeaders() }); |
|
|
if (response.status === 401) return handleAuthFailure(); |
|
|
if (!response.ok) throw new Error('获取数据失败'); |
|
|
const data = await response.json(); |
|
|
|
|
|
uptimeEl.textContent = formatUptime(data.status.uptime); |
|
|
browserConnectedEl.innerHTML = data.status.browserConnected ? '<span class="status-text-info">已连接</span>' : '<span class="status-text-red">已断开</span>'; |
|
|
authModeEl.innerHTML = data.status.authMode === 'env' ? '<span class="status-text-info">环境变量</span>' : '<span class="status-text-info">Cookie文件</span>'; |
|
|
apiKeyAuthEl.innerHTML = data.status.apiKeyAuth === '已启用' ? '<span class="status-text-info">已启用</span>' : '<span class="status-text-gray">已禁用</span>'; |
|
|
debugModeEl.innerHTML = data.status.debugMode ? '<span class="status-text-yellow">已启用</span>' : '<span class="status-text-gray">已禁用</span>'; |
|
|
totalCallsEl.textContent = data.stats.totalCalls; |
|
|
|
|
|
accountCallsEl.innerHTML = ''; |
|
|
const sortedAccounts = Object.entries(data.stats.accountCalls).sort((a,b) => parseInt(a[0]) - parseInt(b[0])); |
|
|
const callsUl = document.createElement('ul'); |
|
|
callsUl.className = 'account-list'; |
|
|
for (const [index, stats] of sortedAccounts) { |
|
|
const li = document.createElement('li'); |
|
|
const isCurrent = parseInt(index, 10) === data.auth.currentAuthIndex; |
|
|
let modelStatsHtml = '<ul class="model-stats-list">'; |
|
|
const sortedModels = Object.entries(stats.models).sort((a,b) => b[1] - a[1]); |
|
|
sortedModels.length > 0 ? sortedModels.forEach(([model, count]) => { modelStatsHtml += \`<li><span>\${model}:</span> <strong>\${count}</strong></li>\`; }) : modelStatsHtml += '<li>无模型调用记录</li>'; |
|
|
modelStatsHtml += '</ul>'; |
|
|
li.innerHTML = \`<details><summary><span class="\${isCurrent ? 'current' : ''}">账号 \${index}</span><strong>总计: \${stats.total}</strong></summary>\${modelStatsHtml}</details>\`; |
|
|
if(isCurrent) { li.querySelector('summary').style.color = 'var(--pico-primary)'; } |
|
|
callsUl.appendChild(li); |
|
|
} |
|
|
accountCallsEl.appendChild(callsUl); |
|
|
|
|
|
accountPoolEl.innerHTML = ''; |
|
|
const poolUl = document.createElement('ul'); |
|
|
poolUl.className = 'account-list'; |
|
|
data.auth.accounts.forEach(acc => { |
|
|
const li = document.createElement('li'); |
|
|
const isCurrent = acc.index === data.auth.currentAuthIndex; |
|
|
const sourceTag = acc.source === 'temporary' ? '<span class="tag tag-yellow">临时</span>' : (acc.source === 'env' ? '<span class="tag tag-info">变量</span>' : '<span class="tag tag-blue">文件</span>'); |
|
|
let html = \`<span class="\${isCurrent ? 'current' : ''}">账号 \${acc.index} \${sourceTag}</span>\`; |
|
|
if (acc.source === 'temporary') { html += \`<button class="btn-danger btn-sm" data-index="\${acc.index}">删除</button>\`; } else { html += '<span></span>'; } |
|
|
li.innerHTML = html; |
|
|
poolUl.appendChild(li); |
|
|
}); |
|
|
accountPoolEl.appendChild(poolUl); |
|
|
|
|
|
const streamingModeInput = document.querySelector(\`input[name="streamingMode"][value="\${data.config.streamingMode}"]\`); |
|
|
if(streamingModeInput) streamingModeInput.checked = true; |
|
|
configForm.failureThreshold.value = data.config.failureThreshold; |
|
|
configForm.maxRetries.value = data.config.maxRetries; |
|
|
configForm.retryDelay.value = data.config.retryDelay; |
|
|
configForm.immediateSwitchStatusCodes.value = data.config.immediateSwitchStatusCodes.join(', '); |
|
|
} catch (error) { |
|
|
console.error('获取数据时出错:', error); |
|
|
showToast(error.message, true); |
|
|
} |
|
|
} |
|
|
|
|
|
function initializeDashboardListeners() { |
|
|
switchAccountBtn.addEventListener('click', async () => { |
|
|
switchAccountBtn.disabled = true; |
|
|
switchAccountBtn.textContent = '切换中...'; |
|
|
try { |
|
|
const response = await fetch('/switch', { method: 'POST', headers: getAuthHeaders() }); |
|
|
const text = await response.text(); |
|
|
if (!response.ok) throw new Error(text); |
|
|
showToast(text); |
|
|
await fetchData(); |
|
|
} catch (error) { |
|
|
showToast(error.message, true); |
|
|
} finally { |
|
|
switchAccountBtn.disabled = false; |
|
|
switchAccountBtn.textContent = '切换到下一个账号'; |
|
|
} |
|
|
}); |
|
|
|
|
|
addAccountBtn.addEventListener('click', () => { |
|
|
const index = prompt("为新的临时账号输入一个唯一的数字索引："); |
|
|
if (!index || isNaN(parseInt(index))) { if(index !== null) alert("索引无效。"); return; } |
|
|
const authDataStr = prompt("请输入单行压缩后的Cookie内容:"); |
|
|
if (!authDataStr) return; |
|
|
let authData; |
|
|
try { authData = JSON.parse(authDataStr); } catch(e) { alert("Cookie JSON格式无效。"); return; } |
|
|
|
|
|
fetch(\`\${API_BASE}/accounts\`, { method: 'POST', headers: getAuthHeaders(true), body: JSON.stringify({ index: parseInt(index), authData }) }) |
|
|
.then(res => res.json().then(data => ({ ok: res.ok, data }))).then(({ok, data}) => { |
|
|
if (!ok) throw new Error(data.message); |
|
|
showToast(data.message); fetchData(); }).catch(err => showToast(err.message, true)); |
|
|
}); |
|
|
|
|
|
accountPoolEl.addEventListener('click', e => { |
|
|
if (e.target.matches('button.btn-danger')) { |
|
|
const index = e.target.dataset.index; |
|
|
if (confirm(\`您确定要删除临时账号 \${index} 吗？\`)) { |
|
|
fetch(\`\${API_BASE}/accounts/\${index}\`, { method: 'DELETE', headers: getAuthHeaders() }) |
|
|
.then(res => res.json().then(data => ({ ok: res.ok, data }))).then(({ok, data}) => { |
|
|
if (!ok) throw new Error(data.message); |
|
|
showToast(data.message); fetchData(); }).catch(err => showToast(err.message, true)); |
|
|
} |
|
|
} |
|
|
}); |
|
|
|
|
|
configForm.addEventListener('submit', e => { |
|
|
e.preventDefault(); |
|
|
const formData = new FormData(configForm); |
|
|
const data = Object.fromEntries(formData.entries()); |
|
|
data.immediateSwitchStatusCodes = data.immediateSwitchStatusCodes.split(',').map(s => s.trim()).filter(Boolean); |
|
|
fetch(\`\${API_BASE}/config\`, { method: 'POST', headers: getAuthHeaders(true), body: JSON.stringify(data) }) |
|
|
.then(res => res.json().then(data => ({ ok: res.ok, data }))).then(({ok, data}) => { |
|
|
if (!ok) throw new Error(data.message); |
|
|
showToast('配置已应用。'); fetchData(); }).catch(err => showToast(err.message, true)); |
|
|
}); |
|
|
|
|
|
configForm.addEventListener('change', e => { |
|
|
if (e.target.name === 'streamingMode') { |
|
|
fetch(\`\${API_BASE}/config\`, { method: 'POST', headers: getAuthHeaders(true), body: JSON.stringify({ streamingMode: e.target.value }) }) |
|
|
.then(res => res.json().then(d => ({ ok: res.ok, data: d }))).then(({ok, data}) => { |
|
|
if (!ok) throw new Error(data.message); |
|
|
showToast(\`流式模式已更新为: \${e.target.value.charAt(0).toUpperCase() + e.target.value.slice(1)}\`); |
|
|
}).catch(err => showToast(err.message, true)); |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
async function verifyAndLoad(keyToVerify) { |
|
|
try { |
|
|
const response = await fetch(\`\${API_BASE}/verify-key\`, { |
|
|
method: 'POST', |
|
|
headers: { 'Content-Type': 'application/json' }, |
|
|
body: JSON.stringify({ key: keyToVerify || '' }) |
|
|
}); |
|
|
const result = await response.json(); |
|
|
|
|
|
if (response.ok && result.success) { |
|
|
if (keyToVerify) { |
|
|
sessionStorage.setItem(API_KEY_SESSION_STORAGE, keyToVerify); |
|
|
} |
|
|
mainContainer.style.display = 'block'; |
|
|
initializeDashboardListeners(); |
|
|
fetchData(); |
|
|
setInterval(fetchData, 5000); |
|
|
return true; |
|
|
} else { |
|
|
sessionStorage.removeItem(API_KEY_SESSION_STORAGE); |
|
|
return false; |
|
|
} |
|
|
} catch (err) { |
|
|
document.body.innerHTML = \`<h1>认证时发生错误: \${err.message}</h1>\`; |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
async function checkAndInitiate() { |
|
|
const storedApiKey = sessionStorage.getItem(API_KEY_SESSION_STORAGE); |
|
|
|
|
|
// 尝试使用已存储的密钥或空密钥进行验证 |
|
|
const initialCheckSuccess = await verifyAndLoad(storedApiKey); |
|
|
|
|
|
// 如果初次验证失败，说明服务器需要密钥，而我们没有提供或提供了错误的密钥 |
|
|
if (!initialCheckSuccess) { |
|
|
const newApiKey = prompt("请输入API密钥以访问仪表盘 (服务器需要认证):"); |
|
|
if (newApiKey) { |
|
|
// 使用用户新输入的密钥再次尝试 |
|
|
const secondCheckSuccess = await verifyAndLoad(newApiKey); |
|
|
if (!secondCheckSuccess) { |
|
|
document.body.innerHTML = \`<h1>认证失败: 无效的API密钥</h1>\`; |
|
|
} |
|
|
} else { |
|
|
// 用户取消了输入 |
|
|
document.body.innerHTML = '<h1>访问被拒绝</h1>'; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
checkAndInitiate(); |
|
|
}); |
|
|
</script> |
|
|
</body> |
|
|
</html> |
|
|
`; |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
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 }); |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async function initializeServer() { |
|
|
try { |
|
|
const serverSystem = new ProxyServerSystem(); |
|
|
await serverSystem.start(); |
|
|
} catch (error) { |
|
|
console.error('❌ 服务器启动失败:', error.message); |
|
|
process.exit(1); |
|
|
} |
|
|
} |
|
|
|
|
|
if (require.main === module) { |
|
|
initializeServer(); |
|
|
} |
|
|
|
|
|
module.exports = { ProxyServerSystem, BrowserManager, initializeServer }; |
