@mallocfeng/chromedev 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mallocfeng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,337 @@
+# ChromeDev
+
+`ChromeDev` 是一个本地命令行工具，用来把 `chrome-devtools-mcp` 作为后台中间件运行，并通过 `--autoConnect` 连接你当前正在使用的 Chrome。
+
+启动后，本地 MCP 地址固定为：
+
+```text
+http://127.0.0.1:8787/mcp
+```
+
+## 快速开始
+
+整个流程只有两步：
+
+1. 在 Chrome 中开启远程调试
+2. 安装并启动 `chromedev` 服务
+
+### 1. 在 Chrome 中开启远程调试
+
+在 Chrome（版本 `>= 144`）中，执行以下操作来设置远程调试：
+
+前往 `chrome://inspect/#remote-debugging` 以启用远程调试。
+
+建议操作：
+
+1. 打开 Chrome。
+2. 在地址栏输入 `chrome://inspect/#remote-debugging`。
+3. 开启远程调试相关选项。
+4. 保持这个 Chrome 实例继续运行。
+
+第一次连接时，Chrome 可能会弹出授权确认框。默认会等待 30 秒。
+
+### 2. 安装并启动服务
+
+推荐直接用 npm 全局安装：
+
+```bash
+npm install -g @mallocfeng/chromedev
+```
+
+安装完成后，后台启动：
+
+```bash
+chromedev run
+```
+
+如果你是在项目源码目录里本地运行，也可以用：
+
+```bash
+node ./bin/chromedev.mjs run
+```
+
+成功后会看到：
+
+```text
+chromedev started in background (pid 12345)
+endpoint: http://127.0.0.1:8787/mcp
+```
+
+这表示服务已经在后台运行，其他 AI 或程序现在可以访问 `http://127.0.0.1:8787/mcp`。
+
+## npm 安装
+
+推荐安装方式：
+
+```bash
+npm install -g @mallocfeng/chromedev
+```
+
+安装完成后可直接使用：
+
+```bash
+chromedev run
+chromedev status
+chromedev stop
+```
+
+如果你不想全局安装，也可以临时执行：
+
+```bash
+npx @mallocfeng/chromedev run
+```
+
+如果用户把这个 GitHub 仓库地址直接发给 AI，AI 应该按下面的步骤理解和执行：
+
+1. 先安装命令行工具：
+
+```bash
+npm install -g @mallocfeng/chromedev
+```
+
+2. 然后启动服务：
+
+```bash
+chromedev run
+```
+
+3. 如果还需要安装 OpenClaw skill，再从 GitHub 下载项目源码，并把 `skills/chromedev` 拷贝到 OpenClaw 的 `skills` 目录。
+
+## 常用命令
+
+后台启动：
+
+```bash
+chromedev run
+```
+
+前台调试：
+
+```bash
+chromedev run --foreground
+```
+
+查看状态：
+
+```bash
+chromedev status
+```
+
+停止服务：
+
+```bash
+chromedev stop
+```
+
+查看日志路径：
+
+```bash
+chromedev logs
+```
+
+如果你是在源码目录里本地运行，把 `chromedev` 换成：
+
+```bash
+node ./bin/chromedev.mjs
+```
+
+## 如何验证服务正常
+
+看状态：
+
+```bash
+chromedev status
+```
+
+看端点是否存在：
+
+```bash
+curl -i http://127.0.0.1:8787/mcp
+```
+
+如果返回 `400 Bad Request` 且内容类似 `No sessionId`，这是正常的，说明 MCP 端点已经存在。
+
+## 命令行访问网页示例
+
+列出当前页面：
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs list_pages
+```
+
+打开 `163.com`：
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs new_page '{"url":"https://www.163.com/","timeout":30000}'
+```
+
+读取当前页面快照：
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs take_snapshot
+```
+
+## 在 OpenClaw 中安装 skill
+
+这个项目里已经包含了一份 skill：
+
+```text
+skills/chromedev
+```
+
+如果你是通过 GitHub 下载项目源码：
+
+1. 打开仓库：`https://github.com/mallocfeng/chromeDev`
+2. 下载项目源码，或者直接 clone：
+
+```bash
+git clone https://github.com/mallocfeng/chromeDev.git
+```
+
+3. 你需要用到的 skill 目录就是：
+
+```text
+chromeDev/skills/chromedev
+```
+
+如果用户把 GitHub 地址直接发给 AI，AI 可以按这套指令执行：
+
+```bash
+git clone https://github.com/mallocfeng/chromeDev.git
+```
+
+然后取出：
+
+```text
+chromeDev/skills/chromedev
+```
+
+再把它复制到 OpenClaw 的 `skills` 目录下。
+
+安装到 OpenClaw 的方法很简单：
+
+1. 把项目目录中的 `skills/chromedev` 目录拷贝到你 OpenClaw 工作目录的 `skills` 文件夹下。
+2. 如果你不清楚这个文件夹在哪里，可以先直接问 OpenClaw，它会告诉你当前 agent 工作目录在哪里。
+3. 拷贝进去以后，运行：
+
+```bash
+openclaw gateway restart
+```
+
+完成后就可以在 OpenClaw 里调用这个 skill。
+
+给 AI 的可执行描述可以直接写成这样：
+
+```text
+从 https://github.com/mallocfeng/chromeDev 下载项目，把其中的 skills/chromedev 目录拷贝到当前 OpenClaw agent 工作目录下的 skills 文件夹，然后执行 openclaw gateway restart。
+```
+
+目录结构应该像这样：
+
+```text
+<openclaw-agent-workdir>/
+  skills/
+    chromedev/
+      SKILL.md
+      agents/openai.yaml
+      scripts/http_mcp_call.mjs
+```
+
+## 在 OpenClaw 中使用
+
+在聊天框中可以直接这样输入：
+
+```text
+/chromedev 调用这个 skills 访问当前打开的纽约时报标签文章，并摘要
+```
+
+或者：
+
+```text
+调用 chromedev 这个 skills，访问纽约时报，并且摘要新闻
+```
+
+这个 skill 会通过本地 `ChromeDev` MCP 服务访问你当前打开的 Chrome，并读取网页内容。
+
+注意：
+
+- OpenClaw 里的 skill 只负责“告诉 AI 怎么调用本地 ChromeDev 服务”
+- 真正提供浏览器访问能力的，还是你本机运行中的 `chromedev run`
+- 所以使用 skill 前，先确认本地 `chromedev` 服务已经启动
+
+## 日志与运行文件
+
+默认文件位置：
+
+- `~/.chromedev/run/chromedev.pid`
+- `~/.chromedev/run/chromedev.out.log`
+- `~/.chromedev/run/chromedev.err.log`
+
+直接查看日志：
+
+```bash
+tail -f ~/.chromedev/run/chromedev.out.log
+tail -f ~/.chromedev/run/chromedev.err.log
+```
+
+## 默认配置
+
+默认参数：
+
+```bash
+CHROME_AUTO_CONNECT=1
+CHROME_CHANNEL=stable
+MCP_HOST=127.0.0.1
+MCP_PORT=8787
+MCP_CONNECTION_TIMEOUT=30000
+MCP_REQUEST_TIMEOUT=30000
+```
+
+如果你要改端口：
+
+```bash
+MCP_PORT=8788 chromedev run
+```
+
+## 常见问题
+
+### 1. `EADDRINUSE: address already in use 127.0.0.1:8787`
+
+说明 `8787` 已经被已有实例占用了。
+
+处理方式：
+
+```bash
+chromedev status
+chromedev stop
+```
+
+或者换端口：
+
+```bash
+MCP_PORT=8788 chromedev run
+```
+
+### 2. Chrome 没有响应
+
+检查这几项：
+
+1. Chrome 是否已经打开
+2. 是否已访问 `chrome://inspect/#remote-debugging`
+3. 远程调试是否已经启用
+4. Chrome 是否弹出了授权确认框但还没有点
+
+### 3. 第一次连接会卡几秒
+
+通常是正常的，可能是：
+
+- Chrome 正在等待授权确认
+- `autoConnect` 正在连接浏览器
+- 页面本身还在加载
+
+## 安全说明
+
+- 服务只应监听本地地址 `127.0.0.1`
+- 不要把 `http://127.0.0.1:8787/mcp` 暴露到公网
+- 不要让不可信程序访问这个端点
+- 这个中间件拥有你当前 Chrome 会话的高权限访问能力

package/bin/chromedev.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process'
+import { mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import process from 'node:process'
+import net from 'node:net'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const projectRoot = dirname(__dirname)
+const appHome = process.env.CHROMEDEV_HOME || join(homedir(), '.chromedev')
+const runDir = join(appHome, 'run')
+const pidFile = join(runDir, 'chromedev.pid')
+const metaFile = join(runDir, 'chromedev.json')
+const outLog = join(runDir, 'chromedev.out.log')
+const errLog = join(runDir, 'chromedev.err.log')
+const daemonScript = join(projectRoot, 'server', 'chrome-mcp-daemon.mjs')
+
+const argv = process.argv.slice(2)
+const command = argv[0] || 'help'
+
+main().catch((error) => {
+  console.error(error.message || String(error))
+  process.exit(1)
+})
+
+async function main() {
+  switch (command) {
+    case 'run':
+    case 'start':
+      await runCommand(argv.slice(1))
+      return
+    case 'stop':
+      await stopCommand()
+      return
+    case 'status':
+      await statusCommand()
+      return
+    case 'logs':
+      logsCommand()
+      return
+    case 'help':
+    case '--help':
+    case '-h':
+      printHelp()
+      return
+    default:
+      throw new Error(`Unknown command: ${command}`)
+  }
+}
+
+async function runCommand(args) {
+  const foreground = args.includes('--foreground') || args.includes('-f')
+  const meta = readMeta()
+  const pid = readPid()
+  const port = Number(process.env.MCP_PORT || meta?.port || '8787')
+
+  if (pid && isProcessRunning(pid)) {
+    console.log(`chromedev is already running (pid ${pid})`)
+    console.log(`endpoint: http://127.0.0.1:${port}/mcp`)
+    return
+  }
+
+  ensureRunDir()
+  cleanupState()
+
+  if (await isPortListening(port)) {
+    throw new Error(`port ${port} is already in use; stop the existing service or set MCP_PORT`)
+  }
+
+  if (foreground) {
+    console.log('starting chromedev in foreground')
+    process.stdout.write(`endpoint: http://127.0.0.1:${port}/mcp\n`)
+    const child = spawn(process.execPath, [daemonScript], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        CHROMEDEV_HOME: appHome,
+      },
+    })
+    child.on('exit', (code) => {
+      process.exit(code ?? 0)
+    })
+    return
+  }
+
+  const stdoutFd = openSync(outLog, 'a')
+  const stderrFd = openSync(errLog, 'a')
+  const child = spawn(process.execPath, [daemonScript], {
+    cwd: projectRoot,
+    detached: true,
+    stdio: ['ignore', stdoutFd, stderrFd],
+    env: {
+      ...process.env,
+      CHROMEDEV_HOME: appHome,
+    },
+  })
+
+  child.unref()
+
+  writeFileSync(pidFile, `${child.pid}\n`)
+  writeMeta(port)
+
+  console.log(`chromedev started in background (pid ${child.pid})`)
+  console.log(`endpoint: http://127.0.0.1:${port}/mcp`)
+  console.log(`stdout: ${outLog}`)
+  console.log(`stderr: ${errLog}`)
+}
+
+async function stopCommand() {
+  const pid = readPid()
+
+  if (!pid) {
+    console.log('chromedev is not running')
+    cleanupState()
+    return
+  }
+
+  if (!isProcessRunning(pid)) {
+    console.log(`stale pid file found for pid ${pid}; cleaning up`)
+    cleanupState()
+    return
+  }
+
+  process.kill(pid, 'SIGTERM')
+
+  const deadline = Date.now() + 5000
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      cleanupState()
+      console.log(`chromedev stopped (pid ${pid})`)
+      return
+    }
+    await sleep(200)
+  }
+
+  process.kill(pid, 'SIGKILL')
+  cleanupState()
+  console.log(`chromedev force-stopped (pid ${pid})`)
+}
+
+async function statusCommand() {
+  const meta = readMeta()
+  const pid = readPid()
+  const port = Number(process.env.MCP_PORT || meta?.port || '8787')
+  const endpoint = `http://127.0.0.1:${port}/mcp`
+
+  if (pid && isProcessRunning(pid)) {
+    console.log(`status: running`)
+    console.log(`pid: ${pid}`)
+    console.log(`endpoint: ${endpoint}`)
+    console.log(`stdout: ${outLog}`)
+    console.log(`stderr: ${errLog}`)
+    return
+  }
+
+  if (await isPortListening(port)) {
+    console.log('status: port in use by another process')
+    console.log(`endpoint: ${endpoint}`)
+    return
+  }
+
+  console.log('status: stopped')
+  console.log(`endpoint: ${endpoint}`)
+}
+
+function logsCommand() {
+  console.log(`stdout: ${outLog}`)
+  console.log(`stderr: ${errLog}`)
+}
+
+function ensureRunDir() {
+  mkdirSync(runDir, { recursive: true })
+}
+
+function cleanupState() {
+  rmSync(pidFile, { force: true })
+  rmSync(metaFile, { force: true })
+}
+
+function readPid() {
+  try {
+    return Number(readFileSync(pidFile, 'utf8').trim())
+  } catch {
+    return null
+  }
+}
+
+function writeMeta(port) {
+  const payload = {
+    port,
+    updatedAt: new Date().toISOString(),
+  }
+  writeFileSync(metaFile, JSON.stringify(payload, null, 2))
+}
+
+function readMeta() {
+  try {
+    return JSON.parse(readFileSync(metaFile, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function isPortListening(port) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host: '127.0.0.1', port })
+    socket.once('connect', () => {
+      socket.destroy()
+      resolve(true)
+    })
+    socket.once('error', () => {
+      resolve(false)
+    })
+  })
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function printHelp() {
+  console.log('chromedev <command>')
+  console.log('')
+  console.log('Commands:')
+  console.log('  run, start        Start the Chrome MCP daemon in background')
+  console.log('  run --foreground  Start in foreground')
+  console.log('  stop              Stop the background daemon')
+  console.log('  status            Show daemon status')
+  console.log('  logs              Print log file locations')
+}

package/launchd/com.local.chrome-mcp-daemon.plist

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>com.local.chrome-mcp-daemon</string>
+
+    <key>ProgramArguments</key>
+    <array>
+      <string>/usr/bin/env</string>
+      <string>npm</string>
+      <string>start</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>/Volumes/MacMiniDisk/project/chromeDev</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+      <key>CHROME_AUTO_CONNECT</key>
+      <string>1</string>
+      <key>CHROME_CHANNEL</key>
+      <string>stable</string>
+      <key>MCP_HOST</key>
+      <string>127.0.0.1</string>
+      <key>MCP_PORT</key>
+      <string>8787</string>
+      <key>MCP_CONNECTION_TIMEOUT</key>
+      <string>30000</string>
+      <key>MCP_REQUEST_TIMEOUT</key>
+      <string>30000</string>
+    </dict>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>/tmp/chrome-mcp-daemon.out.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/tmp/chrome-mcp-daemon.err.log</string>
+  </dict>
+</plist>

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@mallocfeng/chromedev",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI that exposes chrome-devtools-mcp as a local background service connected to your live Chrome browser.",
+  "license": "MIT",
+  "author": "mallocfeng",
+  "homepage": "https://github.com/mallocfeng/chromeDev#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mallocfeng/chromeDev.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mallocfeng/chromeDev/issues"
+  },
+  "keywords": [
+    "chrome",
+    "mcp",
+    "devtools",
+    "cli",
+    "browser",
+    "automation"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "server",
+    "skills",
+    "launchd",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "chromedev": "./bin/chromedev.mjs"
+  },
+  "scripts": {
+    "start": "node ./server/chrome-mcp-daemon.mjs",
+    "start:headless": "CHROME_HEADLESS=1 node ./server/chrome-mcp-daemon.mjs",
+    "cli": "node ./bin/chromedev.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "chrome-devtools-mcp": "^0.20.1",
+    "mcp-proxy": "^6.4.4"
+  }
+}

package/server/chrome-mcp-daemon.mjs

@@ -0,0 +1,159 @@
+import { spawn } from 'node:child_process'
+import { existsSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import process from 'node:process'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const projectRoot = dirname(__dirname)
+const appHome = process.env.CHROMEDEV_HOME || join(homedir(), '.chromedev')
+
+const HOST = process.env.MCP_HOST || '127.0.0.1'
+const MCP_PORT = Number(process.env.MCP_PORT || '8787')
+const DEBUG_PORT = Number(process.env.CHROME_DEBUG_PORT || '9222')
+const PROFILE_DIR = process.env.CHROME_USER_DATA_DIR || join(appHome, 'chrome-profile')
+const HEADLESS = ['1', 'true', 'yes'].includes(String(process.env.CHROME_HEADLESS || '').toLowerCase())
+const AUTO_CONNECT = !['0', 'false', 'no'].includes(String(process.env.CHROME_AUTO_CONNECT || '1').toLowerCase())
+const MCP_CONNECTION_TIMEOUT = Number(process.env.MCP_CONNECTION_TIMEOUT || '30000')
+const MCP_REQUEST_TIMEOUT = Number(process.env.MCP_REQUEST_TIMEOUT || '30000')
+const CHROME_PATH = process.env.CHROME_PATH || detectChromePath()
+
+if (!AUTO_CONNECT && !CHROME_PATH) {
+  console.error('Chrome executable not found. Set CHROME_PATH and retry.')
+  process.exit(1)
+}
+
+if (!AUTO_CONNECT) {
+  mkdirSync(PROFILE_DIR, { recursive: true })
+}
+
+let chromeProcess
+let proxyProcess
+
+main().catch((error) => {
+  console.error('[daemon] fatal error:', error)
+  shutdown(1)
+})
+
+async function main() {
+  const args = [
+    '--host',
+    HOST,
+    '--port',
+    String(MCP_PORT),
+    '--server',
+    'stream',
+    '--connectionTimeout',
+    String(MCP_CONNECTION_TIMEOUT),
+    '--requestTimeout',
+    String(MCP_REQUEST_TIMEOUT),
+    '--',
+    localBin('chrome-devtools-mcp'),
+    '--no-usage-statistics',
+  ]
+
+  if (AUTO_CONNECT) {
+    console.log('[daemon] using Chrome autoConnect mode against the running browser...')
+    console.log(`[daemon] exposing MCP on http://${HOST}:${MCP_PORT}/mcp`)
+    args.push('--autoConnect')
+    if (process.env.CHROME_CHANNEL) {
+      args.push('--channel', process.env.CHROME_CHANNEL)
+    }
+  } else {
+    console.log('[daemon] launching Chrome with persistent remote debugging...')
+    chromeProcess = spawn(CHROME_PATH, chromeArgs(), {
+      stdio: 'inherit',
+    })
+    chromeProcess.once('exit', (code, signal) => {
+      console.error(`[daemon] Chrome exited (code=${code ?? 'null'}, signal=${signal ?? 'null'})`)
+      shutdown(code ?? 1)
+    })
+
+    await waitForChrome(`http://127.0.0.1:${DEBUG_PORT}/json/version`, 30_000)
+
+    console.log(`[daemon] Chrome debugger ready on http://127.0.0.1:${DEBUG_PORT}`)
+    console.log(`[daemon] exposing MCP on http://${HOST}:${MCP_PORT}/mcp`)
+    args.push('--browserUrl', `http://127.0.0.1:${DEBUG_PORT}`)
+  }
+
+  proxyProcess = spawn(localBin('mcp-proxy'), args, {
+    stdio: 'inherit',
+  })
+
+  proxyProcess.once('exit', (code, signal) => {
+    console.error(`[daemon] mcp-proxy exited (code=${code ?? 'null'}, signal=${signal ?? 'null'})`)
+    shutdown(code ?? 1)
+  })
+
+  process.on('SIGINT', () => shutdown(0))
+  process.on('SIGTERM', () => shutdown(0))
+}
+
+function chromeArgs() {
+  const args = [
+    `--remote-debugging-port=${DEBUG_PORT}`,
+    `--user-data-dir=${PROFILE_DIR}`,
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-background-networking',
+    '--disable-sync',
+  ]
+
+  if (HEADLESS) {
+    args.push('--headless=new')
+  }
+
+  return args
+}
+
+async function waitForChrome(url, timeoutMs) {
+  const start = Date.now()
+  let lastError
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const response = await fetch(url)
+      if (response.ok) {
+        return
+      }
+      lastError = new Error(`HTTP ${response.status}`)
+    } catch (error) {
+      lastError = error
+    }
+    await sleep(500)
+  }
+
+  throw new Error(`Chrome debugger did not become ready within ${timeoutMs}ms: ${String(lastError)}`)
+}
+
+function detectChromePath() {
+  const candidates = [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  ]
+
+  return candidates.find((candidate) => existsSync(candidate))
+}
+
+function localBin(name) {
+  const suffix = process.platform === 'win32' ? '.cmd' : ''
+  return join(projectRoot, 'node_modules', '.bin', `${name}${suffix}`)
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+function shutdown(code) {
+  if (proxyProcess && !proxyProcess.killed) {
+    proxyProcess.kill('SIGTERM')
+  }
+  if (chromeProcess && !chromeProcess.killed) {
+    chromeProcess.kill('SIGTERM')
+  }
+  process.exit(code)
+}

package/skills/chromedev/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: chromedev
+description: Use this skill when you need to access or control a live Chrome browser through the local Chrome DevTools MCP middleware at http://127.0.0.1:8787/mcp, especially for opening pages, extracting rendered content, interacting with DOM elements, taking snapshots, or collecting data from websites.
+---
+
+# chromedev
+
+Use this skill when the user wants browser-backed data from real web pages through the local `chrome-devtools-mcp` middleware running at `http://127.0.0.1:8787/mcp`.
+
+This skill is for cases where rendered browser state matters: JavaScript-heavy sites, login state in the user's Chrome, interaction flows, screenshots, DOM snapshots, or page data that should come from the live browser instead of plain HTTP fetches.
+
+## Preconditions
+
+- The local middleware must already be running on `127.0.0.1:8787`.
+- The middleware usually runs via the user's `chromeDev` project and uses Chrome `--autoConnect`.
+- On first connection, Chrome may show a remote-debugging authorization prompt. Wait up to 30 seconds for the user to approve it.
+
+Quick endpoint check:
+
+```bash
+curl -i http://127.0.0.1:8787/mcp
+```
+
+A response like `400 Bad Request` with `No sessionId` means the endpoint exists and is healthy.
+
+## Workflow
+
+1. Confirm the middleware is reachable.
+2. Connect to `http://127.0.0.1:8787/mcp`.
+3. Use MCP browser tools to open or select a page.
+4. Prefer `take_snapshot` or `evaluate_script` for structured extraction.
+5. Use `wait_for` when content depends on async rendering.
+6. Return the extracted data, not raw protocol noise.
+
+## Preferred tool order
+
+- `list_pages`: inspect current browser pages before changing state.
+- `new_page`: open a URL when the user wants navigation.
+- `select_page`: switch to the relevant tab before reading or interacting.
+- `take_snapshot`: get accessible text/structure from the current page.
+- `evaluate_script`: extract structured values from the live DOM.
+- `wait_for`: wait for a known string when the page is still rendering.
+- `take_screenshot`: use only when the visual result matters.
+
+## Command-line client
+
+This skill includes a reusable script:
+
+- [`scripts/http_mcp_call.mjs`](/Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs)
+
+It connects to the local HTTP MCP endpoint and calls one tool.
+
+If `@modelcontextprotocol/sdk` is missing in the current workspace, install it in that workspace first:
+
+```bash
+npm install @modelcontextprotocol/sdk
+```
+
+## Common commands
+
+List current pages:
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs list_pages
+```
+
+Open `163.com`:
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs new_page '{"url":"https://www.163.com/","timeout":30000}'
+```
+
+Get the current page snapshot:
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs take_snapshot
+```
+
+Extract page title and URL:
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs evaluate_script '{"function":"() => ({ title: document.title, url: location.href })"}'
+```
+
+Wait for specific text:
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs wait_for '{"text":["网易","163"],"timeout":30000}'
+```
+
+## Extraction guidance
+
+- Use `take_snapshot` for readable page summaries, navigation labels, and visible content.
+- Use `evaluate_script` for precise fields, arrays, links, prices, tables, or JSON-shaped output.
+- Use `wait_for` before reading if the site is client-rendered or slow.
+- Use `list_network_requests` and `get_network_request` only when DOM extraction is insufficient.
+
+## Example patterns
+
+For article text:
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs evaluate_script '{"function":"() => ({ title: document.title, text: document.body.innerText.slice(0, 4000) })"}'
+```
+
+For links on the page:
+
+```bash
+node /Volumes/MacMiniDisk/project/chromeDev/skills/chromedev/scripts/http_mcp_call.mjs evaluate_script '{"function":"() => Array.from(document.querySelectorAll(\"a\")).slice(0,50).map(a => ({ text: (a.innerText || a.textContent || \"\").trim(), href: a.href })).filter(x => x.href)"}'
+```
+
+## Operational notes
+
+- Keep the browser state intact unless the user asked for navigation or interaction.
+- If a tool call hangs near connection start, assume Chrome may be waiting for the authorization dialog.
+- Prefer returning concise extracted data over full raw snapshots unless the user asked for raw output.
+- Do not expose the local MCP endpoint outside `127.0.0.1`.

package/skills/chromedev/agents/openai.yaml

@@ -0,0 +1,15 @@
+interface:
+  display_name: "ChromeDev"
+  short_description: "Use local Chrome MCP for live browsing"
+  default_prompt: "Use $chromedev to access the user's live Chrome through the local MCP middleware and extract data from webpages."
+
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "chromedev-local"
+      description: "Local chrome-devtools-mcp middleware for browser access"
+      transport: "streamable_http"
+      url: "http://127.0.0.1:8787/mcp"
+
+policy:
+  allow_implicit_invocation: true

package/skills/chromedev/scripts/http_mcp_call.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
+import process from 'node:process'
+
+async function main() {
+  const [toolName, rawArgs] = process.argv.slice(2)
+
+  if (!toolName) {
+    printUsage()
+    process.exit(1)
+  }
+
+  let args = {}
+  if (rawArgs) {
+    try {
+      args = JSON.parse(rawArgs)
+    } catch (error) {
+      console.error(`Invalid JSON args: ${error.message}`)
+      process.exit(1)
+    }
+  }
+
+  let Client
+  let StreamableHTTPClientTransport
+  try {
+    const require = createRequire(import.meta.url)
+    const clientModule = require.resolve('@modelcontextprotocol/sdk/client/index.js', {
+      paths: [process.cwd()],
+    })
+    const transportModule = require.resolve('@modelcontextprotocol/sdk/client/streamableHttp.js', {
+      paths: [process.cwd()],
+    })
+    ;({ Client } = await import(pathToFileURL(clientModule).href))
+    ;({ StreamableHTTPClientTransport } = await import(pathToFileURL(transportModule).href))
+  } catch (error) {
+    console.error('Missing dependency: @modelcontextprotocol/sdk')
+    console.error('Install it in the current workspace with: npm install @modelcontextprotocol/sdk')
+    console.error(String(error))
+    process.exit(1)
+  }
+
+  const endpoint = process.env.CHROMEDEV_MCP_URL || 'http://127.0.0.1:8787/mcp'
+  const client = new Client({ name: 'chromedev-skill-client', version: '1.0.0' }, { capabilities: {} })
+  const transport = new StreamableHTTPClientTransport(new URL(endpoint))
+
+  try {
+    await client.connect(transport)
+    const result = await client.callTool({ name: toolName, arguments: args })
+    console.log(JSON.stringify(result, null, 2))
+  } finally {
+    await transport.close().catch(() => {})
+  }
+}
+
+function printUsage() {
+  console.error('Usage: http_mcp_call.mjs <tool_name> [json_args]')
+  console.error("Example: http_mcp_call.mjs new_page '{\"url\":\"https://www.163.com/\",\"timeout\":30000}'")
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})