vite-plugin-aipanel 1.2.0-beta.0

package/es/endpoints/logs.mjs

@@ -0,0 +1,86 @@
+import {
+  getProcessLogBuffer
+} from "@aipanel/core/node";
+import { RequestContext, createLogger } from "@aipanel/core/node";
+import { LOGS_API_PATH } from "@aipanel/core";
+const log = createLogger("Endpoints:Logs");
+function setupLogsEndpoint(server) {
+  server.middlewares.use(LOGS_API_PATH, async (req, res) => {
+    const reqCtx = new RequestContext(req.method || "GET", LOGS_API_PATH);
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      reqCtx.end(200);
+      return;
+    }
+    const buffer = getProcessLogBuffer();
+    if (req.method === "GET") {
+      try {
+        const url = new URL(req.url || "", `http://${req.headers.host || "localhost"}`);
+        const levelParam = url.searchParams.get("level");
+        const limitParam = url.searchParams.get("limit");
+        const sourceParam = url.searchParams.get("source");
+        const sinceParam = url.searchParams.get("since");
+        const options = {};
+        if (levelParam) {
+          const levels = levelParam.split(",").map((l) => l.trim());
+          options.level = levels.length === 1 ? levels[0] : levels;
+        }
+        if (limitParam) {
+          const limit = parseInt(limitParam, 10);
+          if (limit > 0 && limit <= 1e3) {
+            options.limit = limit;
+          }
+        }
+        if (sourceParam) {
+          options.source = sourceParam;
+        }
+        if (sinceParam) {
+          options.since = sinceParam;
+        }
+        const logs = buffer.getLogs(options);
+        log.debug("Logs requested", {
+          params: { level: levelParam, limit: limitParam, source: sourceParam, since: sinceParam },
+          resultCount: logs.length,
+          bufferSize: buffer.size()
+        });
+        res.writeHead(200);
+        res.end(
+          JSON.stringify({
+            logs,
+            meta: {
+              total: buffer.size(),
+              returned: logs.length,
+              filters: options
+            }
+          })
+        );
+        reqCtx.end(200);
+      } catch (e) {
+        log.error("Failed to get logs", { error: e });
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: "Internal server error" }));
+        reqCtx.error(e);
+      }
+      return;
+    }
+    if (req.method === "DELETE") {
+      buffer.clear();
+      log.debug("Log buffer cleared");
+      res.writeHead(200);
+      res.end(JSON.stringify({ success: true, message: "Log buffer cleared" }));
+      reqCtx.end(200);
+      return;
+    }
+    res.writeHead(405);
+    res.end(JSON.stringify({ error: "Method not allowed" }));
+    reqCtx.end(405);
+  });
+}
+export {
+  setupLogsEndpoint
+};

package/es/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;

package/es/endpoints/mcp.mjs

@@ -0,0 +1,610 @@
+import { MCP_API_PATH, VUE_DEVTOOLS_ACTIONS, sleep } from "@aipanel/core";
+import {
+  createLogger,
+  getProcessLogBuffer,
+  readLogFileTail
+} from "@aipanel/core/node";
+import {
+  parseListPages,
+  resolveChromePageId,
+  getProjectOrigins,
+  isProjectPage,
+  validatePageId
+} from "../core/mcp-chrome.mjs";
+import { CUSTOM_TOOLS } from "../core/mcp-tools.mjs";
+import { executeAction } from "./vue-devtools.mjs";
+import { findGitRoot } from "../utils/system.mjs";
+const log = createLogger("McpEndpoint");
+function setupMcpEndpoint(server, mcp, getPageContext, logFiles = []) {
+  const projectRoot = findGitRoot(process.cwd());
+  server.middlewares.use(async (req, res, next) => {
+    if (!req.url?.startsWith(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,
+        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 = [...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 ? parseListPages(text) : [];
+  const filtered = allPages.filter((p) => 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 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 sleep(500);
+    }
+  }
+  if (!ok) return null;
+  if (pages.length === 0) {
+    await 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 (!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 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 (!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": VUE_DEVTOOLS_ACTIONS.GET_APPS,
+  "vue-devtools_set_active_app": VUE_DEVTOOLS_ACTIONS.TOGGLE_APP,
+  "vue-devtools_get_component_tree": VUE_DEVTOOLS_ACTIONS.GET_COMPONENT_TREE,
+  "vue-devtools_get_component_state": VUE_DEVTOOLS_ACTIONS.GET_COMPONENT_STATE,
+  "vue-devtools_get_component_render_code": VUE_DEVTOOLS_ACTIONS.GET_COMPONENT_RENDER_CODE,
+  "vue-devtools_get_current_route": VUE_DEVTOOLS_ACTIONS.GET_ROUTER_INFO,
+  "vue-devtools_get_routes": 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 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 = 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 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;
+  }
+}
+export {
+  MCP_API_PATH,
+  setupMcpEndpoint
+};

package/es/endpoints/sessions.d.ts

@@ -0,0 +1,3 @@
+import type { ViteDevServer } from "vite";
+import type { EndpointContext } from "./types";
+export declare function setupSessionsEndpoint(server: ViteDevServer, ctx: EndpointContext): void;