@xiaou66/vite-plugin-vue-mcp-next 0.0.6 → 0.0.7

package/dist/index.d.cts

@@ -177,6 +177,8 @@ type ScreenshotTarget = 'viewport' | 'fullPage' | 'element';
  * MCP 返回 base64 数据，格式会直接影响体积；限制为常见浏览器截图格式可以简化大小控制和文档说明。
  */
 type ScreenshotFormat = 'png' | 'jpeg' | 'webp';
+/** 截图输出类型，项目级配置用于统一控制 MCP 返回路径还是直接返回图片数据。 */
+type ScreenshotOutputType = 'path' | 'base64';
 /**
  * snapdom 插件路径对象。
  *
@@ -247,6 +249,10 @@ interface SnapdomScreenshotOptions {
  * 截图能力同时存在真截图和 DOM 降级截图；集中配置可以让用户明确选择准确度、体积和兼容性边界。
  */
 interface ScreenshotOptions {
+    /** 截图输出类型，项目级 MCP 默认用路径减少 base64 对上下文的占用。 */
+    readonly type?: ScreenshotOutputType;
+    /** 截图保存目录，相对路径按 Vite 项目根目录解析。 */
+    readonly saveDir?: string;
     /** 默认截图通道选择，适合项目按运行环境统一控制降级策略。 */
     readonly prefer?: ScreenshotPrefer;
     /** 单次 MCP 返回图片最大字节数，避免 base64 图片挤占上下文或拖慢客户端。 */
@@ -490,6 +496,12 @@ interface VueRuntimeRpc {
     }): void | Promise<void>;
     /** 回传 selector 查询结果。 */
     onDomQueryUpdated(event: string, data: unknown): void;
+    /** 触发页面刷新，用于测试前消除上一轮运行状态对页面初始化的影响。 */
+    reloadPage(options: {
+        event: string;
+    }): void | Promise<void>;
+    /** 回传页面刷新触发结果；Runtime 路径只能普通刷新，不能承诺绕过 HTTP 缓存。 */
+    onPageReloaded(event: string, data: unknown): void;
     /** 执行已授权的页面表达式，用于无 CDP 配置时提供控制台测试能力。 */
     evaluateScript(options: {
         event: string;

package/dist/index.d.ts

@@ -177,6 +177,8 @@ type ScreenshotTarget = 'viewport' | 'fullPage' | 'element';
  * MCP 返回 base64 数据，格式会直接影响体积；限制为常见浏览器截图格式可以简化大小控制和文档说明。
  */
 type ScreenshotFormat = 'png' | 'jpeg' | 'webp';
+/** 截图输出类型，项目级配置用于统一控制 MCP 返回路径还是直接返回图片数据。 */
+type ScreenshotOutputType = 'path' | 'base64';
 /**
  * snapdom 插件路径对象。
  *
@@ -247,6 +249,10 @@ interface SnapdomScreenshotOptions {
  * 截图能力同时存在真截图和 DOM 降级截图；集中配置可以让用户明确选择准确度、体积和兼容性边界。
  */
 interface ScreenshotOptions {
+    /** 截图输出类型，项目级 MCP 默认用路径减少 base64 对上下文的占用。 */
+    readonly type?: ScreenshotOutputType;
+    /** 截图保存目录，相对路径按 Vite 项目根目录解析。 */
+    readonly saveDir?: string;
     /** 默认截图通道选择，适合项目按运行环境统一控制降级策略。 */
     readonly prefer?: ScreenshotPrefer;
     /** 单次 MCP 返回图片最大字节数，避免 base64 图片挤占上下文或拖慢客户端。 */
@@ -490,6 +496,12 @@ interface VueRuntimeRpc {
     }): void | Promise<void>;
     /** 回传 selector 查询结果。 */
     onDomQueryUpdated(event: string, data: unknown): void;
+    /** 触发页面刷新，用于测试前消除上一轮运行状态对页面初始化的影响。 */
+    reloadPage(options: {
+        event: string;
+    }): void | Promise<void>;
+    /** 回传页面刷新触发结果；Runtime 路径只能普通刷新，不能承诺绕过 HTTP 缓存。 */
+    onPageReloaded(event: string, data: unknown): void;
     /** 执行已授权的页面表达式，用于无 CDP 配置时提供控制台测试能力。 */
     evaluateScript(options: {
         event: string;

package/dist/index.js

@@ -17,8 +17,10 @@ var DEFAULT_MASK_HEADERS = [
 // src/constants.ts
 var DEFAULT_MCP_PATH = "/__mcp";
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_SCREENSHOT_SAVE_DIR = ".vite-mcp/screenshot";
 var MCP_TOOL_NAMES = {
   listPages: "list_pages",
+  reloadPage: "reload_page",
   getPageState: "get_page_state",
   getDomTree: "get_dom_tree",
   queryDom: "query_dom",
@@ -41,7 +43,10 @@ var VIRTUAL_RUNTIME_ID = "virtual:vite-plugin-vue-mcp-next/runtime";
 var RESOLVED_VIRTUAL_RUNTIME_ID = `\0${VIRTUAL_RUNTIME_ID}`;
 var VIRTUAL_SCREENSHOT_CONFIG_ID = "virtual:vite-plugin-vue-mcp-next/screenshot-config";
 var RESOLVED_VIRTUAL_SCREENSHOT_CONFIG_ID = `\0${VIRTUAL_SCREENSHOT_CONFIG_ID}`;
+var VIRTUAL_SNAPDOM_LOADER_ID = "virtual:vite-plugin-vue-mcp-next/snapdom-loader";
+var RESOLVED_VIRTUAL_SNAPDOM_LOADER_ID = `\0${VIRTUAL_SNAPDOM_LOADER_ID}`;
 var DEFAULT_MCP_CLIENT_SERVER_NAME = "vue-mcp-next";
+var RUNTIME_PAGE_RECONNECTED_EVENT = "vite-plugin-vue-mcp-next:page-reconnected";
 var DEFAULT_OPTIONS = {
   mcpPath: DEFAULT_MCP_PATH,
   host: "localhost",
@@ -82,6 +87,8 @@ var DEFAULT_OPTIONS = {
     maxRecords: DEFAULT_CONSOLE_MAX_RECORDS
   },
   screenshot: {
+    type: "path",
+    saveDir: DEFAULT_SCREENSHOT_SAVE_DIR,
     prefer: "auto",
     maxBytes: DEFAULT_SCREENSHOT_MAX_BYTES,
     snapdom: {
@@ -611,6 +618,9 @@ function registerNetworkTools(server, ctx) {
   );
 }
 
+// src/mcp/tools/pages.ts
+import { z as z5 } from "zod";
+
 // src/plugin/entryDiscovery.ts
 import fs from "fs";
 import path from "path";
@@ -662,6 +672,118 @@ function registerPageTools(server, ctx, vite) {
       });
     }
   );
+  server.registerTool(
+    MCP_TOOL_NAMES.reloadPage,
+    {
+      description: "Reload the selected page. CDP uses ignoreCache; Runtime Hook falls back to normal reload.",
+      inputSchema: {
+        pageId: z5.string().optional(),
+        ignoreCache: z5.boolean().optional()
+      }
+    },
+    async (input) => {
+      if (hasCdpConfig(ctx)) {
+        return reloadPageWithCdp(ctx, input.pageId, input.ignoreCache ?? true);
+      }
+      const target = resolveRuntimeReloadTarget(ctx, input.pageId);
+      if (!target.ok) {
+        return createToolError(target.error);
+      }
+      const reconnect = waitForRuntimePageReconnect(ctx);
+      ctx.pages.disconnect(target.page.pageId);
+      const result = await requestRuntimeData(ctx, (event) => {
+        void ctx.rpcServer?.reloadPage({ event });
+      });
+      if (!isRecord(result) || result.ok === false) {
+        reconnect.cancel();
+        return createToolResponse(
+          isRecord(result) ? result : { ok: false, error: "Invalid runtime reload response" }
+        );
+      }
+      const page = await reconnect.promise;
+      return createToolResponse(
+        page ? { ...result, reconnected: true, pageId: page.pageId, page } : {
+          ...result,
+          reconnected: false,
+          error: "runtime page reconnect timed out"
+        }
+      );
+    }
+  );
+}
+function hasCdpConfig(ctx) {
+  return Boolean(ctx.options.cdp.browserUrl || ctx.options.cdp.wsEndpoint);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveRuntimeReloadTarget(ctx, pageId) {
+  try {
+    const page = resolvePageTarget(ctx, pageId);
+    if (page.source !== "runtime") {
+      return {
+        ok: false,
+        error: "Runtime reload requires a runtime page target"
+      };
+    }
+    return { ok: true, page };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function waitForRuntimePageReconnect(ctx) {
+  let timeout;
+  let cleanup;
+  const promise = new Promise((resolve) => {
+    timeout = setTimeout(() => {
+      cleanup?.();
+      resolve(null);
+    }, 5e3);
+    cleanup = ctx.hooks.hookOnce(RUNTIME_PAGE_RECONNECTED_EVENT, (payload) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      resolve(isPageTarget(payload) ? payload : null);
+    });
+  });
+  return {
+    promise,
+    cancel() {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      cleanup?.();
+    }
+  };
+}
+function isPageTarget(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.pageId === "string" && (value.source === "runtime" || value.source === "cdp") && typeof value.url === "string" && typeof value.pathname === "string" && typeof value.connected === "boolean";
+}
+async function reloadPageWithCdp(ctx, pageId, ignoreCache) {
+  const cdp = await connectCdpForPage(ctx, pageId);
+  if (!cdp) {
+    return createToolError("CDP target is unavailable for page reload");
+  }
+  try {
+    await cdp.client.Page.enable();
+    const loaded = cdp.client.Page.loadEventFired();
+    await cdp.client.Page.reload({ ignoreCache });
+    await loaded;
+    return createToolResponse({
+      ok: true,
+      source: "cdp",
+      ignoreCache,
+      pageId
+    });
+  } finally {
+    await closeCdpClient(cdp.client);
+  }
 }
 async function listCdpPageTargets(ctx) {
   if (ctx.options.cdp.wsEndpoint) {
@@ -708,7 +830,7 @@ function getPathname(url) {
 }
 
 // src/mcp/tools/screenshot.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/cdp/cdpScreenshot.ts
 async function cdpCaptureScreenshot(options) {
@@ -812,18 +934,70 @@ function isElementRect(value) {
   return typeof rect.x === "number" && typeof rect.y === "number" && typeof rect.width === "number" && rect.width > 0 && typeof rect.height === "number" && rect.height > 0;
 }
 
+// src/mcp/tools/screenshotOutput.ts
+import { randomUUID } from "crypto";
+import { mkdir, writeFile } from "fs/promises";
+import path2 from "path";
+async function createScreenshotOutput(ctx, payload) {
+  if (ctx.options.screenshot.type === "base64") {
+    return payload;
+  }
+  const saveDir = resolveScreenshotSaveDir(ctx);
+  await mkdir(saveDir, { recursive: true });
+  const filePath = path2.join(saveDir, createScreenshotFileName(payload));
+  await writeFile(filePath, Buffer.from(payload.data, "base64"));
+  return {
+    source: payload.source,
+    target: payload.target,
+    format: payload.format,
+    width: payload.width,
+    height: payload.height,
+    mimeType: payload.mimeType,
+    byteLength: payload.byteLength,
+    limitations: payload.limitations,
+    path: filePath,
+    relativePath: createProjectRelativePath(ctx, filePath)
+  };
+}
+function resolveScreenshotSaveDir(ctx) {
+  const saveDir = ctx.options.screenshot.saveDir.trim();
+  if (!saveDir) {
+    throw new Error("screenshot.saveDir must be a non-empty string");
+  }
+  const root = ctx.server?.config.root;
+  if (!root) {
+    throw new Error("Vite server root is required for screenshot path output");
+  }
+  if (path2.isAbsolute(saveDir)) {
+    return saveDir;
+  }
+  return path2.resolve(root, saveDir);
+}
+function createScreenshotFileName(payload) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const suffix = randomUUID().slice(0, 8);
+  return `${timestamp}-${payload.source}-${payload.target}-${suffix}.${payload.format}`;
+}
+function createProjectRelativePath(ctx, filePath) {
+  const root = ctx.server?.config.root;
+  if (!root) {
+    throw new Error("Vite server root is required for screenshot path output");
+  }
+  return path2.relative(root, filePath).split(path2.sep).join("/");
+}
+
 // src/mcp/tools/screenshot.ts
 var DEFAULT_SCREENSHOT_TARGET = "viewport";
 var DEFAULT_SCREENSHOT_FORMAT = "png";
 var screenshotInputSchema = {
-  pageId: z5.string().optional(),
-  target: z5.enum(["viewport", "fullPage", "element"]).optional(),
-  selector: z5.string().optional(),
-  format: z5.enum(["png", "jpeg", "webp"]).optional(),
-  prefer: z5.enum(["auto", "cdp", "runtime"]).optional(),
-  quality: z5.number().optional(),
-  scale: z5.number().optional(),
-  snapdom: z5.record(z5.string(), z5.unknown()).optional()
+  pageId: z6.string().optional(),
+  target: z6.enum(["viewport", "fullPage", "element"]).optional(),
+  selector: z6.string().optional(),
+  format: z6.enum(["png", "jpeg", "webp"]).optional(),
+  prefer: z6.enum(["auto", "cdp", "runtime"]).optional(),
+  quality: z6.number().optional(),
+  scale: z6.number().optional(),
+  snapdom: z6.record(z6.string(), z6.unknown()).optional()
 };
 function registerScreenshotTools(server, ctx) {
   server.registerTool(
@@ -853,7 +1027,7 @@ async function handleTakeScreenshot(ctx, input) {
           format,
           quality: input.quality
         });
-        return createScreenshotResponse(ctx, {
+        return await createScreenshotResponse(ctx, {
           source: "cdp",
           target,
           format,
@@ -899,15 +1073,30 @@ async function createRuntimeScreenshot(ctx, input, normalized) {
   if (!isPlainRecord(result)) {
     return createToolError("runtime screenshot returned an invalid response");
   }
-  return createToolResponse(result);
+  if (result.ok === false) {
+    return createToolResponse(result);
+  }
+  if (!isScreenshotImagePayload(result)) {
+    return createToolError("runtime screenshot returned an invalid response");
+  }
+  return createScreenshotResponse(ctx, {
+    ...result,
+    target: normalized.target,
+    format: normalized.format
+  });
 }
-function createScreenshotResponse(ctx, result) {
+async function createScreenshotResponse(ctx, result) {
   if (result.byteLength > ctx.options.screenshot.maxBytes) {
     return createToolError(
       `screenshot is too large: ${String(result.byteLength)} bytes`
     );
   }
-  return createToolResponse(result);
+  try {
+    return createToolResponse(await createScreenshotOutput(ctx, result));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return createToolError(`failed to create screenshot output: ${message}`);
+  }
 }
 function isScreenshotTooLarge(ctx, result) {
   return isPlainRecord(result) && "byteLength" in result && typeof result.byteLength === "number" && result.byteLength > ctx.options.screenshot.maxBytes;
@@ -922,10 +1111,13 @@ function getBase64ByteLength(data) {
   const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
   return Math.ceil(data.length * 3 / 4) - padding;
 }
+function isScreenshotImagePayload(result) {
+  return (result.source === "cdp" || result.source === "snapdom") && typeof result.data === "string" && typeof result.width === "number" && typeof result.height === "number" && typeof result.mimeType === "string" && typeof result.byteLength === "number";
+}
 
 // src/mcp/tools/vue.ts
 import { nanoid as nanoid2 } from "nanoid";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function registerVueTools(server, ctx) {
   server.registerTool(
     MCP_TOOL_NAMES.getComponentTree,
@@ -938,7 +1130,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.getComponentState,
     {
       description: "Get Vue component state.",
-      inputSchema: { componentName: z6.string() }
+      inputSchema: { componentName: z7.string() }
     },
     async ({ componentName }) => requestVueData(ctx, (event) => {
       void ctx.rpcServer?.getInspectorState({ event, componentName });
@@ -949,19 +1141,19 @@ function registerVueTools(server, ctx) {
     {
       description: "Edit Vue component state.",
       inputSchema: {
-        componentName: z6.string(),
-        path: z6.array(z6.string()),
-        value: z6.string(),
-        valueType: z6.enum(["string", "number", "boolean", "object", "array"])
+        componentName: z7.string(),
+        path: z7.array(z7.string()),
+        value: z7.string(),
+        valueType: z7.enum(["string", "number", "boolean", "object", "array"])
       }
     },
-    ({ componentName, path: path5, value, valueType }) => {
+    ({ componentName, path: path6, value, valueType }) => {
       if (!ctx.rpcServer) {
         return vueBridgeUnavailable();
       }
       void ctx.rpcServer.editComponentState({
         componentName,
-        path: path5,
+        path: path6,
         value,
         valueType
       });
@@ -972,7 +1164,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.highlightComponent,
     {
       description: "Highlight a Vue component.",
-      inputSchema: { componentName: z6.string() }
+      inputSchema: { componentName: z7.string() }
     },
     ({ componentName }) => {
       if (!ctx.rpcServer) {
@@ -1000,7 +1192,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.getPiniaState,
     {
       description: "Get Pinia store state.",
-      inputSchema: { storeName: z6.string() }
+      inputSchema: { storeName: z7.string() }
     },
     async ({ storeName }) => requestVueData(ctx, (event) => {
       void ctx.rpcServer?.getPiniaState({ event, storeName });
@@ -1122,6 +1314,10 @@ function createServerVueRuntimeRpc(ctx) {
     onDomQueryUpdated: (event, data) => {
       void ctx.hooks.callHook(event, data);
     },
+    reloadPage: () => void 0,
+    onPageReloaded: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
     evaluateScript: () => void 0,
     onEvaluateScriptUpdated: (event, data) => {
       void ctx.hooks.callHook(event, data);
@@ -1415,6 +1611,8 @@ async function startCdpObservers(ctx, target, client) {
 }
 
 // src/plugin/injectRuntime.ts
+import { createRequire } from "module";
+import { join } from "path";
 function createRuntimeInjectionController(options, getConfig) {
   return {
     resolveId(importee) {
@@ -1424,6 +1622,9 @@ function createRuntimeInjectionController(options, getConfig) {
       if (importee === VIRTUAL_SCREENSHOT_CONFIG_ID) {
         return RESOLVED_VIRTUAL_SCREENSHOT_CONFIG_ID;
       }
+      if (importee === VIRTUAL_SNAPDOM_LOADER_ID) {
+        return RESOLVED_VIRTUAL_SNAPDOM_LOADER_ID;
+      }
       return void 0;
     },
     load(id) {
@@ -1433,6 +1634,9 @@ function createRuntimeInjectionController(options, getConfig) {
       if (id === RESOLVED_VIRTUAL_SCREENSHOT_CONFIG_ID) {
         return createScreenshotConfigModule(options);
       }
+      if (id === RESOLVED_VIRTUAL_SNAPDOM_LOADER_ID) {
+        return createSnapdomLoaderModule(getConfig()?.root);
+      }
       return void 0;
     },
     transformIndexHtml(html) {
@@ -1470,12 +1674,39 @@ ${code}`;
 }
 function createRuntimeModule() {
   return [
-    "import { setScreenshotModuleRegistry, startRuntimeClient } from '@xiaou66/vite-plugin-vue-mcp-next/runtime/client';",
+    "import { setScreenshotModuleRegistry, setSnapdomLoader, startRuntimeClient } from '@xiaou66/vite-plugin-vue-mcp-next/runtime/client';",
     `import { screenshotModuleRegistry } from '${VIRTUAL_SCREENSHOT_CONFIG_ID}';`,
+    `import { loadSnapdom } from '${VIRTUAL_SNAPDOM_LOADER_ID}';`,
     "setScreenshotModuleRegistry(screenshotModuleRegistry);",
+    "setSnapdomLoader(loadSnapdom);",
     "void startRuntimeClient();"
   ].join("\n");
 }
+function createSnapdomLoaderModule(root) {
+  if (!canResolveSnapdomFromProject(root)) {
+    return [
+      "export const loadSnapdom = () =>",
+      `  Promise.reject(new Error(${JSON.stringify(createMissingSnapdomMessage())}));`
+    ].join("\n");
+  }
+  return [
+    "import { snapdom } from '@zumer/snapdom';",
+    "export const loadSnapdom = () => Promise.resolve({ snapdom });"
+  ].join("\n");
+}
+function canResolveSnapdomFromProject(root) {
+  try {
+    createRequire(join(root ?? process.cwd(), "package.json")).resolve(
+      "@zumer/snapdom"
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createMissingSnapdomMessage() {
+  return "\u7F3A\u5C11\u53EF\u9009\u4F9D\u8D56 @zumer/snapdom\u3002DOM \u622A\u56FE\u964D\u7EA7\u9700\u8981\u8BE5\u4F9D\u8D56\uFF0C\u8BF7\u6267\u884C\uFF1Apnpm add -D @zumer/snapdom";
+}
 function createScreenshotConfigModule(options) {
   const paths = collectScreenshotImportPaths(options);
   const imports = paths.map((item, index) => `import * as m${String(index)} from ${JSON.stringify(item)};`).join("\n");
@@ -1504,16 +1735,16 @@ function getPluginPath(plugin) {
 }
 
 // src/plugin/mcpClientConfig/index.ts
-import path4 from "path";
+import path5 from "path";
 
 // src/plugin/mcpClientConfig/codexConfig.ts
 import fs2 from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 async function updateCodexMcpClientConfig(options) {
   try {
     const current = await readOptionalTextFile(options.configPath);
     const next = replaceOrAppendOwnedBlock(current, options);
-    await fs2.mkdir(path2.dirname(options.configPath), { recursive: true });
+    await fs2.mkdir(path3.dirname(options.configPath), { recursive: true });
     await fs2.writeFile(options.configPath, next);
   } catch (error) {
     console.warn(
@@ -1583,7 +1814,7 @@ function isNodeError(error) {
 
 // src/plugin/mcpClientConfig/jsonConfig.ts
 import fs3 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 async function updateJsonMcpClientConfig(options) {
   try {
     const config = await readJsonConfig(options.configPath);
@@ -1597,7 +1828,7 @@ async function updateJsonMcpClientConfig(options) {
     }
     mcpServers[options.serverName] = { type: "sse", url: options.mcpUrl };
     config.mcpServers = mcpServers;
-    await fs3.mkdir(path3.dirname(options.configPath), { recursive: true });
+    await fs3.mkdir(path4.dirname(options.configPath), { recursive: true });
     await fs3.writeFile(
       options.configPath,
       `${JSON.stringify(config, null, 2)}
@@ -1647,7 +1878,7 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options)
     jobs.push(
       updateJsonMcpClientConfig({
         clientName: "Cursor",
-        configPath: path4.join(root, ".cursor", "mcp.json"),
+        configPath: path5.join(root, ".cursor", "mcp.json"),
         mcpUrl: sseUrl,
         serverName
       })
@@ -1656,7 +1887,7 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options)
   if (options.codex) {
     jobs.push(
       updateCodexMcpClientConfig({
-        configPath: path4.join(root, ".codex", "config.toml"),
+        configPath: path5.join(root, ".codex", "config.toml"),
         mcpUrl: streamableHttpUrl,
         serverName
       })
@@ -1666,7 +1897,7 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options)
     jobs.push(
       updateJsonMcpClientConfig({
         clientName: "Claude Code",
-        configPath: path4.join(root, ".mcp.json"),
+        configPath: path5.join(root, ".mcp.json"),
         mcpUrl: sseUrl,
         serverName
       })
@@ -1676,7 +1907,7 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options)
     jobs.push(
       updateJsonMcpClientConfig({
         clientName: "Trae",
-        configPath: path4.join(root, ".trae", "mcp.json"),
+        configPath: path5.join(root, ".trae", "mcp.json"),
         mcpUrl: sseUrl,
         serverName
       })
@@ -1723,6 +1954,7 @@ function vueMcpNext(userOptions = {}) {
         (payload) => {
           if (isRuntimePageTarget(payload)) {
             ctx.pages.upsert(payload);
+            void ctx.hooks.callHook(RUNTIME_PAGE_RECONNECTED_EVENT, payload);
             void cdpLifecycle.connectPage(payload);
           }
         }