eze-is/web-access

"name": "一泽 Eze"   },   "homepage": "https://github.com/eze-is/web-access",

},   "homepage": "https://github.com/eze-is/web-access",   "repository": "https://github.com/eze-is/web-access",

"homepage": "https://github.com/eze-is/web-access",

"repository": "https://github.com/eze-is/web-access",

<div>       <div align="center">         <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=en">English</a>

<div align="center">         <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=en">English</a>         | <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=zh-CN">简体中文</a>

<a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=en">English</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=zh-CN">简体中文</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=zh-TW">繁體中文</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=ja">日本語</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=ko">한국어</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=fr">Français</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=de">Deutsch</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=es">Español</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=pt">Português</a>

| <a href="https://openaitx.github.io/view.html?user=eze-is&project=web-access&lang=ru">Русский</a>

<img width="879" height="376" alt="image" src="https://github.com/user-attachments/assets/a87fd816-a0b5-4264-b01c-9466eae90723" />

<p align="center">   <b>给 AI Agent 装上完整联网能力的 Skill。</b><br/>   <a href="https://web-access.eze.is">🌐 官网</a> · <a href="https://mp.weixin.qq.com/s/rps5YVB6TchT9npAaIWKCw">📖 设计详解</a> · <a href="#安装">⚡ 快速安装</a>

<b>给 AI Agent 装上完整联网能力的 Skill。</b><br/>   <a href="https://web-access.eze.is">🌐 官网</a> · <a href="https://mp.weixin.qq.com/s/rps5YVB6TchT9npAaIWKCw">📖 设计详解</a> · <a href="#安装">⚡ 快速安装</a> </p>

<a href="https://web-access.eze.is">🌐 官网</a> · <a href="https://mp.weixin.qq.com/s/rps5YVB6TchT9npAaIWKCw">📖 设计详解</a> · <a href="#安装">⚡ 快速安装</a>

> 推荐必读：[Web Access：一个 Skill，拉满 Agent 联网和浏览器能力](https://mp.weixin.qq.com/s/rps5YVB6TchT9npAaIWKCw) ，完整介绍了 Web-Access Skill 的开发细节与 Agent Skill 设计哲学，帮助你也能写出类似通用、高上限的 Skill

> > ```text > 我要把 web-access 升级到 v2.6。升级前请先迁移我的数据：找到当前 web-access skill 的安装目录，把其中的 config.env 复制到 ~/.web-access/config.env，把 references/site-patterns/ 整个文件夹（含子文件夹）复制到 ~/.web-access/site-patterns/（Windows 上 ~ 指 %USERPROFILE%），已存在的文件不要覆盖；确认复制

> ```text > 我要把 web-access 升级到 v2.6。升级前请先迁移我的数据：找到当前 web-access skill 的安装目录，把其中的 config.env 复制到 ~/.web-access/config.env，把 references/site-patterns/ 整个文件夹（含子文件夹）复制到 ~/.web-access/site-patterns/（Windows 上 ~ 指 %USERPROFILE%），已存在的文件不要覆盖；确认复制成功

> 我要把 web-access 升级到 v2.6。升级前请先迁移我的数据：找到当前 web-access skill 的安装目录，把其中的 config.env 复制到 ~/.web-access/config.env，把 references/site-patterns/ 整个文件夹（含子文件夹）复制到 ~/.web-access/site-patterns/（Windows 上 ~ 指 %USERPROFILE%），已存在的文件不要覆盖；确认复制成功后再按 https:

| 能力 | 说明 | |------|------| | 联网工具自动选择 | WebSearch / WebFetch / curl / Jina / CDP，按场景自主判断，可任意组合 |

|------|------| | 联网工具自动选择 | WebSearch / WebFetch / curl / Jina / CDP，按场景自主判断，可任意组合 | | CDP Proxy 浏览器操作 | 直连用户日常浏览器（Chrome / Edge / Brave / Arc / Dia 等任意 Chromium 内核浏览器），天然携带登录态，支持动态页面、交互操作、视频截帧 |

| 联网工具自动选择 | WebSearch / WebFetch / curl / Jina / CDP，按场景自主判断，可任意组合 |

> [skills CLI](https://github.com/vercel-labs/skills) 是开源的 Agent Skill 包管理器，自动检测你的 Agent 环境并安装到正确位置。

帮我安装这个 skill：https://github.com/eze-is/web-access

claude plugin marketplace add https://github.com/eze-is/web-access

git clone https://github.com/eze-is/web-access ~/.claude/skills/web-access

# 页面操作 curl -s -X POST --data-raw 'https://example.com' http://localhost:3456/new  # 新建 tab（v2.5.3 起 URL 走 POST body）

curl -s -X POST --data-raw 'https://example.com' http://localhost:3456/new  # 新建 tab（v2.5.3 起 URL 走 POST body）

curl -s -X POST "http://localhost:3456/eval?target=ID" -d 'document.title'  # 执行 JS

curl -s -X POST "http://localhost:3456/click?target=ID" -d 'button.submit'  # JS 点击

curl -s -X POST "http://localhost:3456/clickAt?target=ID" -d '.upload-btn'  # 真实鼠标点击

curl -s -X POST "http://localhost:3456/setFiles?target=ID" \

-d '{"selector":"input[type=file]","files":["/path/to/file.png"]}'        # 文件上传 curl -s "http://localhost:3456/screenshot?target=ID&file=/tmp/shot.png"     # 截图 curl -s "http://localhost:3456/scroll?target=ID&direction=bottom"           # 

curl -s "http://localhost:3456/screenshot?target=ID&file=/tmp/shot.png"     # 截图

curl -s "http://localhost:3456/scroll?target=ID&direction=bottom"           # 滚动

curl -s "http://localhost:3456/close?target=ID"                             # 关闭 tab

curl -s "http://localhost:3456/health"                                      # 查看状态（含 managedTabs 数量）

MIT · 作者：[一泽 Eze](https://github.com/eze-is) · [官网](https://web-access.eze.is)

[![Star History Chart](https://api.star-history.com/svg?repos=eze-is/web-access&type=Date)](https://star-history.com/#eze-is/web-access&Date)

[![Download History](https://skill-history.com/chart/eze-is/web-access.svg)](https://skill-history.com/eze-is/web-access)

<img width="1280" height="306" alt="image" src="https://github.com/user-attachments/assets/2afa25c2-3730-413e-b40f-94e52567249d" />

author: 一泽Eze   version: "2.6.0"   github: https://github.com/eze-is/web-access

version: "2.6.0"   github: https://github.com/eze-is/web-access ---

github: https://github.com/eze-is/web-access

浏览器 CDP 不要求 URL 已知——可从任意入口出发，通过页面内搜索、点击、跳转等方式找到目标内容。WebSearch、WebFetch、curl 均不处理登录态。

**Jina**（可选预处理层，可与 WebFetch/curl 组合使用，由于其特性可节省 tokens 消耗，请积极在任务合适时组合使用）：第三方网络服务，可将网页转为 Markdown，大幅节省 token 但可能有信息损耗。调用方式为 `r.jina.ai/example.com`（URL 前加前缀，不保留原网址 http 前缀），限 20 RPM。适合文章、博客、文档、PDF 等以正文为核心的页面；对数据面板、商品页等非文章结构页面可能提取到错误区块。

所有操作通过 curl 调用 HTTP API：

# 列出用户已打开的 tab curl -s http://localhost:3456/targets

curl -s http://localhost:3456/targets

# 创建新后台 tab（自动等待加载）— URL 走 POST body，避免目标 URL 含 query 时被切分 curl -s -X POST --data-raw 'https://example.com' http://localhost:3456/new

curl -s -X POST --data-raw 'https://example.com' http://localhost:3456/new

# 页面信息 curl -s "http://localhost:3456/info?target=ID"

curl -s "http://localhost:3456/info?target=ID"

# 执行任意 JS：可读写 DOM、提取数据、操控元素、触发状态变更、提交表单、调用内部方法 curl -s -X POST "http://localhost:3456/eval?target=ID" -d 'document.title'

curl -s -X POST "http://localhost:3456/eval?target=ID" -d 'document.title'

# 捕获页面渲染状态（含视频当前帧） curl -s "http://localhost:3456/screenshot?target=ID&file=/tmp/shot.png"

curl -s "http://localhost:3456/screenshot?target=ID&file=/tmp/shot.png"

# 导航（URL 走 POST body，target 走 query）、后退 curl -s -X POST --data-raw 'https://example.com' "http://localhost:3456/navigate?target=ID"

curl -s -X POST --data-raw 'https://example.com' "http://localhost:3456/navigate?target=ID"

curl -s "http://localhost:3456/back?target=ID"

# 点击（POST body 为 CSS 选择器）— JS el.click()，简单快速，覆盖大多数场景 curl -s -X POST "http://localhost:3456/click?target=ID" -d 'button.submit'

curl -s -X POST "http://localhost:3456/click?target=ID" -d 'button.submit'

# 真实鼠标点击 — CDP Input.dispatchMouseEvent，算用户手势，能触发文件对话框 curl -s -X POST "http://localhost:3456/clickAt?target=ID" -d 'button.upload'

curl -s -X POST "http://localhost:3456/clickAt?target=ID" -d 'button.upload'

# 按视口坐标真实点击 — 可点中跨站 iframe 里的元素，不激活标签页 curl -s "http://localhost:3456/clickXY?target=ID&x=120&y=90"

curl -s "http://localhost:3456/clickXY?target=ID&x=120&y=90"

# 页面里的 iframe — 列出 frameId（跨站 iframe 标 crossProcess），再在其中执行 JS curl -s "http://localhost:3456/frames?target=ID"

curl -s "http://localhost:3456/frames?target=ID"

curl -s -X POST "http://localhost:3456/eval?target=ID&frame=FRAME_ID" -d 'document.body.innerText'

# 文件上传 — 直接设置 file input 的本地文件路径，绕过文件对话框 curl -s -X POST "http://localhost:3456/setFiles?target=ID" -d '{"selector":"input[type=file]","files":["/path/to/file.png"]}'

curl -s -X POST "http://localhost:3456/setFiles?target=ID" -d '{"selector":"input[type=file]","files":["/path/to/file.png"]}'

# 滚动（触发懒加载） curl -s "http://localhost:3456/scroll?target=ID&y=3000"

curl -s "http://localhost:3456/scroll?target=ID&y=3000"

curl -s "http://localhost:3456/scroll?target=ID&direction=bottom"

# 关闭 tab curl -s "http://localhost:3456/close?target=ID"

curl -s "http://localhost:3456/close?target=ID"

- 地址：`http://localhost:3456`

curl -s http://localhost:3456/health

curl -s http://localhost:3456/targets

curl -s -X POST --data-raw 'https://example.com' http://localhost:3456/new

[Credential-related source omitted]

curl -s "http://localhost:3456/close?target=TARGET_ID"

curl -s -X POST --data-raw 'https://example.com' "http://localhost:3456/navigate?target=ID"

curl -s "http://localhost:3456/back?target=ID"

curl -s "http://localhost:3456/info?target=ID"

curl -s -X POST "http://localhost:3456/eval?target=ID" -d 'document.title'

curl -s -X POST "http://localhost:3456/eval?target=ID&frame=FRAME_ID" -d 'document.body.innerText'

curl -s "http://localhost:3456/frames?target=ID"

curl -s "http://localhost:3456/clickXY?target=ID&x=120&y=90"

curl -s -X POST "http://localhost:3456/setFiles?target=ID" -d '{"selector":"input[type=file]","files":["/path/to/file1.png","/path/to/file2.png"]}'

curl -s "http://localhost:3456/scroll?target=ID&y=3000"

curl -s "http://localhost:3456/scroll?target=ID&direction=bottom"

curl -s "http://localhost:3456/screenshot?target=ID&file=/tmp/shot.png"

- curl -s "http://localhost:3456/new?url=https://example.com"

+ curl -s -X POST --data-raw 'https://example.com' http://localhost:3456/new

- curl -s "http://localhost:3456/navigate?target=ID&url=https://example.com"

+ curl -s -X POST --data-raw 'https://example.com' "http://localhost:3456/navigate?target=ID"

GET /new?url=https://xhs.com/explore/x?a=1&b=2

proxy 解析结果： - `q.url = "https://xhs.com/explore/x?a=1"` ← 被截断

- `q.url = "https://xhs.com/explore/x?a=1"` ← 被截断

| 场景 | 旧（v2.5.2） | 新（v2.5.3） | |---|---|---| | 简单 URL | `curl ".../new?url=https://example.com"` | `curl -X POST --data-raw 'https://example.com' .../new` |

[Credential-related source omitted]

| 简单 URL | `curl ".../new?url=https://example.com"` | `curl -X POST --data-raw 'https://example.com' .../new` |

[Credential-related source omitted]

| URL 含 `#` fragment | `curl ".../new?url=https://app/page#sec"` ⚠<U+FE0F> fragment 丢失 | `curl -X POST --data-raw 'https://app/page#sec' .../new` ✓ |

| 旧 | 新 | |---|---| | `curl ".../navigate?target=ID&url=URL"` | `curl -X POST --data-raw 'URL' ".../navigate?target=ID"` |

| `curl ".../navigate?target=ID&url=URL"` | `curl -X POST --data-raw 'URL' ".../navigate?target=ID"` |

Executable file

Executable file

#!/usr/bin/env node

Executable file

const outcome = await exec([path.join(root, 'runner.mjs')], { action, ...options });

cli: (...args) => exec([path.join(scripts, 'browser-probe.mjs'), ...args]),

Executable file

Executable file

#!/usr/bin/env node

await sendCDP('Fetch.enable', {       patterns: [         { urlPattern: `http://127.0.0.1:${chromePort}/*`, requestStage: 'Request' },

patterns: [         { urlPattern: `http://127.0.0.1:${chromePort}/*`, requestStage: 'Request' },         { urlPattern: `http://localhost:${chromePort}/*`, requestStage: 'Request' },

{ urlPattern: `http://127.0.0.1:${chromePort}/*`, requestStage: 'Request' },

{ urlPattern: `http://localhost:${chromePort}/*`, requestStage: 'Request' },

const server = http.createServer(async (req, res) => {   const parsed = new URL(req.url, `http://localhost:${PORT}`);

const parsed = new URL(req.url, `http://localhost:${PORT}`);

error: 'v2.5.3 起 /new 改为 POST 传 URL（避免目标 URL 含 query 时被错误切分）',           migration: 'references/migration-2.5.3.md',           example: "curl -X POST --data-raw 'https://example.com' http://localhost:3456/new",

migration: 'references/migration-2.5.3.md',           example: "curl -X POST --data-raw 'https://example.com' http://localhost:3456/new",         }));

example: "curl -X POST --data-raw 'https://example.com' http://localhost:3456/new",

error: 'v2.5.3 起 /navigate 改为 POST 传 URL（避免目标 URL 含 query 时被错误切分）',           migration: 'references/migration-2.5.3.md',           example: "curl -X POST --data-raw 'https://example.com' 'http://localhost:3456/navigate?target=ID'",

migration: 'references/migration-2.5.3.md',           example: "curl -X POST --data-raw 'https://example.com' 'http://localhost:3456/navigate?target=ID'",         }));

example: "curl -X POST --data-raw 'https://example.com' 'http://localhost:3456/navigate?target=ID'",

let existing;       try {         const response = await fetch(`http://127.0.0.1:${PORT}/health`, { signal: AbortSignal.timeout(2000) });

try {         const response = await fetch(`http://127.0.0.1:${PORT}/health`, { signal: AbortSignal.timeout(2000) });         if (response.ok) existing = await response.json();

const response = await fetch(`http://127.0.0.1:${PORT}/health`, { signal: AbortSignal.timeout(2000) });

throw error;   }   lifecycleLog(`运行在 http://127.0.0.1:${PORT}，revision=${RUNNING_REVISION}`);

}   lifecycleLog(`运行在 http://127.0.0.1:${PORT}，revision=${RUNNING_REVISION}`);   cleanupTimer = setInterval(cleanupIdleTabs, CLEANUP_INTERVAL);

lifecycleLog(`运行在 http://127.0.0.1:${PORT}，revision=${RUNNING_REVISION}`);

Executable file

return { model: { content: [55, 65, 355, 65, 355, 315, 55, 315] } };       case 'Page.getFrameTree':         return { frameTree: { frame: { id: 'user-page' }, childFrames: [{ frame: { id: 'local-frame', url: 'http://localhost/same' } }] } }

case 'Page.getFrameTree':         return { frameTree: { frame: { id: 'user-page' }, childFrames: [{ frame: { id: 'local-frame', url: 'http://localhost/same' } }] } };       case 'Page.createIsolatedWorld':

return { frameTree: { frame: { id: 'user-page' }, childFrames: [{ frame: { id: 'local-frame', url: 'http://localhost/same' } }] } };

if (message.method === 'Target.getTargets') {       result = { targetInfos: [{ targetId: 'user-page', type: 'page', title: 'Fake page', url: 'about:blank' }] };       if (process.env.TEST_FRAMES === '1') result.targetInfos.push({ targetId: 

result = { targetInfos: [{ targetId: 'user-page', type: 'page', title: 'Fake page', url: 'about:blank' }] };       if (process.env.TEST_FRAMES === '1') result.targetInfos.push({ targetId: 'oopif-frame', type: 'iframe', url: 'http://127.0.0.

if (process.env.TEST_FRAMES === '1') result.targetInfos.push({ targetId: 'oopif-frame', type: 'iframe', url: 'http://127.0.0.1/child' });

if (message.params.expression.includes('JSON.stringify({ ready:')) {         const ready = fs.existsSync(path.join(root, 'page-release')) ? 'complete' : 'loading';         result = { result: { value: JSON.stringify({ ready, url: 'https://fa

const ready = fs.existsSync(path.join(root, 'page-release')) ? 'complete' : 'loading';         result = { result: { value: JSON.stringify({ ready, url: 'https://fake.example/page' }) } };       } else result = { result: { value: 'fake value

result = { result: { value: JSON.stringify({ ready, url: 'https://fake.example/page' }) } };

const health = await f.ready(entry);   assert.equal((await requestJson(f.port, '/shutdown')).status, 403);   assert.equal((await requestJson(f.port, '/shutdown', { method: 'POST', headers: { Origin: 'https://example.com' }, body: { instance

assert.equal((await requestJson(f.port, '/shutdown')).status, 403);   assert.equal((await requestJson(f.port, '/shutdown', { method: 'POST', headers: { Origin: 'https://example.com' }, body: { instanceId: health.instanceId } })).status, 403

assert.equal((await requestJson(f.port, '/shutdown', { method: 'POST', headers: { Origin: 'https://example.com' }, body: { instanceId: health.instanceId } })).status, 403);

const entry = f.spawn();   const health = await f.ready(entry);   const navigation = beginRequest(f.port, '/navigate?target=user-page', { method: 'POST', body: 'https://fake.example/page' });

const health = await f.ready(entry);   const navigation = beginRequest(f.port, '/navigate?target=user-page', { method: 'POST', body: 'https://fake.example/page' });   const aborted = navigation.done.catch(error => error);

const navigation = beginRequest(f.port, '/navigate?target=user-page', { method: 'POST', body: 'https://fake.example/page' });

assert.equal(frames.status, 200);   assert.deepEqual(frames.body.map(frame => [frame.frameId, frame.crossProcess, frame.url]), [     ['local-frame', false, 'http://localhost/same'],

assert.deepEqual(frames.body.map(frame => [frame.frameId, frame.crossProcess, frame.url]), [     ['local-frame', false, 'http://localhost/same'],     ['oopif-frame', true, 'http://127.0.0.1/child'],

['local-frame', false, 'http://localhost/same'],

['oopif-frame', true, 'http://127.0.0.1/child'],

#!/usr/bin/env node

const PROXY_SCRIPT = path.join(ROOT, 'scripts', 'cdp-proxy.mjs'); const PROXY_PORT = Number(process.env.CDP_PROXY_PORT || 3456); const HEALTH_URL = `http://127.0.0.1:${PROXY_PORT}/health`;

const PROXY_PORT = Number(process.env.CDP_PROXY_PORT || 3456); const HEALTH_URL = `http://127.0.0.1:${PROXY_PORT}/health`; const USER_DATA = userDataPaths();

const HEALTH_URL = `http://127.0.0.1:${PROXY_PORT}/health`;

function httpGetJson(url, timeoutMs = 3000) {   return fetch(url, { signal: AbortSignal.timeout(timeoutMs) })

return fetch(url, { signal: AbortSignal.timeout(timeoutMs) })

async function ensureProxy(expectedBrowserId, browserOverride, health) {   const targetsUrl = `http://127.0.0.1:${PROXY_PORT}/targets`;

const targetsUrl = `http://127.0.0.1:${PROXY_PORT}/targets`;

Executable file

const requests = [];   const server = http.createServer((req, res) => {     requests.push(req.url);

const server = http.createServer((req, res) => {     requests.push(req.url);     res.setHeader('content-type', 'application/json');

requests.push(req.url);

assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.length > 0);   assert.ok(proxy.requests.every(request => request === '/health'));

assert.ok(proxy.requests.length > 0);   assert.ok(proxy.requests.every(request => request === '/health')); });

assert.ok(proxy.requests.every(request => request === '/health'));

assert.match(result.stdout, /正在维护/);     assert.deepEqual(await f.events(), []);     assert.ok(proxy.requests.every(request => request === '/health'));

assert.deepEqual(await f.events(), []);     assert.ok(proxy.requests.every(request => request === '/health'));   });

assert.ok(proxy.requests.every(request => request === '/health'));

assert.match(result.stdout, /浏览器不一致/);     assert.deepEqual(await f.events(), []);     assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);

assert.deepEqual(await f.events(), []);     assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);     assert.ok(proxy.requests.every(request => request === '/health'));

assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);

assert.ok(proxy.requests.every(request => request === '/health'));

assert.match(result.stdout, /无法确认当前连接的浏览器/);     assert.deepEqual(await f.events(), []);     assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);

assert.deepEqual(await f.events(), []);     assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);     assert.ok(proxy.requests.every(request => request === '/health'));

assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);

assert.ok(proxy.requests.every(request => request === '/health'));

success(await f.run(proxy.port));   assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.every(request => request === '/health'));

assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.every(request => request === '/health')); });

assert.ok(proxy.requests.every(request => request === '/health'));

success(await f.run(proxy.port));   assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.includes('/targets'));

assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.includes('/targets'));   assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);

assert.ok(proxy.requests.includes('/targets'));

assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, true);

success(await f.run(proxy.port));   assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.includes('/targets'));

assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.includes('/targets'));   const health = await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json();

assert.ok(proxy.requests.includes('/targets'));

const health = await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json();

assert.match(result.stdout, /连接超时/);   assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.includes('/targets'));

assert.deepEqual(await f.events(), []);   assert.ok(proxy.requests.includes('/targets'));   assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).status, 'ok');

assert.ok(proxy.requests.includes('/targets'));

assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).status, 'ok');

assert.match(result.stdout, /连接超时/);   assert.deepEqual(await f.events(), []);   assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, false);

assert.deepEqual(await f.events(), []);   assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, false); });

assert.equal((await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json()).connected, false);

assert.equal(events.filter(event => event.action === 'spawn').length, 1);   assert.deepEqual(events.find(event => event.action === 'spawn').args, ['--browser', 'edge']);   const health = await (await fetch(`http://127.0.0.1:${port}/health`)

assert.deepEqual(events.find(event => event.action === 'spawn').args, ['--browser', 'edge']);   const health = await (await fetch(`http://127.0.0.1:${port}/health`)).json();   assert.equal(health.connected, true);

const health = await (await fetch(`http://127.0.0.1:${port}/health`)).json();

const events = await f.events();   assert.deepEqual(events.find(event => event.action === 'spawn').args, []);   const health = await (await fetch(`http://127.0.0.1:${port}/health`)).json();

assert.deepEqual(events.find(event => event.action === 'spawn').args, []);   const health = await (await fetch(`http://127.0.0.1:${port}/health`)).json();   assert.deepEqual(health.browser, { id: path.join(f.home, 'Dia', 'User Data'), label

const health = await (await fetch(`http://127.0.0.1:${port}/health`)).json();

#!/usr/bin/env node

});   } catch (e) {     if (e.code === 'ENOENT') die('未找到 sqlite3 命令。macOS/Linux 通常自带；Windows 可用 `winget install sqlite.sqlite` 或从 https://sqlite.org/download.html 下载后加入 PATH。');

} catch (e) {     if (e.code === 'ENOENT') die('未找到 sqlite3 命令。macOS/Linux 通常自带；Windows 可用 `winget install sqlite.sqlite` 或从 https://sqlite.org/download.html 下载后加入 PATH。');     return [];

if (e.code === 'ENOENT') die('未找到 sqlite3 命令。macOS/Linux 通常自带；Windows 可用 `winget install sqlite.sqlite` 或从 https://sqlite.org/download.html 下载后加入 PATH。');

#!/usr/bin/env node

Executable file

Executable file

case 'Target.getTargets':         return { result: { targetInfos: [           { targetId: 'page-1', type: 'page', url: 'http://localhost/p' },

return { result: { targetInfos: [           { targetId: 'page-1', type: 'page', url: 'http://localhost/p' },           { targetId: 'oopif-frame', type: 'iframe', url: 'http://127.0.0.1/child' },

{ targetId: 'page-1', type: 'page', url: 'http://localhost/p' },

{ targetId: 'oopif-frame', type: 'iframe', url: 'http://127.0.0.1/child' },

{ targetId: 'page-2', type: 'page', url: 'http://other/' },

case 'Page.getFrameTree':         return { result: { frameTree: { frame: { id: 'page-1' }, childFrames: [           { frame: { id: 'local-frame', url: 'http://localhost/same-now', name: 'kid' } },

return { result: { frameTree: { frame: { id: 'page-1' }, childFrames: [           { frame: { id: 'local-frame', url: 'http://localhost/same-now', name: 'kid' } },         ] } } };

{ frame: { id: 'local-frame', url: 'http://localhost/same-now', name: 'kid' } },

const nodes = {           'el-local': { frameId: 'local-frame', attributes: ['name', 'kid', 'src', '/same'] },           'el-oopif': { frameId: 'oopif-frame', attributes: ['id', 'pay', 'src', 'http://127.0.0.1/child', 'style', 'x'] },

'el-local': { frameId: 'local-frame', attributes: ['name', 'kid', 'src', '/same'] },           'el-oopif': { frameId: 'oopif-frame', attributes: ['id', 'pay', 'src', 'http://127.0.0.1/child', 'style', 'x'] },           'el-unloaded': { attr

'el-oopif': { frameId: 'oopif-frame', attributes: ['id', 'pay', 'src', 'http://127.0.0.1/child', 'style', 'x'] },

const { frames, calls, attached } = fakeBrowser();   assert.deepEqual(await frames.listFrames('page-1'), [     { index: 0, frameId: 'local-frame', crossProcess: false, url: 'http://localhost/same-now', name: 'kid', src: '/same' },

assert.deepEqual(await frames.listFrames('page-1'), [     { index: 0, frameId: 'local-frame', crossProcess: false, url: 'http://localhost/same-now', name: 'kid', src: '/same' },     { index: 1, frameId: 'oopif-frame', crossProcess: true, ur

{ index: 0, frameId: 'local-frame', crossProcess: false, url: 'http://localhost/same-now', name: 'kid', src: '/same' },

{ index: 1, frameId: 'oopif-frame', crossProcess: true, url: 'http://127.0.0.1/child', id: 'pay', src: 'http://127.0.0.1/child' },

return alive(params.objectId) ? { result: { model: { content: [0, 0, 300, 0, 300, 250, 0, 250] } } } : dead;       case 'Target.getTargets': return { result: { targetInfos: [] } };       case 'Page.getFrameTree': return { result: { frameTre

case 'Target.getTargets': return { result: { targetInfos: [] } };       case 'Page.getFrameTree': return { result: { frameTree: { frame: { id: 'page-1' }, childFrames: [{ frame: { id: 'local-frame', url: 'http://localhost/a' } }] } } };    

case 'Page.getFrameTree': return { result: { frameTree: { frame: { id: 'page-1' }, childFrames: [{ frame: { id: 'local-frame', url: 'http://localhost/a' } }] } } };

#!/usr/bin/env node

Executable file

for (let i = 0; i < 100; i++) {   try {     const res = await fetch('http://127.0.0.1:' + process.env.CDP_PROXY_PORT + '/health');

try {     const res = await fetch('http://127.0.0.1:' + process.env.CDP_PROXY_PORT + '/health');     const health = await res.json();

const res = await fetch('http://127.0.0.1:' + process.env.CDP_PROXY_PORT + '/health');

for await (const chunk of req) text += chunk;       const body = text ? JSON.parse(text) : null;       requests.push({ method: req.method, path: req.url, body, origin: req.headers.origin, connection: sockets.get(req.socket) });

const body = text ? JSON.parse(text) : null;       requests.push({ method: req.method, path: req.url, body, origin: req.headers.origin, connection: sockets.get(req.socket) });       res.setHeader('content-type', 'application/json');

requests.push({ method: req.method, path: req.url, body, origin: req.headers.origin, connection: sockets.get(req.socket) });

assert.equal(result.code, 0, result.stderr);   assert.deepEqual(result.output, { status: 'running', health: oldHealth });   assert.deepEqual(proxy.requests.map(r => r.path), ['/health']);

assert.deepEqual(result.output, { status: 'running', health: oldHealth });   assert.deepEqual(proxy.requests.map(r => r.path), ['/health']);   assert.deepEqual(await f.events(), []);

assert.deepEqual(proxy.requests.map(r => r.path), ['/health']);

assert.equal(result.output.status, 'busy');     }     assert.ok(proxy.requests.every(req => req.path === '/health'));

}     assert.ok(proxy.requests.every(req => req.path === '/health'));     assert.deepEqual(await f.events(), []);

assert.ok(proxy.requests.every(req => req.path === '/health'));

assert.equal(result.output.status, 'busy');     }     assert.ok(proxy.requests.every(req => req.path === '/health'));

}     assert.ok(proxy.requests.every(req => req.path === '/health'));     assert.deepEqual(await f.events(), []);

assert.ok(proxy.requests.every(req => req.path === '/health'));

assert.match(result.output.message, /禁止自动强停/);   }   assert.ok(proxy.requests.every(req => req.path === '/health'));

}   assert.ok(proxy.requests.every(req => req.path === '/health'));   assert.deepEqual(await f.events(), []);

assert.ok(proxy.requests.every(req => req.path === '/health'));

assert.equal(result.output.status, 'stopped');   assert.equal(result.output.stoppedInstanceId, oldHealth.instanceId);   const shutdowns = proxy.requests.filter(req => req.path === '/shutdown');

assert.equal(result.output.stoppedInstanceId, oldHealth.instanceId);   const shutdowns = proxy.requests.filter(req => req.path === '/shutdown');   assert.equal(shutdowns.length, 1);

const shutdowns = proxy.requests.filter(req => req.path === '/shutdown');

assert.equal(result.code, 2, result.stderr);   assert.equal(result.output.status, 'busy');   assert.equal(proxy.requests.filter(r => r.path === '/shutdown').length, 1);

assert.equal(result.output.status, 'busy');   assert.equal(proxy.requests.filter(r => r.path === '/shutdown').length, 1);   assert.deepEqual(await f.events(), []);

assert.equal(proxy.requests.filter(r => r.path === '/shutdown').length, 1);

assert.equal(result.output.health.instanceId, replacement.instanceId);       if (action === 'restart') assert.equal(result.output.reused, true);       assert.equal(proxy.requests.filter(req => req.path === '/shutdown').length, 1);

if (action === 'restart') assert.equal(result.output.reused, true);       assert.equal(proxy.requests.filter(req => req.path === '/shutdown').length, 1);       assert.deepEqual(await f.events(), []);

assert.equal(proxy.requests.filter(req => req.path === '/shutdown').length, 1);

assert.equal(result.output.expectedBrowserId, 'edge');       assert.equal(result.output.health.instanceId, replacement.instanceId);       assert.equal(proxy.requests.filter(req => req.path === '/shutdown').length, 1);

assert.equal(result.output.health.instanceId, replacement.instanceId);       assert.equal(proxy.requests.filter(req => req.path === '/shutdown').length, 1);       assert.deepEqual(await f.events(), []);

assert.equal(proxy.requests.filter(req => req.path === '/shutdown').length, 1);

assert.deepEqual(await f.events(), []);       const health = await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json();       assert.equal(health.instanceId, replacement.instanceId);

const health = await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json();

assert.equal(result.output.health.instanceId, 'new-instance');     assert.equal((await f.events()).filter(event => event.action === 'startup').length, 1);     const health = await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json(

assert.equal((await f.events()).filter(event => event.action === 'startup').length, 1);     const health = await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json();     assert.equal(health.instanceId, 'new-instance');

const health = await (await fetch(`http://127.0.0.1:${proxy.port}/health`)).json();

const result = await f.run(proxy.port, ['restart']);     assert.equal(result.code, 1, result.stderr);     assert.ok(proxy.requests.every(req => req.path === '/health'));

assert.equal(result.code, 1, result.stderr);     assert.ok(proxy.requests.every(req => req.path === '/health'));     assert.deepEqual(await f.events(), []);

assert.ok(proxy.requests.every(req => req.path === '/health'));

assert.equal(result.code, 0, `${result.stdout}\n${result.stderr}`);   assert.equal(result.output.status, 'stopped');   const connections = proxy.requests.map(request => request.connection);

assert.equal(result.output.status, 'stopped');   const connections = proxy.requests.map(request => request.connection);   assert.equal(new Set(connections).size, connections.length, JSON.stringify(proxy.requests));

const connections = proxy.requests.map(request => request.connection);

assert.equal(result.output.health.instanceId, oldHealth.instanceId);     assert.equal(resets, 1);     assert.equal(proxy.requests.filter(request => request.path === '/health').length, 2);

assert.equal(resets, 1);     assert.equal(proxy.requests.filter(request => request.path === '/health').length, 2);     assert.deepEqual(await f.events(), []);

assert.equal(proxy.requests.filter(request => request.path === '/health').length, 2);

Executable file

Executable file