mooncat-browser 0.1.0

package/browser-op/cdp/chrome-launcher.cjs

@@ -0,0 +1,370 @@
+// -*- coding: utf-8 -*-
+//
+// launcher.cjs — CDP 模式浏览器启动器。
+// 完整复刻自 bee/packages/app/browser-op/main/cdp-browser-launcher.ts（去 DI、纯 JS）。
+//
+// 职责：
+//   - spawn Chrome（带 --remote-debugging-port 或不带，enableCdpPort 控制）
+//   - 分配空闲端口（listen 0 拿可用端口）
+//   - 等 CDP endpoint 就绪（轮询 http://127.0.0.1:<port>/json/version 拿 webSocketDebuggerUrl）
+//   - 停止进程（Win 用 taskkill /T /F，Unix 用 SIGTERM→SIGKILL）
+
+'use strict'
+
+const { execFile, spawn } = require('node:child_process')
+const { createServer } = require('node:net')
+const { join } = require('node:path')
+const { promisify } = require('node:util')
+const http = require('node:http')
+const fs = require('node:fs')
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * 跨进程检测某个 user-data-dir 的 Chrome 是否正在运行, 并返回其 CDP 端点。
+ *
+ * 背景：AI 协作场景下每个脚本是独立 node 进程, 进程内的 launcher.isRunning
+ * 只能看本进程启的 Chrome, 看不到别的进程启的同一 profile。每个脚本都
+ * 以为"还没开"又启动一个 Chrome, 同一 user-data-dir 被启 N 次 = N 个窗口。
+ *
+ * 正确做法：Chrome 用 --remote-debugging-port 启动后, 会把端口和 ws path
+ * 写进 user-data-dir/DevToolsActivePort 文件 (Chrome 原生机制)。别的进程
+ * 读这个文件拿端点, 直接 connectOverCDP 连上去, 不要再 spawn。
+ *
+ * @param {string} userDataDir
+ * @param {number[]=} candidatePorts  兼容用：手动指定端口时试探 (一般留空, 靠 DevToolsActivePort)
+ * @returns {Promise<{inUse:boolean, port?:number, wsEndpoint?:string, via:string}>}
+ */
+async function isProfileInUse (userDataDir, candidatePorts = []) {
+  // 1. 读 Chrome 原生的 DevToolsActivePort 文件 (最可靠)
+  if (userDataDir) {
+    const endpoint = readDevToolsActivePort(userDataDir)
+    if (endpoint && await isCdpPortAlive(endpoint.port)) {
+      return {
+        inUse: true,
+        port: endpoint.port,
+        wsEndpoint: `ws://127.0.0.1:${endpoint.port}${endpoint.wsPath}`,
+        via: 'devtools-active-port'
+      }
+    }
+  }
+  // 2. fallback: 试连手工指定的端口
+  for (const port of candidatePorts) {
+    if (await isCdpPortAlive(port)) {
+      // 拿该端口的 ws path
+      const wsPath = await fetchBrowserWsPath(port)
+      return { inUse: true, port, wsEndpoint: `ws://127.0.0.1:${port}${wsPath}`, via: 'cdp-port' }
+    }
+  }
+  return { inUse: false, via: 'none' }
+}
+
+/**
+ * 读 user-data-dir/DevToolsActivePort 文件。
+ * 格式: 第一行端口, 第二行 ws path (如 /devtools/browser/<uuid>)。
+ * 返回 { port, wsPath } 或 null。
+ */
+function readDevToolsActivePort (userDataDir) {
+  try {
+    const f = join(userDataDir, 'DevToolsActivePort')
+    if (!fs.existsSync(f)) return null
+    const raw = fs.readFileSync(f, 'utf8').trim()
+    const lines = raw.split(/\r?\n/)
+    const port = parseInt(lines[0], 10)
+    const wsPath = lines[1] || ''
+    if (!port || !wsPath) return null
+    return { port, wsPath }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 从 /json/version 拿 browser 的 ws path (fallback 用)。
+ */
+async function fetchBrowserWsPath (port) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/json/version`, { timeout: 800 }, (res) => {
+      let body = ''
+      res.on('data', (c) => { body += c })
+      res.on('end', () => {
+        try { resolve(JSON.parse(body).webSocketDebuggerUrl.replace(/^ws:\/\/[^/]+/, '') || '') }
+        catch { resolve('') }
+      })
+    })
+    req.on('timeout', () => { req.destroy(); resolve('') })
+    req.on('error', () => resolve(''))
+  })
+}
+
+/**
+ * 探测某个端口是否有 Chrome CDP 服务在监听。
+ * GET http://127.0.0.1:port/json/version 200 即活。
+ */
+function isCdpPortAlive (port) {
+  return new Promise((resolve) => {
+    const req = http.get(
+      `http://127.0.0.1:${port}/json/version`,
+      { timeout: 400 },
+      (res) => {
+        res.resume()
+        resolve(res.statusCode === 200)
+      }
+    )
+    req.on('timeout', () => { req.destroy(); resolve(false) })
+    req.on('error', () => resolve(false))
+  })
+}
+
+/**
+ * @typedef {Object} CdpLaunchResult
+ * @property {boolean} ok
+ * @property {number=} port
+ * @property {string=} wsEndpoint
+ * @property {string=} error
+ */
+
+/**
+ * @typedef {Object} CdpLaunchOptions
+ * @property {string} executablePath
+ * @property {string} userDataDir
+ * @property {string=} url
+ * @property {boolean=} headless
+ * @property {number=} preferPort
+ * @property {NodeJS.ProcessEnv=} environment
+ * @property {boolean=} enableCdpPort  true(默认)=CDP 模式；false=插件模式（纯 WS，不可 CDP 连）
+ */
+
+class CdpBrowserLauncher {
+  constructor () {
+    this.chromeProcess = null
+    this.closeCallbacks = new Set()
+    this.activeResult = null
+    this.intentionalStop = false
+  }
+
+  onClose (callback) {
+    this.closeCallbacks.add(callback)
+    return () => this.closeCallbacks.delete(callback)
+  }
+
+  async findAvailablePort () {
+    return new Promise((resolve, reject) => {
+      const server = createServer()
+      server.unref()
+      server.on('error', reject)
+      server.listen(0, '127.0.0.1', () => {
+        const port = server.address().port
+        server.close(() => resolve(port))
+      })
+    })
+  }
+
+  get isRunning () {
+    return this.chromeProcess !== null && !hasProcessExited(this.chromeProcess)
+  }
+
+  get processId () {
+    return this.chromeProcess ? this.chromeProcess.pid : undefined
+  }
+
+  get currentResult () {
+    return this.activeResult
+  }
+
+  /**
+   * @param {CdpLaunchOptions} options
+   * @returns {Promise<CdpLaunchResult>}
+   */
+  async launch (options) {
+    if (this.isRunning && this.activeResult) return this.activeResult
+
+    const enableCdpPort = options.enableCdpPort !== false
+    const port = enableCdpPort && options.preferPort && options.preferPort > 0
+      ? options.preferPort
+      : enableCdpPort
+        ? await this.findAvailablePort()
+        : undefined
+
+    const args = [
+      ...(port != null ? [`--remote-debugging-port=${port}`] : []),
+      `--user-data-dir=${options.userDataDir}`,
+      '--no-first-run',
+      '--no-default-browser-check'
+    ]
+    if (options.headless) args.push('--headless=new')
+
+    // NOTE: 不在启动参数里带业务 URL，避免 Chrome 一启动就被风控脚本采集
+    // （对齐 mooncat：先启动空白页，连接后再由 page.goto 导航）
+
+    let spawnError
+    try {
+      const child = spawn(options.executablePath, args, {
+        stdio: 'ignore',
+        detached: true,
+        windowsHide: true,
+        env: options.environment || process.env
+      })
+      child.unref()
+      this.chromeProcess = child
+      this.intentionalStop = false
+
+      child.once('error', (error) => {
+        spawnError = error
+      })
+      child.once('close', () => {
+        if (this.chromeProcess !== child) return
+        this.chromeProcess = null
+        this.activeResult = null
+        if (!this.intentionalStop) {
+          for (const cb of this.closeCallbacks) cb()
+        }
+      })
+
+      // 插件模式（无端口）：不等 CDP 端点，只确认进程活着即可
+      if (port == null) {
+        await waitForProcessReady(child, 8000)
+        this.activeResult = { ok: true }
+        return this.activeResult
+      }
+      const wsEndpoint = await this.waitForEndpoint(child, port, 15000, () => spawnError)
+      this.activeResult = { ok: true, port, wsEndpoint }
+      return this.activeResult
+    } catch (error) {
+      await this.stop()
+      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  }
+
+  async waitForEndpoint (child, port, timeoutMs, getSpawnError) {
+    const url = `http://127.0.0.1:${port}/json/version`
+    const deadline = Date.now() + timeoutMs
+    let lastError = ''
+
+    while (Date.now() < deadline) {
+      const spawnError = getSpawnError()
+      if (spawnError) throw spawnError
+      if (hasProcessExited(child)) {
+        throw new Error(
+          `Chrome exited before CDP was ready: ${child.exitCode || child.signalCode || 'unknown'}`
+        )
+      }
+      try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(2000) })
+        if (!response.ok) throw new Error(`CDP responded with HTTP ${response.status}`)
+        const data = await response.json()
+        if (data.webSocketDebuggerUrl) return data.webSocketDebuggerUrl
+        lastError = 'webSocketDebuggerUrl not in response'
+      } catch (error) {
+        lastError = error instanceof Error ? error.message : String(error)
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250))
+    }
+    throw new Error(`CDP endpoint not ready after ${timeoutMs}ms: ${lastError}`)
+  }
+
+  getUserDataDir (profileRoot, profileId = 'default') {
+    return join(profileRoot, profileId)
+  }
+
+  async stop () {
+    // close 语义 (handshake-first 后):
+    //   - chromeProcess 有值 = 本次 browserd 启动的 Chrome → 杀
+    //   - chromeProcess 为 null = 复用已有 session (attach) → 不杀, 只让上层关 browserd/17321
+    //     (杀用户真实浏览器是严重事故)
+    const child = this.chromeProcess
+    if (!child) {
+      this.activeResult = null
+      return
+    }
+    this.intentionalStop = true
+    this.activeResult = null
+    const closePromise = waitForProcessClose(child, 5000)
+
+    try {
+      let terminationError
+      if (process.platform === 'win32' && child.pid) {
+        const systemRoot = process.env.SystemRoot || 'C:\\Windows'
+        const taskkill = join(systemRoot, 'System32', 'taskkill.exe')
+        try {
+          await execFileAsync(taskkill, ['/PID', String(child.pid), '/T', '/F'], {
+            windowsHide: true
+          })
+        } catch (error) {
+          terminationError = error
+        }
+      } else {
+        child.kill('SIGTERM')
+      }
+
+      const closed = await closePromise
+      if (!closed && process.platform !== 'win32' && !hasProcessExited(child)) {
+        child.kill('SIGKILL')
+        await waitForProcessClose(child, 2000)
+      }
+      if (process.platform === 'win32' && !closed && !hasProcessExited(child)) {
+        throw new Error(`Chrome process tree did not exit: PID ${child.pid}`)
+      }
+      if (terminationError && !hasProcessExited(child)) throw terminationError
+    } finally {
+      if (this.chromeProcess === child) this.chromeProcess = null
+      this.intentionalStop = false
+    }
+  }
+}
+
+async function waitForProcessClose (child, timeoutMs) {
+  if (hasProcessExited(child)) return true
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      child.removeListener('close', onClose)
+      resolve(false)
+    }, timeoutMs)
+    const onClose = () => {
+      clearTimeout(timeout)
+      resolve(true)
+    }
+    child.once('close', onClose)
+  })
+}
+
+function hasProcessExited (child) {
+  return child.exitCode !== null || child.signalCode !== null
+}
+
+/**
+ * 等待进程 spawn 完成（插件模式用，无 CDP 端口可探）。
+ * 给一点时间让 Chrome 起来；若 spawn 后迅速退出或报 error 则抛出。
+ */
+async function waitForProcessReady (child, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let done = false
+    const finish = (fn) => {
+      if (done) return
+      done = true
+      child.removeListener('error', onError)
+      child.removeListener('close', onClose)
+      fn()
+    }
+    const onError = (err) =>
+      finish(() => reject(new Error(`Chrome failed to start: ${err.message}`)))
+    const onClose = () =>
+      finish(() => reject(new Error(
+        `Chrome exited immediately: ${child.exitCode || child.signalCode || 'unknown'}`
+      )))
+    child.once('error', onError)
+    child.once('close', onClose)
+    setTimeout(() => {
+      if (!hasProcessExited(child)) finish(() => resolve())
+    }, 1500)
+    setTimeout(() => {
+      finish(() =>
+        hasProcessExited(child)
+          ? reject(new Error('Chrome exited during startup'))
+          : resolve()
+      )
+    }, timeoutMs)
+  })
+}
+
+module.exports = { CdpBrowserLauncher, isProfileInUse, isCdpPortAlive, readDevToolsActivePort }

package/browser-op/cdp/chrome-path.cjs

@@ -0,0 +1,57 @@
+// -*- coding: utf-8 -*-
+//
+// chrome-path.cjs — 按操作系统自动检测 Chrome 安装路径。
+// 完整复刻自 bee/packages/app/browser-op/main/chrome-path-resolver.ts。
+//
+// 检测顺序：
+//   Windows: %LOCALAPPDATA% → Program Files → Program Files (x86)
+//   macOS:   /Applications/Google Chrome.app
+//   Linux:   /usr/bin/google-chrome → chromium-browser
+
+'use strict'
+
+const { existsSync } = require('node:fs')
+const { platform } = require('node:os')
+
+class ChromePathResolver {
+  /** 尝试所有已知路径，返回第一个存在的路径。全部不存在返回 null */
+  detect () {
+    const candidates = this.getCandidates()
+    for (const candidate of candidates) {
+      if (existsSync(candidate)) return candidate
+    }
+    return null
+  }
+
+  getCandidates () {
+    switch (platform()) {
+      case 'win32': return this.getWindowsCandidates()
+      case 'darwin': return this.getMacOsCandidates()
+      case 'linux': return this.getLinuxCandidates()
+      default: return []
+    }
+  }
+
+  getWindowsCandidates () {
+    const localAppData = process.env.LOCALAPPDATA || ''
+    const candidates = []
+    if (localAppData) {
+      candidates.push(`${localAppData}\\Google\\Chrome\\Application\\chrome.exe`)
+    }
+    candidates.push(
+      'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+      'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'
+    )
+    return candidates
+  }
+
+  getMacOsCandidates () {
+    return ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome']
+  }
+
+  getLinuxCandidates () {
+    return ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium-browser']
+  }
+}
+
+module.exports = { ChromePathResolver }

package/browser-op/cdp/state.cjs

@@ -0,0 +1,89 @@
+// -*- coding: utf-8 -*-
+//
+// lib/cdp/state.cjs — CDP 路由专属运行时状态。
+//
+// CDP 路由的跨进程复用靠 wsEndpoint 字符串 (对齐 playwright/puppeteer):
+//   主进程 launch 成功 → 把 wsEndpoint/port 写入 <userDataDir>/.cdp-endpoint
+//   子进程 open 开头 → 读该文件, 有且端口活着 → connectOverCDP 复用, 不再 spawn
+//
+// 文件位置: <userDataDir>/.cdp-endpoint
+
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const http = require('node:http')
+
+const STATE_FILENAME = '.cdp-endpoint'
+
+function statePath (userDataDir) {
+  return path.join(userDataDir, STATE_FILENAME)
+}
+
+/** 读 CDP 状态。返回 { wsEndpoint, port, pid, updatedAt } 或 null。 */
+function read (userDataDir) {
+  try {
+    const p = statePath(userDataDir)
+    if (!fs.existsSync(p)) return null
+    return JSON.parse(fs.readFileSync(p, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/** 写 CDP 状态 (主进程 launch 拿到 wsEndpoint 后调)。 */
+function write (userDataDir, info) {
+  try {
+    const p = statePath(userDataDir)
+    fs.mkdirSync(path.dirname(p), { recursive: true })
+    fs.writeFileSync(p, JSON.stringify({
+      wsEndpoint: info.wsEndpoint || null,
+      port: info.port || null,
+      pid: info.pid || process.pid,
+      updatedAt: Date.now()
+    }, null, 2))
+  } catch { /* ignore */ }
+}
+
+/** 清 CDP 状态 (close 后调)。 */
+function clear (userDataDir) {
+  try {
+    const p = statePath(userDataDir)
+    if (fs.existsSync(p)) fs.unlinkSync(p)
+  } catch { /* ignore */ }
+}
+
+/** 探测 CDP 端口是否还活着 (GET /json/version 200)。 */
+function isPortAlive (port, timeoutMs = 500) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/json/version`, { timeout: timeoutMs }, (res) => {
+      res.resume()
+      resolve(res.statusCode === 200)
+    })
+    req.on('timeout', () => { req.destroy(); resolve(false) })
+    req.on('error', () => resolve(false))
+  })
+}
+
+/**
+ * 读状态 + 验证端口存活, 返回是否可复用。
+ * @returns {Promise<{active:boolean, wsEndpoint?:string, port?:number, via:string}>}
+ */
+async function probe (userDataDir) {
+  const st = read(userDataDir)
+  if (!st) return { active: false, via: 'no-state' }
+  if (!st.port) return { active: false, via: 'no-port' }
+  const alive = await isPortAlive(st.port)
+  if (!alive) return { active: false, via: 'port-dead' }
+  return { active: true, wsEndpoint: st.wsEndpoint, port: st.port, via: 'cdp-alive' }
+}
+
+module.exports = {
+  STATE_FILENAME,
+  statePath,
+  read,
+  write,
+  clear,
+  isPortAlive,
+  probe
+}