vite-plugin-aipanel 1.2.0-beta.0

package/lib/endpoints/mcp.cjs

@@ -0,0 +1,624 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcp_exports = {};
+__export(mcp_exports, {
+  MCP_API_PATH: () => import_core.MCP_API_PATH,
+  setupMcpEndpoint: () => setupMcpEndpoint
+});
+module.exports = __toCommonJS(mcp_exports);
+var import_core = require("@aipanel/core");
+var import_node = require("@aipanel/core/node");
+var import_mcp_chrome = require("../core/mcp-chrome.cjs");
+var import_mcp_tools = require("../core/mcp-tools.cjs");
+var import_vue_devtools = require("./vue-devtools.cjs");
+var import_system = require("../utils/system.cjs");
+const log = (0, import_node.createLogger)("McpEndpoint");
+function setupMcpEndpoint(server, mcp, getPageContext, logFiles = []) {
+  const projectRoot = (0, import_system.findGitRoot)(process.cwd());
+  server.middlewares.use(async (req, res, next) => {
+    if (!req.url?.startsWith(import_core.MCP_API_PATH)) return next();
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id, Authorization");
+    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method === "GET") {
+      handleGetSse(req, res, mcp);
+      return;
+    }
+    if (req.method === "DELETE") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    if (req.method === "POST") {
+      await handlePost(
+        req,
+        res,
+        mcp,
+        (0, import_mcp_chrome.getProjectOrigins)(server),
+        getPageContext,
+        logFiles,
+        projectRoot
+      );
+      return;
+    }
+    next();
+  });
+}
+function handleGetSse(req, res, mcp) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "Mcp-Session-Id": mcp.sessionId
+  });
+  res.write(":ok\n\n");
+  const keepAlive = setInterval(() => res.write(":ping\n\n"), 15e3);
+  req.on("close", () => clearInterval(keepAlive));
+}
+async function handlePost(req, res, mcp, projectOrigins, getPageContext, logFiles, projectRoot) {
+  try {
+    const body = await readBody(req);
+    if (!body) {
+      res.writeHead(400);
+      res.end("Empty body");
+      return;
+    }
+    const { method, id } = tryParseRequest(body);
+    log.debug("MCP request", { method, body: body.substring(0, 150) });
+    switch (method) {
+      case "tools/list":
+        return handleToolsList(res, id, mcp.sessionId, logFiles);
+      case "tools/call":
+        return await handleToolsCall(
+          res,
+          id,
+          body,
+          mcp,
+          projectOrigins,
+          getPageContext,
+          logFiles,
+          projectRoot
+        );
+      default:
+        return await handleForward(res, body, mcp);
+    }
+  } catch (e) {
+    log.debug("MCP POST error", { error: e.message });
+    sendMcpJson(res, 500, {
+      jsonrpc: "2.0",
+      error: { code: -32603, message: e.message }
+    });
+  }
+}
+function handleToolsList(res, id, sessionId, logFiles) {
+  const tools = [...import_mcp_tools.CUSTOM_TOOLS, ...buildServiceLogTools(logFiles)];
+  sendMcpJson(res, 200, { jsonrpc: "2.0", id, result: { tools } }, sessionId);
+}
+function handleToolsCall(res, id, body, mcp, projectOrigins, getPageContext, logFiles, projectRoot) {
+  const params = tryParseParams(body);
+  const toolName = params?.name;
+  const args = params?.arguments ?? {};
+  if (toolName === "chrome-devtools_current_page") {
+    return handleGetPageContext(res, id, mcp, projectOrigins, getPageContext);
+  }
+  if (toolName?.startsWith("vue-devtools_")) {
+    return handleVueDevtoolsTool(res, id, mcp, projectOrigins, toolName, args);
+  }
+  if (toolName === "logs-devtools_vite_logs") {
+    return handleViteLogsTool(res, id, args, mcp.sessionId);
+  }
+  if (toolName && isServiceLogTool(toolName, logFiles)) {
+    return handleServiceLogsTool(res, id, toolName, args, logFiles, projectRoot, mcp.sessionId);
+  }
+  if (toolName?.startsWith("chrome-devtools_")) {
+    const mapped = toolName.slice("chrome-devtools_".length);
+    if (toolName === "chrome-devtools_list_pages") {
+      return handleListPages(res, id, mcp, projectOrigins, getPageContext);
+    }
+    if (toolName === "chrome-devtools_new_page") {
+      return handleNewPage(res, id, mcp, args, projectOrigins, getPageContext);
+    }
+    return handleDevTool(res, id, mcp, mapped, args, projectOrigins, toolName);
+  }
+  sendMcpError(res, id, -32601, `Tool not found: ${toolName}`, mcp.sessionId);
+}
+async function resolveProjectPages(mcp, projectOrigins, getPageContext) {
+  const listResult = await mcp.callChromeDevTool("list_pages", {});
+  if (listResult?.error || !listResult?.result) {
+    throw new Error(listResult?.error?.message ?? "\u65E0\u6CD5\u83B7\u53D6 Chrome \u9875\u9762\u5217\u8868");
+  }
+  const text = listResult?.result?.content?.[0]?.text;
+  const allPages = text ? (0, import_mcp_chrome.parseListPages)(text) : [];
+  const filtered = allPages.filter((p) => (0, import_mcp_chrome.isProjectPage)(p.url, projectOrigins));
+  log.debug("Chrome pages", { total: allPages.length, urls: allPages.map((p) => p.url) });
+  log.debug("project origins", { origins: projectOrigins });
+  log.debug("filtered pages", { count: filtered.length, pageIds: filtered.map((p) => p.pageId) });
+  let activePageId = null;
+  let activePageError;
+  if (filtered.length > 0) {
+    const pc = getPageContext();
+    const chromeSelectedPageId = allPages.find((p) => p.selected)?.pageId;
+    const resolved = await (0, import_mcp_chrome.resolveChromePageId)(
+      mcp,
+      pc.url,
+      pc.title,
+      projectOrigins,
+      pc.sessionId,
+      filtered,
+      chromeSelectedPageId
+    );
+    activePageId = resolved.ok ? resolved.pageId : null;
+    if (!resolved.ok) activePageError = resolved.error;
+  }
+  return { filtered, activePageId, activePageError };
+}
+async function confirmOpenProjectPages(mcp, projectOrigins, getPageContext) {
+  let pages = [];
+  let ok = false;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      ({ filtered: pages } = await resolveProjectPages(mcp, projectOrigins, getPageContext));
+      ok = true;
+      break;
+    } catch {
+      if (attempt < 2) await (0, import_core.sleep)(500);
+    }
+  }
+  if (!ok) return null;
+  if (pages.length === 0) {
+    await (0, import_core.sleep)(500);
+    try {
+      ({ filtered: pages } = await resolveProjectPages(mcp, projectOrigins, getPageContext));
+    } catch {
+    }
+  }
+  return pages;
+}
+async function handleListPages(res, id, mcp, projectOrigins, getPageContext) {
+  try {
+    const { filtered, activePageId } = await resolveProjectPages(
+      mcp,
+      projectOrigins,
+      getPageContext
+    );
+    if (filtered.length === 0) {
+      sendMcpResult(res, id, "\u6682\u65E0\u9879\u76EE\u9875\u9762\uFF0C\u8BF7\u5148\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u672C\u5730\u5F00\u53D1\u9875\u9762", mcp.sessionId);
+      return;
+    }
+    const pageList = filtered.map((p) => ({
+      pageId: p.pageId,
+      url: p.url,
+      title: p.title,
+      active: activePageId != null ? p.pageId === activePageId : false,
+      selected: p.selected
+    }));
+    sendMcpResult(res, id, JSON.stringify(pageList, null, 2), mcp.sessionId);
+  } catch (e) {
+    log.debug("handleListPages error", { error: e.message });
+    sendMcpError(res, id, -32603, `MCP \u8C03\u7528\u5931\u8D25: ${e.message}`, mcp.sessionId);
+  }
+}
+async function handleGetPageContext(res, id, mcp, projectOrigins, getPageContext) {
+  try {
+    const { filtered, activePageId, activePageError } = await resolveProjectPages(
+      mcp,
+      projectOrigins,
+      getPageContext
+    );
+    if (filtered.length === 0) {
+      sendMcpResult(res, id, "\u6682\u65E0\u9879\u76EE\u9875\u9762\uFF0C\u8BF7\u5148\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u672C\u5730\u5F00\u53D1\u9875\u9762", mcp.sessionId);
+      return;
+    }
+    const pc = getPageContext();
+    if (activePageId == null) {
+      sendMcpResult(
+        res,
+        id,
+        `\u65E0\u6CD5\u5B9A\u4F4D\u5F53\u524D\u9875\u9762\u5BF9\u5E94\u7684 pageId\uFF1A${activePageError ?? "\u672A\u5339\u914D\u5230\u5DF2\u6253\u5F00\u7684\u9875\u9762"}
+
+\u5F53\u524D\u9875\u9762\u4E0A\u4E0B\u6587\uFF1A${pc.title} (${pc.url})
+
+\u8BF7\u5237\u65B0\u76EE\u6807\u9875\u9762\u540E\u91CD\u8BD5\uFF1B\u6216\u4F7F\u7528 chrome-devtools_list_pages \u83B7\u53D6\u9875\u9762 ID \u540E\u76F4\u63A5\u64CD\u4F5C\u3002`,
+        mcp.sessionId
+      );
+      return;
+    }
+    const activePage = filtered.find((p) => p.pageId === activePageId);
+    sendMcpResult(
+      res,
+      id,
+      JSON.stringify(
+        {
+          url: activePage?.url ?? pc.url,
+          title: activePage?.title ?? pc.title,
+          pageId: activePageId
+        },
+        null,
+        2
+      ),
+      mcp.sessionId
+    );
+  } catch (e) {
+    log.debug("handleGetPageContext error", { error: e.message });
+    sendMcpError(res, id, -32603, `MCP \u8C03\u7528\u5931\u8D25: ${e.message}`, mcp.sessionId);
+  }
+}
+async function handleNewPage(res, id, mcp, args, projectOrigins, getPageContext) {
+  try {
+    const url = args["url"];
+    if (typeof url !== "string" || url.trim().length === 0) {
+      sendMcpError(res, id, -32e3, "\u7F3A\u5C11 url \u53C2\u6570\uFF0C\u8BF7\u63D0\u4F9B\u8981\u6253\u5F00\u7684\u9875\u9762 URL", mcp.sessionId);
+      return;
+    }
+    if (!(0, import_mcp_chrome.isProjectPage)(url, projectOrigins)) {
+      sendMcpError(
+        res,
+        id,
+        -32e3,
+        `\u4E0D\u5141\u8BB8\u6253\u5F00\u975E\u672C\u9879\u76EE\u9875\u9762: ${url}\u3002\u4EC5\u5141\u8BB8\u6253\u5F00\u9879\u76EE\u9875\u9762 (${projectOrigins.join(", ")})`,
+        mcp.sessionId
+      );
+      return;
+    }
+    const projectPages = await confirmOpenProjectPages(mcp, projectOrigins, getPageContext);
+    if (projectPages === null) {
+      sendMcpError(
+        res,
+        id,
+        -32e3,
+        `\u65E0\u6CD5\u786E\u8BA4\u5F53\u524D\u9879\u76EE\u9875\u9762\u72B6\u6001\uFF0C\u4E3A\u907F\u514D\u91CD\u590D\u6253\u5F00\uFF0C\u8BF7\u786E\u8BA4 Chrome DevTools \u5DF2\u8FDE\u63A5\u540E\u91CD\u8BD5`,
+        mcp.sessionId
+      );
+      return;
+    }
+    if (projectPages.length > 0) {
+      const existing = projectPages.map((p) => `- ${p.title} (${p.url}) [pageId: ${p.pageId}]`).join("\n");
+      sendMcpResult(
+        res,
+        id,
+        `\u5F53\u524D\u9879\u76EE\u5DF2\u6709\u6253\u5F00\u7684\u9875\u9762\uFF0C\u65E0\u9700\u91CD\u590D\u6253\u5F00\u3002
+
+\u5DF2\u6253\u5F00\u7684\u9875\u9762\uFF1A
+${existing}
+
+\u5982\u9700\u64CD\u4F5C\u73B0\u6709\u9875\u9762\uFF0C\u8BF7\u4F7F\u7528 chrome-devtools_list_pages \u83B7\u53D6\u9875\u9762 ID\uFF0C\u518D\u914D\u5408\u5176\u4ED6 chrome-devtools_* \u5DE5\u5177\u4F7F\u7528\u3002`,
+        mcp.sessionId
+      );
+      return;
+    }
+    const forwardBody = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method: "tools/call",
+      params: { name: "new_page", arguments: { ...args, background: true } }
+    });
+    const responseText = await mcp.forward(forwardBody);
+    log.debug("MCP response", { tool: "new_page", response: responseText.substring(0, 100) });
+    sendMcpJson(res, 200, responseText, mcp.sessionId);
+  } catch (e) {
+    log.debug("handleNewPage error", { error: e.message });
+    sendMcpError(res, id, -32603, `MCP \u8C03\u7528\u5931\u8D25: ${e.message}`, mcp.sessionId);
+  }
+}
+async function handleDevTool(res, id, mcp, mapped, args, projectOrigins, toolName) {
+  try {
+    const pageId = args["pageId"];
+    if (typeof pageId !== "number") {
+      sendMcpError(res, id, -32e3, "\u7F3A\u5C11 pageId \u53C2\u6570\uFF0C\u8BF7\u5148\u83B7\u53D6\u9875\u9762 ID", mcp.sessionId);
+      return;
+    }
+    const validation = await (0, import_mcp_chrome.validatePageId)(mcp, pageId, projectOrigins);
+    log.debug("handleDevTool validation", {
+      pageId,
+      projectPages: validation.projectPages.length,
+      projectPageIds: validation.projectPages.map((p) => p.pageId),
+      origins: projectOrigins,
+      isValid: validation.valid
+    });
+    if (!validation.valid) {
+      sendMcpError(res, id, -32e3, validation.error, mcp.sessionId);
+      return;
+    }
+    if (toolName === "chrome-devtools_navigate_page" && args["type"] === "url") {
+      const targetUrl = args["url"];
+      if (typeof targetUrl === "string" && targetUrl.length > 0) {
+        if (!(0, import_mcp_chrome.isProjectPage)(targetUrl, projectOrigins)) {
+          sendMcpError(
+            res,
+            id,
+            -32e3,
+            `\u4E0D\u5141\u8BB8\u8DF3\u8F6C\u5230\u975E\u672C\u9879\u76EE\u9875\u9762: ${targetUrl}\u3002\u4EC5\u5141\u8BB8\u5BFC\u822A\u5230\u9879\u76EE\u9875\u9762 (${projectOrigins.join(", ")})`,
+            mcp.sessionId
+          );
+          return;
+        }
+      }
+    }
+    await mcp.callChromeDevTool("select_page", { pageId, bringToFront: false });
+    const forwardArgs = { ...args };
+    delete forwardArgs["pageId"];
+    const forwardBody = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method: "tools/call",
+      params: { name: mapped, arguments: forwardArgs }
+    });
+    const responseText = await mcp.forward(forwardBody);
+    log.debug("MCP response", { mapped, response: responseText.substring(0, 100) });
+    sendMcpJson(res, 200, responseText, mcp.sessionId);
+  } catch (e) {
+    log.debug("handleDevTool error", { error: e.message, mapped });
+    sendMcpError(res, id, -32603, `MCP \u8C03\u7528\u5931\u8D25: ${e.message}`, mcp.sessionId);
+  }
+}
+const VUE_DEVTOOLS_TOOL_ACTIONS = {
+  "vue-devtools_get_apps": import_core.VUE_DEVTOOLS_ACTIONS.GET_APPS,
+  "vue-devtools_set_active_app": import_core.VUE_DEVTOOLS_ACTIONS.TOGGLE_APP,
+  "vue-devtools_get_component_tree": import_core.VUE_DEVTOOLS_ACTIONS.GET_COMPONENT_TREE,
+  "vue-devtools_get_component_state": import_core.VUE_DEVTOOLS_ACTIONS.GET_COMPONENT_STATE,
+  "vue-devtools_get_component_render_code": import_core.VUE_DEVTOOLS_ACTIONS.GET_COMPONENT_RENDER_CODE,
+  "vue-devtools_get_current_route": import_core.VUE_DEVTOOLS_ACTIONS.GET_ROUTER_INFO,
+  "vue-devtools_get_routes": import_core.VUE_DEVTOOLS_ACTIONS.GET_ROUTER_INFO
+};
+async function handleVueDevtoolsTool(res, id, mcp, projectOrigins, toolName, args) {
+  try {
+    const action = VUE_DEVTOOLS_TOOL_ACTIONS[toolName];
+    if (!action) {
+      sendMcpError(res, id, -32601, `Tool not found: ${toolName}`, mcp.sessionId);
+      return;
+    }
+    const result = await (0, import_vue_devtools.executeAction)(action, args, mcp, projectOrigins);
+    switch (toolName) {
+      case "vue-devtools_set_active_app":
+        sendMcpResult(res, id, `\u5DF2\u5207\u6362\u5230\u5E94\u7528 ${args["appId"]}`, mcp.sessionId);
+        return;
+      case "vue-devtools_get_current_route":
+      case "vue-devtools_get_routes": {
+        const parsed = typeof result === "string" ? parseJsonSafe(result) : result;
+        const data = parsed ?? {};
+        const value = toolName === "vue-devtools_get_current_route" ? data.currentRoute ?? null : data.routes ?? null;
+        sendMcpResult(res, id, JSON.stringify(value), mcp.sessionId);
+        return;
+      }
+      case "vue-devtools_get_component_render_code":
+        sendMcpResult(
+          res,
+          id,
+          typeof result === "string" ? result : JSON.stringify(result),
+          mcp.sessionId
+        );
+        return;
+      default:
+        sendMcpResult(res, id, JSON.stringify(result), mcp.sessionId);
+        return;
+    }
+  } catch (e) {
+    log.debug("handleVueDevtoolsTool error", { error: e.message });
+    sendMcpError(res, id, -32603, `Vue DevTools \u8C03\u7528\u5931\u8D25: ${e.message}`, mcp.sessionId);
+  }
+}
+function parseJsonSafe(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function handleViteLogsTool(res, id, args, sessionId) {
+  const { level, limit, source } = args;
+  const buffer = (0, import_node.getProcessLogBuffer)();
+  const logs = buffer.getLogs({
+    level: parseProcessLevelFilter(level),
+    limit: typeof limit === "number" && limit >= 1 ? limit : 50,
+    source: typeof source === "string" && source ? source : void 0
+  });
+  if (logs.length === 0) {
+    sendMcpResult(
+      res,
+      id,
+      `\u5F53\u524D\u6CA1\u6709\u7B26\u5408\u6761\u4EF6\u7684\u65E5\u5FD7\uFF08\u7F13\u51B2\u533A\u5171 ${buffer.size()} \u6761\uFF09\u3002
+
+\u5EFA\u8BAE\uFF1A
+- \u4E0D\u6307\u5B9A\u53C2\u6570\u83B7\u53D6\u6240\u6709\u65E5\u5FD7
+- \u4F7F\u7528 level=error,warn \u83B7\u53D6\u9519\u8BEF\u548C\u8B66\u544A`,
+      sessionId
+    );
+    return;
+  }
+  const formattedLogs = logs.map((entry) => {
+    const time = new Date(entry.timestamp).toLocaleTimeString();
+    const levelIcon = entry.level === "error" ? "\u274C" : entry.level === "warn" ? "\u26A0\uFE0F" : entry.level === "info" ? "\u2139\uFE0F" : "";
+    return `${time} ${levelIcon} ${entry.message}`;
+  }).join("\n");
+  sendMcpResult(
+    res,
+    id,
+    `Vite \u5F00\u53D1\u670D\u52A1\u5668\u65E5\u5FD7\uFF08${logs.length}/${buffer.size()} \u6761\uFF09\uFF1A
+
+${formattedLogs}`,
+    sessionId
+  );
+}
+function parseProcessLevelFilter(level) {
+  if (typeof level !== "string" || !level.trim()) return void 0;
+  const levels = level.split(",").map((l) => l.trim()).filter(Boolean);
+  return levels.length ? levels : void 0;
+}
+function buildServiceLogTools(logFiles) {
+  return logFiles.map((cfg) => ({
+    name: `logs-devtools_${cfg.name}_logs`,
+    description: `\u83B7\u53D6 ${cfg.name} \u7684\u65E5\u5FD7\u3002
+
+**\u4F55\u65F6\u4F7F\u7528\u6B64\u5DE5\u5177**\uFF1A
+${cfg.description}
+
+**\u65E5\u5FD7\u5185\u5BB9**\uFF1A
+- \u6765\u81EA\u65E5\u5FD7\u6587\u4EF6 ${cfg.path} \u7684\u5B9E\u65F6\u65E5\u5FD7
+- \u9ED8\u8BA4\u8FD4\u56DE\u6700\u8FD1 200 \u884C\u65E5\u5FD7`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        level: {
+          type: "string",
+          description: "\u65E5\u5FD7\u7EA7\u522B\u8FC7\u6EE4\uFF1Aerror(\u9519\u8BEF)\u3001warn(\u8B66\u544A)\u3001info(\u4FE1\u606F)\u3002\u591A\u4E2A\u7528\u9017\u53F7\u5206\u9694\uFF0C\u5982 'error,warn'"
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 200,
+          default: 50,
+          description: "\u8FD4\u56DE\u6761\u6570\uFF0C\u9ED8\u8BA4 50\uFF0C\u6700\u5927 200"
+        }
+      }
+    }
+  }));
+}
+function isServiceLogTool(toolName, logFiles) {
+  return logFiles.some((cfg) => `logs-devtools_${cfg.name}_logs` === toolName);
+}
+async function handleServiceLogsTool(res, id, toolName, args, logFiles, projectRoot, sessionId) {
+  try {
+    const cfg = logFiles.find((c) => `logs-devtools_${c.name}_logs` === toolName);
+    if (!cfg) {
+      sendMcpError(res, id, -32601, `Tool not found: ${toolName}`, sessionId);
+      return;
+    }
+    const { level, limit } = args;
+    const requestedLimit = typeof limit === "number" ? limit : 50;
+    const entries = await (0, import_node.readLogFileTail)({
+      name: cfg.name,
+      filePath: cfg.path,
+      projectRoot,
+      lines: Math.max(requestedLimit * 3, 500),
+      level: parseFileLevelFilter(level),
+      limit: requestedLimit
+    });
+    if (entries.length === 0) {
+      sendMcpResult(
+        res,
+        id,
+        `\u5F53\u524D\u6CA1\u6709\u7B26\u5408\u6761\u4EF6\u7684\u65E5\u5FD7\u3002
+
+\u5EFA\u8BAE\uFF1A
+- \u4E0D\u6307\u5B9A\u53C2\u6570\u83B7\u53D6\u6240\u6709\u65E5\u5FD7
+- \u4F7F\u7528 level=error,warn \u83B7\u53D6\u9519\u8BEF\u548C\u8B66\u544A`,
+        sessionId
+      );
+      return;
+    }
+    const formattedLogs = entries.map((entry) => {
+      const levelIcon = entry.level === "error" ? "\u274C" : entry.level === "warn" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+      return `${levelIcon} ${entry.message}`;
+    }).join("\n");
+    sendMcpResult(
+      res,
+      id,
+      `${cfg.name} \u65E5\u5FD7\uFF08${entries.length} \u6761\uFF09\uFF1A
+
+${formattedLogs}`,
+      sessionId
+    );
+  } catch (e) {
+    log.debug("handleServiceLogsTool error", { error: e.message });
+    sendMcpError(res, id, -32603, `\u8BFB\u53D6\u65E5\u5FD7\u5931\u8D25: ${e.message}`, sessionId);
+  }
+}
+function parseFileLevelFilter(level) {
+  if (typeof level !== "string" || !level.trim()) return void 0;
+  const levels = level.split(",").map((l) => l.trim()).filter(Boolean);
+  return levels.length ? levels : void 0;
+}
+async function handleForward(res, body, mcp) {
+  try {
+    const responseText = await mcp.forward(body);
+    sendMcpJson(res, 200, responseText, mcp.sessionId);
+  } catch (e) {
+    log.debug("handleForward error", { error: e.message });
+    sendMcpError(res, null, -32603, `MCP \u8C03\u7528\u5931\u8D25: ${e.message}`, mcp.sessionId);
+  }
+}
+function sendMcpResult(res, id, text, sessionId) {
+  sendMcpJson(
+    res,
+    200,
+    {
+      jsonrpc: "2.0",
+      id,
+      result: { content: [{ type: "text", text }] }
+    },
+    sessionId
+  );
+}
+function sendMcpError(res, id, code, message, sessionId) {
+  sendMcpJson(
+    res,
+    200,
+    {
+      jsonrpc: "2.0",
+      id,
+      error: { code, message }
+    },
+    sessionId
+  );
+}
+function sendMcpJson(res, statusCode, body, sessionId) {
+  const headers = { "Content-Type": "application/json" };
+  if (sessionId) headers["Mcp-Session-Id"] = sessionId;
+  res.writeHead(statusCode, headers);
+  res.end(typeof body === "string" ? body : JSON.stringify(body));
+}
+function readBody(req, maxSize = 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+      if (body.length > maxSize) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+      }
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+function tryParseRequest(body) {
+  try {
+    const data = JSON.parse(body);
+    return { method: data.method || "unknown", id: data.id ?? null };
+  } catch {
+    return { method: "unknown", id: null };
+  }
+}
+function tryParseParams(body) {
+  try {
+    return JSON.parse(body).params ?? null;
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCP_API_PATH,
+  setupMcpEndpoint
+});

package/lib/endpoints/mcp.d.ts

@@ -0,0 +1,6 @@
+import type { ViteDevServer } from "vite";
+import type { LogFileConfig, PageContext } from "@aipanel/core";
+import { MCP_API_PATH } from "@aipanel/core";
+import { McpProxy } from "../core/mcp-proxy";
+export { MCP_API_PATH };
+export declare function setupMcpEndpoint(server: ViteDevServer, mcp: McpProxy, getPageContext: () => PageContext, logFiles?: LogFileConfig[]): void;