@ohos-cpf/3rdloop 0.0.1

package/vendor/Server/Routes/controllers/StatsController.js

@@ -0,0 +1,57 @@
+import { StatsService } from '../../library/StatsService.js';
+import { getSessionSemaphoreStats } from '../../Orchestrator/Orchestrator.js';
+
+/**
+ * StatsController —— 统计控制器
+ *
+ * 职责：提供访问计数、Session 调用计数、Session 并发占用的查询接口。
+ */
+class StatsController {
+
+    /**
+     * GET /api/stats/visit
+     * 获取页面访问计数，并自增（每次页面加载调用一次）
+     */
+    async visit(req, res) {
+        try {
+            const count = await StatsService.incrementVisitCount();
+            res.json({ success: true, data: { visitCount: count } });
+        } catch (err) {
+            res.json({ success: false, data: { visitCount: 0 }, error: err.message });
+        }
+    }
+
+    /**
+     * GET /api/stats/session/count
+     * 获取 Session 调用计数（只读，不自增）
+     */
+    async sessionCount(req, res) {
+        try {
+            const count = await StatsService.getSessionCount();
+            res.json({ success: true, data: { sessionCount: count } });
+        } catch (err) {
+            res.json({ success: false, data: { sessionCount: 0 }, error: err.message });
+        }
+    }
+
+    /**
+     * GET /api/stats/session/concurrency
+     * 获取全局 Session 并发占用快照（Orchestrator 进程级信号量）。
+     *
+     * 返回：
+     *   active   - 当前活跃 Session 数（正在执行的编排步骤数）
+     *   limit    - 并发上限（MAX_CONCURRENT_SESSIONS，默认 50）
+     *   waiting  - 排队等待槽位的步骤数
+     *   utilization - 占用率（0-100）
+     */
+    async sessionConcurrency(req, res) {
+        try {
+            const stats = getSessionSemaphoreStats();
+            res.json({ success: true, data: stats });
+        } catch (err) {
+            res.json({ success: false, data: null, error: err.message });
+        }
+    }
+}
+
+export default StatsController;

package/vendor/Server/Routes/controllers/StreamController.js

@@ -0,0 +1,67 @@
+import SseHub from '../sse/SseHub.js';
+
+/**
+ * StreamController —— SSE 实时推送控制器
+ *
+ * 职责：处理 SSE 订阅请求，将 HTTP 响应注册到 SseHub。
+ * 不感知具体业务事件（步骤状态等），只负责连接管理。
+ *
+ * 事件由业务层（Agent Loop）通过 sseHub.emit() 推送，本控制器不产生事件。
+ */
+class StreamController {
+    /**
+     * @param {SseHub} sseHub
+     */
+    constructor(sseHub) {
+        this.sseHub = sseHub;
+    }
+
+    /**
+     * GET /stream/tasks/:taskId
+     * 订阅指定任务的实时事件流
+     *
+     * 前端用法：
+     *   const es = new EventSource('/stream/tasks/task-xxx');
+     *   es.addEventListener('step:status', (e) => { ... });
+     *   es.addEventListener('step:completed', (e) => { ... });
+     */
+    async subscribeTask(req, res) {
+        const { taskId } = req.params;
+        const userId = req.query.userId || 'anonymous';
+
+        // 响应头已在 ResponseContext.stream() 中设置
+        res.stream();
+
+        const result = this.sseHub.subscribe(taskId, res.raw, {
+            userId,
+            initialData: {
+                taskId,
+                message: 'SSE 连接已建立',
+                timestamp: new Date().toISOString()
+            }
+        });
+
+        if (!result.ok) {
+            // 订阅被拒（限流等），已写入流头无法改 HTTP 状态码，
+            // 通过 SSE 事件通知客户端后关闭连接
+            this.sseHub.emit(taskId, 'error', {
+                code: result.errorCode,
+                message: result.message
+            });
+            res.raw.end();
+        }
+    }
+
+    /**
+     * GET /stream/stats
+     * 返回 SSE Hub 全局统计信息（REST 接口，非 SSE 流）
+     */
+    async stats(req, res) {
+        res.json({
+            ...this.sseHub.getStats(),
+            timestamp: new Date().toISOString()
+        });
+    }
+}
+
+export default StreamController;

package/vendor/Server/Routes/library/logger.js

@@ -0,0 +1,179 @@
+/**
+ * 轻量日志工具（支持文件持久化）
+ *
+ * 为 Routes 层提供统一日志接口。
+ * - 控制台：带 ANSI 颜色的高亮输出
+ * - 文件：纯文本（去除颜色码），按天轮转写入 db/log/app-YYYY-MM-DD.log
+ *
+ * 环境变量：
+ *   LOG_LEVEL          日志级别（debug/info/warn/error），默认 info
+ *   LOG_FILE_ENABLED   是否启用文件持久化（true/false），默认 true
+ *   LOG_RETENTION_DAYS 日志保留天数，超过自动清理，默认 30
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
+const MIN_LEVEL = LEVELS[process.env.LOG_LEVEL ?? 'info'] ?? LEVELS.info;
+
+const COLORS = {
+    debug: '\x1b[90m',
+    info:  '\x1b[36m',
+    warn:  '\x1b[33m',
+    error: '\x1b[31m',
+    reset: '\x1b[0m'
+};
+
+// ─── 文件持久化配置 ──────────────────────────────────────────────────
+const FILE_ENABLED = process.env.LOG_FILE_ENABLED !== 'false';
+const RETENTION_DAYS = parseInt(process.env.LOG_RETENTION_DAYS ?? '30', 10);
+
+// 解析 db/ 根目录：从 Server/Routes/library/ 上溯 4 层到 workspace 根
+const DB_ROOT = path.resolve(__dirname, '..', '..', '..', '..', 'db');
+const LOG_DIR = path.join(DB_ROOT, 'log');
+
+/** @type {import('node:fs').WriteStream | null} */
+let _stream = null;
+let _streamDate = '';
+
+/**
+ * 获取当天日期字符串 (YYYY-MM-DD)。
+ */
+function _today() {
+    return new Date().toISOString().slice(0, 10);
+}
+
+/**
+ * 获取（或轮转）当前日志文件的 WriteStream。
+ * 日期变化时自动关闭旧流、创建新流，实现按天轮转。
+ * @returns {import('node:fs').WriteStream | null}
+ */
+function _getStream() {
+    if (!FILE_ENABLED) return null;
+
+    const today = _today();
+    if (_stream && _streamDate === today) {
+        return _stream;
+    }
+
+    // 日期变化 → 关闭旧流
+    if (_stream) {
+        _stream.end();
+        _stream = null;
+    }
+
+    try {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+        const file = path.join(LOG_DIR, `app-${today}.log`);
+        _stream = fs.createWriteStream(file, { flags: 'a', encoding: 'utf8' });
+        _streamDate = today;
+        _stream.on('error', (err) => {
+            console.error(`[Logger] 文件写入失败，降级为仅控制台输出: ${err.message}`);
+            _stream = null;
+        });
+        // 启动时清理过期日志
+        _cleanupOldLogs();
+    } catch (err) {
+        console.error(`[Logger] 无法创建日志文件: ${err.message}`);
+        _stream = null;
+    }
+
+    return _stream;
+}
+
+/**
+ * 清理超过保留天数的旧日志文件（幂等，失败静默）。
+ */
+function _cleanupOldLogs() {
+    try {
+        const files = fs.readdirSync(LOG_DIR);
+        const now = Date.now();
+        const maxAgeMs = RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        for (const file of files) {
+            if (!file.startsWith('app-') || !file.endsWith('.log')) continue;
+            const filePath = path.join(LOG_DIR, file);
+            const stat = fs.statSync(filePath);
+            if (now - stat.mtimeMs > maxAgeMs) {
+                fs.unlinkSync(filePath);
+                console.debug(`[Logger] 已清理过期日志: ${file}`);
+            }
+        }
+    } catch {
+        // 清理失败不影响主流程
+    }
+}
+
+// 进程退出时刷新写入流
+process.on('exit', () => {
+    if (_stream) {
+        _stream.end();
+    }
+});
+
+/**
+ * 格式化日志行（带 ANSI 颜色，用于控制台）。
+ */
+function format(level, tag, message, meta) {
+    const time = new Date().toISOString();
+    const prefix = `${COLORS[level]}${time} [${tag}] ${level.toUpperCase()}${COLORS.reset} ${message}`;
+    if (meta && Object.keys(meta).length > 0) {
+        return `${prefix} ${JSON.stringify(meta)}`;
+    }
+    return prefix;
+}
+
+/**
+ * 格式化日志行（纯文本，用于文件写入）。
+ */
+function formatPlain(level, tag, message, meta) {
+    const time = new Date().toISOString();
+    const prefix = `${time} [${tag}] ${level.toUpperCase()} ${message}`;
+    if (meta && Object.keys(meta).length > 0) {
+        return `${prefix} ${JSON.stringify(meta)}`;
+    }
+    return prefix;
+}
+
+/**
+ * 将一行日志异步写入文件（非阻塞）。
+ * @param {string} line
+ */
+function _writeFile(line) {
+    const stream = _getStream();
+    if (stream) {
+        stream.write(line + '\n');
+    }
+}
+
+export function createLogger(tag) {
+    return {
+        debug: (msg, meta) => {
+            // debug 始终写入文件，但不打印到控制台
+            _writeFile(formatPlain('debug', tag, msg, meta));
+        },
+        info: (msg, meta) => {
+            if (LEVELS.info >= MIN_LEVEL) {
+                console.log(format('info', tag, msg, meta));
+                _writeFile(formatPlain('info', tag, msg, meta));
+            }
+        },
+        warn: (msg, meta) => {
+            if (LEVELS.warn >= MIN_LEVEL) {
+                console.warn(format('warn', tag, msg, meta));
+                _writeFile(formatPlain('warn', tag, msg, meta));
+            }
+        },
+        error: (msg, meta) => {
+            if (LEVELS.error >= MIN_LEVEL) {
+                console.error(format('error', tag, msg, meta));
+                _writeFile(formatPlain('error', tag, msg, meta));
+            }
+        }
+    };
+}
+
+export default createLogger;

package/vendor/Server/Routes/library/zipArchive.js

@@ -0,0 +1,172 @@
+/**
+ * zipArchive.js — 零依赖 ZIP 打包工具（仅用 Node 内置模块）
+ *
+ * 用途：将任务目录下的检视报告（.md）打包为 ZIP 供前端下载。
+ * 实现：传统 ZIP 格式（PKZIP 2.0），deflate 压缩（zlib.deflateRawSync），
+ *       压缩后不小于原文时回退 STORE；文件名 UTF-8（bit11 标志，支持中文）。
+ *
+ * 不使用 ZIP64：文件数 > 65535 或单文件/归档 > 4GB 时抛错（检视报告远小于该量级）。
+ *
+ * 用法：
+ *   import { createZipBuffer } from '../library/zipArchive.js';
+ *   const zip = createZipBuffer([
+ *     { name: 'taskId/报告.md', data: buffer, mtime: new Date() },
+ *   ]);
+ */
+
+import zlib from 'node:zlib';
+
+// ─── CRC32（PKZIP 多项式 0xEDB88320）────────────────────────────────────────
+
+const CRC_TABLE = (() => {
+    const table = new Int32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+        }
+        table[n] = c;
+    }
+    return table;
+})();
+
+/**
+ * @param {Buffer} buf
+ * @returns {number} 无符号 CRC32
+ */
+function crc32(buf) {
+    let crc = -1;
+    for (let i = 0; i < buf.length; i++) {
+        crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ buf[i]) & 0xFF];
+    }
+    return (crc ^ -1) >>> 0;
+}
+
+/**
+ * JS Date → ZIP 的 DOS 时间/日期字段。
+ * @param {Date|number|string} [date]
+ * @returns {{time: number, day: number}}
+ */
+function dosDateTime(date) {
+    const d = date instanceof Date ? date : new Date(date || Date.now());
+    const year = Math.min(2107, Math.max(1980, d.getFullYear()));
+    const time = (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2);
+    const day = ((year - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+    return { time, day };
+}
+
+const MAX_UINT16 = 0xFFFF;
+const MAX_UINT32 = 0xFFFFFFFF;
+
+const LOCAL_HEADER_SIG = 0x04034b50;
+const CENTRAL_HEADER_SIG = 0x02014b50;
+const EOCD_SIG = 0x06054b50;
+const FLAG_UTF8 = 0x0800;         // bit11：文件名为 UTF-8 编码
+const METHOD_STORE = 0;
+const METHOD_DEFLATE = 8;
+
+/**
+ * 构建 ZIP 归档 Buffer。
+ *
+ * @param {Array<{name: string, data: Buffer, mtime?: Date}>} files - 文件列表（name 支持 UTF-8 中文，可含目录前缀）
+ * @returns {Buffer} 完整 ZIP 归档
+ * @throws {Error} 文件列表为空 / 超出传统 ZIP 格式上限
+ */
+export function createZipBuffer(files) {
+    if (!Array.isArray(files) || files.length === 0) {
+        throw new Error('createZipBuffer: files 不能为空');
+    }
+    if (files.length > MAX_UINT16) {
+        throw new Error(`createZipBuffer: 文件数 ${files.length} 超过传统 ZIP 上限 65535（需 ZIP64）`);
+    }
+
+    /** @type {Buffer[]} 顺序拼接的片段（local headers + 数据） */
+    const locals = [];
+    /** @type {Buffer[]} 中央目录记录 */
+    const centrals = [];
+    /** 当前文件 local header 的起始偏移 */
+    let offset = 0;
+
+    for (const f of files) {
+        const nameBuf = Buffer.from(f.name, 'utf8');
+        if (nameBuf.length > MAX_UINT16) {
+            throw new Error(`createZipBuffer: 文件名过长: ${f.name}`);
+        }
+        const data = Buffer.isBuffer(f.data) ? f.data : Buffer.from(f.data);
+        const crc = crc32(data);
+
+        // deflate 压缩；不小于原文时回退 STORE
+        let method = METHOD_DEFLATE;
+        let payload = zlib.deflateRawSync(data, { level: 9 });
+        if (payload.length >= data.length) {
+            method = METHOD_STORE;
+            payload = data;
+        }
+
+        if (data.length > MAX_UINT32 || payload.length > MAX_UINT32) {
+            throw new Error(`createZipBuffer: 文件过大（需 ZIP64）: ${f.name}`);
+        }
+
+        const { time, day } = dosDateTime(f.mtime);
+
+        // ── Local File Header（30 字节 + 文件名）──
+        const lh = Buffer.alloc(30);
+        lh.writeUInt32LE(LOCAL_HEADER_SIG, 0);
+        lh.writeUInt16LE(20, 4);                      // version needed: 2.0
+        lh.writeUInt16LE(FLAG_UTF8, 6);               // flags: UTF-8 文件名
+        lh.writeUInt16LE(method, 8);
+        lh.writeUInt16LE(time, 10);
+        lh.writeUInt16LE(day, 12);
+        lh.writeUInt32LE(crc, 14);
+        lh.writeUInt32LE(payload.length, 18);         // compressed size
+        lh.writeUInt32LE(data.length, 22);            // uncompressed size
+        lh.writeUInt16LE(nameBuf.length, 26);
+        lh.writeUInt16LE(0, 28);                      // extra field length
+
+        locals.push(lh, nameBuf, payload);
+
+        // ── Central Directory Record（46 字节 + 文件名）──
+        const cd = Buffer.alloc(46);
+        cd.writeUInt32LE(CENTRAL_HEADER_SIG, 0);
+        cd.writeUInt16LE(0x0314, 4);                  // version made by: UNIX(3) + ZIP 2.0
+        cd.writeUInt16LE(20, 6);                      // version needed
+        cd.writeUInt16LE(FLAG_UTF8, 8);
+        cd.writeUInt16LE(method, 10);
+        cd.writeUInt16LE(time, 12);
+        cd.writeUInt16LE(day, 14);
+        cd.writeUInt32LE(crc, 16);
+        cd.writeUInt32LE(payload.length, 20);
+        cd.writeUInt32LE(data.length, 24);
+        cd.writeUInt16LE(nameBuf.length, 28);
+        cd.writeUInt16LE(0, 30);                      // extra length
+        cd.writeUInt16LE(0, 32);                      // comment length
+        cd.writeUInt16LE(0, 34);                      // disk number start
+        cd.writeUInt16LE(0, 36);                      // internal attrs
+        cd.writeUInt32LE((0o100644 << 16) >>> 0, 38); // external attrs: UNIX rw-r--r--
+        cd.writeUInt32LE(offset, 42);                 // local header 偏移
+
+        centrals.push(Buffer.concat([cd, nameBuf]));
+
+        offset += 30 + nameBuf.length + payload.length;
+    }
+
+    if (offset > MAX_UINT32) {
+        throw new Error('createZipBuffer: 归档总大小超过 4GB（需 ZIP64）');
+    }
+    const cdBuf = Buffer.concat(centrals);
+
+    // ── End of Central Directory（22 字节）──
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(EOCD_SIG, 0);
+    eocd.writeUInt16LE(0, 4);                         // 当前磁盘号
+    eocd.writeUInt16LE(0, 6);                         // 中央目录所在磁盘号
+    eocd.writeUInt16LE(files.length, 8);              // 本磁盘条目数
+    eocd.writeUInt16LE(files.length, 10);             // 总条目数
+    eocd.writeUInt32LE(cdBuf.length, 12);             // 中央目录大小
+    eocd.writeUInt32LE(offset, 16);                   // 中央目录起始偏移
+    eocd.writeUInt16LE(0, 20);                        // 注释长度
+
+    return Buffer.concat([...locals, cdBuf, eocd]);
+}
+
+export default { createZipBuffer };

package/vendor/Server/Routes/router/Router.js

@@ -0,0 +1,204 @@
+import http from 'node:http';
+
+/**
+ * Router —— 轻量级 HTTP 路由器
+ *
+ * 职责：路由匹配、参数提取、请求分发。不感知业务逻辑。
+ *
+ * 设计要点：
+ *  - 高内聚：只负责「URL → handler」的映射与分发
+ *  - 低耦合：不依赖任何业务模块，handler 由各 Controller 自行注册
+ *  - 统一响应：封装 sendJson / sendError，保证响应格式一致
+ *  - 中间件链：支持 per-route 中间件（鉴权、日志等）
+ *
+ * 路由匹配规则：
+ *  - 精确匹配优先：/api/health 优先于 /api/:id
+ *  - 参数提取：/api/tasks/:taskId → req.params.taskId
+ *  - 通配符：/api/files/* → req.params[0] 为剩余路径
+ */
+
+/**
+ * @typedef {(req: RequestContext, res: ResponseContext, next: () => void) => void} Middleware
+ * @typedef {(req: RequestContext, res: ResponseContext) => void|Promise<void>} Handler
+ */
+
+/**
+ * 请求上下文：在原生 req 基础上注入路由参数与解析后的 body
+ */
+class RequestContext {
+    constructor(req, url) {
+        this.raw = req;
+        this.method = req.method;
+        this.url = url;
+        this.pathname = url.pathname;
+        this.query = Object.fromEntries(url.searchParams);
+        this.params = {};
+        this.body = null;
+    }
+}
+
+/**
+ * 响应上下文：封装统一响应方法
+ */
+class ResponseContext {
+    constructor(res) {
+        this.raw = res;
+    }
+
+    /** JSON 成功响应 */
+    json(data, status = 200) {
+        const body = JSON.stringify(data);
+        this.raw.writeHead(status, {
+            'Content-Type': 'application/json; charset=utf-8',
+            'Content-Length': Buffer.byteLength(body)
+        });
+        this.raw.end(body);
+    }
+
+    /** 错误响应 */
+    error(status, message, extra = {}) {
+        this.json({ error: message, ...extra }, status);
+    }
+
+    /** SSE 流式响应头（供实时推送端点使用） */
+    stream() {
+        this.raw.writeHead(200, {
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no'  // Nginx 反代时不缓冲
+        });
+        return this.raw;
+    }
+}
+
+/**
+ * 将路径转为正则 + 参数名数组
+ * /api/tasks/:taskId → { regex: /^\/api\/tasks\/([^/]+)$/, keys: ['taskId'] }
+ * /api/files/*       → { regex: /^\/api\/files\/(.*)$/, keys: [0] }
+ */
+function compilePath(path) {
+    const keys = [];
+    const regexStr = path
+        .replace(/\*/g, () => { keys.push(0); return '(.*)'; })
+        .replace(/:([^/]+)/g, (_, name) => { keys.push(name); return '([^/]+)'; });
+    return { regex: new RegExp(`^${regexStr}$`), keys };
+}
+
+class Router {
+    constructor() {
+        /** @type {{ method: string, path: string, compiled: {regex, keys}, middlewares: Middleware[], handler: Handler }[]} */
+        this.routes = [];
+    }
+
+    /**
+     * 注册路由
+     * @param {string} method   - HTTP 方法
+     * @param {string} path     - 路径模板，支持 :param 和 *
+     * @param {Handler} handler - 业务处理函数
+     * @param {Middleware[]} [middlewares=[]] - 中间件链
+     */
+    register(method, path, handler, middlewares = []) {
+        this.routes.push({ method, path, compiled: compilePath(path), middlewares, handler });
+    }
+
+    // 便捷方法
+    get(path, handler, middlewares)    { this.register('GET',    path, handler, middlewares); }
+    post(path, handler, middlewares)   { this.register('POST',   path, handler, middlewares); }
+    put(path, handler, middlewares)    { this.register('PUT',    path, handler, middlewares); }
+    delete(path, handler, middlewares) { this.register('DELETE', path, handler, middlewares); }
+
+    /**
+     * 挂载子路由（按前缀聚合）
+     * @param {string} prefix  - 路径前缀，如 /api/health
+     * @param {Router} router  - 子路由器
+     */
+    use(prefix, router) {
+        for (const route of router.routes) {
+            this.routes.push({
+                ...route,
+                path: prefix + route.path,
+                compiled: compilePath(prefix + route.path)
+            });
+        }
+    }
+
+    /**
+     * 匹配并执行路由
+     * @returns {boolean} 是否命中
+     */
+    async handle(req, res) {
+        const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+        const ctxReq = new RequestContext(req, url);
+        const ctxRes = new ResponseContext(res);
+
+        // CORS 预检
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+            });
+            res.end();
+            return true;
+        }
+
+        // 注入 CORS 头到所有响应
+        res.setHeader('Access-Control-Allow-Origin', '*');
+
+        // 查找匹配路由
+        for (const route of this.routes) {
+            if (route.method !== req.method) continue;
+            const match = ctxReq.pathname.match(route.compiled.regex);
+            if (!match) continue;
+
+            // 提取路径参数
+            route.compiled.keys.forEach((key, i) => {
+                ctxReq.params[key] = decodeURIComponent(match[i + 1]);
+            });
+
+            // 解析 body（POST/PUT/DELETE）
+            if (['POST', 'PUT', 'PATCH'].includes(req.method) && req.headers['content-type']?.includes('application/json')) {
+                ctxReq.body = await this._readJsonBody(req);
+            }
+
+            // 执行中间件链 → handler
+            try {
+                await this._runChain(route.middlewares, route.handler, ctxReq, ctxRes);
+            } catch (err) {
+                ctxRes.error(500, `内部错误: ${err.message}`);
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    _runChain(middlewares, handler, req, res) {
+        let index = 0;
+        const stack = [...middlewares, async (r, rs) => handler(r, rs)];
+
+        const next = () => {
+            if (index < stack.length) {
+                return Promise.resolve(stack[index++](req, res, next));
+            }
+        };
+        return next();
+    }
+
+    _readJsonBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', chunk => { data += chunk; });
+            req.on('end', () => {
+                if (!data) return resolve(null);
+                try { resolve(JSON.parse(data)); }
+                catch { reject(new Error('JSON 解析失败')); }
+            });
+            req.on('error', reject);
+        });
+    }
+}
+
+export { Router, RequestContext, ResponseContext };
+export default Router;