@xiaou66/vite-plugin-vue-mcp-next 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1519 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => vueMcpNext,
+  vueMcpNext: () => vueMcpNext
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin/createPlugin.ts
+var import_vite2 = require("vite");
+
+// src/shared/limits.ts
+var DEFAULT_DOM_MAX_DEPTH = 8;
+var DEFAULT_DOM_MAX_NODES = 2e3;
+var DEFAULT_DOM_MAX_TEXT_LENGTH = 300;
+var DEFAULT_CONSOLE_MAX_RECORDS = 1e3;
+var DEFAULT_NETWORK_MAX_RECORDS = 500;
+var DEFAULT_NETWORK_MAX_BODY_SIZE = 1e5;
+var DEFAULT_MASK_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie"
+];
+
+// src/constants.ts
+var DEFAULT_MCP_PATH = "/__mcp";
+var MCP_TOOL_NAMES = {
+  listPages: "list_pages",
+  getPageState: "get_page_state",
+  getDomTree: "get_dom_tree",
+  queryDom: "query_dom",
+  getConsoleLogs: "get_console_logs",
+  clearConsoleLogs: "clear_console_logs",
+  evaluateScript: "evaluate_script",
+  getNetworkRequests: "get_network_requests",
+  getNetworkRequestDetail: "get_network_request_detail",
+  clearNetworkRequests: "clear_network_requests",
+  getComponentTree: "get_component_tree",
+  getComponentState: "get_component_state",
+  editComponentState: "edit_component_state",
+  highlightComponent: "highlight_component",
+  getRouterInfo: "get_router_info",
+  getPiniaTree: "get_pinia_tree",
+  getPiniaState: "get_pinia_state"
+};
+var VIRTUAL_RUNTIME_ID = "virtual:vite-plugin-vue-mcp-next/runtime";
+var RESOLVED_VIRTUAL_RUNTIME_ID = `\0${VIRTUAL_RUNTIME_ID}`;
+var DEFAULT_MCP_CLIENT_SERVER_NAME = "vue-mcp-next";
+var DEFAULT_OPTIONS = {
+  mcpPath: DEFAULT_MCP_PATH,
+  host: "localhost",
+  printUrl: true,
+  updateCursorMcpJson: {
+    enabled: true,
+    serverName: DEFAULT_MCP_CLIENT_SERVER_NAME
+  },
+  mcpClients: {
+    cursor: true,
+    codex: true,
+    claudeCode: true,
+    trae: true,
+    serverName: DEFAULT_MCP_CLIENT_SERVER_NAME
+  },
+  runtime: {
+    mode: "auto",
+    evaluate: {
+      enabled: false,
+      timeoutMs: 3e3
+    }
+  },
+  cdp: {},
+  network: {
+    mode: "auto",
+    maxRecords: DEFAULT_NETWORK_MAX_RECORDS,
+    captureRequestBody: true,
+    captureResponseBody: true,
+    maxBodySize: DEFAULT_NETWORK_MAX_BODY_SIZE,
+    maskHeaders: [...DEFAULT_MASK_HEADERS]
+  },
+  dom: {
+    maxDepth: DEFAULT_DOM_MAX_DEPTH,
+    maxNodes: DEFAULT_DOM_MAX_NODES,
+    maxTextLength: DEFAULT_DOM_MAX_TEXT_LENGTH
+  },
+  console: {
+    maxRecords: DEFAULT_CONSOLE_MAX_RECORDS
+  }
+};
+function mergeMcpClientOptions(cursorConfig, mcpClients) {
+  return {
+    ...DEFAULT_OPTIONS.mcpClients,
+    cursor: cursorConfig.enabled,
+    serverName: cursorConfig.serverName,
+    ...mcpClients
+  };
+}
+function mergeOptions(options = {}) {
+  const cursorConfig = typeof options.updateCursorMcpJson === "boolean" ? {
+    enabled: options.updateCursorMcpJson,
+    serverName: DEFAULT_OPTIONS.updateCursorMcpJson.serverName
+  } : {
+    ...DEFAULT_OPTIONS.updateCursorMcpJson,
+    ...options.updateCursorMcpJson
+  };
+  const mcpClients = mergeMcpClientOptions(cursorConfig, options.mcpClients);
+  return {
+    ...DEFAULT_OPTIONS,
+    ...options,
+    updateCursorMcpJson: cursorConfig,
+    mcpClients,
+    runtime: {
+      ...DEFAULT_OPTIONS.runtime,
+      ...options.runtime,
+      evaluate: {
+        ...DEFAULT_OPTIONS.runtime.evaluate,
+        ...options.runtime?.evaluate
+      }
+    },
+    cdp: {
+      ...DEFAULT_OPTIONS.cdp,
+      ...options.cdp
+    },
+    network: {
+      ...DEFAULT_OPTIONS.network,
+      ...options.network,
+      maskHeaders: options.network?.maskHeaders ?? [
+        ...DEFAULT_OPTIONS.network.maskHeaders
+      ]
+    },
+    dom: {
+      ...DEFAULT_OPTIONS.dom,
+      ...options.dom
+    },
+    console: {
+      ...DEFAULT_OPTIONS.console,
+      ...options.console
+    }
+  };
+}
+
+// src/context.ts
+var import_hookable = require("hookable");
+
+// src/shared/ringBuffer.ts
+function createRingBuffer(capacity) {
+  const items = [];
+  return {
+    push(value) {
+      items.push(value);
+      while (items.length > capacity) {
+        items.shift();
+      }
+    },
+    all() {
+      return [...items];
+    },
+    clear() {
+      items.length = 0;
+    }
+  };
+}
+
+// src/context.ts
+function createPageTargetRegistry() {
+  const targets = /* @__PURE__ */ new Map();
+  return {
+    upsert(target) {
+      targets.set(target.pageId, target);
+    },
+    get(pageId) {
+      return targets.get(pageId);
+    },
+    list() {
+      return [...targets.values()];
+    },
+    disconnect(pageId) {
+      const target = targets.get(pageId);
+      if (!target) {
+        return;
+      }
+      targets.set(pageId, { ...target, connected: false });
+    }
+  };
+}
+function createVueMcpNextContext(options) {
+  return {
+    options,
+    hooks: (0, import_hookable.createHooks)(),
+    rpcServer: void 0,
+    pages: createPageTargetRegistry(),
+    consoleRecords: createRingBuffer(options.console.maxRecords),
+    networkRecords: createRingBuffer(options.network.maxRecords)
+  };
+}
+
+// src/mcp/createMcpServer.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/mcp/tools/console.ts
+var import_zod = require("zod");
+
+// src/mcp/routeTools.ts
+var import_nanoid = require("nanoid");
+
+// src/cdp/cdpClient.ts
+var import_chrome_remote_interface = __toESM(require("chrome-remote-interface"), 1);
+function createCdpClient(options) {
+  return {
+    async listTargets() {
+      if (!options.browserUrl) {
+        return [];
+      }
+      const listUrl = new URL("/json/list", options.browserUrl);
+      const response = await fetch(listUrl);
+      return await response.json();
+    },
+    async connect(wsEndpoint) {
+      return (0, import_chrome_remote_interface.default)({ target: wsEndpoint });
+    }
+  };
+}
+
+// src/cdp/targetMatcher.ts
+function matchCdpTarget(targets, options) {
+  const pageTargets = targets.filter(
+    (target) => target.type === "page" && target.webSocketDebuggerUrl
+  );
+  if (options.url) {
+    const exact = pageTargets.find((target) => target.url === options.url);
+    if (exact) {
+      return exact;
+    }
+  }
+  if (options.targetUrlPattern) {
+    const pattern = options.targetUrlPattern;
+    return pageTargets.find(
+      (target) => typeof pattern === "string" ? target.url.includes(pattern) : pattern.test(target.url)
+    );
+  }
+  return pageTargets[0];
+}
+
+// src/mcp/routeTools.ts
+function shouldUseCdp(options) {
+  if (options.capabilityMode === "off" || options.capabilityMode === "hook") {
+    return false;
+  }
+  if (!options.hasMatchedCdpTarget) {
+    return false;
+  }
+  return Boolean(
+    options.options.cdp.browserUrl || options.options.cdp.wsEndpoint
+  );
+}
+function createToolResponse(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
+}
+function createToolError(message, data) {
+  return createToolResponse({
+    ok: false,
+    error: message,
+    data
+  });
+}
+function resolvePageTarget(ctx, pageId) {
+  const targets = ctx.pages.list().filter((target) => target.connected);
+  if (pageId) {
+    const target = targets.find((item) => item.pageId === pageId);
+    if (!target) {
+      throw new Error(`Page target not found: ${pageId}`);
+    }
+    return target;
+  }
+  if (targets.length === 1) {
+    return targets[0];
+  }
+  throw new Error(
+    "Multiple or no page targets available. Call list_pages and pass pageId."
+  );
+}
+async function connectCdpForPage(ctx, pageId) {
+  if (!ctx.options.cdp.browserUrl && !ctx.options.cdp.wsEndpoint) {
+    return void 0;
+  }
+  const cdp = createCdpClient(ctx.options.cdp);
+  if (ctx.options.cdp.wsEndpoint) {
+    return { client: await cdp.connect(ctx.options.cdp.wsEndpoint) };
+  }
+  const page = resolvePageTarget(ctx, pageId);
+  const target = matchCdpTarget(await cdp.listTargets(), {
+    url: page.url,
+    targetUrlPattern: ctx.options.cdp.targetUrlPattern
+  });
+  if (!target?.webSocketDebuggerUrl) {
+    return void 0;
+  }
+  return { client: await cdp.connect(target.webSocketDebuggerUrl), target };
+}
+async function closeCdpClient(client) {
+  await client.close();
+}
+async function requestRuntimeData(ctx, trigger) {
+  if (!ctx.rpcServer) {
+    return { ok: false, error: "runtime bridge is not connected" };
+  }
+  const event = (0, import_nanoid.nanoid)();
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve({ ok: false, error: "runtime bridge response timed out" });
+    }, 5e3);
+    ctx.hooks.hookOnce(event, (data) => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+    trigger(event);
+  });
+}
+
+// src/mcp/tools/console.ts
+function registerConsoleTools(server, ctx) {
+  server.registerTool(
+    MCP_TOOL_NAMES.getConsoleLogs,
+    {
+      description: "Get console logs for the selected page.",
+      inputSchema: {
+        pageId: import_zod.z.string().optional(),
+        level: import_zod.z.enum(["log", "info", "warn", "error", "debug"]).optional(),
+        limit: import_zod.z.number().optional()
+      }
+    },
+    (input) => {
+      const logs = ctx.consoleRecords.all().filter((record) => !input.pageId || record.pageId === input.pageId).filter((record) => !input.level || record.level === input.level).slice(-(input.limit ?? ctx.options.console.maxRecords));
+      return createToolResponse({ logs });
+    }
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.clearConsoleLogs,
+    {
+      description: "Clear cached console logs for the selected page.",
+      inputSchema: {
+        pageId: import_zod.z.string().optional()
+      }
+    },
+    () => {
+      ctx.consoleRecords.clear();
+      return createToolResponse({ ok: true });
+    }
+  );
+}
+
+// src/mcp/tools/dom.ts
+var import_zod2 = require("zod");
+
+// src/cdp/cdpDom.ts
+async function cdpGetDomSnapshot(client) {
+  await client.DOMSnapshot.enable();
+  return client.DOMSnapshot.captureSnapshot({
+    computedStyles: []
+  });
+}
+async function cdpQueryDom(client, selector, limit) {
+  const expression = `Array.from(document.querySelectorAll(${JSON.stringify(selector)})).slice(0, ${String(limit)}).map((el) => ({ tag: el.tagName.toLowerCase(), text: el.textContent?.trim() || '', attrs: Object.fromEntries(Array.from(el.attributes).map((attr) => [attr.name, attr.value])), rect: el.getBoundingClientRect().toJSON() }))`;
+  const result = await client.Runtime.evaluate({
+    expression,
+    returnByValue: true
+  });
+  if (result.exceptionDetails) {
+    throw new Error(result.exceptionDetails.text || "CDP query DOM failed");
+  }
+  return result.result.value;
+}
+
+// src/mcp/tools/dom.ts
+function registerDomTools(server, ctx) {
+  server.registerTool(
+    MCP_TOOL_NAMES.getDomTree,
+    {
+      description: "Get a clipped DOM tree for the selected page.",
+      inputSchema: {
+        pageId: import_zod2.z.string().optional(),
+        maxDepth: import_zod2.z.number().optional(),
+        maxNodes: import_zod2.z.number().optional()
+      }
+    },
+    async (input) => {
+      const cdp = await connectCdpForPage(ctx, input.pageId);
+      if (cdp && shouldUseCdp({
+        options: ctx.options,
+        capabilityMode: ctx.options.runtime.mode,
+        hasMatchedCdpTarget: true
+      })) {
+        try {
+          const snapshot2 = await cdpGetDomSnapshot(cdp.client);
+          return createToolResponse({
+            source: "cdp",
+            snapshot: snapshot2,
+            limits: {
+              maxDepth: input.maxDepth ?? ctx.options.dom.maxDepth,
+              maxNodes: input.maxNodes ?? ctx.options.dom.maxNodes
+            }
+          });
+        } finally {
+          await closeCdpClient(cdp.client);
+        }
+      }
+      const snapshot = await requestRuntimeData(ctx, (event) => {
+        void ctx.rpcServer?.getDomTree({
+          event,
+          maxDepth: input.maxDepth ?? ctx.options.dom.maxDepth,
+          maxNodes: input.maxNodes ?? ctx.options.dom.maxNodes,
+          maxTextLength: ctx.options.dom.maxTextLength
+        });
+      });
+      return createToolResponse({ source: "hook", snapshot });
+    }
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.queryDom,
+    {
+      description: "Query DOM nodes by selector in the selected page.",
+      inputSchema: {
+        pageId: import_zod2.z.string().optional(),
+        selector: import_zod2.z.string(),
+        limit: import_zod2.z.number().optional()
+      }
+    },
+    async (input) => {
+      const cdp = await connectCdpForPage(ctx, input.pageId);
+      if (cdp && shouldUseCdp({
+        options: ctx.options,
+        capabilityMode: ctx.options.runtime.mode,
+        hasMatchedCdpTarget: true
+      })) {
+        try {
+          const nodes2 = await cdpQueryDom(
+            cdp.client,
+            input.selector,
+            input.limit ?? 20
+          );
+          return createToolResponse({ source: "cdp", nodes: nodes2 });
+        } finally {
+          await closeCdpClient(cdp.client);
+        }
+      }
+      const nodes = await requestRuntimeData(ctx, (event) => {
+        void ctx.rpcServer?.queryDom({
+          event,
+          selector: input.selector,
+          limit: input.limit ?? 20
+        });
+      });
+      return createToolResponse({ source: "hook", nodes });
+    }
+  );
+}
+
+// src/mcp/tools/evaluate.ts
+var import_zod3 = require("zod");
+
+// src/cdp/cdpEvaluate.ts
+async function cdpEvaluate(options) {
+  const result = await options.client.Runtime.evaluate({
+    expression: options.expression,
+    awaitPromise: options.awaitPromise ?? true,
+    returnByValue: true
+  });
+  if (result.exceptionDetails) {
+    throw new Error(result.exceptionDetails.text || "CDP evaluate failed");
+  }
+  return result.result.value;
+}
+
+// src/mcp/tools/evaluate.ts
+function registerEvaluateTools(server, ctx) {
+  server.registerTool(
+    MCP_TOOL_NAMES.evaluateScript,
+    {
+      description: "Evaluate a script in the selected page when explicitly enabled.",
+      inputSchema: {
+        pageId: import_zod3.z.string().optional(),
+        expression: import_zod3.z.string(),
+        awaitPromise: import_zod3.z.boolean().optional()
+      }
+    },
+    async (input) => {
+      try {
+        assertEvaluateEnabled(ctx.options);
+      } catch (error) {
+        return createToolError(
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      const cdp = await connectCdpForPage(ctx, input.pageId);
+      if (cdp && shouldUseCdp({
+        options: ctx.options,
+        capabilityMode: ctx.options.runtime.mode,
+        hasMatchedCdpTarget: true
+      })) {
+        try {
+          const value = await cdpEvaluate({
+            client: cdp.client,
+            expression: input.expression,
+            awaitPromise: input.awaitPromise
+          });
+          return createToolResponse({ source: "cdp", value });
+        } finally {
+          await closeCdpClient(cdp.client);
+        }
+      }
+      const result = await requestRuntimeData(ctx, (event) => {
+        void ctx.rpcServer?.evaluateScript({
+          event,
+          expression: input.expression,
+          awaitPromise: input.awaitPromise,
+          timeoutMs: ctx.options.runtime.evaluate.timeoutMs
+        });
+      });
+      return createToolResponse({ source: "hook", result });
+    }
+  );
+}
+function assertEvaluateEnabled(options) {
+  if (!options.runtime.evaluate.enabled) {
+    throw new Error(
+      "evaluate_script is disabled. Enable runtime.evaluate.enabled to use it."
+    );
+  }
+}
+
+// src/mcp/tools/network.ts
+var import_zod4 = require("zod");
+function registerNetworkTools(server, ctx) {
+  server.registerTool(
+    MCP_TOOL_NAMES.getNetworkRequests,
+    {
+      description: "Get captured network request summaries.",
+      inputSchema: {
+        pageId: import_zod4.z.string().optional(),
+        urlContains: import_zod4.z.string().optional(),
+        method: import_zod4.z.string().optional(),
+        status: import_zod4.z.number().optional(),
+        limit: import_zod4.z.number().optional()
+      }
+    },
+    (input) => {
+      if (ctx.options.network.mode === "off") {
+        return createToolError(
+          "Network collection is disabled by configuration"
+        );
+      }
+      const records = ctx.networkRecords.all().filter((record) => !input.pageId || record.pageId === input.pageId).filter(
+        (record) => !input.urlContains || record.url.includes(input.urlContains)
+      ).filter(
+        (record) => !input.method || record.method.toUpperCase() === input.method.toUpperCase()
+      ).filter(
+        (record) => input.status === void 0 || record.status === input.status
+      ).slice(-(input.limit ?? ctx.options.network.maxRecords));
+      return createToolResponse({ requests: records });
+    }
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.getNetworkRequestDetail,
+    {
+      description: "Get captured network request detail by id.",
+      inputSchema: { id: import_zod4.z.string() }
+    },
+    (input) => {
+      if (ctx.options.network.mode === "off") {
+        return createToolError(
+          "Network collection is disabled by configuration"
+        );
+      }
+      const record = ctx.networkRecords.all().find((item) => item.id === input.id);
+      return createToolResponse({ request: record ?? null });
+    }
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.clearNetworkRequests,
+    {
+      description: "Clear cached network requests.",
+      inputSchema: {
+        pageId: import_zod4.z.string().optional()
+      }
+    },
+    () => {
+      ctx.networkRecords.clear();
+      return createToolResponse({ ok: true });
+    }
+  );
+}
+
+// src/plugin/entryDiscovery.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_vite = require("vite");
+function discoverHtmlEntries(server) {
+  const root = server.config.root;
+  const entries = [];
+  walkHtmlEntries(root, root, entries);
+  return entries;
+}
+function walkHtmlEntries(root, dir, entries) {
+  for (const item of import_node_fs.default.readdirSync(dir, { withFileTypes: true })) {
+    if (item.name === "node_modules" || item.name.startsWith(".")) {
+      continue;
+    }
+    const fullPath = import_node_path.default.join(dir, item.name);
+    if (item.isDirectory()) {
+      walkHtmlEntries(root, fullPath, entries);
+      continue;
+    }
+    if (!item.isFile() || !item.name.endsWith(".html")) {
+      continue;
+    }
+    const relative = (0, import_vite.normalizePath)(import_node_path.default.relative(root, fullPath));
+    entries.push({
+      file: relative,
+      pathname: relative === "index.html" ? "/" : `/${relative}`
+    });
+  }
+}
+
+// src/mcp/tools/pages.ts
+function registerPageTools(server, ctx, vite) {
+  server.registerTool(
+    MCP_TOOL_NAMES.listPages,
+    {
+      description: "List Vite page entries and connected runtime/CDP targets."
+    },
+    async () => {
+      const cdpResult = await listCdpPageTargets(ctx);
+      for (const target of cdpResult.pages) {
+        ctx.pages.upsert(target);
+        void ctx.cdpLifecycle?.connectPage(target);
+      }
+      return createToolResponse({
+        entries: discoverHtmlEntries(vite),
+        pages: ctx.pages.list(),
+        cdpError: cdpResult.error
+      });
+    }
+  );
+}
+async function listCdpPageTargets(ctx) {
+  if (ctx.options.cdp.wsEndpoint) {
+    return { pages: [createWsEndpointTarget(ctx.options.cdp.wsEndpoint)] };
+  }
+  if (!ctx.options.cdp.browserUrl) {
+    return { pages: [] };
+  }
+  try {
+    const targets = await createCdpClient(ctx.options.cdp).listTargets();
+    return {
+      pages: targets.filter((target) => target.type === "page").map((target) => ({
+        pageId: `cdp:${target.id}`,
+        source: "cdp",
+        url: target.url,
+        pathname: getPathname(target.url),
+        title: target.title,
+        connected: Boolean(target.webSocketDebuggerUrl)
+      }))
+    };
+  } catch (error) {
+    return {
+      pages: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createWsEndpointTarget(wsEndpoint) {
+  return {
+    pageId: "cdp:ws-endpoint",
+    source: "cdp",
+    url: wsEndpoint,
+    pathname: "cdp:ws-endpoint",
+    title: "CDP WebSocket endpoint",
+    connected: true
+  };
+}
+function getPathname(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+
+// src/mcp/tools/vue.ts
+var import_nanoid2 = require("nanoid");
+var import_zod5 = require("zod");
+function registerVueTools(server, ctx) {
+  server.registerTool(
+    MCP_TOOL_NAMES.getComponentTree,
+    { description: "Get Vue component tree." },
+    async () => requestVueData(ctx, (event) => {
+      void ctx.rpcServer?.getInspectorTree({ event });
+    })
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.getComponentState,
+    {
+      description: "Get Vue component state.",
+      inputSchema: { componentName: import_zod5.z.string() }
+    },
+    async ({ componentName }) => requestVueData(ctx, (event) => {
+      void ctx.rpcServer?.getInspectorState({ event, componentName });
+    })
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.editComponentState,
+    {
+      description: "Edit Vue component state.",
+      inputSchema: {
+        componentName: import_zod5.z.string(),
+        path: import_zod5.z.array(import_zod5.z.string()),
+        value: import_zod5.z.string(),
+        valueType: import_zod5.z.enum(["string", "number", "boolean", "object", "array"])
+      }
+    },
+    ({ componentName, path: path5, value, valueType }) => {
+      if (!ctx.rpcServer) {
+        return vueBridgeUnavailable();
+      }
+      void ctx.rpcServer.editComponentState({
+        componentName,
+        path: path5,
+        value,
+        valueType
+      });
+      return createToolResponse({ ok: true });
+    }
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.highlightComponent,
+    {
+      description: "Highlight a Vue component.",
+      inputSchema: { componentName: import_zod5.z.string() }
+    },
+    ({ componentName }) => {
+      if (!ctx.rpcServer) {
+        return vueBridgeUnavailable();
+      }
+      void ctx.rpcServer.highlightComponent({ componentName });
+      return createToolResponse({ ok: true });
+    }
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.getRouterInfo,
+    { description: "Get Vue Router information." },
+    async () => requestVueData(ctx, (event) => {
+      ctx.rpcServer?.getRouterInfo({ event });
+    })
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.getPiniaTree,
+    { description: "Get Pinia inspector tree." },
+    async () => requestVueData(ctx, (event) => {
+      void ctx.rpcServer?.getPiniaTree({ event });
+    })
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.getPiniaState,
+    {
+      description: "Get Pinia store state.",
+      inputSchema: { storeName: import_zod5.z.string() }
+    },
+    async ({ storeName }) => requestVueData(ctx, (event) => {
+      void ctx.rpcServer?.getPiniaState({ event, storeName });
+    })
+  );
+}
+async function requestVueData(ctx, trigger) {
+  if (!ctx.rpcServer) {
+    return vueBridgeUnavailable();
+  }
+  const event = (0, import_nanoid2.nanoid)();
+  const data = await waitForVueHook(ctx, event, () => {
+    trigger(event);
+  });
+  return {
+    ...createToolResponse({ data })
+  };
+}
+function waitForVueHook(ctx, event, trigger) {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve({ ok: false, error: "Vue runtime bridge response timed out" });
+    }, 5e3);
+    ctx.hooks.hookOnce(event, (data) => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+    trigger();
+  });
+}
+function vueBridgeUnavailable() {
+  return createToolError("Vue runtime bridge is not connected");
+}
+
+// src/mcp/createMcpServer.ts
+function createMcpServer(ctx, vite) {
+  const server = new import_mcp.McpServer({
+    name: "vite-plugin-vue-mcp-next",
+    version: "0.0.0"
+  });
+  registerPageTools(server, ctx, vite);
+  registerDomTools(server, ctx);
+  registerConsoleTools(server, ctx);
+  registerEvaluateTools(server, ctx);
+  registerNetworkTools(server, ctx);
+  registerVueTools(server, ctx);
+  return server;
+}
+
+// src/mcp/transport.ts
+var import_sse = require("@modelcontextprotocol/sdk/server/sse.js");
+function setupMcpTransport(base, server, vite) {
+  const transports = /* @__PURE__ */ new Map();
+  vite.middlewares.use(`${base}/sse`, (_req, res) => {
+    const transport = new import_sse.SSEServerTransport(`${base}/messages`, res);
+    transports.set(transport.sessionId, transport);
+    res.on("close", () => {
+      transports.delete(transport.sessionId);
+    });
+    void server.connect(transport).catch((error) => {
+      res.destroy(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+  vite.middlewares.use(`${base}/messages`, (req, res) => {
+    if (req.method !== "POST") {
+      res.statusCode = 405;
+      res.end("Method Not Allowed");
+      return;
+    }
+    const query = new URLSearchParams(req.url?.split("?").pop() || "");
+    const sessionId = query.get("sessionId");
+    if (!sessionId) {
+      res.statusCode = 400;
+      res.end("Bad Request");
+      return;
+    }
+    const transport = transports.get(sessionId);
+    if (!transport) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    void transport.handlePostMessage(req, res).catch((error) => {
+      res.destroy(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+}
+
+// src/mcp/vueRpc.ts
+function createServerVueRuntimeRpc(ctx) {
+  return {
+    getDomTree: () => void 0,
+    onDomTreeUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    queryDom: () => void 0,
+    onDomQueryUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    evaluateScript: () => void 0,
+    onEvaluateScriptUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    getInspectorTree: () => void 0,
+    onInspectorTreeUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    getInspectorState: () => void 0,
+    onInspectorStateUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    editComponentState: () => void 0,
+    highlightComponent: () => void 0,
+    getRouterInfo: () => void 0,
+    onRouterInfoUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    getPiniaTree: () => void 0,
+    onPiniaTreeUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    getPiniaState: () => void 0,
+    onPiniaInfoUpdated: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    }
+  };
+}
+
+// src/cdp/cdpConsole.ts
+var import_nanoid3 = require("nanoid");
+
+// src/shared/serialization.ts
+function safeStringify(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const serialized = JSON.stringify(
+    value,
+    (_key, current) => {
+      if (typeof current !== "object" || current === null) {
+        return current;
+      }
+      if (seen.has(current)) {
+        return "[Circular]";
+      }
+      seen.add(current);
+      return current;
+    }
+  );
+  return serialized;
+}
+
+// src/cdp/cdpConsole.ts
+async function startCdpConsole(options) {
+  await options.client.Runtime.enable();
+  options.client.Runtime.consoleAPICalled((event) => {
+    options.push({
+      id: (0, import_nanoid3.nanoid)(),
+      pageId: options.pageId,
+      source: "cdp",
+      level: normalizeConsoleLevel(event.type),
+      message: event.args.map((arg) => safeStringify(arg.value ?? arg.description)).join(" "),
+      timestamp: event.timestamp
+    });
+  });
+}
+function normalizeConsoleLevel(level) {
+  if (level === "warning") {
+    return "warn";
+  }
+  if (level === "error" || level === "debug" || level === "info") {
+    return level;
+  }
+  return "log";
+}
+
+// src/cdp/cdpNetwork.ts
+var import_nanoid4 = require("nanoid");
+
+// src/shared/sanitize.ts
+function maskHeaders(headers = {}, maskNames = []) {
+  const normalizedMaskNames = new Set(
+    maskNames.map((name) => name.toLowerCase())
+  );
+  return Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => [
+      name,
+      normalizedMaskNames.has(name.toLowerCase()) ? "[masked]" : value
+    ])
+  );
+}
+
+// src/shared/url.ts
+function parseRequestQuery(url) {
+  const parsed = new URL(url, "http://vite-plugin-vue-mcp-next.local");
+  const queryEntries = /* @__PURE__ */ new Map();
+  for (const [key, value] of parsed.searchParams.entries()) {
+    const existing = queryEntries.get(key);
+    if (existing === void 0) {
+      queryEntries.set(key, value);
+      continue;
+    }
+    if (Array.isArray(existing)) {
+      existing.push(value);
+      continue;
+    }
+    queryEntries.set(key, [existing, value]);
+  }
+  return Object.fromEntries(queryEntries);
+}
+
+// src/cdp/cdpNetwork.ts
+async function startCdpNetwork(options) {
+  const records = /* @__PURE__ */ new Map();
+  await options.client.Network.enable();
+  options.client.Network.requestWillBeSent((event) => {
+    records.set(event.requestId, {
+      id: (0, import_nanoid4.nanoid)(),
+      pageId: options.pageId,
+      source: "cdp",
+      url: event.request.url,
+      method: event.request.method,
+      requestHeaders: maskHeaders(
+        normalizeHeaders(event.request.headers),
+        options.maskHeaders
+      ),
+      requestQuery: parseRequestQuery(event.request.url),
+      requestBody: event.request.postData,
+      startedAt: event.timestamp * 1e3
+    });
+  });
+  options.client.Network.responseReceived((event) => {
+    const record = records.get(event.requestId);
+    if (!record) {
+      return;
+    }
+    records.set(event.requestId, {
+      ...record,
+      status: event.response.status,
+      responseHeaders: normalizeHeaders(event.response.headers)
+    });
+  });
+  options.client.Network.loadingFinished((event) => {
+    void finalizeCdpNetworkRecord(
+      options,
+      records,
+      event.requestId,
+      event.timestamp * 1e3
+    );
+  });
+  options.client.Network.loadingFailed((event) => {
+    const record = records.get(event.requestId);
+    if (!record) {
+      return;
+    }
+    records.delete(event.requestId);
+    options.push({
+      ...record,
+      error: event.errorText,
+      endedAt: event.timestamp * 1e3,
+      durationMs: event.timestamp * 1e3 - record.startedAt
+    });
+  });
+}
+async function finalizeCdpNetworkRecord(options, records, requestId, endedAt) {
+  const record = records.get(requestId);
+  if (!record) {
+    return;
+  }
+  records.delete(requestId);
+  options.push({
+    ...record,
+    responseBody: options.captureResponseBody ? await safeGetResponseBody(options.client, requestId) : void 0,
+    endedAt,
+    durationMs: endedAt - record.startedAt
+  });
+}
+async function safeGetResponseBody(client, requestId) {
+  try {
+    return (await client.Network.getResponseBody({ requestId })).body;
+  } catch {
+    return void 0;
+  }
+}
+function normalizeHeaders(headers) {
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [key, String(value)])
+  );
+}
+
+// src/plugin/cdpLifecycle.ts
+function createCdpLifecycleController(ctx) {
+  const clients = /* @__PURE__ */ new Map();
+  return {
+    async connectPage(target) {
+      if (clients.has(target.pageId) || !shouldStartCdp(ctx)) {
+        return;
+      }
+      const client = await safeConnectCdp(ctx, target);
+      if (!client) {
+        return;
+      }
+      clients.set(target.pageId, client);
+      try {
+        await startCdpObservers(ctx, target, client);
+      } catch (error) {
+        clients.delete(target.pageId);
+        await client.close();
+        warnWhenCdpForced(ctx, error);
+      }
+    },
+    async closeAll() {
+      await Promise.all([...clients.values()].map((client) => client.close()));
+      clients.clear();
+    }
+  };
+}
+function shouldStartCdp(ctx) {
+  const consoleUsesCdp = shouldUseCdp({
+    options: ctx.options,
+    capabilityMode: ctx.options.runtime.mode,
+    hasMatchedCdpTarget: true
+  });
+  const networkUsesCdp = shouldUseCdp({
+    options: ctx.options,
+    capabilityMode: ctx.options.network.mode,
+    hasMatchedCdpTarget: true
+  });
+  return consoleUsesCdp || networkUsesCdp;
+}
+async function safeConnectCdp(ctx, target) {
+  try {
+    return await connectCdp(ctx, target);
+  } catch (error) {
+    warnWhenCdpForced(ctx, error);
+    return void 0;
+  }
+}
+function warnWhenCdpForced(ctx, error) {
+  if (ctx.options.runtime.mode !== "cdp" && ctx.options.network.mode !== "cdp") {
+    return;
+  }
+  console.warn(
+    `[vite-plugin-vue-mcp-next] CDP connect failed: ${error instanceof Error ? error.message : String(error)}`
+  );
+}
+async function connectCdp(ctx, target) {
+  const cdp = createCdpClient(ctx.options.cdp);
+  if (ctx.options.cdp.wsEndpoint) {
+    return cdp.connect(ctx.options.cdp.wsEndpoint);
+  }
+  if (!ctx.options.cdp.browserUrl) {
+    return void 0;
+  }
+  const matched = matchCdpTarget(await cdp.listTargets(), {
+    url: target.url,
+    targetUrlPattern: ctx.options.cdp.targetUrlPattern
+  });
+  if (!matched?.webSocketDebuggerUrl) {
+    return void 0;
+  }
+  return cdp.connect(matched.webSocketDebuggerUrl);
+}
+async function startCdpObservers(ctx, target, client) {
+  if (ctx.options.runtime.mode !== "hook") {
+    await startCdpConsole({
+      client,
+      pageId: target.pageId,
+      push: (record) => {
+        ctx.consoleRecords.push(record);
+      }
+    });
+  }
+  if (ctx.options.network.mode === "auto" || ctx.options.network.mode === "cdp") {
+    await startCdpNetwork({
+      client,
+      pageId: target.pageId,
+      maskHeaders: ctx.options.network.maskHeaders,
+      captureResponseBody: ctx.options.network.captureResponseBody,
+      push: (record) => {
+        ctx.networkRecords.push(record);
+      }
+    });
+  }
+}
+
+// src/plugin/injectRuntime.ts
+function createRuntimeInjectionController(options, getConfig) {
+  return {
+    resolveId(importee) {
+      if (importee === VIRTUAL_RUNTIME_ID) {
+        return RESOLVED_VIRTUAL_RUNTIME_ID;
+      }
+      return void 0;
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_RUNTIME_ID) {
+        return void 0;
+      }
+      return "import { startRuntimeClient } from 'vite-plugin-vue-mcp-next/runtime/client';\nvoid startRuntimeClient();";
+    },
+    transformIndexHtml(html) {
+      if (options.appendTo) {
+        return void 0;
+      }
+      const base = getConfig()?.base || "/";
+      return {
+        html,
+        tags: [
+          {
+            tag: "script",
+            injectTo: "head-prepend",
+            attrs: {
+              type: "module",
+              src: `${base}@id/${VIRTUAL_RUNTIME_ID}`
+            }
+          }
+        ]
+      };
+    },
+    transform(code, id, ssr) {
+      if (ssr || !options.appendTo) {
+        return void 0;
+      }
+      const [filename] = id.split("?", 2);
+      const matched = typeof options.appendTo === "string" ? filename.endsWith(options.appendTo) : options.appendTo.test(filename);
+      if (!matched) {
+        return void 0;
+      }
+      return `import '${VIRTUAL_RUNTIME_ID}';
+${code}`;
+    }
+  };
+}
+
+// src/plugin/mcpClientConfig/index.ts
+var import_node_path4 = __toESM(require("path"), 1);
+
+// src/plugin/mcpClientConfig/codexConfig.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+async function updateCodexMcpClientConfig(options) {
+  try {
+    const current = await readOptionalTextFile(options.configPath);
+    const next = replaceOrAppendOwnedBlock(current, options);
+    await import_promises.default.mkdir(import_node_path2.default.dirname(options.configPath), { recursive: true });
+    await import_promises.default.writeFile(options.configPath, next);
+  } catch (error) {
+    console.warn(
+      `[vite-plugin-vue-mcp-next] Failed to update Codex MCP config at ${options.configPath}: ${formatError(error)}`
+    );
+  }
+}
+function replaceOrAppendOwnedBlock(current, options) {
+  const block = createCodexServerBlock(options);
+  const matcher = createOwnedBlockMatcher(options.serverName);
+  if (matcher.test(current)) {
+    return current.replace(matcher, block);
+  }
+  const separator = current.trim() ? "\n\n" : "";
+  return `${trimEndNewline(current)}${separator}${block}`;
+}
+function createCodexServerBlock(options) {
+  return `${createTableHeader(options.serverName)}
+url = ${quoteTomlString(options.mcpUrl)}
+`;
+}
+function createOwnedBlockMatcher(serverName) {
+  const plainHeader = escapeRegExp(`[mcp_servers.${serverName}]`);
+  const quotedHeader = escapeRegExp(
+    `[mcp_servers.${quoteTomlKey(serverName)}]`
+  );
+  return new RegExp(
+    `(?:^|\\n)(?:${plainHeader}|${quotedHeader})\\n[\\s\\S]*?(?=\\n\\[|$)`
+  );
+}
+function createTableHeader(serverName) {
+  const key = /^[A-Za-z0-9_-]+$/.test(serverName) ? serverName : quoteTomlKey(serverName);
+  return `[mcp_servers.${key}]`;
+}
+function quoteTomlKey(value) {
+  return quoteTomlString(value);
+}
+function quoteTomlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+async function readOptionalTextFile(filePath) {
+  try {
+    return await import_promises.default.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+function trimEndNewline(value) {
+  return value.replace(/\n+$/u, "");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/plugin/mcpClientConfig/jsonConfig.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+async function updateJsonMcpClientConfig(options) {
+  try {
+    const config = await readJsonConfig(options.configPath);
+    if (!isPlainRecord(config)) {
+      warnConfigFailure(options, "config root must be a JSON object");
+      return;
+    }
+    const mcpServers = isPlainRecord(config.mcpServers) ? config.mcpServers : {};
+    mcpServers[options.serverName] = { url: options.mcpUrl };
+    config.mcpServers = mcpServers;
+    await import_promises2.default.mkdir(import_node_path3.default.dirname(options.configPath), { recursive: true });
+    await import_promises2.default.writeFile(
+      options.configPath,
+      `${JSON.stringify(config, null, 2)}
+`
+    );
+  } catch (error) {
+    warnConfigFailure(options, formatError2(error));
+  }
+}
+async function readJsonConfig(configPath) {
+  const raw = await readOptionalTextFile2(configPath);
+  if (!raw.trim()) {
+    return {};
+  }
+  return JSON.parse(raw);
+}
+async function readOptionalTextFile2(filePath) {
+  try {
+    return await import_promises2.default.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return "{}";
+    }
+    throw error;
+  }
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function warnConfigFailure(options, reason) {
+  console.warn(
+    `[vite-plugin-vue-mcp-next] Failed to update ${options.clientName} MCP config at ${options.configPath}: ${reason}`
+  );
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/plugin/mcpClientConfig/index.ts
+async function updateMcpClientConfigs(root, mcpUrl, options) {
+  const serverName = options.serverName;
+  const jobs = [];
+  if (options.cursor) {
+    jobs.push(
+      updateJsonMcpClientConfig({
+        clientName: "Cursor",
+        configPath: import_node_path4.default.join(root, ".cursor", "mcp.json"),
+        mcpUrl,
+        serverName
+      })
+    );
+  }
+  if (options.codex) {
+    jobs.push(
+      updateCodexMcpClientConfig({
+        configPath: import_node_path4.default.join(root, ".codex", "config.toml"),
+        mcpUrl,
+        serverName
+      })
+    );
+  }
+  if (options.claudeCode) {
+    jobs.push(
+      updateJsonMcpClientConfig({
+        clientName: "Claude Code",
+        configPath: import_node_path4.default.join(root, ".mcp.json"),
+        mcpUrl,
+        serverName
+      })
+    );
+  }
+  if (options.trae) {
+    jobs.push(
+      updateJsonMcpClientConfig({
+        clientName: "Trae",
+        configPath: import_node_path4.default.join(root, ".trae", "mcp.json"),
+        mcpUrl,
+        serverName
+      })
+    );
+  }
+  await Promise.all(jobs);
+}
+
+// src/plugin/createPlugin.ts
+var import_vite_dev_rpc = require("vite-dev-rpc");
+function vueMcpNext(userOptions = {}) {
+  const options = mergeOptions(userOptions);
+  const ctx = createVueMcpNextContext(options);
+  let config;
+  const runtimeInjection = createRuntimeInjectionController(
+    options,
+    () => config
+  );
+  const cdpLifecycle = createCdpLifecycleController(ctx);
+  ctx.cdpLifecycle = cdpLifecycle;
+  return {
+    name: "vite-plugin-vue-mcp-next",
+    enforce: "pre",
+    apply: "serve",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async configureServer(server) {
+      ctx.rpcServer = (0, import_vite_dev_rpc.createRPCServer)(
+        "vite-plugin-vue-mcp-next",
+        server.ws,
+        createServerVueRuntimeRpc(ctx),
+        {
+          timeout: -1
+        }
+      );
+      const mcpServer = createMcpServer(ctx, server);
+      setupMcpTransport(options.mcpPath, mcpServer, server);
+      server.ws.on(
+        "vite-plugin-vue-mcp-next:page-connected",
+        (payload) => {
+          if (isRuntimePageTarget(payload)) {
+            ctx.pages.upsert(payload);
+            void cdpLifecycle.connectPage(payload);
+          }
+        }
+      );
+      server.ws.on(
+        "vite-plugin-vue-mcp-next:console-record",
+        (payload) => {
+          if (isConsoleRecord(payload)) {
+            ctx.consoleRecords.push(payload);
+          }
+        }
+      );
+      server.ws.on(
+        "vite-plugin-vue-mcp-next:network-record",
+        (payload) => {
+          if (isNetworkRecord(payload)) {
+            ctx.networkRecords.push(payload);
+          }
+        }
+      );
+      const port = String(server.config.server.port || 5173);
+      const mcpUrl = `http://${options.host}:${port}${options.mcpPath}/sse`;
+      const root = (0, import_vite2.searchForWorkspaceRoot)(server.config.root);
+      await updateMcpClientConfigs(root, mcpUrl, options.mcpClients);
+      if (options.printUrl) {
+        setTimeout(() => {
+          console.log(`  \u279C  MCP:     Server is running at ${mcpUrl}`);
+        }, 300);
+      }
+      server.httpServer?.once("close", () => {
+        void cdpLifecycle.closeAll();
+      });
+    },
+    resolveId(importee) {
+      return runtimeInjection.resolveId(importee);
+    },
+    load(id) {
+      return runtimeInjection.load(id);
+    },
+    transform(code, id, transformOptions) {
+      return runtimeInjection.transform(code, id, transformOptions?.ssr);
+    },
+    transformIndexHtml(html) {
+      return runtimeInjection.transformIndexHtml(html);
+    }
+  };
+}
+function isRuntimePageTarget(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const target = payload;
+  return target.source === "runtime" && typeof target.pageId === "string" && typeof target.url === "string" && typeof target.pathname === "string" && typeof target.connected === "boolean";
+}
+function isConsoleRecord(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const record = payload;
+  return typeof record.id === "string" && typeof record.pageId === "string" && record.source === "hook" && isConsoleLevel(record.level) && typeof record.message === "string" && typeof record.timestamp === "number";
+}
+function isConsoleLevel(level) {
+  return level === "log" || level === "info" || level === "warn" || level === "error" || level === "debug";
+}
+function isNetworkRecord(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const record = payload;
+  return typeof record.id === "string" && typeof record.pageId === "string" && record.source === "hook" && typeof record.url === "string" && typeof record.method === "string" && typeof record.startedAt === "number";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  vueMcpNext
+});
+//# sourceMappingURL=index.cjs.map