@weapp-vite/mcp 1.5.8 → 2.0.0

package/dist/index.mjs

@@ -4,1041 +4,714 @@ import http from 'node:http';
 import { toNodeHandler, localhostHostValidation, hostHeaderValidation, localhostOriginValidation, originValidation } from '@modelcontextprotocol/node';
 import { ResourceTemplate, McpServer, createMcpHandler } from '@modelcontextprotocol/server';
 import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { DEFAULT_RUNTIME_REST_ENDPOINT, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT } from '@weapp-core/constants';
+export { DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT } from '@weapp-core/constants';
 import { Buffer } from 'node:buffer';
-import fs$1 from 'node:fs/promises';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import { z } from 'zod';
-import { closeSharedMiniProgram, resolveDevtoolsProjectPath, resolveDevtoolsWorkspacePath, acquireSharedMiniProgram, releaseSharedMiniProgram, resolveSharedMiniProgramSessionKey, toDevtoolsSerializableValue } from '@weapp-vite/devtools-runtime';
+import { withRuntimeLease, closeSharedMiniProgram, closeOwnedSharedMiniProgram, resolveDevtoolsProjectPath, resolveDevtoolsWorkspacePath, hasSharedMiniProgram, acquireSharedMiniProgram, releaseSharedMiniProgram, resolveSharedMiniProgramSessionKey, retainSharedMiniProgram, releaseSharedMiniProgramByKey, toDevtoolsSerializableValue, acquireRuntimeLease, runWithRuntimeLease } from '@weapp-vite/devtools-runtime';
+import { AcceptanceService, redactor, redactValue } from '@weapp-vite/acceptance';
 import { createRequire } from 'node:module';
-import fs from 'node:fs';
+import fs$1 from 'node:fs';
 import { spawn } from 'node:child_process';
 
-const MCP_SERVER_NAME = "@weapp-vite/mcp";
-const MCP_SERVER_VERSION = "2.0.0";
-const EXPOSED_PACKAGES = {
-  "weapp-vite": {
-    id: "weapp-vite",
-    label: "weapp-vite",
-    packageName: "weapp-vite",
-    relativePath: path.join("packages", "weapp-vite")
-  },
-  "wevu": {
-    id: "wevu",
-    label: "wevu",
-    packageName: "wevu",
-    relativePath: path.join("packages-runtime", "wevu")
-  },
-  "wevu-compiler": {
-    id: "wevu-compiler",
-    label: "wevu-compiler",
-    packageName: "@wevu/compiler",
-    relativePath: path.join("packages-runtime", "wevu-compiler")
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function normalizeErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-};
-const DEFAULT_TIMEOUT_MS = 12e4;
-const DEFAULT_MAX_OUTPUT_CHARS = 12e4;
-const DEFAULT_MAX_FILE_CHARS = 8e4;
-const DEFAULT_MAX_RESULTS = 200;
-const SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".turbo",
-  "dist",
-  "coverage"
-]);
-
-function hasWorkspaceMarkers(dir) {
-  return fs.existsSync(path.join(dir, "pnpm-workspace.yaml")) && fs.existsSync(path.join(dir, "package.json"));
+  return String(error);
 }
-function resolveWorkspaceRoot(start = process.cwd()) {
-  let current = path.resolve(start);
-  while (true) {
-    if (hasWorkspaceMarkers(current)) {
-      return current;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return path.resolve(start);
+function toToolResult(data, text) {
+  return {
+    content: [{
+      type: "text",
+      text: text ?? formatJson(data)
+    }],
+    structuredContent: {
+      result: data
     }
-    current = parent;
-  }
+  };
 }
-function assertInsideRoot(root, targetPath) {
-  const resolvedRoot = path.resolve(root);
-  const resolvedTarget = path.resolve(targetPath);
-  const relative = path.relative(resolvedRoot, resolvedTarget);
-  if (relative === "" || relative === ".") {
-    return resolvedTarget;
+function toToolError(error) {
+  const message = normalizeErrorMessage(error);
+  return {
+    isError: true,
+    content: [{
+      type: "text",
+      text: message
+    }]
+  };
+}
+
+const DEFAULT_SCREENSHOT_TIMEOUT = 6e4;
+const SCREENSHOT_RETRY_DELAY = 500;
+const connectionSchema$1 = z.object({
+  cliPath: z.string().trim().min(1).optional(),
+  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(),
+  port: z.number().int().positive().max(65535).optional(),
+  preferOpenedSession: z.boolean().optional(),
+  preserveProjectRoot: z.boolean().optional(),
+  sessionId: z.string().trim().min(1).optional()
+});
+const connectionInputSchema = {
+  cliPath: z.string().trim().min(1).optional(),
+  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(),
+  port: z.number().int().positive().max(65535).optional(),
+  preferOpenedSession: z.boolean().optional(),
+  preserveProjectRoot: z.boolean().optional(),
+  sessionId: z.string().trim().min(1).optional()
+};
+class RuntimeSessionManager {
+  constructor(workspaceRoot, runtimeHooks = createUnavailableRuntimeHooks()) {
+    this.workspaceRoot = workspaceRoot;
+    this.runtimeHooks = runtimeHooks;
   }
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${targetPath}`);
+  resolvedInputs = /* @__PURE__ */ new Map();
+  resolvedSessionKeys = /* @__PURE__ */ new Map();
+  logs = [];
+  attachedSessions = /* @__PURE__ */ new Map();
+  maxLogs = 1e3;
+  logSequence = 0;
+  ownedSessions = /* @__PURE__ */ new Map();
+  async close(input) {
+    input = await this.resolveInput(input);
+    const projectPath = this.resolveProjectPath(input.projectPath);
+    const sessionKey = this.resolveSessionKey(projectPath, input);
+    await withRuntimeLease(projectPath, async () => {
+      this.detach(sessionKey);
+      await closeSharedMiniProgram(projectPath, input.sessionId || input.port, input);
+    });
   }
-  return resolvedTarget;
-}
-function resolveSubPath(root, relativePath) {
-  if (!relativePath || relativePath === ".") {
-    return path.resolve(root);
+  clearLogs() {
+    this.logs.length = 0;
   }
-  if (path.isAbsolute(relativePath)) {
-    throw new Error("\u4EC5\u652F\u6301\u76F8\u5BF9\u8DEF\u5F84");
+  getLogs(projectPath, afterSequence = 0) {
+    return this.logs.filter((entry) => (!projectPath || entry.projectPath === this.resolveProjectPath(projectPath)) && (entry.sequence ?? 0) > afterSequence);
   }
-  return assertInsideRoot(root, path.resolve(root, relativePath));
-}
-
-async function pathExists(filePath) {
-  try {
-    await fs$1.access(filePath);
-    return true;
-  } catch {
-    return false;
+  getLogCursor() {
+    return this.logSequence;
   }
-}
-async function toWorkspaceRelativePath(workspaceRoot, absolutePath) {
-  const [realWorkspaceRoot, realAbsolutePath] = await Promise.all([
-    fs$1.realpath(workspaceRoot),
-    fs$1.realpath(absolutePath)
-  ]);
-  const relativePath = path.relative(realWorkspaceRoot, realAbsolutePath);
-  if (!relativePath || relativePath === ".") {
-    return ".";
+  async prepareProject(projectPath, signal) {
+    const options = await this.resolveInput({ projectPath });
+    await this.runtimeHooks.prepareProject?.(projectPath, signal, options);
   }
-  return relativePath;
-}
-async function readPackageJson(filePath) {
-  const content = await fs$1.readFile(filePath, "utf8");
-  return JSON.parse(content);
-}
-function createWorkspaceRequire(workspaceRoot) {
-  return createRequire(path.join(workspaceRoot, "__weapp_vite_mcp__.cjs"));
-}
-async function resolveMonorepoPackage(workspaceRoot, id) {
-  const config = EXPOSED_PACKAGES[id];
-  const absolutePath = assertInsideRoot(workspaceRoot, path.join(workspaceRoot, config.relativePath));
-  const packageJsonPath = path.join(absolutePath, "package.json");
-  if (!await pathExists(packageJsonPath)) {
-    return void 0;
+  fork(workspaceRoot = this.workspaceRoot) {
+    return new RuntimeSessionManager(workspaceRoot, this.runtimeHooks);
   }
-  const packageJson = await readPackageJson(packageJsonPath);
-  const readmePath = path.join(absolutePath, "README.md");
-  const changelogPath = path.join(absolutePath, "CHANGELOG.md");
-  const sourceRoot = await pathExists(path.join(absolutePath, "src")) ? absolutePath : void 0;
-  const cliPath = id === "weapp-vite" ? await pathExists(path.join(absolutePath, "bin", "weapp-vite.js")) ? path.join(absolutePath, "bin", "weapp-vite.js") : void 0 : void 0;
-  return {
-    id,
-    label: config.label,
-    packageName: packageJson.name ?? config.packageName,
-    version: packageJson.version ?? "0.0.0",
-    absolutePath,
-    relativePath: config.relativePath,
-    scripts: Object.keys(packageJson.scripts ?? {}),
-    docs: {
-      readme: await pathExists(readmePath) ? readmePath : void 0,
-      changelog: await pathExists(changelogPath) ? changelogPath : void 0
-    },
-    sourceRoot,
-    cliPath
-  };
-}
-async function resolveInstalledPackage(workspaceRoot, id) {
-  const config = EXPOSED_PACKAGES[id];
-  const workspaceRequire = createWorkspaceRequire(workspaceRoot);
-  let packageJsonPath;
-  try {
-    packageJsonPath = workspaceRequire.resolve(`${config.packageName}/package.json`);
-  } catch {
-    return void 0;
+  async dispose() {
+    for (const key of this.attachedSessions.keys()) {
+      this.detach(key);
+    }
+    for (const { input, miniProgram } of this.ownedSessions.values()) {
+      await closeOwnedSharedMiniProgram(input, miniProgram);
+    }
+    this.ownedSessions.clear();
   }
-  const absolutePath = path.dirname(packageJsonPath);
-  const relativePath = await toWorkspaceRelativePath(workspaceRoot, absolutePath);
-  const packageJson = await readPackageJson(packageJsonPath);
-  const docsRoot = path.join(absolutePath, "dist", "docs");
-  const installedReadmePath = path.join(docsRoot, "README.md");
-  const installedChangelogPath = path.join(docsRoot, "CHANGELOG.md");
-  const sourceRoot = await pathExists(path.join(absolutePath, "src")) ? absolutePath : void 0;
-  let cliPath;
-  if (id === "weapp-vite") {
-    const binEntry = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.["weapp-vite"];
-    if (typeof binEntry === "string" && binEntry.trim()) {
-      const resolvedCliPath = path.resolve(absolutePath, binEntry);
-      if (await pathExists(resolvedCliPath)) {
-        cliPath = resolvedCliPath;
+  resolveProjectPath(projectPath) {
+    return resolveDevtoolsProjectPath(this.workspaceRoot, projectPath);
+  }
+  resolveWorkspacePath(filePath) {
+    return resolveDevtoolsWorkspacePath(this.workspaceRoot, filePath);
+  }
+  async withMiniProgram(input, runner) {
+    input = await this.resolveInput(input);
+    const projectPath = this.resolveProjectPath(input.projectPath);
+    return withRuntimeLease(projectPath, async () => {
+      const existed = hasSharedMiniProgram({ ...input, projectPath });
+      const miniProgram = await acquireSharedMiniProgram(this.runtimeHooks, {
+        ...input,
+        port: input.port,
+        projectPath,
+        sessionId: input.sessionId,
+        timeout: input.timeout,
+        preferOpenedSession: input.preferOpenedSession,
+        preserveProjectRoot: input.preserveProjectRoot ?? true,
+        sharedSession: true
+      });
+      const sessionKey = this.resolveSessionKey(projectPath, input);
+      if (!existed) {
+        this.ownedSessions.set(sessionKey, { input: { ...input, projectPath }, miniProgram });
+      }
+      this.attach(sessionKey, miniProgram, projectPath);
+      try {
+        return await runner(miniProgram);
+      } finally {
+        releaseSharedMiniProgram(projectPath, input.sessionId || input.port, input);
+      }
+    });
+  }
+  async withPage(input, runner) {
+    input = await this.resolveInput(input);
+    const projectPath = this.resolveProjectPath(input.projectPath);
+    const sessionKey = this.resolveSessionKey(projectPath, input);
+    return await this.withMiniProgram(input, async (miniProgram) => {
+      const page = await this.resolveCurrentPage(sessionKey, miniProgram);
+      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);
+    });
+  }
+  rememberPage(input, page) {
+    if (!page) {
+      return;
     }
+    const projectPath = this.resolveProjectPath(input.projectPath);
+    const sessionKey = this.resolveSessionKey(projectPath, input);
+    this.attachedSessions.get(sessionKey).currentPage = page;
   }
-  return {
-    id,
-    label: config.label,
-    packageName: packageJson.name ?? config.packageName,
-    version: packageJson.version ?? "0.0.0",
-    absolutePath,
-    relativePath,
-    scripts: Object.keys(packageJson.scripts ?? {}),
-    docs: {
-      readme: await pathExists(installedReadmePath) ? installedReadmePath : void 0,
-      changelog: await pathExists(installedChangelogPath) ? installedChangelogPath : void 0
-    },
-    sourceRoot,
-    cliPath
-  };
-}
-async function resolveExposedPackage(workspaceRoot, id) {
-  return await resolveMonorepoPackage(workspaceRoot, id) ?? await resolveInstalledPackage(workspaceRoot, id) ?? Promise.reject(new Error(`\u672A\u627E\u5230\u66B4\u9732\u5305\uFF1A${id}`));
-}
-async function resolveExposedPackages(workspaceRoot) {
-  const resolved = await Promise.allSettled(
-    Object.keys(EXPOSED_PACKAGES).map((id) => resolveExposedPackage(workspaceRoot, id))
-  );
-  return resolved.flatMap((result) => {
-    if (result.status === "fulfilled") {
-      return [result.value];
+  async resolveInput(input) {
+    const options = { ...input, projectPath: this.resolveProjectPath(input.projectPath) };
+    const key = resolveSharedMiniProgramSessionKey(options);
+    let resolution = this.resolvedInputs.get(key);
+    if (!resolution) {
+      resolution = this.runtimeHooks.resolveSessionOptions?.(options) ?? Promise.resolve(options);
+      this.resolvedInputs.set(key, resolution);
     }
-    return [];
-  }).sort((a, b) => a.id.localeCompare(b.id));
-}
-
-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: z.object({
-      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: z.object({
-      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: z.object({
-      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")
-          }
-        }
-      ]
+    try {
+      const resolved = await resolution;
+      this.resolvedSessionKeys.set(key, resolveSharedMiniProgramSessionKey(resolved));
+      return { ...resolved, ...input, projectPath: options.projectPath, cliPath: resolved.cliPath, installationId: resolved.installationId };
+    } catch (error) {
+      this.resolvedInputs.delete(key);
+      throw error;
+    }
+  }
+  resolveSessionKey(projectPath, input) {
+    const key = resolveSharedMiniProgramSessionKey({ ...input, projectPath });
+    return this.resolvedSessionKeys.get(key) ?? key;
+  }
+  attach(sessionKey, miniProgram, projectPath) {
+    const existing = this.attachedSessions.get(sessionKey);
+    if (existing?.miniProgram === miniProgram) {
+      return;
+    }
+    this.detach(sessionKey);
+    retainSharedMiniProgram(sessionKey);
+    const onConsole = (payload) => {
+      this.pushLog({ ...normalizeConsoleEvent(payload), projectPath, sessionKey });
     };
-  });
-  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: z.object({
-      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")
-          }
-        }
-      ]
+    const onException = (payload) => {
+      this.pushLog({ ...normalizeExceptionEvent(payload), projectPath, sessionKey });
     };
-  });
-}
-
-async function walkFilesRecursive(root, current, output, maxResults) {
-  if (output.length >= maxResults) {
-    return;
+    miniProgram.on("console", onConsole);
+    miniProgram.on("exception", onException);
+    this.attachedSessions.set(sessionKey, {
+      miniProgram,
+      onConsole,
+      onException
+    });
   }
-  const entries = await fs$1.readdir(current, { withFileTypes: true });
-  for (const entry of entries) {
-    if (output.length >= maxResults) {
+  async resolveCurrentPage(sessionKey, miniProgram) {
+    try {
+      const page = await miniProgram.currentPage();
+      this.attachedSessions.get(sessionKey).currentPage = page;
+      return page;
+    } catch (error) {
+      const cachedPage = this.attachedSessions.get(sessionKey)?.currentPage;
+      if (cachedPage && isCurrentPageRecoverableError(error)) {
+        return cachedPage;
+      }
+      throw error;
+    }
+  }
+  detach(projectPath) {
+    const attached = this.attachedSessions.get(projectPath);
+    if (!attached) {
       return;
     }
-    if (entry.isDirectory()) {
-      if (SKIPPED_DIR_NAMES.has(entry.name)) {
-        continue;
-      }
-      await walkFilesRecursive(root, path.join(current, entry.name), output, maxResults);
-      continue;
+    if (typeof attached.miniProgram.off === "function") {
+      attached.miniProgram.off("console", attached.onConsole);
+      attached.miniProgram.off("exception", attached.onException);
     }
-    if (!entry.isFile()) {
-      continue;
+    releaseSharedMiniProgramByKey(projectPath);
+    this.attachedSessions.delete(projectPath);
+  }
+  pushLog(entry) {
+    this.logs.push({ ...entry, sequence: ++this.logSequence });
+    while (this.logs.length > this.maxLogs) {
+      this.logs.shift();
     }
-    const absolutePath = path.join(current, entry.name);
-    const relativePath = path.relative(root, absolutePath).split(path.sep).join("/");
-    output.push(relativePath);
   }
 }
-async function listFilesInDirectory(root, relativeDirectory = ".", maxResults = DEFAULT_MAX_RESULTS) {
-  const dirPath = resolveSubPath(root, relativeDirectory);
-  const files = [];
-  await walkFilesRecursive(root, dirPath, files, maxResults);
-  return files;
-}
-function sliceLines(content, startLine, endLine) {
-  if (!startLine && !endLine) {
-    return content;
+function buildUrl(pagePath, query) {
+  const normalizedPath = pagePath.startsWith("/") ? pagePath : `/${pagePath}`;
+  if (!query || Object.keys(query).length === 0) {
+    return normalizedPath;
   }
-  const lines = content.split("\n");
-  const safeStart = Math.max(1, startLine ?? 1);
-  const safeEnd = Math.max(safeStart, endLine ?? lines.length);
-  return lines.slice(safeStart - 1, safeEnd).join("\n");
+  const search = new URLSearchParams(query).toString();
+  if (!search) {
+    return normalizedPath;
+  }
+  return `${normalizedPath}${normalizedPath.includes("?") ? "&" : "?"}${search}`;
 }
-async function readFileContent(root, relativeFilePath, options) {
-  const filePath = assertInsideRoot(root, path.join(root, relativeFilePath));
-  const content = await fs$1.readFile(filePath, "utf8");
-  const selected = sliceLines(content, options?.startLine, options?.endLine);
-  const maxChars = options?.maxChars ?? DEFAULT_MAX_FILE_CHARS;
-  const clipped = selected.length > maxChars ? `${selected.slice(0, maxChars)}
-
-[truncated: ${selected.length - maxChars} chars omitted]` : selected;
-  return {
-    filePath,
-    content: clipped
-  };
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function collectMatchesFromText(query, relativeFilePath, content, maxResults, output) {
-  const lines = content.split("\n");
-  for (let index = 0; index < lines.length; index += 1) {
-    if (output.length >= maxResults) {
-      return;
-    }
-    const lineText = lines[index] ?? "";
-    const column = lineText.toLowerCase().indexOf(query.toLowerCase());
-    if (column === -1) {
-      continue;
-    }
-    output.push({
-      filePath: relativeFilePath,
-      line: index + 1,
-      column: column + 1,
-      text: lineText.trim()
-    });
+function isCaptureScreenshotProtocolTimeout(error) {
+  return error instanceof Error && "code" in error && error.code === "DEVTOOLS_PROTOCOL_TIMEOUT" && "method" in error && error.method === "App.captureScreenshot";
+}
+function isCurrentPageRecoverableError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if ("code" in error && error.code === "DEVTOOLS_PROTOCOL_TIMEOUT" && "method" in error) {
+    return error.method === "App.getCurrentPage" || error.method === "App.getPageStack" || error.method === "App.callFunction";
   }
+  return error.message.includes("page is not on top of page stack");
 }
-async function searchTextInDirectory(root, query, options) {
-  const maxResults = options?.maxResults ?? DEFAULT_MAX_RESULTS;
-  const files = await listFilesInDirectory(root, options?.relativeDirectory ?? ".", Math.max(400, maxResults));
-  const matches = [];
-  for (const file of files) {
-    if (matches.length >= maxResults) {
-      break;
-    }
-    const absolutePath = path.join(root, file);
-    let content = "";
+async function captureMiniProgramScreenshot(miniProgram, timeout = DEFAULT_SCREENSHOT_TIMEOUT) {
+  let lastError;
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
     try {
-      content = await fs$1.readFile(absolutePath, "utf8");
-    } catch {
-      continue;
+      const screenshot = await miniProgram.screenshot({ timeout });
+      if (screenshot == null) {
+        throw new Error("DevTools screenshot returned no data.");
+      }
+      return typeof screenshot === "string" ? Buffer.from(screenshot, "base64") : Buffer.from(screenshot);
+    } catch (error) {
+      lastError = error;
+      if (!isCaptureScreenshotProtocolTimeout(error) || attempt === 2) {
+        throw error;
+      }
+      await miniProgram.currentPage().catch(() => void 0);
+      await sleep(SCREENSHOT_RETRY_DELAY);
     }
-    collectMatchesFromText(query, file, content, maxResults, matches);
   }
-  return matches;
-}
-
-function formatJson(value) {
-  return JSON.stringify(value, null, 2);
+  throw lastError;
 }
-function normalizeErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
+function parseSelectorWithIndex(selector) {
+  const match = selector.match(/^(.+?)\[index=(\d+)\]$/);
+  if (!match?.[1] || !match[2]) {
+    return {
+      selector,
+      index: void 0
+    };
   }
-  return String(error);
-}
-function toToolResult(data, text) {
-  return {
-    content: [{
-      type: "text",
-      text: text ?? formatJson(data)
-    }],
-    structuredContent: {
-      result: data
-    }
-  };
-}
-function toToolError(error) {
-  const message = normalizeErrorMessage(error);
   return {
-    isError: true,
-    content: [{
-      type: "text",
-      text: message
-    }]
+    selector: match[1],
+    index: Number.parseInt(match[2], 10)
   };
 }
-
-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";
+async function resolveElement(page, selectorInput, innerSelector, queryOptions) {
+  const { selector, index } = parseSelectorWithIndex(selectorInput);
+  let element;
+  if (index === void 0) {
+    element = await page.$(selector, queryOptions);
+  } else {
+    const elements = await queryElements(page, selector, queryOptions);
+    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];
   }
-  return command;
-}
-function truncateOutput(text, maxChars) {
-  if (text.length <= maxChars) {
-    return text;
+  if (!element) {
+    throw new Error(`\u672A\u627E\u5230\u5143\u7D20: ${selectorInput}`);
   }
-  return `${text.slice(0, maxChars)}
-
-[truncated: ${text.length - maxChars} chars omitted]`;
+  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 runCommand(workspaceRoot, command, args, options) {
-  if (!ALLOWED_COMMANDS.has(command)) {
-    throw new Error(`\u4E0D\u5141\u8BB8\u7684\u547D\u4EE4\uFF1A${command}`);
+async function queryElements(page, selectorInput, queryOptions) {
+  const { selector, index } = parseSelectorWithIndex(selectorInput);
+  const elements = await callOptionalMethod(page, "$$", selector, queryOptions);
+  if (!Array.isArray(elements)) {
+    return [];
   }
-  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);
+  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, markup] = await Promise.all([
+    callMaybe(element, "text"),
+    callMaybe(element, "value"),
+    callMaybe(element, "size"),
+    callMaybe(element, "offset"),
+    callMaybe(element, "scrollWidth"),
+    callMaybe(element, "scrollHeight"),
+    withWxml ? readElementMarkup(element).catch(() => null) : Promise.resolve(null)
+  ]);
+  return compactObject({
+    tagName: readProperty(element, "tagName"),
+    text,
+    value,
+    size,
+    offset,
+    scrollWidth,
+    scrollHeight,
+    outerWxml: withWxml && markup?.type === "outerWxml" ? markup.wxml : null,
+    wxml: withWxml && markup?.type !== "outerWxml" ? markup?.wxml ?? null : void 0,
+    wxmlType: withWxml ? markup?.type ?? null : void 0
   });
+}
+async function readElementMarkup(element, outer = false) {
+  if (outer) {
+    const outerWxml = await callMaybe(element, "outerWxml");
+    if (typeof outerWxml === "string") {
+      return {
+        type: "outerWxml",
+        wxml: outerWxml
+      };
+    }
+  }
+  const wxml = await callRequiredMethod(element, "wxml");
   return {
-    command,
-    args,
-    cwd: path.resolve(cwd),
-    exitCode,
-    stdout: truncateOutput(stdout.trim(), maxOutputChars),
-    stderr: truncateOutput(stderr.trim(), maxOutputChars),
-    timedOut
+    type: outer ? "wxml-fallback" : "wxml",
+    wxml: typeof wxml === "string" ? wxml : String(wxml ?? "")
   };
 }
-
-async function resolvePackageRoot(workspaceRoot, packageId) {
-  const resolved = await resolveExposedPackage(workspaceRoot, packageId);
-  if (!resolved.sourceRoot) {
-    throw new Error(`\u5F53\u524D\u5DE5\u4F5C\u533A\u4E2D\u7684 ${packageId} \u4E0D\u5305\u542B\u6E90\u7801\u76EE\u5F55\uFF0C\u8BF7\u6539\u4E3A\u4F18\u5148\u8BFB\u53D6\u672C\u5730\u968F\u5305\u6587\u6863\u3002`);
-  }
-  return assertInsideRoot(workspaceRoot, resolved.sourceRoot);
+function toSerializableValue(value) {
+  return toDevtoolsSerializableValue(value);
 }
-function toDocsUri(packageId, fileName) {
-  return `weapp-vite://docs/${packageId}/${fileName}`;
+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 readTextFile(filePath) {
-  return fs$1.readFile(filePath, "utf8");
+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 runWeappViteCliTool(workspaceRoot, input) {
-  const cliPath = (await resolveExposedPackage(workspaceRoot, "weapp-vite")).cliPath;
-  if (!cliPath) {
-    throw new Error("\u5F53\u524D\u5DE5\u4F5C\u533A\u4E2D\u7684 weapp-vite \u672A\u66B4\u9732 CLI \u5165\u53E3");
+async function callMaybe(target, methodName, ...args) {
+  try {
+    return await callOptionalMethod(target, methodName, ...args);
+  } catch {
+    return void 0;
   }
-  const finalArgs = [cliPath, input.subCommand];
-  if (input.projectPath) {
-    finalArgs.push(resolveSubPath(workspaceRoot, input.projectPath));
+}
+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;
   }
-  if (input.platform) {
-    finalArgs.push("--platform", input.platform);
+  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 (Array.isArray(input.args) && input.args.length > 0) {
-    finalArgs.push(...input.args);
+  if (["debug", "log", "info", "warn", "error"].includes(normalized)) {
+    return normalized;
   }
-  return runCommand(workspaceRoot, "node", finalArgs, {
-    timeoutMs: input.timeoutMs ?? DEFAULT_TIMEOUT_MS
-  });
+  return "log";
 }
-
-function registerServerResources(server, options) {
-  const { workspaceRoot, packageIds, exposedPackages } = 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 catalog = await resolveExposedPackages(workspaceRoot);
-    const text = JSON.stringify({ workspaceRoot, packages: catalog }, null, 2);
-    return {
-      contents: [{
-        uri: "weapp-vite://workspace/catalog",
-        mimeType: "application/json",
-        text
-      }]
-    };
-  });
-  for (const summary of exposedPackages) {
-    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);
+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: z.object({
+      ...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);
+        manager.rememberPage(connection, page);
+        const systemInfo = await miniProgram.systemInfo().catch(() => null);
         return {
-          contents: [{ uri, mimeType: "text/markdown", text }]
+          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);
     }
-    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);
+  });
+  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: z.object(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();
+          manager.rememberPage(connection, page2);
+          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
+        );
+        manager.rememberPage(connection, page);
+        if (waitMs && page) {
+          await page.waitFor(waitMs);
+        }
         return {
-          contents: [{ uri, mimeType: "text/markdown", text }]
+          transition,
+          url,
+          activePage: page ? { path: page.path, query: toSerializableValue(page.query) } : null
         };
       });
-    }
-  }
-  const sourceTemplate = new ResourceTemplate("weapp-vite://source/{package}?path={path}", {
-    list: void 0,
-    complete: {
-      package: () => packageIds
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
     }
   });
-  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) => {
+  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: z.object({
+      ...connectionInputSchema,
+      withData: z.boolean().optional()
+    })
+  }, async ({ withData, ...connection }) => {
     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
+      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 {
-        contents: [{
-          uri: uri.toString(),
-          mimeType: "text/plain",
-          text: content
-        }]
-      };
+      return toToolResult(result);
     } catch (error) {
-      return {
-        contents: [{
-          uri: uri.toString(),
-          mimeType: "text/plain",
-          text: `[resource-error] ${normalizeErrorMessage(error)}`
-        }]
-      };
+      return toToolError(error);
     }
   });
-}
-
-const DEFAULT_SCREENSHOT_TIMEOUT = 6e4;
-const SCREENSHOT_RETRY_DELAY = 500;
-const connectionSchema$1 = 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(),
-  port: z.number().int().positive().optional(),
-  preferOpenedSession: z.boolean().optional(),
-  preserveProjectRoot: z.boolean().optional(),
-  sessionId: z.string().trim().min(1).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(),
-  port: z.number().int().positive().optional(),
-  preferOpenedSession: z.boolean().optional(),
-  preserveProjectRoot: z.boolean().optional(),
-  sessionId: z.string().trim().min(1).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);
-    const sessionKey = this.resolveSessionKey(projectPath, input);
-    this.detach(sessionKey);
-    await closeSharedMiniProgram(projectPath, input.sessionId || input.port);
-  }
-  clearLogs() {
-    this.logs.length = 0;
-  }
-  getLogs() {
-    return [...this.logs];
-  }
-  resolveProjectPath(projectPath) {
-    return resolveDevtoolsProjectPath(this.workspaceRoot, projectPath);
-  }
-  resolveWorkspacePath(filePath) {
-    return resolveDevtoolsWorkspacePath(this.workspaceRoot, filePath);
-  }
-  async withMiniProgram(input, runner) {
-    const projectPath = this.resolveProjectPath(input.projectPath);
-    const miniProgram = await acquireSharedMiniProgram(this.runtimeHooks, {
-      port: input.port,
-      projectPath,
-      sessionId: input.sessionId,
-      timeout: input.timeout,
-      preferOpenedSession: input.preferOpenedSession,
-      preserveProjectRoot: input.preserveProjectRoot ?? true,
-      sharedSession: true
-    });
-    const sessionKey = this.resolveSessionKey(projectPath, input);
-    this.attach(sessionKey, miniProgram);
+  server.registerTool("weapp_devtools_page_stack", {
+    title: "Mini Program Page Stack",
+    description: "\u83B7\u53D6\u5F53\u524D\u5C0F\u7A0B\u5E8F\u9875\u9762\u6808\u3002",
+    inputSchema: connectionSchema$1
+  }, async (connection) => {
     try {
-      return await runner(miniProgram);
-    } finally {
-      releaseSharedMiniProgram(projectPath, input.sessionId || input.port);
-    }
-  }
-  async withPage(input, runner) {
-    const projectPath = this.resolveProjectPath(input.projectPath);
-    const sessionKey = this.resolveSessionKey(projectPath, input);
-    return await this.withMiniProgram(input, async (miniProgram) => {
-      const page = await this.resolveCurrentPage(sessionKey, miniProgram);
-      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);
-    });
-  }
-  rememberPage(input, page) {
-    if (!page) {
-      return;
-    }
-    const projectPath = this.resolveProjectPath(input.projectPath);
-    const sessionKey = this.resolveSessionKey(projectPath, input);
-    this.attachedSessions.get(sessionKey).currentPage = page;
-  }
-  resolveSessionKey(projectPath, input) {
-    return resolveSharedMiniProgramSessionKey({
-      port: input.port,
-      projectPath,
-      sessionId: input.sessionId
-    });
-  }
-  attach(sessionKey, miniProgram) {
-    const existing = this.attachedSessions.get(sessionKey);
-    if (existing?.miniProgram === miniProgram) {
-      return;
+      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);
     }
-    this.detach(sessionKey);
-    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(sessionKey, {
-      miniProgram,
-      onConsole,
-      onException
-    });
-  }
-  async resolveCurrentPage(sessionKey, miniProgram) {
+  });
+  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: z.object(screenshotSchema)
+  }, async ({ outputPath, ...connection }) => {
     try {
-      const page = await miniProgram.currentPage();
-      this.attachedSessions.get(sessionKey).currentPage = page;
-      return page;
+      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+        const buffer = await captureMiniProgramScreenshot(
+          miniProgram,
+          connection.timeout ?? DEFAULT_SCREENSHOT_TIMEOUT
+        );
+        if (outputPath) {
+          const resolvedOutputPath = manager.resolveWorkspacePath(outputPath);
+          await fs.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+          await fs.writeFile(resolvedOutputPath, buffer);
+          return {
+            path: resolvedOutputPath,
+            bytes: buffer.length
+          };
+        }
+        return {
+          base64: buffer.toString("base64"),
+          bytes: buffer.length
+        };
+      });
+      return toToolResult(result);
     } catch (error) {
-      const cachedPage = this.attachedSessions.get(sessionKey)?.currentPage;
-      if (cachedPage && isCurrentPageRecoverableError(error)) {
-        return cachedPage;
-      }
-      throw error;
-    }
-  }
-  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);
+      return toToolError(error);
     }
-    this.attachedSessions.delete(projectPath);
-  }
-  pushLog(entry) {
-    this.logs.push(entry);
-    while (this.logs.length > this.maxLogs) {
-      this.logs.shift();
+  });
+  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: z.object(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);
     }
-  }
-}
-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 sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isCaptureScreenshotProtocolTimeout(error) {
-  return error instanceof Error && "code" in error && error.code === "DEVTOOLS_PROTOCOL_TIMEOUT" && "method" in error && error.method === "App.captureScreenshot";
-}
-function isCurrentPageRecoverableError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  if ("code" in error && error.code === "DEVTOOLS_PROTOCOL_TIMEOUT" && "method" in error) {
-    return error.method === "App.getCurrentPage" || error.method === "App.getPageStack" || error.method === "App.callFunction";
-  }
-  return error.message.includes("page is not on top of page stack");
-}
-async function captureMiniProgramScreenshot(miniProgram, timeout = DEFAULT_SCREENSHOT_TIMEOUT) {
-  let lastError;
-  for (let attempt = 1; attempt <= 2; attempt += 1) {
+  });
+  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: z.object({
+      clear: z.boolean().optional()
+    })
+  }, async ({ clear }) => {
     try {
-      const screenshot = await miniProgram.screenshot({ timeout });
-      if (screenshot == null) {
-        throw new Error("DevTools screenshot returned no data.");
+      const logs = manager.getLogs();
+      if (clear) {
+        manager.clearLogs();
       }
-      return typeof screenshot === "string" ? Buffer.from(screenshot, "base64") : Buffer.from(screenshot);
+      return toToolResult({
+        count: logs.length,
+        logs
+      });
     } catch (error) {
-      lastError = error;
-      if (!isCaptureScreenshotProtocolTimeout(error) || attempt === 2) {
-        throw error;
-      }
-      await miniProgram.currentPage().catch(() => void 0);
-      await sleep(SCREENSHOT_RETRY_DELAY);
-    }
-  }
-  throw lastError;
-}
-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, queryOptions) {
-  const { selector, index } = parseSelectorWithIndex(selectorInput);
-  let element;
-  if (index === void 0) {
-    element = await page.$(selector, queryOptions);
-  } else {
-    const elements = await queryElements(page, selector, queryOptions);
-    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 toToolError(error);
     }
-    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, queryOptions) {
-  const { selector, index } = parseSelectorWithIndex(selectorInput);
-  const elements = await callOptionalMethod(page, "$$", selector, queryOptions);
-  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, markup] = await Promise.all([
-    callMaybe(element, "text"),
-    callMaybe(element, "value"),
-    callMaybe(element, "size"),
-    callMaybe(element, "offset"),
-    callMaybe(element, "scrollWidth"),
-    callMaybe(element, "scrollHeight"),
-    withWxml ? readElementMarkup(element).catch(() => null) : Promise.resolve(null)
-  ]);
-  return compactObject({
-    tagName: readProperty(element, "tagName"),
-    text,
-    value,
-    size,
-    offset,
-    scrollWidth,
-    scrollHeight,
-    outerWxml: withWxml && markup?.type === "outerWxml" ? markup.wxml : null,
-    wxml: withWxml && markup?.type !== "outerWxml" ? markup?.wxml ?? null : void 0,
-    wxmlType: withWxml ? markup?.type ?? null : void 0
   });
 }
-async function readElementMarkup(element, outer = false) {
-  if (outer) {
-    const outerWxml = await callMaybe(element, "outerWxml");
-    if (typeof outerWxml === "string") {
-      return {
-        type: "outerWxml",
-        wxml: outerWxml
-      };
-    }
-  }
-  const wxml = await callRequiredMethod(element, "wxml");
-  return {
-    type: outer ? "wxml-fallback" : "wxml",
-    wxml: typeof wxml === "string" ? wxml : String(wxml ?? "")
-  };
-}
-function toSerializableValue(value) {
-  return toDevtoolsSerializableValue(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 = {
+const elementSelectorSchema = {
   ...connectionInputSchema,
-  method: z.string().trim().min(1),
-  args: z.array(z.unknown()).optional()
+  selector: z.string().trim().min(1),
+  innerSelector: z.string().trim().min(1).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",
+const nativeElementQuery = { fallback: false };
+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: z.object({
-      ...connectionInputSchema,
-      reconnect: z.boolean().optional()
+      ...elementSelectorSchema,
+      waitMs: z.number().int().nonnegative().optional()
     })
-  }, async ({ reconnect, ...connection }) => {
+  }, async ({ selector, innerSelector, waitMs, ...connection }) => {
     try {
-      if (reconnect) {
-        await manager.close(connection);
-      }
-      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
-        const page = await miniProgram.currentPage().catch(() => null);
-        manager.rememberPage(connection, page);
-        const systemInfo = await miniProgram.systemInfo().catch(() => null);
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector, nativeElementQuery);
+        await element.tap();
+        if (waitMs) {
+          await page.waitFor(waitMs);
+        }
         return {
-          connected: true,
-          projectPath: connection.projectPath,
-          resolvedProjectPath: manager.resolveProjectPath(connection.projectPath),
-          currentPage: page ? { path: page.path, query: toSerializableValue(page.query) } : null,
-          systemInfo: toSerializableValue(systemInfo)
+          selector,
+          innerSelector: innerSelector ?? null,
+          waitedMs: waitMs ?? 0
         };
       });
       return toToolResult(result);
@@ -1046,41 +719,22 @@ function registerDevtoolsRuntimeTools(server, manager) {
       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: z.object(navigateSchema)
-  }, async ({ path: pagePath, query, transition = "navigateTo", waitMs, ...connection }) => {
+  server.registerTool("weapp_runtime_input_node", {
+    title: "Input Element Text",
+    description: "\u5411 input \u6216 textarea \u5143\u7D20\u8F93\u5165\u6587\u672C\u3002",
+    inputSchema: z.object({
+      ...elementSelectorSchema,
+      value: z.union([z.string(), z.number()])
+    })
+  }, async ({ selector, innerSelector, value, ...connection }) => {
     try {
-      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
-        if (transition === "navigateBack") {
-          const page2 = await miniProgram.navigateBack();
-          manager.rememberPage(connection, page2);
-          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
-        );
-        manager.rememberPage(connection, page);
-        if (waitMs && page) {
-          await page.waitFor(waitMs);
-        }
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await resolveElement(page, selector, innerSelector, nativeElementQuery);
+        await callRequiredMethod(element, "input", String(value));
         return {
-          transition,
-          url,
-          activePage: page ? { path: page.path, query: toSerializableValue(page.query) } : null
+          selector,
+          innerSelector: innerSelector ?? null,
+          value: String(value)
         };
       });
       return toToolResult(result);
@@ -1088,200 +742,26 @@ function registerDevtoolsRuntimeTools(server, manager) {
       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",
+  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: z.object({
-      ...connectionInputSchema,
-      withData: z.boolean().optional()
+      ...elementSelectorSchema,
+      method: z.string().trim().min(1),
+      args: z.array(z.unknown()).optional()
     })
-  }, async ({ withData, ...connection }) => {
+  }, async ({ selector, innerSelector, method, args, ...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: connectionSchema$1
-  }, 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: z.object(screenshotSchema)
-  }, async ({ outputPath, ...connection }) => {
-    try {
-      const result = await manager.withMiniProgram(connection, async (miniProgram) => {
-        const buffer = await captureMiniProgramScreenshot(
-          miniProgram,
-          connection.timeout ?? DEFAULT_SCREENSHOT_TIMEOUT
-        );
-        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: z.object(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: z.object({
-      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()
-};
-const nativeElementQuery = { fallback: false };
-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: z.object({
-      ...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, nativeElementQuery);
-        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: z.object({
-      ...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, nativeElementQuery);
-        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: z.object({
-      ...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, nativeElementQuery);
-        const callArgs = args ?? [];
-        return {
-          selector,
-          innerSelector: innerSelector ?? null,
-          method,
-          args: toSerializableValue(callArgs),
-          result: toSerializableValue(await callRequiredMethod(element, "callMethod", method, ...callArgs))
-        };
+        const element = await resolveElement(page, selector, innerSelector, nativeElementQuery);
+        const callArgs = args ?? [];
+        return {
+          selector,
+          innerSelector: innerSelector ?? null,
+          method,
+          args: toSerializableValue(callArgs),
+          result: toSerializableValue(await callRequiredMethod(element, "callMethod", method, ...callArgs))
+        };
       });
       return toToolResult(result);
     } catch (error) {
@@ -1567,198 +1047,900 @@ function registerRuntimePageTools(server, manager) {
       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: z.object({
-      ...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_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: z.object({
+      ...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_find_node_by_xpath", {
+    title: "Get Page Element by XPath",
+    description: "\u901A\u8FC7 XPath \u83B7\u53D6\u5F53\u524D\u9875\u9762\u7B2C\u4E00\u4E2A\u5339\u914D\u5143\u7D20\uFF0C\u9002\u5408\u6309\u6587\u672C\u3001\u5C5E\u6027\u6216\u5C42\u7EA7\u5173\u7CFB\u5B9A\u4F4D\u3002",
+    inputSchema: z.object(xpathSchema)
+  }, async ({ xpath, withWxml, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const element = await callRequiredMethod(page, "getElementByXpath", xpath);
+        if (!element) {
+          throw new Error(`XPath \u672A\u627E\u5230\u5143\u7D20: "${xpath}"`);
+        }
+        return {
+          xpath,
+          ...await summarizeElement(element, withWxml)
+        };
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("weapp_runtime_find_nodes_by_xpath", {
+    title: "Get Page Elements by XPath",
+    description: "\u901A\u8FC7 XPath \u83B7\u53D6\u5F53\u524D\u9875\u9762\u5168\u90E8\u5339\u914D\u5143\u7D20\uFF0C\u9002\u5408\u6279\u91CF\u68C0\u67E5\u7ED3\u6784\u4E0E\u5185\u5BB9\u3002",
+    inputSchema: z.object(xpathSchema)
+  }, async ({ xpath, withWxml, ...connection }) => {
+    try {
+      const result = await manager.withPage(connection, async (page) => {
+        const elements = await callRequiredMethod(page, "getElementsByXpath", xpath);
+        return {
+          xpath,
+          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: z.object({
+      ...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: z.object({
+      ...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: z.object({
+      ...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: z.object({
+      ...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: z.object({
+      ...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, "callMethod", 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;
+}
+
+function acceptanceRuntime(parent) {
+  return async (_server, context) => {
+    const lease = await acquireRuntimeLease(context.root);
+    const manager = parent.fork(context.root);
+    const cursor = manager.getLogCursor();
+    const tools = [];
+    try {
+      const collector = {
+        registerTool(name, definition, handler) {
+          const shape = definition.inputSchema;
+          const schema = shape && typeof shape.parse === "function" ? shape : z.object(shape ?? {});
+          tools.push({ name: `weapp__${name}`, description: definition.description ?? name, schema, mutates: true, async execute(input) {
+            context.signal.throwIfAborted();
+            return runWithRuntimeLease(lease, async () => {
+              if (name === "weapp_devtools_console") {
+                const result = { logs: manager.getLogs(context.root, cursor) };
+                return { text: JSON.stringify({ result }), data: { result } };
+              }
+              const parsed = schema.parse(input);
+              if (name === "weapp_devtools_connect") {
+                await manager.prepareProject(context.root, context.signal);
+                context.signal.throwIfAborted();
+                await parent.withMiniProgram(parsed, async () => {
+                });
+              }
+              context.signal.throwIfAborted();
+              const response = await handler(parsed);
+              if (response.isError) {
+                throw new Error(JSON.stringify(response.content));
+              }
+              const text = response.content?.filter((c) => c.type === "text").map((c) => c.text).join("\n") ?? "";
+              return { text, data: response.structuredContent ?? JSON.parse(text) };
+            });
+          } });
+          return {};
+        }
+      };
+      registerRuntimeTools(collector, { manager, workspaceRoot: context.root });
+      return { tools, close: async () => {
+        try {
+          await manager.dispose();
+        } finally {
+          await lease.release();
+        }
+      } };
+    } catch (error) {
+      try {
+        await manager.dispose();
+      } finally {
+        await lease.release();
+      }
+      throw error;
+    }
+  };
+}
+async function createRuntimeAcceptanceService(root, options = {}, hooks) {
+  const manager = new RuntimeSessionManager(root, hooks);
+  const service = await AcceptanceService.create(root, { ...options, connect: options.connect ?? acceptanceRuntime(manager) });
+  const close = service.close.bind(service);
+  service.close = async () => {
+    try {
+      await close();
+    } finally {
+      await manager.dispose();
+    }
+  };
+  return service;
+}
+
+const MCP_SERVER_NAME = "@weapp-vite/mcp";
+const MCP_SERVER_VERSION = "2.0.0";
+const EXPOSED_PACKAGES = {
+  "weapp-vite": {
+    id: "weapp-vite",
+    label: "weapp-vite",
+    packageName: "weapp-vite",
+    relativePath: path.join("packages", "weapp-vite")
+  },
+  "wevu": {
+    id: "wevu",
+    label: "wevu",
+    packageName: "wevu",
+    relativePath: path.join("packages-runtime", "wevu")
+  },
+  "wevu-compiler": {
+    id: "wevu-compiler",
+    label: "wevu-compiler",
+    packageName: "@wevu/compiler",
+    relativePath: path.join("packages-runtime", "wevu-compiler")
+  }
+};
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_MAX_OUTPUT_CHARS = 12e4;
+const DEFAULT_MAX_FILE_CHARS = 8e4;
+const DEFAULT_MAX_RESULTS = 200;
+const SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".turbo",
+  "dist",
+  "coverage"
+]);
+
+function hasWorkspaceMarkers(dir) {
+  return fs$1.existsSync(path.join(dir, "pnpm-workspace.yaml")) && fs$1.existsSync(path.join(dir, "package.json"));
+}
+function resolveWorkspaceRoot(start = process.cwd()) {
+  let current = path.resolve(start);
+  while (true) {
+    if (hasWorkspaceMarkers(current)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return path.resolve(start);
+    }
+    current = parent;
+  }
+}
+function assertInsideRoot(root, targetPath) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedTarget = path.resolve(targetPath);
+  const relative = path.relative(resolvedRoot, resolvedTarget);
+  if (relative === "" || relative === ".") {
+    return resolvedTarget;
+  }
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${targetPath}`);
+  }
+  return resolvedTarget;
+}
+function resolveSubPath(root, relativePath) {
+  if (!relativePath || relativePath === ".") {
+    return path.resolve(root);
+  }
+  if (path.isAbsolute(relativePath)) {
+    throw new Error("\u4EC5\u652F\u6301\u76F8\u5BF9\u8DEF\u5F84");
+  }
+  return assertInsideRoot(root, path.resolve(root, relativePath));
+}
+
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function toWorkspaceRelativePath(workspaceRoot, absolutePath) {
+  const [realWorkspaceRoot, realAbsolutePath] = await Promise.all([
+    fs.realpath(workspaceRoot),
+    fs.realpath(absolutePath)
+  ]);
+  const relativePath = path.relative(realWorkspaceRoot, realAbsolutePath);
+  if (!relativePath || relativePath === ".") {
+    return ".";
+  }
+  return relativePath;
+}
+async function readPackageJson(filePath) {
+  const content = await fs.readFile(filePath, "utf8");
+  return JSON.parse(content);
+}
+function createWorkspaceRequire(workspaceRoot) {
+  return createRequire(path.join(workspaceRoot, "__weapp_vite_mcp__.cjs"));
+}
+async function resolveMonorepoPackage(workspaceRoot, id) {
+  const config = EXPOSED_PACKAGES[id];
+  const absolutePath = assertInsideRoot(workspaceRoot, path.join(workspaceRoot, config.relativePath));
+  const packageJsonPath = path.join(absolutePath, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return void 0;
+  }
+  const packageJson = await readPackageJson(packageJsonPath);
+  const readmePath = path.join(absolutePath, "README.md");
+  const changelogPath = path.join(absolutePath, "CHANGELOG.md");
+  const sourceRoot = await pathExists(path.join(absolutePath, "src")) ? absolutePath : void 0;
+  const cliPath = id === "weapp-vite" ? await pathExists(path.join(absolutePath, "bin", "weapp-vite.js")) ? path.join(absolutePath, "bin", "weapp-vite.js") : void 0 : void 0;
+  return {
+    id,
+    label: config.label,
+    packageName: packageJson.name ?? config.packageName,
+    version: packageJson.version ?? "0.0.0",
+    absolutePath,
+    relativePath: config.relativePath,
+    scripts: Object.keys(packageJson.scripts ?? {}),
+    docs: {
+      readme: await pathExists(readmePath) ? readmePath : void 0,
+      changelog: await pathExists(changelogPath) ? changelogPath : void 0
+    },
+    sourceRoot,
+    cliPath
+  };
+}
+async function resolveInstalledPackage(workspaceRoot, id) {
+  const config = EXPOSED_PACKAGES[id];
+  const workspaceRequire = createWorkspaceRequire(workspaceRoot);
+  let packageJsonPath;
+  try {
+    packageJsonPath = workspaceRequire.resolve(`${config.packageName}/package.json`);
+  } catch {
+    return void 0;
+  }
+  const absolutePath = path.dirname(packageJsonPath);
+  const relativePath = await toWorkspaceRelativePath(workspaceRoot, absolutePath);
+  const packageJson = await readPackageJson(packageJsonPath);
+  const docsRoot = path.join(absolutePath, "dist", "docs");
+  const installedReadmePath = path.join(docsRoot, "README.md");
+  const installedChangelogPath = path.join(docsRoot, "CHANGELOG.md");
+  const sourceRoot = await pathExists(path.join(absolutePath, "src")) ? absolutePath : void 0;
+  let cliPath;
+  if (id === "weapp-vite") {
+    const binEntry = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.["weapp-vite"];
+    if (typeof binEntry === "string" && binEntry.trim()) {
+      const resolvedCliPath = path.resolve(absolutePath, binEntry);
+      if (await pathExists(resolvedCliPath)) {
+        cliPath = resolvedCliPath;
+      }
+    }
+  }
+  return {
+    id,
+    label: config.label,
+    packageName: packageJson.name ?? config.packageName,
+    version: packageJson.version ?? "0.0.0",
+    absolutePath,
+    relativePath,
+    scripts: Object.keys(packageJson.scripts ?? {}),
+    docs: {
+      readme: await pathExists(installedReadmePath) ? installedReadmePath : void 0,
+      changelog: await pathExists(installedChangelogPath) ? installedChangelogPath : void 0
+    },
+    sourceRoot,
+    cliPath
+  };
+}
+async function resolveExposedPackage(workspaceRoot, id) {
+  return await resolveMonorepoPackage(workspaceRoot, id) ?? await resolveInstalledPackage(workspaceRoot, id) ?? Promise.reject(new Error(`\u672A\u627E\u5230\u66B4\u9732\u5305\uFF1A${id}`));
+}
+async function resolveExposedPackages(workspaceRoot) {
+  const resolved = await Promise.allSettled(
+    Object.keys(EXPOSED_PACKAGES).map((id) => resolveExposedPackage(workspaceRoot, id))
+  );
+  return resolved.flatMap((result) => {
+    if (result.status === "fulfilled") {
+      return [result.value];
+    }
+    return [];
+  }).sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function registerAcceptanceTools(server, service) {
+  const json = (data) => {
+    const structuredContent = redactValue(data);
+    return { content: [{ type: "text", text: JSON.stringify(structuredContent) }], structuredContent };
+  };
+  const guarded = (fn) => async (args) => {
+    try {
+      return await fn(args);
+    } catch (error) {
+      return { isError: true, content: [{ type: "text", text: redactor()(error instanceof Error ? error.message : String(error)) }] };
+    }
+  };
+  const jobId = z.uuid();
+  server.registerTool("weapp_project_inspect", {
+    description: "Inspect mini-program support, configured acceptance and missing prerequisites. No model or runtime startup.",
+    inputSchema: z.object({}),
+    annotations: { readOnlyHint: true }
+  }, guarded(async () => json(await (await service()).inspect())));
+  server.registerTool("weapp_acceptance_start", {
+    description: "Start configured checks and deterministic WeChat DevTools scenarios. Returns a jobId immediately. Requires previously reviewed project trust; no model calls or code edits.",
+    inputSchema: z.object({}),
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
+  }, guarded(async () => json(await (await service()).start())));
+  server.registerTool("weapp_acceptance_status", {
+    description: "Get current acceptance progress and source freshness. Poll until status is no longer running.",
+    inputSchema: z.object({ jobId }),
+    annotations: { readOnlyHint: true }
+  }, guarded(async ({ jobId: jobId2 }) => {
+    const report = await (await service()).report(jobId2);
+    return json({ version: report.version, jobId: jobId2, status: report.status, passed: report.passed, snapshot: report.snapshot, checks: report.checks.map(({ output: _output, ...check }) => check), lastStep: report.steps.at(-1), reason: report.reason });
+  }));
+  server.registerTool("weapp_acceptance_cancel", {
+    description: "Cancel an acceptance task owned by this server. Completed interactions are not undone or replayed.",
+    inputSchema: z.object({ jobId }),
+    annotations: { readOnlyHint: false, idempotentHint: true }
+  }, guarded(async ({ jobId: jobId2 }) => json(await (await service()).cancel(jobId2))));
+  server.registerTool("weapp_acceptance_report", {
+    description: "Read the version 2 acceptance report, or one named screenshot/console artifact from that report. Evidence may be stale; inspect snapshot.stale before claiming success.",
+    inputSchema: z.object({ jobId, artifact: z.string().optional() }),
+    annotations: { readOnlyHint: true }
+  }, guarded(async ({ jobId: jobId2, artifact }) => {
+    if (!artifact) {
+      return json(await (await service()).report(jobId2));
+    }
+    const result = await (await service()).artifact(jobId2, artifact);
+    const report = await (await service()).report(jobId2);
+    return {
+      ...json({ jobId: jobId2, artifact, status: report.status, stale: report.snapshot.stale }),
+      content: [
+        { type: "text", text: JSON.stringify({ jobId: jobId2, artifact, status: report.status, stale: report.snapshot.stale }) },
+        result.mediaType === "image/png" ? { type: "image", data: result.data, mimeType: result.mediaType } : { type: "text", text: result.data }
+      ]
+    };
+  }));
+  return server;
+}
+
+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: z.object({
+      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: z.object({
+      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: z.object({
+      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: z.object({
+      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 walkFilesRecursive(root, current, output, maxResults) {
+  if (output.length >= maxResults) {
+    return;
+  }
+  const entries = await fs.readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    if (output.length >= maxResults) {
+      return;
+    }
+    if (entry.isDirectory()) {
+      if (SKIPPED_DIR_NAMES.has(entry.name)) {
+        continue;
+      }
+      await walkFilesRecursive(root, path.join(current, entry.name), output, maxResults);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const absolutePath = path.join(current, entry.name);
+    const relativePath = path.relative(root, absolutePath).split(path.sep).join("/");
+    output.push(relativePath);
+  }
+}
+async function listFilesInDirectory(root, relativeDirectory = ".", maxResults = DEFAULT_MAX_RESULTS) {
+  const dirPath = resolveSubPath(root, relativeDirectory);
+  const files = [];
+  await walkFilesRecursive(root, dirPath, files, maxResults);
+  return files;
+}
+function sliceLines(content, startLine, endLine) {
+  if (!startLine && !endLine) {
+    return content;
+  }
+  const lines = content.split("\n");
+  const safeStart = Math.max(1, startLine ?? 1);
+  const safeEnd = Math.max(safeStart, endLine ?? lines.length);
+  return lines.slice(safeStart - 1, safeEnd).join("\n");
+}
+async function readFileContent(root, relativeFilePath, options) {
+  const filePath = assertInsideRoot(root, path.join(root, relativeFilePath));
+  const content = await fs.readFile(filePath, "utf8");
+  const selected = sliceLines(content, options?.startLine, options?.endLine);
+  const maxChars = options?.maxChars ?? DEFAULT_MAX_FILE_CHARS;
+  const clipped = selected.length > maxChars ? `${selected.slice(0, maxChars)}
+
+[truncated: ${selected.length - maxChars} chars omitted]` : selected;
+  return {
+    filePath,
+    content: clipped
+  };
+}
+function collectMatchesFromText(query, relativeFilePath, content, maxResults, output) {
+  const lines = content.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    if (output.length >= maxResults) {
+      return;
+    }
+    const lineText = lines[index] ?? "";
+    const column = lineText.toLowerCase().indexOf(query.toLowerCase());
+    if (column === -1) {
+      continue;
+    }
+    output.push({
+      filePath: relativeFilePath,
+      line: index + 1,
+      column: column + 1,
+      text: lineText.trim()
+    });
+  }
+}
+async function searchTextInDirectory(root, query, options) {
+  const maxResults = options?.maxResults ?? DEFAULT_MAX_RESULTS;
+  const files = await listFilesInDirectory(root, options?.relativeDirectory ?? ".", Math.max(400, maxResults));
+  const matches = [];
+  for (const file of files) {
+    if (matches.length >= maxResults) {
+      break;
+    }
+    const absolutePath = path.join(root, file);
+    let content = "";
+    try {
+      content = await fs.readFile(absolutePath, "utf8");
+    } catch {
+      continue;
+    }
+    collectMatchesFromText(query, file, content, maxResults, matches);
+  }
+  return matches;
+}
+
+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) {
+    throw new Error(`\u5F53\u524D\u5DE5\u4F5C\u533A\u4E2D\u7684 ${packageId} \u4E0D\u5305\u542B\u6E90\u7801\u76EE\u5F55\uFF0C\u8BF7\u6539\u4E3A\u4F18\u5148\u8BFB\u53D6\u672C\u5730\u968F\u5305\u6587\u6863\u3002`);
+  }
+  return assertInsideRoot(workspaceRoot, resolved.sourceRoot);
+}
+function toDocsUri(packageId, fileName) {
+  return `weapp-vite://docs/${packageId}/${fileName}`;
+}
+async function readTextFile(filePath) {
+  return fs.readFile(filePath, "utf8");
+}
+async function runWeappViteCliTool(workspaceRoot, input) {
+  const cliPath = (await resolveExposedPackage(workspaceRoot, "weapp-vite")).cliPath;
+  if (!cliPath) {
+    throw new Error("\u5F53\u524D\u5DE5\u4F5C\u533A\u4E2D\u7684 weapp-vite \u672A\u66B4\u9732 CLI \u5165\u53E3");
+  }
+  const finalArgs = [cliPath, input.subCommand];
+  if (input.projectPath) {
+    finalArgs.push(resolveSubPath(workspaceRoot, input.projectPath));
+  }
+  if (input.platform) {
+    finalArgs.push("--platform", input.platform);
+  }
+  if (Array.isArray(input.args) && input.args.length > 0) {
+    finalArgs.push(...input.args);
+  }
+  return runCommand(workspaceRoot, "node", finalArgs, {
+    timeoutMs: input.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  });
+}
+
+function registerServerResources(server, options) {
+  const { workspaceRoot, packageIds, exposedPackages } = 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 catalog = await resolveExposedPackages(workspaceRoot);
+    const text = JSON.stringify({ workspaceRoot, packages: catalog }, null, 2);
+    return {
+      contents: [{
+        uri: "weapp-vite://workspace/catalog",
+        mimeType: "application/json",
+        text
+      }]
+    };
   });
-  server.registerTool("weapp_runtime_find_node_by_xpath", {
-    title: "Get Page Element by XPath",
-    description: "\u901A\u8FC7 XPath \u83B7\u53D6\u5F53\u524D\u9875\u9762\u7B2C\u4E00\u4E2A\u5339\u914D\u5143\u7D20\uFF0C\u9002\u5408\u6309\u6587\u672C\u3001\u5C5E\u6027\u6216\u5C42\u7EA7\u5173\u7CFB\u5B9A\u4F4D\u3002",
-    inputSchema: z.object(xpathSchema)
-  }, async ({ xpath, withWxml, ...connection }) => {
-    try {
-      const result = await manager.withPage(connection, async (page) => {
-        const element = await callRequiredMethod(page, "getElementByXpath", xpath);
-        if (!element) {
-          throw new Error(`XPath \u672A\u627E\u5230\u5143\u7D20: "${xpath}"`);
-        }
+  for (const summary of exposedPackages) {
+    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 {
-          xpath,
-          ...await summarizeElement(element, withWxml)
+          contents: [{ uri, mimeType: "text/markdown", text }]
         };
       });
-      return toToolResult(result);
-    } catch (error) {
-      return toToolError(error);
     }
-  });
-  server.registerTool("weapp_runtime_find_nodes_by_xpath", {
-    title: "Get Page Elements by XPath",
-    description: "\u901A\u8FC7 XPath \u83B7\u53D6\u5F53\u524D\u9875\u9762\u5168\u90E8\u5339\u914D\u5143\u7D20\uFF0C\u9002\u5408\u6279\u91CF\u68C0\u67E5\u7ED3\u6784\u4E0E\u5185\u5BB9\u3002",
-    inputSchema: z.object(xpathSchema)
-  }, async ({ xpath, withWxml, ...connection }) => {
-    try {
-      const result = await manager.withPage(connection, async (page) => {
-        const elements = await callRequiredMethod(page, "getElementsByXpath", xpath);
+    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 {
-          xpath,
-          count: elements.length,
-          elements: await Promise.all(elements.map(async (element, index) => ({
-            index,
-            ...await summarizeElement(element, withWxml)
-          })))
+          contents: [{ uri, mimeType: "text/markdown", text }]
         };
       });
-      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: z.object({
-      ...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: z.object({
-      ...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: z.object({
-      ...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: z.object({
-      ...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);
+  }
+  const sourceTemplate = new ResourceTemplate("weapp-vite://source/{package}?path={path}", {
+    list: void 0,
+    complete: {
+      package: () => packageIds
     }
   });
-  server.registerTool("weapp_runtime_invoke_page", {
-    title: "Call Page Method",
-    description: "\u8C03\u7528\u5F53\u524D\u9875\u9762\u5B9E\u4F8B\u65B9\u6CD5\u3002",
-    inputSchema: z.object({
-      ...connectionInputSchema,
-      method: z.string().trim().min(1),
-      args: z.array(z.unknown()).optional()
-    })
-  }, async ({ method, args, ...connection }) => {
+  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 result = await manager.withPage(connection, async (page) => {
-        const callArgs = args ?? [];
-        return {
-          method,
-          args: toSerializableValue(callArgs),
-          result: toSerializableValue(await callRequiredMethod(page, "callMethod", method, ...callArgs))
-        };
+      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 toToolResult(result);
+      return {
+        contents: [{
+          uri: uri.toString(),
+          mimeType: "text/plain",
+          text: content
+        }]
+      };
     } catch (error) {
-      return toToolError(error);
+      return {
+        contents: [{
+          uri: uri.toString(),
+          mimeType: "text/plain",
+          text: `[resource-error] ${normalizeErrorMessage(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);
 }
@@ -2041,9 +2223,28 @@ const packageIds = Object.keys(EXPOSED_PACKAGES);
 const packageIdSchema = z.enum(packageIds);
 async function createWeappViteMcpServerFactory(options) {
   const workspaceRoot = resolveWorkspaceRoot(options?.workspaceRoot);
+  const acceptanceRoot = path.resolve(options?.workspaceRoot ?? process.cwd());
   const exposedPackages = await resolveExposedPackages(workspaceRoot);
   const runtimeManager = new RuntimeSessionManager(workspaceRoot, options?.runtimeHooks);
+  let closed = false;
+  let acceptance;
+  const getAcceptance = () => {
+    if (closed) {
+      return Promise.reject(new Error("MCP service is shutting down"));
+    }
+    return acceptance ??= AcceptanceService.create(acceptanceRoot, { connect: acceptanceRuntime(runtimeManager) });
+  };
   return {
+    close: async () => {
+      closed = true;
+      try {
+        if (acceptance) {
+          await (await acceptance).close();
+        }
+      } finally {
+        await runtimeManager.dispose();
+      }
+    },
     runtimeManager,
     workspaceRoot,
     createServer: () => {
@@ -2051,6 +2252,7 @@ async function createWeappViteMcpServerFactory(options) {
         name: MCP_SERVER_NAME,
         version: MCP_SERVER_VERSION
       });
+      registerAcceptanceTools(server, getAcceptance);
       registerServerTools(server, {
         workspaceRoot,
         packageIds,
@@ -2076,18 +2278,28 @@ async function createWeappViteMcpServerFactory(options) {
 }
 async function createWeappViteMcpServer(options) {
   const factory = await createWeappViteMcpServerFactory(options);
+  const server = factory.createServer();
+  const closeProtocol = server.close.bind(server);
+  server.close = async () => {
+    try {
+      await factory.close();
+    } finally {
+      await closeProtocol();
+    }
+  };
   return {
+    close: server.close,
     runtimeManager: factory.runtimeManager,
-    server: factory.createServer(),
+    server,
     workspaceRoot: factory.workspaceRoot
   };
 }
 
-const DEFAULT_RUNTIME_REST_ENDPOINT = "/api/weapp/devtools";
 const connectionSchema = z.object({
+  cliPath: z.string().trim().min(1).optional(),
   projectPath: z.string().trim().min(1),
   timeout: z.number().int().positive().optional(),
-  port: z.number().int().positive().optional(),
+  port: z.number().int().positive().max(65535).optional(),
   preferOpenedSession: z.boolean().optional(),
   preserveProjectRoot: z.boolean().optional(),
   sessionId: z.string().trim().min(1).optional()
@@ -2166,10 +2378,12 @@ function readNumberParam(value) {
   return Number.isFinite(parsed) ? parsed : void 0;
 }
 function readConnectionFromQuery(url) {
+  const rawPort = url.searchParams.get("port");
   return connectionSchema.parse(compactObject({
     projectPath: url.searchParams.get("projectPath") ?? void 0,
+    cliPath: url.searchParams.get("cliPath") ?? void 0,
     timeout: readNumberParam(url.searchParams.get("timeout")),
-    port: readNumberParam(url.searchParams.get("port")),
+    port: rawPort === null ? void 0 : /^\d+$/.test(rawPort) ? Number(rawPort) : Number.NaN,
     preferOpenedSession: readBooleanParam(url.searchParams.get("preferOpenedSession")),
     preserveProjectRoot: readBooleanParam(url.searchParams.get("preserveProjectRoot")),
     sessionId: url.searchParams.get("sessionId") ?? void 0
@@ -2335,8 +2549,8 @@ async function handleCapture(req, res, manager) {
     );
     if (input.outputPath) {
       const resolvedOutputPath = manager.resolveWorkspacePath(input.outputPath);
-      await fs$1.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
-      await fs$1.writeFile(resolvedOutputPath, buffer);
+      await fs.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+      await fs.writeFile(resolvedOutputPath, buffer);
       return {
         path: resolvedOutputPath,
         bytes: buffer.length
@@ -2417,9 +2631,6 @@ async function handleRuntimeRestRequest(req, res, options) {
   return true;
 }
 
-const DEFAULT_MCP_HOST = "127.0.0.1";
-const DEFAULT_MCP_PORT = 3088;
-const DEFAULT_MCP_ENDPOINT = "/mcp";
 function normalizeEndpoint(input) {
   const value = typeof input === "string" ? input.trim() : "";
   if (!value) {
@@ -2452,6 +2663,7 @@ async function startStdioServer(options) {
     return {
       transport: "stdio",
       close: async () => {
+        await factory.close();
         await handle.close();
       }
     };
@@ -2550,6 +2762,7 @@ async function startStreamableHttpServer(options) {
   return {
     transport: "streamable-http",
     close: async () => {
+      await factory.close();
       await mcpHandler.close();
       await new Promise((resolve, reject) => {
         httpServer.close((error) => {
@@ -2588,4 +2801,4 @@ ${message}
   });
 }
 
-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, createWeappViteMcpServerFactory, 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_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, acceptanceRuntime, assertInsideRoot, createRuntimeAcceptanceService, createWeappViteMcpServer, createWeappViteMcpServerFactory, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, registerAcceptanceTools, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };