server.js

// server.js
const express = require('express');
require('./modules/dotenvPatch.js'); // 应用 dotenv.parse 补丁以支持特殊字符
const dotenv = require('dotenv');
dotenv.config({ path: 'config.env' });
const schedule = require('node-schedule');
const lunarCalendar = require('chinese-lunar-calendar');
const dayjs = require('dayjs');
const timezone = require('dayjs/plugin/timezone');
const utc = require('dayjs/plugin/utc');
dayjs.extend(utc);
dayjs.extend(timezone);

const DEFAULT_TIMEZONE = process.env.DEFAULT_TIMEZONE || 'Asia/Shanghai';
const fs = require('fs').promises; // fs.promises for async operations
const path = require('path');
const { Writable } = require('stream');
const fsSync = require('fs'); // Renamed to fsSync for clarity with fs.promises

// 🌟 核心修复：彻底解放 Node.js 默认的全局连接池限制，防止底层网络排队导致 AdminPanel 死锁
const http = require('http');
const https = require('https');
http.globalAgent.maxSockets = 10000;
https.globalAgent.maxSockets = 10000;

// 初始化日志记录器
const logger = require('./modules/logger.js');
logger.initializeServerLogger();
logger.overrideConsole();

// Agent 目录路径初始化（同步，在模块加载时解析）
let AGENT_DIR;

function resolveAgentDir() {
    const configPath = process.env.AGENT_DIR_PATH;

    if (!configPath || typeof configPath !== 'string' || configPath.trim() === '') {
        return path.join(__dirname, 'Agent');
    }

    const normalizedPath = path.normalize(configPath.trim());
    const absolutePath = path.isAbsolute(normalizedPath)
        ? normalizedPath
        : path.resolve(__dirname, normalizedPath);

    return absolutePath;
}

AGENT_DIR = resolveAgentDir();

// 确保目录存在（异步，在服务器启动时调用）
async function ensureAgentDirectory() {
    try {
        await fs.mkdir(AGENT_DIR, { recursive: true });
        console.log(`[Server] Agent directory: ${AGENT_DIR}`);
    } catch (error) {
        if (error.code !== 'EEXIST') {
            console.error(`[Server] Failed to create Agent directory: ${AGENT_DIR}`);

            if (error.code === 'EACCES' || error.code === 'EPERM') {
                console.error('[Server] Error: Permission denied');
            } else if (error.code === 'ENOENT') {
                console.error('[Server] Error: Parent directory does not exist');
            } else if (error.code === 'ENOSPC') {
                console.error('[Server] Error: No space left on device');
            } else if (error.code === 'ENAMETOOLONG') {
                console.error('[Server] Error: Path is too long');
            }

            process.exit(1);
        }
    }
}

// TVStxt 目录路径初始化
let TVS_DIR;

function resolveTvsDir() {
    const configPath = process.env.TVSTXT_DIR_PATH;

    if (!configPath || typeof configPath !== 'string' || configPath.trim() === '') {
        return path.join(__dirname, 'TVStxt');
    }

    const normalizedPath = path.normalize(configPath.trim());
    const absolutePath = path.isAbsolute(normalizedPath)
        ? normalizedPath
        : path.resolve(__dirname, normalizedPath);

    return absolutePath;
}

TVS_DIR = resolveTvsDir();

// 确保 TVStxt 目录存在
async function ensureTvsDirectory() {
    try {
        await fs.mkdir(TVS_DIR, { recursive: true });
        console.log(`[Server] TVStxt directory: ${TVS_DIR}`);
    } catch (error) {
        if (error.code !== 'EEXIST') {
            console.error(`[Server] Failed to create TVStxt directory: ${TVS_DIR}`);
        }
    }
}

const crypto = require('crypto');
const agentManager = require('./modules/agentManager.js'); // 新增：Agent管理器
const tvsManager = require('./modules/tvsManager.js'); // 新增：TVS管理器
const toolboxManager = require('./modules/toolboxManager.js');
const dynamicToolRegistry = require('./modules/dynamicToolRegistry.js');
const messageProcessor = require('./modules/messageProcessor.js');
const knowledgeBaseManager = require('./KnowledgeBaseManager.js'); // 新增：引入统一知识库管理器
const tdbKnowledgeManager = require('./TDBKnowledge.js'); // 新增：引入 TriviumDB 冷知识库管理器
const pluginManager = require('./Plugin.js');
const sarPromptManager = require('./modules/sarPromptManager.js');
const taskScheduler = require('./routes/taskScheduler.js');
const webSocketServer = require('./WebSocketServer.js'); // 新增 WebSocketServer 引入
const FileFetcherServer = require('./FileFetcherServer.js'); // 引入新的 FileFetcherServer 模块
const vcpInfoHandler = require('./vcpInfoHandler.js'); // 引入新的 VCP 信息处理器
const toolCallRecordStore = require('./modules/toolCallRecordStore.js'); // 工具调用记录独立 SQLite 存储
const basicAuth = require('basic-auth');
const cors = require('cors'); // 引入 cors 模块

const BLACKLIST_FILE = path.join(__dirname, 'ip_blacklist.json');
const MAX_API_ERRORS = 5;
let ipBlacklist = [];
const apiErrorCounts = new Map();

const loginAttempts = new Map();
const tempBlocks = new Map();
const noCredentialAccess = new Map(); // 无凭据访问计数（防DDoS探测）
const MAX_LOGIN_ATTEMPTS = 5; // 15分钟内最多尝试5次（错误凭据）
const MAX_NO_CREDENTIAL_REQUESTS = 100; // 15分钟内无凭据访问上限（防DDoS探测）
const LOGIN_ATTEMPT_WINDOW = 15 * 60 * 1000; // 15分钟的窗口
const TEMP_BLOCK_DURATION = 30 * 60 * 1000; // 封禁30分钟（错误凭据触发）
const NO_CREDENTIAL_BLOCK_DURATION = 15 * 60 * 1000; // 封禁15分钟（无凭据DDoS触发）

const ChatCompletionHandler = require('./modules/chatCompletionHandler.js');
const ToolCallParser = require('./modules/vcpLoop/toolCallParser.js');

const activeRequests = new Map(); // 新增：用于存储活动中的请求，以便中止

const SERVER_LIFECYCLE = Object.freeze({
    RUNNING: 'RUNNING',
    DRAINING: 'DRAINING',
    SHUTTING_DOWN: 'SHUTTING_DOWN',
    EXITING: 'EXITING'
});

let serverLifecycleState = SERVER_LIFECYCLE.RUNNING;
let shutdownPromise = null;
let shutdownStartedAt = null;
let shutdownReason = null;
let lastShutdownExitCode = 0;
let forceShutdownTimer = null;
const trackedSockets = new Set();
const activeHttpRequests = new Set();

function getServerLifecycleStatus() {
    return {
        state: serverLifecycleState,
        reason: shutdownReason,
        startedAt: shutdownStartedAt,
        uptimeMsInState: shutdownStartedAt ? Date.now() - shutdownStartedAt : 0,
        activeRequestCount: activeRequests.size
    };
}

function isServerDraining() {
    return serverLifecycleState !== SERVER_LIFECYCLE.RUNNING;
}

function buildDrainingResponse(req) {
    const lifecycleStatus = getServerLifecycleStatus();
    const isStreamRequest = req?.body?.stream === true;
    const message = '服务正在重启/关闭中，暂时不再接受新的请求。';

    if (isStreamRequest) {
        return {
            type: 'stream',
            status: 200,
            headers: {
                'Content-Type': 'text/event-stream',
                'Cache-Control': 'no-cache',
                'Connection': 'keep-alive'
            },
            body: {
                id: `chatcmpl-draining-${Date.now()}`,
                object: 'chat.completion.chunk',
                created: Math.floor(Date.now() / 1000),
                model: req?.body?.model || 'unknown',
                choices: [{
                    index: 0,
                    delta: { content: message },
                    finish_reason: 'stop'
                }],
                lifecycle: lifecycleStatus
            }
        };
    }

    return {
        type: 'json',
        status: 503,
        body: {
            error: 'Service Unavailable',
            message,
            lifecycle: lifecycleStatus
        }
    };
}

function sendDrainingResponse(req, res) {
    const payload = buildDrainingResponse(req);

    if (payload.type === 'stream') {
        if (!res.headersSent) {
            res.status(payload.status);
            Object.entries(payload.headers).forEach(([key, value]) => res.setHeader(key, value));
        }
        res.write(`data: ${JSON.stringify(payload.body)}\n\n`);
        res.write('data: [DONE]\n\n');
        res.end();
        return;
    }

    if (!res.headersSent) {
        res.status(payload.status).json(payload.body);
    } else if (!res.writableEnded) {
        res.end();
    }
}

function destroyIdleSockets() {
    let destroyedCount = 0;
    for (const socket of trackedSockets) {
        try {
            const hasActiveRequest = activeHttpRequests.has(socket);
            if (!hasActiveRequest && !socket.destroyed) {
                socket.destroy();
                destroyedCount++;
            }
        } catch (error) {
            console.error('[Server] Failed to destroy idle socket:', error.message);
        }
    }
    console.log(`[Server] Destroyed ${destroyedCount} idle socket(s).`);
}

async function closeHttpServerGracefully() {
    if (!server || typeof server.close !== 'function') {
        return;
    }

    console.log(`[Server] Preparing to close HTTP server. trackedSockets=${trackedSockets.size}, activeHttpRequests=${activeHttpRequests.size}`);

    destroyIdleSockets();

    await new Promise((resolve) => {
        try {
            server.close((error) => {
                if (error) {
                    console.error('[Server] Error while closing HTTP server:', error);
                } else {
                    console.log('[Server] HTTP server stopped accepting new connections.');
                }
                resolve();
            });
        } catch (error) {
            console.error('[Server] Failed to invoke server.close():', error);
            resolve();
        }
    });
}

async function waitForActiveRequestsToDrain(timeoutMs = 30000) {
    const start = Date.now();

    while (activeRequests.size > 0 && (Date.now() - start) < timeoutMs) {
        console.log(`[Shutdown] Waiting for ${activeRequests.size} active request(s) to finish...`);
        await new Promise(resolve => setTimeout(resolve, 500));
    }

    return activeRequests.size === 0;
}

async function abortAllActiveRequests(reason = '服务器正在关闭') {
    console.log(`[Shutdown] Aborting ${activeRequests.size} active request(s)...`);

    for (const [id, context] of activeRequests.entries()) {
        try {
            if (!context.aborted) {
                context.aborted = true;
            }

            if (context.abortController && !context.abortController.signal.aborted) {
                context.abortController.abort();
            }

            if (context.res && !context.res.writableEnded && !context.res.destroyed) {
                const isStreamRequest = context.req?.body?.stream === true;

                if (!context.res.headersSent) {
                    if (isStreamRequest) {
                        context.res.status(200);
                        context.res.setHeader('Content-Type', 'text/event-stream');
                        context.res.setHeader('Cache-Control', 'no-cache');
                        context.res.setHeader('Connection', 'keep-alive');

                        const shutdownChunk = {
                            id: `chatcmpl-shutdown-${Date.now()}`,
                            object: 'chat.completion.chunk',
                            created: Math.floor(Date.now() / 1000),
                            model: context.req?.body?.model || 'unknown',
                            choices: [{
                                index: 0,
                                delta: { content: reason },
                                finish_reason: 'stop'
                            }]
                        };

                        context.res.write(`data: ${JSON.stringify(shutdownChunk)}\n\n`);
                        context.res.write('data: [DONE]\n\n');
                        context.res.end();
                    } else {
                        context.res.status(503).json({
                            error: 'Service Unavailable',
                            message: reason
                        });
                    }
                } else if (String(context.res.getHeader('Content-Type') || '').includes('text/event-stream')) {
                    context.res.write('data: [DONE]\n\n');
                    context.res.end();
                } else {
                    context.res.end();
                }
            }
        } catch (error) {
            console.error(`[Shutdown] Failed to abort active request ${id}:`, error.message);
            try {
                if (context.res && !context.res.destroyed) {
                    context.res.destroy();
                }
            } catch (destroyError) {
                console.error(`[Shutdown] Failed to destroy response for request ${id}:`, destroyError.message);
            }
        }
    }
}

// 新增：定时清理 activeRequests 防止内存泄漏
setInterval(() => {
    const now = Date.now();
    for (const [id, context] of activeRequests.entries()) {
        // 30分钟超时
        if (now - (context.timestamp || 0) > 30 * 60 * 1000) {
            console.log(`[Request Cleanup] Aborting and removing timed-out request: ${id}`);
            if (context.abortController) {
                context.abortController.abort();
            }
            activeRequests.delete(id);
        }
    }
}, 60 * 1000); // 每分钟检查一次

const ADMIN_USERNAME = process.env.AdminUsername;
const ADMIN_PASSWORD = process.env.AdminPassword;

const DEBUG_MODE = (process.env.DebugMode || "False").toLowerCase() === "true";
const CHAT_LOG_ENABLED = (process.env.CHAT_LOG_ENABLED || "false").toLowerCase() === "true";
// 只控制已通过现有 IP 映射识别的 VChat 节点的常规 POST 追踪日志，不影响鉴权与安全日志。
const LOG_VCHAT_POST_IP_ENABLED = (process.env.LOG_VCHAT_POST_IP_ENABLED || "true").trim().toLowerCase() !== "false";
const VCPToolCode = (process.env.VCPToolCode || "false").toLowerCase() === "true"; // 新增：读取VCP工具调用验证码开关
const SHOW_VCP_OUTPUT = (process.env.ShowVCP || "False").toLowerCase() === "true"; // 读取 ShowVCP 环境变量
const REASONING_TO_CONTENT_ENABLED = (process.env.ReasoningToContentEnabled || "false").toLowerCase() === "true";
const REASONING_TO_CONTENT_TAG = String(process.env.ReasoningToContentTag || "think").trim().toLowerCase() === "thinking"
    ? "thinking"
    : "think";
const REASONING_TO_CONTENT_MODELS = String(process.env.ReasoningToContentModel || "")
    .split(',')
    .map(model => model.trim().toLowerCase())
    .filter(Boolean);
const RAG_MEMO_REFRESH = (process.env.RAGMemoRefresh || "false").toLowerCase() === "true"; // 新增：传递RAG日记刷新开关
const ENABLE_ROLE_DIVIDER = (process.env.EnableRoleDivider || "false").toLowerCase() === "true"; // 新增：角色分割开关
const ENABLE_ROLE_DIVIDER_IN_LOOP = (process.env.EnableRoleDividerInLoop || "false").toLowerCase() === "true"; // 新增：循环栈角色分割开关
const ROLE_DIVIDER_SYSTEM = (process.env.RoleDividerSystem || "true").toLowerCase() === "true"; // 新增：System角色分割开关
const ROLE_DIVIDER_ASSISTANT = (process.env.RoleDividerAssistant || "true").toLowerCase() === "true"; // 新增：Assistant角色分割开关
const ROLE_DIVIDER_USER = (process.env.RoleDividerUser || "true").toLowerCase() === "true"; // 新增：User角色分割开关
const ROLE_DIVIDER_SCAN_SYSTEM = (process.env.RoleDividerScanSystem || "true").toLowerCase() === "true"; // 新增：System角色扫描开关
const ROLE_DIVIDER_SCAN_ASSISTANT = (process.env.RoleDividerScanAssistant || "true").toLowerCase() === "true"; // 新增：Assistant角色扫描开关
const ROLE_DIVIDER_SCAN_USER = (process.env.RoleDividerScanUser || "true").toLowerCase() === "true"; // 新增：User角色扫描开关
const ROLE_DIVIDER_REMOVE_DISABLED_TAGS = (process.env.RoleDividerRemoveDisabledTags || "true").toLowerCase() === "true"; // 新增：禁用标签清除开关

let ROLE_DIVIDER_IGNORE_LIST = [];
try {
    ROLE_DIVIDER_IGNORE_LIST = JSON.parse(process.env.RoleDividerIgnoreList || "[]");
} catch (e) {
    console.error("Failed to parse RoleDividerIgnoreList:", e);
}

// 新增：国产A类模型推理功能配置
let CHINA_MODEL_1 = [];
try {
    CHINA_MODEL_1 = (process.env.ChinaModel1 || "").split(',').map(m => m.trim()).filter(m => m !== "");
} catch (e) {
    console.error("Failed to parse ChinaModel1:", e);
}
const CHINA_MODEL_1_COT = (process.env.ChinaModel1Cot || "false").toLowerCase() === "true";

// 多模态配置 JSON 真相源（multimodal-config.json）：优先级高于 config.env，支持热更新
// 在初始化阶段先确保文件存在并加载内存配置；运行时由 chatCompletionHandler / image-processor 直接调用 store。
const multiModalConfigStore = require('./modules/multiModalConfigStore.js');
try {
    multiModalConfigStore.init();
    console.log('[Server] multimodal-config.json 配置真相源已加载，路径：', multiModalConfigStore.CONFIG_PATH);
} catch (multiModalInitErr) {
    console.error('[Server] 初始化 multimodal-config.json 失败：', multiModalInitErr);
}

// 纯文本模型强制翻译多模态：tag 列表，命中即无视 {{TransBase64}}/{{TransBase64+}} 占位符
// 用于配合模型动态路由（VCPModelAuto/SemanticModelRouter），避免把 base64 多模态传给纯文本模型
// 仅作为启动快照保留；运行时 chatCompletionHandler 会从 multiModalConfigStore 拉取最新值
let MULTIMODAL_FORCE_TRANSLATE_MODELS = [];
try {
    const storeTags = multiModalConfigStore.getForceTranslateModels();
    if (Array.isArray(storeTags) && storeTags.length > 0) {
        MULTIMODAL_FORCE_TRANSLATE_MODELS = storeTags;
    } else {
        MULTIMODAL_FORCE_TRANSLATE_MODELS = (process.env.MultiModalForceTranslateModels || "")
            .split(',')
            .map(tag => tag.trim().toLowerCase())
            .filter(tag => tag !== "");
    }
    if (MULTIMODAL_FORCE_TRANSLATE_MODELS.length > 0) {
        console.log(`[Server] MultiModalForceTranslateModels 启动快照已加载 ${MULTIMODAL_FORCE_TRANSLATE_MODELS.length} 个 tag: [${MULTIMODAL_FORCE_TRANSLATE_MODELS.join(', ')}]`);
    }
} catch (e) {
    console.error("Failed to parse MultiModalForceTranslateModels:", e);
}

// 新增：模型重定向功能
const ModelRedirectHandler = require('./modelRedirectHandler.js');
const modelRedirectHandler = new ModelRedirectHandler();

// 语义任务智能模型路由器
const SemanticModelRouter = require('./modules/semanticModelRouter.js');
const semanticModelRouter = new SemanticModelRouter();

// ensureDebugLogDir is now ensureDebugLogDirSync and called by initializeServerLogger
// writeDebugLog remains for specific debug purposes, it uses fs.promises.
// 优化：Debug 日志按天归档到 archive/YYYY-MM-DD/Debug/ 目录
async function writeDebugLog(filenamePrefix, data) {
    if (DEBUG_MODE) {
        const DEBUG_LOG_DIR = path.join(__dirname, 'DebugLog');
        const now = dayjs().tz(DEFAULT_TIMEZONE);
        const dateStr = now.format('YYYY-MM-DD');
        const timestamp = now.format('HHmmss_SSS');

        // 归档目录：DebugLog/archive/YYYY-MM-DD/Debug/
        const archiveDir = path.join(DEBUG_LOG_DIR, 'archive', dateStr, 'Debug');

        try {
            await fs.mkdir(archiveDir, { recursive: true });
        } catch (error) {
            console.error(`创建 Debug 归档目录失败: ${archiveDir}`, error);
        }

        const filename = `${filenamePrefix}-${timestamp}.txt`;
        const filePath = path.join(archiveDir, filename);
        try {
            await fs.writeFile(filePath, JSON.stringify(data, null, 2));
            console.log(`[DebugLog] 已记录日志: archive/${dateStr}/Debug/${filename}`);
        } catch (error) {
            console.error(`写入调试日志失败: ${filePath}`, error);
        }
    }
}

// ChatLog：在 DebugLog/chat/YYYY-MM-DD/ 下记录每次 chat 的请求体与响应（仅当 CHAT_LOG_ENABLED 时有效）
let writeChatLog;
if (CHAT_LOG_ENABLED) {
    const crypto = require('crypto');
    writeChatLog = function (requestBody, logs) {
        const now = dayjs().tz(DEFAULT_TIMEZONE);
        const dateStr = now.format('YYYY-MM-DD');
        const timeStr = now.format('HHmmss_SSS');
        const id = (requestBody && (requestBody.requestId || requestBody.messageId)) || 'no-id';
        const safeId = String(id).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
        const shortRandom = crypto.randomBytes(2).toString('hex');
        const filename = `chat-${safeId}-${timeStr}-${shortRandom}.json`;
        const chatDir = path.join(__dirname, 'DebugLog', 'chat', dateStr);
        const filePath = path.join(chatDir, filename);
        const payload = logs;
        fs.mkdir(chatDir, { recursive: true })
            .then(() => fs.writeFile(filePath, JSON.stringify(payload, null, 2)))
            .catch(e => console.error('[ChatLog] 写入失败:', e));
    };
} else {
    writeChatLog = undefined;
}

// 新增：加载IP黑名单
async function loadBlacklist() {
    try {
        await fs.access(BLACKLIST_FILE);
        const data = await fs.readFile(BLACKLIST_FILE, 'utf8');
        ipBlacklist = JSON.parse(data);
        console.log(`[Security] IP黑名单加载成功，共 ${ipBlacklist.length} 个条目。`);
    } catch (error) {
        if (error.code === 'ENOENT') {
            console.log('[Security] 未找到IP黑名单文件，将创建一个新的。');
            await saveBlacklist(); // 创建一个空的黑名单文件
        } else {
            console.error('[Security] 加载IP黑名单失败:', error);
        }
    }
}

// 新增：保存IP黑名单
async function saveBlacklist() {
    try {
        await fs.writeFile(BLACKLIST_FILE, JSON.stringify(ipBlacklist, null, 2));
    } catch (error) {
        console.error('[Security] 保存IP黑名单失败:', error);
    }
}

const detectors = [];
for (const key in process.env) {
    if (/^Detector\d+$/.test(key)) {
        const index = key.substring(8);
        const outputKey = `Detector_Output${index}`;
        if (process.env[outputKey] !== undefined) {
            detectors.push({ detector: process.env[key], output: process.env[outputKey] });
        }
    }
}
if (detectors.length > 0) console.log(`共加载了 ${detectors.length} 条系统提示词转换规则。`);
else console.log('未加载任何系统提示词转换规则。');

const superDetectors = [];
for (const key in process.env) {
    if (/^SuperDetector\d+$/.test(key)) {
        const index = key.substring(13);
        const outputKey = `SuperDetector_Output${index}`;
        if (process.env[outputKey] !== undefined) {
            superDetectors.push({ detector: process.env[key], output: process.env[outputKey] });
        }
    }
}
if (superDetectors.length > 0) console.log(`共加载了 ${superDetectors.length} 条全局上下文转换规则。`);
else console.log('未加载任何全局上下文转换规则。');


const app = express();
app.set('trust proxy', true); // 新增：信任代理，以便正确解析 X-Forwarded-For 头，解决本地IP识别为127.0.0.1的问题
app.use(cors({ origin: '*' })); // 启用 CORS，允许所有来源的跨域请求，方便本地文件调试

// 在路由决策之前解析请求体，以便 req.body 可用
app.use(express.json({ limit: '300mb' }));
app.use(express.urlencoded({ limit: '300mb', extended: true }));
app.use(express.text({ limit: '300mb', type: 'text/plain' })); // 新增：用于处理纯文本请求体

// 新增：IP追踪中间件
app.use((req, res, next) => {
    if (req.method === 'POST') {
        let clientIp = req.ip;
        // 标准化IPv6映射的IPv4地址 (e.g., from '::ffff:127.0.0.1' to '127.0.0.1')
        if (clientIp && clientIp.substr(0, 7) === "::ffff:") {
            clientIp = clientIp.substr(7);
        }

        const serverName = webSocketServer.findServerByIp(clientIp);
        const suppressVchatPostIpLog = !LOG_VCHAT_POST_IP_ENABLED
            && serverName === 'VCPChat-Desktop-Client-Distributed-Server';

        if (!suppressVchatPostIpLog) {
            console.log(`[IP Tracker] Received POST request from IP: ${clientIp}`);
            if (serverName) {
                console.log(`[IP Tracker] SUCCESS: Post request is from known Distributed Server: '${serverName}' (IP: ${clientIp})`);
            }
        }
    }
    next();
});

// 新增：处理API错误并更新IP计数
function handleApiError(req) {
    let clientIp = req.ip;
    if (clientIp && clientIp.substr(0, 7) === "::ffff:") {
        clientIp = clientIp.substr(7);
    }

    // Don't blacklist the server itself.
    if (clientIp === '127.0.0.1' || clientIp === '::1') {
        console.log(`[Security] Ignored an API error from the local server itself (IP: ${clientIp}). This is to prevent self-blocking.`);
        return;
    }

    if (!clientIp || ipBlacklist.includes(clientIp)) {
        return; // 如果IP无效或已在黑名单中，则不处理
    }

    const currentErrors = (apiErrorCounts.get(clientIp) || 0) + 1;
    apiErrorCounts.set(clientIp, currentErrors);
    console.log(`[Security] IP ${clientIp} 出现API错误，当前计次: ${currentErrors}/${MAX_API_ERRORS}`);

    if (currentErrors >= MAX_API_ERRORS) {
        if (!ipBlacklist.includes(clientIp)) {
            ipBlacklist.push(clientIp);
            console.log(`[Security] IP ${clientIp} 已达到错误上限，已加入黑名单。`);
            saveBlacklist(); // 异步保存，不阻塞当前请求
            apiErrorCounts.delete(clientIp); // 从计数器中移除
        }
    }
}

// 新增：IP黑名单中间件
app.use((req, res, next) => {
    let clientIp = req.ip;
    if (clientIp && clientIp.substr(0, 7) === "::ffff:") {
        clientIp = clientIp.substr(7);
    }

    if (clientIp && ipBlacklist.includes(clientIp)) {
        console.warn(`[Security] 已阻止来自黑名单IP ${clientIp} 的请求。`);
        return res.status(403).json({ error: 'Forbidden: Your IP address has been blocked due to suspicious activity.' });
    }
    next();
});

app.use((req, res, next) => {
    if (isServerDraining()) {
        const allowDuringShutdownPaths = new Set([
            '/admin_api/server/restart',
            '/admin_api/server/lifecycle',
            '/v1/interrupt'
        ]);
        const allowDuringShutdown =
            allowDuringShutdownPaths.has(req.path) ||
            req.path.startsWith('/plugin-callback/');

        if (!allowDuringShutdown) {
            console.warn(`[Server] Rejecting new request during ${serverLifecycleState}: ${req.method} ${req.path}`);
            return sendDrainingResponse(req, res);
        }
    }
    next();
});

// 引入并使用特殊模型路由
const specialModelRouter = require('./routes/specialModelRouter');
app.use(specialModelRouter); // 这个将处理所有白名单模型的请求

const port = process.env.PORT;
const apiKey = process.env.API_Key;
const apiUrl = process.env.API_URL;
const serverKey = process.env.Key;

const cachedEmojiLists = new Map();

// Authentication middleware for Admin Panel and Admin API
const adminAuth = (req, res, next) => {
    // This middleware protects both the Admin Panel static files and its API endpoints.
    const isAdminPath = req.path.startsWith('/admin_api') || req.path.startsWith('/AdminPanel');

    if (isAdminPath) {
        // ========== 新增：允许登录页面和相关资源无需认证 ==========
        const publicPaths = [
            '/AdminPanel/login.html',
            '/AdminPanel/VCPLogo2.png',
            '/AdminPanel/favicon.ico',
            '/AdminPanel/style.css',
            '/AdminPanel/woff.css',
            '/AdminPanel/font.woff2'
        ];

        // 验证登录的端点也需要特殊处理（允许无凭据时返回401而不是重定向）
        const isVerifyEndpoint = req.path === '/admin_api/verify-login';

        // ========== 新增：只读仪表板接口白名单（不计入登录失败次数）==========
        const readOnlyDashboardPaths = [
            '/admin_api/system-monitor',
            '/admin_api/newapi-monitor',
            '/admin_api/server-log',
            '/admin_api/user-auth-code',
            '/admin_api/weather'
        ];
        const isReadOnlyPath = readOnlyDashboardPaths.some(path => req.path.startsWith(path));
        // ========== 新增结束 ==========

        if (publicPaths.includes(req.path)) {
            return next(); // 直接放行登录页面相关资源
        }
        // ========== 新增结束 ==========

        let clientIp = req.ip;
        if (clientIp && clientIp.substr(0, 7) === "::ffff:") {
            clientIp = clientIp.substr(7);
        }

        // 1. 检查管理员凭据是否已配置 (这是最高优先级的安全检查)
        if (!ADMIN_USERNAME || !ADMIN_PASSWORD) {
            console.error('[AdminAuth] AdminUsername or AdminPassword not set in config.env. Admin panel is disabled.');
            // 对API和页面请求返回不同的错误格式
            if (req.path.startsWith('/admin_api') || (req.headers.accept && req.headers.accept.includes('application/json'))) {
                res.status(503).json({
                    error: 'Service Unavailable: Admin credentials not configured.',
                    message: 'Please set AdminUsername and AdminPassword in the config.env file to enable the admin panel.'
                });
            } else {
                res.status(503).send('<h1>503 Service Unavailable</h1><p>Admin credentials (AdminUsername, AdminPassword) are not configured in config.env. Please configure them to enable the admin panel.</p>');
            }
            return; // 停止进一步处理
        }

        // 2. 检查IP是否被临时封禁（仅对非只读接口生效）
        const blockInfo = tempBlocks.get(clientIp);
        if (blockInfo && Date.now() < blockInfo.expires && !isReadOnlyPath) {
            console.warn(`[AdminAuth] Blocked login attempt from IP: ${clientIp}. Block expires at ${new Date(blockInfo.expires).toLocaleString()}.`);
            const timeLeft = Math.ceil((blockInfo.expires - Date.now()) / 1000 / 60);
            res.setHeader('Retry-After', Math.ceil((blockInfo.expires - Date.now()) / 1000)); // In seconds
            return res.status(429).json({
                error: 'Too Many Requests',
                message: `由于登录失败次数过多，您的IP已被暂时封禁。请在 ${timeLeft} 分钟后重试。`
            });
        }

        // 3. 尝试获取凭据（优先 Header，其次 Cookie）
        let credentials = basicAuth(req);

        // 如果 Header 中没有凭据，尝试从 Cookie 中读取
        if (!credentials && req.headers.cookie) {
            const cookies = req.headers.cookie.split(';').reduce((acc, cookie) => {
                const [key, value] = cookie.trim().split('=');
                acc[key] = value;
                return acc;
            }, {});

            if (cookies.admin_auth) {
                try {
                    // Cookie 存储的是 "Basic xxxx" 格式
                    const authValue = decodeURIComponent(cookies.admin_auth);
                    if (authValue.startsWith('Basic ')) {
                        const base64Credentials = authValue.substring(6);
                        const decodedCredentials = Buffer.from(base64Credentials, 'base64').toString('utf8');
                        const [name, pass] = decodedCredentials.split(':');
                        if (name && pass) {
                            credentials = { name, pass };
                        }
                    }
                } catch (e) {
                    console.warn('[AdminAuth] Failed to parse auth cookie:', e.message);
                }
            }
        }

        // 4. 验证凭据
        if (!credentials || credentials.name !== ADMIN_USERNAME || credentials.pass !== ADMIN_PASSWORD) {
            // 认证失败，处理登录尝试计数
            // 🌟 关键修复：只有当用户主动提供了凭据（但凭据错误）时才计入失败次数
            // 当 credentials 为 null 时（如 cookie 过期、用户登出后面板后台轮询），
            // 不计入失败次数，避免面板挂着时 cookie 过期导致立即封禁 IP
            const isActiveLoginAttempt = !!credentials;
            if (clientIp && !isReadOnlyPath && isActiveLoginAttempt) {
                const now = Date.now();
                let attemptInfo = loginAttempts.get(clientIp) || { count: 0, firstAttempt: now };

                // 如果时间窗口已过，则重置计数
                if (now - attemptInfo.firstAttempt > LOGIN_ATTEMPT_WINDOW) {
                    attemptInfo = { count: 0, firstAttempt: now };
                }

                attemptInfo.count++;
                console.log(`[AdminAuth] Failed login attempt from IP: ${clientIp}. Count: ${attemptInfo.count}/${MAX_LOGIN_ATTEMPTS}`);

                if (attemptInfo.count >= MAX_LOGIN_ATTEMPTS) {
                    console.warn(`[AdminAuth] IP ${clientIp} has been temporarily blocked for ${TEMP_BLOCK_DURATION / 60000} minutes due to excessive failed login attempts.`);
                    tempBlocks.set(clientIp, { expires: now + TEMP_BLOCK_DURATION });
                    loginAttempts.delete(clientIp); // 封禁后清除尝试记录
                } else {
                    loginAttempts.set(clientIp, attemptInfo);
                }
            }
            // 🌟 防DDoS：无凭据访问独立计数，阈值更宽松（不影响正常 cookie 过期场景）
            else if (clientIp && !isReadOnlyPath) {
                const now = Date.now();
                let accessInfo = noCredentialAccess.get(clientIp) || { count: 0, firstAccess: now };

                if (now - accessInfo.firstAccess > LOGIN_ATTEMPT_WINDOW) {
                    accessInfo = { count: 0, firstAccess: now };
                }

                accessInfo.count++;

                if (accessInfo.count >= MAX_NO_CREDENTIAL_REQUESTS) {
                    console.warn(`[AdminAuth] IP ${clientIp} blocked for ${NO_CREDENTIAL_BLOCK_DURATION / 60000} min — excessive unauthenticated requests (${accessInfo.count}/${MAX_NO_CREDENTIAL_REQUESTS}).`);
                    tempBlocks.set(clientIp, { expires: now + NO_CREDENTIAL_BLOCK_DURATION });
                    noCredentialAccess.delete(clientIp);
                } else {
                    noCredentialAccess.set(clientIp, accessInfo);
                    if (accessInfo.count % 10 === 0) {
                        console.log(`[AdminAuth] Unauthenticated access from IP: ${clientIp}. Count: ${accessInfo.count}/${MAX_NO_CREDENTIAL_REQUESTS}`);
                    }
                }
            }

            // ========== 修改：根据请求类型决定响应方式 ==========
            // API 请求或验证端点：返回 401 JSON
            if (isVerifyEndpoint || req.path.startsWith('/admin_api') ||
                (req.headers.accept && req.headers.accept.includes('application/json'))) {
                // 不设置 WWW-Authenticate 头，避免触发浏览器弹窗
                return res.status(401).json({ error: 'Unauthorized' });
            }
            // AdminPanel 页面请求：重定向到登录页面
            else if (req.path.startsWith('/AdminPanel')) {
                return res.redirect('/AdminPanel/login.html');
            }
            // 其他情况
            else {
                res.setHeader('WWW-Authenticate', 'Basic realm="Admin Panel"');
                return res.status(401).send('<h1>401 Unauthorized</h1><p>Authentication required to access the Admin Panel.</p>');
            }
            // ========== 修改结束 ==========
        }

        // 4. 认证成功
        if (clientIp) {
            loginAttempts.delete(clientIp); // 成功后清除尝试记录
        }
        return next();
    }

    // 非管理面板路径，继续
    return next();
};
// Apply admin authentication to all /AdminPanel and /admin_api routes.
// This MUST come before serving static files to protect the panel itself.
app.use(adminAuth);

// 🌟 AdminPanel 独立进程解耦：主进程不再直接提供 AdminPanel 页面
// 访问主端口的 /AdminPanel 会被重定向到 PORT+1 的独立后台进程
const ADMIN_PORT = parseInt(port) + 1;
app.use('/AdminPanel', (req, res) => {
    // 构建重定向 URL，保留原始路径和查询参数
    const host = req.hostname;
    const protocol = req.protocol;
    const originalPath = req.originalUrl;
    res.redirect(302, `${protocol}://${host}:${ADMIN_PORT}${originalPath}`);
});


// Image server logic is now handled by the ImageServer plugin.


// General API authentication (Bearer token) - This was the original one, now adminAuth handles its paths
app.use((req, res, next) => {
    // Skip bearer token check for admin panel API and static files, as they use basic auth or no auth
    if (req.path.startsWith('/admin_api') || req.path.startsWith('/AdminPanel')) {
        return next();
    }

    const imageServicePathRegex = /^\/pw=[^/]+\/images\//;
    if (imageServicePathRegex.test(req.path)) {
        return next();
    }

    // Add a similar check for the FileServer plugin path
    const fileServicePathRegex = /^\/pw=[^/]+\/files\//;
    if (fileServicePathRegex.test(req.path)) {
        return next();
    }

    // Skip bearer token check for plugin callbacks
    if (req.path.startsWith('/plugin-callback')) {
        return next();
    }

    const authHeader = req.headers.authorization;
    if (!authHeader || authHeader !== `Bearer ${serverKey}`) {
        return res.status(401).json({ error: 'Unauthorized (Bearer token required)' });
    }
    next();
});

// This function is no longer needed as the EmojiListGenerator plugin handles generation.
// async function updateAndLoadAgentEmojiList(agentName, dirPath, filePath) { ... }



app.get('/v1/models', async (req, res) => {
    const { default: fetch } = await import('node-fetch');
    const appendSemanticRouterModels = (modelsData) => {
        const virtualModels = semanticModelRouter.getVirtualModels();
        if (!virtualModels.length) return modelsData;

        if (!modelsData || typeof modelsData !== 'object') {
            modelsData = { object: 'list', data: [] };
        }
        if (!Array.isArray(modelsData.data)) {
            modelsData.data = [];
        }

        const existingIds = new Set(modelsData.data.map(model => model && model.id).filter(Boolean));
        for (const virtualModel of virtualModels) {
            if (!existingIds.has(virtualModel.id)) {
                modelsData.data.push(virtualModel);
                existingIds.add(virtualModel.id);
            }
        }
        return modelsData;
    };

    try {
        const modelsApiUrl = `${apiUrl}/v1/models`;
        const apiResponse = await fetch(modelsApiUrl, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                ...(req.headers['user-agent'] && { 'User-Agent': req.headers['user-agent'] }),
                'Accept': req.headers['accept'] || 'application/json',
            },
        });

        if (apiResponse.ok) {
            const responseText = await apiResponse.text();
            try {
                let modelsData = JSON.parse(responseText);

                // 新增：如果启用了模型重定向，需要处理模型列表响应
                if (modelRedirectHandler.isEnabled()) {
                    if (modelsData.data && Array.isArray(modelsData.data)) {
                        modelsData.data = modelsData.data.map(model => {
                            if (model.id) {
                                const publicModelName = modelRedirectHandler.redirectModelForClient(model.id);
                                if (publicModelName !== model.id) {
                                    if (DEBUG_MODE) {
                                        console.log(`[ModelRedirect] 模型列表重定向: ${model.id} -> ${publicModelName}`);
                                    }
                                    return { ...model, id: publicModelName };
                                }
                            }
                            return model;
                        });
                    }
                }

                modelsData = appendSemanticRouterModels(modelsData);

                // 设置响应头
                res.status(apiResponse.status);
                apiResponse.headers.forEach((value, name) => {
                    if (!['content-encoding', 'transfer-encoding', 'connection', 'content-length', 'keep-alive'].includes(name.toLowerCase())) {
                        res.setHeader(name, value);
                    }
                });

                // 发送修改后的响应
                res.json(modelsData);
                return;
            } catch (parseError) {
                console.warn('[Models] 解析模型列表响应失败，返回语义路由虚拟模型列表:', parseError.message);
                const fallbackModelsData = appendSemanticRouterModels({ object: 'list', data: [] });
                if (fallbackModelsData.data.length > 0) {
                    return res.status(200).json(fallbackModelsData);
                }
                // 如果解析失败且没有虚拟模型，回退到错误响应
            }
        }

        // 上游模型列表不可用时，仍返回语义路由虚拟模型，避免前端无法选择 VCPModelAuto。
        const fallbackModelsData = appendSemanticRouterModels({ object: 'list', data: [] });
        if (fallbackModelsData.data.length > 0) {
            return res.status(200).json(fallbackModelsData);
        }

        res.status(apiResponse.status);
        const errorText = await apiResponse.text();
        res.type('text/plain').send(errorText);

    } catch (error) {
        console.error('转发 /v1/models 请求时出错:', error.message, error.stack);
        if (!res.headersSent) {
            res.status(500).json({ error: 'Internal Server Error', details: error.message });
        } else if (!res.writableEnded) {
            console.error('[STREAM ERROR] Headers already sent. Cannot send JSON error. Ending stream if not already ended.');
            res.end();
        }
    }
});
// 新增：标准化任务创建API端点
const VCP_TIMED_CONTACTS_DIR = path.join(__dirname, 'VCPTimedContacts');

// 辅助函数：将 Date 对象格式化为包含时区偏移的本地时间字符串 (e.g., 2025-06-29T15:00:00+08:00)
function formatToLocalDateTimeWithOffset(date) {
    // 使用 dayjs 在配置的时区中解析 Date 对象，并格式化为 ISO 8601 扩展格式
    // 'YYYY-MM-DDTHH:mm:ssZ' 格式会包含时区偏移
    return dayjs(date).tz(DEFAULT_TIMEZONE).format('YYYY-MM-DDTHH:mm:ssZ');
}

app.post('/v1/schedule_task', async (req, res) => {
    // 这是一个内部端点，由插件调用以创建定时任务。
    // 它依赖于全局的 Bearer token 认证。
    const { schedule_time, task_id, tool_call } = req.body;

    if (!schedule_time || !task_id || !tool_call || !tool_call.tool_name || !tool_call.arguments) {
        return res.status(400).json({ status: "error", error: "请求无效，缺少 'schedule_time', 'task_id', 或有效的 'tool_call' 对象。" });
    }

    const targetDate = new Date(schedule_time);
    if (isNaN(targetDate.getTime())) {
        return res.status(400).json({ status: "error", error: "无效的 'schedule_time' 时间格式。" });
    }
    if (targetDate.getTime() <= Date.now()) {
        return res.status(400).json({ status: "error", error: "schedule_time 不能是过去的时间。" });
    }

    try {
        // 确保目录存在
        await fs.mkdir(VCP_TIMED_CONTACTS_DIR, { recursive: true });

        const taskFilePath = path.join(VCP_TIMED_CONTACTS_DIR, `${task_id}.json`);

        const scheduledTimeWithOffset = formatToLocalDateTimeWithOffset(targetDate);

        const taskData = {
            taskId: task_id,
            scheduledLocalTime: scheduledTimeWithOffset, // 使用带时区偏移的本地时间格式
            tool_call: tool_call, // 存储完整的 VCP Tool Call
            requestor: `Plugin: ${tool_call.tool_name}`,
        };

        await fs.writeFile(taskFilePath, JSON.stringify(taskData, null, 2));
        if (DEBUG_MODE) console.log(`[Server] 已通过API创建新的定时任务文件: ${taskFilePath}`);

        // 返回成功的响应，插件可以基于此生成最终的用户回执
        res.status(200).json({
            status: "success",
            message: "任务已成功调度。",
            details: {
                taskId: task_id,
                scheduledTime: scheduledTimeWithOffset
            }
        });

    } catch (error) {
        console.error(`[Server] 通过API创建定时任务文件时出错:`, error);
        res.status(500).json({ status: "error", error: "在服务器上保存定时任务时发生内部错误。" });
    }
});

// 新增：生命周期状态查询路由
app.get('/admin_api/server/lifecycle', (req, res) => {
    res.status(200).json({
        status: 'success',
        lifecycle: getServerLifecycleStatus(),
        shutdownExitCode: lastShutdownExitCode
    });
});

// 新增：紧急停止路由
app.post('/v1/interrupt', (req, res) => {
    const id = req.body.requestId || req.body.messageId; // 兼容 requestId 和 messageId
    if (!id) {
        return res.status(400).json({ error: 'requestId or messageId is required.' });
    }

    const context = activeRequests.get(id);
    if (context) {
        console.log(`[Interrupt] Received stop signal for ID: ${id}`);

        // 修复 Bug #1, #2, #3: 先设置中止标志，再触发 abort，最后才尝试写入
        // 1. 设置中止标志，防止 chatCompletionHandler 继续写入
        if (!context.aborted) {
            context.aborted = true; // 标记为已中止

            // 2. 立即触发 abort 信号（中断正在进行的 fetch 请求）
            if (context.abortController && !context.abortController.signal.aborted) {
                context.abortController.abort();
                console.log(`[Interrupt] AbortController.abort() called for ID: ${id}`);
            }

            // 3. 等待一小段时间让 abort 传播（避免竞态条件）
            setImmediate(() => {
                // 4. 现在安全地尝试关闭响应流（如果还未关闭）
                if (context.res && !context.res.writableEnded && !context.res.destroyed) {
                    try {
                        // 检查响应头是否已发送，决定如何关闭
                        if (!context.res.headersSent) {
                            // 修复竞态条件Bug: 根据原始请求的stream属性判断响应类型
                            const isStreamRequest = context.req?.body?.stream === true;

                            if (isStreamRequest) {
                                // 流式请求：发送SSE格式的中止信号
                                console.log(`[Interrupt] Sending SSE abort signal for stream request ${id}`);
                                context.res.status(200);
                                context.res.setHeader('Content-Type', 'text/event-stream');
                                context.res.setHeader('Cache-Control', 'no-cache');
                                context.res.setHeader('Connection', 'keep-alive');

                                const abortChunk = {
                                    id: `chatcmpl-interrupt-${Date.now()}`,
                                    object: 'chat.completion.chunk',
                                    created: Math.floor(Date.now() / 1000),
                                    model: context.req?.body?.model || 'unknown',
                                    choices: [{
                                        index: 0,
                                        delta: { content: '请求已被用户中止' },
                                        finish_reason: 'stop'
                                    }]
                                };
                                context.res.write(`data: ${JSON.stringify(abortChunk)}\n\n`);
                                context.res.write('data: [DONE]\n\n');
                                context.res.end();
                            } else {
                                // 非流式请求：发送标准JSON响应
                                console.log(`[Interrupt] Sending JSON abort response for non-stream request ${id}`);
                                context.res.status(200).json({
                                    choices: [{
                                        index: 0,
                                        message: { role: 'assistant', content: '请求已被用户中止' },
                                        finish_reason: 'stop'
                                    }]
                                });
                            }
                        } else if (context.res.getHeader('Content-Type')?.includes('text/event-stream')) {
                            // 是流式响应，发送 [DONE] 信号并关闭
                            context.res.write('data: [DONE]\n\n');
                            context.res.end();
                            console.log(`[Interrupt] Sent [DONE] signal and closed stream for ID: ${id}`);
                        } else {
                            // 其他情况，直接结束响应
                            context.res.end();
                            console.log(`[Interrupt] Ended response for ID: ${id}`);
                        }
                    } catch (e) {
                        console.error(`[Interrupt] Error closing response for ${id}:`, e.message);
                        // 即使写入失败也不要崩溃，只记录错误
                        // 尝试强制关闭连接以防止挂起
                        try {
                            if (context.res && !context.res.destroyed) {
                                context.res.destroy();
                                console.log(`[Interrupt] Forcefully destroyed response for ${id}`);
                            }
                        } catch (destroyError) {
                            console.error(`[Interrupt] Error destroying response for ${id}:`, destroyError.message);
                        }
                    }
                } else {
                    console.log(`[Interrupt] Response for ${id} already closed or destroyed.`);
                }
            });
        } else {
            console.log(`[Interrupt] Request ${id} already aborted, skipping duplicate abort.`);
        }

        // 最后从 activeRequests 中移除，防止内存泄漏
        setTimeout(() => {
            if (activeRequests.has(id)) {
                activeRequests.delete(id);
                console.log(`[Interrupt] Cleaned up request ${id} from activeRequests`);
            }
        }, 1000); // 延迟1秒删除，确保所有异步操作完成

        // 向中断请求的发起者返回成功响应
        res.status(200).json({ status: 'success', message: `Interrupt signal sent for request ${id}.` });
    } else {
        console.log(`[Interrupt] Received stop signal for non-existent or completed ID: ${id}`);
        res.status(404).json({ status: 'error', message: `Request ${id} not found or already completed.` });
    }
});



const chatCompletionHandler = new ChatCompletionHandler({
    apiUrl,
    apiKey,
    modelRedirectHandler,
    pluginManager,
    activeRequests,
    writeDebugLog,
    writeChatLog,
    webSocketServer,
    DEBUG_MODE,
    SHOW_VCP_OUTPUT,
    reasoningToContentEnabled: REASONING_TO_CONTENT_ENABLED,
    reasoningToContentTag: REASONING_TO_CONTENT_TAG,
    reasoningToContentModels: REASONING_TO_CONTENT_MODELS,
    VCPToolCode, // 新增：传递VCP工具调用验证码开关
    RAGMemoRefresh: RAG_MEMO_REFRESH, // 新增：传递RAG日记刷新开关
    enableRoleDivider: ENABLE_ROLE_DIVIDER, // 新增：传递角色分割开关
    enableRoleDividerInLoop: ENABLE_ROLE_DIVIDER_IN_LOOP, // 新增：传递循环栈角色分割开关
    roleDividerIgnoreList: ROLE_DIVIDER_IGNORE_LIST, // 新增：传递角色分割忽略列表
    roleDividerSwitches: {
        system: ROLE_DIVIDER_SYSTEM,
        assistant: ROLE_DIVIDER_ASSISTANT,
        user: ROLE_DIVIDER_USER
    },
    roleDividerScanSwitches: {
        system: ROLE_DIVIDER_SCAN_SYSTEM,
        assistant: ROLE_DIVIDER_SCAN_ASSISTANT,
        user: ROLE_DIVIDER_SCAN_USER
    },
    roleDividerRemoveDisabledTags: ROLE_DIVIDER_REMOVE_DISABLED_TAGS,
    maxVCPLoopStream: parseInt(process.env.MaxVCPLoopStream),
    maxVCPLoopNonStream: parseInt(process.env.MaxVCPLoopNonStream),
    apiRetries: parseInt(process.env.ApiRetries) || 3, // 新增：API重试次数
    apiRetryDelay: parseInt(process.env.ApiRetryDelay) || 1000, // 新增：API重试延迟
    apiConnectionTimeoutMs: parseInt(process.env.ApiConnectionTimeoutMs) || 900000, // 单次上游连接/首包超时，默认15分钟
    cachedEmojiLists,
    detectors,
    superDetectors,
    chinaModel1: CHINA_MODEL_1,
    chinaModel1Cot: CHINA_MODEL_1_COT,
    semanticModelRouter,
    multiModalForceTranslateModels: MULTIMODAL_FORCE_TRANSLATE_MODELS // 纯文本模型 tag 命中后强制翻译多模态
});

// Route for standard chat completions. VCP info is shown based on the .env config.
app.post('/v1/chat/completions', async (req, res) => {
    try {
        await chatCompletionHandler.handle(req, res, false);
    } catch (e) {
        console.error(`[FATAL] Uncaught exception from chatCompletionHandler for ${req.path}:`, e);
        if (!res.headersSent) {
            res.status(500).json({ error: "A fatal internal error occurred." });
        } else if (!res.writableEnded) {
            res.end();
        }
    }
});

// Route to force VCP info to be shown, regardless of the .env config.
app.post('/v1/chatvcp/completions', async (req, res) => {
    try {
        await chatCompletionHandler.handle(req, res, true);
    } catch (e) {
        console.error(`[FATAL] Uncaught exception from chatCompletionHandler for ${req.path}:`, e);
        if (!res.headersSent) {
            res.status(500).json({ error: "A fatal internal error occurred." });
        } else if (!res.writableEnded) {
            res.end();
        }
    }
});

// 协议桥接路由：支持 OpenAI Responses API、Anthropic Messages、Gemini GenerateContent
// 将这些协议格式的请求转换为标准 messages 数组后内部转发到 /v1/chat/completions
const protocolBridge = require('./routes/protocolBridge');
app.use(protocolBridge);

// 新增：人类直接调用工具的端点
app.post('/v1/human/tool', async (req, res) => {
    try {
        const requestBody = req.body;
        if (typeof requestBody !== 'string' || !requestBody.trim()) {
            return res.status(400).json({ error: 'Request body must be a non-empty plain text.' });
        }

        const extractedToolBlock = ToolCallParser.extractNextToolBlock(requestBody);

        if (!extractedToolBlock) {
            return res.status(400).json({ error: 'Malformed request: Missing TOOL_REQUEST markers.' });
        }

        const parsedToolCall = ToolCallParser.parseBlock(extractedToolBlock.blockContent);

        if (!parsedToolCall || !parsedToolCall.name) {
            return res.status(400).json({ error: 'Malformed request: tool_name not found within the request block.' });
        }

        const requestedToolName = parsedToolCall.name;
        const parsedToolArgs = parsedToolCall.args || {};

        if (DEBUG_MODE) {
            console.log(`[Human Tool Exec] Received tool call for: ${requestedToolName}`, parsedToolArgs);
        }

        // 直接调用插件管理器，并传递 requestIp 以支持分布式文件拉取
        let clientIp = req.ip;
        if (clientIp && clientIp.substr(0, 7) === "::ffff:") {
            clientIp = clientIp.substr(7);
        }
        const result = await pluginManager.processToolCall(requestedToolName, parsedToolArgs, clientIp, 'human/tool');

        // processToolCall 的结果已经是正确的对象格式
        res.status(200).json(result);

    } catch (error) {
        console.error('[Human Tool Exec] Error processing direct tool call:', error.message);
        handleApiError(req); // 新增：处理API错误计数

        let errorObject;
        try {
            // processToolCall 抛出的错误是一个字符串化的JSON
            errorObject = JSON.parse(error.message);
        } catch (parseError) {
            errorObject = { error: 'Internal Server Error', details: error.message };
        }

        res.status(500).json(errorObject);
    }
});


// --- Admin API Router (Moved to routes/adminPanelRoutes.js) ---

// Define dailyNoteRootPath here as it's needed by the adminPanelRoutes module
// and was previously defined within the moved block.
const dailyNoteRootPath = process.env.KNOWLEDGEBASE_ROOT_PATH || path.join(__dirname, 'dailynote');
const knowledgeRootPath = process.env.TDB_KNOWLEDGE_ROOT_PATH
    ? (path.isAbsolute(process.env.TDB_KNOWLEDGE_ROOT_PATH)
        ? process.env.TDB_KNOWLEDGE_ROOT_PATH
        : path.resolve(__dirname, process.env.TDB_KNOWLEDGE_ROOT_PATH))
    : path.join(__dirname, 'knowledge');

// Import and use the admin panel routes, passing the getter for currentServerLogPath
const adminPanelRoutes = require('./routes/adminPanelRoutes')(
    DEBUG_MODE,
    dailyNoteRootPath,
    pluginManager,
    knowledgeRootPath,
    logger.getServerLogPath, // Pass the getter function
    knowledgeBaseManager, // Pass the knowledgeBaseManager instance
    AGENT_DIR, // Pass the Agent directory path
    cachedEmojiLists,
    TVS_DIR, // Pass the TVStxt directory path
    (code = 1) => {
        console.log(`[Server] Restart triggered from admin API (exit code: ${code}).`);
        gracefulShutdown(code, 'admin_restart').catch(err => {
            console.error('[Server] Fatal error during graceful restart:', err);
            process.exit(code);
        });
    },
    semanticModelRouter,
    modelRedirectHandler,
    apiUrl,
    apiKey,
    tdbKnowledgeManager
);

// 新增：引入 VCP 论坛 API 路由
const forumApiRoutes = require('./routes/forumApi');

// --- End Admin API Router ---

// 新增：异步插件回调路由
const VCP_ASYNC_RESULTS_DIR = path.join(__dirname, 'VCPAsyncResults');

async function ensureAsyncResultsDir() {
    try {
        await fs.mkdir(VCP_ASYNC_RESULTS_DIR, { recursive: true });
    } catch (error) {
        console.error(`[ServerSetup] 创建 VCPAsyncResults 目录失败: ${VCP_ASYNC_RESULTS_DIR}`, error);
    }
}

app.post('/plugin-callback/:pluginName/:taskId', async (req, res) => {
    const { pluginName, taskId } = req.params;
    const callbackData = req.body; // 这是插件回调时发送的 JSON 数据

    if (DEBUG_MODE) {
        console.log(`[Server] Received callback for plugin: ${pluginName}, taskId: ${taskId}`);
        console.log(`[Server] Callback data:`, JSON.stringify(callbackData, null, 2));
    }

    // 1. Save callback data to a file
    await ensureAsyncResultsDir();
    const resultFilePath = path.join(VCP_ASYNC_RESULTS_DIR, `${pluginName}-${taskId}.json`);
    try {
        await fs.writeFile(resultFilePath, JSON.stringify(callbackData, null, 2), 'utf-8');
        if (DEBUG_MODE) console.log(`[Server Callback] Saved async result for ${pluginName}-${taskId} to ${resultFilePath}`);
    } catch (fileError) {
        console.error(`[Server Callback] Error saving async result file for ${pluginName}-${taskId}:`, fileError);
        // Continue with WebSocket push even if file saving fails for now
    }

    const pluginManifest = pluginManager.getPlugin(pluginName);

    if (!pluginManifest) {
        console.error(`[Server Callback] Plugin manifest not found for: ${pluginName}`);
        // Still attempt to acknowledge the callback if possible, but log error
        return res.status(404).json({ status: "error", message: "Plugin not found, but callback noted." });
    }

    // 2. WebSocket push (existing logic)
    if (pluginManifest.webSocketPush && pluginManifest.webSocketPush.enabled) {
        const targetClientType = pluginManifest.webSocketPush.targetClientType || null;
        const wsMessage = {
            type: pluginManifest.webSocketPush.messageType || 'plugin_callback_notification',
            data: callbackData
        };
        webSocketServer.broadcast(wsMessage, targetClientType);
        if (DEBUG_MODE) {
            console.log(`[Server Callback] WebSocket push for ${pluginName} (taskId: ${taskId}) processed. Message:`, JSON.stringify(wsMessage, null, 2));
        }
    } else if (DEBUG_MODE) {
        console.log(`[Server Callback] WebSocket push not configured or disabled for plugin: ${pluginName}`);
    }

    res.status(200).json({ status: "success", message: "Callback received and processed" });
});


async function initialize() {
    console.log('开始初始化工具调用记录存储...');
    toolCallRecordStore.initialize();
    console.log('工具调用记录存储初始化完成。');

    console.log('开始初始化向量数据库...');
    await knowledgeBaseManager.initialize(); // 在加载插件之前启动，确保服务就绪
    console.log('向量数据库初始化完成。');

    console.log('开始初始化 TDB 冷知识库...');
    await tdbKnowledgeManager.initialize();
    console.log('TDB 冷知识库初始化完成。');

    pluginManager.setProjectBasePath(__dirname);
    pluginManager.setVectorDBManager(knowledgeBaseManager); // 注入 knowledgeBaseManager
    pluginManager.setTdbKnowledgeManager(tdbKnowledgeManager); // 注入冷知识库管理器
    await dynamicToolRegistry.initialize({
        pluginManager,
        projectBasePath: __dirname,
        debugMode: DEBUG_MODE
    });

    console.log('开始加载插件...');
    await pluginManager.loadPlugins();
    console.log('插件加载完成。');

    console.log('开始初始化服务类插件...');
    // --- 关键顺序调整 ---
    // 必须先将 WebSocketServer 实例注入到 PluginManager，
    // 这样在 initializeServices 内部才能正确地为 VCPLog 等插件注入广播函数。
    pluginManager.setWebSocketServer(webSocketServer);

    await pluginManager.initializeServices(app, adminPanelRoutes, __dirname);
    // 在所有服务插件都注册完路由后，再将 adminApiRouter 挂载到主 app 上
    app.use('/admin_api', adminPanelRoutes);
    // 挂载 VCP 论坛 API 路由
    app.use('/admin_api/forum', forumApiRoutes);
    console.log('服务类插件初始化完成，管理面板 API 路由和 VCP 论坛 API 路由已挂载。');

    // --- 新增：通用依赖注入 ---
    // 在所有服务都初始化完毕后，再执行依赖注入，确保 VCPLog 等服务已准备就绪。
    try {
        const dependencies = {
            knowledgeBaseManager,
            tdbKnowledgeManager,
            vcpLogFunctions: pluginManager.getVCPLogFunctions()
        };
        if (DEBUG_MODE) console.log('[Server] Injecting dependencies into plugins...');

        // 注入到消息预处理器
        for (const [name, module] of pluginManager.messagePreprocessors) {
            if (typeof module.setDependencies === 'function') {
                module.setDependencies(dependencies);
                if (DEBUG_MODE) console.log(`  - Injected dependencies into message preprocessor: ${name}.`);
            }
        }
        // 注入到服务模块 (排除VCPLog自身)
        for (const [name, serviceData] of pluginManager.serviceModules) {
            if (name !== 'VCPLog' && typeof serviceData.module.setDependencies === 'function') {
                serviceData.module.setDependencies(dependencies);
                if (DEBUG_MODE) console.log(`  - Injected dependencies into service: ${name}.`);
            }
        }
    } catch (e) {
        console.error('[Server] An error occurred during dependency injection:', e);
    }
    // --- 依赖注入结束 ---

    console.log('开始初始化静态插件...');
    await pluginManager.initializeStaticPlugins();
    console.log('静态插件初始化完成。'); // Keep
    await pluginManager.prewarmPythonPlugins(); // 新增：预热Python插件以解决冷启动问题
    // EmojiListGenerator (static plugin) is automatically executed as part of the initializeStaticPlugins call above.
    // Its script (`emoji-list-generator.js`) will run and generate/update the .txt files
    // in its `generated_lists` directory. No need to call it separately here.

    if (DEBUG_MODE) console.log('开始从插件目录加载表情包列表到缓存 (由EmojiListGenerator插件生成)...');
    const emojiListSourceDir = path.join(__dirname, 'Plugin', 'EmojiListGenerator', 'generated_lists');
    cachedEmojiLists.clear();

    try {
        const listFiles = await fs.readdir(emojiListSourceDir);
        const txtFiles = listFiles.filter(file => file.toLowerCase().endsWith('.txt'));

        if (txtFiles.length === 0) {
            if (DEBUG_MODE) console.warn(`[initialize] Warning: No .txt files found in emoji list source directory: ${emojiListSourceDir}`);
        } else {
            if (DEBUG_MODE) console.log(`[initialize] Found ${txtFiles.length} emoji list files in ${emojiListSourceDir}. Loading...`);
            await Promise.all(txtFiles.map(async (fileName) => {
                const emojiName = fileName.replace(/\.txt$/i, '');
                const filePath = path.join(emojiListSourceDir, fileName);
                try {
                    const listContent = await fs.readFile(filePath, 'utf-8');
                    cachedEmojiLists.set(emojiName, listContent);
                } catch (readError) {
                    console.error(`[initialize] Error reading emoji list file ${filePath}:`, readError.message); // Keep as error
                    cachedEmojiLists.set(emojiName, `[加载 ${emojiName} 列表失败: ${readError.code}]`);
                }
            }));
            if (DEBUG_MODE) console.log('[initialize] All available emoji lists loaded into cache.');
        }
    } catch (error) {
        if (error.code === 'ENOENT') {
            console.error(`[initialize] Error: Emoji list source directory not found: ${emojiListSourceDir}. Make sure the EmojiListGenerator plugin ran successfully.`); // Keep as error
        } else {
            console.error(`[initialize] Error reading emoji list source directory ${emojiListSourceDir}:`, error.message); // Keep as error
        }
    }
    if (DEBUG_MODE) console.log('表情包列表缓存加载完成。');

    // 所有插件运行时、服务路由和静态任务就绪后再启动清单监听，
    // 避免启动阶段的文件写入触发多余重载。
    pluginManager.startPluginWatcher();

    // 初始化通用任务调度器
    taskScheduler.initialize(pluginManager, webSocketServer, DEBUG_MODE);
}

// Store the server instance globally so it can be accessed by gracefulShutdown
let server;

async function startServer() {
    await loadBlacklist(); // 新增：在服务器启动时加载IP黑名单

    // 确保 Agent 目录存在
    await ensureAgentDirectory();
    // 确保 TVStxt 目录存在
    await ensureTvsDirectory();

    // 新增：加载模型重定向配置
    console.log('正在加载模型重定向配置...');
    modelRedirectHandler.setDebugMode(DEBUG_MODE);
    await modelRedirectHandler.loadModelRedirectConfig(path.join(__dirname, 'ModelRedirect.json'));
    console.log('模型重定向配置加载完成。');

    console.log('正在加载语义模型路由配置...');
    await semanticModelRouter.initialize(path.join(__dirname, 'SemanticModelRouter.json'), DEBUG_MODE);
    console.log('语义模型路由配置加载完成。');

    // 新增：初始化Agent管理器
    console.log('正在初始化Agent管理器...');
    agentManager.setAgentDir(AGENT_DIR);
    await agentManager.initialize(DEBUG_MODE);
    console.log('Agent管理器初始化完成。');

    console.log('正在初始化TVS管理器...');
    tvsManager.setTvsDir(TVS_DIR);
    tvsManager.initialize(DEBUG_MODE);
    console.log('TVS管理器初始化完成。');

    console.log('正在初始化Toolbox管理器...');
    toolboxManager.setTvsDir(TVS_DIR);
    await toolboxManager.initialize(DEBUG_MODE);
    console.log('Toolbox管理器初始化完成。');

    console.log('正在初始化SarPrompt管理器...');
    await sarPromptManager.initialize(DEBUG_MODE);
    console.log('SarPrompt管理器初始化完成。');

    // 🌟 关键修复：在监听端口前完成所有初始化
    await initialize(); // This loads plugins and initializes services

    // 🌟 核心网络优化：100% 确保首请求的 node-fetch ESM 模块热启动，消除冷启动导致的延迟和上游挂断风险
    console.log('[Server] 正在预热 node-fetch ESM 模块...');
    await import('node-fetch');
    console.log('[Server] node-fetch 模块预热完毕，准备处理请求。');

    server = app.listen(port, () => {
        console.log(`中间层服务器正在监听端口 ${port}`);
        console.log(`API 服务器地址: ${apiUrl}`);

        server.on('connection', (socket) => {
            trackedSockets.add(socket);

            socket.on('close', () => {
                trackedSockets.delete(socket);
                activeHttpRequests.delete(socket);
            });
        });

        server.on('request', (req, res) => {
            if (req.socket) {
                activeHttpRequests.add(req.socket);
                res.on('finish', () => {
                    activeHttpRequests.delete(req.socket);
                });
                res.on('close', () => {
                    activeHttpRequests.delete(req.socket);
                });
            }
        });

        // Initialize the new WebSocketServer
        if (DEBUG_MODE) console.log('[Server] Initializing WebSocketServer...');
        const vcpKeyValue = pluginManager.getResolvedPluginConfigValue('VCPLog', 'VCP_Key') || process.env.VCP_Key;
        const distributedMusicPlaylistSyncEnabled = (process.env.DISTRIBUTED_MUSIC_PLAYLIST_SYNC_ENABLED || 'false').toLowerCase() === 'true';
        const webSocketHeartbeatEnabled = (process.env.WEBSOCKET_HEARTBEAT_ENABLED || 'false').toLowerCase() === 'true';
        webSocketServer.initialize(server, {
            debugMode: DEBUG_MODE,
            vcpKey: vcpKeyValue,
            distributedMusicPlaylistSyncEnabled,
            heartbeatEnabled: webSocketHeartbeatEnabled
        });

        // --- 注入依赖 ---
        webSocketServer.setPluginManager(pluginManager);

        // 初始化 FileFetcherServer
        FileFetcherServer.initialize(webSocketServer);

        if (DEBUG_MODE) console.log('[Server] WebSocketServer, PluginManager, and FileFetcherServer have been interconnected.');
    });
}

startServer().catch(err => {
    console.error('[Server] Failed to start server:', err);
    process.exit(1);
});


async function gracefulShutdown(exitCode = 0, reason = 'signal') {
    if (shutdownPromise) {
        console.log(`[Server] gracefulShutdown already in progress. Reusing existing shutdown promise. Current state: ${serverLifecycleState}`);
        return shutdownPromise;
    }

    lastShutdownExitCode = exitCode;
    shutdownReason = reason;
    shutdownStartedAt = Date.now();
    serverLifecycleState = SERVER_LIFECYCLE.DRAINING;

    console.log(`[Server] Initiating graceful shutdown. reason=${reason}, exitCode=${exitCode}`);
    console.log(`[Server][ShutdownTrace] Phase 0/10 - shutdown requested. activeRequests=${activeRequests.size}`);

    forceShutdownTimer = setTimeout(() => {
        console.error('[Server] Graceful shutdown timed out. Forcing process exit.');
        serverLifecycleState = SERVER_LIFECYCLE.EXITING;
        process.exit(exitCode);
    }, 60000);
    forceShutdownTimer.unref();

    shutdownPromise = (async () => {
        try {
            if (webSocketServer && typeof webSocketServer.beginDrain === 'function') {
                console.log(`[Server][ShutdownTrace] Phase 1/10 - begin WebSocket drain`);
                console.log('[Server] Draining WebSocket upgrade handling...');
                await webSocketServer.beginDrain();
                console.log(`[Server][ShutdownTrace] Phase 1/10 - WebSocket drain ready`);
            } else {
                console.log(`[Server][ShutdownTrace] Phase 1/10 - WebSocket drain skipped`);
            }

            console.log(`[Server][ShutdownTrace] Phase 2/10 - closing HTTP server listener`);
            await closeHttpServerGracefully();
            console.log(`[Server][ShutdownTrace] Phase 2/10 - HTTP server listener closed. trackedSockets=${trackedSockets.size}, activeHttpRequests=${activeHttpRequests.size}`);

            console.log(`[Server][ShutdownTrace] Phase 3/10 - waiting active requests to drain (initial=${activeRequests.size})`);
            const drainedNaturally = await waitForActiveRequestsToDrain(30000);
            console.log(`[Server][ShutdownTrace] Phase 3/10 - drain wait result=${drainedNaturally}, remaining=${activeRequests.size}`);

            if (!drainedNaturally) {
                console.warn(`[Server] Active requests did not drain within timeout. Remaining: ${activeRequests.size}`);
                console.log(`[Server][ShutdownTrace] Phase 4/10 - aborting remaining active requests`);
                await abortAllActiveRequests('服务正在重启，当前请求已被服务器安全中止。');
                const drainedAfterAbort = await waitForActiveRequestsToDrain(5000);
                console.log(`[Server][ShutdownTrace] Phase 4/10 - abort complete. drainedAfterAbort=${drainedAfterAbort}, remaining=${activeRequests.size}`);
            } else {
                console.log(`[Server][ShutdownTrace] Phase 4/10 - abort skipped, no remaining active requests`);
            }

            serverLifecycleState = SERVER_LIFECYCLE.SHUTTING_DOWN;
            console.log(`[Server][ShutdownTrace] Phase 5/10 - lifecycle switched to SHUTTING_DOWN`);

            if (taskScheduler) {
                console.log(`[Server][ShutdownTrace] Phase 6/10 - taskScheduler.shutdown start`);
                taskScheduler.shutdown();
                console.log(`[Server][ShutdownTrace] Phase 6/10 - taskScheduler.shutdown done`);
            } else {
                console.log(`[Server][ShutdownTrace] Phase 6/10 - taskScheduler shutdown skipped`);
            }

            if (webSocketServer) {
                console.log(`[Server][ShutdownTrace] Phase 7/10 - webSocketServer.shutdown start`);
                console.log('[Server] Shutting down WebSocketServer...');
                await Promise.resolve(webSocketServer.shutdown());
                console.log(`[Server][ShutdownTrace] Phase 7/10 - webSocketServer.shutdown done`);
            } else {
                console.log(`[Server][ShutdownTrace] Phase 7/10 - WebSocketServer shutdown skipped`);
            }

            if (pluginManager) {
                console.log(`[Server][ShutdownTrace] Phase 8/10 - pluginManager.shutdownAllPlugins start`);
                await pluginManager.shutdownAllPlugins();
                console.log(`[Server][ShutdownTrace] Phase 8/10 - pluginManager.shutdownAllPlugins done`);
            } else {
                console.log(`[Server][ShutdownTrace] Phase 8/10 - pluginManager shutdown skipped`);
            }

            if (toolCallRecordStore) {
                console.log(`[Server][ShutdownTrace] Phase 8/10 - toolCallRecordStore.shutdown start`);
                toolCallRecordStore.shutdown();
                console.log(`[Server][ShutdownTrace] Phase 8/10 - toolCallRecordStore.shutdown done`);
            }

            if (tdbKnowledgeManager) {
                console.log(`[Server][ShutdownTrace] Phase 9/10 - tdbKnowledgeManager.shutdown start`);
                await tdbKnowledgeManager.shutdown();
                console.log(`[Server][ShutdownTrace] Phase 9/10 - tdbKnowledgeManager.shutdown done`);
            } else {
                console.log(`[Server][ShutdownTrace] Phase 9/10 - tdbKnowledgeManager shutdown skipped`);
            }

            if (knowledgeBaseManager) {
                console.log(`[Server][ShutdownTrace] Phase 9/10 - knowledgeBaseManager.shutdown start`);
                await knowledgeBaseManager.shutdown();
                console.log(`[Server][ShutdownTrace] Phase 9/10 - knowledgeBaseManager.shutdown done`);
            } else {
                console.log(`[Server][ShutdownTrace] Phase 9/10 - knowledgeBaseManager shutdown skipped`);
            }

            const serverLogWriteStream = logger.getLogWriteStream();
            if (serverLogWriteStream) {
                logger.originalConsoleLog('[Server][ShutdownTrace] Phase 10/10 - closing server log file stream');
                logger.originalConsoleLog('[Server] Closing server log file stream...');
                const logClosePromise = new Promise((resolve) => {
                    serverLogWriteStream.end(`[${dayjs().tz(DEFAULT_TIMEZONE).format('YYYY-MM-DD HH:mm:ss Z')}] Server gracefully shut down. reason=${reason}\n`, () => {
                        logger.originalConsoleLog('[Server] Server log stream closed.');
                        logger.originalConsoleLog('[Server][ShutdownTrace] Phase 10/10 - server log file stream closed');
                        resolve();
                    });
                });
                await logClosePromise;
            } else {
                console.log(`[Server][ShutdownTrace] Phase 10/10 - log stream close skipped`);
            }
        } finally {
            if (forceShutdownTimer) {
                clearTimeout(forceShutdownTimer);
                forceShutdownTimer = null;
            }
            serverLifecycleState = SERVER_LIFECYCLE.EXITING;
        }

        console.log(`[Server][ShutdownTrace] Final - process.exit(${exitCode})`);
        process.exit(exitCode);
    })();

    return shutdownPromise;
}

process.on('SIGINT', () => gracefulShutdown(0, 'SIGINT'));
process.on('SIGTERM', () => gracefulShutdown(0, 'SIGTERM'));

// 新增：捕获未处理的异常，防止服务器崩溃
process.on('uncaughtException', (error) => {
    console.error('[CRITICAL] Uncaught Exception detected:', error.message);
    console.error('[CRITICAL] Stack trace:', error.stack);

    // 记录到日志文件
    const serverLogWriteStream = logger.getLogWriteStream();
    if (serverLogWriteStream && !serverLogWriteStream.destroyed) {
        try {
            serverLogWriteStream.write(
                `[${dayjs().tz(DEFAULT_TIMEZONE).format('YYYY-MM-DD HH:mm:ss Z')}] [CRITICAL] Uncaught Exception: ${error.message}\n${error.stack}\n`
            );
        } catch (e) {
            console.error('[CRITICAL] Failed to write exception to log:', e.message);
        }
    }

    // 不要立即退出，让服务器继续运行
    console.log('[CRITICAL] Server will continue running despite the exception.');
});

// 新增：捕获未处理的 Promise 拒绝
process.on('unhandledRejection', (reason, promise) => {
    console.error('[WARNING] Unhandled Promise Rejection at:', promise);
    console.error('[WARNING] Reason:', reason);

    // 记录到日志文件
    const serverLogWriteStream = logger.getLogWriteStream();
    if (serverLogWriteStream && !serverLogWriteStream.destroyed) {
        try {
            serverLogWriteStream.write(
                `[${dayjs().tz(DEFAULT_TIMEZONE).format('YYYY-MM-DD HH:mm:ss Z')}] [WARNING] Unhandled Promise Rejection: ${reason}\n`
            );
        } catch (e) {
            console.error('[WARNING] Failed to write rejection to log:', e.message);
        }
    }
});

// Ensure log stream is flushed on uncaught exceptions or synchronous exit, though less reliable
process.on('exit', (code) => {
    logger.originalConsoleLog(`[Server] Exiting with code ${code}.`);
    const serverLogWriteStream = logger.getLogWriteStream();
    const currentServerLogPath = logger.getServerLogPath();
    if (serverLogWriteStream && !serverLogWriteStream.destroyed) {
        try {
            fsSync.appendFileSync(currentServerLogPath, `[${dayjs().tz(DEFAULT_TIMEZONE).format('YYYY-MM-DD HH:mm:ss Z')}] Server exited with code ${code}.\n`);
            serverLogWriteStream.end();
        } catch (e) {
            logger.originalConsoleError('[Server] Error during final log write on exit:', e.message);
        }
    }
});