vite-plugin-opencode-assistant 1.1.24 → 1.1.25

package/es/core/mcp-proxy.d.ts

@@ -0,0 +1,21 @@
+export interface McpProxyOptions {
+    args?: string[];
+    idleTimeout?: number;
+}
+export declare class McpProxy {
+    #private;
+    readonly sessionId: string;
+    readonly accessToken: string;
+    constructor(options?: McpProxyOptions);
+    get isRunning(): boolean;
+    start(): Promise<void>;
+    /** 转发原始 JSON-RPC 请求，保留客户端 ID */
+    forward(rawRequest: string): Promise<string>;
+    /** 调用 MCP 工具 */
+    call(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** 直接调用 chrome-devtools-mcp 底层工具（内部使用） */
+    callChromeDevTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    /** 验证 MCP 是否可用 + 预热 CDP 连接 */
+    verify(): Promise<boolean>;
+    stop(): void;
+}

package/es/core/mcp-proxy.mjs

@@ -0,0 +1,254 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const import_meta = {};
+var _proc, _rl, _messageId, _internalIdBase, _pending, _args, _startPromise, _idleTimer, _idleTimeout, _McpProxy_instances, doStart_fn, resetIdleTimer_fn;
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import crypto from "node:crypto";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createLogger } from "@vite-plugin-opencode-assistant/shared/node";
+const log = createLogger("McpProxy");
+function resolveChromeDevToolsMcpBin() {
+  const require2 = createRequire(import_meta.url);
+  const pkgJsonPath = require2.resolve("chrome-devtools-mcp/package.json");
+  const pkgDir = path.dirname(pkgJsonPath);
+  const { bin } = require2(pkgJsonPath);
+  const binEntry = typeof bin === "string" ? bin : Object.values(bin)[0];
+  return path.resolve(pkgDir, binEntry);
+}
+class McpProxy {
+  constructor(options = {}) {
+    __privateAdd(this, _McpProxy_instances);
+    __privateAdd(this, _proc, null);
+    __privateAdd(this, _rl, null);
+    __privateAdd(this, _messageId, 0);
+    /** 内部调用使用的高位 ID 起始值，避免与客户端 ID 冲突 */
+    __privateAdd(this, _internalIdBase, 1e6);
+    __privateAdd(this, _pending, /* @__PURE__ */ new Map());
+    __privateAdd(this, _args);
+    __privateAdd(this, _startPromise, null);
+    __privateAdd(this, _idleTimer, null);
+    __privateAdd(this, _idleTimeout);
+    __publicField(this, "sessionId");
+    __publicField(this, "accessToken");
+    var _a, _b;
+    __privateSet(this, _args, (_a = options.args) != null ? _a : ["--auto-connect", "--no-usage-statistics"]);
+    __privateSet(this, _idleTimeout, (_b = options.idleTimeout) != null ? _b : 0);
+    this.sessionId = crypto.randomUUID();
+    this.accessToken = crypto.randomBytes(32).toString("hex");
+  }
+  get isRunning() {
+    return __privateGet(this, _proc) !== null && !__privateGet(this, _proc).killed;
+  }
+  start() {
+    return __async(this, null, function* () {
+      if (this.isRunning) return;
+      if (__privateGet(this, _startPromise)) return __privateGet(this, _startPromise);
+      __privateSet(this, _startPromise, __privateMethod(this, _McpProxy_instances, doStart_fn).call(this));
+      return __privateGet(this, _startPromise);
+    });
+  }
+  /** 转发原始 JSON-RPC 请求，保留客户端 ID */
+  forward(rawRequest) {
+    return __async(this, null, function* () {
+      yield this.start();
+      if (!__privateGet(this, _proc) || !__privateGet(this, _proc).stdin) {
+        throw new Error("MCP process not available");
+      }
+      __privateMethod(this, _McpProxy_instances, resetIdleTimer_fn).call(this);
+      let msg;
+      try {
+        msg = JSON.parse(rawRequest);
+      } catch (e) {
+        throw new Error("Invalid JSON-RPC request");
+      }
+      return new Promise((resolve, reject) => {
+        const id = msg.id;
+        if (id !== void 0) {
+          __privateGet(this, _pending).set(id, (raw) => resolve(JSON.stringify(raw)));
+        } else {
+          __privateGet(this, _proc).stdin.write(rawRequest + "\n");
+          resolve("");
+          return;
+        }
+        __privateGet(this, _proc).stdin.write(rawRequest + "\n");
+        setTimeout(() => {
+          if (__privateGet(this, _pending).has(id)) {
+            __privateGet(this, _pending).delete(id);
+            reject(new Error("MCP forward timeout"));
+          }
+        }, 3e4);
+      });
+    });
+  }
+  /** 调用 MCP 工具 */
+  call(_0) {
+    return __async(this, arguments, function* (method, params = {}) {
+      yield this.start();
+      if (!__privateGet(this, _proc) || !__privateGet(this, _proc).stdin) {
+        throw new Error("MCP process not available");
+      }
+      __privateMethod(this, _McpProxy_instances, resetIdleTimer_fn).call(this);
+      const id = __privateGet(this, _internalIdBase) + ++__privateWrapper(this, _messageId)._;
+      return new Promise((resolve, reject) => {
+        __privateGet(this, _pending).set(id, resolve);
+        const request = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+        __privateGet(this, _proc).stdin.write(request + "\n");
+        setTimeout(() => {
+          if (__privateGet(this, _pending).has(id)) {
+            __privateGet(this, _pending).delete(id);
+            reject(new Error(`MCP call timeout: ${method}`));
+          }
+        }, 3e4);
+      });
+    });
+  }
+  /** 直接调用 chrome-devtools-mcp 底层工具（内部使用） */
+  callChromeDevTool(_0) {
+    return __async(this, arguments, function* (name, args = {}) {
+      return this.call("tools/call", { name, arguments: args });
+    });
+  }
+  /** 验证 MCP 是否可用 + 预热 CDP 连接 */
+  verify() {
+    return __async(this, null, function* () {
+      try {
+        yield this.callChromeDevTool("list_pages", {});
+        return true;
+      } catch (e) {
+        return false;
+      }
+    });
+  }
+  stop() {
+    if (__privateGet(this, _idleTimer)) clearTimeout(__privateGet(this, _idleTimer));
+    const err = new Error("MCP server shutting down");
+    for (const resolve of __privateGet(this, _pending).values()) {
+      resolve({ error: { code: -32e3, message: err.message } });
+    }
+    __privateGet(this, _pending).clear();
+    if (__privateGet(this, _rl)) {
+      __privateGet(this, _rl).close();
+      __privateSet(this, _rl, null);
+    }
+    if (__privateGet(this, _proc) && !__privateGet(this, _proc).killed) {
+      __privateGet(this, _proc).kill();
+      __privateSet(this, _proc, null);
+    }
+    __privateSet(this, _startPromise, null);
+  }
+}
+_proc = new WeakMap();
+_rl = new WeakMap();
+_messageId = new WeakMap();
+_internalIdBase = new WeakMap();
+_pending = new WeakMap();
+_args = new WeakMap();
+_startPromise = new WeakMap();
+_idleTimer = new WeakMap();
+_idleTimeout = new WeakMap();
+_McpProxy_instances = new WeakSet();
+doStart_fn = function() {
+  return __async(this, null, function* () {
+    var _a;
+    log.debug("Starting MCP process", { args: __privateGet(this, _args) });
+    try {
+      const binPath = resolveChromeDevToolsMcpBin();
+      __privateSet(this, _proc, spawn(binPath, __privateGet(this, _args), { stdio: ["pipe", "pipe", "pipe"] }));
+      log.debug("Using local chrome-devtools-mcp");
+    } catch (e) {
+      __privateSet(this, _proc, spawn("npx", ["-y", "chrome-devtools-mcp@latest", ...__privateGet(this, _args)], {
+        stdio: ["pipe", "pipe", "pipe"]
+      }));
+    }
+    __privateSet(this, _rl, createInterface({ input: __privateGet(this, _proc).stdout }));
+    __privateGet(this, _rl).on("line", (line) => {
+      try {
+        const msg = JSON.parse(line);
+        log.debug("MCP stdout", {
+          id: msg.id,
+          method: msg.method,
+          hasResult: !!msg.result,
+          hasError: !!msg.error
+        });
+        if (msg.id !== void 0 && __privateGet(this, _pending).has(msg.id)) {
+          const resolve = __privateGet(this, _pending).get(msg.id);
+          __privateGet(this, _pending).delete(msg.id);
+          log.debug("MCP pending resolved", { id: msg.id });
+          resolve(msg);
+        }
+      } catch (e) {
+      }
+    });
+    (_a = __privateGet(this, _proc).stderr) == null ? void 0 : _a.on("data", (d) => {
+      const text = d.toString().trim();
+      if (text) log.debug("[MCP stderr]", { text: text.substring(0, 200) });
+    });
+    __privateGet(this, _proc).on("close", (code) => {
+      log.debug("MCP process closed", { code });
+      for (const resolve of __privateGet(this, _pending).values()) {
+        resolve({ error: { code: -32e3, message: `MCP process exited with code ${code}` } });
+      }
+      __privateGet(this, _pending).clear();
+      __privateSet(this, _proc, null);
+      __privateSet(this, _rl, null);
+      __privateSet(this, _startPromise, null);
+    });
+    yield this.call("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "vite-plugin-opencode", version: "1.0.0" }
+    });
+    log.debug("MCP proxy ready");
+    __privateSet(this, _startPromise, null);
+  });
+};
+resetIdleTimer_fn = function() {
+  if (__privateGet(this, _idleTimeout) <= 0) return;
+  if (__privateGet(this, _idleTimer)) clearTimeout(__privateGet(this, _idleTimer));
+  __privateSet(this, _idleTimer, setTimeout(() => {
+    log.debug("MCP process idle timeout, stopping");
+    this.stop();
+  }, __privateGet(this, _idleTimeout)));
+};
+export {
+  McpProxy
+};

package/es/core/opencode-web.d.ts

@@ -1,4 +1,4 @@
 import type { ResultPromise } from "execa";
 import type { WebOptions } from "@vite-plugin-opencode-assistant/shared";
-export declare function prepareOpenCodeRuntime(cwd: string): string;
+export declare function prepareOpenCodeRuntime(cwd: string, vitePort: number, mcpToken: string): string;
 export declare function startOpenCodeWeb(options: WebOptions): ResultPromise;

package/es/core/opencode-web.mjs

@@ -22,11 +22,12 @@ import fs from "fs";
 import { createRequire } from "module";
 import path from "path";
 import { pathToFileURL } from "url";
+import { MCP_API_PATH } from "@vite-plugin-opencode-assistant/shared";
 import { createLogger, getProcessLogBuffer } from "@vite-plugin-opencode-assistant/shared/node";
 const require2 = createRequire(path.join(process.cwd(), "package.json"));
 const packageDir = resolvePackageDir();
 const log = createLogger("OpenCodeWeb");
-function prepareOpenCodeRuntime(cwd) {
+function prepareOpenCodeRuntime(cwd, vitePort, mcpToken) {
   const cacheDir = path.join(cwd, "node_modules", ".cache", "opencode");
   log.debug("Setting up OpenCode runtime", { cacheDir });
   if (!fs.existsSync(cacheDir)) {
@@ -42,9 +43,8 @@ function prepareOpenCodeRuntime(cwd) {
         plugin: plugins,
         mcp: {
           "chrome-devtools": {
-            type: "local",
-            command: ["npx", "-y", "chrome-devtools-mcp@latest", "--autoConnect"],
-            enabled: true
+            type: "remote",
+            url: `http://localhost:${vitePort}${MCP_API_PATH}?token=${mcpToken}`
           }
         }
       },

package/es/core/service.d.ts

@@ -4,6 +4,7 @@ import type { ModelInfo } from "@vite-plugin-opencode-assistant/shared";
 import type { OpenCodeOptions, ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
 import { ChromeMcpWarmupErrorType } from "@vite-plugin-opencode-assistant/shared";
 import type { OpenCodeAPI } from "./api";
+import type { McpProxy } from "./mcp-proxy";
 export declare class OpenCodeService {
     private config;
     private api;
@@ -26,7 +27,7 @@ export declare class OpenCodeService {
     workspaceRoot: string | null;
     constructor(config: Required<OpenCodeOptions>, api: OpenCodeAPI, sseClients: Set<http.ServerResponse>, onPortAllocated: (port: number) => void, onProxyPortAllocated: (port: number) => void);
     private sendTaskUpdate;
-    start(corsOrigins?: string[], contextApiUrl?: string, logsApiUrl?: string, viteOrigin?: string): Promise<void>;
+    start(mcpToken: string, vitePort: number, corsOrigins: string[], contextApiUrl: string, logsApiUrl: string, viteOrigin: string, mcp: McpProxy): Promise<void>;
     getAvailableModels(): Promise<ModelInfo[]>;
     retryWarmupChromeMcp(viteOrigin?: string, selectedModel?: {
         providerID: string;

package/es/core/service.mjs

@@ -87,7 +87,7 @@ class OpenCodeService {
       }
     });
   }
-  start(corsOrigins, contextApiUrl, logsApiUrl, viteOrigin) {
+  start(mcpToken, vitePort, corsOrigins, contextApiUrl, logsApiUrl, viteOrigin, mcp) {
     return __async(this, null, function* () {
       if (this.isStarted && this.webProcess) {
         log.debug("Services already started, skipping");
@@ -148,7 +148,7 @@ Please install OpenCode first:
         this.workspaceRoot = findGitRoot(process.cwd());
         log.debug(`Using workspace root: ${this.workspaceRoot}`);
         this.sendTaskUpdate("preparing_runtime");
-        const configDir = prepareOpenCodeRuntime(this.workspaceRoot);
+        const configDir = prepareOpenCodeRuntime(this.workspaceRoot, vitePort, mcpToken);
         timer.checkpoint("Plugin setup complete");
         this.sendTaskUpdate("starting_web");
         log.debug("Starting OpenCode Web process...", {
@@ -238,7 +238,8 @@ Please install OpenCode first:
         this.sendTaskUpdate("warming_up_chrome");
         let warmupFailed = false;
         try {
-          yield this.api.warmupChromeMcp(this.workspaceRoot, viteOrigin);
+          const ok = yield mcp.verify();
+          if (!ok) throw new Error("MCP tools list returned empty");
           timer.checkpoint("Chrome MCP warmup complete");
         } catch (e) {
           log.warn("Chrome MCP warmup failed", { error: e });

package/es/endpoints/context.d.ts

@@ -1,3 +1,38 @@
 import type { ViteDevServer } from "vite";
+import type { McpProxy } from "../core/mcp-proxy";
 import type { EndpointContext } from "./types";
+/** 从页面 URL 提取项目 origin（protocol + host + port） */
+export declare function getProjectOrigin(pageUrl: string): string | null;
+export interface PageInfo {
+    pageId: number;
+    url: string;
+    title: string;
+    /** Chrome DevTools 当前选中的页面 */
+    selected: boolean;
+}
+/** 解析 list_pages 返回的文本。格式："56: Title (URL) [selected]" */
+export declare function parseListPages(text: string): PageInfo[];
+/** 从 evaluate_script 返回的格式化文本中提取 JSON 值 */
+export declare function extractEvalValue(text: string | undefined): string | undefined;
+type PageIdResult = {
+    ok: true;
+    pageId: number;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * 通过 MCP 解析当前页面对应的 Chrome DevTools pageId
+ *
+ * 策略：
+ * 1. list_pages → 解析每行的 "pageId: title (URL)" 格式
+ * 2. 优先用 sessionId 匹配（跨导航可靠，遍历所有页面 evaluate_script）
+ * 3. 无 sessionId 时降级为 URL 精确匹配
+ *
+ * 失败时返回具体原因，由调用方透传给 Agent。
+ */
+export declare function resolveChromePageId(mcp: McpProxy | undefined, url: string, title: string, sessionId?: string, pages?: PageInfo[], 
+/** Chrome 当前选中的 pageId（调用方传入，避免过滤后丢失非项目页面信息） */
+chromeSelectedPageId?: number): Promise<PageIdResult>;
 export declare function setupContextEndpoint(server: ViteDevServer, ctx: EndpointContext): void;
+export {};

package/es/endpoints/context.mjs

@@ -21,6 +21,121 @@ var __async = (__this, __arguments, generator) => {
 import { CONTEXT_API_PATH } from "@vite-plugin-opencode-assistant/shared";
 import { RequestContext, createLogger } from "@vite-plugin-opencode-assistant/shared/node";
 const log = createLogger("Endpoints:Context");
+function getProjectOrigin(pageUrl) {
+  try {
+    return new URL(pageUrl).origin;
+  } catch (e) {
+    return null;
+  }
+}
+function parseListPages(text) {
+  const pages = [];
+  for (const line of text.split("\n")) {
+    const match = line.match(/^(\d+):\s*(.+?)\s*\((\S+)\)/);
+    if (match) {
+      pages.push({
+        pageId: parseInt(match[1], 10),
+        title: match[2].replace(/\s*\.{3}$/, "").trim(),
+        url: match[3],
+        selected: /\[selected\]/i.test(line)
+      });
+    }
+  }
+  return pages;
+}
+function extractEvalValue(text) {
+  if (!text) return void 0;
+  const marker = "```json\n";
+  const startIdx = text.indexOf(marker);
+  if (startIdx < 0) return text.trim();
+  const contentStart = startIdx + marker.length;
+  const endIdx = text.indexOf("\n```", contentStart);
+  const jsonStr = endIdx < 0 ? text.substring(contentStart) : text.substring(contentStart, endIdx);
+  try {
+    return JSON.parse(jsonStr.trim());
+  } catch (e) {
+    return jsonStr.trim();
+  }
+}
+function resolveChromePageId(mcp, url, title, sessionId, pages, chromeSelectedPageId) {
+  return __async(this, null, function* () {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!mcp || !mcp.isRunning) {
+      const reason = !mcp ? "MCP \u6A21\u5757\u672A\u521D\u59CB\u5316" : "Chrome DevTools MCP \u8FDB\u7A0B\u672A\u542F\u52A8";
+      log.debug(`resolveChromePageId: ${reason}`);
+      return { ok: false, error: reason };
+    }
+    if (!url) {
+      return { ok: false, error: "\u9875\u9762 URL \u4E3A\u7A7A\uFF0C\u5C1A\u672A\u6536\u5230\u4E0A\u4E0B\u6587\u4FE1\u606F" };
+    }
+    try {
+      if (!pages) {
+        const listResult = yield mcp.callChromeDevTool("list_pages", {});
+        const text = (_c = (_b = (_a = listResult == null ? void 0 : listResult.result) == null ? void 0 : _a.content) == null ? void 0 : _b[0]) == null ? void 0 : _c.text;
+        if (!text) {
+          return { ok: false, error: "\u65E0\u6CD5\u83B7\u53D6 Chrome \u9875\u9762\u5217\u8868\uFF0C\u8BF7\u786E\u8BA4\u5DF2\u6253\u5F00\u76EE\u6807\u9875\u9762" };
+        }
+        const allPages = parseListPages(text);
+        chromeSelectedPageId = (_d = allPages.find((p) => p.selected)) == null ? void 0 : _d.pageId;
+        const projectOrigin = getProjectOrigin(url);
+        pages = projectOrigin ? allPages.filter((p) => p.url.startsWith(projectOrigin)) : allPages;
+      }
+      log.debug("resolveChromePageId: list_pages result", {
+        pages: pages.map((p) => ({ id: p.pageId, url: p.url, title: p.title.substring(0, 40) })),
+        target: { url, title }
+      });
+      const normalizeUrl = (u) => u.replace(/\/$/, "");
+      const targetUrl = normalizeUrl(url);
+      if (sessionId) {
+        let matchedPageId = null;
+        for (const page of pages) {
+          yield mcp.callChromeDevTool("select_page", { pageId: page.pageId, bringToFront: false });
+          const evalResult = yield mcp.callChromeDevTool("evaluate_script", {
+            function: "() => sessionStorage.getItem('_opencode_pk')"
+          });
+          const rawText = (_g = (_f = (_e = evalResult == null ? void 0 : evalResult.result) == null ? void 0 : _e.content) == null ? void 0 : _f[0]) == null ? void 0 : _g.text;
+          const extracted = extractEvalValue(rawText);
+          if (extracted === sessionId) {
+            matchedPageId = page.pageId;
+            break;
+          }
+        }
+        if (chromeSelectedPageId != null && chromeSelectedPageId !== matchedPageId) {
+          yield mcp.callChromeDevTool("select_page", {
+            pageId: chromeSelectedPageId,
+            bringToFront: false
+          });
+        }
+        if (matchedPageId != null) {
+          return { ok: true, pageId: matchedPageId };
+        }
+        return {
+          ok: false,
+          error: `\u672A\u80FD\u901A\u8FC7\u4F1A\u8BDD\u6807\u8BC6\u627E\u5230\u76EE\u6807\u9875\u9762\uFF0C\u8BF7\u786E\u8BA4\u76EE\u6807\u9875\u9762\u5DF2\u6253\u5F00`
+        };
+      }
+      const matches = pages.filter((p) => normalizeUrl(p.url) === targetUrl);
+      if (matches.length === 0) {
+        return {
+          ok: false,
+          error: `Chrome \u4E2D\u672A\u627E\u5230\u5339\u914D\u7684\u9875\u9762 (${targetUrl})\uFF0C\u8BF7\u786E\u8BA4\u672C\u5730\u5F00\u53D1\u9875\u9762\u5DF2\u5728 Chrome DevTools \u4E2D\u6253\u5F00`
+        };
+      }
+      if (matches.length === 1) {
+        log.debug("resolveChromePageId: URL matched", { pageId: matches[0].pageId });
+        return { ok: true, pageId: matches[0].pageId };
+      }
+      return {
+        ok: false,
+        error: `\u5B58\u5728 ${matches.length} \u4E2A\u540C URL \u7684\u9875\u9762\uFF0C\u7F3A\u5C11\u9875\u9762\u6807\u8BC6\u65E0\u6CD5\u533A\u5206\uFF0C\u8BF7\u5237\u65B0\u9875\u9762\u540E\u91CD\u8BD5`
+      };
+    } catch (err) {
+      const msg = `MCP \u8C03\u7528\u5931\u8D25: ${err.message}`;
+      log.debug("Failed to resolve pageId via MCP", { error: err.message });
+      return { ok: false, error: msg };
+    }
+  });
+}
 function setupContextEndpoint(server, ctx) {
   server.middlewares.use(CONTEXT_API_PATH, (req, res) => __async(null, null, function* () {
     const reqCtx = new RequestContext(req.method || "GET", CONTEXT_API_PATH);
@@ -36,7 +151,6 @@ function setupContextEndpoint(server, ctx) {
     }
     if (req.method === "GET") {
       const pc = ctx.getPageContext();
-      log.debug(`[Context] GET \u2192 url=${pc.url} title=${pc.title} tabId=${pc.tabId}`);
       res.writeHead(200);
       res.end(JSON.stringify(pc));
       reqCtx.end(200);
@@ -67,7 +181,11 @@ function setupContextEndpoint(server, ctx) {
     }
     if (req.method === "POST") {
       let body = "";
-      req.on("data", (chunk) => body += chunk);
+      req.on("data", (chunk) => body += chunk.toString());
+      req.on("error", () => {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Request error" }));
+      });
       req.on("end", () => {
         var _a, _b, _c;
         try {
@@ -77,6 +195,7 @@ function setupContextEndpoint(server, ctx) {
           const newCtx = {
             url: data.url || "",
             title: data.title || "",
+            sessionId: data.sessionId,
             tabId: (_a = data.tabId) != null ? _a : existing.tabId,
             tabIndex: (_b = data.tabIndex) != null ? _b : existing.tabIndex,
             selectedElements: data.selectedElements || []
@@ -89,6 +208,7 @@ function setupContextEndpoint(server, ctx) {
             tabId,
             url: newCtx.url,
             title: newCtx.title,
+            sessionId: newCtx.sessionId,
             selectedElementsCount: ((_c = newCtx.selectedElements) == null ? void 0 : _c.length) || 0
           });
           if (newCtx.selectedElements && newCtx.selectedElements.length > 0) {
@@ -121,5 +241,9 @@ function setupContextEndpoint(server, ctx) {
   }));
 }
 export {
+  extractEvalValue,
+  getProjectOrigin,
+  parseListPages,
+  resolveChromePageId,
   setupContextEndpoint
 };

package/es/endpoints/index.d.ts

@@ -1,6 +1,8 @@
 import type { ViteDevServer } from "vite";
 import type { EndpointContext } from "./types";
+import { MCP_API_PATH } from "./mcp";
+import type { McpProxy } from "../core/mcp-proxy";
 import { LOGS_API_PATH } from "@vite-plugin-opencode-assistant/shared";
 export * from "./types";
-export { LOGS_API_PATH };
-export declare function setupMiddlewares(server: ViteDevServer, ctx: EndpointContext): void;
+export { LOGS_API_PATH, MCP_API_PATH };
+export declare function setupMiddlewares(server: ViteDevServer, ctx: EndpointContext, mcp?: McpProxy): void;

package/es/endpoints/index.mjs

@@ -5,9 +5,10 @@ import { setupSseEndpoint } from "./sse.mjs";
 import { setupSessionsEndpoint } from "./sessions.mjs";
 import { setupWarmupEndpoint } from "./warmup.mjs";
 import { setupLogsEndpoint } from "./logs.mjs";
+import { setupMcpEndpoint, MCP_API_PATH } from "./mcp.mjs";
 import { LOGS_API_PATH } from "@vite-plugin-opencode-assistant/shared";
 export * from "./types.mjs";
-function setupMiddlewares(server, ctx) {
+function setupMiddlewares(server, ctx, mcp) {
   setupWidgetEndpoints(server, ctx);
   setupContextEndpoint(server, ctx);
   setupStartEndpoint(server, ctx);
@@ -15,8 +16,10 @@ function setupMiddlewares(server, ctx) {
   setupSessionsEndpoint(server, ctx);
   setupWarmupEndpoint(server, ctx);
   setupLogsEndpoint(server);
+  if (mcp) setupMcpEndpoint(server, mcp, () => ctx.getPageContext());
 }
 export {
   LOGS_API_PATH,
+  MCP_API_PATH,
   setupMiddlewares
 };

package/es/endpoints/mcp-tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 自定义 DevTools 工具定义
+ * 所有工具自动映射到 chrome-devtools-mcp 底层工具
+ */
+export interface CustomTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export declare const CUSTOM_TOOLS: CustomTool[];
+/** 工具名映射（自定义 → chrome-devtools-mcp） */
+export declare const TOOL_MAP: Record<string, string>;