Skill: liulike/browser-local-chrome (version 1.1.0)

# 浏览器自动化配置技能 配置 OpenClaw 使用本地 Chrome 调试模式进行浏览器自动化。 ## 功能 - ✅ 一键启动 Chrome 调试模式 - ✅ 自动配置 OpenClaw 浏览器设置 - ✅ 启用 SSRF 白名单（允许访问任意网站） - ✅ 检查浏览器状态 ## 使用方法 ### 一键配置（推荐） ```bash node scripts/setup.js ``` 这会自动完成所有步骤：启动 Chrome → 配置 OpenClaw → 验证状态 ### 分步配置 ### 1. 启动浏览器 ```bash node scripts/start-chrome.js ``` ### 2. 配置 OpenClaw ```bash node scripts/configure-browser.js ``` ### 3. 重启 Gateway ```bash openclaw gateway restart ``` ### 4. 检查状态 ```bash node scripts/check-status.js ``` ### 5. 关闭浏览器（使用完成后） ```bash node scripts/stop-chrome.js ``` ## 配置说明 ### CDP 端口 默认：`9222` ### 用户数据目录 默认：`C:\chrome-debug-profile` ### SSRF 策略 - `dangerouslyAllowPrivateNetwork: true` - 允许访问任意网站 - 如需更严格的安全策略，可改用 `hostnameAllowlist` ## 故障排查 ### Chrome 无法启动 - 检查 Chrome 是否已安装：`C:\Program Files\Google\Chrome\Application\chrome.exe` - 检查端口 9222 是否被占用 ### 浏览器工具不可用 - 确认 Gateway 已重启 - 检查 CDP 连接：`curl http://127.0.0.1:9222/json/version` ### SSRF 错误 - 确认 `openclaw.json` 中已配置 `ssrfPolicy` - 重启 Gateway 使配置生效 ## 适用场景 - 访问需要 JavaScript 渲染的网站 - 自动化网页操作（点击、填写表单等） - 截图和页面分析 - 绕过 curl 无法处理的动态内容 ## 注意事项 - Chrome 调试模式需要保持运行 - **使用完成后请关闭浏览器**：`node scripts/stop-chrome.js` - 重启后需要重新启动 Chrome - 建议将启动脚本添加到开机自启

path: HYBRID-MODE.md
content: # 浏览器混合方案 - 使用说明

## 🎯 配置策略

**默认：** 官方 Browser (OpenClaw-managed)  
**备用：** 本地 Chrome 技能 (browser-local-chrome)

---

## 📋 方案对比

| 特性 | 官方 Browser | 本地 Chrome 技能 |
|------|-------------|-----------------|
| **配置文件** | `openclaw` | `local-chrome` |
| **端口** | 18800 | 9222 |
| **管理方式** | OpenClaw 自动管理 | 手动启动/关闭 |
| **启动命令** | `openclaw browser start` | `node scripts/start-chrome.js` |
| **关闭命令** | `openclaw browser stop` | `node scripts/stop-chrome.js` |
| **适用场景** | 日常使用（默认） | 官方失败时（备用） |

---

## 🚀 使用方法

### 方案 1：官方 Browser（默认）

```bash
# 启动浏览器
openclaw browser --browser-profile openclaw start

# 检查状态
openclaw browser --browser-profile openclaw status

# 打开网页
openclaw browser --browser-profile openclaw open https://example.com

# 使用完成后关闭 ⭐ 重要！
openclaw browser --browser-profile openclaw stop
```

### 方案 2：本地 Chrome 技能（备用）

```bash
# 启动浏览器
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\start-chrome.js

# 检查状态
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\check-status.js

# 使用完成后关闭 ⭐ 重要！
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\stop-chrome.js
```

### 方案 3：故障排查工具（推荐）

```bash
# 自动检测 + 启动可用的浏览器
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\troubleshoot.js
```

---

## 🔄 工作流程

```
用户要求访问网站
    ↓
尝试官方 Browser (默认)
    ↓
成功？ → 使用官方 Browser
    ↓
失败？ → 切换到本地 Chrome 技能
    ↓
完成任务
    ↓
关闭浏览器 ⭐
```

---

## ⚠️ 重要规则

**使用浏览器完成任务后，必须关闭浏览器！**

- 官方 Browser：`openclaw browser --browser-profile openclaw stop`
- 本地 Chrome：`node scripts/stop-chrome.js`

---

## 🛠️ 故障排查

### 官方 Browser 无法启动

1. 检查 Gateway 是否运行：`openclaw gateway status`
2. 重启 Gateway：`openclaw gateway restart`
3. 切换到本地 Chrome：`node scripts/start-chrome.js`

### 本地 Chrome 无法启动

1. 检查 Chrome 是否安装：`Test-Path "C:\Program Files\Google\Chrome\Application\chrome.exe"`
2. 检查端口占用：`netstat -ano | findstr :9222`
3. 尝试官方 Browser：`openclaw browser --browser-profile openclaw start`

### 自动故障排查

```bash
node scripts/troubleshoot.js
```

自动检测并启动可用的浏览器方案！

---

## 📁 配置文件位置

**OpenClaw 配置：** `C:\Users\Admin\.openclaw\openclaw.json`

```json5
{
  "browser": {
    "enabled": true,
    "defaultProfile": "openclaw",  // 默认使用官方 Browser
    "ssrfPolicy": {
      "dangerouslyAllowPrivateNetwork": true
    },
    "profiles": {
      "openclaw": {
        "cdpPort": 18800,
        "color": "#FF4500"
      },
      "local-chrome": {
        "cdpUrl": "http://127.0.0.1:9222",
        "color": "#00AA00",
        "attachOnly": true
      }
    }
  }
}
```

---

## 🎯 快速参考

| 需求 | 命令 |
|------|------|
| **启动官方 Browser** | `openclaw browser --browser-profile openclaw start` |
| **启动本地 Chrome** | `node scripts/start-chrome.js` |
| **关闭官方 Browser** | `openclaw browser --browser-profile openclaw stop` |
| **关闭本地 Chrome** | `node scripts/stop-chrome.js` |
| **故障排查** | `node scripts/troubleshoot.js` |
| **检查状态** | `openclaw browser status` 或 `node scripts/check-status.js` |

---

**技能路径：** `C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome`


path: INSTALL.md
content: # browser-local-chrome 技能安装指南

## 📦 安装包内容

```
browser-local-chrome/
├── scripts/
│   ├── start-chrome.js       # 启动 Chrome
│   ├── stop-chrome.js        # 关闭 Chrome
│   ├── check-status.js       # 检查状态
│   ├── configure-browser.js  # 配置 OpenClaw
│   ├── setup.js              # 一键配置
│   └── troubleshoot.js       # 故障排查
├── SKILL.md                  # 技能说明
├── README.md                 # 使用指南
├── QUICKSTART.md             # 快速参考
├── HYBRID-MODE.md            # 混合方案说明
├── INSTALL.md                # 安装说明（本文件）
├── _meta.json                # 技能元数据
└── package.json              # NPM 配置
```

---

## 🚀 快速安装

### 方法 1：直接复制（推荐）

1. **复制技能文件夹**到目标主机的 OpenClaw 技能目录：
   ```bash
   # Windows
   xcopy /E /I browser-local-chrome %USERPROFILE%\.openclaw\workspace\skills\
   
   # macOS/Linux
   cp -r browser-local-chrome ~/.openclaw/workspace/skills/
   ```

2. **验证安装**：
   ```bash
   cd ~/.openclaw/workspace/skills/browser-local-chrome
   node scripts/check-status.js
   ```

3. **启动浏览器**：
   ```bash
   node scripts/start-chrome.js
   ```

---

### 方法 2：使用 clawhub（如果已配置）

```bash
# 在目标主机上
cd ~/.openclaw/workspace/skills
clawhub install browser-local-chrome --local /path/to/browser-local-chrome
```

---

## 📋 系统要求

| 要求 | Windows | macOS | Linux |
|------|---------|-------|-------|
| **操作系统** | Windows 10+ | macOS 10.15+ | Ubuntu 20.04+ |
| **Chrome 版本** | Chrome 100+ | Chrome 100+ | Chrome 100+ |
| **Node.js** | 14+ | 14+ | 14+ |
| **OpenClaw** | 2026.4.0+ | 2026.4.0+ | 2026.4.0+ |

---

## 🔧 安装步骤

### 步骤 1：检查依赖

```bash
# 检查 Node.js
node --version

# 检查 Chrome 是否安装
# Windows
Test-Path "C:\Program Files\Google\Chrome\Application\chrome.exe"

# macOS
ls "/Applications/Google Chrome.app"

# Linux
which google-chrome
```

### 步骤 2：复制技能文件

将 `browser-local-chrome` 文件夹复制到目标位置：

```bash
# 目标路径：~/.openclaw/workspace/skills/browser-local-chrome
```

### 步骤 3：配置 OpenClaw（可选）

如果需要自动配置 OpenClaw：

```bash
cd ~/.openclaw/workspace/skills/browser-local-chrome
node scripts/setup.js
```

### 步骤 4：重启 Gateway

```bash
openclaw gateway restart
```

---

## ⚙️ 自定义配置

### 修改 Chrome 路径

编辑 `_meta.json`：

```json
{
  "config": {
    "chromePath": {
      "win32": "你的 Chrome 路径",
      "darwin": "你的 Chrome 路径",
      "linux": "你的 Chrome 路径"
    }
  }
}
```

### 修改 CDP 端口

编辑 `_meta.json`：

```json
{
  "config": {
    "cdpPort": 9222
  }
}
```

---

## 🎯 使用方式

### 启动浏览器

```bash
node scripts/start-chrome.js
```

### 检查状态

```bash
node scripts/check-status.js
```

### 关闭浏览器

```bash
node scripts/stop-chrome.js
```

### 故障排查

```bash
node scripts/troubleshoot.js
```

---

## 🌐 跨平台说明

此技能支持 Windows、macOS 和 Linux：

- **Windows:** 使用 `taskkill` 关闭进程
- **macOS:** 使用 `killall` 关闭进程
- **Linux:** 使用 `killall` 关闭进程

所有脚本会自动检测操作系统并使用正确的命令。

---

## 📝 配置文件位置

| 文件 | Windows | macOS/Linux |
|------|---------|-------------|
| **OpenClaw 配置** | `%USERPROFILE%\.openclaw\openclaw.json` | `~/.openclaw/openclaw.json` |
| **Chrome 用户数据** | `C:\chrome-debug-profile` | `~/chrome-debug-profile` |
| **技能目录** | `%USERPROFILE%\.openclaw\workspace\skills\` | `~/.openclaw/workspace/skills/` |

---

## 🐛 常见问题

### Chrome 无法启动

**Windows:**
```bash
# 检查 Chrome 是否安装
Test-Path "C:\Program Files\Google\Chrome\Application\chrome.exe"
```

**macOS:**
```bash
# 检查 Chrome 是否安装
ls "/Applications/Google Chrome.app"
```

**Linux:**
```bash
# 安装 Chrome
sudo apt install google-chrome-stable
```

### 端口被占用

```bash
# 检查端口占用
# Windows
netstat -ano | findstr :9222

# macOS/Linux
lsof -i :9222

# 关闭占用端口的进程
# Windows
taskkill /F /PID <PID>

# macOS/Linux
kill -9 <PID>
```

### 配置不生效

```bash
# 重启 Gateway
openclaw gateway restart
```

---

## 📞 支持

如有问题，请查看：
- [OpenClaw 官方文档](https://docs.openclaw.ai)
- [技能说明文档](SKILL.md)
- [快速参考](QUICKSTART.md)

---

**版本：** 1.1.0  
**作者：** Like Liu  
**许可证：** MIT


path: package.json
content: {
  "name": "browser-local-chrome",
  "version": "1.0.0",
  "description": "本地 Chrome 调试模式浏览器自动化配置",
  "main": "scripts/setup.js",
  "author": "Like Liu",
  "license": "MIT",
  "scripts": {
    "start": "node scripts/start-chrome.js",
    "stop": "node scripts/stop-chrome.js",
    "config": "node scripts/configure-browser.js",
    "status": "node scripts/check-status.js",
    "setup": "node scripts/setup.js",
    "troubleshoot": "node scripts/troubleshoot.js"
  },
  "bin": {
    "browser-local-chrome": "./scripts/setup.js"
  },
  "config": {
    "cdpPort": 9222,
    "userDataDir": "C:\\chrome-debug-profile",
    "chromePath": "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
  }
}


path: QUICKSTART.md
content: # 浏览器自动化技能 - 快速参考

## 🚀 一键启动

```bash
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\setup.js
```

## 📋 完整工作流程

```bash
# 1. 启动浏览器
node scripts/start-chrome.js

# 2. 配置 OpenClaw（仅首次）
node scripts/configure-browser.js

# 3. 重启 Gateway（仅首次）
openclaw gateway restart

# 4. 检查状态
node scripts/check-status.js

# === 使用浏览器工具 ===
# 在 OpenClaw 中访问网站

# 5. 使用完成后关闭浏览器 ⭐ 重要！
node scripts/stop-chrome.js
```

## 🔧 脚本说明

| 脚本 | 功能 | 何时使用 |
|------|------|---------|
| `setup.js` | 一键配置全流程 | 首次配置或快速启动 |
| `start-chrome.js` | 启动 Chrome 调试模式 | 每次使用前 |
| `stop-chrome.js` | 关闭 Chrome 浏览器 | **使用完成后** |
| `check-status.js` | 检查浏览器状态 | 确认是否运行 |
| `configure-browser.js` | 配置 OpenClaw | 仅首次配置 |

## 💡 最佳实践

### ✅ 推荐做法
- 使用完成后立即关闭浏览器
- 定期检查浏览器状态
- 保存重要数据后再关闭

### ❌ 避免做法
- 让 Chrome 长时间后台运行
- 同时启动多个 Chrome 调试实例
- 不关闭浏览器直接重启系统

## 🎯 常用命令

```bash
# 启动浏览器
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\start-chrome.js

# 检查状态
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\check-status.js

# 关闭浏览器（使用完成后）
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\stop-chrome.js

# 一键配置（包含启动、配置、验证）
node C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\scripts\setup.js
```

## 📁 技能路径

```
C:\Users\Admin\.openclaw\workspace\skills\browser-local-chrome\
├── scripts/
│   ├── setup.js              # 一键配置
│   ├── start-chrome.js       # 启动
│   ├── stop-chrome.js        # 关闭 ⭐
│   ├── configure-browser.js  # 配置
│   └── check-status.js       # 检查
├── SKILL.md                  # 技能文档
├── README.md                 # 使用指南
├── _meta.json                # 元数据
└── package.json              # NPM 配置
```

## 🔒 安全说明

- `dangerouslyAllowPrivateNetwork: true` 允许访问私有网络
- 仅在可信环境中使用
- 使用完成后关闭浏览器可避免安全风险

## 🐛 故障排查

**Chrome 无法关闭**
```bash
# 强制关闭所有 Chrome 进程
taskkill /F /IM chrome.exe
```

**端口被占用**
```bash
# 查找占用端口的进程
netstat -ano | findstr :9222

# 关闭对应进程（替换 PID）
taskkill /F /PID <PID>
```

**配置不生效**
```bash
# 重启 Gateway
openclaw gateway restart
```


path: README.md
content: # browser-local-chrome

本地 Chrome 调试模式浏览器自动化配置技能

## 快速开始

### 方案 A：官方 Browser（默认）

```bash
# 启动
openclaw browser --browser-profile openclaw start

# 检查状态
openclaw browser --browser-profile openclaw status

# 打开网页
openclaw browser --browser-profile openclaw open https://example.com

# 使用完成后关闭
openclaw browser --browser-profile openclaw stop
```

### 方案 B：本地 Chrome 技能（备用）

```bash
# 启动
node scripts/start-chrome.js

# 检查状态
node scripts/check-status.js

# 使用完成后关闭
node scripts/stop-chrome.js
```

### 方案 C：一键故障排查（推荐）

```bash
node scripts/troubleshoot.js
```

自动检测 + 启动可用的浏览器方案！

## 脚本说明

| 脚本 | 功能 | 参数 |
|------|------|------|
| `setup.js` | 一键配置（启动 + 配置 + 验证） | 无 |
| `start-chrome.js` | 启动 Chrome 调试模式 | `[端口]` (默认 9222) |
| `stop-chrome.js` | 关闭 Chrome 浏览器 | `[端口]` (默认 9222) |
| `configure-browser.js` | 配置 OpenClaw | `[端口]` (默认 9222) |
| `check-status.js` | 检查浏览器状态 | `[端口]` (默认 9222) |

## 配置项

在 `_meta.json` 中可自定义：

```json
{
  "config": {
    "cdpPort": 9222,
    "userDataDir": "C:\\chrome-debug-profile",
    "chromePath": "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
  }
}
```

## 使用场景

- ✅ 访问需要 JavaScript 的网站（如 Google 搜索）
- ✅ 自动化网页操作
- ✅ 截图和页面分析
- ✅ 绕过 SSRF 限制

## 完整工作流程示例

```bash
# 1. 启动浏览器
node scripts/start-chrome.js

# 2. 配置 OpenClaw（首次使用时）
node scripts/configure-browser.js

# 3. 重启 Gateway（首次配置后）
openclaw gateway restart

# 4. 检查状态
node scripts/check-status.js

# === 使用浏览器工具访问网站 ===
# 在 OpenClaw 中：browser open https://example.com

# 5. 使用完成后关闭浏览器
node scripts/stop-chrome.js
```

## 故障排查

**Chrome 无法启动**
```bash
# 检查 Chrome 是否安装
Test-Path "C:\Program Files\Google\Chrome\Application\chrome.exe"

# 检查端口占用
netstat -ano | findstr :9222
```

**配置不生效**
```bash
# 重启 Gateway
openclaw gateway restart

# 检查配置文件
cat ~/.openclaw/openclaw.json
```

## 安全说明

此技能配置 `dangerouslyAllowPrivateNetwork: true`，允许浏览器访问私有网络地址。仅在可信环境中使用。

如需更严格的安全策略，可修改 `openclaw.json` 中的 `ssrfPolicy`：

```json
{
  "browser": {
    "ssrfPolicy": {
      "hostnameAllowlist": ["*.example.com", "example.com"]
    }
  }
}
```


path: RELEASE.md
content: # 📦 browser-local-chrome 技能发布包

## 📋 发布信息

- **版本：** v1.1.0
- **发布日期：** 2026-04-14
- **作者：** Like Liu
- **许可证：** MIT

---

## 📦 打包文件

**文件名：** `browser-local-chrome-v1.1.0.zip`  
**大小：** ~18 KB  
**内容：** 完整的技能文件夹（不含 node_modules）

---

## 🎯 功能特性

### ✅ 核心功能
- 启动 Chrome 调试模式（CDP 端口 9222）
- 自动配置 OpenClaw 浏览器设置
- 优雅关闭 Chrome 浏览器
- 检查浏览器状态
- 故障排查工具
- 一键配置脚本

### ✅ 跨平台支持
- **Windows:** ✅ 支持（已测试）
- **macOS:** ✅ 支持（自动检测路径）
- **Linux:** ✅ 支持（自动检测路径）

### ✅ 混合方案
- 默认使用官方 Browser（端口 18800）
- 备用本地 Chrome 技能（端口 9222）
- 自动故障切换

---

## 📋 打包内容

```
browser-local-chrome/
├── scripts/
│   ├── start-chrome.js       # 启动 Chrome（跨平台）
│   ├── stop-chrome.js        # 关闭 Chrome（跨平台）
│   ├── check-status.js       # 检查状态
│   ├── configure-browser.js  # 配置 OpenClaw
│   ├── setup.js              # 一键配置
│   ├── troubleshoot.js       # 故障排查
│   ├── simple-package.js     # 打包脚本
│   └── package.js            # 打包脚本（需要 archiver）
├── SKILL.md                  # 技能说明
├── README.md                 # 使用指南
├── QUICKSTART.md             # 快速参考
├── HYBRID-MODE.md            # 混合方案说明
├── INSTALL.md                # 安装说明
├── RELEASE.md                # 发布说明（本文件）
├── _meta.json                # 技能元数据（v1.1.0）
└── package.json              # NPM 配置
```

---

## 🚀 安装方法

### 方法 1：解压 ZIP 文件（推荐）

1. **复制 ZIP 文件**到目标主机
2. **解压**到 OpenClaw 技能目录：
   ```bash
   # Windows
   Expand-Archive -Path browser-local-chrome-v1.1.0.zip `
                  -DestinationPath "$env:USERPROFILE\.openclaw\workspace\skills\"
   
   # macOS/Linux
   unzip browser-local-chrome-v1.1.0.zip \
         -d ~/.openclaw/workspace/skills/
   ```

3. **验证安装**：
   ```bash
   cd ~/.openclaw/workspace/skills/browser-local-chrome
   node scripts/check-status.js
   ```

4. **启动浏览器**：
   ```bash
   node scripts/start-chrome.js
   ```

---

### 方法 2：直接复制文件夹

```bash
# Windows
xcopy /E /I browser-local-chrome "%USERPROFILE%\.openclaw\workspace\skills\"

# macOS/Linux
cp -r browser-local-chrome ~/.openclaw/workspace/skills/
```

---

## 📋 系统要求

| 要求 | Windows | macOS | Linux |
|------|---------|-------|-------|
| **操作系统** | Windows 10+ | macOS 10.15+ | Ubuntu 20.04+ |
| **Chrome 版本** | Chrome 100+ | Chrome 100+ | Chrome 100+ |
| **Node.js** | 14+ | 14+ | 14+ |
| **OpenClaw** | 2026.4.0+ | 2026.4.0+ | 2026.4.0+ |

---

## 🔧 配置说明

### 默认配置

- **CDP 端口：** 9222
- **用户数据目录：**
  - Windows: `C:\chrome-debug-profile`
  - macOS/Linux: `~/chrome-debug-profile`
- **Chrome 路径：** 自动检测（可自定义）

### 自定义配置

编辑 `_meta.json` 文件：

```json
{
  "config": {
    "cdpPort": 9222,
    "userDataDir": {
      "win32": "C:\\chrome-debug-profile",
      "darwin": "~/chrome-debug-profile",
      "linux": "~/chrome-debug-profile"
    },
    "chromePath": {
      "win32": "你的 Chrome 路径",
      "darwin": "你的 Chrome 路径",
      "linux": "你的 Chrome 路径"
    }
  }
}
```

---

## 🎯 使用方式

### 启动浏览器

```bash
node scripts/start-chrome.js
```

### 检查状态

```bash
node scripts/check-status.js
```

### 关闭浏览器 ⭐

```bash
node scripts/stop-chrome.js
```

### 故障排查

```bash
node scripts/troubleshoot.js
```

### 一键配置

```bash
node scripts/setup.js
```

---

## 🌐 混合方案配置

如果需要在同一主机上使用官方 Browser + 本地 Chrome 技能：

### OpenClaw 配置 (`~/.openclaw/openclaw.json`)

```json5
{
  "browser": {
    "enabled": true,
    "defaultProfile": "openclaw",
    "ssrfPolicy": {
      "dangerouslyAllowPrivateNetwork": true
    },
    "profiles": {
      "openclaw": {
        "cdpPort": 18800,
        "color": "#FF4500"
      },
      "local-chrome": {
        "cdpUrl": "http://127.0.0.1:9222",
        "color": "#00AA00",
        "attachOnly": true
      }
    }
  }
}
```

### 使用方式

- **默认：** `openclaw browser --browser-profile openclaw start`
- **备用：** `node scripts/start-chrome.js`

---

## 🐛 常见问题

### Chrome 无法启动

**Windows:**
```bash
Test-Path "C:\Program Files\Google\Chrome\Application\chrome.exe"
```

**macOS:**
```bash
ls "/Applications/Google Chrome.app"
```

**Linux:**
```bash
which google-chrome
# 或安装：sudo apt install google-chrome-stable
```

### 端口被占用

```bash
# Windows
netstat -ano | findstr :9222
taskkill /F /PID <PID>

# macOS/Linux
lsof -i :9222
kill -9 <PID>
```

### 配置不生效

```bash
openclaw gateway restart
```

---

## 📞 支持

- **官方文档：** https://docs.openclaw.ai
- **技能文档：** 查看 `SKILL.md` 和 `README.md`
- **快速参考：** 查看 `QUICKSTART.md`
- **安装说明：** 查看 `INSTALL.md`

---

## 📝 更新日志

### v1.1.0 (2026-04-14)

**新增：**
- ✅ 跨平台支持（Windows/macOS/Linux）
- ✅ 故障排查工具 (`troubleshoot.js`)
- ✅ 混合方案文档 (`HYBRID-MODE.md`)
- ✅ 安装说明文档 (`INSTALL.md`)
- ✅ 打包脚本 (`simple-package.js`)

**改进：**
- 🔧 所有脚本支持跨平台路径
- 🔧 自动检测操作系统
- 🔧 改进错误提示和故障恢复

**修复：**
- 🐛 修复 Windows 路径问题
- 🐛 修复进程关闭逻辑

### v1.0.0 (2026-04-14)

- 🎉 初始版本发布
- ✅ 基础功能实现
- ✅ Windows 平台支持

---

## 📄 许可证

MIT License - 详见 [LICENSE](LICENSE) 文件（如有）

---

**打包时间：** 2026-04-14 11:55  
**打包文件：** `browser-local-chrome-v1.1.0.zip`  
**文件大小：** ~18 KB


path: scripts/check-status.js
content: #!/usr/bin/env node

/**
 * 检查浏览器状态
 * 
 * 用法：node scripts/check-status.js [端口]
 */

const https = require('https');
const http = require('http');

const CDP_PORT = process.argv[2] || '9222';
const CDP_URL = `http://127.0.0.1:${CDP_PORT}/json/version`;

console.log('🔍 检查浏览器状态...\n');

http.get(CDP_URL, (res) => {
  let data = '';
  
  res.on('data', (chunk) => {
    data += chunk;
  });
  
  res.on('end', () => {
    if (res.statusCode === 200) {
      const info = JSON.parse(data);
      console.log('✅ Chrome 调试模式运行中！');
      console.log('   版本:', info.Browser);
      console.log('   V8 版本:', info['V8-Version']);
      console.log('   WebKit 版本:', info['WebKit-Version']);
      console.log('   CDP 地址:', CDP_URL);
      console.log('   WebSocket:', info.webSocketDebuggerUrl);
    } else {
      console.error('❌ CDP 响应异常:', res.statusCode);
    }
  });
}).on('error', (err) => {
  console.error('❌ 无法连接到 Chrome 调试模式');
  console.error('   错误:', err.message);
  console.error('\n💡 提示：');
  console.error('   1. 启动 Chrome: node scripts/start-chrome.js');
  console.error('   2. 检查端口是否被占用：netstat -ano | findstr :9222');
  process.exit(1);
});


path: scripts/configure-browser.js
content: #!/usr/bin/env node

/**
 * 配置 OpenClaw 浏览器设置
 * 
 * 用法：node scripts/configure-browser.js [端口]
 */

const fs = require('fs');
const path = require('path');

const CDP_PORT = process.argv[2] || '9222';
const CONFIG_PATH = path.join(process.env.USERPROFILE, '.openclaw', 'openclaw.json');

console.log('⚙️  配置 OpenClaw 浏览器...');

// 读取配置文件
let config;
try {
  const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
  config = JSON.parse(content);
} catch (error) {
  console.error('❌ 读取配置文件失败:', error.message);
  process.exit(1);
}

// 配置浏览器
config.browser = {
  enabled: true,
  defaultProfile: 'local-chrome',
  attachOnly: true,
  ssrfPolicy: {
    dangerouslyAllowPrivateNetwork: true
  },
  profiles: {
    'local-chrome': {
      cdpUrl: `http://127.0.0.1:${CDP_PORT}`,
      color: '#00AA00'
    }
  }
};

// 写回配置文件
try {
  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
  console.log('✅ 配置已更新！');
  console.log(`   配置文件：${CONFIG_PATH}`);
  console.log(`   CDP 地址：http://127.0.0.1:${CDP_PORT}`);
  console.log('\n⚠️  请重启 Gateway 使配置生效：');
  console.log('   openclaw gateway restart');
} catch (error) {
  console.error('❌ 写入配置文件失败:', error.message);
  process.exit(1);
}


path: scripts/package.js
content: #!/usr/bin/env node

/**
 * 打包技能为 ZIP 文件
 * 
 * 用法：node scripts/package.js [输出文件名]
 * 示例：node scripts/package.js browser-local-chrome-v1.1.0.zip
 */

const fs = require('fs');
const path = require('path');
const { exec } = require('child_process');
const archiver = require('archiver');

const SKILL_DIR = path.join(__dirname, '..');
const OUTPUT_FILE = process.argv[2] || 'browser-local-chrome.zip';

console.log('📦 打包 browser-local-chrome 技能...\n');

// 检查 archiver 是否安装
try {
  require.resolve('archiver');
} catch (e) {
  console.log('⚠️  archiver 模块未安装，尝试使用系统 zip 命令...\n');
  useSystemZip();
  return;
}

// 使用 archiver 打包
function createZip() {
  const output = fs.createWriteStream(path.join(SKILL_DIR, OUTPUT_FILE));
  const archive = archiver('zip', {
    zlib: { level: 9 } // 最高压缩级别
  });

  output.on('close', () => {
    const sizeMB = (archive.pointer() / 1024 / 1024).toFixed(2);
    console.log(`✅ 打包完成！`);
    console.log(`   文件：${OUTPUT_FILE}`);
    console.log(`   大小：${sizeMB} MB`);
    console.log(`   位置：${SKILL_DIR}`);
  });

  archive.on('error', (err) => {
    console.error('❌ 打包失败:', err);
    process.exit(1);
  });

  archive.pipe(output);

  console.log('📁 添加文件...');
  
  // 添加所有文件（排除 node_modules 和 zip 文件）
  archive.glob('**/*', {
    cwd: SKILL_DIR,
    ignore: [
      'node_modules/**',
      '*.zip',
      '.git/**'
    ]
  });

  archive.finalize();
}

// 使用系统 zip 命令
function useSystemZip() {
  const zipFile = path.join(SKILL_DIR, OUTPUT_FILE);
  const platform = process.platform;
  
  let command;
  
  if (platform === 'win32') {
    // Windows: 使用 PowerShell Compress-Archive
    command = `Compress-Archive -Path "${SKILL_DIR}\\*" -DestinationPath "${zipFile}" -Force`;
    console.log('🔧 使用 PowerShell Compress-Archive...\n');
  } else {
    // macOS/Linux: 使用 zip 命令
    const cwd = path.dirname(SKILL_DIR);
    const skillName = path.basename(SKILL_DIR);
    command = `cd "${cwd}" && zip -r "${OUTPUT_FILE}" "${skillName}" -x "*.zip" -x "node_modules/*" -x ".git/*"`;
    console.log('🔧 使用系统 zip 命令...\n');
  }
  
  exec(command, { cwd: platform === 'win32' ? undefined : cwd }, (error, stdout, stderr) => {
    if (error) {
      console.error('❌ 打包失败:', error.message);
      console.error('💡 提示：安装 archiver 模块：npm install archiver');
      process.exit(1);
    }
    
    const stats = fs.statSync(zipFile);
    const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
    
    console.log('✅ 打包完成！');
    console.log(`   文件：${OUTPUT_FILE}`);
    console.log(`   大小：${sizeMB} MB`);
    console.log(`   位置：${zipFile}`);
  });
}

// 检查并打包
console.log('📂 技能目录:', SKILL_DIR);
console.log('📄 输出文件:', OUTPUT_FILE);
console.log('🖥️  平台:', process.platform);
console.log('');

// 列出将要打包的文件
console.log('📋 文件清单:');
const files = fs.readdirSync(SKILL_DIR, { recursive: true })
  .filter(f => {
    const fullPath = path.join(SKILL_DIR, f);
    const stat = fs.statSync(fullPath);
    return stat.isFile() && 
           !f.includes('node_modules') && 
           !f.endsWith('.zip');
  });

files.forEach(f => {
  console.log(`   - ${f}`);
});

console.log('');
console.log(`📊 共 ${files.length} 个文件`);
console.log('');

createZip();


path: scripts/setup.js
content: #!/usr/bin/env node

/**
 * 一键配置浏览器自动化
 * 
 * 用法：node scripts/setup.js
 */

const { exec } = require('child_process');
const fs = require('fs');
const path = require('path');

const CDP_PORT = '9222';
const SCRIPTS_DIR = path.join(__dirname);

console.log('🦞 浏览器自动化一键配置\n');
console.log('=' .repeat(50));

// 步骤 1: 启动 Chrome
console.log('\n📌 步骤 1/4: 启动 Chrome 调试模式...');
exec(`node "${path.join(SCRIPTS_DIR, 'start-chrome.js')}" ${CDP_PORT}`, (error) => {
  if (error) {
    console.error('❌ 启动失败:', error.message);
  } else {
    console.log('✅ Chrome 已启动');
  }
  
  // 等待 3 秒让 Chrome 完全启动
  setTimeout(() => {
    // 步骤 2: 配置 OpenClaw
    console.log('\n📌 步骤 2/4: 配置 OpenClaw...');
    exec(`node "${path.join(SCRIPTS_DIR, 'configure-browser.js')}" ${CDP_PORT}`, (error, stdout) => {
      if (error) {
        console.error('❌ 配置失败:', error.message);
      } else {
        console.log(stdout);
      }
      
      // 步骤 3: 检查状态
      console.log('\n📌 步骤 3/4: 检查浏览器状态...');
      exec(`node "${path.join(SCRIPTS_DIR, 'check-status.js')}" ${CDP_PORT}`, (error, stdout, stderr) => {
        if (error) {
          console.log('⚠️  浏览器未运行，需要手动启动');
          console.log('   命令：node scripts/start-chrome.js');
        } else {
          console.log(stdout);
        }
        
        // 步骤 4: 提示重启 Gateway
        console.log('\n📌 步骤 4/4: 重启 Gateway');
        console.log('⚠️  请手动执行以下命令使配置生效：');
        console.log('   openclaw gateway restart\n');
        
        console.log('=' .repeat(50));
        console.log('✅ 配置完成！\n');
        console.log('📖 使用说明:');
        console.log('   - 启动浏览器：node scripts/start-chrome.js');
        console.log('   - 检查状态：node scripts/check-status.js');
        console.log('   - 重新配置：node scripts/configure-browser.js');
        console.log('\n🎉 现在可以使用浏览器工具访问任何网站了！\n');
      });
    });
  }, 3000);
});


path: scripts/simple-package.js
content: #!/usr/bin/env node

/**
 * 简单打包脚本（无需依赖）
 * 
 * 用法：node scripts/simple-package.js [版本]
 * 示例：node scripts/simple-package.js 1.1.0
 */

const fs = require('fs');
const path = require('path');
const { exec } = require('child_process');

const SKILL_DIR = path.join(__dirname, '..');
const VERSION = process.argv[2] || '1.1.0';
const ZIP_FILE = `browser-local-chrome-v${VERSION}.zip`;

console.log('📦 打包 browser-local-chrome 技能...\n');
console.log(`📝 版本：v${VERSION}`);
console.log(`📄 输出：${ZIP_FILE}\n`);

// 使用 PowerShell Compress-Archive (Windows)
function packageWindows() {
  const excludePatterns = [
    'node_modules',
    '*.zip',
    '.git'
  ].join('\",\"');
  
  const command = `
    $files = Get-ChildItem -Path "${SKILL_DIR}" -Recurse -File | 
             Where-Object { 
               $_.FullName -notmatch 'node_modules' -and 
               $_.FullName -notmatch '\\.zip$' -and 
               $_.FullName -notmatch '\\.git' 
             }
    Compress-Archive -Path $files.FullName -DestinationPath "${path.join(SKILL_DIR, ZIP_FILE)}" -Force
  `;
  
  exec(`powershell -Command "${command}"`, (error, stdout, stderr) => {
    if (error) {
      console.error('❌ 打包失败:', error.message);
      fallbackPackage();
      return;
    }
    
    showSuccess();
  });
}

// 使用 zip 命令 (macOS/Linux)
function packageUnix() {
  const cwd = path.dirname(SKILL_DIR);
  const skillName = path.basename(SKILL_DIR);
  
  const command = `cd "${cwd}" && zip -r "${ZIP_FILE}" "${skillName}" \\
    -x "*.zip" \\
    -x "*/node_modules/*" \\
    -x "*/.git/*"`;
  
  exec(command, (error, stdout, stderr) => {
    if (error) {
      console.error('❌ 打包失败:', error.message);
      fallbackPackage();
      return;
    }
    
    showSuccess();
  });
}

// 备用方案：手动复制文件
function fallbackPackage() {
  console.log('\n⚠️  自动打包失败，使用备用方案...\n');
  console.log('📋 请手动创建 ZIP 文件，包含以下文件:\n');
  
  const files = fs.readdirSync(SKILL_DIR, { recursive: true })
    .filter(f => {
      const fullPath = path.join(SKILL_DIR, f);
      const stat = fs.statSync(fullPath);
      return stat.isFile() && 
             !f.includes('node_modules') && 
             !f.endsWith('.zip') &&
             !f.includes('.git');
    });
  
  files.forEach(f => {
    console.log(`   - ${f}`);
  });
  
  console.log(`\n📊 共 ${files.length} 个文件`);
  console.log('\n💡 手动打包方法:');
  console.log('   1. 复制 browser-local-chrome 文件夹');
  console.log('   2. 右键 -> 发送到 -> 压缩 (ZIP) 文件夹 (Windows)');
  console.log('   3. 或使用 zip 命令：zip -r browser-local-chrome.zip browser-local-chrome');
}

function showSuccess() {
  const zipPath = path.join(SKILL_DIR, ZIP_FILE);
  
  if (fs.existsSync(zipPath)) {
    const stats = fs.statSync(zipPath);
    const sizeKB = (stats.size / 1024).toFixed(2);
    
    console.log('✅ 打包完成！\n');
    console.log('📦 文件信息:');
    console.log(`   文件名：${ZIP_FILE}`);
    console.log(`   大小：${sizeKB} KB`);
    console.log(`   位置：${zipPath}`);
    console.log('\n📋 包含文件:');
    
    const files = fs.readdirSync(SKILL_DIR, { recursive: true })
      .filter(f => {
        const fullPath = path.join(SKILL_DIR, f);
        const stat = fs.statSync(fullPath);
        return stat.isFile() && 
               !f.includes('node_modules') && 
               !f.endsWith('.zip') &&
               !f.includes('.git');
      });
    
    files.forEach(f => {
      console.log(`   - ${f}`);
    });
    
    console.log(`\n📊 共 ${files.length} 个文件`);
    console.log('\n🚀 安装方法:');
    console.log('   1. 将 ZIP 文件复制到目标主机');
    console.log('   2. 解压到 ~/.openclaw/workspace/skills/');
    console.log('   3. 运行：node scripts/start-chrome.js');
  } else {
    console.log('❌ ZIP 文件创建失败');
  }
}

// 开始打包
console.log('🖥️  平台:', process.platform);
console.log('');

if (process.platform === 'win32') {
  packageWindows();
} else {
  packageUnix();
}


path: scripts/start-chrome.js
content: #!/usr/bin/env node

/**
 * 启动 Chrome 调试模式（跨平台）
 * 
 * 用法：node scripts/start-chrome.js [端口]
 * 示例：node scripts/start-chrome.js 9222
 */

const { exec } = require('child_process');
const path = require('path');
const os = require('os');

const CDP_PORT = process.argv[2] || '9222';
const platform = os.platform();

// 跨平台路径配置
const CONFIG = {
  win32: {
    userDataDir: 'C:\\chrome-debug-profile',
    chromePath: 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'
  },
  darwin: {
    userDataDir: '~/chrome-debug-profile',
    chromePath: '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
  },
  linux: {
    userDataDir: '~/chrome-debug-profile',
    chromePath: '/usr/bin/google-chrome'
  }
};

const config = CONFIG[platform] || CONFIG.linux;
const USER_DATA_DIR = config.userDataDir;
const CHROME_PATH = config.chromePath;

console.log('🚀 启动 Chrome 调试模式...');
console.log(`   平台：${platform}`);
console.log(`   端口：${CDP_PORT}`);
console.log(`   用户数据目录：${USER_DATA_DIR}`);
console.log(`   Chrome 路径：${CHROME_PATH}`);

const args = [
  `--remote-debugging-port=${CDP_PORT}`,
  `--user-data-dir="${USER_DATA_DIR}"`,
  '--no-first-run',
  '--no-default-browser-check'
].join(' ');

const command = `"${CHROME_PATH}" ${args}`;

exec(command, (error, stdout, stderr) => {
  if (error) {
    console.error('❌ 启动失败:', error.message);
    console.error('\n💡 提示：');
    if (platform === 'win32') {
      console.error('   确认 Chrome 已安装到默认路径');
      console.error('   或修改 _meta.json 中的 chromePath');
    } else if (platform === 'darwin') {
      console.error('   确认 Chrome 已安装：/Applications/Google Chrome.app');
      console.error('   或使用：which "Google Chrome"');
    } else {
      console.error('   确认 Chrome 已安装：which google-chrome');
      console.error('   或使用：sudo apt install google-chrome-stable');
    }
    process.exit(1);
  }
  
  console.log('✅ Chrome 已启动！');
  console.log(`   CDP 地址：http://127.0.0.1:${CDP_PORT}`);
  console.log(`   验证命令：curl http://127.0.0.1:${CDP_PORT}/json/version`);
});


path: scripts/stop-chrome.js
content: #!/usr/bin/env node

/**
 * 关闭 Chrome 调试模式（跨平台）
 * 
 * 用法：node scripts/stop-chrome.js
 */

const { exec } = require('child_process');
const os = require('os');

const platform = os.platform();

console.log('🛑 关闭 Chrome 浏览器...\n');

// 方法 1: 通过 CDP API 关闭浏览器（优雅关闭）
const http = require('http');
const CDP_PORT = process.argv[2] || '9222';
const CDP_URL = `http://127.0.0.1:${CDP_PORT}/json/version`;

console.log('📡 尝试通过 CDP API 关闭...');

http.get(CDP_URL, (res) => {
  let data = '';
  
  res.on('data', (chunk) => {
    data += chunk;
  });
  
  res.on('end', () => {
    if (res.statusCode === 200) {
      const info = JSON.parse(data);
      const wsUrl = info.webSocketDebuggerUrl;
      
      if (wsUrl) {
        console.log('✅ Chrome 已响应，尝试关闭所有标签页...');
        
        // 获取所有标签页并关闭
        http.get(`http://127.0.0.1:${CDP_PORT}/json`, (res2) => {
          let pages = '';
          
          res2.on('data', (chunk) => {
            pages += chunk;
          });
          
          res2.on('end', () => {
            try {
              const pageList = JSON.parse(pages);
              console.log(`   发现 ${pageList.length} 个标签页`);
              
              // 关闭所有标签页
              pageList.forEach((page, index) => {
                if (page.id) {
                  http.get(`http://127.0.0.1:${CDP_PORT}/json/close/${page.id}`, () => {});
                }
              });
              
              console.log('✅ 所有标签页已关闭');
            } catch (e) {
              console.log('⚠️  无法解析标签页列表');
            }
            
            // 强制关闭 Chrome 进程
            forceKill();
          });
        });
      }
    } else {
      console.log('⚠️  Chrome 未响应，尝试强制关闭...');
      forceKill();
    }
  });
}).on('error', (err) => {
  console.log('⚠️  无法连接到 Chrome，尝试强制关闭进程...');
  forceKill();
});

// 方法 2: 强制关闭 Chrome 进程（跨平台）
function forceKill() {
  console.log('\n🔨 强制关闭 Chrome 进程...');
  
  let command;
  let platformName;
  
  if (platform === 'win32') {
    command = 'taskkill /F /IM chrome.exe';
    platformName = 'Windows';
  } else if (platform === 'darwin') {
    command = 'killall "Google Chrome"';
    platformName = 'macOS';
  } else {
    command = 'killall -9 chrome';
    platformName = 'Linux';
  }
  
  exec(command, (error, stdout, stderr) => {
    if (error) {
      if (error.code === 128 || error.code === 1 || (stderr && stderr.includes('no process'))) {
        console.log('ℹ️  Chrome 进程未运行');
      } else {
        console.error('❌ 关闭失败:', error.message);
      }
    } else {
      console.log('✅ Chrome 已关闭');
      if (stdout) console.log(stdout);
    }
    
    // 获取用户数据目录路径
    let userDataDir;
    if (platform === 'win32') {
      userDataDir = 'C:\\chrome-debug-profile';
    } else {
      userDataDir = '~/chrome-debug-profile';
    }
    
    console.log('\n💡 提示：');
    console.log(`   - 用户数据目录：${userDataDir}`);
    console.log('   - 如需清理缓存，可删除此目录');
    console.log('   - 下次启动会自动创建新配置文件');
  });
}


path: scripts/troubleshoot.js
content: #!/usr/bin/env node

/**
 * 浏览器故障排查工具
 * 
 * 用法：node scripts/troubleshoot.js
 */

const http = require('http');
const { exec } = require('child_process');

const OFFICIAL_PORT = '18800';
const LOCAL_PORT = '9222';

console.log('🔍 浏览器故障排查工具\n');
console.log('=' .repeat(50));

// 检查官方 Browser
function checkOfficialBrowser() {
  return new Promise((resolve) => {
    const url = `http://127.0.0.1:${OFFICIAL_PORT}/json/version`;
    http.get(url, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        if (res.statusCode === 200) {
          const info = JSON.parse(data);
          console.log(`✅ 官方 Browser 运行中 (端口 ${OFFICIAL_PORT})`);
          console.log(`   版本：${info.Browser}`);
          resolve(true);
        } else {
          console.log(`❌ 官方 Browser 未响应 (端口 ${OFFICIAL_PORT})`);
          resolve(false);
        }
      });
    }).on('error', () => {
      console.log(`❌ 官方 Browser 未运行 (端口 ${OFFICIAL_PORT})`);
      resolve(false);
    });
  });
}

// 检查本地 Chrome
function checkLocalChrome() {
  return new Promise((resolve) => {
    const url = `http://127.0.0.1:${LOCAL_PORT}/json/version`;
    http.get(url, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        if (res.statusCode === 200) {
          const info = JSON.parse(data);
          console.log(`✅ 本地 Chrome 运行中 (端口 ${LOCAL_PORT})`);
          console.log(`   版本：${info.Browser}`);
          resolve(true);
        } else {
          console.log(`❌ 本地 Chrome 未响应 (端口 ${LOCAL_PORT})`);
          resolve(false);
        }
      });
    }).on('error', () => {
      console.log(`❌ 本地 Chrome 未运行 (端口 ${LOCAL_PORT})`);
      resolve(false);
    });
  });
}

// 启动官方 Browser
function startOfficialBrowser() {
  return new Promise((resolve) => {
    console.log('\n🚀 尝试启动官方 Browser...');
    exec('openclaw browser --browser-profile openclaw start', (error, stdout, stderr) => {
      if (error) {
        console.log('❌ 启动失败:', error.message);
        resolve(false);
      } else {
        console.log('✅ 官方 Browser 已启动');
        resolve(true);
      }
    });
  });
}

// 启动本地 Chrome
function startLocalChrome() {
  return new Promise((resolve) => {
    console.log('\n🚀 尝试启动本地 Chrome...');
    exec('node scripts/start-chrome.js', { cwd: 'C:\\Users\\Admin\\.openclaw\\workspace\\skills\\browser-local-chrome' }, (error, stdout, stderr) => {
      if (error) {
        console.log('❌ 启动失败:', error.message);
        resolve(false);
      } else {
        console.log('✅ 本地 Chrome 已启动');
        resolve(true);
      }
    });
  });
}

// 主流程
async function main() {
  console.log('📌 步骤 1/3: 检查浏览器状态...\n');
  
  const officialRunning = await checkOfficialBrowser();
  const localRunning = await checkLocalChrome();
  
  console.log('\n📌 步骤 2/3: 分析结果...\n');
  
  if (officialRunning) {
    console.log('✅ 推荐：使用官方 Browser (默认配置)');
    console.log('\n💡 使用命令:');
    console.log('   openclaw browser --browser-profile openclaw open <URL>');
    console.log('   openclaw browser --browser-profile openclaw stop  (完成后关闭)');
  } else if (localRunning) {
    console.log('⚠️  官方 Browser 未运行，使用本地 Chrome (备用方案)');
    console.log('\n💡 使用命令:');
    console.log('   node scripts/start-chrome.js  (启动)');
    console.log('   node scripts/stop-chrome.js   (完成后关闭)');
  } else {
    console.log('❌ 两个浏览器都未运行，尝试启动...\n');
    
    console.log('📌 步骤 3/3: 启动浏览器...\n');
    
    // 尝试启动官方 Browser
    const started = await startOfficialBrowser();
    
    if (started) {
      setTimeout(async () => {
        const check = await checkOfficialBrowser();
        if (check) {
          console.log('\n✅ 启动成功！现在可以使用官方 Browser 了');
          console.log('\n💡 提示：');
          console.log('   - 如果官方 Browser 失败，运行：node scripts/start-chrome.js');
          console.log('   - 使用完成后记得关闭浏览器！');
        } else {
          console.log('\n⚠️  官方 Browser 启动失败，尝试本地 Chrome...');
          await startLocalChrome();
        }
      }, 3000);
    } else {
      // 官方失败，尝试本地 Chrome
      await startLocalChrome();
    }
  }
  
  console.log('\n' + '=' .repeat(50));
  console.log('✅ 排查完成！\n');
}

main();


path: _meta.json
content: {
  "name": "browser-local-chrome",
  "version": "1.1.0",
  "description": "本地 Chrome 调试模式浏览器自动化配置（跨平台）",
  "author": "Like Liu",
  "license": "MIT",
  "scripts": [
    "scripts/start-chrome.js",
    "scripts/configure-browser.js",
    "scripts/check-status.js",
    "scripts/stop-chrome.js",
    "scripts/setup.js",
    "scripts/troubleshoot.js"
  ],
  "config": {
    "cdpPort": 9222,
    "userDataDir": {
      "win32": "C:\\chrome-debug-profile",
      "darwin": "~/chrome-debug-profile",
      "linux": "~/chrome-debug-profile"
    },
    "chromePath": {
      "win32": "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
      "darwin": "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
      "linux": "/usr/bin/google-chrome"
    }
  },
  "platforms": ["win32", "darwin", "linux"],
  "requirements": [
    "Google Chrome 浏览器已安装",
    "Node.js 14+",
    "OpenClaw 2026.4.0+"
  ]
}


Security scan verdicts — ClawScan: suspicious | static analysis: suspicious | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)