@weapp-vite/mcp 1.2.1 → 1.3.1

package/dist/index.mjs

@@ -1,15 +1,17 @@
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { Buffer } from 'node:buffer';
+import { randomUUID } from 'node:crypto';
 import http from 'node:http';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import fs$1 from 'node:fs/promises';
-import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import { createRequire } from 'node:module';
 import path from 'node:path';
+import { z } from 'zod';
+import { closeSharedMiniProgram, acquireSharedMiniProgram, releaseSharedMiniProgram } from '@weapp-vite/devtools-runtime';
+import { ResourceTemplate, McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
 
 const MCP_SERVER_NAME = "@weapp-vite/mcp";
@@ -84,6 +86,118 @@ function resolveSubPath(root, relativePath) {
   return assertInsideRoot(root, path.resolve(root, relativePath));
 }
 
+function registerServerPrompts(server, options) {
+  const { packageIds, packageIdSchema } = options;
+  server.registerPrompt("plan-weapp-vite-change", {
+    title: "Plan weapp-vite Change",
+    description: "\u6839\u636E\u53D8\u66F4\u76EE\u6807\u751F\u6210 weapp-vite / wevu \u4FEE\u6539\u8BA1\u5212\u63D0\u793A\u8BCD",
+    argsSchema: {
+      objective: z.string().min(1),
+      focusPackage: packageIdSchema.optional()
+    }
+  }, async ({ objective, focusPackage }) => {
+    const targets = focusPackage ? [focusPackage] : packageIds;
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "\u4F60\u662F weapp-vite monorepo \u7EF4\u62A4\u8005\uFF0C\u8BF7\u7ED9\u51FA\u53EF\u6267\u884C\u7684\u6539\u9020\u8BA1\u5212\u3002",
+              `\u76EE\u6807\uFF1A${objective}`,
+              `\u805A\u7126\u5305\uFF1A${targets.join(", ")}`,
+              "\u8BF7\u5305\u542B\uFF1A\u5F71\u54CD\u9762\u3001\u98CE\u9669\u70B9\u3001\u6D4B\u8BD5\u7B56\u7565\u3001\u56DE\u6EDA\u7B56\u7565\u3002"
+            ].join("\n")
+          }
+        }
+      ]
+    };
+  });
+  server.registerPrompt("debug-wevu-runtime", {
+    title: "Debug wevu Runtime",
+    description: "\u7528\u4E8E\u5B9A\u4F4D wevu runtime \u751F\u547D\u5468\u671F/\u54CD\u5E94\u5F0F\u95EE\u9898\u7684\u6807\u51C6\u63D0\u793A\u8BCD",
+    argsSchema: {
+      symptom: z.string().min(1)
+    }
+  }, async ({ symptom }) => {
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "\u8BF7\u57FA\u4E8E wevu runtime \u4EE3\u7801\u8DEF\u5F84\u8FDB\u884C\u5206\u5C42\u6392\u67E5\uFF1A",
+              "1. \u590D\u73B0\u573A\u666F\u4E0E\u6700\u5C0F\u6837\u4F8B",
+              "2. \u751F\u547D\u5468\u671F\u94A9\u5B50\u89E6\u53D1\u94FE",
+              "3. \u54CD\u5E94\u5F0F\u4E0E setData \u5DEE\u91CF\u540C\u6B65\u94FE",
+              "4. \u5355\u6D4B\u4E0E e2e \u56DE\u5F52\u8865\u4E01",
+              `\u73B0\u8C61\uFF1A${symptom}`
+            ].join("\n")
+          }
+        }
+      ]
+    };
+  });
+  server.registerPrompt("inspect-mini-program-page", {
+    title: "Inspect Mini Program Page",
+    description: "\u8FDE\u63A5\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177\u5E76\u68C0\u67E5\u5F53\u524D\u5C0F\u7A0B\u5E8F\u9875\u9762\u7684\u6807\u51C6\u6D41\u7A0B",
+    argsSchema: {
+      projectPath: z.string().min(1),
+      pagePath: z.string().optional(),
+      focus: z.string().optional()
+    }
+  }, async ({ projectPath, pagePath, focus }) => {
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "\u8BF7\u6309\u987A\u5E8F\u4F7F\u7528 weapp-vite MCP runtime tools \u68C0\u67E5\u5C0F\u7A0B\u5E8F\u9875\u9762\uFF1A",
+              `1. \u8C03\u7528 weapp_devtools_connect\uFF0CprojectPath=${projectPath}`,
+              pagePath ? `2. \u8C03\u7528 weapp_devtools_route \u8DF3\u8F6C\u5230 ${pagePath}` : "2. \u8C03\u7528 weapp_devtools_active_page \u786E\u8BA4\u5F53\u524D\u9875\u9762",
+              "3. \u8C03\u7528 weapp_devtools_capture \u83B7\u53D6\u622A\u56FE",
+              "4. \u5982\u9700\u68C0\u67E5\u7ED3\u6784\uFF0C\u4F18\u5148\u8C03\u7528 weapp_runtime_find_node/weapp_runtime_find_nodes\uFF0C\u5FC5\u8981\u65F6\u8BBE\u7F6E withWxml=true",
+              "5. \u8C03\u7528 weapp_devtools_console \u68C0\u67E5 console/exception \u65E5\u5FD7",
+              focus ? `\u5173\u6CE8\u70B9\uFF1A${focus}` : "\u5173\u6CE8\u70B9\uFF1A\u9875\u9762\u662F\u5426\u6B63\u786E\u6E32\u67D3\u3001\u662F\u5426\u5B58\u5728\u8FD0\u884C\u65F6\u9519\u8BEF\u3002"
+            ].join("\n")
+          }
+        }
+      ]
+    };
+  });
+  server.registerPrompt("recover-mini-program-connection", {
+    title: "Recover Mini Program Connection",
+    description: "\u6062\u590D\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177 automator \u8FDE\u63A5\u7684\u6807\u51C6\u6D41\u7A0B",
+    argsSchema: {
+      projectPath: z.string().min(1),
+      lastError: z.string().optional()
+    }
+  }, async ({ projectPath, lastError }) => {
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "\u8BF7\u6309\u987A\u5E8F\u6062\u590D weapp-vite MCP runtime \u8FDE\u63A5\uFF1A",
+              `1. \u8C03\u7528 weapp_devtools_connect\uFF0CprojectPath=${projectPath}\uFF0Creconnect=true`,
+              "2. \u5982\u679C\u4ECD\u5931\u8D25\uFF0C\u68C0\u67E5\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177\u662F\u5426\u5DF2\u5F00\u542F\u670D\u52A1\u7AEF\u53E3\u4E0E\u81EA\u52A8\u5316\u6D4B\u8BD5\u80FD\u529B",
+              "3. \u5982\u679C\u662F\u534F\u8BAE\u8D85\u65F6\uFF0C\u5173\u95ED\u591A\u4F59 DevTools \u7A97\u53E3\u540E\u53EA\u91CD\u8BD5\u4E00\u6B21",
+              "4. \u6062\u590D\u540E\u8C03\u7528 weapp_devtools_active_page \u548C weapp_devtools_console \u786E\u8BA4\u72B6\u6001",
+              lastError ? `\u4E0A\u4E00\u6B21\u9519\u8BEF\uFF1A${lastError}` : "\u4E0A\u4E00\u6B21\u9519\u8BEF\uFF1A\u672A\u63D0\u4F9B\u3002"
+            ].join("\n")
+          }
+        }
+      ]
+    };
+  });
+}
+
 async function pathExists(filePath) {
   try {
     await fs$1.access(filePath);
@@ -195,87 +309,6 @@ async function resolveExposedPackages(workspaceRoot) {
   }).sort((a, b) => a.id.localeCompare(b.id));
 }
 
-async function loadPackageSummary(workspaceRoot, id) {
-  return resolveExposedPackage(workspaceRoot, id);
-}
-async function loadExposedCatalog(workspaceRoot) {
-  return resolveExposedPackages(workspaceRoot);
-}
-
-const ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
-  "pnpm",
-  "node",
-  "git",
-  "rg"
-]);
-function resolveExecutable(command) {
-  if (process.platform === "win32") {
-    if (command === "pnpm") {
-      return "pnpm.cmd";
-    }
-    if (command === "git") {
-      return "git.exe";
-    }
-    if (command === "rg") {
-      return "rg.exe";
-    }
-  }
-  return command;
-}
-function truncateOutput(text, maxChars) {
-  if (text.length <= maxChars) {
-    return text;
-  }
-  return `${text.slice(0, maxChars)}
-
-[truncated: ${text.length - maxChars} chars omitted]`;
-}
-async function runCommand(workspaceRoot, command, args, options) {
-  if (!ALLOWED_COMMANDS.has(command)) {
-    throw new Error(`\u4E0D\u5141\u8BB8\u7684\u547D\u4EE4\uFF1A${command}`);
-  }
-  const cwd = resolveSubPath(workspaceRoot, options?.cwdRelative ?? ".");
-  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const maxOutputChars = options?.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
-  const executable = resolveExecutable(command);
-  const child = spawn(executable, args, {
-    cwd,
-    env: process.env,
-    stdio: ["ignore", "pipe", "pipe"],
-    shell: false
-  });
-  let stdout = "";
-  let stderr = "";
-  let timedOut = false;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    child.kill("SIGTERM");
-  }, timeoutMs);
-  child.stdout.on("data", (chunk) => {
-    stdout += chunk.toString();
-  });
-  child.stderr.on("data", (chunk) => {
-    stderr += chunk.toString();
-  });
-  const exitCode = await new Promise((resolve, reject) => {
-    child.on("error", reject);
-    child.on("close", (code) => {
-      resolve(code ?? -1);
-    });
-  }).finally(() => {
-    clearTimeout(timer);
-  });
-  return {
-    command,
-    args,
-    cwd: path.resolve(cwd),
-    exitCode,
-    stdout: truncateOutput(stdout.trim(), maxOutputChars),
-    stderr: truncateOutput(stderr.trim(), maxOutputChars),
-    timedOut
-  };
-}
-
 async function walkFilesRecursive(root, current, output, maxResults) {
   if (output.length >= maxResults) {
     return;
@@ -398,8 +431,80 @@ function toToolError(error) {
   };
 }
 
-const packageIds = Object.keys(EXPOSED_PACKAGES);
-const packageIdSchema = z.enum(packageIds);
+const ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
+  "pnpm",
+  "node",
+  "git",
+  "rg"
+]);
+function resolveExecutable(command) {
+  if (process.platform === "win32") {
+    if (command === "pnpm") {
+      return "pnpm.cmd";
+    }
+    if (command === "git") {
+      return "git.exe";
+    }
+    if (command === "rg") {
+      return "rg.exe";
+    }
+  }
+  return command;
+}
+function truncateOutput(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}
+
+[truncated: ${text.length - maxChars} chars omitted]`;
+}
+async function runCommand(workspaceRoot, command, args, options) {
+  if (!ALLOWED_COMMANDS.has(command)) {
+    throw new Error(`\u4E0D\u5141\u8BB8\u7684\u547D\u4EE4\uFF1A${command}`);
+  }
+  const cwd = resolveSubPath(workspaceRoot, options?.cwdRelative ?? ".");
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxOutputChars = options?.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+  const executable = resolveExecutable(command);
+  const child = spawn(executable, args, {
+    cwd,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false
+  });
+  let stdout = "";
+  let stderr = "";
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGTERM");
+  }, timeoutMs);
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve(code ?? -1);
+    });
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+  return {
+    command,
+    args,
+    cwd: path.resolve(cwd),
+    exitCode,
+    stdout: truncateOutput(stdout.trim(), maxOutputChars),
+    stderr: truncateOutput(stderr.trim(), maxOutputChars),
+    timedOut
+  };
+}
+
 async function resolvePackageRoot(workspaceRoot, packageId) {
   const resolved = await resolveExposedPackage(workspaceRoot, packageId);
   if (!resolved.sourceRoot) {
@@ -432,21 +537,1120 @@ async function runWeappViteCliTool(workspaceRoot, input) {
     timeoutMs: input.timeoutMs ?? DEFAULT_TIMEOUT_MS
   });
 }
-async function createWeappViteMcpServer(options) {
-  const workspaceRoot = resolveWorkspaceRoot(options?.workspaceRoot);
-  const server = new McpServer({
-    name: MCP_SERVER_NAME,
-    version: MCP_SERVER_VERSION
-  });
+
+async function registerServerResources(server, options) {
+  const { workspaceRoot, packageIds } = options;
+  server.registerResource("workspace-catalog", "weapp-vite://workspace/catalog", {
+    title: "Workspace Catalog",
+    description: "weapp-vite / wevu \u5305\u76EE\u5F55\u3001\u7248\u672C\u548C\u811A\u672C\u5217\u8868",
+    mimeType: "application/json"
+  }, async () => {
+    const catalog2 = await resolveExposedPackages(workspaceRoot);
+    const text = JSON.stringify({ workspaceRoot, packages: catalog2 }, null, 2);
+    return {
+      contents: [{
+        uri: "weapp-vite://workspace/catalog",
+        mimeType: "application/json",
+        text
+      }]
+    };
+  });
+  const catalog = await resolveExposedPackages(workspaceRoot);
+  for (const summary of catalog) {
+    if (summary.docs.readme) {
+      const uri = toDocsUri(summary.id, "README.md");
+      server.registerResource(`docs-${summary.id}-readme`, uri, {
+        title: `${summary.id} README`,
+        mimeType: "text/markdown"
+      }, async () => {
+        const text = await readTextFile(summary.docs.readme);
+        return {
+          contents: [{ uri, mimeType: "text/markdown", text }]
+        };
+      });
+    }
+    if (summary.docs.changelog) {
+      const uri = toDocsUri(summary.id, "CHANGELOG.md");
+      server.registerResource(`docs-${summary.id}-changelog`, uri, {
+        title: `${summary.id} CHANGELOG`,
+        mimeType: "text/markdown"
+      }, async () => {
+        const text = await readTextFile(summary.docs.changelog);
+        return {
+          contents: [{ uri, mimeType: "text/markdown", text }]
+        };
+      });
+    }
+  }
+  const sourceTemplate = new ResourceTemplate("weapp-vite://source/{package}?path={path}", {
+    list: void 0,
+    complete: {
+      package: () => packageIds
+    }
+  });
+  server.registerResource("source-template", sourceTemplate, {
+    title: "Source Template",
+    description: "\u8BFB\u53D6 weapp-vite / wevu \u4EFB\u610F\u6E90\u7801\u6587\u4EF6\uFF08\u901A\u8FC7 package + path \u53C2\u6570\uFF09",
+    mimeType: "text/plain"
+  }, async (uri, variables) => {
+    try {
+      const packageId = String(variables.package ?? "");
+      if (!packageIds.includes(packageId)) {
+        throw new Error(`\u672A\u77E5 package\uFF1A${packageId}`);
+      }
+      const relativePath = decodeURIComponent(String(variables.path ?? ""));
+      const packageRoot = await resolvePackageRoot(workspaceRoot, packageId);
+      const { content } = await readFileContent(packageRoot, relativePath, {
+        maxChars: DEFAULT_MAX_FILE_CHARS
+      });
+      return {
+        contents: [{
+          uri: uri.toString(),
+          mimeType: "text/plain",
+          text: content
+        }]
+      };
+    } catch (error) {
+      return {
+        contents: [{
+          uri: uri.toString(),
+          mimeType: "text/plain",
+          text: `[resource-error] ${normalizeErrorMessage(error)}`
+        }]
+      };
+    }
+  });
+}
+
+z.object({
+  projectPath: z.string().trim().min(1).describe("\u5C0F\u7A0B\u5E8F\u9879\u76EE\u8DEF\u5F84\uFF1B\u652F\u6301 workspaceRoot \u76F8\u5BF9\u8DEF\u5F84"),
+  timeout: z.number().int().positive().optional(),
+  preferOpenedSession: z.boolean().optional()
+});
+const connectionInputSchema = {
+  projectPath: z.string().trim().min(1).describe("\u5C0F\u7A0B\u5E8F\u9879\u76EE\u8DEF\u5F84\uFF1B\u652F\u6301 workspaceRoot \u76F8\u5BF9\u8DEF\u5F84"),
+  timeout: z.number().int().positive().optional(),
+  preferOpenedSession: z.boolean().optional()
+};
+class RuntimeSessionManager {
+  constructor(workspaceRoot, runtimeHooks = createUnavailableRuntimeHooks()) {
+    this.workspaceRoot = workspaceRoot;
+    this.runtimeHooks = runtimeHooks;
+  }
+  logs = [];
+  attachedSessions = /* @__PURE__ */ new Map();
+  maxLogs = 1e3;
+  async close(input) {
+    const projectPath = this.resolveProjectPath(input.projectPath);
+    this.detach(projectPath);
+    await closeSharedMiniProgram(projectPath);
+  }
+  clearLogs() {
+    this.logs.length = 0;
+  }
+  getLogs() {
+    return [...this.logs];
+  }
+  resolveProjectPath(projectPath) {
+    return path.isAbsolute(projectPath) ? path.normalize(projectPath) : path.resolve(this.workspaceRoot, projectPath);
+  }
+  resolveWorkspacePath(filePath) {
+    return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(this.workspaceRoot, filePath);
+  }
+  async withMiniProgram(input, runner) {
+    const projectPath = this.resolveProjectPath(input.projectPath);
+    const miniProgram = await acquireSharedMiniProgram(this.runtimeHooks, {
+      projectPath,
+      timeout: input.timeout,
+      preferOpenedSession: input.preferOpenedSession,
+      sharedSession: true
+    });
+    this.attach(projectPath, miniProgram);
+    try {
+      return await runner(miniProgram);
+    } catch (error) {
+      this.detach(projectPath);
+      await closeSharedMiniProgram(projectPath);
+      throw error;
+    } finally {
+      releaseSharedMiniProgram(projectPath);
+    }
+  }
+  async withPage(input, runner) {
+    return await this.withMiniProgram(input, async (miniProgram) => {
+      const page = await miniProgram.currentPage();
+      if (!page) {
+        throw new Error("\u5F53\u524D\u6CA1\u6709\u6D3B\u52A8\u9875\u9762\uFF0C\u8BF7\u5148\u8C03\u7528 weapp_devtools_connect \u786E\u8BA4 DevTools \u4F1A\u8BDD\u3002");
+      }
+      return await runner(page, miniProgram);
+    });
+  }
+  attach(projectPath, miniProgram) {
+    const existing = this.attachedSessions.get(projectPath);
+    if (existing?.miniProgram === miniProgram) {
+      return;
+    }
+    this.detach(projectPath);
+    const onConsole = (payload) => {
+      this.pushLog(normalizeConsoleEvent(payload));
+    };
+    const onException = (payload) => {
+      this.pushLog(normalizeExceptionEvent(payload));
+    };
+    miniProgram.on("console", onConsole);
+    miniProgram.on("exception", onException);
+    this.attachedSessions.set(projectPath, {
+      miniProgram,
+      onConsole,
+      onException
+    });
+  }
+  detach(projectPath) {
+    const attached = this.attachedSessions.get(projectPath);
+    if (!attached) {
+      return;
+    }
+    if (typeof attached.miniProgram.off === "function") {
+      attached.miniProgram.off("console", attached.onConsole);
+      attached.miniProgram.off("exception", attached.onException);
+    }
+    this.attachedSessions.delete(projectPath);
+  }
+  pushLog(entry) {
+    this.logs.push(entry);
+    while (this.logs.length > this.maxLogs) {
+      this.logs.shift();
+    }
+  }
+}
+function buildUrl(pagePath, query) {
+  const normalizedPath = pagePath.startsWith("/") ? pagePath : `/${pagePath}`;
+  if (!query || Object.keys(query).length === 0) {
+    return normalizedPath;
+  }
+  const search = new URLSearchParams(query).toString();
+  if (!search) {
+    return normalizedPath;
+  }
+  return `${normalizedPath}${normalizedPath.includes("?") ? "&" : "?"}${search}`;
+}
+function parseSelectorWithIndex(selector) {
+  const match = selector.match(/^(.+?)\[index=(\d+)\]$/);
+  if (!match?.[1] || !match[2]) {
+    return {
+      selector,
+      index: void 0
+    };
+  }
+  return {
+    selector: match[1],
+    index: Number.parseInt(match[2], 10)
+  };
+}
+async function resolveElement(page, selectorInput, innerSelector) {
+  const { selector, index } = parseSelectorWithIndex(selectorInput);
+  let element;
+  if (index === void 0) {
+    element = await page.$(selector);
+  } else {
+    const elements = await queryElements(page, selector);
+    if (index < 0 || index >= elements.length) {
+      throw new Error(`\u9009\u62E9\u5668 "${selector}" \u7684 index=${index} \u8D85\u51FA\u8303\u56F4\uFF0C\u5F53\u524D\u5339\u914D ${elements.length} \u4E2A\u5143\u7D20\u3002`);
+    }
+    element = elements[index];
+  }
+  if (!element) {
+    throw new Error(`\u672A\u627E\u5230\u5143\u7D20: ${selectorInput}`);
+  }
+  if (!innerSelector) {
+    return element;
+  }
+  const inner = await callOptionalMethod(element, "$", innerSelector);
+  if (!inner) {
+    throw new Error(`\u5728\u5143\u7D20 "${selectorInput}" \u5185\u672A\u627E\u5230\u5143\u7D20: ${innerSelector}`);
+  }
+  return inner;
+}
+async function queryElements(page, selectorInput) {
+  const { selector, index } = parseSelectorWithIndex(selectorInput);
+  const elements = await callOptionalMethod(page, "$$", selector);
+  if (!Array.isArray(elements)) {
+    return [];
+  }
+  if (index === void 0) {
+    return elements;
+  }
+  if (index < 0 || index >= elements.length) {
+    throw new Error(`\u9009\u62E9\u5668 "${selector}" \u7684 index=${index} \u8D85\u51FA\u8303\u56F4\uFF0C\u5F53\u524D\u5339\u914D ${elements.length} \u4E2A\u5143\u7D20\u3002`);
+  }
+  return [elements[index]];
+}
+async function summarizeElement(element, withWxml = false) {
+  const [text, value, size, offset, scrollWidth, scrollHeight, outerWxml] = await Promise.all([
+    callMaybe(element, "text"),
+    callMaybe(element, "value"),
+    callMaybe(element, "size"),
+    callMaybe(element, "offset"),
+    callMaybe(element, "scrollWidth"),
+    callMaybe(element, "scrollHeight"),
+    withWxml ? callMaybe(element, "outerWxml") : Promise.resolve(void 0)
+  ]);
+  return compactObject({
+    tagName: readProperty(element, "tagName"),
+    text,
+    value,
+    size,
+    offset,
+    scrollWidth,
+    scrollHeight,
+    outerWxml
+  });
+}
+function toSerializableValue(value) {
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString("base64");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toSerializableValue(item));
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, toSerializableValue(item)]));
+  }
+  return String(value);
+}
+async function callRequiredMethod(target, methodName, ...args) {
+  const method = readProperty(target, methodName);
+  if (typeof method !== "function") {
+    throw new TypeError(`\u5F53\u524D\u5BF9\u8C61\u4E0D\u652F\u6301 ${methodName} \u65B9\u6CD5\u3002`);
+  }
+  return await method.apply(target, args);
+}
+async function callOptionalMethod(target, methodName, ...args) {
+  const method = readProperty(target, methodName);
+  if (typeof method !== "function") {
+    return void 0;
+  }
+  return await method.apply(target, args);
+}
+async function callMaybe(target, methodName, ...args) {
+  try {
+    return await callOptionalMethod(target, methodName, ...args);
+  } catch {
+    return void 0;
+  }
+}
+function compactObject(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function readProperty(target, key) {
+  if (!target || typeof target !== "object") {
+    return void 0;
+  }
+  return target[key];
+}
+function normalizeConsoleEvent(payload) {
+  const record = toRecord$1(payload);
+  return {
+    level: normalizeLogLevel(record.type ?? record.level ?? record.method),
+    message: resolveLogMessage(record, payload),
+    timestamp: Date.now(),
+    raw: toSerializableValue(payload)
+  };
+}
+function normalizeExceptionEvent(payload) {
+  const record = toRecord$1(payload);
+  const error = toRecord$1(record.error);
+  const message = [
+    typeof error.message === "string" ? error.message : void 0,
+    typeof record.message === "string" ? record.message : void 0,
+    typeof error.stack === "string" ? error.stack : void 0,
+    typeof record.stack === "string" ? record.stack : void 0
+  ].filter(Boolean).join("\n");
+  return {
+    level: "error",
+    message: message || JSON.stringify(toSerializableValue(payload)),
+    timestamp: Date.now(),
+    raw: toSerializableValue(payload)
+  };
+}
+function normalizeLogLevel(value) {
+  const normalized = String(value ?? "log").toLowerCase();
+  if (normalized === "warning") {
+    return "warn";
+  }
+  if (["debug", "log", "info", "warn", "error"].includes(normalized)) {
+    return normalized;
+  }
+  return "log";
+}
+function resolveLogMessage(record, payload) {
+  if (typeof record.text === "string" && record.text) {
+    return record.text;
+  }
+  if (typeof record.message === "string" && record.message) {
+    return record.message;
+  }
+  if (Array.isArray(record.args)) {
+    return record.args.map(formatLogArgument).join(" ");
+  }
+  if (typeof payload === "string") {
+    return payload;
+  }
+  return JSON.stringify(toSerializableValue(payload));
+}
+function formatLogArgument(value) {
+  const record = toRecord$1(value);
+  if (record.value !== void 0) {
+    return typeof record.value === "string" ? record.value : JSON.stringify(toSerializableValue(record.value));
+  }
+  if (typeof record.description === "string") {
+    return record.description;
+  }
+  return typeof value === "string" ? value : JSON.stringify(toSerializableValue(value));
+}
+function toRecord$1(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function createUnavailableRuntimeHooks() {
+  return {
+    async connectMiniProgram() {
+      throw new Error("\u672A\u914D\u7F6E DevTools runtime hooks\u3002\u8BF7\u901A\u8FC7 createWeappViteMcpServer({ runtimeHooks }) \u6CE8\u5165 automator \u8FDE\u63A5\u80FD\u529B\u3002");
+    }
+  };
+}
+
+const navigateSchema = {
+  ...connectionInputSchema,
+  path: z.string().trim().min(1).optional(),
+  query: z.record(z.string(), z.string()).optional(),
+  transition: z.enum(["navigateTo", "redirectTo", "reLaunch", "switchTab", "navigateBack"]).optional(),
+  waitMs: z.number().int().nonnegative().optional()
+};
+const screenshotSchema = {
+  ...connectionInputSchema,
+  outputPath: z.string().trim().min(1).optional()
+};
+const hostApiSchema = {
+  ...connectionInputSchema,
+  method: z.string().trim().min(1),
+  args: z.array(z.unknown()).optional()
+};
+function registerDevtoolsRuntimeTools(server, manager) {
+  server.registerTool("weapp_devtools_connect", {
+    title: "Ensure Mini Program Connection",
+    description: "\u786E\u4FDD\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177 automator \u4F1A\u8BDD\u53EF\u7528\uFF0C\u5E76\u8FD4\u56DE\u5F53\u524D\u9875\u9762\u4E0E\u7CFB\u7EDF\u4FE1\u606F\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      reconnect: z.boolean().optional()
+    }
+  }, async ({ reconnect, ...connection }) => {
+    try {
+      if (reconnect) {
+        await manager.close(connection);
+      }
+      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+        const page = await miniProgram.currentPage().catch(() => null);
+        const systemInfo = await miniProgram.systemInfo().catch(() => null);
+        return {
+          connected: true,
+          projectPath: connection.projectPath,
+          resolvedProjectPath: manager.resolveProjectPath(connection.projectPath),
+          currentPage: page ? { path: page.path, query: toSerializableValue(page.query) } : null,
+          systemInfo: toSerializableValue(systemInfo)
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_devtools_route", {
+    title: "Navigate Mini Program",
+    description: "\u5728\u5C0F\u7A0B\u5E8F\u5185\u6267\u884C navigateTo\u3001redirectTo\u3001reLaunch\u3001switchTab \u6216 navigateBack\u3002",
+    inputSchema: navigateSchema
+  }, async ({ path: pagePath, query, transition = "navigateTo", waitMs, ...connection }) => {
+    try {
+      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+        if (transition === "navigateBack") {
+          const page2 = await miniProgram.navigateBack();
+          if (waitMs && page2) {
+            await page2.waitFor(waitMs);
+          }
+          return {
+            transition,
+            activePage: page2 ? { path: page2.path, query: toSerializableValue(page2.query) } : null
+          };
+        }
+        if (!pagePath) {
+          throw new Error("transition \u4E0D\u662F navigateBack \u65F6\u5FC5\u987B\u63D0\u4F9B path\u3002");
+        }
+        const url = buildUrl(pagePath, query);
+        const page = await callRequiredMethod(
+          miniProgram,
+          transition,
+          url
+        );
+        if (waitMs && page) {
+          await page.waitFor(waitMs);
+        }
+        return {
+          transition,
+          url,
+          activePage: page ? { path: page.path, query: toSerializableValue(page.query) } : null
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_devtools_active_page", {
+    title: "Current Mini Program Page",
+    description: "\u83B7\u53D6\u5F53\u524D\u9875\u9762\u8DEF\u5F84\u3001\u67E5\u8BE2\u53C2\u6570\u3001\u5C3A\u5BF8\u3001\u6EDA\u52A8\u4F4D\u7F6E\uFF1B\u53EF\u9009\u8FD4\u56DE\u9875\u9762 data\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      withData: z.boolean().optional()
+    }
+  }, async ({ withData, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const [size, scrollTop, data] = await Promise.all([
+          page.size().catch(() => null),
+          page.scrollTop().catch(() => null),
+          withData ? page.data().catch(() => null) : Promise.resolve(void 0)
+        ]);
+        return compactObject({
+          path: page.path,
+          query: toSerializableValue(page.query),
+          size: toSerializableValue(size),
+          scrollTop: toSerializableValue(scrollTop),
+          data: toSerializableValue(data)
+        });
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_devtools_page_stack", {
+    title: "Mini Program Page Stack",
+    description: "\u83B7\u53D6\u5F53\u524D\u5C0F\u7A0B\u5E8F\u9875\u9762\u6808\u3002",
+    inputSchema: connectionInputSchema
+  }, async (connection) => {
+    try {
+      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+        const stack = await miniProgram.pageStack();
+        return stack.map((page) => ({
+          path: page.path,
+          query: toSerializableValue(page.query)
+        }));
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_devtools_capture", {
+    title: "Mini Program Screenshot",
+    description: "\u622A\u53D6\u5F53\u524D\u5C0F\u7A0B\u5E8F\u89C6\u53E3\uFF0C\u8FD4\u56DE base64\uFF0C\u6216\u4FDD\u5B58\u5230 workspaceRoot \u76F8\u5BF9 outputPath\u3002",
+    inputSchema: screenshotSchema
+  }, async ({ outputPath, ...connection }) => {
+    try {
+      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+        const screenshot = await miniProgram.screenshot();
+        const buffer = typeof screenshot === "string" ? Buffer.from(screenshot, "base64") : Buffer.from(screenshot);
+        if (outputPath) {
+          const resolvedOutputPath = manager.resolveWorkspacePath(outputPath);
+          await fs$1.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+          await fs$1.writeFile(resolvedOutputPath, buffer);
+          return {
+            path: resolvedOutputPath,
+            bytes: buffer.length
+          };
+        }
+        return {
+          base64: buffer.toString("base64"),
+          bytes: buffer.length
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_devtools_host_api", {
+    title: "Call wx Method",
+    description: "\u8C03\u7528\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F wx API\uFF0C\u4F8B\u5982 wx.pageScrollTo\u3002",
+    inputSchema: hostApiSchema
+  }, async ({ method, args, ...connection }) => {
+    try {
+      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+        const callArgs = args ?? [];
+        const callResult = await miniProgram.callWxMethod(method, ...callArgs);
+        return {
+          method,
+          args: toSerializableValue(callArgs),
+          result: toSerializableValue(callResult)
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_devtools_console", {
+    title: "Get Mini Program Logs",
+    description: "\u8BFB\u53D6 MCP \u4F1A\u8BDD\u6355\u83B7\u5230\u7684\u5C0F\u7A0B\u5E8F console/exception \u65E5\u5FD7\uFF1B\u53EF\u9009\u8BFB\u53D6\u540E\u6E05\u7A7A\u3002",
+    inputSchema: {
+      clear: z.boolean().optional()
+    }
+  }, async ({ clear }) => {
+    try {
+      const logs = manager.getLogs();
+      if (clear) {
+        manager.clearLogs();
+      }
+      return toToolResult({
+        count: logs.length,
+        logs
+      });
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+}
+
+const elementSelectorSchema = {
+  ...connectionInputSchema,
+  selector: z.string().trim().min(1),
+  innerSelector: z.string().trim().min(1).optional()
+};
+function registerRuntimeNodeTools(server, manager) {
+  server.registerTool("weapp_runtime_tap_node", {
+    title: "Tap Element",
+    description: "\u70B9\u51FB\u9875\u9762\u5143\u7D20\uFF0C\u652F\u6301 selector[index=N]\u3001innerSelector \u548C\u70B9\u51FB\u540E\u7B49\u5F85\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      waitMs: z.number().int().nonnegative().optional()
+    }
+  }, async ({ selector, innerSelector, waitMs, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        await element.tap();
+        if (waitMs) {
+          await page.waitFor(waitMs);
+        }
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          waitedMs: waitMs ?? 0
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_input_node", {
+    title: "Input Element Text",
+    description: "\u5411 input \u6216 textarea \u5143\u7D20\u8F93\u5165\u6587\u672C\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      value: z.union([z.string(), z.number()])
+    }
+  }, async ({ selector, innerSelector, value, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        await callRequiredMethod(element, "input", String(value));
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          value: String(value)
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_invoke_component", {
+    title: "Call Element Method",
+    description: "\u8C03\u7528\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u5143\u7D20\u5B9E\u4F8B\u65B9\u6CD5\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      method: z.string().trim().min(1),
+      args: z.array(z.unknown()).optional()
+    }
+  }, async ({ selector, innerSelector, method, args, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        const callArgs = args ?? [];
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          method,
+          args: toSerializableValue(callArgs),
+          result: toSerializableValue(await callRequiredMethod(element, method, ...callArgs))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_component_state", {
+    title: "Get Element Data",
+    description: "\u8BFB\u53D6\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u5143\u7D20 data\uFF0C\u53EF\u901A\u8FC7 path \u8BFB\u53D6\u5D4C\u5957\u5B57\u6BB5\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      path: z.string().trim().min(1).optional()
+    }
+  }, async ({ selector, innerSelector, path, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          path: path ?? null,
+          data: toSerializableValue(await callRequiredMethod(element, "data", path))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_update_component_state", {
+    title: "Set Element Data",
+    description: "\u8C03\u7528\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u5143\u7D20 setData \u66F4\u65B0 data\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      data: z.record(z.string(), z.unknown())
+    }
+  }, async ({ selector, innerSelector, data, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        await callRequiredMethod(element, "setData", data);
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          keys: Object.keys(data)
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_find_child", {
+    title: "Get Inner Element",
+    description: "\u5728\u5143\u7D20\u8303\u56F4\u5185\u67E5\u8BE2\u5355\u4E2A\u5185\u90E8\u5143\u7D20\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      targetSelector: z.string().trim().min(1),
+      withWxml: z.boolean().optional()
+    }
+  }, async ({ selector, innerSelector, targetSelector, withWxml, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const parent = await resolveElement(page, selector, innerSelector);
+        const element = await callRequiredMethod(parent, "$", targetSelector);
+        if (!element) {
+          throw new Error(`\u5728\u5143\u7D20 "${selector}" \u5185\u672A\u627E\u5230\u5143\u7D20: ${targetSelector}`);
+        }
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          targetSelector,
+          ...await summarizeElement(element, withWxml)
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_find_children", {
+    title: "Get Inner Elements",
+    description: "\u5728\u5143\u7D20\u8303\u56F4\u5185\u67E5\u8BE2\u5185\u90E8\u5143\u7D20\u6570\u7EC4\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      targetSelector: z.string().trim().min(1),
+      withWxml: z.boolean().optional()
+    }
+  }, async ({ selector, innerSelector, targetSelector, withWxml, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const parent = await resolveElement(page, selector, innerSelector);
+        const elements = await callRequiredMethod(parent, "$$", targetSelector);
+        if (!Array.isArray(elements)) {
+          throw new TypeError(`\u5728\u5143\u7D20 "${selector}" \u5185\u67E5\u8BE2 "${targetSelector}" \u5931\u8D25\u3002`);
+        }
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          targetSelector,
+          count: elements.length,
+          elements: await Promise.all(elements.map(async (element, index) => ({
+            index,
+            ...await summarizeElement(element, withWxml)
+          })))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_node_markup", {
+    title: "Get Element WXML",
+    description: "\u8BFB\u53D6\u5143\u7D20 inner WXML \u6216 outer WXML\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      outer: z.boolean().optional()
+    }
+  }, async ({ selector, innerSelector, outer, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        const method = outer ? "outerWxml" : "wxml";
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          type: method,
+          wxml: toSerializableValue(await callRequiredMethod(element, method))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_node_styles", {
+    title: "Get Element Styles",
+    description: "\u8BFB\u53D6\u5143\u7D20\u6837\u5F0F\u503C\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      names: z.array(z.string().trim().min(1)).min(1)
+    }
+  }, async ({ selector, innerSelector, names, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          styles: Object.fromEntries(await Promise.all(names.map(async (name) => [
+            name,
+            toSerializableValue(await callMaybe(element, "style", name))
+          ])))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_node_attrs", {
+    title: "Get Element Attributes",
+    description: "\u8BFB\u53D6\u5143\u7D20 attribute \u503C\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      names: z.array(z.string().trim().min(1)).min(1)
+    }
+  }, async ({ selector, innerSelector, names, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          attributes: Object.fromEntries(await Promise.all(names.map(async (name) => [
+            name,
+            toSerializableValue(await callMaybe(element, "attribute", name))
+          ])))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_scroll_node", {
+    title: "Scroll Element",
+    description: "\u6EDA\u52A8 scroll-view \u5143\u7D20\u5230\u6307\u5B9A\u4F4D\u7F6E\u3002",
+    inputSchema: {
+      ...elementSelectorSchema,
+      x: z.number(),
+      y: z.number()
+    }
+  }, async ({ selector, innerSelector, x, y, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        await callRequiredMethod(element, "scrollTo", x, y);
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          x,
+          y
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_measure_node", {
+    title: "Get Element Bounding Rect",
+    description: "\u8BFB\u53D6\u5143\u7D20\u89C6\u53E3\u77E9\u5F62\uFF1B\u4F18\u5148\u4F7F\u7528\u5143\u7D20 offset/size\uFF0C\u7F3A\u5931\u65F6\u8FD4\u56DE\u53EF\u7528\u5B57\u6BB5\u3002",
+    inputSchema: elementSelectorSchema
+  }, async ({ selector, innerSelector, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        const offset = toRecord(await callMaybe(element, "offset"));
+        const size = toRecord(await callMaybe(element, "size"));
+        const left = toNumber(offset.left);
+        const top = toNumber(offset.top);
+        const width = toNumber(size.width ?? offset.width);
+        const height = toNumber(size.height ?? offset.height);
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          boundingClientRect: compactObject({
+            left,
+            top,
+            width,
+            height,
+            right: left !== void 0 && width !== void 0 ? left + width : void 0,
+            bottom: top !== void 0 && height !== void 0 ? top + height : void 0,
+            rawOffset: toSerializableValue(offset),
+            rawSize: toSerializableValue(size),
+            tagName: readProperty(element, "tagName")
+          })
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+}
+function toRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function toNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+const selectorSchema = {
+  ...connectionInputSchema,
+  selector: z.string().trim().min(1),
+  innerSelector: z.string().trim().min(1).optional(),
+  withWxml: z.boolean().optional()
+};
+function registerRuntimePageTools(server, manager) {
+  server.registerTool("weapp_runtime_find_node", {
+    title: "Get Page Element",
+    description: "\u901A\u8FC7\u9009\u62E9\u5668\u83B7\u53D6\u5F53\u524D\u9875\u9762\u5143\u7D20\u6458\u8981\uFF0C\u652F\u6301 selector[index=N]\u3001innerSelector \u4E0E withWxml\u3002",
+    inputSchema: selectorSchema
+  }, async ({ selector, innerSelector, withWxml, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector);
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          ...await summarizeElement(element, withWxml)
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_find_nodes", {
+    title: "Get Page Elements",
+    description: "\u901A\u8FC7\u9009\u62E9\u5668\u83B7\u53D6\u5F53\u524D\u9875\u9762\u5143\u7D20\u6570\u7EC4\u6458\u8981\uFF0C\u652F\u6301 selector[index=N] \u4E0E withWxml\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      selector: z.string().trim().min(1),
+      withWxml: z.boolean().optional()
+    }
+  }, async ({ selector, withWxml, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const elements = await queryElements(page, selector);
+        return {
+          selector,
+          count: elements.length,
+          elements: await Promise.all(elements.map(async (element, index) => ({
+            index,
+            ...await summarizeElement(element, withWxml)
+          })))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_wait_node", {
+    title: "Wait Page Element",
+    description: "\u8F6E\u8BE2\u7B49\u5F85\u5143\u7D20\u51FA\u73B0\uFF0C\u652F\u6301 selector[index=N]\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      selector: z.string().trim().min(1),
+      timeoutMs: z.number().int().positive().optional(),
+      intervalMs: z.number().int().positive().optional()
+    }
+  }, async ({ selector, timeoutMs = 5e3, intervalMs = 200, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt <= timeoutMs) {
+          const elements = await queryElements(page, selector).catch(() => []);
+          if (elements.length > 0) {
+            return {
+              selector,
+              found: true,
+              count: elements.length,
+              waitMs: Date.now() - startedAt
+            };
+          }
+          await page.waitFor(intervalMs);
+        }
+        throw new Error(`\u7B49\u5F85\u5143\u7D20 "${selector}" \u8D85\u65F6 (${timeoutMs}ms)\u3002`);
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_wait", {
+    title: "Wait Page Timeout",
+    description: "\u5728\u5F53\u524D\u9875\u9762\u7B49\u5F85\u6307\u5B9A\u6BEB\u79D2\u6570\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      milliseconds: z.number().int().nonnegative()
+    }
+  }, async ({ milliseconds, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        await page.waitFor(milliseconds);
+        return { waitedMs: milliseconds };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_page_state", {
+    title: "Get Page Data",
+    description: "\u8BFB\u53D6\u5F53\u524D\u9875\u9762 data\uFF0C\u53EF\u901A\u8FC7 path \u8BFB\u53D6\u5D4C\u5957\u5B57\u6BB5\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      path: z.string().trim().min(1).optional()
+    }
+  }, async ({ path, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => ({
+        path: path ?? null,
+        data: toSerializableValue(await page.data(path))
+      }));
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_update_page_state", {
+    title: "Set Page Data",
+    description: "\u8C03\u7528\u5F53\u524D\u9875\u9762 setData \u66F4\u65B0 data\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      data: z.record(z.string(), z.unknown()),
+      verify: z.boolean().optional()
+    }
+  }, async ({ data, verify, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        await callRequiredMethod(page, "setData", data);
+        return {
+          keys: Object.keys(data),
+          data: verify ? toSerializableValue(await page.data()) : void 0
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_invoke_page", {
+    title: "Call Page Method",
+    description: "\u8C03\u7528\u5F53\u524D\u9875\u9762\u5B9E\u4F8B\u65B9\u6CD5\u3002",
+    inputSchema: {
+      ...connectionInputSchema,
+      method: z.string().trim().min(1),
+      args: z.array(z.unknown()).optional()
+    }
+  }, async ({ method, args, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const callArgs = args ?? [];
+        return {
+          method,
+          args: toSerializableValue(callArgs),
+          result: toSerializableValue(await callRequiredMethod(page, method, ...callArgs))
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+}
+
+function registerRuntimeTools(server, options) {
+  const manager = options.manager ?? new RuntimeSessionManager(options.workspaceRoot, options.runtimeHooks);
+  registerDevtoolsRuntimeTools(server, manager);
+  registerRuntimePageTools(server, manager);
+  registerRuntimeNodeTools(server, manager);
+  return manager;
+}
+
+async function loadPackageSummary(workspaceRoot, id) {
+  return resolveExposedPackage(workspaceRoot, id);
+}
+async function loadExposedCatalog(workspaceRoot) {
+  return resolveExposedPackages(workspaceRoot);
+}
+
+function registerServerTools(server, options) {
+  const { workspaceRoot, packageIds, packageIdSchema } = options;
   server.registerTool("workspace_catalog", {
     title: "Workspace Catalog",
     description: "\u8BFB\u53D6 weapp-vite / wevu \u76F8\u5173\u5305\u76EE\u5F55\u4E0E\u811A\u672C\u80FD\u529B\u6E05\u5355"
   }, async () => {
     try {
-      const catalog2 = await loadExposedCatalog(workspaceRoot);
+      const catalog = await loadExposedCatalog(workspaceRoot);
       return toToolResult({
         workspaceRoot,
-        packages: catalog2
+        packages: catalog
       });
     } catch (error) {
       return toToolError(error);
@@ -695,142 +1899,366 @@ async function createWeappViteMcpServer(options) {
       return toToolError(error);
     }
   });
-  server.registerPrompt("plan-weapp-vite-change", {
-    title: "Plan weapp-vite Change",
-    description: "\u6839\u636E\u53D8\u66F4\u76EE\u6807\u751F\u6210 weapp-vite / wevu \u4FEE\u6539\u8BA1\u5212\u63D0\u793A\u8BCD",
-    argsSchema: {
-      objective: z.string().min(1),
-      focusPackage: packageIdSchema.optional()
-    }
-  }, async ({ objective, focusPackage }) => {
-    const targets = focusPackage ? [focusPackage] : packageIds;
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "\u4F60\u662F weapp-vite monorepo \u7EF4\u62A4\u8005\uFF0C\u8BF7\u7ED9\u51FA\u53EF\u6267\u884C\u7684\u6539\u9020\u8BA1\u5212\u3002",
-              `\u76EE\u6807\uFF1A${objective}`,
-              `\u805A\u7126\u5305\uFF1A${targets.join(", ")}`,
-              "\u8BF7\u5305\u542B\uFF1A\u5F71\u54CD\u9762\u3001\u98CE\u9669\u70B9\u3001\u6D4B\u8BD5\u7B56\u7565\u3001\u56DE\u6EDA\u7B56\u7565\u3002"
-            ].join("\n")
-          }
-        }
-      ]
-    };
+}
+
+const packageIds = Object.keys(EXPOSED_PACKAGES);
+const packageIdSchema = z.enum(packageIds);
+async function createWeappViteMcpServer(options) {
+  const workspaceRoot = resolveWorkspaceRoot(options?.workspaceRoot);
+  const server = new McpServer({
+    name: MCP_SERVER_NAME,
+    version: MCP_SERVER_VERSION
   });
-  server.registerPrompt("debug-wevu-runtime", {
-    title: "Debug wevu Runtime",
-    description: "\u7528\u4E8E\u5B9A\u4F4D wevu runtime \u751F\u547D\u5468\u671F/\u54CD\u5E94\u5F0F\u95EE\u9898\u7684\u6807\u51C6\u63D0\u793A\u8BCD",
-    argsSchema: {
-      symptom: z.string().min(1)
+  const runtimeManager = new RuntimeSessionManager(workspaceRoot, options?.runtimeHooks);
+  registerServerTools(server, {
+    workspaceRoot,
+    packageIds,
+    packageIdSchema
+  });
+  registerRuntimeTools(server, {
+    manager: runtimeManager,
+    runtimeHooks: options?.runtimeHooks,
+    workspaceRoot
+  });
+  registerServerPrompts(server, {
+    packageIds,
+    packageIdSchema
+  });
+  await registerServerResources(server, {
+    workspaceRoot,
+    packageIds
+  });
+  return {
+    runtimeManager,
+    server,
+    workspaceRoot
+  };
+}
+
+const DEFAULT_RUNTIME_REST_ENDPOINT = "/api/weapp/devtools";
+const connectionSchema = z.object({
+  projectPath: z.string().trim().min(1),
+  timeout: z.number().int().positive().optional(),
+  preferOpenedSession: z.boolean().optional()
+});
+const routeBodySchema = connectionSchema.extend({
+  path: z.string().trim().min(1).optional(),
+  query: z.record(z.string(), z.string()).optional(),
+  transition: z.enum(["navigateTo", "redirectTo", "reLaunch", "switchTab", "navigateBack"]).optional(),
+  waitMs: z.number().int().nonnegative().optional()
+});
+const activePageBodySchema = connectionSchema.extend({
+  withData: z.boolean().optional()
+});
+const captureBodySchema = connectionSchema.extend({
+  outputPath: z.string().trim().min(1).optional()
+});
+const hostApiBodySchema = connectionSchema.extend({
+  method: z.string().trim().min(1),
+  args: z.array(z.unknown()).optional()
+});
+function normalizeRuntimeRestEndpoint(input) {
+  if (input === false) {
+    return false;
+  }
+  const value = typeof input === "string" ? input.trim() : "";
+  const endpoint = value || DEFAULT_RUNTIME_REST_ENDPOINT;
+  return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+}
+function writeJson$1(res, statusCode, payload) {
+  if (res.headersSent) {
+    return;
+  }
+  res.statusCode = statusCode;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+function writeOk(res, result) {
+  writeJson$1(res, 200, {
+    ok: true,
+    result
+  });
+}
+function writeError(res, statusCode, error) {
+  writeJson$1(res, statusCode, {
+    ok: false,
+    error: {
+      message: error instanceof Error ? error.message : String(error)
     }
-  }, async ({ symptom }) => {
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "\u8BF7\u57FA\u4E8E wevu runtime \u4EE3\u7801\u8DEF\u5F84\u8FDB\u884C\u5206\u5C42\u6392\u67E5\uFF1A",
-              "1. \u590D\u73B0\u573A\u666F\u4E0E\u6700\u5C0F\u6837\u4F8B",
-              "2. \u751F\u547D\u5468\u671F\u94A9\u5B50\u89E6\u53D1\u94FE",
-              "3. \u54CD\u5E94\u5F0F\u4E0E setData \u5DEE\u91CF\u540C\u6B65\u94FE",
-              "4. \u5355\u6D4B\u4E0E e2e \u56DE\u5F52\u8865\u4E01",
-              `\u73B0\u8C61\uFF1A${symptom}`
-            ].join("\n")
-          }
-        }
-      ]
-    };
   });
-  server.registerResource("workspace-catalog", "weapp-vite://workspace/catalog", {
-    title: "Workspace Catalog",
-    description: "weapp-vite / wevu \u5305\u76EE\u5F55\u3001\u7248\u672C\u548C\u811A\u672C\u5217\u8868",
-    mimeType: "application/json"
-  }, async () => {
-    const catalog2 = await loadExposedCatalog(workspaceRoot);
-    const text = JSON.stringify({ workspaceRoot, packages: catalog2 }, null, 2);
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) {
+    return {};
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) {
+    return {};
+  }
+  return JSON.parse(raw);
+}
+function readBooleanParam(value) {
+  if (value == null) {
+    return void 0;
+  }
+  return ["1", "true", "yes"].includes(value.toLowerCase());
+}
+function readNumberParam(value) {
+  if (value == null || value.trim() === "") {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function readConnectionFromQuery(url) {
+  return connectionSchema.parse(compactObject({
+    projectPath: url.searchParams.get("projectPath") ?? void 0,
+    timeout: readNumberParam(url.searchParams.get("timeout")),
+    preferOpenedSession: readBooleanParam(url.searchParams.get("preferOpenedSession"))
+  }));
+}
+function getRouteContext(req, endpoint) {
+  if (endpoint === false) {
+    return void 0;
+  }
+  const hostHeader = req.headers.host ?? "127.0.0.1";
+  const url = new URL(req.url ?? "/", `http://${hostHeader}`);
+  const pathname = url.pathname.replace(/\/+$/, "") || "/";
+  const normalizedEndpoint = endpoint.replace(/\/+$/, "") || "/";
+  if (pathname !== normalizedEndpoint && !pathname.startsWith(`${normalizedEndpoint}/`)) {
+    return void 0;
+  }
+  const requestPath = pathname === normalizedEndpoint ? "/" : pathname.slice(normalizedEndpoint.length);
+  return {
+    pathname,
+    requestPath,
+    url
+  };
+}
+function getAllowedMethods(pathname) {
+  if (pathname === "/") {
+    return ["GET"];
+  }
+  if (pathname === "/connect" || pathname === "/route" || pathname === "/capture" || pathname === "/host-api") {
+    return ["POST"];
+  }
+  if (pathname === "/active-page" || pathname === "/page-stack") {
+    return ["GET", "POST"];
+  }
+  if (pathname === "/console") {
+    return ["GET", "DELETE"];
+  }
+  if (pathname === "/session") {
+    return ["DELETE"];
+  }
+  return [];
+}
+function assertMethod(res, method, requestPath) {
+  const allowedMethods = getAllowedMethods(requestPath);
+  if (allowedMethods.length === 0) {
+    writeError(res, 404, `Not Found: ${requestPath}`);
+    return false;
+  }
+  if (!allowedMethods.includes(method)) {
+    res.setHeader("allow", allowedMethods.join(", "));
+    writeError(res, 405, `Method Not Allowed: ${method}`);
+    return false;
+  }
+  return true;
+}
+async function readConnectionBody(req) {
+  return connectionSchema.parse(await readJsonBody(req));
+}
+async function getActivePage(manager, input) {
+  return await manager.withPage(input, async (page) => {
+    const [size, scrollTop, data] = await Promise.all([
+      page.size().catch(() => null),
+      page.scrollTop().catch(() => null),
+      input.withData ? page.data().catch(() => null) : Promise.resolve(void 0)
+    ]);
+    return compactObject({
+      path: page.path,
+      query: toSerializableValue(page.query),
+      size: toSerializableValue(size),
+      scrollTop: toSerializableValue(scrollTop),
+      data: toSerializableValue(data)
+    });
+  });
+}
+async function handleRoot(res, endpoint) {
+  writeOk(res, {
+    endpoint,
+    routes: [
+      "POST /connect",
+      "POST /route",
+      "GET|POST /active-page",
+      "GET|POST /page-stack",
+      "POST /capture",
+      "POST /host-api",
+      "GET|DELETE /console",
+      "DELETE /session"
+    ]
+  });
+}
+async function handleConnect(req, res, manager) {
+  const connection = await readConnectionBody(req);
+  const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+    const page = await miniProgram.currentPage().catch(() => null);
+    const systemInfo = await miniProgram.systemInfo().catch(() => null);
     return {
-      contents: [{
-        uri: "weapp-vite://workspace/catalog",
-        mimeType: "application/json",
-        text
-      }]
+      connected: true,
+      projectPath: connection.projectPath,
+      resolvedProjectPath: manager.resolveProjectPath(connection.projectPath),
+      currentPage: page ? { path: page.path, query: toSerializableValue(page.query) } : null,
+      systemInfo: toSerializableValue(systemInfo)
     };
   });
-  const catalog = await resolveExposedPackages(workspaceRoot);
-  for (const summary of catalog) {
-    if (summary.docs.readme) {
-      const uri = toDocsUri(summary.id, "README.md");
-      server.registerResource(`docs-${summary.id}-readme`, uri, {
-        title: `${summary.id} README`,
-        mimeType: "text/markdown"
-      }, async () => {
-        const text = await readTextFile(summary.docs.readme);
-        return {
-          contents: [{ uri, mimeType: "text/markdown", text }]
-        };
-      });
+  writeOk(res, result);
+}
+async function handleRoute(req, res, manager) {
+  const input = routeBodySchema.parse(await readJsonBody(req));
+  const result = await manager.withMiniProgram(input, async (miniProgram) => {
+    const transition = input.transition ?? "navigateTo";
+    if (transition === "navigateBack") {
+      const page2 = await miniProgram.navigateBack();
+      if (input.waitMs && page2) {
+        await page2.waitFor(input.waitMs);
+      }
+      return {
+        transition,
+        activePage: page2 ? { path: page2.path, query: toSerializableValue(page2.query) } : null
+      };
     }
-    if (summary.docs.changelog) {
-      const uri = toDocsUri(summary.id, "CHANGELOG.md");
-      server.registerResource(`docs-${summary.id}-changelog`, uri, {
-        title: `${summary.id} CHANGELOG`,
-        mimeType: "text/markdown"
-      }, async () => {
-        const text = await readTextFile(summary.docs.changelog);
-        return {
-          contents: [{ uri, mimeType: "text/markdown", text }]
-        };
-      });
+    if (!input.path) {
+      throw new Error("transition \u4E0D\u662F navigateBack \u65F6\u5FC5\u987B\u63D0\u4F9B path\u3002");
     }
-  }
-  const sourceTemplate = new ResourceTemplate("weapp-vite://source/{package}?path={path}", {
-    list: void 0,
-    complete: {
-      package: () => packageIds
+    const url = buildUrl(input.path, input.query);
+    const page = await callRequiredMethod(
+      miniProgram,
+      transition,
+      url
+    );
+    if (input.waitMs && page) {
+      await page.waitFor(input.waitMs);
     }
+    return {
+      transition,
+      url,
+      activePage: page ? { path: page.path, query: toSerializableValue(page.query) } : null
+    };
   });
-  server.registerResource("source-template", sourceTemplate, {
-    title: "Source Template",
-    description: "\u8BFB\u53D6 weapp-vite / wevu \u4EFB\u610F\u6E90\u7801\u6587\u4EF6\uFF08\u901A\u8FC7 package + path \u53C2\u6570\uFF09",
-    mimeType: "text/plain"
-  }, async (uri, variables) => {
-    try {
-      const packageId = String(variables.package ?? "");
-      if (!packageIds.includes(packageId)) {
-        throw new Error(`\u672A\u77E5 package\uFF1A${packageId}`);
-      }
-      const relativePath = decodeURIComponent(String(variables.path ?? ""));
-      const packageRoot = await resolvePackageRoot(workspaceRoot, packageId);
-      const { content } = await readFileContent(packageRoot, relativePath, {
-        maxChars: DEFAULT_MAX_FILE_CHARS
-      });
-      return {
-        contents: [{
-          uri: uri.toString(),
-          mimeType: "text/plain",
-          text: content
-        }]
-      };
-    } catch (error) {
+  writeOk(res, result);
+}
+async function handleActivePage(req, res, context, manager) {
+  const input = req.method === "GET" ? activePageBodySchema.parse({
+    ...readConnectionFromQuery(context.url),
+    withData: readBooleanParam(context.url.searchParams.get("withData"))
+  }) : activePageBodySchema.parse(await readJsonBody(req));
+  const result = await getActivePage(manager, input);
+  writeOk(res, result);
+}
+async function handlePageStack(req, res, context, manager) {
+  const connection = req.method === "GET" ? readConnectionFromQuery(context.url) : await readConnectionBody(req);
+  const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+    const stack = await miniProgram.pageStack();
+    return stack.map((page) => ({
+      path: page.path,
+      query: toSerializableValue(page.query)
+    }));
+  });
+  writeOk(res, result);
+}
+async function handleCapture(req, res, manager) {
+  const input = captureBodySchema.parse(await readJsonBody(req));
+  const result = await manager.withMiniProgram(input, async (miniProgram) => {
+    const screenshot = await miniProgram.screenshot();
+    const buffer = typeof screenshot === "string" ? Buffer.from(screenshot, "base64") : Buffer.from(screenshot);
+    if (input.outputPath) {
+      const resolvedOutputPath = manager.resolveWorkspacePath(input.outputPath);
+      await fs$1.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+      await fs$1.writeFile(resolvedOutputPath, buffer);
       return {
-        contents: [{
-          uri: uri.toString(),
-          mimeType: "text/plain",
-          text: `[resource-error] ${normalizeErrorMessage(error)}`
-        }]
+        path: resolvedOutputPath,
+        bytes: buffer.length
       };
     }
+    return {
+      base64: buffer.toString("base64"),
+      bytes: buffer.length
+    };
   });
-  return {
-    server,
-    workspaceRoot
-  };
+  writeOk(res, result);
+}
+async function handleHostApi(req, res, manager) {
+  const input = hostApiBodySchema.parse(await readJsonBody(req));
+  const result = await manager.withMiniProgram(input, async (miniProgram) => {
+    const args = input.args ?? [];
+    return {
+      method: input.method,
+      args: toSerializableValue(args),
+      result: toSerializableValue(await miniProgram.callWxMethod(input.method, ...args))
+    };
+  });
+  writeOk(res, result);
+}
+async function handleConsole(req, res, manager) {
+  const logs = manager.getLogs();
+  if (req.method === "DELETE") {
+    manager.clearLogs();
+  }
+  writeOk(res, {
+    count: logs.length,
+    logs,
+    cleared: req.method === "DELETE"
+  });
+}
+async function handleSession(req, res, context, manager) {
+  const connection = context.url.searchParams.has("projectPath") ? readConnectionFromQuery(context.url) : await readConnectionBody(req);
+  await manager.close(connection);
+  writeOk(res, {
+    closed: true,
+    projectPath: connection.projectPath,
+    resolvedProjectPath: manager.resolveProjectPath(connection.projectPath)
+  });
+}
+async function handleRuntimeRestRequest(req, res, options) {
+  const endpoint = normalizeRuntimeRestEndpoint(options.endpoint);
+  const context = getRouteContext(req, endpoint);
+  if (!context) {
+    return false;
+  }
+  const method = req.method ?? "GET";
+  if (!assertMethod(res, method, context.requestPath)) {
+    return true;
+  }
+  try {
+    if (context.requestPath === "/") {
+      await handleRoot(res, endpoint);
+    } else if (context.requestPath === "/connect") {
+      await handleConnect(req, res, options.manager);
+    } else if (context.requestPath === "/route") {
+      await handleRoute(req, res, options.manager);
+    } else if (context.requestPath === "/active-page") {
+      await handleActivePage(req, res, context, options.manager);
+    } else if (context.requestPath === "/page-stack") {
+      await handlePageStack(req, res, context, options.manager);
+    } else if (context.requestPath === "/capture") {
+      await handleCapture(req, res, options.manager);
+    } else if (context.requestPath === "/host-api") {
+      await handleHostApi(req, res, options.manager);
+    } else if (context.requestPath === "/console") {
+      await handleConsole(req, res, options.manager);
+    } else if (context.requestPath === "/session") {
+      await handleSession(req, res, context, options.manager);
+    }
+  } catch (error) {
+    writeError(res, error instanceof SyntaxError || error instanceof z.ZodError ? 400 : 500, error);
+  }
+  return true;
 }
 
 const DEFAULT_MCP_HOST = "127.0.0.1";
@@ -894,22 +2322,32 @@ async function startStreamableHttpServer(options) {
     endpoint = DEFAULT_MCP_ENDPOINT,
     host = DEFAULT_MCP_HOST,
     port = DEFAULT_MCP_PORT,
+    restEndpoint = DEFAULT_RUNTIME_REST_ENDPOINT,
     workspaceRoot,
+    runtimeHooks,
     unref = false,
     quiet = false,
     onReady
   } = options;
   const normalizedEndpoint = normalizeEndpoint(endpoint);
   const normalizedPort = normalizePort(port);
-  const { server: mcpServer } = await createWeappViteMcpServer({ workspaceRoot });
+  const normalizedRestEndpoint = normalizeRuntimeRestEndpoint(restEndpoint);
+  const { runtimeManager, server: mcpServer } = await createWeappViteMcpServer({ runtimeHooks, workspaceRoot });
   const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: void 0
+    sessionIdGenerator: randomUUID
   });
   await mcpServer.connect(transport);
   const httpServer = http.createServer(async (req, res) => {
     try {
       const hostHeader = req.headers.host ?? `${host}:${normalizedPort}`;
       const url = new URL(req.url ?? "/", `http://${hostHeader}`);
+      const handledByRest = await handleRuntimeRestRequest(req, res, {
+        endpoint: normalizedRestEndpoint,
+        manager: runtimeManager
+      });
+      if (handledByRest) {
+        return;
+      }
       if (url.pathname !== normalizedEndpoint) {
         writeJson(res, 404, {
           jsonrpc: "2.0",
@@ -957,6 +2395,9 @@ async function startStreamableHttpServer(options) {
   }
   if (!quiet) {
     onReady?.(`[mcp] streamable-http ready at http://${host}:${normalizedPort}${normalizedEndpoint}`);
+    if (normalizedRestEndpoint !== false) {
+      onReady?.(`[mcp] REST runtime ready at http://${host}:${normalizedPort}${normalizedRestEndpoint}`);
+    }
   }
   return {
     transport: "streamable-http",
@@ -1002,4 +2443,4 @@ ${message}
   });
 }
 
-export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
+export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };