web-access-mcp 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# web-access-mcp
+
+把 [`eze-is/web-access`](https://github.com/eze-is/web-access) 里真正“可执行”的浏览器能力改成一个显式 MCP server，避免依赖 skill 自动激活。
+
+当前版本聚焦于 Chrome CDP 自动化，不再依赖 `SKILL.md` 的提示词调度逻辑。
+
+## 资源限制
+
+- MCP 自己创建的受管 tab 最多 10 个
+- 超过 10 个后，`new_tab` 会直接报错，防止 Chrome target 过多导致卡顿或内存爆掉
+- `adopt_tab` 接管你原本已打开的 tab 后，不计入这 10 个配额
+- `close_tab` 会释放配额
+- 默认情况下，用户本来就打开的 Chrome tab 不计入这 10 个配额，除非你显式执行 `adopt_tab`
+
+## 已实现能力
+
+- `browser_health`: 检查 Chrome remote debugging 是否可发现
+- `browser_health` 额外返回当前受管总数、`created` 配额占用与上限
+- `list_tabs`: 列出当前页面 tab
+- `list_tabs` 额外标记 `isManaged` 与 `managedSource`
+- `new_tab`: 新建后台 tab
+- `close_tab`: 关闭 tab
+- `close_all_managed_tabs`: 一键关闭全部受管 tab
+- `close_created_tabs`: 只关闭 MCP 新开的 `created` tab，保留接管的 `adopted` tab
+- `adopt_tab`: 接管一个用户已打开的 tab
+- `navigate`: 页面跳转并等待加载
+- `go_back`: 后退
+- `page_info`: 读取标题、URL、readyState
+- `eval`: 在页面内执行 JavaScript
+- `click`: `element.click()`
+- `click_at`: 真实鼠标点击
+- `set_files`: 给 file input 注入本地文件
+- `scroll`: 页面滚动
+- `screenshot`: 截图，支持返回 base64 或落盘
+
+## 前置条件
+
+1. Node.js 22+
+2. Chrome 已打开
+3. 在 Chrome 打开 `chrome://inspect/#remote-debugging`
+4. 勾选 `Allow remote debugging for this browser instance`
+
+## 本地运行
+
+```bash
+npm run check
+npm start
+```
+
+## MCP 接入示例
+
+Claude Desktop / Codex 类客户端可将该 server 配成 stdio：
+
+```json
+{
+  "mcpServers": {
+    "web-access": {
+      "command": "node",
+      "args": ["D:/Desktop/浏览器mcp/src/index.mjs"]
+    }
+  }
+}
+```
+
+## 与原 skill 的差异
+
+- 原 skill 的“自动选择 WebSearch / WebFetch / Jina / CDP”是提示词层能力，不是脚本层能力
+- 本仓库把稳定、确定、可调用的部分下沉成 MCP tools
+- 如果后续需要，可继续补 `fetch_url`、`fetch_html`、`site_pattern_lookup` 等工具
+
+## 设计取舍
+
+- 目前无第三方依赖，直接用 Node 22 自带 `WebSocket`
+- 采用 stdio + JSON-RPC 实现最小 MCP server
+- 保留原仓库的核心思路：复用用户自己的 Chrome 登录态，而不是启动独立浏览器

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "web-access-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for browser automation over Chrome CDP, adapted from eze-is/web-access",
+  "type": "module",
+  "bin": {
+    "web-access-mcp": "./src/index.mjs"
+  },
+  "scripts": {
+    "start": "node ./src/index.mjs",
+    "check": "node --check ./src/index.mjs && node --check ./src/cdp-client.mjs"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "license": "MIT"
+}

package/src/cdp-client.mjs

@@ -0,0 +1,631 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+
+const DEFAULT_PORTS = [9222, 9229, 9333];
+const MAX_MANAGED_TABS = 10;
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function portIsOpen(port, host = '127.0.0.1', timeoutMs = 2000) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection(port, host);
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeoutMs);
+
+    socket.once('connect', () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+
+    socket.once('error', () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+
+function getActivePortCandidates() {
+  const home = os.homedir();
+  const localAppData = process.env.LOCALAPPDATA || '';
+  switch (os.platform()) {
+    case 'darwin':
+      return [
+        path.join(home, 'Library/Application Support/Google/Chrome/DevToolsActivePort'),
+        path.join(home, 'Library/Application Support/Google/Chrome Canary/DevToolsActivePort'),
+        path.join(home, 'Library/Application Support/Chromium/DevToolsActivePort'),
+      ];
+    case 'linux':
+      return [
+        path.join(home, '.config/google-chrome/DevToolsActivePort'),
+        path.join(home, '.config/chromium/DevToolsActivePort'),
+      ];
+    case 'win32':
+      return [
+        path.join(localAppData, 'Google/Chrome/User Data/DevToolsActivePort'),
+        path.join(localAppData, 'Chromium/User Data/DevToolsActivePort'),
+      ];
+    default:
+      return [];
+  }
+}
+
+async function discoverChromeDebugTarget() {
+  for (const filePath of getActivePortCandidates()) {
+    try {
+      const lines = fs.readFileSync(filePath, 'utf8').trim().split(/\r?\n/).filter(Boolean);
+      const port = Number.parseInt(lines[0], 10);
+      const wsPath = lines[1] || null;
+      if (Number.isInteger(port) && port > 0 && port < 65536 && await portIsOpen(port)) {
+        return { port, wsPath };
+      }
+    } catch {
+      // Ignore missing files or parse errors and continue probing.
+    }
+  }
+
+  for (const port of DEFAULT_PORTS) {
+    if (await portIsOpen(port)) {
+      return { port, wsPath: null };
+    }
+  }
+
+  return null;
+}
+
+function socketIsOpen(ws) {
+  return Boolean(ws && (ws.readyState === WebSocket.OPEN || ws.readyState === 1));
+}
+
+export class ChromeCdpClient {
+  constructor() {
+    this.ws = null;
+    this.chromePort = null;
+    this.chromeWsPath = null;
+    this.commandId = 0;
+    this.pending = new Map();
+    this.sessions = new Map();
+    this.portGuardedSessions = new Set();
+    this.connectingPromise = null;
+    this.managedTargets = new Map();
+  }
+
+  async discover() {
+    if (this.chromePort) {
+      return {
+        port: this.chromePort,
+        wsPath: this.chromeWsPath,
+      };
+    }
+
+    const discovered = await discoverChromeDebugTarget();
+    if (!discovered) {
+      throw new Error(
+        '未发现 Chrome remote debugging。请打开 Chrome，然后访问 chrome://inspect/#remote-debugging 并启用 "Allow remote debugging for this browser instance"。'
+      );
+    }
+
+    this.chromePort = discovered.port;
+    this.chromeWsPath = discovered.wsPath;
+    return discovered;
+  }
+
+  async connect() {
+    if (socketIsOpen(this.ws)) {
+      return;
+    }
+    if (this.connectingPromise) {
+      return this.connectingPromise;
+    }
+
+    const { port, wsPath } = await this.discover();
+    const wsUrl = wsPath
+      ? `ws://127.0.0.1:${port}${wsPath}`
+      : `ws://127.0.0.1:${port}/devtools/browser`;
+
+    this.connectingPromise = new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      this.ws = ws;
+
+      const cleanup = () => {
+        ws.removeEventListener('open', onOpen);
+        ws.removeEventListener('error', onError);
+      };
+
+      const onOpen = () => {
+        cleanup();
+        this.connectingPromise = null;
+        resolve();
+      };
+
+      const onError = (event) => {
+        cleanup();
+        this.connectingPromise = null;
+        this.ws = null;
+        this.chromePort = null;
+        this.chromeWsPath = null;
+        reject(new Error(event?.message || '连接 Chrome CDP 失败'));
+      };
+
+      const onClose = () => {
+        this.ws = null;
+        this.chromePort = null;
+        this.chromeWsPath = null;
+        this.sessions.clear();
+        this.portGuardedSessions.clear();
+      };
+
+      const onMessage = (event) => {
+        const message = JSON.parse(typeof event.data === 'string' ? event.data : event.data.toString());
+
+        if (message.method === 'Target.attachedToTarget') {
+          const { sessionId, targetInfo } = message.params;
+          this.sessions.set(targetInfo.targetId, sessionId);
+        }
+
+        if (message.method === 'Fetch.requestPaused') {
+          const { requestId, sessionId } = message.params;
+          this.sendCommand('Fetch.failRequest', { requestId, errorReason: 'ConnectionRefused' }, sessionId)
+            .catch(() => {});
+        }
+
+        if (message.id && this.pending.has(message.id)) {
+          const { resolve: done, reject: fail, timeout } = this.pending.get(message.id);
+          clearTimeout(timeout);
+          this.pending.delete(message.id);
+          if (message.error) {
+            fail(new Error(message.error.message || JSON.stringify(message.error)));
+          } else {
+            done(message);
+          }
+        }
+      };
+
+      ws.addEventListener('open', onOpen);
+      ws.addEventListener('error', onError);
+      ws.addEventListener('close', onClose);
+      ws.addEventListener('message', onMessage);
+    });
+
+    return this.connectingPromise;
+  }
+
+  async sendCommand(method, params = {}, sessionId = null) {
+    await this.connect();
+
+    return new Promise((resolve, reject) => {
+      const id = ++this.commandId;
+      const message = { id, method, params };
+      if (sessionId) {
+        message.sessionId = sessionId;
+      }
+
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`CDP 命令超时: ${method}`));
+      }, 30000);
+
+      this.pending.set(id, { resolve, reject, timeout });
+      this.ws.send(JSON.stringify(message));
+    });
+  }
+
+  async ensureSession(targetId) {
+    if (this.sessions.has(targetId)) {
+      return this.sessions.get(targetId);
+    }
+
+    const response = await this.sendCommand('Target.attachToTarget', { targetId, flatten: true });
+    const sessionId = response.result?.sessionId;
+    if (!sessionId) {
+      throw new Error(`无法附着到 target ${targetId}`);
+    }
+
+    this.sessions.set(targetId, sessionId);
+    await this.enablePortGuard(sessionId);
+    return sessionId;
+  }
+
+  async enablePortGuard(sessionId) {
+    if (!this.chromePort || this.portGuardedSessions.has(sessionId)) {
+      return;
+    }
+
+    try {
+      await this.sendCommand('Fetch.enable', {
+        patterns: [
+          { urlPattern: `http://127.0.0.1:${this.chromePort}/*`, requestStage: 'Request' },
+          { urlPattern: `http://localhost:${this.chromePort}/*`, requestStage: 'Request' },
+        ],
+      }, sessionId);
+      this.portGuardedSessions.add(sessionId);
+    } catch {
+      // Do not block normal automation if request interception is unavailable.
+    }
+  }
+
+  async waitForLoad(sessionId, timeoutMs = 15000) {
+    await this.sendCommand('Page.enable', {}, sessionId);
+
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+      const state = await this.sendCommand('Runtime.evaluate', {
+        expression: 'document.readyState',
+        returnByValue: true,
+      }, sessionId);
+
+      if (state.result?.result?.value === 'complete') {
+        return 'complete';
+      }
+
+      await delay(500);
+    }
+
+    return 'timeout';
+  }
+
+  async health() {
+    let discovered = null;
+    let error = null;
+    let managedTabCount = this.managedTargets.size;
+    let createdTabCount = [...this.managedTargets.values()].filter((source) => source === 'created').length;
+
+    try {
+      discovered = await this.discover();
+      managedTabCount = await this.getManagedTabCount();
+      createdTabCount = this.getCreatedTabCount();
+    } catch (err) {
+      error = err.message;
+    }
+
+    return {
+      connected: socketIsOpen(this.ws),
+      chromePort: discovered?.port ?? this.chromePort ?? null,
+      wsPath: discovered?.wsPath ?? this.chromeWsPath ?? null,
+      sessions: this.sessions.size,
+      managedTabCount,
+      createdTabCount,
+      managedTargets: [...this.managedTargets.entries()].map(([targetId, source]) => ({ targetId, source })),
+      maxManagedTabs: MAX_MANAGED_TABS,
+      error,
+    };
+  }
+
+  async pruneManagedTargets() {
+    if (this.managedTargets.size === 0) {
+      return 0;
+    }
+
+    const openTargets = await this.listTargets();
+    const openTargetIds = new Set(openTargets.map((target) => target.targetId));
+    for (const targetId of this.managedTargets.keys()) {
+      if (!openTargetIds.has(targetId)) {
+        this.managedTargets.delete(targetId);
+        this.sessions.delete(targetId);
+      }
+    }
+
+    return this.managedTargets.size;
+  }
+
+  async getManagedTabCount() {
+    return this.pruneManagedTargets();
+  }
+
+  getCreatedTabCount() {
+    let count = 0;
+    for (const source of this.managedTargets.values()) {
+      if (source === 'created') {
+        count += 1;
+      }
+    }
+    return count;
+  }
+
+  async listTargets() {
+    const response = await this.sendCommand('Target.getTargets');
+    const targets = response.result?.targetInfos?.filter((target) => target.type === 'page') ?? [];
+    return targets.map((target) => ({
+      ...target,
+      isManaged: this.managedTargets.has(target.targetId),
+      managedSource: this.managedTargets.get(target.targetId) ?? null,
+    }));
+  }
+
+  async assertTabExists(targetId) {
+    const targets = await this.listTargets();
+    const target = targets.find((item) => item.targetId === targetId);
+    if (!target) {
+      throw new Error(`目标 tab 不存在: ${targetId}`);
+    }
+    return target;
+  }
+
+  async adoptTab(targetId) {
+    await this.getManagedTabCount();
+    const target = await this.assertTabExists(targetId);
+    if (this.managedTargets.has(targetId)) {
+      return {
+        targetId,
+        title: target.title,
+        url: target.url,
+        managedSource: this.managedTargets.get(targetId),
+        managedTabCount: this.managedTargets.size,
+        createdTabCount: this.getCreatedTabCount(),
+        maxManagedTabs: MAX_MANAGED_TABS,
+      };
+    }
+
+    this.managedTargets.set(targetId, 'adopted');
+    return {
+      targetId,
+      title: target.title,
+      url: target.url,
+      managedSource: 'adopted',
+      managedTabCount: this.managedTargets.size,
+      createdTabCount: this.getCreatedTabCount(),
+      maxManagedTabs: MAX_MANAGED_TABS,
+    };
+  }
+
+  async newTab(url = 'about:blank') {
+    await this.getManagedTabCount();
+    const createdTabCount = this.getCreatedTabCount();
+    if (createdTabCount >= MAX_MANAGED_TABS) {
+      throw new Error(`MCP 新开 tab 配额已达上限 ${MAX_MANAGED_TABS}，请先关闭部分 created 窗口再创建新窗口`);
+    }
+
+    const response = await this.sendCommand('Target.createTarget', {
+      url,
+      background: true,
+    });
+    const targetId = response.result?.targetId;
+    if (!targetId) {
+      throw new Error('创建 tab 失败');
+    }
+    this.managedTargets.set(targetId, 'created');
+
+    if (url !== 'about:blank') {
+      const sessionId = await this.ensureSession(targetId);
+      await this.waitForLoad(sessionId);
+    }
+
+    return {
+      targetId,
+      managedSource: 'created',
+      managedTabCount: this.managedTargets.size,
+      createdTabCount: this.getCreatedTabCount(),
+      maxManagedTabs: MAX_MANAGED_TABS,
+    };
+  }
+
+  async closeTab(targetId) {
+    const response = await this.sendCommand('Target.closeTarget', { targetId });
+    this.sessions.delete(targetId);
+    this.managedTargets.delete(targetId);
+    return {
+      ...(response.result ?? { success: true }),
+      managedTabCount: this.managedTargets.size,
+      createdTabCount: this.getCreatedTabCount(),
+      maxManagedTabs: MAX_MANAGED_TABS,
+    };
+  }
+
+  async closeAllManagedTabs() {
+    await this.getManagedTabCount();
+    const targetIds = [...this.managedTargets.keys()];
+    const closed = [];
+    const failed = [];
+
+    for (const targetId of targetIds) {
+      const source = this.managedTargets.get(targetId) ?? null;
+      try {
+        await this.closeTab(targetId);
+        closed.push({ targetId, source });
+      } catch (error) {
+        failed.push({ targetId, source, error: error.message });
+      }
+    }
+
+    return {
+      requested: targetIds.length,
+      closed,
+      failed,
+      managedTabCount: this.managedTargets.size,
+      createdTabCount: this.getCreatedTabCount(),
+      maxManagedTabs: MAX_MANAGED_TABS,
+    };
+  }
+
+  async closeCreatedTabs() {
+    await this.getManagedTabCount();
+    const targetIds = [...this.managedTargets.entries()]
+      .filter(([, source]) => source === 'created')
+      .map(([targetId]) => targetId);
+    const closed = [];
+    const failed = [];
+
+    for (const targetId of targetIds) {
+      try {
+        await this.closeTab(targetId);
+        closed.push({ targetId, source: 'created' });
+      } catch (error) {
+        failed.push({ targetId, source: 'created', error: error.message });
+      }
+    }
+
+    return {
+      requested: targetIds.length,
+      closed,
+      failed,
+      managedTabCount: this.managedTargets.size,
+      createdTabCount: this.getCreatedTabCount(),
+      maxManagedTabs: MAX_MANAGED_TABS,
+    };
+  }
+
+  async navigate(targetId, url) {
+    const sessionId = await this.ensureSession(targetId);
+    const response = await this.sendCommand('Page.navigate', { url }, sessionId);
+    const loadState = await this.waitForLoad(sessionId);
+    return {
+      frameId: response.result?.frameId ?? null,
+      loaderId: response.result?.loaderId ?? null,
+      loadState,
+    };
+  }
+
+  async goBack(targetId) {
+    const sessionId = await this.ensureSession(targetId);
+    await this.sendCommand('Runtime.evaluate', { expression: 'history.back()' }, sessionId);
+    const loadState = await this.waitForLoad(sessionId);
+    return { success: true, loadState };
+  }
+
+  async pageInfo(targetId) {
+    const sessionId = await this.ensureSession(targetId);
+    const response = await this.sendCommand('Runtime.evaluate', {
+      expression: '({ title: document.title, url: location.href, readyState: document.readyState })',
+      returnByValue: true,
+      awaitPromise: true,
+    }, sessionId);
+    return response.result?.result?.value ?? {};
+  }
+
+  async evaluate(targetId, expression) {
+    const sessionId = await this.ensureSession(targetId);
+    const response = await this.sendCommand('Runtime.evaluate', {
+      expression,
+      returnByValue: true,
+      awaitPromise: true,
+    }, sessionId);
+
+    if (response.result?.exceptionDetails) {
+      throw new Error(response.result.exceptionDetails.text || '页面脚本执行失败');
+    }
+
+    return response.result?.result?.value;
+  }
+
+  async click(targetId, selector) {
+    const selectorLabel = JSON.stringify(selector);
+    const script = `(() => {
+      const selector = ${selectorLabel};
+      const el = document.querySelector(selector);
+      if (!el) return { error: '未找到元素: ' + selector };
+      el.scrollIntoView({ block: 'center' });
+      el.click();
+      return {
+        clicked: true,
+        tag: el.tagName,
+        text: (el.textContent || '').slice(0, 200)
+      };
+    })()`;
+    const result = await this.evaluate(targetId, script);
+    if (result?.error) {
+      throw new Error(result.error);
+    }
+    return result;
+  }
+
+  async clickAt(targetId, selector) {
+    const sessionId = await this.ensureSession(targetId);
+    const selectorLabel = JSON.stringify(selector);
+    const coords = await this.evaluate(targetId, `(() => {
+      const selector = ${selectorLabel};
+      const el = document.querySelector(selector);
+      if (!el) return { error: '未找到元素: ' + selector };
+      el.scrollIntoView({ block: 'center' });
+      const rect = el.getBoundingClientRect();
+      return {
+        x: rect.x + rect.width / 2,
+        y: rect.y + rect.height / 2,
+        tag: el.tagName,
+        text: (el.textContent || '').slice(0, 200)
+      };
+    })()`);
+
+    if (!coords || coords.error) {
+      throw new Error(coords?.error || '无法定位点击坐标');
+    }
+
+    await this.sendCommand('Input.dispatchMouseEvent', {
+      type: 'mousePressed',
+      x: coords.x,
+      y: coords.y,
+      button: 'left',
+      clickCount: 1,
+    }, sessionId);
+
+    await this.sendCommand('Input.dispatchMouseEvent', {
+      type: 'mouseReleased',
+      x: coords.x,
+      y: coords.y,
+      button: 'left',
+      clickCount: 1,
+    }, sessionId);
+
+    return { clicked: true, ...coords };
+  }
+
+  async setFiles(targetId, selector, files) {
+    const sessionId = await this.ensureSession(targetId);
+    await this.sendCommand('DOM.enable', {}, sessionId);
+    const documentNode = await this.sendCommand('DOM.getDocument', {}, sessionId);
+    const node = await this.sendCommand('DOM.querySelector', {
+      nodeId: documentNode.result.root.nodeId,
+      selector,
+    }, sessionId);
+
+    const nodeId = node.result?.nodeId;
+    if (!nodeId) {
+      throw new Error(`未找到元素: ${selector}`);
+    }
+
+    await this.sendCommand('DOM.setFileInputFiles', { nodeId, files }, sessionId);
+    return { success: true, count: files.length };
+  }
+
+  async scroll(targetId, { y = 3000, direction = 'down' } = {}) {
+    const signedY = Math.abs(y);
+    let expression = `window.scrollBy(0, ${signedY}); "scrolled down ${signedY}px"`;
+
+    if (direction === 'up') {
+      expression = `window.scrollBy(0, -${signedY}); "scrolled up ${signedY}px"`;
+    } else if (direction === 'top') {
+      expression = 'window.scrollTo(0, 0); "scrolled to top"';
+    } else if (direction === 'bottom') {
+      expression = 'window.scrollTo(0, document.body.scrollHeight); "scrolled to bottom"';
+    }
+
+    const value = await this.evaluate(targetId, expression);
+    await delay(800);
+    return { value };
+  }
+
+  async screenshot(targetId, { filePath = null, format = 'png' } = {}) {
+    const sessionId = await this.ensureSession(targetId);
+    const response = await this.sendCommand('Page.captureScreenshot', {
+      format,
+      quality: format === 'jpeg' ? 80 : undefined,
+    }, sessionId);
+
+    const base64 = response.result?.data;
+    if (!base64) {
+      throw new Error('截图失败');
+    }
+
+    if (filePath) {
+      fs.writeFileSync(filePath, Buffer.from(base64, 'base64'));
+      return { saved: filePath, format };
+    }
+
+    return { format, data: base64 };
+  }
+}

package/src/index.mjs

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+import { ChromeCdpClient } from './cdp-client.mjs';
+
+const SERVER_INFO = {
+  name: 'web-access-mcp',
+  version: '0.1.0',
+};
+
+const client = new ChromeCdpClient();
+
+const tools = [
+  {
+    name: 'browser_health',
+    description: 'Check Chrome remote debugging status, all managed tabs, and the quota used only by MCP-created tabs.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'list_tabs',
+    description: 'List current Chrome page targets, including whether each tab is managed by this MCP server.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'new_tab',
+    description: 'Create a new background tab and optionally navigate it to a URL. Refuses once MCP-created tabs reach the quota of 10; adopted user tabs do not consume quota.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to open. Defaults to about:blank.' },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'close_tab',
+    description: 'Close a tab by targetId and release one managed tab slot if the tab was created by this MCP server.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+      },
+      required: ['targetId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'close_all_managed_tabs',
+    description: 'Close every tab currently managed by this MCP server, including tabs adopted from the user session.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'close_created_tabs',
+    description: 'Close only MCP-created managed tabs. Adopted user tabs are preserved.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'adopt_tab',
+    description: 'Take over an existing user tab so it becomes managed by this MCP server. Adopted tabs do not consume the 10-tab quota reserved for MCP-created tabs.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+      },
+      required: ['targetId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'navigate',
+    description: 'Navigate an existing tab to a URL and wait for the page to load.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+        url: { type: 'string' },
+      },
+      required: ['targetId', 'url'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'go_back',
+    description: 'Trigger history.back() in an existing tab and wait for the page to load.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+      },
+      required: ['targetId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'page_info',
+    description: 'Read title, current URL, and readyState from a tab.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+      },
+      required: ['targetId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'eval',
+    description: 'Run JavaScript in a page context and return the resulting JSON-serializable value.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+        expression: { type: 'string' },
+      },
+      required: ['targetId', 'expression'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'click',
+    description: 'Use element.click() on the first DOM node matching a CSS selector.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+        selector: { type: 'string' },
+      },
+      required: ['targetId', 'selector'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'click_at',
+    description: 'Perform a real Chrome mouse click on the center of the first element matching a CSS selector.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+        selector: { type: 'string' },
+      },
+      required: ['targetId', 'selector'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'set_files',
+    description: 'Attach local files to a file input selected by CSS.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+        selector: { type: 'string' },
+        files: {
+          type: 'array',
+          items: { type: 'string' },
+          minItems: 1,
+        },
+      },
+      required: ['targetId', 'selector', 'files'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'scroll',
+    description: 'Scroll a page by distance or to top/bottom.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+        y: { type: 'integer', minimum: 0 },
+        direction: {
+          type: 'string',
+          enum: ['down', 'up', 'top', 'bottom'],
+        },
+      },
+      required: ['targetId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'screenshot',
+    description: 'Capture a page screenshot. Returns base64 unless filePath is provided.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetId: { type: 'string' },
+        filePath: { type: 'string' },
+        format: {
+          type: 'string',
+          enum: ['png', 'jpeg'],
+        },
+      },
+      required: ['targetId'],
+      additionalProperties: false,
+    },
+  },
+];
+
+function makeResponse(id, result) {
+  return {
+    jsonrpc: '2.0',
+    id,
+    result,
+  };
+}
+
+function makeError(id, code, message, data = undefined) {
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: {
+      code,
+      message,
+      ...(data === undefined ? {} : { data }),
+    },
+  };
+}
+
+function toolResult(payload) {
+  const text = typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2);
+  return {
+    content: [
+      {
+        type: 'text',
+        text,
+      },
+    ],
+  };
+}
+
+async function runTool(name, args = {}) {
+  switch (name) {
+    case 'browser_health':
+      return toolResult(await client.health());
+    case 'list_tabs':
+      return toolResult(await client.listTargets());
+    case 'new_tab':
+      return toolResult(await client.newTab(args.url));
+    case 'close_tab':
+      return toolResult(await client.closeTab(args.targetId));
+    case 'close_all_managed_tabs':
+      return toolResult(await client.closeAllManagedTabs());
+    case 'close_created_tabs':
+      return toolResult(await client.closeCreatedTabs());
+    case 'adopt_tab':
+      return toolResult(await client.adoptTab(args.targetId));
+    case 'navigate':
+      return toolResult(await client.navigate(args.targetId, args.url));
+    case 'go_back':
+      return toolResult(await client.goBack(args.targetId));
+    case 'page_info':
+      return toolResult(await client.pageInfo(args.targetId));
+    case 'eval':
+      return toolResult(await client.evaluate(args.targetId, args.expression));
+    case 'click':
+      return toolResult(await client.click(args.targetId, args.selector));
+    case 'click_at':
+      return toolResult(await client.clickAt(args.targetId, args.selector));
+    case 'set_files':
+      return toolResult(await client.setFiles(args.targetId, args.selector, args.files));
+    case 'scroll':
+      return toolResult(await client.scroll(args.targetId, {
+        y: args.y,
+        direction: args.direction,
+      }));
+    case 'screenshot':
+      return toolResult(await client.screenshot(args.targetId, {
+        filePath: args.filePath,
+        format: args.format,
+      }));
+    default:
+      throw new Error(`未知工具: ${name}`);
+  }
+}
+
+function writeMessage(message) {
+  const payload = Buffer.from(JSON.stringify(message), 'utf8');
+  process.stdout.write(`Content-Length: ${payload.length}\r\n\r\n`);
+  process.stdout.write(payload);
+}
+
+function parseMessages(onMessage) {
+  let buffer = Buffer.alloc(0);
+
+  process.stdin.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+
+    while (true) {
+      const headerEnd = buffer.indexOf('\r\n\r\n');
+      if (headerEnd === -1) {
+        return;
+      }
+
+      const headerText = buffer.slice(0, headerEnd).toString('utf8');
+      const contentLengthMatch = headerText.match(/Content-Length:\s*(\d+)/i);
+      if (!contentLengthMatch) {
+        throw new Error('缺少 Content-Length 头');
+      }
+
+      const contentLength = Number.parseInt(contentLengthMatch[1], 10);
+      const totalLength = headerEnd + 4 + contentLength;
+      if (buffer.length < totalLength) {
+        return;
+      }
+
+      const body = buffer.slice(headerEnd + 4, totalLength).toString('utf8');
+      buffer = buffer.slice(totalLength);
+      onMessage(JSON.parse(body));
+    }
+  });
+}
+
+async function handleRequest(message) {
+  const { id, method, params } = message;
+
+  try {
+    switch (method) {
+      case 'initialize':
+        return makeResponse(id, {
+          protocolVersion: '2024-11-05',
+          capabilities: {
+            tools: {},
+          },
+          serverInfo: SERVER_INFO,
+        });
+      case 'ping':
+        return makeResponse(id, {});
+      case 'notifications/initialized':
+        return null;
+      case 'tools/list':
+        return makeResponse(id, { tools });
+      case 'tools/call':
+        return makeResponse(id, await runTool(params.name, params.arguments || {}));
+      default:
+        return makeError(id, -32601, `Method not found: ${method}`);
+    }
+  } catch (error) {
+    return makeError(id, -32000, error.message);
+  }
+}
+
+parseMessages(async (message) => {
+  const response = await handleRequest(message);
+  if (response) {
+    writeMessage(response);
+  }
+});