@sleepinsummer/agent-browser-cli 0.2.0 → 0.2.3

package/README.md

@@ -9,8 +9,8 @@
 <p>
   <a href="https://github.com/sleepinginsummer/agent-browser-cli"><img src="https://img.shields.io/badge/CLI-agentbrowsercli-2ea44f" alt="CLI agentbrowsercli"></a>
   <a href="https://github.com/sleepinginsummer/agent-browser-cli/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="License MIT"></a>
-    <a href="https://github.com/sleepinginsummer/agent-browser-cli"><img src="https://img.shields.io/badge/Windows-MacOS-0078D6?labelColor=0078D6&color=C0C0C0" alt="Windows/MacOS"></a>
-  <a href="https://github.com/sleepinginsummer/agent-browser-cli/releases"><img src="https://img.shields.io/badge/release-v0.2.0-blue" alt="release v0.2.0"></a>
+  <a href="https://github.com/sleepinginsummer/agent-browser-cli"><img src="https://img.shields.io/badge/Windows-MacOS-0078D6?labelColor=0078D6&color=C0C0C0" alt="Windows/MacOS"></a>
+  <a href="https://github.com/sleepinginsummer/agent-browser-cli/releases"><img src="https://img.shields.io/badge/release-v0.2.3-blue" alt="release v0.2.3"></a>
   <a href="https://github.com/sleepinginsummer/agent-browser-cli/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen" alt="PRs welcome"></a>
 </p>
 
@@ -26,9 +26,8 @@
 
 ## 项目信息
 
-- 当前版本：`0.2.0`
-- 支持平台：Windows、macOS
-- 运行时：Rust 原生二进制；npm 安装时按平台选择二进制包
+- 当前版本：`0.2.3`
+- 支持平台：sys win/mac
 - 浏览器：Chrome / Chromium，需加载 `assets/tmwd_cdp_bridge`
 
 ## 致谢
@@ -50,19 +49,46 @@
 - 新增启动锁，避免多个 CLI 并发启动时重复绑定底层端口。
 - 增加skill：`skills/agent-browser-cli/SKILL.md`，提供ai参考使用。
 - 若干优化，缩短命令执行时间
+- rust实现cli端
+
+## 性能参考
+
+以下为常驻服务已启动、Chrome 扩展已连接时的实测参考，实际耗时会受页面复杂度、网络、Chrome 状态和返回数据量影响。
+
+| 操作 | 参考耗时 |
+| --- | --- |
+| 打开百度标签页 | 约 `0.10s` |
+| 注入 JS 输入关键词并点击搜索 | 约 `0.27s` |
+| 打开百度并搜索“小猫”合计 | 约 `0.37s` |
+| `scan --tab --text-only` 读取页面文本 | 约 `0.04-0.12s` |
+| `exec 'return document.title'` 注入简单 JS | 约 `0.04-0.12s` |
+| `exec 'return document.body.innerText'` 读取正文 | 多数 `0.04-0.05s`，偶发约 `0.30s` |
+| 查询 DOM 链接列表 | 约 `0.27-0.36s` |
+| `exec --monitor` 页面变化摘要 | 约 `0.72-0.88s` |
+
+一般判断：普通读页面和简单 JS 注入是 `50ms` 级；复杂 DOM 查询主要取决于页面结构和返回数据量，常见约 `300ms`；`--monitor` 会额外生成页面变化摘要，通常接近 `0.8s`。
+
+与原 Python 调用链的参考对比：
+
+| 对比项 | Python 版本 | Rust CLI 版本 |
+| --- | --- | --- |
+| 启动方式 | 每次调用更容易触发 Python 进程、模块加载和连接初始化开销 | CLI 命令复用常驻服务，避免重复初始化浏览器连接 |
+| 简单读页面 / JS 注入 | 通常受进程启动和 Python 调用链影响，延迟更不稳定 | 常见 `0.04-0.12s` |
+| 连续多次调用 | 多次短命令开销更明显 | 更适合 Agent 高频调用 |
+
+该对比只用于说明架构差异带来的性能趋势；具体耗时仍取决于页面复杂度、Chrome 状态和返回数据量。
 
 ## 目录结构
 
 ```text
 .
-├── agent_browser_cli.py          # 命令行入口
-├── agent_browser_server.py       # 常驻 HTTP 服务
-├── ga.py                         # web_scan / web_execute_js 入口
-├── TMWebDriver.py                # 浏览器扩展 WebSocket / HTTP 桥
-├── simphtml.py                   # 页面简化和 DOM diff
+├── Cargo.toml                    # Rust 工程配置
+├── src/                          # Rust CLI / 常驻服务 / bridge
 ├── assets/tmwd_cdp_bridge/       # Chrome MV3 扩展
-├── memory/                       # 浏览器工具 SOP
-└── skills/agent-browser-cli/     #  skill
+├── assets/simphtml_opt.js        # 页面简化脚本
+├── assets/simphtml_find_list.js  # 列表识别脚本
+├── npm/                          # npm 启动脚本
+└── skills/agent-browser-cli/     # skill
 ```
 
 ## 手动安装
@@ -74,15 +100,6 @@ npm install -g @sleepinsummer/agent-browser-cli
 agent-browser-cli tabs
 ```
 
-当前 npm 分发采用主包 + 平台二进制包：
-
-```text
-@sleepinsummer/agent-browser-cli
-@sleepinsummer/agent-browser-cli-darwin-arm64
-@sleepinsummer/agent-browser-cli-darwin-x64
-@sleepinsummer/agent-browser-cli-win32-x64
-```
-
 ### 本地源码构建
 
 ```bash
@@ -90,15 +107,6 @@ cargo build --release
 ./target/release/agent-browser-cli tabs
 ```
 
-### Python 旧版运行方式
-
-Python 实现暂时保留为迁移参考和回退入口：
-
-```bash
-cd /path/to/agent-browser-cli
-python3 -m venv .venv
-.venv/bin/python -m pip install -r requirements.txt
-```
 
 ## Chrome 扩展
 
@@ -182,7 +190,6 @@ rm -rf ~/.agents/skills/agent-browser-cli
 ## 端口
 
 - `18765`：底层 `TMWebDriver` WebSocket，Chrome 扩展连接使用。
-- `18766`：底层 `TMWebDriver` HTTP `/link`，用于内部 master/remote 协议。
 - `18767`：外层 `agent-browser-cli` HTTP 服务，供 CLI 复用会话。
 
 ## 友情链接

package/README_EN.md

@@ -9,9 +9,8 @@ Browser perception · Page control · Chrome session reuse · CDP · Conditional
 <p>
   <a href="https://github.com/sleepinginsummer/agent-browser-cli"><img src="https://img.shields.io/badge/CLI-agentbrowsercli-2ea44f" alt="CLI agentbrowsercli"></a>
   <a href="https://github.com/sleepinginsummer/agent-browser-cli/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="License MIT"></a>
-  <a href="https://www.python.org/"><img src="https://img.shields.io/badge/Python-%3E%3D3.10-3776AB?logo=python&logoColor=white" alt="Python >=3.10"></a>
   <a href="https://github.com/sleepinginsummer/agent-browser-cli"><img src="https://img.shields.io/badge/Windows-MacOS-0078D6?labelColor=0078D6&color=C0C0C0" alt="Windows/MacOS"></a>
-  <a href="https://github.com/sleepinginsummer/agent-browser-cli/releases"><img src="https://img.shields.io/badge/release-v0.1.1-blue" alt="release v0.1.1"></a>
+  <a href="https://github.com/sleepinginsummer/agent-browser-cli/releases"><img src="https://img.shields.io/badge/release-v0.2.3-blue" alt="release v0.2.3"></a>
   <a href="https://github.com/sleepinginsummer/agent-browser-cli/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen" alt="PRs welcome"></a>
 </p>
 
@@ -27,9 +26,8 @@ This project is not Selenium or Playwright. It is better suited for helping agen
 
 ## Project Info
 
-- Current version: `0.1.1`
+- Current version: `0.2.3`
 - Supported platforms: Windows, macOS
-- Python: `3.10+` recommended
 - Browser: Chrome / Chromium, with `assets/tmwd_cdp_bridge` loaded
 
 ## Acknowledgements
@@ -51,29 +49,65 @@ Please read https://github.com/sleepinginsummer/agent-browser-cli/blob/main/AI_I
 - Adds a startup lock to avoid repeated low-level port binding when multiple CLI commands start concurrently.
 - Adds the skill `skills/agent-browser-cli/SKILL.md` for AI usage reference.
 - Includes several optimizations to reduce command execution time.
+- Rust implementation for the CLI side.
+
+## Performance Reference
+
+The following numbers are measured with the long-lived service already running and the Chrome extension already connected. Actual latency depends on page complexity, network conditions, Chrome state, and response size.
+
+| Operation | Reference Latency |
+| --- | --- |
+| Open a Baidu tab | About `0.10s` |
+| Inject JS to enter a keyword and submit search | About `0.27s` |
+| Open Baidu and search “小猫” end-to-end | About `0.37s` |
+| `scan --tab --text-only` to read page text | About `0.04-0.12s` |
+| `exec 'return document.title'` for simple JS | About `0.04-0.12s` |
+| `exec 'return document.body.innerText'` to read body text | Mostly `0.04-0.05s`, occasional `0.30s` |
+| Query DOM link lists | About `0.27-0.36s` |
+| `exec --monitor` page-change summary | About `0.72-0.88s` |
+
+Rule of thumb: normal page reads and simple JS injection are around the `50ms` level; complex DOM queries depend on page structure and returned data size, commonly around `300ms`; `--monitor` adds page-change summary work and is usually close to `0.8s`.
+
+Reference comparison with the original Python call chain:
+
+| Item | Python Version | Rust CLI Version |
+| --- | --- | --- |
+| Startup model | Each call is more likely to pay for Python process startup, module loading, and connection initialization | CLI commands reuse the long-lived service and avoid repeated browser connection initialization |
+| Simple page read / JS injection | Usually more affected by process startup and the Python call chain, so latency is less stable | Commonly `0.04-0.12s` |
+| Repeated calls | Overhead is more visible across many short commands | Better suited for high-frequency Agent calls |
+
+This comparison is intended to describe the performance trend caused by the architecture difference. Actual latency still depends on page complexity, Chrome state, and response size.
 
 ## Layout
 
 ```text
 .
-├── agent_browser_cli.py          # CLI entry
-├── agent_browser_server.py       # Long-lived HTTP service
-├── ga.py                         # web_scan / web_execute_js entry
-├── TMWebDriver.py                # Browser extension WebSocket / HTTP bridge
-├── simphtml.py                   # Page simplification and DOM diff
+├── Cargo.toml                    # Rust crate config
+├── src/                          # Rust CLI / daemon / bridge
 ├── assets/tmwd_cdp_bridge/       # Chrome MV3 extension
-├── memory/                       # Browser tool SOPs
+├── assets/simphtml_opt.js        # Page simplification script
+├── assets/simphtml_find_list.js  # List detection script
+├── npm/                          # npm launcher scripts
 └── skills/agent-browser-cli/     # skill
 ```
 
 ## Manual Installation
 
+### npm
+
+```bash
+npm install -g @sleepinsummer/agent-browser-cli
+agent-browser-cli tabs
+```
+
+### Build From Source
+
 ```bash
-cd /path/to/agent-browser-cli
-python3 -m venv .venv
-.venv/bin/python -m pip install -r requirements.txt
+cargo build --release
+./target/release/agent-browser-cli tabs
 ```
 
+
 ## Chrome Extension
 
 Load this extension directory:
@@ -87,8 +121,8 @@ Chrome needs at least one normal web page tab open. Do not leave it only on `abo
 ## Quick Check
 
 ```bash
-.venv/bin/python agent_browser_cli.py tabs
-.venv/bin/python agent_browser_cli.py open https://www.baidu.com
+agent-browser-cli tabs
+agent-browser-cli open https://www.baidu.com
 ```
 
 On success, it returns:
@@ -110,15 +144,15 @@ On success, it returns:
 The README only keeps the quick entry point. For the full command list and browser operation SOP, see [skills/agent-browser-cli/SKILL.md](./skills/agent-browser-cli/SKILL.md).
 
 ```bash
-.venv/bin/python agent_browser_cli.py tabs
+agent-browser-cli tabs
 ```
 
 ## Update
 
 ```bash
 git pull
-.venv/bin/python -m pip install -r requirements.txt
-.venv/bin/python agent_browser_cli.py restart
+cargo build --release
+./target/release/agent-browser-cli restart
 ```
 
 If the Chrome extension has updates, reload the `assets/tmwd_cdp_bridge` extension in `chrome://extensions`.
@@ -141,13 +175,12 @@ cp skills/agent-browser-cli/SKILL.md ~/.agents/skills/agent-browser-cli/SKILL.md
 Stop the long-lived service first:
 
 ```bash
-.venv/bin/python agent_browser_cli.py stop
+agent-browser-cli stop
 ```
 
 Then clean up as needed:
 
 ```bash
-rm -rf .venv
 rm -f .agent-browser-cli.log .agent-browser-cli.lock
 rm -rf ~/.agents/skills/agent-browser-cli
 ```
@@ -157,7 +190,6 @@ Finally, remove the `TMWD CDP Bridge` extension from Chrome's extension manageme
 ## Ports
 
 - `18765`: underlying `TMWebDriver` WebSocket, used by the Chrome extension.
-- `18766`: underlying `TMWebDriver` HTTP `/link`, used by the internal master/remote protocol.
 - `18767`: outer `agent-browser-cli` HTTP service, used by the CLI to reuse the session.
 
 ## Friendly Links

package/assets/simphtml_find_list.js

@@ -0,0 +1,266 @@
+function findMainList(startElement = null) {
+        const root = startElement || document.body;
+        const MIN_CHILDREN = 8;
+        const MAX_CONTAINERS = 20;
+
+        // 全局扫描：收集候选容器，按 l1 + l2*0.1 排序（l2=孙子元素数，捕获表格等多层结构）
+        const candidates = [];
+        const allEls = root.querySelectorAll('*');
+        for (const node of allEls) {
+            if (node.closest('svg')) continue;
+            const l1 = node.children.length;
+            if (l1 < 5) continue;
+            let l2 = 0;
+            for (const child of node.children) l2 += child.children.length;
+            const score = l1 + l2 * 0.1;
+            if (score >= MIN_CHILDREN) candidates.push({node, score});
+        }
+        candidates.sort((a, b) => b.score - a.score);
+        const toProcess = candidates.slice(0, MAX_CONTAINERS).map(c => c.node);
+
+        // 对每个容器找候选组并评分
+        let allCandidates = [];
+        for (const container of toProcess) {
+            const topGroups = findTopGroups(container, 3);
+            for (const groupInfo of topGroups) {
+                const items = findMatchingElements(container, groupInfo.selector);
+                if (items.length >= 5) {
+                    const score = scoreContainer(container, items) + groupInfo.score;
+                    if (score >= 30) {
+                        allCandidates.push({ container, selector: groupInfo.selector, items, score });
+                    }
+                }
+            }
+        }
+
+        // 按分数降序排列
+        allCandidates.sort((a, b) => b.score - a.score);
+
+        // 去重：移除与更高分候选重叠超50%的结果
+        const kept = [];
+        for (const cand of allCandidates) {
+            let dominated = false;
+            for (const k of kept) {
+                if (k.container.contains(cand.container) || cand.container.contains(k.container)) {
+                    const kSet = new Set(k.items);
+                    const overlap = cand.items.filter(it => kSet.has(it)).length;
+                    if (overlap > cand.items.length * 0.5) { dominated = true; break; }
+                }
+            }
+            if (!dominated) kept.push(cand);
+        }
+
+        function describeResult(container, items, selector, score) {
+            if(container&&!container.id)container.id='_ljq'+(window._lci=(window._lci||0)+1);
+            const cTag = container ? container.tagName : null;
+            const cId = container ? (container.id || '') : '';
+            const cClass = container ? (String(container.className || '').trim()) : '';
+            const result = {
+                containerTag: cTag, containerId: cId, containerClass: cClass,
+                itemCount: items.length,
+            };
+            let prefix = '';
+            if (cId) prefix = '#' + CSS.escape(cId);
+            if (selector) result.selector = prefix ? (prefix + ' > ' + selector) : selector;
+            if (score !== undefined) result.score = score;
+            if (items.length > 0) {
+                result.firstItemPreview = items[0].outerHTML.substring(0, 200);
+                result.itemTags = items.slice(0, 10).map(el => el.tagName + (el.className ? '.' + String(el.className).trim().split(/\s+/)[0] : ''));
+            }
+            return result;
+        }
+
+        if (kept.length === 0) return [];
+
+        return kept.map(c => describeResult(c.container, c.items, c.selector, c.score));
+    }
+    
+    function findTopGroups(container, limit) {
+        const children = Array.from(container.children).filter(c => !c.closest('svg'));
+        const totalChildren = children.length;
+        if (totalChildren < 3) return [];
+
+        const minGroupSize = Math.max(3, Math.floor(totalChildren * 0.2));
+        const groups = [];
+
+        // 统计标签和类名
+        const tagFreq = {}, classFreq = {}, tagMap = {}, classMap = {};
+
+        children.forEach(child => {
+            // 统计标签
+            const tag = child.tagName.toLowerCase();
+            if (tag === "td") return;
+            tagFreq[tag] = (tagFreq[tag] || 0) + 1;
+            if (!tagMap[tag]) tagMap[tag] = [];
+            tagMap[tag].push(child);
+
+            // 统计类名
+            if (child.className) {
+                child.className.trim().split(/\s+/).forEach(cls => {
+                    if (cls) {
+                        classFreq[cls] = (classFreq[cls] || 0) + 1;
+                        if (!classMap[cls]) classMap[cls] = [];
+                        classMap[cls].push(child);
+                    }
+                });
+            }
+        });
+
+        // 评分函数
+        const scoreGroup = (selector, elements) => {
+            const coverage = elements.length / totalChildren;
+            let specificity = selector.startsWith('.')
+            ? (0.6 + (selector.match(/\./g).length - 1) * 0.1) // 类选择器
+            : (selector.includes('.')
+               ? (0.7 + (selector.match(/\./g).length) * 0.1) // 标签+类
+               : 0.3); // 纯标签
+            return (coverage * 0.5) + (specificity * 0.5);
+        };
+
+        // 添加标签组
+        Object.keys(tagFreq).forEach(tag => {
+            if (tag !== "div" && tagFreq[tag] >= minGroupSize) {
+                groups.push({
+                    selector: tag,
+                    elements: tagMap[tag],
+                    score: scoreGroup(tag, tagMap[tag]) - 0.5
+                });
+            }
+        });
+
+        // 添加类组
+        Object.keys(classFreq).forEach(cls => {
+            if (classFreq[cls] >= minGroupSize) {
+                const selector = '.' + CSS.escape(cls);
+                groups.push({
+                    selector,
+                    elements: classMap[cls],
+                    score: scoreGroup(selector, classMap[cls])
+                });
+            }
+        });
+        // 添加标签+类组合
+        const topTags = Object.keys(tagFreq).filter(t => tagFreq[t] >= minGroupSize).slice(0, 3);
+        const topClasses = Object.keys(classFreq).filter(c => classFreq[c] >= minGroupSize).sort((a, b) => classFreq[b] - classFreq[a]).slice(0, 3);
+
+        // 标签+类
+        topTags.forEach(tag => {
+            topClasses.forEach(cls => {
+                const elements = children.filter(el =>
+                                                 el.tagName.toLowerCase() === tag &&
+                                                 el.className && el.className.split(/\s+/).includes(cls)
+                                                );
+
+                if (elements.length >= minGroupSize) {
+                    const selector = tag + '.' + CSS.escape(cls);
+                    groups.push({selector, elements, score: scoreGroup(selector, elements)});
+                }
+            });
+        });
+
+        // 多类组合
+        for (let i = 0; i < topClasses.length; i++) {
+            for (let j = i + 1; j < topClasses.length; j++) {
+                const elements = children.filter(el =>
+                                                 el.className && el.className.split(/\s+/).includes(topClasses[i]) && el.className.split(/\s+/).includes(topClasses[j]));
+
+                if (elements.length >= minGroupSize) {
+                    const selector = '.' + CSS.escape(topClasses[i]) + '.' + CSS.escape(topClasses[j]);
+                    groups.push({selector, elements,score: scoreGroup(selector, elements)});
+                }
+            }
+        }
+        // 返回得分最高的N个组
+        return groups.sort((a, b) => b.score - a.score).slice(0, limit);
+    }
+
+    function findMatchingElements(container, selector) {
+        try {
+            return Array.from(container.querySelectorAll(selector));
+        } catch (e) {
+            // 处理无效选择器
+            console.error('Invalid selector:', selector, e);
+            return [];
+        }
+    }
+
+    function scoreContainer(container, items) {
+        if (!container || items.length < 3) return 0;
+        // 1. 计算基础面积数据
+        const containerRect = container.getBoundingClientRect();
+        const containerArea = containerRect.width * containerRect.height;
+        if (containerArea < 10000) return 0; // 容器太小
+
+        // 收集列表项面积数据
+        const itemAreas = [];
+        let totalItemArea = 0;
+        let visibleItems = 0;
+
+        items.forEach(item => {
+            const rect = item.getBoundingClientRect();
+            const area = rect.width * rect.height;
+            if (area > 0) {
+                totalItemArea += area;
+                itemAreas.push(area);
+                visibleItems++;
+            }
+        });
+        // 如果可见项太少，返回低分
+        if (visibleItems < 3) return 0;
+        // 防止异常值：确保面积不超过容器
+        totalItemArea = Math.min(totalItemArea, containerArea * 0.98);
+        const areaRatio = totalItemArea / containerArea;
+        // 3. 计算各项评分 - 使用线性插值而非阶梯
+        // 3.2 面积比评分 - 最多40分，连续曲线
+        // 使用sigmoid函数让评分更平滑
+        const areaScore = 40 / (1 + Math.exp(-12 * (areaRatio - 0.4)));
+
+        // 3.3 均匀性评分 - 最多20分，连续曲线
+        let uniformityScore = 0;
+        if (itemAreas.length >= 3) {
+            const mean = itemAreas.reduce((sum, area) => sum + area, 0) / itemAreas.length;
+            const variance = itemAreas.reduce((sum, area) => sum + Math.pow(area - mean, 2), 0) / itemAreas.length;
+            const cv = mean > 0 ? Math.sqrt(variance) / mean : 1;
+            // 指数衰减函数，cv越小分数越高
+            uniformityScore = 20 * Math.exp(-2.5 * cv);
+        }
+
+        const baseScore = Math.log2(visibleItems) * 5 + Math.floor(visibleItems / 5) * 0.25;
+        const rawCountScore = Math.min(40, baseScore);
+        const countScore = rawCountScore * Math.max(0.1, uniformityScore / 20);
+
+        // 3.4 容器尺寸评分 - 最多15分，连续曲线
+        const viewportArea = window.innerWidth * window.innerHeight;
+        const containerViewportRatio = containerArea / viewportArea;
+        const sizeScore = 2 * (1 - 1/(1 + Math.exp(-10 * (containerViewportRatio - 0.25))));  
+
+        let layoutScore = 0;
+        if (items.length >= 3) {
+            // 坐标分组并计算行列数
+            const uniqueRows = new Set(items.map(item => Math.round(item.getBoundingClientRect().top / 5) * 5)).size;
+            const uniqueCols = new Set(items.map(item => Math.round(item.getBoundingClientRect().left / 5) * 5)).size;
+            // 如果是单行或单列，直接给满分；否则评估网格质量
+            if (uniqueRows === 1 || uniqueCols === 1) { layoutScore = 20;
+            } else {
+                const coverage = Math.min(1, items.length / (uniqueRows * uniqueCols));
+                const efficiency = Math.max(0, 1 - (uniqueRows + uniqueCols) / (2 * items.length));
+                layoutScore = 20 * (0.7 * coverage + 0.3 * efficiency);
+            }
+        }
+
+        // 总分 - 仍然保持100分左右的总分
+        const totalScore = countScore + areaScore + uniformityScore + layoutScore + sizeScore;
+
+        if (totalScore > 100)
+            console.log(container, {
+                total: totalScore.toFixed(2),
+                count: countScore.toFixed(2),
+                areaRatio: areaRatio.toFixed(2),
+                area: areaScore.toFixed(2),
+                uniformity: uniformityScore.toFixed(2),
+                size: sizeScore.toFixed(2),
+                layout: layoutScore.toFixed(2)
+            });
+
+        return totalScore;
+    }

package/assets/simphtml_opt.js

@@ -0,0 +1,324 @@
+function optHTML(text_only=false) {
+function createEnhancedDOMCopy() {  
+  const nodeInfo = new WeakMap();  
+  const ignoreTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'META', 'LINK', 'COLGROUP', 'COL', 'TEMPLATE', 'PARAM', 'SOURCE'];  
+  const ignoreIds = ['agent-browser-cli-ind'];
+  function cloneNode(sourceNode, keep=false) {  
+    if (sourceNode.nodeType === 8 ||   
+        (sourceNode.nodeType === 1 && (  
+          ignoreTags.includes(sourceNode.tagName) ||   
+          (sourceNode.id && ignoreIds.includes(sourceNode.id))  
+        ))) {  
+      return null;  
+    }  
+    if (sourceNode.nodeType === 3) return sourceNode.cloneNode(false);  
+    const clone = sourceNode.cloneNode(false);
+    if ((sourceNode.tagName === 'INPUT' || sourceNode.tagName === 'TEXTAREA') && sourceNode.value) clone.setAttribute('value', sourceNode.value);
+    if (sourceNode.tagName === 'INPUT' && (sourceNode.type === 'radio' || sourceNode.type === 'checkbox') && sourceNode.checked) clone.setAttribute('checked', '');
+    else if (sourceNode.tagName === 'SELECT' && sourceNode.value) clone.setAttribute('data-selected', sourceNode.value);  
+    try { if (sourceNode.matches && sourceNode.matches(':-webkit-autofill')) { clone.setAttribute('data-autofilled', 'true'); if (!sourceNode.value) clone.setAttribute('value', '⚠️受保护-读tmwebdriver_sop的autofill章节提取'); } } catch(e) {}
+
+    const isDropdown = sourceNode.classList?.contains('dropdown-menu') ||   
+             /dropdown|menu/i.test(sourceNode.className) || sourceNode.getAttribute('role') === 'menu'; 
+    const _ddItems = isDropdown ? sourceNode.querySelectorAll('a, button, [role="menuitem"], li').length : 0;
+    const isSmallDropdown = _ddItems > 0 && _ddItems <= 7 && sourceNode.textContent.length < 500;  
+
+    const childNodes = [];  
+    for (const child of sourceNode.childNodes) {  
+      const childClone = cloneNode(child, keep || isSmallDropdown);  
+      if (childClone) childNodes.push(childClone);  
+    }  
+    if (sourceNode.tagName === 'IFRAME') {
+      try {
+        const iDoc = sourceNode.contentDocument || sourceNode.contentWindow?.document;
+        if (iDoc && iDoc.body && iDoc.body.children.length > 0) {
+          const wrapper = document.createElement('div');
+          wrapper.setAttribute('data-iframe-content', sourceNode.src || '');
+          for (const ch of iDoc.body.childNodes) {
+            const c = cloneNode(ch, keep);
+            if (c) wrapper.appendChild(c);
+          }
+          if (wrapper.childNodes.length) childNodes.push(wrapper);
+        }
+      } catch(e) {}
+    }
+    if (sourceNode.shadowRoot) {
+      for (const shadowChild of sourceNode.shadowRoot.childNodes) {
+        const shadowClone = cloneNode(shadowChild, keep);
+        if (shadowClone) childNodes.push(shadowClone);
+      }
+    }
+
+    const rect = sourceNode.getBoundingClientRect();
+    const style = window.getComputedStyle(sourceNode);
+    const area = (style.display === 'none' || style.visibility === 'hidden' || parseFloat(style.opacity) <= 0)?0:rect.width * rect.height;
+    const isVisible = (rect.width > 1 && rect.height > 1 &&   
+                  style.display !== 'none' && style.visibility !== 'hidden' &&   
+                  parseFloat(style.opacity) > 0 &&  
+                  Math.abs(rect.left) < 5000 && Math.abs(rect.top) < 5000) 
+                  || isSmallDropdown;  
+    const zIndex = style.position !== 'static' ? (parseInt(style.zIndex) || 0) : 0;
+  
+    let info = {
+          rect, area, isVisible, isSmallDropdown, zIndex,
+          style: {  
+            display: style.display, visibility: style.visibility,  
+            opacity: style.opacity, position: style.position
+          }};
+    
+    const nonTextChildren = childNodes.filter(child => child.nodeType !== 3);  
+    const hasValidChildren = nonTextChildren.length > 0;  
+          
+    if (hasValidChildren) {
+      const childrenInfos = nonTextChildren.map(c => nodeInfo.get(c)).filter(i => i && i.rect && i.rect.width > 0 && i.rect.height > 0);
+      const bgAlpha = (() => {
+        const c = style.backgroundColor;
+        if (!c || c === 'transparent') return 0;
+        const m = c.match(/rgba?\([^)]+,\s*([\d.]+)\)/);
+        return m ? parseFloat(m[1]) : 1;
+      })();
+      const hasVisualBg = bgAlpha > 0.1 || style.backgroundImage !== 'none' || (style.backdropFilter && style.backdropFilter !== 'none') || style.boxShadow !== 'none';
+      
+      if (!hasVisualBg && childrenInfos.length > 0) {
+        // Skip fixed/absolute children when computing parent's merged rect (they're out of flow)
+        const flowChildren = childrenInfos.filter(cInfo => cInfo.style && cInfo.style.position !== 'fixed' && cInfo.style.position !== 'absolute');
+        if (flowChildren.length > 0) {
+          let minL = Infinity, minT = Infinity, maxR = -Infinity, maxB = -Infinity;
+          for (const cInfo of flowChildren) {
+            minL = Math.min(minL, cInfo.rect.left);
+            minT = Math.min(minT, cInfo.rect.top);
+            maxR = Math.max(maxR, cInfo.rect.right);
+            maxB = Math.max(maxB, cInfo.rect.bottom);
+          }
+          info.rect = { left: minL, top: minT, right: maxR, bottom: maxB, width: maxR - minL, height: maxB - minT };
+          info.area = info.rect.width * info.rect.height;
+        } else {
+          const maxC = childrenInfos.filter(i => i.isVisible).sort((a, b) => b.area - a.area)[0];
+          if (maxC && maxC.area > 10000 && (!isVisible || maxC.area > info.area * 5)) info = maxC;
+        }
+      }
+    }
+
+    if (sourceNode.nodeType === 1 && sourceNode.tagName === 'DIV') {    
+      if (!hasValidChildren && !sourceNode.textContent.trim()) return null; 
+    }  
+    // aria-hidden + not visible = truly hidden (e.g. mobile menus), remove even if has children
+    if (sourceNode.getAttribute && sourceNode.getAttribute('aria-hidden') === 'true' && !info.isVisible) {
+      return null;
+    }
+    if (info.isVisible || hasValidChildren || keep) {  
+      childNodes.forEach(child => clone.appendChild(child));  
+      return clone;  
+    }  
+    return null;  
+  }  
+  
+  return {  
+    domCopy: cloneNode(document.body),  
+    getNodeInfo: node => nodeInfo.get(node),  
+    isVisible: node => {  
+      const info = nodeInfo.get(node);  
+      return info && info.isVisible;  
+    }  
+  };  
+}  
+const { domCopy, getNodeInfo, isVisible } = createEnhancedDOMCopy();
+if (text_only) {
+  const blocks = new Set(['DIV','P','H1','H2','H3','H4','H5','H6','LI','TR','SECTION','ARTICLE','HEADER','FOOTER','NAV','BLOCKQUOTE','PRE','HR','BR','DT','DD','FIGCAPTION','DETAILS','SUMMARY']);
+  domCopy.querySelectorAll('*').forEach(el => {
+    if (blocks.has(el.tagName)) el.insertAdjacentText('beforebegin', '\n');
+  });
+  domCopy.querySelectorAll('input:not([type=hidden]),textarea,select').forEach(el=>{
+    const p=[el.tagName,el.id&&'#'+el.id,el.getAttribute('name')&&'name='+el.getAttribute('name'),el.tagName==='INPUT'&&'type='+(el.getAttribute('type')||'text'),el.getAttribute('placeholder')&&'"'+el.getAttribute('placeholder')+'"',el.getAttribute('data-autofilled')&&'autofilled',el.disabled&&'disabled',el.tagName==='SELECT'&&el.getAttribute('data-selected')&&'="'+el.getAttribute('data-selected')+'"'].filter(Boolean).join(' ');
+    el.insertAdjacentText('beforebegin','\n['+p+']\n');
+  });
+  domCopy.querySelectorAll('button[disabled]').forEach(el=>el.insertAdjacentText('beforebegin','[DISABLED] '));
+  return domCopy.textContent;
+}
+const viewportArea = window.innerWidth * window.innerHeight; 
+
+function analyzeNode(node, pPathType='main') {  
+    // 处理非元素节点和叶节点  
+    if (node.nodeType !== 1 || !node.children.length) {  
+      node.nodeType === 1 && (node.dataset.mark = 'K:leaf');  
+      return;  
+    }  
+    const pathType = (node.dataset.mark === 'K:secondary') ? 'second' : pPathType;  
+    const nodeInfoData = getNodeInfo(node);
+    if (!nodeInfoData || !nodeInfoData.rect) return;
+    const rectn = nodeInfoData.rect; 
+    if (rectn.width < window.innerWidth * 0.8 && rectn.height < window.innerHeight * 0.8) return node;
+    if (node.tagName === 'TABLE') return;
+    const children = Array.from(node.children);  
+    if (children.length === 1) {  
+      node.dataset.mark = 'K:container';  
+      return analyzeNode(children[0], pathType);  
+    }  
+    if (children.length > 10) return;
+    
+    // 获取子元素信息并排序  
+    const childrenInfo = children.map(child => {  
+      const info = getNodeInfo(child) || { rect: {}, style: {} };  
+      return { node: child, rect: info.rect, style: info.style, 
+          area: info.area, zIndex: (info.zIndex || 0), isVisible: info.isVisible };  
+    });
+    childrenInfo.sort((a, b) => b.area - a.area);  
+    
+    // 检测是划分还是覆盖  
+    const isOverlay = hasOverlap(childrenInfo);  
+    node.dataset.mark = isOverlay ? 'K:overlayParent' : 'K:partitionParent';  
+    
+    if (isOverlay) handleOverlayContainer(childrenInfo, pathType);  
+    else handlePartitionContainer(childrenInfo, pathType);  
+
+    console.log(`${isOverlay ? '覆盖' : '划分'}容器:`, node, `子元素数量: ${children.length}`);  
+    console.log('子元素及标记:', children.map(child => ({   
+      element: child,   
+      mark: child.dataset.mark || '无',  
+      info: getNodeInfo ? getNodeInfo(child) : undefined  
+    })));  
+    for (const child of children)  
+      if (!child.dataset.mark || child.dataset.mark[0] !== 'R') analyzeNode(child, pathType);  
+  }  
+  
+  // 处理划分容器  
+  function handlePartitionContainer(childrenInfo, pathType) {  
+    childrenInfo.sort((a, b) => b.area - a.area);
+    const totalArea = childrenInfo.reduce((sum, item) => sum + item.area, 0);  
+    console.log(childrenInfo[0].area / totalArea);
+    const hasMainElement = childrenInfo.length >= 1 &&   
+                          (childrenInfo[0].area / totalArea > 0.5) &&   
+                          (childrenInfo.length === 1 || childrenInfo[0].area > childrenInfo[1].area * 2);  
+    if (hasMainElement) {  
+      childrenInfo[0].node.dataset.mark = 'K:main';
+      for (let i = 1; i < childrenInfo.length; i++) {  
+        const child = childrenInfo[i];  
+        let className = (child.node.getAttribute('class') || '').toLowerCase();
+        let isSecondary = containsButton(child.node);
+        if (className.includes('nav')) isSecondary = true;
+        if (className.includes('breadcrumbs')) isSecondary = true;
+        if (className.includes('header') && className.includes('table')) isSecondary = true;
+        if (child.node.innerHTML.trim().replace(/\s+/g, '').length < 500) isSecondary = true;
+        if (child.node.textContent.trim().length > 200) isSecondary = true;  // P3: 有实质文本内容则保留
+        if (child.style.visibility === 'hidden') isSecondary = false;
+        if (isSecondary) child.node.dataset.mark = 'K:secondary';  
+        else child.node.dataset.mark = 'K:nonEssential';  
+      }  
+    } else {  
+      return; // relaxed: skip equalmany filtering, list truncation handles token budget
+      const uniqueClassNames = new Set(childrenInfo.map(item => item.node.getAttribute('class') || '')).size;  
+      const highClassNameVariety = uniqueClassNames >= childrenInfo.length * 0.8;  
+      if (pathType !== 'main' && highClassNameVariety && childrenInfo.length > 5) {
+        childrenInfo.forEach(child => child.node.dataset.mark = 'R:equalmany');  
+      } else {
+        childrenInfo.forEach(child => child.node.dataset.mark = 'K:equal');  
+      }
+    }  
+  }  
+
+  function containsButton(container) {  
+    const hasStandardButton = container.querySelector('button, input[type="button"], input[type="submit"], [role="button"]') !== null;  
+    if (hasStandardButton) return true;  
+    const hasClassButton = container.querySelector('[class*="-btn"], [class*="-button"], .button, .btn, [class*="btn-"]') !== null;  
+    return hasClassButton;  
+  }   
+  
+  function handleOverlayContainer(childrenInfo, pathType) {  
+    // elementFromPoint ground truth: 让浏览器告诉我们谁在视觉最上层
+    const _efp = document.elementFromPoint(window.innerWidth/2, window.innerHeight/2);
+    if (_efp) { let _el = _efp; while (_el) { const _h = childrenInfo.find(c => c.node.id && c.node.id === _el.id); if (_h) { _h.zIndex = 9999; break; } _el = _el.parentElement; } }
+    const sorted = [...childrenInfo].sort((a, b) => b.zIndex - a.zIndex);  
+    console.log('排序后的子元素:', sorted);
+    if (sorted.length === 0) return;  
+    
+    const top = sorted[0];  
+    const rect = top.rect;  
+    const topNode = top.node; 
+    const isComplex = top.node.querySelectorAll('input, select, textarea, button, a, [role="button"]').length >= 1;  
+
+    const textContent = topNode.textContent?.trim() || '';  
+    const textLength = textContent.length;  
+    const hasLinks = topNode.querySelectorAll('a').length > 0;  
+    const isMostlyText = textLength > 7 && !hasLinks;  
+
+    const centerDiff = Math.abs((rect.left + rect.width/2) - window.innerWidth/2) / window.innerWidth;  
+    const minDimensionRatio = Math.min(rect.width / window.innerWidth, rect.height / window.innerHeight);  
+    const maxDimensionRatio = Math.max(rect.width / window.innerWidth, rect.height / window.innerHeight);  
+    const isNearTop = rect.top < 50;  
+    const isDialog = (top.node.querySelector('iframe') || top.node.querySelector('button') || top.node.querySelector('input')) && centerDiff < 0.3;
+
+    if (isComplex && centerDiff < 0.2 && 
+        ((minDimensionRatio > 0.2 && rect.width/window.innerWidth < 0.98) || minDimensionRatio > 0.95)) {  
+      top.node.dataset.mark = 'K:mainInteractive';  
+       sorted.slice(1).forEach(e => {
+          if ((parseInt(e.zIndex)||0) <= (parseInt(sorted[0].zIndex)||0)) {
+              e.node.dataset.mark = 'R:covered';
+          } else {
+              e.node.dataset.mark = 'K:noncovered';
+          }
+      });
+    } else {
+      if (isComplex && isNearTop && maxDimensionRatio > 0.4 && top.isVisible) {
+        top.node.dataset.mark = 'K:topBar';
+      } else if (isMostlyText || isComplex || isDialog) {  
+        topNode.dataset.mark = 'K:messageContent'; 
+      } else {  
+        topNode.dataset.mark = 'R:floatingAd'; 
+      }  
+      const rest = sorted.slice(1);  
+      rest.length && (!hasOverlap(rest) ? handlePartitionContainer(rest, pathType) : handleOverlayContainer(rest, pathType));  
+    } 
+  }  
+    
+  function hasOverlap(items) {  
+    return items.some((a, i) =>   
+      items.slice(i+1).some(b => {  
+        const r1 = a.rect, r2 = b.rect;  
+        if (!r1.width || !r2.width || !r1.height || !r2.height) {return false;}
+        const epsilon = 1;
+        const x1 = r1.x !== undefined ? r1.x : r1.left;
+        const y1 = r1.y !== undefined ? r1.y : r1.top;
+        const x2 = r2.x !== undefined ? r2.x : r2.left;
+        const y2 = r2.y !== undefined ? r2.y : r2.top;
+        return !(x1 + r1.width <= x2 + epsilon || x1 >= x2 + r2.width - epsilon || 
+            y1 + r1.height <= y2 + epsilon || y1 >= y2 + r2.height - epsilon
+        );
+      })
+    );  
+}
+
+// Hoist top 1-2 deep fixed dialogs to body level for overlay detection
+const _fc = [...domCopy.querySelectorAll('*')].filter(el => {
+  if (el.parentNode === domCopy) return false;
+  const info = getNodeInfo(el);
+  if (!info?.rect || info.style.position !== 'fixed') return false;
+  const r = info.rect, cover = (r.width * r.height) / viewportArea;
+  const cd = Math.abs((r.left + r.width/2) - window.innerWidth/2) / window.innerWidth;
+  return cover > 0.15 && cover < 1.0 && cd < 0.3 && el.querySelector('button, input, a, [role="button"], iframe');
+}).filter((el, _, arr) => !arr.some(o => o !== el && o.contains(el)))
+  .sort((a, b) => (getNodeInfo(b).rect.width * getNodeInfo(b).rect.height) - (getNodeInfo(a).rect.width * getNodeInfo(a).rect.height))
+  .slice(0, 2);
+_fc.forEach(el => { const r = getNodeInfo(el).rect; console.log('[simphtml] Hoisted fixed dialog:', el.tagName + (el.id ? '#'+el.id : '') + (el.className ? '.'+String(el.className).split(' ')[0] : ''), Math.round(r.width)+'x'+Math.round(r.height), Math.round(100*r.width*r.height/viewportArea)+'%'); el.parentNode.removeChild(el); domCopy.appendChild(el); });
+const result = analyzeNode(domCopy); 
+domCopy.querySelectorAll('[data-mark^="R:"]').forEach(el=>el.parentNode?.removeChild(el));  
+let root = domCopy;  
+while (root.children.length === 1) {  
+  root = root.children[0];  
+}  
+for (let ii = 0; ii < 3; ii++) {
+  root.querySelectorAll('div').forEach(div => (!div.textContent.trim() && div.children.length === 0) && div.remove());
+}
+root.querySelectorAll('[data-mark]').forEach(e => e.removeAttribute('data-mark'));  
+root.removeAttribute('data-mark');
+root.querySelectorAll('iframe').forEach(f => {
+  if (f.children.length) {
+    const d = document.createElement('div');
+    for (const a of f.attributes) d.setAttribute(a.name, a.value);
+    d.setAttribute('data-tag', 'iframe');
+    while (f.firstChild) d.appendChild(f.firstChild);
+    f.parentNode.replaceChild(d, f);
+  }
+});
+return root.outerHTML;
+    }
+optHTML()

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@sleepinsummer/agent-browser-cli",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Agent-oriented browser sensing and control CLI backed by a native Rust daemon.",
   "license": "MIT",
   "bin": {
     "agent-browser-cli": "npm/bin/agent-browser-cli.js"
   },
   "files": [
-    "npm",
+    "npm/bin",
+    "npm/postinstall.js",
     "assets",
     "skills",
     "README.md",
@@ -20,11 +21,19 @@
     "postinstall": "node npm/postinstall.js"
   },
   "optionalDependencies": {
-    "@sleepinsummer/agent-browser-cli-darwin-arm64": "0.2.0",
-    "@sleepinsummer/agent-browser-cli-darwin-x64": "0.2.0",
-    "@sleepinsummer/agent-browser-cli-win32-x64": "0.2.0"
+    "@sleepinsummer/agent-browser-cli-darwin-arm64": "0.2.3",
+    "@sleepinsummer/agent-browser-cli-darwin-x64": "0.2.3",
+    "@sleepinsummer/agent-browser-cli-win32-x64": "0.2.3"
   },
   "engines": {
     "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sleepinginsummer/agent-browser-cli"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   }
 }

package/skills/agent-browser-cli/SKILL.md

@@ -5,7 +5,7 @@ description: 使用 agent-browser-cli 进行浏览器感知与控制。适用于
 
 # agent-browser-cli
 
-使用 `agent-browser-cli` 进行浏览器控制。底层通过 Rust 常驻服务和 Chrome 扩展接管用户浏览器，保留登录态和 Cookie；不是 Selenium/Playwright。旧 Python API `web_scan`、`web_execute_js` 只作为兼容和排障入口。
+使用 `agent-browser-cli` 进行浏览器控制。底层通过 Rust 常驻服务和 Chrome 扩展接管用户浏览器，保留登录态和 Cookie；不是 Selenium/Playwright。
 
 ## 项目路径
 
@@ -73,18 +73,8 @@ agent-browser-cli restart
 
 常驻服务端口：
 - `18765`：底层 `TMWebDriver` WebSocket，Chrome 扩展连接使用。
-- `18766`：底层 `TMWebDriver` HTTP `/link`，用于内部 master/remote 协议。
 - `18767`：外层 `agent-browser-cli` HTTP 服务，供 CLI 复用会话。
 
-旧 Python 实现只用于回退排障或开发：
-
-```bash
-.venv/bin/python - <<'PY'
-import ga
-print(ga.web_scan(tabs_only=True))
-PY
-```
-
 成功标志：
 - 返回 `status=success`
 - 能看到 `tabs_count`
@@ -127,38 +117,29 @@ agent-browser-cli exec --tab 303987837 'document.querySelector("button").click()
 
 ## 基础调用
 
-`web_scan` 负责感知，`web_execute_js` 负责精确操作。能精确操作时，不做全量扫描。下面是旧 Python 直接调用方式，主要用于排障或兼容旧脚本；日常命令行操作优先用上面的常驻 CLI。
-
-```python
-import ga
+`scan` 负责感知，`exec` 负责精确操作。能精确操作时，不做全量扫描。
 
-print(ga.web_scan(tabs_only=True))
-print(ga.web_scan())
-print(ga.web_scan(text_only=True))
-print(ga.web_scan(switch_tab_id="303987837"))
+```bash
+agent-browser-cli scan --tabs-only
+agent-browser-cli scan
+agent-browser-cli scan --text-only
+agent-browser-cli scan --tab 303987837
 ```
 
 普通页面 JS：
 
-```python
-import ga
-
-print(ga.web_execute_js("return document.title"))
-print(ga.web_execute_js("""
-return {
-  title: document.title,
-  url: location.href
-}
-"""))
+```bash
+agent-browser-cli exec 'return document.title'
+agent-browser-cli exec 'return { title: document.title, url: location.href }'
 ```
 
-`web_execute_js` 内使用 `await` 时必须显式 `return`，否则结果可能是 `null`。
+`exec` 内使用 `await` 时必须显式 `return`，否则结果可能是 `null`。
 
-`web_scan` 只读取当前页，不负责导航。切换网站用 `web_execute_js` 执行：
+`scan` 只读取当前页，不负责导航。切换网站用 `open` 或 `exec` 执行：
 
-```python
-import ga
-print(ga.web_execute_js("location.href='https://example.com'; return location.href"))
+```bash
+agent-browser-cli open https://example.com
+agent-browser-cli exec "location.href='https://example.com'; return location.href"
 ```
 
 新开标签页优先使用原生 `open` 命令，不要用 `window.open` 加 `--monitor`。`open` 底层走扩展 `chrome.tabs.create`，不会触发 CDP debugger attach。
@@ -174,13 +155,11 @@ JS 事件的 `isTrusted=false`，敏感操作可能被页面拦截。JS 点击
 
 跨标签页、Cookie、CDP、扩展管理、浏览器内容权限时，优先用 JSON 字符串直传，不要自己拼 DOM 节点。
 
-```python
-import ga
-
-print(ga.web_execute_js('{"cmd":"tabs"}'))
-print(ga.web_execute_js('{"cmd":"cookies"}'))
-print(ga.web_execute_js('{"cmd":"cdp","tabId":303987837,"method":"Page.captureScreenshot","params":{"format":"png"}}'))
-print(ga.web_execute_js('{"cmd":"batch","tabId":303987837,"commands":[{"cmd":"tabs"},{"cmd":"cookies"}]}'))
+```bash
+agent-browser-cli exec '{"cmd":"tabs"}'
+agent-browser-cli exec '{"cmd":"cookies"}'
+agent-browser-cli exec '{"cmd":"cdp","tabId":303987837,"method":"Page.captureScreenshot","params":{"format":"png"}}'
+agent-browser-cli exec '{"cmd":"batch","tabId":303987837,"commands":[{"cmd":"tabs"},{"cmd":"cookies"}]}'
 ```
 
 常用命令：
@@ -263,11 +242,11 @@ return fetch('PDF_URL').then(r => r.blob()).then(b => {
 });
 ```
 
-Google 图搜场景不要硬编码混淆 class。点击结果优先找 `[role=button]` 容器；`web_scan` 可能过滤边栏，弹出后用 JS 读 `document.body.innerText`；大图遍历 `img` 按 `naturalWidth` 最大取 `src`；“访问”链接遍历 `a` 找 `textContent.includes('访问')` 的 `href`；缩略图直接提取 `img[src^="data:image"]`。
+Google 图搜场景不要硬编码混淆 class。点击结果优先找 `[role=button]` 容器；`scan` 可能过滤边栏，弹出后用 JS 读 `document.body.innerText`；大图遍历 `img` 按 `naturalWidth` 最大取 `src`；“访问”链接遍历 `a` 找 `textContent.includes('访问')` 的 `href`；缩略图直接提取 `img[src^="data:image"]`。
 
 ## iframe、Shadow DOM 与截图
 
-同源 iframe 会被 `web_scan` 自动穿透。跨域 iframe 优先走 CDP：`Page.getFrameTree` 找 `frameId`，再 `Page.createIsolatedWorld` 获取 `contextId`，最后用 `Runtime.evaluate` 在 iframe 上下文执行。
+同源 iframe 会被 `scan` 自动穿透。跨域 iframe 优先走 CDP：`Page.getFrameTree` 找 `frameId`，再 `Page.createIsolatedWorld` 获取 `contextId`，最后用 `Runtime.evaluate` 在 iframe 上下文执行。
 
 iframe 内元素做 CDP 点击时，坐标需要合成：`finalX = iframeRect.x + elRect.x`，`finalY = iframeRect.y + elRect.y`。`Target.getTargets` / `Target.attachToTarget` 在当前 CDP 桥里通常会返回 `Not allowed`，不要优先走这条路。postMessage 中继只在 content script 已注入 iframe 时可靠，第三方支付 iframe 通常不可用。
 
@@ -277,33 +256,21 @@ closed Shadow DOM 使用 `DOM.getDocument({depth:-1,pierce:true})`，再逐级 `
 
 截图优先 CDP：
 
-```python
-import ga
-print(ga.web_execute_js('{"cmd":"cdp","method":"Page.captureScreenshot","params":{"format":"png"}}'))
+```bash
+agent-browser-cli exec '{"cmd":"cdp","method":"Page.captureScreenshot","params":{"format":"png"}}'
 ```
 
 验证码 canvas/img 优先用 JS `canvas.toDataURL()` 或直接读取图片 `src`。
 
 ## Autofill 与登录
 
-`web_scan` 输出的 input 若带 `data-autofilled="true"`，value 可能显示为受保护提示，不是真实值。Chrome 只在前台 tab 释放 autofill 保护值，所以必须先 CDP `Page.bringToFront`。
+`scan` 输出的 input 若带 `data-autofilled="true"`，value 可能显示为受保护提示，不是真实值。Chrome 只在前台 tab 释放 autofill 保护值，所以必须先 CDP `Page.bringToFront`。
 
 一键释放流程：`Page.bringToFront` -> `mousePressed` 点任一字段，通常不需要 `mouseReleased` -> 等 500ms -> 补发 `input/change` 事件 -> 点登录。
 
 ## 调试
 
-`simphtml` 调试必须注入 JS 到真实浏览器，本地静态解析无法模拟 DOM。
-
-```python
-from TMWebDriver import TMWebDriver
-import simphtml
-
-d = TMWebDriver()
-d.set_session('url_pattern')
-print(d.execute_js('return document.title'))
-```
-
-`simphtml.optimize_html_for_tokens(html)` 返回 BeautifulSoup Tag，展示前用 `str(...)`。
+页面简化调试必须注入 JS 到真实浏览器，本地静态解析无法模拟 DOM。优先用 `scan --text-only` 和小段 `exec` 缩小问题范围。
 
 ## 排障顺序
 
@@ -312,4 +279,4 @@ print(d.execute_js('return document.title'))
 3. 若提示无法加载 `config.js` 或清单，检查 `assets/tmwd_cdp_bridge/config.js`。
 4. 若提示没有可用标签页，先打开正常网页，不要只开内部页。
 5. 若扩展没装，加载 `assets/tmwd_cdp_bridge`。
-6. 仍失败时继续看 `memory/web_setup_sop.md` 和 `memory/tmwebdriver_sop.md`。
+6. 仍失败时检查 Chrome 扩展后台日志和 `.agent-browser-cli.log`。

package/npm/platform/darwin-arm64/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "@sleepinsummer/agent-browser-cli-darwin-arm64",
-  "version": "0.2.0",
-  "license": "MIT",
-  "os": [
-    "darwin"
-  ],
-  "cpu": [
-    "arm64"
-  ],
-  "files": [
-    "bin"
-  ]
-}