@jonathanleelx/meddle 0.0.1

package/dist/server/plugins.js

@@ -0,0 +1,795 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reloadPlugins = reloadPlugins;
+exports.setPluginEnabled = setPluginEnabled;
+exports.sortPluginsByHookOrder = sortPluginsByHookOrder;
+exports.selectTestPluginsForHook = selectTestPluginsForHook;
+exports.registerPluginsRoutes = registerPluginsRoutes;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function reloadPlugins(ctx) {
+    const plugins = await ctx.reloadCustomPlugins();
+    const summaries = plugins.map((p) => {
+        const plugin = p;
+        return {
+            id: plugin.manifest.id,
+            name: plugin.manifest.name,
+            version: plugin.manifest.version,
+        };
+    });
+    return {
+        status: 'success',
+        message: `已重新加载 ${summaries.length} 个自定义插件`,
+        count: summaries.length,
+        plugins: summaries,
+    };
+}
+function setPluginEnabled(ctx, pluginId, enabled) {
+    const allPlugins = ctx.pluginManager.getAll();
+    const target = allPlugins.find(p => p.manifest.id === pluginId);
+    if (!target) {
+        throw new Error('插件不存在');
+    }
+    const newState = enabled ? 'running' : 'disabled';
+    ctx.pluginManager.setState(pluginId, newState);
+    try {
+        let settings = {};
+        if (fs.existsSync(ctx.settingsPath)) {
+            settings = JSON.parse(fs.readFileSync(ctx.settingsPath, 'utf8'));
+        }
+        const disabledPlugins = Array.isArray(settings.disabledPlugins)
+            ? settings.disabledPlugins
+            : [];
+        if (enabled) {
+            settings.disabledPlugins = disabledPlugins.filter(id => id !== pluginId);
+        }
+        else {
+            if (!disabledPlugins.includes(pluginId)) {
+                disabledPlugins.push(pluginId);
+            }
+            settings.disabledPlugins = disabledPlugins;
+        }
+        fs.writeFileSync(ctx.settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+    }
+    catch (e) {
+        console.error('保存插件状态失败:', e);
+    }
+    return {
+        status: 'success',
+        pluginId,
+        state: newState,
+    };
+}
+function sortPluginsByHookOrder(plugins) {
+    return [...plugins].sort((a, b) => {
+        const priorityA = typeof a.manifest.priority === 'number' ? a.manifest.priority : 100;
+        const priorityB = typeof b.manifest.priority === 'number' ? b.manifest.priority : 100;
+        if (priorityA !== priorityB)
+            return priorityA - priorityB;
+        return a.manifest.id.localeCompare(b.manifest.id);
+    });
+}
+function selectTestPluginsForHook(allPlugins, hookName, targetPluginId, includeBuiltinFlow) {
+    const allowedIds = new Set([targetPluginId]);
+    if (includeBuiltinFlow) {
+        allowedIds.add('builtin.mock');
+        allowedIds.add('builtin.router');
+    }
+    return sortPluginsByHookOrder(allPlugins.filter((plugin) => allowedIds.has(plugin.manifest.id) &&
+        Array.isArray(plugin.manifest.hooks) &&
+        plugin.manifest.hooks.includes(hookName)));
+}
+function registerPluginsRoutes(app, ctx) {
+    const meddleDir = ctx.meddleDir;
+    // API: 生成插件代码（流式）
+    app.post('/api/plugins/generate-stream', async (req, res) => {
+        try {
+            const data = req.body;
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { generatePluginStream, cleanAIResponse } = require('../core/plugin-generator');
+            // 设置 SSE 响应头
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*'
+            });
+            // 发送初始事件
+            res.write('event: start\n');
+            res.write('data: {"status":"generating"}\n\n');
+            let accumulatedCode = '';
+            // 生成插件，实时发送chunk
+            const result = await generatePluginStream(data.requirement, data.aiConfig, (chunk) => {
+                accumulatedCode += chunk;
+                res.write('event: chunk\n');
+                res.write(`data: ${JSON.stringify({ chunk, accumulated: cleanAIResponse(accumulatedCode) })}\n\n`);
+            });
+            // 发送完成事件
+            res.write('event: complete\n');
+            res.write(`data: ${JSON.stringify({ status: 'success', plugin: result })}\n\n`);
+            res.end();
+        }
+        catch (error) {
+            res.write('event: error\n');
+            res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+            res.end();
+        }
+    });
+    // API: 生成插件代码（非流式，向后兼容）
+    app.post('/api/plugins/generate', async (req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        try {
+            const data = req.body;
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { generatePlugin } = require('../core/plugin-generator');
+            const result = await generatePlugin(data.requirement, data.aiConfig);
+            res.write(JSON.stringify({ status: 'success', plugin: result }));
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.write(JSON.stringify({ error: error.message }));
+        }
+        res.end();
+    });
+    // API: 保存插件到配置目录
+    app.post('/api/plugins/save', (req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        try {
+            const data = req.body;
+            const pluginsDir = path.resolve(meddleDir, 'plugins');
+            // 创建 plugins 目录
+            if (!fs.existsSync(pluginsDir)) {
+                fs.mkdirSync(pluginsDir, { recursive: true });
+            }
+            const filePath = path.resolve(pluginsDir, data.filename);
+            fs.writeFileSync(filePath, data.code, 'utf8');
+            console.log(`已保存插件: ${data.filename}`);
+            res.write(JSON.stringify({
+                status: 'success',
+                message: '插件已保存',
+                path: filePath
+            }));
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.write(JSON.stringify({ error: error.message }));
+        }
+        res.end();
+    });
+    // API: 列出自定义插件
+    app.get('/api/plugins/custom', (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        try {
+            const pluginsDir = path.resolve(meddleDir, 'plugins');
+            if (!fs.existsSync(pluginsDir)) {
+                res.write(JSON.stringify({ plugins: [] }));
+                res.end();
+                return;
+            }
+            const files = fs.readdirSync(pluginsDir);
+            const pluginInfo = [];
+            // 只列出.js文件
+            const jsFiles = files.filter(f => f.endsWith('.js'));
+            jsFiles.forEach(jsFile => {
+                const jsPath = path.resolve(pluginsDir, jsFile);
+                const jsStat = fs.statSync(jsPath);
+                pluginInfo.push({
+                    filename: jsFile,
+                    path: jsPath,
+                    modified: jsStat.mtime
+                });
+            });
+            res.write(JSON.stringify({ plugins: pluginInfo }));
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.write(JSON.stringify({ error: error.message }));
+        }
+        res.end();
+    });
+    // API: 读取插件源码
+    app.get('/api/plugins/custom/:filename/code', (req, res) => {
+        try {
+            const filename = decodeURIComponent(req.params.filename);
+            const pluginsDir = path.resolve(meddleDir, 'plugins');
+            const filePath = path.resolve(pluginsDir, filename);
+            if (!filePath.startsWith(pluginsDir)) {
+                res.status(403).json({ error: '非法的文件路径' });
+                return;
+            }
+            if (!fs.existsSync(filePath)) {
+                res.status(404).json({ error: '插件文件不存在' });
+                return;
+            }
+            const code = fs.readFileSync(filePath, 'utf8');
+            res.json({ filename, code });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // API: 更新插件源码
+    app.put('/api/plugins/custom/:filename/code', (req, res) => {
+        try {
+            const filename = decodeURIComponent(req.params.filename);
+            const pluginsDir = path.resolve(meddleDir, 'plugins');
+            const filePath = path.resolve(pluginsDir, filename);
+            if (!filePath.startsWith(pluginsDir)) {
+                res.status(403).json({ error: '非法的文件路径' });
+                return;
+            }
+            if (!fs.existsSync(filePath)) {
+                res.status(404).json({ error: '插件文件不存在' });
+                return;
+            }
+            const { code } = req.body;
+            if (typeof code !== 'string') {
+                res.status(400).json({ error: '缺少 code 字段' });
+                return;
+            }
+            fs.writeFileSync(filePath, code, 'utf8');
+            console.log(`已更新插件代码: ${filename}`);
+            res.json({ status: 'success', message: '插件代码已保存' });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // API: 删除自定义插件
+    app.delete('/api/plugins/custom/:filename', (req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        try {
+            const filename = decodeURIComponent(req.params.filename);
+            const pluginsDir = path.resolve(meddleDir, 'plugins');
+            const filePath = path.resolve(pluginsDir, filename);
+            // 安全检查：确保文件在 plugins 目录内
+            if (!filePath.startsWith(pluginsDir)) {
+                res.statusCode = 403;
+                res.write(JSON.stringify({ error: '非法的文件路径' }));
+                res.end();
+                return;
+            }
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+                // 同时删除编译后的.js文件
+                if (filename.endsWith('.ts')) {
+                    const jsPath = filePath.replace(/\.ts$/, '.js');
+                    if (fs.existsSync(jsPath)) {
+                        fs.unlinkSync(jsPath);
+                    }
+                }
+                res.write(JSON.stringify({
+                    status: 'success',
+                    message: '插件已删除'
+                }));
+            }
+            else {
+                res.statusCode = 404;
+                res.write(JSON.stringify({ error: '插件文件不存在' }));
+            }
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.write(JSON.stringify({ error: error.message }));
+        }
+        res.end();
+    });
+    // API: 热加载自定义插件
+    app.post('/api/plugins/reload', async (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        try {
+            res.write(JSON.stringify(await reloadPlugins(ctx)));
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.write(JSON.stringify({ error: error.message }));
+        }
+        res.end();
+    });
+    // API: AI自动修复插件
+    app.post('/api/plugins/fix', async (req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        try {
+            const data = req.body;
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { fixPluginWithAI } = require('../core/plugin-generator');
+            const fixedCode = await fixPluginWithAI(data.originalCode, data.testError, data.requirement, data.aiConfig);
+            res.write(JSON.stringify({ status: 'success', fixedCode }));
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.write(JSON.stringify({ error: error.message }));
+        }
+        res.end();
+    });
+    // API: AI自动修复插件（流式）
+    app.post('/api/plugins/fix-stream', async (req, res) => {
+        try {
+            const data = req.body;
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { fixPluginWithAIStream, cleanAIResponse } = require('../core/plugin-generator');
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*'
+            });
+            res.write('event: start\n');
+            res.write('data: {"status":"generating"}\n\n');
+            let accumulatedCode = '';
+            const fixedCode = await fixPluginWithAIStream(data.originalCode, data.testError, data.requirement, data.aiConfig, (chunk) => {
+                accumulatedCode += chunk;
+                res.write('event: chunk\n');
+                res.write(`data: ${JSON.stringify({ chunk, accumulated: cleanAIResponse(accumulatedCode) })}\n\n`);
+            });
+            res.write('event: complete\n');
+            res.write(`data: ${JSON.stringify({ status: 'success', fixedCode })}\n\n`);
+            res.end();
+        }
+        catch (error) {
+            res.write('event: error\n');
+            res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+            res.end();
+        }
+    });
+    app.post('/api/plugins/revise-stream', async (req, res) => {
+        try {
+            const data = req.body;
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { revisePluginWithAIStream, cleanAIResponse } = require('../core/plugin-generator');
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*'
+            });
+            res.write('event: start\n');
+            res.write('data: {"status":"generating"}\n\n');
+            let accumulatedCode = '';
+            const revisedCode = await revisePluginWithAIStream(data.originalCode, data.instruction, data.requirement, data.aiConfig, (chunk) => {
+                accumulatedCode += chunk;
+                res.write('event: chunk\n');
+                res.write(`data: ${JSON.stringify({ chunk, accumulated: cleanAIResponse(accumulatedCode) })}\n\n`);
+            });
+            res.write('event: complete\n');
+            res.write(`data: ${JSON.stringify({ status: 'success', revisedCode })}\n\n`);
+            res.end();
+        }
+        catch (error) {
+            res.write('event: error\n');
+            res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+            res.end();
+        }
+    });
+    // API: 测试插件功能（真实请求模式）
+    app.post('/api/plugins/test', async (req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        try {
+            const data = req.body;
+            const pluginId = data.pluginId;
+            const url = data.url || 'http://example.com/test';
+            const method = (data.method || 'GET').toUpperCase();
+            const integrated = data.integrated !== false;
+            const allPlugins = ctx.pluginManager.getAll();
+            const targetPlugin = allPlugins.find(p => p.manifest.id === pluginId);
+            if (!targetPlugin) {
+                res.status(404).json({ error: '插件不存在' });
+                return;
+            }
+            const testLogs = [];
+            const testLogger = {
+                debug: (...args) => testLogs.push({ level: 'debug', message: args.join(' '), timestamp: Date.now() }),
+                log: (...args) => testLogs.push({ level: 'log', message: args.join(' '), timestamp: Date.now() }),
+                info: (...args) => testLogs.push({ level: 'info', message: args.join(' '), timestamp: Date.now() }),
+                warn: (...args) => testLogs.push({ level: 'warn', message: args.join(' '), timestamp: Date.now() }),
+                error: (...args) => testLogs.push({ level: 'error', message: args.join(' '), timestamp: Date.now() }),
+            };
+            const hooks = targetPlugin.manifest.hooks || [];
+            const hookResults = {};
+            // integrated=true：尽量贴近真实代理前半段（直出 Mock / 内置 Mock / Router 的先后）
+            const source = url;
+            const legacyTarget = integrated && typeof ctx.resolveTargetUrlForTest === 'function'
+                ? ctx.resolveTargetUrlForTest(source)
+                : source;
+            const usePipelineFlow = integrated && typeof ctx.canUsePipelineExecuteForTest === 'function'
+                ? ctx.canUsePipelineExecuteForTest(source)
+                : false;
+            let currentTarget = usePipelineFlow ? source : legacyTarget;
+            const requestMutable = {
+                method,
+                url: source,
+                headers: { 'user-agent': 'meddle-test/1.0', ...(data.headers || {}) },
+                body: data.body || '',
+            };
+            const initialRequestSnapshot = { headers: { ...requestMutable.headers }, body: requestMutable.body };
+            let shortCircuited = false;
+            let shortCircuitResponse = null;
+            let realResponse = null;
+            let fetchError = null;
+            let fetchDuration = 0;
+            let usedMock = false;
+            const requestMeta = { _test: true, _pluginRequestStartAt: Date.now() };
+            // --- Phase 0: 与真实代理一致，先处理“直出 Mock”路径 ---
+            if (integrated) {
+                const mockRule = typeof ctx.matchMockRuleForTest === 'function'
+                    ? ctx.matchMockRuleForTest(source, method)
+                    : null;
+                if (mockRule && typeof ctx.shouldUseMockForTest === 'function' && ctx.shouldUseMockForTest(source, mockRule) && typeof ctx.buildMockResponseForTest === 'function') {
+                    const mockRes = ctx.buildMockResponseForTest(mockRule);
+                    currentTarget = source;
+                    realResponse = { statusCode: mockRes.statusCode, headers: mockRes.headers, body: mockRes.body };
+                    fetchDuration = 0;
+                    usedMock = true;
+                }
+            }
+            // --- Phase 1: onRequestStart / onBeforeProxy ---
+            if (!realResponse) {
+                for (const hookName of ['onRequestStart', 'onBeforeProxy']) {
+                    const orderedPlugins = selectTestPluginsForHook(allPlugins, hookName, pluginId, integrated && usePipelineFlow);
+                    if (orderedPlugins.length === 0)
+                        continue;
+                    const hookStartTarget = currentTarget;
+                    const hookCtx = {
+                        log: testLogger,
+                        request: requestMutable,
+                        target: currentTarget,
+                        meta: requestMeta,
+                        shortCircuited,
+                        shortCircuitResponse,
+                        setTarget: (t) => { hookCtx.target = t; currentTarget = t; },
+                        respond: (r) => {
+                            hookCtx.shortCircuited = true;
+                            hookCtx.shortCircuitResponse = r;
+                            shortCircuited = true;
+                            shortCircuitResponse = r;
+                        },
+                    };
+                    for (const plugin of orderedPlugins) {
+                        const hookFn = plugin[hookName];
+                        if (typeof hookFn !== 'function')
+                            continue;
+                        const t0 = Date.now();
+                        try {
+                            await hookFn.call(plugin, hookCtx);
+                            if (plugin.manifest.id === pluginId) {
+                                hookResults[hookName] = {
+                                    status: 'success',
+                                    duration: Date.now() - t0,
+                                    targetChanged: currentTarget !== hookStartTarget ? currentTarget : null,
+                                    shortCircuited,
+                                };
+                            }
+                        }
+                        catch (e) {
+                            if (plugin.manifest.id === pluginId) {
+                                hookResults[hookName] = {
+                                    status: 'error',
+                                    duration: Date.now() - t0,
+                                    error: e.message,
+                                    stack: e.stack,
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            const modifiedRequestSnapshot = { headers: { ...requestMutable.headers }, body: requestMutable.body };
+            const requestHeadersChanged = JSON.stringify(initialRequestSnapshot.headers) !== JSON.stringify(modifiedRequestSnapshot.headers);
+            const requestBodyChanged = initialRequestSnapshot.body !== modifiedRequestSnapshot.body;
+            // --- Phase 1.5: onAfterRequest (请求处理阶段完成，即将发送) ---
+            if (!shortCircuited && hooks.includes('onAfterRequest')) {
+                const hookFn = targetPlugin.onAfterRequest;
+                if (typeof hookFn === 'function') {
+                    const hookCtx = {
+                        log: testLogger,
+                        request: requestMutable,
+                        target: currentTarget,
+                        meta: { _test: true, _pluginRequestStartAt: Date.now() },
+                        requestSentAt: Date.now(),
+                    };
+                    const t0 = Date.now();
+                    try {
+                        await hookFn.call(targetPlugin, hookCtx);
+                        hookResults['onAfterRequest'] = { status: 'success', duration: Date.now() - t0 };
+                    }
+                    catch (e) {
+                        hookResults['onAfterRequest'] = { status: 'error', duration: Date.now() - t0, error: e.message, stack: e.stack };
+                    }
+                }
+            }
+            // --- Phase 2: 发起真实 HTTP 请求 ---
+            if (!shortCircuited) {
+                if (!realResponse) {
+                    const http = require('http');
+                    const https = require('https');
+                    const parsed = new URL(currentTarget);
+                    const transport = parsed.protocol === 'https:' ? https : http;
+                    const fetchStart = Date.now();
+                    try {
+                        realResponse = await new Promise((resolve, reject) => {
+                            const reqOpts = {
+                                hostname: parsed.hostname,
+                                port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+                                path: parsed.pathname + parsed.search,
+                                method: requestMutable.method,
+                                headers: requestMutable.headers,
+                                timeout: 15000,
+                                rejectUnauthorized: false,
+                            };
+                            const outReq = transport.request(reqOpts, (inRes) => {
+                                const chunks = [];
+                                inRes.on('data', (c) => chunks.push(c));
+                                inRes.on('end', () => {
+                                    const bodyBuf = Buffer.concat(chunks);
+                                    const hdrs = {};
+                                    for (const [k, v] of Object.entries(inRes.headers)) {
+                                        if (v)
+                                            hdrs[k] = Array.isArray(v) ? v.join(', ') : v;
+                                    }
+                                    resolve({
+                                        statusCode: inRes.statusCode || 0,
+                                        headers: hdrs,
+                                        body: bodyBuf.toString('utf-8'),
+                                    });
+                                });
+                            });
+                            outReq.on('error', reject);
+                            outReq.on('timeout', () => { outReq.destroy(); reject(new Error('请求超时 (15s)')); });
+                            if (requestMutable.body)
+                                outReq.write(requestMutable.body);
+                            outReq.end();
+                        });
+                    }
+                    catch (e) {
+                        fetchError = e.message;
+                    }
+                    fetchDuration = Date.now() - fetchStart;
+                }
+            }
+            // --- Phase 3: onBeforeResponse / onAfterResponse（用真实响应） ---
+            let modifiedResponse = null;
+            const originalBody = realResponse?.body || '';
+            if (realResponse && !shortCircuited) {
+                const responseCopy = {
+                    statusCode: realResponse.statusCode,
+                    headers: { ...realResponse.headers },
+                    body: realResponse.body,
+                };
+                for (const hookName of ['onBeforeResponse', 'onAfterResponse']) {
+                    if (!hooks.includes(hookName))
+                        continue;
+                    const hookFn = targetPlugin[hookName];
+                    if (typeof hookFn !== 'function')
+                        continue;
+                    const hookCtx = {
+                        log: testLogger,
+                        request: requestMutable,
+                        target: currentTarget,
+                        meta: { _test: true, _pluginRequestStartAt: Date.now() },
+                        response: responseCopy,
+                    };
+                    const t0 = Date.now();
+                    try {
+                        await hookFn.call(targetPlugin, hookCtx);
+                        hookResults[hookName] = { status: 'success', duration: Date.now() - t0 };
+                    }
+                    catch (e) {
+                        hookResults[hookName] = { status: 'error', duration: Date.now() - t0, error: e.message, stack: e.stack };
+                    }
+                }
+                modifiedResponse = responseCopy;
+            }
+            // --- Phase 4: 构造返回结果 ---
+            const bodyChanged = modifiedResponse && (modifiedResponse.body !== originalBody);
+            const truncate = (s, max) => s.length > max ? s.slice(0, max) + `\n...(已截断，共 ${s.length} 字符)` : s;
+            const headersEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+            const responseHeadersChanged = !!(realResponse && modifiedResponse && !headersEqual(realResponse.headers, modifiedResponse.headers));
+            const DIFF_PREVIEW_LEN = 2500;
+            // 写入代理日志，便于在「日志」页查看此次测试请求
+            if (typeof ctx.appendProxyRecordFromPluginTest === 'function' && !fetchError) {
+                const logData = {
+                    method,
+                    source,
+                    target: usedMock ? `[MOCK] ${currentTarget}` : currentTarget,
+                    time: new Date().toLocaleTimeString(),
+                    statusCode: realResponse?.statusCode,
+                    duration: fetchDuration,
+                    _fromPluginTest: true,
+                };
+                const detail = realResponse
+                    ? {
+                        requestHeaders: requestMutable.headers,
+                        requestBody: requestMutable.body || '',
+                        responseHeaders: realResponse.headers,
+                        responseBody: truncate(originalBody, 5000),
+                        statusCode: realResponse.statusCode,
+                        method,
+                        url: source,
+                    }
+                    : undefined;
+                ctx.appendProxyRecordFromPluginTest(logData, detail);
+            }
+            res.json({
+                status: 'success',
+                results: {
+                    pluginId,
+                    pluginName: targetPlugin.manifest.name,
+                    hooks,
+                    logs: testLogs,
+                    hookResults,
+                    realRequest: {
+                        method,
+                        url: currentTarget,
+                        fetchDuration,
+                        fetchError,
+                        usedMock,
+                        targetResolved: integrated && legacyTarget !== source,
+                        testMode: integrated ? 'integrated' : 'standalone',
+                    },
+                    originalRequest: (requestHeadersChanged || requestBodyChanged) ? {
+                        headers: initialRequestSnapshot.headers,
+                        body: initialRequestSnapshot.body,
+                    } : null,
+                    modifiedRequest: (requestHeadersChanged || requestBodyChanged) ? {
+                        headers: modifiedRequestSnapshot.headers,
+                        body: modifiedRequestSnapshot.body,
+                    } : null,
+                    requestHeadersChanged,
+                    requestBodyChanged,
+                    originalResponse: realResponse ? {
+                        statusCode: realResponse.statusCode,
+                        headers: realResponse.headers,
+                        bodyPreview: truncate(originalBody, 3000),
+                        bodyLength: originalBody.length,
+                        bodyForDiff: truncate(originalBody, DIFF_PREVIEW_LEN),
+                    } : null,
+                    modifiedResponse: modifiedResponse ? (() => {
+                        const h = modifiedResponse.headers;
+                        const headersNormalized = h ? Object.fromEntries(Object.entries(h).map(([k, v]) => [k, v != null ? String(v) : ''])) : {};
+                        return {
+                            statusCode: modifiedResponse.statusCode,
+                            headers: headersNormalized,
+                            bodyPreview: truncate(String(modifiedResponse.body || ''), 3000),
+                            bodyLength: String(modifiedResponse.body || '').length,
+                            bodyChanged,
+                            bodyForDiff: truncate(String(modifiedResponse.body || ''), DIFF_PREVIEW_LEN),
+                        };
+                    })() : null,
+                    responseHeadersChanged,
+                    shortCircuited,
+                    shortCircuitResponse: shortCircuitResponse ? {
+                        statusCode: shortCircuitResponse.statusCode,
+                        body: truncate(String(shortCircuitResponse.body || ''), 2000),
+                    } : null,
+                },
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // API: 启用/禁用单个插件
+    app.put('/api/plugins/:id/toggle', (req, res) => {
+        const pluginId = String(req.params.id);
+        const { enabled } = req.body;
+        try {
+            res.json(setPluginEnabled(ctx, pluginId, Boolean(enabled)));
+        }
+        catch (error) {
+            if (error.message === '插件不存在') {
+                res.status(404).json({ error: '插件不存在' });
+                return;
+            }
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // API: 获取所有插件列表
+    app.get('/api/plugins', (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        const pluginStats = ctx.hookDispatcher.getPluginStats ? ctx.hookDispatcher.getPluginStats() : {};
+        const plugins = ctx.pluginManager.getAll().map((plugin) => ({
+            id: plugin.manifest.id,
+            name: plugin.manifest.name,
+            version: plugin.manifest.version,
+            hooks: plugin.manifest.hooks,
+            permissions: plugin.manifest.permissions,
+            priority: plugin.manifest.priority,
+            state: ctx.pluginManager.getState(plugin.manifest.id),
+            stats: pluginStats[plugin.manifest.id] || null,
+        }));
+        res.write(JSON.stringify({
+            mode: ctx.requestPipeline.mode,
+            total: plugins.length,
+            plugins,
+        }));
+        res.end();
+    });
+    // API: Logger 插件信息
+    app.get('/api/plugins/logger', (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        const pluginStats = ctx.hookDispatcher.getPluginStats ? ctx.hookDispatcher.getPluginStats() : {};
+        res.write(JSON.stringify({
+            pluginId: 'builtin.logger',
+            mode: ctx.requestPipeline.mode,
+            stats: pluginStats['builtin.logger'] || null,
+            summary: typeof ctx.builtinLoggerPlugin.getSummary === 'function'
+                ? ctx.builtinLoggerPlugin.getSummary()
+                : null,
+            recent: typeof ctx.builtinLoggerPlugin.getRecentEntries === 'function'
+                ? ctx.builtinLoggerPlugin.getRecentEntries()
+                : [],
+        }));
+        res.end();
+    });
+    // API: Mock 插件信息
+    app.get('/api/plugins/mock', (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        const pluginStats = ctx.hookDispatcher.getPluginStats ? ctx.hookDispatcher.getPluginStats() : {};
+        const ENABLE_BUILTIN_MOCK_PLUGIN = true; // This should come from REFACTOR_CONFIG
+        res.write(JSON.stringify({
+            pluginId: 'builtin.mock',
+            enabled: ENABLE_BUILTIN_MOCK_PLUGIN,
+            mode: ctx.requestPipeline.mode,
+            stats: pluginStats['builtin.mock'] || null,
+            takeoverRule: 'only inline mock in on mode and host-gated',
+            allowlist: [], // Should come from context
+        }));
+        res.end();
+    });
+    // API: 插件健康检查
+    app.get('/api/plugins/health', (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        const pluginStats = ctx.hookDispatcher.getPluginStats ? ctx.hookDispatcher.getPluginStats() : {};
+        const pluginStates = {};
+        const manifests = ctx.pluginManager.getAll().map((plugin) => {
+            pluginStates[plugin.manifest.id] = ctx.pluginManager.getState(plugin.manifest.id);
+            return plugin.manifest;
+        });
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { buildPluginHealth } = require('../core/plugin-health');
+        const health = buildPluginHealth({
+            plugins: manifests,
+            pluginStates,
+            pluginStats,
+        });
+        res.write(JSON.stringify({
+            mode: ctx.requestPipeline.mode,
+            ...health,
+        }));
+        res.end();
+    });
+}
+//# sourceMappingURL=plugins.js.map