@weapp-vite/mcp 1.3.0 → 1.3.1

package/README.md

@@ -35,6 +35,16 @@ const handle = await startWeappViteMcpServer({
 await handle.close?.()
 ```
 
+`streamable-http` 模式会同时暴露 DevTools runtime REST 接口，默认前缀为
+`/api/weapp/devtools`。可以通过 `restEndpoint` 调整，或设为 `false` 关闭：
+
+```ts
+const handle = await startWeappViteMcpServer({
+  transport: 'streamable-http',
+  restEndpoint: '/api/weapp/devtools',
+})
+```
+
 ## 主要 Tools
 
 - `workspace_catalog`: 输出 `weapp-vite / wevu / wevu-compiler` 目录、版本、脚本
@@ -66,6 +76,31 @@ await handle.close?.()
 
 建议调用顺序：先 `weapp_devtools_connect`，再 `weapp_devtools_active_page`，之后再执行 `weapp_devtools_capture` 或 `weapp_runtime_*`。
 
+### DevTools Runtime REST
+
+REST 接口和 MCP runtime tools 复用同一个 automator 会话管理器，适合脚本或其他非 MCP 客户端连续操控模拟器：
+
+- `POST /api/weapp/devtools/connect`
+- `POST /api/weapp/devtools/route`
+- `GET|POST /api/weapp/devtools/active-page`
+- `GET|POST /api/weapp/devtools/page-stack`
+- `POST /api/weapp/devtools/capture`
+- `POST /api/weapp/devtools/host-api`
+- `GET|DELETE /api/weapp/devtools/console`
+- `DELETE /api/weapp/devtools/session`
+
+示例：
+
+```bash
+curl -X POST http://127.0.0.1:3088/api/weapp/devtools/route \
+  -H 'content-type: application/json' \
+  -d '{"projectPath":"dist/build/mp-weixin","transition":"reLaunch","path":"pages/index/index"}'
+
+curl -X POST http://127.0.0.1:3088/api/weapp/devtools/capture \
+  -H 'content-type: application/json' \
+  -d '{"projectPath":"dist/build/mp-weixin","outputPath":".tmp/home.png"}'
+```
+
 ## 主要 Resources
 
 - `weapp-vite://workspace/catalog`

package/dist/index.d.mts

@@ -86,15 +86,78 @@ declare function searchTextInDirectory(root: string, query: string, options?: {
     maxResults?: number;
 }): Promise<SearchMatch[]>;
 
+interface MiniProgramElement {
+    tagName?: string;
+    $?: (selector: string) => Promise<MiniProgramElement | null>;
+    $$?: (selector: string) => Promise<MiniProgramElement[]>;
+    tap: () => Promise<void>;
+}
+interface MiniProgramPage {
+    path: string;
+    query?: unknown;
+    $: (selector: string) => Promise<MiniProgramElement | null>;
+    $$?: (selector: string) => Promise<MiniProgramElement[]>;
+    data: (path?: string) => Promise<unknown>;
+    size: () => Promise<unknown>;
+    scrollTop: () => Promise<unknown>;
+    waitFor: (milliseconds: number) => Promise<void>;
+}
+interface MiniProgramLike {
+    on: (name: 'console' | 'exception', handler: (payload: unknown) => void) => void;
+    off?: (name: 'console' | 'exception', handler: (payload: unknown) => void) => void;
+    currentPage: () => Promise<MiniProgramPage>;
+    systemInfo: () => Promise<unknown>;
+    pageStack: () => Promise<MiniProgramPage[]>;
+    navigateTo: (url: string) => Promise<MiniProgramPage>;
+    redirectTo: (url: string) => Promise<MiniProgramPage>;
+    reLaunch: (url: string) => Promise<MiniProgramPage>;
+    switchTab: (url: string) => Promise<MiniProgramPage>;
+    navigateBack: () => Promise<MiniProgramPage>;
+    screenshot: () => Promise<string | Uint8Array>;
+    callWxMethod: (method: string, ...args: unknown[]) => Promise<unknown>;
+}
+interface RuntimeConnectionInput {
+    projectPath: string;
+    timeout?: number;
+    preferOpenedSession?: boolean;
+}
+interface RuntimeConsoleLogEntry {
+    level: string;
+    message: string;
+    timestamp: number;
+    raw: unknown;
+}
+declare class RuntimeSessionManager {
+    private readonly workspaceRoot;
+    private readonly runtimeHooks;
+    private readonly logs;
+    private readonly attachedSessions;
+    private readonly maxLogs;
+    constructor(workspaceRoot: string, runtimeHooks?: DevtoolsRuntimeHooks);
+    close(input: RuntimeConnectionInput): Promise<void>;
+    clearLogs(): void;
+    getLogs(): RuntimeConsoleLogEntry[];
+    resolveProjectPath(projectPath: string): string;
+    resolveWorkspacePath(filePath: string): string;
+    withMiniProgram<T>(input: RuntimeConnectionInput, runner: (miniProgram: MiniProgramLike) => Promise<T>): Promise<T>;
+    withPage<T>(input: RuntimeConnectionInput, runner: (page: MiniProgramPage, miniProgram: MiniProgramLike) => Promise<T>): Promise<T>;
+    private attach;
+    private detach;
+    private pushLog;
+}
+
 interface CreateServerOptions {
     runtimeHooks?: DevtoolsRuntimeHooks;
     workspaceRoot?: string;
 }
 declare function createWeappViteMcpServer(options?: CreateServerOptions): Promise<{
+    runtimeManager: RuntimeSessionManager;
     server: McpServer;
     workspaceRoot: string;
 }>;
 
+declare const DEFAULT_RUNTIME_REST_ENDPOINT = "/api/weapp/devtools";
+
 declare const DEFAULT_MCP_HOST = "127.0.0.1";
 declare const DEFAULT_MCP_PORT = 3088;
 declare const DEFAULT_MCP_ENDPOINT = "/mcp";
@@ -103,6 +166,7 @@ interface StartMcpServerOptions extends CreateServerOptions {
     host?: string;
     port?: number;
     endpoint?: string;
+    restEndpoint?: string | false;
     unref?: boolean;
     quiet?: boolean;
     onReady?: (message: string) => void;
@@ -137,5 +201,5 @@ declare function resolveWorkspaceRoot(start?: string): string;
 declare function assertInsideRoot(root: string, targetPath: string): string;
 declare function resolveSubPath(root: string, relativePath: string): string;
 
-export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
+export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
 export type { CommandResult, CreateServerOptions, ExposedPackageId, ExposedPackageSummary, McpServerHandle, SearchMatch, StartMcpServerOptions };

package/dist/index.d.ts

@@ -86,15 +86,78 @@ declare function searchTextInDirectory(root: string, query: string, options?: {
     maxResults?: number;
 }): Promise<SearchMatch[]>;
 
+interface MiniProgramElement {
+    tagName?: string;
+    $?: (selector: string) => Promise<MiniProgramElement | null>;
+    $$?: (selector: string) => Promise<MiniProgramElement[]>;
+    tap: () => Promise<void>;
+}
+interface MiniProgramPage {
+    path: string;
+    query?: unknown;
+    $: (selector: string) => Promise<MiniProgramElement | null>;
+    $$?: (selector: string) => Promise<MiniProgramElement[]>;
+    data: (path?: string) => Promise<unknown>;
+    size: () => Promise<unknown>;
+    scrollTop: () => Promise<unknown>;
+    waitFor: (milliseconds: number) => Promise<void>;
+}
+interface MiniProgramLike {
+    on: (name: 'console' | 'exception', handler: (payload: unknown) => void) => void;
+    off?: (name: 'console' | 'exception', handler: (payload: unknown) => void) => void;
+    currentPage: () => Promise<MiniProgramPage>;
+    systemInfo: () => Promise<unknown>;
+    pageStack: () => Promise<MiniProgramPage[]>;
+    navigateTo: (url: string) => Promise<MiniProgramPage>;
+    redirectTo: (url: string) => Promise<MiniProgramPage>;
+    reLaunch: (url: string) => Promise<MiniProgramPage>;
+    switchTab: (url: string) => Promise<MiniProgramPage>;
+    navigateBack: () => Promise<MiniProgramPage>;
+    screenshot: () => Promise<string | Uint8Array>;
+    callWxMethod: (method: string, ...args: unknown[]) => Promise<unknown>;
+}
+interface RuntimeConnectionInput {
+    projectPath: string;
+    timeout?: number;
+    preferOpenedSession?: boolean;
+}
+interface RuntimeConsoleLogEntry {
+    level: string;
+    message: string;
+    timestamp: number;
+    raw: unknown;
+}
+declare class RuntimeSessionManager {
+    private readonly workspaceRoot;
+    private readonly runtimeHooks;
+    private readonly logs;
+    private readonly attachedSessions;
+    private readonly maxLogs;
+    constructor(workspaceRoot: string, runtimeHooks?: DevtoolsRuntimeHooks);
+    close(input: RuntimeConnectionInput): Promise<void>;
+    clearLogs(): void;
+    getLogs(): RuntimeConsoleLogEntry[];
+    resolveProjectPath(projectPath: string): string;
+    resolveWorkspacePath(filePath: string): string;
+    withMiniProgram<T>(input: RuntimeConnectionInput, runner: (miniProgram: MiniProgramLike) => Promise<T>): Promise<T>;
+    withPage<T>(input: RuntimeConnectionInput, runner: (page: MiniProgramPage, miniProgram: MiniProgramLike) => Promise<T>): Promise<T>;
+    private attach;
+    private detach;
+    private pushLog;
+}
+
 interface CreateServerOptions {
     runtimeHooks?: DevtoolsRuntimeHooks;
     workspaceRoot?: string;
 }
 declare function createWeappViteMcpServer(options?: CreateServerOptions): Promise<{
+    runtimeManager: RuntimeSessionManager;
     server: McpServer;
     workspaceRoot: string;
 }>;
 
+declare const DEFAULT_RUNTIME_REST_ENDPOINT = "/api/weapp/devtools";
+
 declare const DEFAULT_MCP_HOST = "127.0.0.1";
 declare const DEFAULT_MCP_PORT = 3088;
 declare const DEFAULT_MCP_ENDPOINT = "/mcp";
@@ -103,6 +166,7 @@ interface StartMcpServerOptions extends CreateServerOptions {
     host?: string;
     port?: number;
     endpoint?: string;
+    restEndpoint?: string | false;
     unref?: boolean;
     quiet?: boolean;
     onReady?: (message: string) => void;
@@ -137,5 +201,5 @@ declare function resolveWorkspaceRoot(start?: string): string;
 declare function assertInsideRoot(root: string, targetPath: string): string;
 declare function resolveSubPath(root: string, relativePath: string): string;
 
-export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
+export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
 export type { CommandResult, CreateServerOptions, ExposedPackageId, ExposedPackageSummary, McpServerHandle, SearchMatch, StartMcpServerOptions };

package/dist/index.mjs

@@ -1,17 +1,18 @@
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { Buffer } from 'node:buffer';
+import { randomUUID } from 'node:crypto';
 import http from 'node:http';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { ResourceTemplate, McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
+import fs$1 from 'node:fs/promises';
 import path from 'node:path';
+import { z } from 'zod';
+import { closeSharedMiniProgram, acquireSharedMiniProgram, releaseSharedMiniProgram } from '@weapp-vite/devtools-runtime';
+import { ResourceTemplate, McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import fs from 'node:fs';
-import fs$1 from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
-import { closeSharedMiniProgram, acquireSharedMiniProgram, releaseSharedMiniProgram } from '@weapp-vite/devtools-runtime';
 
 const MCP_SERVER_NAME = "@weapp-vite/mcp";
 const MCP_SERVER_VERSION = "2.0.0";
@@ -1625,10 +1626,11 @@ function registerRuntimePageTools(server, manager) {
 }
 
 function registerRuntimeTools(server, options) {
-  const manager = new RuntimeSessionManager(options.workspaceRoot, options.runtimeHooks);
+  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) {
@@ -1907,12 +1909,14 @@ async function createWeappViteMcpServer(options) {
     name: MCP_SERVER_NAME,
     version: MCP_SERVER_VERSION
   });
+  const runtimeManager = new RuntimeSessionManager(workspaceRoot, options?.runtimeHooks);
   registerServerTools(server, {
     workspaceRoot,
     packageIds,
     packageIdSchema
   });
   registerRuntimeTools(server, {
+    manager: runtimeManager,
     runtimeHooks: options?.runtimeHooks,
     workspaceRoot
   });
@@ -1925,11 +1929,338 @@ async function createWeappViteMcpServer(options) {
     packageIds
   });
   return {
+    runtimeManager,
     server,
     workspaceRoot
   };
 }
 
+const DEFAULT_RUNTIME_REST_ENDPOINT = "/api/weapp/devtools";
+const connectionSchema = z.object({
+  projectPath: z.string().trim().min(1),
+  timeout: z.number().int().positive().optional(),
+  preferOpenedSession: z.boolean().optional()
+});
+const routeBodySchema = connectionSchema.extend({
+  path: z.string().trim().min(1).optional(),
+  query: z.record(z.string(), z.string()).optional(),
+  transition: z.enum(["navigateTo", "redirectTo", "reLaunch", "switchTab", "navigateBack"]).optional(),
+  waitMs: z.number().int().nonnegative().optional()
+});
+const activePageBodySchema = connectionSchema.extend({
+  withData: z.boolean().optional()
+});
+const captureBodySchema = connectionSchema.extend({
+  outputPath: z.string().trim().min(1).optional()
+});
+const hostApiBodySchema = connectionSchema.extend({
+  method: z.string().trim().min(1),
+  args: z.array(z.unknown()).optional()
+});
+function normalizeRuntimeRestEndpoint(input) {
+  if (input === false) {
+    return false;
+  }
+  const value = typeof input === "string" ? input.trim() : "";
+  const endpoint = value || DEFAULT_RUNTIME_REST_ENDPOINT;
+  return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+}
+function writeJson$1(res, statusCode, payload) {
+  if (res.headersSent) {
+    return;
+  }
+  res.statusCode = statusCode;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+function writeOk(res, result) {
+  writeJson$1(res, 200, {
+    ok: true,
+    result
+  });
+}
+function writeError(res, statusCode, error) {
+  writeJson$1(res, statusCode, {
+    ok: false,
+    error: {
+      message: error instanceof Error ? error.message : String(error)
+    }
+  });
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) {
+    return {};
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) {
+    return {};
+  }
+  return JSON.parse(raw);
+}
+function readBooleanParam(value) {
+  if (value == null) {
+    return void 0;
+  }
+  return ["1", "true", "yes"].includes(value.toLowerCase());
+}
+function readNumberParam(value) {
+  if (value == null || value.trim() === "") {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function readConnectionFromQuery(url) {
+  return connectionSchema.parse(compactObject({
+    projectPath: url.searchParams.get("projectPath") ?? void 0,
+    timeout: readNumberParam(url.searchParams.get("timeout")),
+    preferOpenedSession: readBooleanParam(url.searchParams.get("preferOpenedSession"))
+  }));
+}
+function getRouteContext(req, endpoint) {
+  if (endpoint === false) {
+    return void 0;
+  }
+  const hostHeader = req.headers.host ?? "127.0.0.1";
+  const url = new URL(req.url ?? "/", `http://${hostHeader}`);
+  const pathname = url.pathname.replace(/\/+$/, "") || "/";
+  const normalizedEndpoint = endpoint.replace(/\/+$/, "") || "/";
+  if (pathname !== normalizedEndpoint && !pathname.startsWith(`${normalizedEndpoint}/`)) {
+    return void 0;
+  }
+  const requestPath = pathname === normalizedEndpoint ? "/" : pathname.slice(normalizedEndpoint.length);
+  return {
+    pathname,
+    requestPath,
+    url
+  };
+}
+function getAllowedMethods(pathname) {
+  if (pathname === "/") {
+    return ["GET"];
+  }
+  if (pathname === "/connect" || pathname === "/route" || pathname === "/capture" || pathname === "/host-api") {
+    return ["POST"];
+  }
+  if (pathname === "/active-page" || pathname === "/page-stack") {
+    return ["GET", "POST"];
+  }
+  if (pathname === "/console") {
+    return ["GET", "DELETE"];
+  }
+  if (pathname === "/session") {
+    return ["DELETE"];
+  }
+  return [];
+}
+function assertMethod(res, method, requestPath) {
+  const allowedMethods = getAllowedMethods(requestPath);
+  if (allowedMethods.length === 0) {
+    writeError(res, 404, `Not Found: ${requestPath}`);
+    return false;
+  }
+  if (!allowedMethods.includes(method)) {
+    res.setHeader("allow", allowedMethods.join(", "));
+    writeError(res, 405, `Method Not Allowed: ${method}`);
+    return false;
+  }
+  return true;
+}
+async function readConnectionBody(req) {
+  return connectionSchema.parse(await readJsonBody(req));
+}
+async function getActivePage(manager, input) {
+  return await manager.withPage(input, async (page) => {
+    const [size, scrollTop, data] = await Promise.all([
+      page.size().catch(() => null),
+      page.scrollTop().catch(() => null),
+      input.withData ? page.data().catch(() => null) : Promise.resolve(void 0)
+    ]);
+    return compactObject({
+      path: page.path,
+      query: toSerializableValue(page.query),
+      size: toSerializableValue(size),
+      scrollTop: toSerializableValue(scrollTop),
+      data: toSerializableValue(data)
+    });
+  });
+}
+async function handleRoot(res, endpoint) {
+  writeOk(res, {
+    endpoint,
+    routes: [
+      "POST /connect",
+      "POST /route",
+      "GET|POST /active-page",
+      "GET|POST /page-stack",
+      "POST /capture",
+      "POST /host-api",
+      "GET|DELETE /console",
+      "DELETE /session"
+    ]
+  });
+}
+async function handleConnect(req, res, manager) {
+  const connection = await readConnectionBody(req);
+  const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+    const page = await miniProgram.currentPage().catch(() => null);
+    const systemInfo = await miniProgram.systemInfo().catch(() => null);
+    return {
+      connected: true,
+      projectPath: connection.projectPath,
+      resolvedProjectPath: manager.resolveProjectPath(connection.projectPath),
+      currentPage: page ? { path: page.path, query: toSerializableValue(page.query) } : null,
+      systemInfo: toSerializableValue(systemInfo)
+    };
+  });
+  writeOk(res, result);
+}
+async function handleRoute(req, res, manager) {
+  const input = routeBodySchema.parse(await readJsonBody(req));
+  const result = await manager.withMiniProgram(input, async (miniProgram) => {
+    const transition = input.transition ?? "navigateTo";
+    if (transition === "navigateBack") {
+      const page2 = await miniProgram.navigateBack();
+      if (input.waitMs && page2) {
+        await page2.waitFor(input.waitMs);
+      }
+      return {
+        transition,
+        activePage: page2 ? { path: page2.path, query: toSerializableValue(page2.query) } : null
+      };
+    }
+    if (!input.path) {
+      throw new Error("transition \u4E0D\u662F navigateBack \u65F6\u5FC5\u987B\u63D0\u4F9B path\u3002");
+    }
+    const url = buildUrl(input.path, input.query);
+    const page = await callRequiredMethod(
+      miniProgram,
+      transition,
+      url
+    );
+    if (input.waitMs && page) {
+      await page.waitFor(input.waitMs);
+    }
+    return {
+      transition,
+      url,
+      activePage: page ? { path: page.path, query: toSerializableValue(page.query) } : null
+    };
+  });
+  writeOk(res, result);
+}
+async function handleActivePage(req, res, context, manager) {
+  const input = req.method === "GET" ? activePageBodySchema.parse({
+    ...readConnectionFromQuery(context.url),
+    withData: readBooleanParam(context.url.searchParams.get("withData"))
+  }) : activePageBodySchema.parse(await readJsonBody(req));
+  const result = await getActivePage(manager, input);
+  writeOk(res, result);
+}
+async function handlePageStack(req, res, context, manager) {
+  const connection = req.method === "GET" ? readConnectionFromQuery(context.url) : await readConnectionBody(req);
+  const result = await manager.withMiniProgram(connection, async (miniProgram) => {
+    const stack = await miniProgram.pageStack();
+    return stack.map((page) => ({
+      path: page.path,
+      query: toSerializableValue(page.query)
+    }));
+  });
+  writeOk(res, result);
+}
+async function handleCapture(req, res, manager) {
+  const input = captureBodySchema.parse(await readJsonBody(req));
+  const result = await manager.withMiniProgram(input, async (miniProgram) => {
+    const screenshot = await miniProgram.screenshot();
+    const buffer = typeof screenshot === "string" ? Buffer.from(screenshot, "base64") : Buffer.from(screenshot);
+    if (input.outputPath) {
+      const resolvedOutputPath = manager.resolveWorkspacePath(input.outputPath);
+      await fs$1.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+      await fs$1.writeFile(resolvedOutputPath, buffer);
+      return {
+        path: resolvedOutputPath,
+        bytes: buffer.length
+      };
+    }
+    return {
+      base64: buffer.toString("base64"),
+      bytes: buffer.length
+    };
+  });
+  writeOk(res, result);
+}
+async function handleHostApi(req, res, manager) {
+  const input = hostApiBodySchema.parse(await readJsonBody(req));
+  const result = await manager.withMiniProgram(input, async (miniProgram) => {
+    const args = input.args ?? [];
+    return {
+      method: input.method,
+      args: toSerializableValue(args),
+      result: toSerializableValue(await miniProgram.callWxMethod(input.method, ...args))
+    };
+  });
+  writeOk(res, result);
+}
+async function handleConsole(req, res, manager) {
+  const logs = manager.getLogs();
+  if (req.method === "DELETE") {
+    manager.clearLogs();
+  }
+  writeOk(res, {
+    count: logs.length,
+    logs,
+    cleared: req.method === "DELETE"
+  });
+}
+async function handleSession(req, res, context, manager) {
+  const connection = context.url.searchParams.has("projectPath") ? readConnectionFromQuery(context.url) : await readConnectionBody(req);
+  await manager.close(connection);
+  writeOk(res, {
+    closed: true,
+    projectPath: connection.projectPath,
+    resolvedProjectPath: manager.resolveProjectPath(connection.projectPath)
+  });
+}
+async function handleRuntimeRestRequest(req, res, options) {
+  const endpoint = normalizeRuntimeRestEndpoint(options.endpoint);
+  const context = getRouteContext(req, endpoint);
+  if (!context) {
+    return false;
+  }
+  const method = req.method ?? "GET";
+  if (!assertMethod(res, method, context.requestPath)) {
+    return true;
+  }
+  try {
+    if (context.requestPath === "/") {
+      await handleRoot(res, endpoint);
+    } else if (context.requestPath === "/connect") {
+      await handleConnect(req, res, options.manager);
+    } else if (context.requestPath === "/route") {
+      await handleRoute(req, res, options.manager);
+    } else if (context.requestPath === "/active-page") {
+      await handleActivePage(req, res, context, options.manager);
+    } else if (context.requestPath === "/page-stack") {
+      await handlePageStack(req, res, context, options.manager);
+    } else if (context.requestPath === "/capture") {
+      await handleCapture(req, res, options.manager);
+    } else if (context.requestPath === "/host-api") {
+      await handleHostApi(req, res, options.manager);
+    } else if (context.requestPath === "/console") {
+      await handleConsole(req, res, options.manager);
+    } else if (context.requestPath === "/session") {
+      await handleSession(req, res, context, options.manager);
+    }
+  } catch (error) {
+    writeError(res, error instanceof SyntaxError || error instanceof z.ZodError ? 400 : 500, error);
+  }
+  return true;
+}
+
 const DEFAULT_MCP_HOST = "127.0.0.1";
 const DEFAULT_MCP_PORT = 3088;
 const DEFAULT_MCP_ENDPOINT = "/mcp";
@@ -1991,6 +2322,7 @@ async function startStreamableHttpServer(options) {
     endpoint = DEFAULT_MCP_ENDPOINT,
     host = DEFAULT_MCP_HOST,
     port = DEFAULT_MCP_PORT,
+    restEndpoint = DEFAULT_RUNTIME_REST_ENDPOINT,
     workspaceRoot,
     runtimeHooks,
     unref = false,
@@ -1999,15 +2331,23 @@ async function startStreamableHttpServer(options) {
   } = options;
   const normalizedEndpoint = normalizeEndpoint(endpoint);
   const normalizedPort = normalizePort(port);
-  const { server: mcpServer } = await createWeappViteMcpServer({ runtimeHooks, workspaceRoot });
+  const normalizedRestEndpoint = normalizeRuntimeRestEndpoint(restEndpoint);
+  const { runtimeManager, server: mcpServer } = await createWeappViteMcpServer({ runtimeHooks, workspaceRoot });
   const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: void 0
+    sessionIdGenerator: randomUUID
   });
   await mcpServer.connect(transport);
   const httpServer = http.createServer(async (req, res) => {
     try {
       const hostHeader = req.headers.host ?? `${host}:${normalizedPort}`;
       const url = new URL(req.url ?? "/", `http://${hostHeader}`);
+      const handledByRest = await handleRuntimeRestRequest(req, res, {
+        endpoint: normalizedRestEndpoint,
+        manager: runtimeManager
+      });
+      if (handledByRest) {
+        return;
+      }
       if (url.pathname !== normalizedEndpoint) {
         writeJson(res, 404, {
           jsonrpc: "2.0",
@@ -2055,6 +2395,9 @@ async function startStreamableHttpServer(options) {
   }
   if (!quiet) {
     onReady?.(`[mcp] streamable-http ready at http://${host}:${normalizedPort}${normalizedEndpoint}`);
+    if (normalizedRestEndpoint !== false) {
+      onReady?.(`[mcp] REST runtime ready at http://${host}:${normalizedPort}${normalizedRestEndpoint}`);
+    }
   }
   return {
     transport: "streamable-http",
@@ -2100,4 +2443,4 @@ ${message}
   });
 }
 
-export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
+export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@weapp-vite/mcp",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "mcp",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "ISC",
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "zod": "^4.3.6",
-    "@weapp-vite/devtools-runtime": "0.2.0"
+    "zod": "^4.4.2",
+    "@weapp-vite/devtools-runtime": "0.2.1"
   },
   "scripts": {
     "dev": "unbuild --stub",