Skill: maxdong-max/wechat-bot-reply-skill (version 5.0.0)

--- name: wechat-auto-reply description: "Monitor WeChat for new messages from specific contacts and auto-reply. Supports macOS (Peekaboo CLI) and Windows (PeekabooWin). Requires Peekaboo CLI on macOS or PeekabooWin on Windows." description_zh: "监控微信指定联系人的新消息并自动回复。支持 macOS (Peekaboo CLI) 和 Windows (PeekabooWin)。智能等待，已回复检测。" description_en: "Monitor WeChat for new messages from specific contacts and auto-reply. Cross-platform: macOS + Windows." --- # WeChat Auto Reply (Cross-Platform v5) Monitor WeChat for new messages from **any specified contact** and auto-reply. Supports **macOS** (Peekaboo CLI) and **Windows** (PeekabooWin). --- ## Prerequisites ### macOS (Apple Silicon / Intel) 1. **Peekaboo CLI** installed: ```bash brew install steipete/peekaboo/peekaboo ``` 2. **Permissions granted**: Screen Recording + Accessibility ```bash peekaboo permissions ``` 3. **WeChat** running and visible on screen ### Windows (10 / 11) 1. **Node.js 22+** installed: https://nodejs.org ```powershell node --version # 确认 >= v22.0.0 ``` 2. **PeekabooWin** installed: ```powershell git clone https://github.com/FelixKruger/PeekabooWin cd PeekabooWin npm install npm test ``` 3. **Set environment variable** (告诉脚本 PeekabooWin 在哪里): ```powershell # 临时设置（当前 PowerShell 窗口有效） $env:PEEKABOO_WIN_DIR = "C:\Users\<你的用户名>\PeekabooWin" # 永久设置（推荐） [System.Environment]::SetEnvironmentVariable("PEEKABOO_WIN_DIR", "C:\Users\<你的用户名>\PeekabooWin", "User") ``` 4. **WeChat** (微信) running and **visible on screen** (不能最小化) 5. **Windows permissions**: - 部分操作可能需要以管理员身份运行 PowerShell - 确保微信窗口未被"专注助手"屏蔽 ### Python - **Python 3.7+** (macOS 和 Windows 均需要) - 脚本仅使用标准库，无需额外 pip 安装 --- ## Quick Start ### Step 0: Platform Detection & Prerequisite Check When the user invokes this skill for the first time, **always** run the prerequisite check first. Do NOT start monitoring until all prerequisites are confirmed. **Run these checks using Bash tool:** ```bash # 1. Detect platform echo "PLATFORM: $(uname -s 2>/dev/null || echo Windows)" # 2. Check Python python3 --version 2>/dev/null || python --version 2>/dev/null ``` #### If macOS (`Darwin`): ```bash # Check Peekaboo CLI which peekaboo && peekaboo version # Check permissions peekaboo permissions ``` **If Peekaboo NOT found**, show this message to the user: > **Peekaboo CLI 未安装，请先执行以下命令：** > ```bash > brew install steipete/peekaboo/peekaboo > ``` > 安装后还需要授予权限： > 1. 打开 **系统设置 → 隐私与安全 → 屏幕录制** → 勾选 Peekaboo > 2. 打开 **系统设置 → 隐私与安全 → 辅助功能** → 勾选 Peekaboo > > 安装完成后对我说"监控 XX 的微信"即可。 **If permissions NOT granted**, show: > **权限未完全授予，请打开以下设置：** > 1. 系统设置 → 隐私与安全 → 屏幕录制 → 勾选 Peekaboo > 2. 系统设置 → 隐私与安全 → 辅助功能 → 勾选 Peekaboo > > 授权后重新运行 `peekaboo permissions` 确认。 #### If Windows: ```powershell # Check Node.js version (must be >= 22) node --version # Check PEEKABOO_WIN_DIR environment variable echo $env:PEEKABOO_WIN_DIR # Check PeekabooWin exists if (Test-Path "$env:PEEKABOO_WIN_DIR\bin\peekaboo-win.js") { echo "PeekabooWin: FOUND" } else { echo "PeekabooWin: NOT FOUND" } # Verify PeekabooWin works node "$env:PEEKABOO_WIN_DIR\bin\peekaboo-win.js" --help 2>$null ``` **If Node.js NOT found or version < 22**, show this message: > **Node.js 未安装或版本过低，请按以下步骤操作：** > > **第 1 步：安装 Node.js 22+** > 1. 打开 https://nodejs.org > 2. 下载 **22.x.x LTS** 版本（不要下载 20.x 或更低） > 3. 运行安装程序，一路点击"Next"完成安装 > 4. 安装完成后，**重新打开 PowerShell**，运行 `node --version` 确认版本 >= v22.0.0 > > 安装完成后对我说"监控 XX 的微信"即可。 **If Node.js OK but PeekabooWin NOT found**, show this message: > **PeekabooWin 未安装，请按以下步骤操作：** > > **第 2 步：安装 PeekabooWin** > 1. 打开 PowerShell，运行： > ```powershell > cd C:\ > git clone https://github.com/FelixKruger/PeekabooWin > cd PeekabooWin > npm install > npm test > ``` > 2. 等待 `npm test` 全部通过（表示安装成功） > > **第 3 步：设置环境变量** > ```powershell > [System.Environment]::SetEnvironmentVariable("PEEKABOO_WIN_DIR", "C:\PeekabooWin", "User") > ``` > 设置后必须**重新打开 PowerShell** 才能生效。 > > 全部完成后对我说"监控 XX 的微信"即可。 **If PeekabooWin found but `node --help` fails**, show: > **PeekabooWin 已安装但运行异常，请检查：** > 1. Node.js 版本是否 >= 22：`node --version` > 2. 在 PeekabooWin 目录重新安装依赖：`cd C:\PeekabooWin && npm install` > 3. 确认没有安全软件拦截 #### All Prerequisites Met Once all checks pass, proceed to Step 1 below. --- ### Step 1: Ask User for Contact & Style 1. Ask user: "Which contact to monitor?" (required - no default) 2. Ask user: "Reply style/tone?" (default: friendly, match user personality) 3. Take screenshot using the appropriate engine 4. Read screenshot to identify current chat state 5. Start monitor script with --contact parameter (background) 6. Set up automation for auto-reply polling **Example**: User says "监控 mini 的微信" ### macOS: - Contact = "mini" - Start monitor: `python3 scripts/wechat_monitor.py --contact mini --interval 600` - Screenshot: `peekaboo image --mode window --app 微信 --retina --path /tmp/wechat_mon/latest.png` ### Windows: - Contact = "mini" - Start monitor: `python scripts/wechat_monitor.py --contact mini --interval 600` - Screenshot: `node <PEEKABOO_WIN_DIR>/bin/peekaboo-win.js screen capture --output <TEMP>\wechat_mon\latest.png` --- ## Core Workflow ### Step 1: Check Contact & Current State **macOS:** ```bash peekaboo list apps --json | grep 微信 peekaboo image --mode window --app 微信 --retina --path /tmp/wechat_mon/latest.png ``` **Windows:** ```powershell node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js app list node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js screen capture --output %TEMP%\wechat_mon\latest.png ``` Read the screenshot to: - Identify the current chat contact - Check for unread messages (red badge on avatar) - Note existing messages in the conversation ### Step 2: Reply to a Message #### macOS (Peekaboo CLI) ```bash # 1. Switch to WeChat peekaboo app switch --to 微信 # 2. Click input box (coords may vary by window position) peekaboo click --coords 900,780 --app 微信 # 3. Type the message peekaboo type "你的回复内容" --app 微信 # 4. Send using type --return (NOT press --key return) peekaboo type "" --app 微信 --return ``` > **IMPORTANT**: `peekaboo press --key return` does NOT reliably trigger WeChat send. > Always use `peekaboo type "" --app 微信 --return` to send. #### Windows (PeekabooWin) ```powershell # 1. Switch to WeChat node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js app switch --name "微信" # 2. Click input box (use label or coordinates) node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js click --on "100,200" # 或者用 label 点击: # node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js click --on "消息输入框" --snapshot latest # 3. Type the message node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js type --text "你的回复内容" # 4. Send using press Enter node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js press --keys "Enter" ``` > **Windows 注意**: PeekabooWin 支持 `--on "label"` 模式通过标签点击 UI 元素，比坐标点击更可靠。 > 建议先用 `peekaboo-win see --mode window --title "微信"` 确认可点击的元素标签。 ### Step 3: Verify Send **macOS:** ```bash peekaboo image --mode window --app 微信 --retina --path /tmp/wechat_mon/verify.png ``` **Windows:** ```powershell node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js screen capture --output %TEMP%\wechat_mon\verify.png ``` Read the verify screenshot to confirm the message appears as a green bubble. ### Step 4: Start Background Monitoring **macOS:** ```bash nohup python3 scripts/wechat_monitor.py \ --contact "联系人名称" \ --interval 600 \ --threshold 1000 \ > /tmp/wechat_mon/monitor.log 2>&1 & ``` **Windows (PowerShell):** ```powershell Start-Process -NoNewWindow python -ArgumentList "scripts/wechat_monitor.py --contact `"联系人名称`" --interval 600 --threshold 1000" -RedirectStandardOutput "$env:TEMP\wechat_mon\monitor.log" -RedirectStandardError "$env:TEMP\wechat_mon\monitor_err.log" ``` **Important**: - Contact name must match exactly as it appears in WeChat - Can run multiple monitors for different contacts (use different --workdir and --pending) - `--engine auto` (default) will auto-detect macOS vs Windows ### Step 5: Set Up Auto-Reply Automation Create a recurring automation (every 30s) that: **macOS Automation Prompt Template:** ``` 检查 /tmp/wechat_pending.txt 是否存在。 IF EXISTS: 1. 读取 pending 文件获取 CONTACT 和 DETECTED 时间 2. 如果距离 DETECTED 时间 < 10分钟: 结束（继续等待） 3. 如果 >= 10分钟: 重新截图，分析是否已回复 - 已回复(绿色气泡): 删除 pending，不回复 - 未回复(白色气泡): 生成回复并发送 发送命令: peekaboo app switch --to 微信 peekaboo click --coords 900,780 --app 微信 peekaboo type "[回复]" --app 微信 peekaboo type "" --app 微信 --return IF NOT EXISTS: 什么都不做 ``` **Windows Automation Prompt Template:** ``` 检查 %TEMP%\wechat_pending.txt 是否存在。 IF EXISTS: 1. 读取 pending 文件获取 CONTACT 和 DETECTED 时间 2. 如果距离 DETECTED 时间 < 10分钟: 结束（继续等待） 3. 如果 >= 10分钟: 重新截图，分析是否已回复 - 已回复(绿色气泡): 删除 pending，不回复 - 未回复(白色气泡): 生成回复并发送 发送命令(替换 <PEEKABOO_WIN_DIR>): node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js app switch --name "微信" node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js type --text "[回复]" node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js press --keys "Enter" IF NOT EXISTS: 什么都不做 ``` Use `automation_update` tool with: - `scheduleType: recurring` - `rrule: RRULE:FREQ=SECONDLY;INTERVAL=30` - `prompt`: (the template above, filled with actual contact) --- ## Sending Rules 1. **Only reply to the target contact** — never reply to other people's messages 2. **Match user personality** — use the user's real voice, not robotic language 3. **Reference current activity truthfully** — what is the user actually doing right now? 4. **Be warm but natural** — no excessive emojis, no corporate tone --- ## Input Box Coordinates / Labels ### macOS The input box coordinates depend on WeChat window position. Default: `900,780` ```bash peekaboo see --app 微信 --annotate --path /tmp/wechat_coords.png ``` ### Windows PeekabooWin supports label-based clicking (recommended) or coordinate clicking: ```powershell # 推荐: 先查看微信窗口有哪些可点击元素 node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js see --mode window --title "微信" # 然后用 label 点击 node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js click --on "消息" --title "微信" # 或用坐标点击 node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js mouse click --x 900 --y 780 ``` --- ## Platform Differences Summary | Feature | macOS (Peekaboo) | Windows (PeekabooWin) | |---------|-----------------|----------------------| | Install | `brew install steipete/peekaboo/peekaboo` | `git clone` + `npm install` | | Screenshot | `peekaboo image --mode window --app 微信` | `peekaboo-win screen capture` | | Click | `peekaboo click --coords X,Y --app 微信` | `peekaboo-win click --on "label"` or `mouse click --x --y` | | Type | `peekaboo type "text" --app 微信` | `peekaboo-win type --text "text"` | | Send | `peekaboo type "" --app 微信 --return` | `peekaboo-win press --keys "Enter"` | | App switch | `peekaboo app switch --to 微信` | `peekaboo-win app switch --name "微信"` | | Temp dir | `/tmp/wechat_mon/` | `%TEMP%\wechat_mon\` | | Pending file | `/tmp/wechat_pending.txt` | `%TEMP%\wechat_pending.txt` | --- ## Troubleshooting | Problem | macOS Fix | Windows Fix | |---------|-----------|-------------| | 截图失败 | 检查权限: `peekaboo permissions` | 检查 Node.js 版本 >= 22 | | 消息未发送 | 用 `type "" --return` | 用 `press --keys "Enter"` | | 检测不到变化 | 降低 `--threshold` 到 800 | 降低 `--threshold` 到 800 | | PeekabooWin 找不到 | - | 设置 `PEEKABOO_WIN_DIR` 环境变量 | | 微信窗口不可见 | `peekaboo app unhide --app 微信` | 确保 WeChat 未最小化 | | 自动化不触发 | 检查 automation 是否 ACTIVE | 检查 automation 是否 ACTIVE | --- ## Stopping **macOS:** ```bash kill $(pgrep -f wechat_monitor.py) automation_update --mode delete --id <automation-id> rm -rf /tmp/wechat_mon /tmp/wechat_pending.txt ``` **Windows (PowerShell):** ```powershell Stop-Process -Name python -Force -ErrorAction SilentlyContinue # 删除 automation (在 WorkBuddy 中操作) Remove-Item -Recurse -Force "$env:TEMP\wechat_mon" Remove-Item -Force "$env:TEMP\wechat_pending.txt" ```

path: README_v4.md
content: # WeChat Auto Reply Skill v5 - 跨平台版（macOS + Windows）

## v5 新功能

### 跨平台支持

- **macOS**: 使用 Peekaboo CLI (`brew install steipete/peekaboo/peekaboo`)
- **Windows**: 使用 PeekabooWin (Node.js 22+)
- 脚本自动检测平台，无需手动指定引擎

### v4 保留功能

- 智能等待10分钟
- 已回复检测（绿色/白色气泡判断）
- 每10分钟扫描，节省资源

---

## 工作原理

```
1. 监控脚本每10分钟扫描一次微信窗口（自动选择平台引擎）
   macOS: Peekaboo CLI 截图
   Windows: PeekabooWin 截图
   ↓
2. 检测到新消息 → 写入 pending 文件（包含检测时间戳）
   macOS: /tmp/wechat_pending.txt
   Windows: %TEMP%\wechat_pending.txt
   ↓
3. 自动化任务每30秒检查一次 pending 文件
   ↓
4. 发现 pending 文件 → 检查是否超过10分钟
   ↓
5. 如果没超过10分钟 → 等待，不做任何操作
   ↓
6. 如果超过10分钟 → 重新截图，分析是否已回复
   ↓
7. 如果已回复（绿色气泡）→ 删除 pending，不回复
   ↓
8. 如果未回复（白色气泡）→ 生成回复并发送
```

---

## 文件结构

```
wechat-auto-reply/
├── SKILL.md           # Skill 定义 + 技术文档（AI Agent 参考）
├── USAGE.md          # 用户使用说明
├── README_v4.md      # 版本说明（本文件）
├── scripts/
│   └── wechat_monitor.py  # v5 跨平台监控脚本
└── references/
    └── peekaboo-guide.md  # Peekaboo (macOS) + PeekabooWin (Windows) 使用指南
```

---

## 前置条件

### macOS

| 要求 | 安装命令 |
|------|----------|
| Peekaboo CLI | `brew install steipete/peekaboo/peekaboo` |
| 权限 | 屏幕录制 + 辅助功能 |
| Python | 3.7+ (系统自带) |

### Windows

| 要求 | 安装步骤 |
|------|----------|
| Node.js 22+ | https://nodejs.org 下载安装 |
| PeekabooWin | `git clone https://github.com/FelixKruger/PeekabooWin && npm install` |
| 环境变量 | 设置 `PEEKABOO_WIN_DIR` 指向安装目录 |
| Python | 3.7+ (python.org 下载) |

详细安装步骤见 `references/peekaboo-guide.md`

---

## 配置参数

### wechat_monitor.py 参数

| 参数 | 默认值 | 说明 |
|------|--------|------|
| `--contact` | "mini" | 监控的联系人名称 |
| `--interval` | 600 | 扫描间隔（秒），默认10分钟 |
| `--threshold` | 1000 | 截图变化阈值（字节） |
| `--wait` | 600 | 等待主人回复的时间（秒） |
| `--workdir` | 自动 | 工作目录（macOS: /tmp/wechat_mon, Windows: %TEMP%\wechat_mon） |
| `--pending` | 自动 | pending 文件路径 |
| `--engine` | auto | 自动化引擎: auto / peekaboo / peekaboo-win |
| `--peekaboo-win-dir` | PEEKABOO_WIN_DIR 环境变量 | PeekabooWin 安装目录 |

### 示例

```bash
# macOS: 默认配置
python3 scripts/wechat_monitor.py --contact mini

# Windows: 默认配置
python scripts/wechat_monitor.py --contact mini

# 指定引擎
python3 scripts/wechat_monitor.py --contact mini --engine peekaboo       # 强制 macOS
python scripts/wechat_monitor.py --contact mini --engine peekaboo-win   # 强制 Windows

# 自定义 PeekabooWin 路径
python scripts/wechat_monitor.py --contact mini --peekaboo-win-dir "D:\Tools\PeekabooWin"
```

---

## Pending 文件格式

```
DETECTED:2026-05-15T02:30:00
SCREENSHOT:/tmp/wechat_mon/latest.png
CONTACT:mini
```

| 字段 | 说明 |
|------|------|
| `DETECTED:` | 检测到新消息的时间戳 |
| `SCREENSHOT:` | 检测到变化时的截图路径 |
| `CONTACT:` | 监控的联系人名称 |

---

## 平台差异速查

| 功能 | macOS | Windows |
|------|-------|---------|
| 截图命令 | `peekaboo image --mode window --app 微信` | `peekaboo-win screen capture --output FILE` |
| 切换应用 | `peekaboo app switch --to 微信` | `peekaboo-win app switch --name "微信"` |
| 点击输入框 | `peekaboo click --coords X,Y --app 微信` | `peekaboo-win click --on "label"` 或 `mouse click --x --y` |
| 输入文字 | `peekaboo type "text" --app 微信` | `peekaboo-win type --text "text"` |
| 发送消息 | `peekaboo type "" --app 微信 --return` | `peekaboo-win press --keys "Enter"` |
| 临时目录 | `/tmp/wechat_mon/` | `%TEMP%\wechat_mon\` |
| Pending 文件 | `/tmp/wechat_pending.txt` | `%TEMP%\wechat_pending.txt` |
| 停止监控 | `kill $(pgrep -f wechat_monitor.py)` | `Stop-Process -Name python -Force` |
| 微信最小化 | 可以（Peekaboo 可取消隐藏） | 不可以（PeekabooWin 截屏幕） |

---

## 版本历史

| 版本 | 日期 | 主要变化 |
|------|------|----------|
| v1 | 2026-05-14 | 初始版本 (macOS only) |
| v2 | 2026-05-14 | 支持任意联系人 |
| v3 | 2026-05-14 | 修复发送逻辑 |
| v4 | 2026-05-15 | 智能等待10分钟 + 已回复检测 |
| **v5** | **2026-05-15** | **跨平台支持 (macOS + Windows)** |

---

**最后更新**：2026-05-15
**版本**：v5（跨平台版）


path: USAGE.md
content: # 微信自动回复 Skill v5 使用说明（跨平台版）

## v5 新功能

### 跨平台支持

- 同时支持 **macOS** 和 **Windows**
- macOS 使用 Peekaboo CLI，Windows 使用 PeekabooWin (Node.js)
- 脚本自动检测平台，无需手动配置

### v4 保留功能

- **智能等待（10分钟）**：检测到新消息后等待，给你时间手动回复
- **已回复检测**：分析截图判断是否已回复，避免重复回复
- **低频扫描**：每10分钟扫描一次，节省资源

---

## 前置条件

> **第一次使用时，WorkBuddy 会自动帮你检查以下条件。如果未满足，会显示安装指引，你按步骤操作后重新说"监控 XX 的微信"即可。**

### macOS 用户

| 要求 | 说明 |
|------|------|
| Peekaboo CLI | `brew install steipete/peekaboo/peekaboo` |
| 权限 | 屏幕录制 + 辅助功能 |
| Python | 3.7+ |

### Windows 用户（3 件事必须提前安装）

| 步骤 | 要求 | 说明 |
|------|------|------|
| **第 1 步** | Node.js 22+ | 从 https://nodejs.org 下载安装，务必选 **22.x LTS** 版本 |
| **第 2 步** | PeekabooWin | 打开 PowerShell 运行：`git clone https://github.com/FelixKruger/PeekabooWin` → `cd PeekabooWin` → `npm install` → `npm test` |
| **第 3 步** | 环境变量 | 运行：`[System.Environment]::SetEnvironmentVariable("PEEKABOO_WIN_DIR", "C:\PeekabooWin", "User")` 然后重新打开 PowerShell |

此外还需要：
- Python 3.7+（从 https://python.org 下载，安装时勾选"Add to PATH"）
- 微信窗口必须保持可见（不能最小化到任务栏）

> Windows 安装详细步骤请参考 `references/peekaboo-guide.md`

### 自动检查机制

当你第一次说 **"监控 XX 的微信"** 时，WorkBuddy 会自动：

1. **检测你的操作系统**（macOS / Windows）
2. **逐项检查依赖**（Node.js 版本、Peekaboo/PeekabooWin 是否安装、环境变量是否设置）
3. **如果全部通过** → 直接开始监控
4. **如果有未满足项** → 显示对应的安装指引（告诉你缺什么、怎么装），等你安装完再重新调用即可

---

## 快速开始

### macOS

```bash
# 1. 安装 Peekaboo
brew install steipete/peekaboo/peekaboo

# 2. 授予权限
# 系统设置 → 隐私与安全 → 屏幕录制 / 辅助功能

# 3. 启动监控（WorkBuddy 会自动检查条件）
# 在 WorkBuddy 中说：监控 mini 的微信
```

### Windows

> **你不需要手动检查，WorkBuddy 会自动检测。** 但如果你想提前安装好，按以下步骤操作：

```powershell
# 1. 安装 Node.js 22+
# 从 https://nodejs.org 下载安装（务必选 22.x LTS 版本）

# 2. 安装 PeekabooWin
git clone https://github.com/FelixKruger/PeekabooWin
cd PeekabooWin
npm install
npm test

# 3. 设置环境变量（永久生效）
[System.Environment]::SetEnvironmentVariable("PEEKABOO_WIN_DIR", "C:\PeekabooWin", "User")
# 重要：设置后必须重新打开 PowerShell 才能生效！

# 4. 安装 Python 3.7+
# 从 https://python.org 下载，安装时勾选 "Add to PATH"

# 5. 启动监控（WorkBuddy 会自动检查条件）
# 在 WorkBuddy 中说：监控 mini 的微信

# 4. 重新打开 PowerShell

# 5. 启动监控
# 在 WorkBuddy 中说：监控 mini 的微信
```

---

## 如何调用这个 Skill

只需要对我说：

```
监控 mini 的微信
```

或者更详细的需求：

```
监控 老板 的微信，回复风格要正式一点
监控 张三 的微信，他是我的好朋友，回复随意一点
监控 mini 的微信，等待时间设为 15 分钟
```

---

## 调用后会发生什么？

当你说 **"监控 [联系人] 的微信"** 后，我会：

### 1. 询问回复风格（可选）

```
你想要什么样的回复风格？
- 匹配你的说话风格（默认）
- 正式一点（适合工作联系人）
- 随意轻松（适合好友）
```

### 2. 检测平台并验证依赖

自动检测 macOS/Windows，确认对应引擎（Peekaboo/PeekabooWin）已安装并可用。

### 3. 启动后台监控

启动 Python 监控脚本（自动选择对应平台的截图引擎）：
- **每10分钟截图一次**微信窗口
- 检测截图文件大小变化
- 检测到变化后，写入"待回复"信号文件

**macOS 命令**：
```bash
python3 scripts/wechat_monitor.py --contact mini --interval 600 --wait 600
```

**Windows 命令**：
```powershell
python scripts/wechat_monitor.py --contact mini --interval 600 --wait 600
```

### 4. 创建自动回复任务

创建 WorkBuddy 自动化任务（每30秒检查一次），逻辑：

- 如果有待回复消息 → 检查是否超过10分钟
  - **没超过** → 等待
  - **已超过** → 截图分析是否已回复
    - **已回复**（绿色气泡）→ 不发送
    - **未回复**（白色气泡）→ 生成回复并发送

---

## 回复在多久内完成？

| 阶段 | 时间 | 说明 |
|------|------|------|
| **检测新消息** | 10分钟内 | 监控脚本每10分钟截图一次 |
| **等待你回复** | 10分钟 | 给你时间手动回复 |
| **AI 分析消息** | 5-15 秒 | 取决于消息复杂度和网络 |
| **发送回复** | 5-10 秒 | 使用 Peekaboo/PeekabooWin 模拟输入 |
| **总计** | **10-15 分钟** | 从收到消息到自动回复完成 |

**重点**：如果你在10分钟内回复了，AI **不会**再自动回复！

---

## 如何调整回复内容？

### 在启动时使用关键词

| 你说的话 | 效果 |
|----------|------|
| `监控 mini 的微信` | 默认风格，匹配你的说话方式 |
| `监控 老板 的微信，正式一点` | 回复更正式、有礼貌 |
| `监控 张三 的微信，随意一点` | 回复更轻松、口语化 |
| `监控 李四 的微信，简短回复` | 回复更简洁 |

### 调整等待时间

```
监控 mini 的微信，等待时间设为 15 分钟  # 延长等待
监控 mini 的微信，等待时间设为 5 分钟   # 缩短等待
```

### 修改已运行的自动回复

```
修改微信自动回复的 prompt，让回复更简短
```

---

## 积分消耗详情

| 项目 | v3（旧版） | v5（新版） | 节省 |
|------|-------------|-------------|--------|
| **扫描频率** | 每15秒 | 每10分钟 | **40倍** |
| **检测后立即回复** | 是 | 否（等待10分钟） | **可能100%** |
| **如果你已回复** | 仍会回复 | 不回复 | **节省1次** |

### 每次回复消耗的 Token

| 步骤 | Token 消耗 |
|------|-------------|
| 截图分析 | ~1000-2000 tokens |
| 消息理解 | ~500-1000 tokens |
| 生成回复 | ~100-300 tokens |
| **总计** | **~1600-3300 tokens/次** |

### 成本估算

| 模型 | 单次回复成本 |
|------|-------------|
| GPT-4o 级别 | 约 ¥0.1 |
| GPT-3.5 级别 | 约 ¥0.007 |

---

## 注意事项

### 通用

1. **微信窗口必须保持可见**（两个平台都是）
2. **联系人名称必须准确**：和微信中显示的名称完全一致
3. **回复不是即时的**：有 10-15 分钟延迟
4. **只会回复指定联系人**：安全可控
5. **已回复检测准确率约 90-95%**

### macOS 专属

- **权限**：屏幕录制 + 辅助功能（`peekaboo permissions` 检查）
- **微信可以最小化到 Dock**：Peekaboo 可以取消隐藏

### Windows 专属

- **微信不能最小化到任务栏**：PeekabooWin 截取屏幕内容，最小化后看不到
- **Node.js 必须 22+**：低于 22 会报错
- **必须设置 PEEKABOO_WIN_DIR 环境变量**：否则脚本找不到 PeekabooWin
- **管理员权限**：部分操作可能需要
- **pyautogui failsafe**：鼠标移到屏幕左上角会紧急停止

---

## 如何停止自动回复？

### 通用方法

```
停止微信监控
```

### macOS 额外操作

```bash
kill $(pgrep -f wechat_monitor.py)
rm -rf /tmp/wechat_mon /tmp/wechat_pending.txt
```

### Windows 额外操作

```powershell
Stop-Process -Name python -Force -ErrorAction SilentlyContinue
Remove-Item -Recurse -Force "$env:TEMP\wechat_mon"
Remove-Item -Force "$env:TEMP\wechat_pending.txt"
```

---

## 常见问题

### Q1: 为什么没有自动回复？

**检查清单**：
1. 监控脚本是否运行？
2. 自动化任务是否启用？
3. Pending 文件是否存在？
4. 你是否已在10分钟内回复？（如果已回复，不会自动回复）
5. 微信窗口是否可见？

### Q2: Windows 上截图失败？

- 检查 Node.js 版本: `node --version` (需要 >= 22)
- 检查 PEEKABOO_WIN_DIR 是否正确设置
- 确保微信窗口未被最小化
- 尝试以管理员身份运行 PowerShell

### Q3: macOS 上权限问题？

```bash
peekaboo permissions
# 系统设置 → 隐私与安全 → 屏幕录制 / 辅助功能
```

### Q4: 回复内容不合适？

```
让回复更简短/更详细/更正式/更随意
```

### Q5: 已回复检测不准确？

- 调整等待时间：`等待时间设为 15 分钟`
- 或说"停用已回复检测"

---

## 工作原理

```
微信收到新消息
    ↓
10分钟后截图检测变化（文件大小比较）
    ↓
写入 pending 文件（包含检测时间戳）
  macOS: /tmp/wechat_pending.txt
  Windows: %TEMP%\wechat_pending.txt
    ↓
WorkBuddy 自动化每 30 秒检查
    ↓
发现 pending 文件 → 检查是否超过10分钟
    ↓
没超过 → 等待，不做任何操作
    ↓
已超过 → 重新截图，分析是否已回复
    ↓
已回复（绿色气泡）→ 删除 pending，不回复
    ↓
未回复（白色气泡）→ 生成回复并发送
    ↓
删除 pending 文件
```

---

## 版本历史

| 版本 | 日期 | 主要变化 |
|------|------|----------|
| v1 | 2026-05-14 | 初始版本 (macOS only) |
| v2 | 2026-05-14 | 支持任意联系人 |
| v3 | 2026-05-14 | 修复发送逻辑 |
| v4 | 2026-05-15 | 智能等待10分钟 + 已回复检测 |
| **v5** | **2026-05-15** | **跨平台支持 (macOS + Windows)** |

---

**最后更新**：2026-05-15
**版本**：v5（跨平台版）


path: 微信自动回复使用说明_v5.txt
content: 微信自动回复 Skill v5 使用说明（跨平台版）
v5 新功能
跨平台支持
同时支持 macOS 和 Windows
macOS 使用 Peekaboo CLI，Windows 使用 PeekabooWin (Node.js)
脚本自动检测平台，无需手动配置
v4 保留功能
智能等待（10分钟）：检测到新消息后等待，给你时间手动回复
已回复检测：分析截图判断是否已回复，避免重复回复
低频扫描：每10分钟扫描一次，节省资源

前置条件
第一次使用时，WorkBuddy 会自动帮你检查以下条件。如果未满足，会显示安装指引，你按步骤操作后重新说”监控 XX 的微信”即可。
macOS 用户
要求	说明
Peekaboo CLI	brew install steipete/peekaboo/peekaboo
权限	屏幕录制 + 辅助功能
Python	3.7+
Windows 用户（3 件事必须提前安装）
步骤	要求	说明
第 1 步	Node.js 22+	从 https://nodejs.org 下载安装，务必选 22.x LTS 版本
第 2 步	PeekabooWin	打开 PowerShell 运行：git clone https://github.com/FelixKruger/PeekabooWin → cd PeekabooWin → npm install → npm test
第 3 步	环境变量	运行：[System.Environment]::SetEnvironmentVariable("PEEKABOO_WIN_DIR", "C:\PeekabooWin", "User") 然后重新打开 PowerShell
此外还需要： - Python 3.7+（从 https://python.org 下载，安装时勾选”Add to PATH”） - 微信窗口必须保持可见（不能最小化到任务栏）
Windows 安装详细步骤请参考 references/peekaboo-guide.md
自动检查机制
当你第一次说 “监控 XX 的微信” 时，WorkBuddy 会自动：
1.检测你的操作系统（macOS / Windows）
2.逐项检查依赖（Node.js 版本、Peekaboo/PeekabooWin 是否安装、环境变量是否设置）
3.如果全部通过 → 直接开始监控
4.如果有未满足项 → 显示对应的安装指引（告诉你缺什么、怎么装），等你安装完再重新调用即可

快速开始
macOS
# 1. 安装 Peekaboo
brew install steipete/peekaboo/peekaboo

# 2. 授予权限
# 系统设置 → 隐私与安全 → 屏幕录制 / 辅助功能

# 3. 启动监控（WorkBuddy 会自动检查条件）
# 在 WorkBuddy 中说：监控 mini 的微信
Windows
你不需要手动检查，WorkBuddy 会自动检测。 但如果你想提前安装好，按以下步骤操作：
# 1. 安装 Node.js 22+
# 从 https://nodejs.org 下载安装（务必选 22.x LTS 版本）

# 2. 安装 PeekabooWin
git clone https://github.com/FelixKruger/PeekabooWin
cd PeekabooWin
npm install
npm test

# 3. 设置环境变量（永久生效）
[System.Environment]::SetEnvironmentVariable("PEEKABOO_WIN_DIR", "C:\PeekabooWin", "User")
# 重要：设置后必须重新打开 PowerShell 才能生效！

# 4. 安装 Python 3.7+
# 从 https://python.org 下载，安装时勾选 "Add to PATH"

# 5. 启动监控（WorkBuddy 会自动检查条件）
# 在 WorkBuddy 中说：监控 mini 的微信

# 4. 重新打开 PowerShell

# 5. 启动监控
# 在 WorkBuddy 中说：监控 mini 的微信

如何调用这个 Skill
只需要对我说：
监控 mini 的微信
或者更详细的需求：
监控 老板 的微信，回复风格要正式一点
监控 张三 的微信，他是我的好朋友，回复随意一点
监控 mini 的微信，等待时间设为 15 分钟

调用后会发生什么？
当你说 “监控 [联系人] 的微信” 后，我会：
1. 询问回复风格（可选）
你想要什么样的回复风格？
- 匹配你的说话风格（默认）
- 正式一点（适合工作联系人）
- 随意轻松（适合好友）
2. 检测平台并验证依赖
自动检测 macOS/Windows，确认对应引擎（Peekaboo/PeekabooWin）已安装并可用。
3. 启动后台监控
启动 Python 监控脚本（自动选择对应平台的截图引擎）： - 每10分钟截图一次微信窗口 - 检测截图文件大小变化 - 检测到变化后，写入”待回复”信号文件
macOS 命令：
python3 scripts/wechat_monitor.py --contact mini --interval 600 --wait 600
Windows 命令：
python scripts/wechat_monitor.py --contact mini --interval 600 --wait 600
4. 创建自动回复任务
创建 WorkBuddy 自动化任务（每30秒检查一次），逻辑：
如果有待回复消息 → 检查是否超过10分钟
o没超过 → 等待
o已超过 → 截图分析是否已回复
已回复（绿色气泡）→ 不发送
未回复（白色气泡）→ 生成回复并发送

回复在多久内完成？
阶段	时间	说明
检测新消息	10分钟内	监控脚本每10分钟截图一次
等待你回复	10分钟	给你时间手动回复
AI 分析消息	5-15 秒	取决于消息复杂度和网络
发送回复	5-10 秒	使用 Peekaboo/PeekabooWin 模拟输入
总计	10-15 分钟	从收到消息到自动回复完成
重点：如果你在10分钟内回复了，AI 不会再自动回复！

如何调整回复内容？
在启动时使用关键词
你说的话	效果
监控 mini 的微信	默认风格，匹配你的说话方式
监控 老板 的微信，正式一点	回复更正式、有礼貌
监控 张三 的微信，随意一点	回复更轻松、口语化
监控 李四 的微信，简短回复	回复更简洁
调整等待时间
监控 mini 的微信，等待时间设为 15 分钟  # 延长等待
监控 mini 的微信，等待时间设为 5 分钟   # 缩短等待
修改已运行的自动回复
修改微信自动回复的 prompt，让回复更简短

积分消耗详情
项目	v3（旧版）	v5（新版）	节省
扫描频率	每15秒	每10分钟	40倍
检测后立即回复	是	否（等待10分钟）	可能100%
如果你已回复	仍会回复	不回复	节省1次
每次回复消耗的 Token
步骤	Token 消耗
截图分析	~1000-2000 tokens
消息理解	~500-1000 tokens
生成回复	~100-300 tokens
总计	~1600-3300 tokens/次
成本估算
模型	单次回复成本
GPT-4o 级别	约 ¥0.1
GPT-3.5 级别	约 ¥0.007

注意事项
通用
1.微信窗口必须保持可见（两个平台都是）
2.联系人名称必须准确：和微信中显示的名称完全一致
3.回复不是即时的：有 10-15 分钟延迟
4.只会回复指定联系人：安全可控
5.已回复检测准确率约 90-95%
macOS 专属
权限：屏幕录制 + 辅助功能（peekaboo permissions 检查）
微信可以最小化到 Dock：Peekaboo 可以取消隐藏
Windows 专属
微信不能最小化到任务栏：PeekabooWin 截取屏幕内容，最小化后看不到
Node.js 必须 22+：低于 22 会报错
必须设置 PEEKABOO_WIN_DIR 环境变量：否则脚本找不到 PeekabooWin
管理员权限：部分操作可能需要
pyautogui failsafe：鼠标移到屏幕左上角会紧急停止

如何停止自动回复？
通用方法
停止微信监控
macOS 额外操作
kill $(pgrep -f wechat_monitor.py)
rm -rf /tmp/wechat_mon /tmp/wechat_pending.txt
Windows 额外操作
Stop-Process -Name python -Force -ErrorAction SilentlyContinue
Remove-Item -Recurse -Force "$env:TEMP\wechat_mon"
Remove-Item -Force "$env:TEMP\wechat_pending.txt"

常见问题
Q1: 为什么没有自动回复？
检查清单： 1. 监控脚本是否运行？ 2. 自动化任务是否启用？ 3. Pending 文件是否存在？ 4. 你是否已在10分钟内回复？（如果已回复，不会自动回复） 5. 微信窗口是否可见？
Q2: Windows 上截图失败？
检查 Node.js 版本: node --version (需要 >= 22)
检查 PEEKABOO_WIN_DIR 是否正确设置
确保微信窗口未被最小化
尝试以管理员身份运行 PowerShell
Q3: macOS 上权限问题？
peekaboo permissions
# 系统设置 → 隐私与安全 → 屏幕录制 / 辅助功能
Q4: 回复内容不合适？
让回复更简短/更详细/更正式/更随意
Q5: 已回复检测不准确？
调整等待时间：等待时间设为 15 分钟
或说”停用已回复检测”

工作原理
微信收到新消息
    ↓
10分钟后截图检测变化（文件大小比较）
    ↓
写入 pending 文件（包含检测时间戳）
  macOS: /tmp/wechat_pending.txt
  Windows: %TEMP%\wechat_pending.txt
    ↓
WorkBuddy 自动化每 30 秒检查
    ↓
发现 pending 文件 → 检查是否超过10分钟
    ↓
没超过 → 等待，不做任何操作
    ↓
已超过 → 重新截图，分析是否已回复
    ↓
已回复（绿色气泡）→ 删除 pending，不回复
    ↓
未回复（白色气泡）→ 生成回复并发送
    ↓
删除 pending 文件

版本历史
版本	日期	主要变化
v1	2026-05-14	初始版本 (macOS only)
v2	2026-05-14	支持任意联系人
v3	2026-05-14	修复发送逻辑
v4	2026-05-15	智能等待10分钟 + 已回复检测
v5	2026-05-15	跨平台支持 (macOS + Windows)

最后更新：2026-05-15 版本：v5（跨平台版）

path: LICENSE.txt
content: MIT License

Copyright (c) 2026 WeChat Auto Reply Skill

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.


path: scripts/wechat_monitor.py
content: #!/usr/bin/env python3
"""
WeChat Monitor Script v5 (Cross-Platform: Windows + macOS)
监控微信窗口变化，检测新消息并写入 pending 文件。

Windows: 使用 PeekabooWin (Node.js) 进行窗口截图
macOS:  使用 Peekaboo CLI (brew install) 进行窗口截图

Usage:
    python3 wechat_monitor.py [options]

Options:
    --contact NAME    监控的联系人名称（默认: mini）
    --interval SEC    截图间隔秒数（默认: 600=10分钟）
    --threshold BYTES 文件大小变化阈值（默认: 1000）
    --workdir PATH    工作目录（默认: 系统临时目录/wechat_mon）
    --pending PATH    pending 文件路径（默认: 系统临时目录/wechat_pending.txt）
    --wait SEC        等待主人回复的时间（默认: 600=10分钟）
    --engine ENGINE   自动化引擎: peekaboo(Mac) / peekaboo-win(Windows) / auto(自动检测, 默认)

Examples:
    python3 wechat_monitor.py --contact mini --interval 600
    python3 wechat_monitor.py --contact 老板 --interval 300 --threshold 2000 --engine peekaboo-win
"""

import subprocess, time, os, sys, platform, argparse, json, shutil

# ============================================================
# 跨平台工具函数
# ============================================================

def get_platform():
    """返回 'windows' 或 'macos'"""
    s = platform.system().lower()
    if s == "windows":
        return "windows"
    elif s == "darwin":
        return "macos"
    else:
        return s

def get_temp_dir():
    """返回系统临时目录"""
    return os.path.join(tempfile.gettempdir(), "wechat_mon") if 'tempfile' in dir() else (
        os.environ.get("TEMP", "/tmp") if get_platform() == "windows" else "/tmp"
    )

def get_default_workdir():
    """返回默认工作目录"""
    if get_platform() == "windows":
        tmp = os.environ.get("TEMP", "C:\\Temp")
        return os.path.join(tmp, "wechat_mon")
    else:
        return "/tmp/wechat_mon"

def get_default_pending():
    """返回默认 pending 文件路径"""
    if get_platform() == "windows":
        tmp = os.environ.get("TEMP", "C:\\Temp")
        return os.path.join(tmp, "wechat_pending.txt")
    else:
        return "/tmp/wechat_pending.txt"

# ============================================================
# 截图引擎抽象层
# ============================================================

class ScreenshotEngine:
    """截图引擎基类"""
    def take_screenshot(self, path, app_name="微信"):
        raise NotImplementedError

    def get_app_name(self):
        return "微信"

class PeekabooMacEngine(ScreenshotEngine):
    """macOS Peekaboo CLI 截图引擎"""
    def take_screenshot(self, path, app_name="微信"):
        r = subprocess.run(
            ["peekaboo", "image", "--mode", "window",
             "--app", app_name, "--retina", "--path", path],
            capture_output=True, text=True, timeout=15
        )
        if r.returncode != 0:
            print(f"  Peekaboo stderr: {r.stderr.strip()}", flush=True)
        return r.returncode == 0

class PeekabooWinEngine(ScreenshotEngine):
    """Windows PeekabooWin (Node.js) 截图引擎"""
    def __init__(self, peekaboo_win_dir=None):
        """
        Args:
            peekaboo_win_dir: PeekabooWin 安装目录。
                默认查找环境变量 PEEKABOO_WIN_DIR 或当前目录下的 peekaboo-win 文件夹
        """
        self.peekaboo_win_dir = peekaboo_win_dir or os.environ.get(
            "PEEKABOO_WIN_DIR", ""
        )
        self._resolved = False
        self._bin_path = None

    def _resolve_bin(self):
        """查找 peekaboo-win 可执行文件"""
        if self._resolved:
            return self._bin_path is not None

        candidates = []
        # 1. 指定目录
        if self.peekaboo_win_dir:
            candidates.append(os.path.join(self.peekaboo_win_dir, "bin", "peekaboo-win.js"))
            candidates.append(os.path.join(self.peekaboo_win_dir, "bin", "peekaboo-win.cmd"))

        # 2. 全局 node_modules
        appdata = os.environ.get("APPDATA", "")
        if appdata:
            candidates.append(os.path.join(appdata, "npm", "node_modules",
                                           "peekaboo-win", "bin", "peekaboo-win.js"))

        # 3. PATH 中查找
        for p in os.environ.get("PATH", "").split(os.pathsep):
            candidates.append(os.path.join(p, "peekaboo-win"))
            candidates.append(os.path.join(p, "peekaboo-win.cmd"))

        for c in candidates:
            if os.path.isfile(c):
                self._bin_path = c
                self._resolved = True
                return True

        # 4. 尝试 npx
        self._bin_path = "npx"
        self._use_npx = True
        self._resolved = True
        return True

    def take_screenshot(self, path, app_name="微信"):
        if not self._resolve_bin():
            print("  PeekabooWin 未找到！请设置 PEEKABOO_WIN_DIR 环境变量", flush=True)
            return False

        cmd = []
        if hasattr(self, '_use_npx') and self._use_npx:
            cmd = ["npx", "peekaboo-win", "screen", "capture",
                   "--output", path]
        else:
            cmd = ["node", self._bin_path, "screen", "capture",
                   "--output", path]

        try:
            r = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
            if r.returncode != 0:
                print(f"  PeekabooWin stderr: {r.stderr.strip()}", flush=True)
            return r.returncode == 0
        except FileNotFoundError:
            print("  PeekabooWin 执行失败，请确认 Node.js 22+ 已安装", flush=True)
            return False

def create_engine(engine_name=None):
    """创建截图引擎实例"""
    plat = get_platform()

    if engine_name == "auto" or engine_name is None:
        engine_name = "peekaboo" if plat == "macos" else "peekaboo-win"

    if engine_name == "peekaboo":
        if plat == "windows":
            print("[警告] 在 Windows 上指定了 peekaboo (macOS)，尝试使用 peekaboo-win 替代", flush=True)
            return PeekabooWinEngine()
        return PeekabooMacEngine()

    elif engine_name == "peekaboo-win":
        if plat == "macos":
            print("[警告] 在 macOS 上指定了 peekaboo-win (Windows)，尝试使用 peekaboo 替代", flush=True)
            return PeekabooMacEngine()
        return PeekabooWinEngine()

    else:
        print(f"[错误] 未知的引擎: {engine_name}，可选: peekaboo / peekaboo-win / auto", flush=True)
        sys.exit(1)

# ============================================================
# 核心监控逻辑
# ============================================================

def parse_args():
    p = argparse.ArgumentParser(description="WeChat 新消息监控 v5 (跨平台)")
    p.add_argument("--contact", default="mini", help="监控的联系人")
    p.add_argument("--interval", type=int, default=600, help="截图间隔(秒, 默认600=10分钟)")
    p.add_argument("--threshold", type=int, default=1000, help="大小变化阈值(字节)")
    p.add_argument("--workdir", default=None, help="工作目录(默认自动)")
    p.add_argument("--pending", default=None, help="pending文件路径(默认自动)")
    p.add_argument("--wait", type=int, default=600, help="等待主人回复的时间(秒, 默认600=10分钟)")
    p.add_argument("--engine", default="auto",
                   choices=["auto", "peekaboo", "peekaboo-win"],
                   help="自动化引擎(默认auto自动检测)")
    p.add_argument("--peekaboo-win-dir", default=None,
                   help="PeekabooWin 安装目录(Windows), 也可用 PEEKABOO_WIN_DIR 环境变量")
    return p.parse_args()

def log(msg):
    ts = time.strftime("%H:%M:%S")
    print(f"[{ts}] {msg}", flush=True)

def write_pending(pending_path, screenshot_path, contact):
    ts = time.strftime("%Y-%m-%dT%H:%M:%S")
    with open(pending_path, "w", encoding="utf-8") as f:
        f.write(f"DETECTED:{ts}\n")
        f.write(f"SCREENSHOT:{screenshot_path}\n")
        f.write(f"CONTACT:{contact}\n")
    log(f"新消息已检测 | 时间:{ts} | 信号:{pending_path}")

def clear_pending(pending_path):
    if os.path.exists(pending_path):
        os.remove(pending_path)

def check_dependencies(engine):
    """检查必要的依赖是否已安装"""
    plat = get_platform()

    if plat == "macos":
        # 检查 peekaboo 是否安装
        r = subprocess.run(["which", "peekaboo"], capture_output=True, text=True)
        if r.returncode != 0:
            print("[错误] Peekaboo CLI 未安装！", flush=True)
            print("  请执行: brew install steipete/peekaboo/peekaboo", flush=True)
            print("  官方文档: https://peekaboo.sh/install.html", flush=True)
            return False

        # 检查权限
        r = subprocess.run(["peekaboo", "permissions"], capture_output=True, text=True, timeout=10)
        if r.returncode != 0:
            print("[警告] Peekaboo 权限可能未完全授予", flush=True)
            print("  请检查: 系统设置 → 隐私与安全 → 屏幕录制 / 辅助功能", flush=True)

    elif plat == "windows":
        # 检查 Node.js
        r = subprocess.run(["node", "--version"], capture_output=True, text=True, timeout=5)
        if r.returncode != 0:
            print("[错误] Node.js 未安装！", flush=True)
            print("  请从 https://nodejs.org 下载安装 Node.js 22+", flush=True)
            return False
        ver = r.stdout.strip().lstrip("v")
        major = int(ver.split(".")[0])
        if major < 22:
            print(f"[警告] Node.js 版本为 {ver}，建议使用 22+", flush=True)

        # 检查 PeekabooWin
        if isinstance(engine, PeekabooWinEngine):
            if not engine._resolve_bin():
                print("[错误] PeekabooWin 未找到！", flush=True)
                print("  请执行以下步骤安装:", flush=True)
                print("    git clone https://github.com/FelixKruger/PeekabooWin", flush=True)
                print("    cd PeekabooWin && npm install", flush=True)
                print("  然后设置环境变量:", flush=True)
                print("    set PEEKABOO_WIN_DIR=C:\\path\\to\\PeekabooWin", flush=True)
                return False

    return True

def monitor(args, engine):
    workdir = args.workdir or get_default_workdir()
    pending_path = args.pending or get_default_pending()
    os.makedirs(workdir, exist_ok=True)
    latest = os.path.join(workdir, "latest.png")
    contact = args.contact

    plat = get_platform()
    engine_label = "PeekabooWin" if isinstance(engine, PeekabooWinEngine) else "Peekaboo"

    log(f"=== WeChat 监控已启动 (v5 跨平台) ===")
    log(f"  平台: {plat}")
    log(f"  引擎: {engine_label}")
    log(f"  联系人: {contact}")
    log(f"  间隔: {args.interval}s | 阈值: {args.threshold}B")
    log(f"  工作目录: {workdir}")
    log(f"  Pending: {pending_path}")
    log(f"  Ctrl+C 停止\n")

    round_num = 0
    prev_size = 0

    while True:
        round_num += 1

        # 如果 pending 文件存在，等待主 agent 处理
        if os.path.exists(pending_path):
            log(f"第{round_num}轮：等待回复处理中...")
            time.sleep(args.interval)
            if not os.path.exists(pending_path):
                log("回复已完成，重新设基准")
                engine.take_screenshot(latest)
                prev_size = os.path.getsize(latest) if os.path.exists(latest) else 0
            continue

        ok = engine.take_screenshot(latest)
        if not ok:
            log(f"第{round_num}轮截图失败")
            time.sleep(args.interval)
            continue

        cur_size = os.path.getsize(latest)
        diff = abs(cur_size - prev_size)

        if prev_size == 0:
            prev_size = cur_size
            log(f"第{round_num}轮：基准已设 | size={cur_size}")
            time.sleep(args.interval)
            continue

        if diff > args.threshold:
            log(f"第{round_num}轮：检测到变化！diff={diff}B")
            write_pending(pending_path, latest, contact)
            prev_size = cur_size
        else:
            prev_size = cur_size
            log(f"第{round_num}轮：无变化 | size={cur_size}")

        time.sleep(args.interval)

if __name__ == "__main__":
    try:
        args = parse_args()
        engine = create_engine(args.engine)

        # 如果指定了 peekaboo-win-dir，覆盖默认值
        if args.peekaboo_win_dir and isinstance(engine, PeekabooWinEngine):
            engine.peekaboo_win_dir = args.peekaboo_win_dir
            engine._resolved = False  # 强制重新查找

        if not check_dependencies(engine):
            sys.exit(1)

        monitor(args, engine)
    except KeyboardInterrupt:
        log("监控已停止")
        sys.exit(0)


path: references/peekaboo-guide.md
content: # Peekaboo / PeekabooWin 使用指南

本 skill 在不同平台上使用不同的自动化引擎：

| 平台 | 引擎 | 语言 | 安装方式 |
|------|------|------|----------|
| **macOS** | Peekaboo CLI | Swift/原生 | `brew install` |
| **Windows** | PeekabooWin | Node.js 22+ | `git clone` + `npm install` |

---

## macOS: Peekaboo CLI

### 安装

```bash
brew install steipete/peekaboo/peekaboo
```

### 验证安装

```bash
peekaboo version
peekaboo permissions
```

### 权限配置

1. 打开 **系统设置** → **隐私与安全性**
2. 授予 **屏幕录制** 权限给 Peekaboo
3. 授予 **辅助功能** 权限给 Peekaboo
4. 重启终端后验证: `peekaboo permissions`

### 命令速查

#### 截图类

| 命令 | 用途 | 示例 |
|------|------|------|
| `peekaboo image --mode window --app 微信 --retina --path FILE` | 截取微信窗口 | 高清 retina 截图 |
| `peekaboo see --app 微信 --annotate --path FILE` | 截图并标注 UI 元素 | 用于定位按钮/输入框坐标 |
| `peekaboo image --mode screen --retina --path FILE` | 截取全屏 | 微信不在前台时使用 |

#### 窗口/应用控制

| 命令 | 用途 |
|------|------|
| `peekaboo app switch --to 微信` | 切换到微信前台 |
| `peekaboo app unhide --app 微信` | 取消隐藏微信 |
| `peekaboo app hide --app 微信` | 隐藏微信 |
| `peekaboo list apps --json` | 列出所有运行中的应用 |

#### 输入操作

| 命令 | 用途 | 注意事项 |
|------|------|---------|
| `peekaboo click --coords X,Y --app 微信` | 点击指定坐标 | 需要先确定正确坐标 |
| `peekaboo type "文字" --app 微信` | 输入文字 | 模拟真人打字速度 |
| `peekaboo type "" --app 微信 --return` | 发送消息（回车） | 微信必须用此方式发送 |
| `peekaboo press --key return` | 按回车键 | 对微信不可靠 |

---

## Windows: PeekabooWin

### 前置条件

| 要求 | 说明 |
|------|------|
| **操作系统** | Windows 10 或 Windows 11 |
| **Node.js** | 22.0.0 或更高版本 ([下载地址](https://nodejs.org)) |
| **Shell** | PowerShell（推荐）或 CMD |
| **Python** | 3.7+ （监控脚本需要） |

### 安装步骤

```powershell
# 1. 克隆仓库
git clone https://github.com/FelixKruger/PeekabooWin
cd PeekabooWin

# 2. 安装依赖
npm install

# 3. 运行测试确认安装成功
npm test
```

### 设置环境变量

监控脚本需要知道 PeekabooWin 安装在哪里。

```powershell
# 方式1: 临时设置（仅当前 PowerShell 窗口有效）
$env:PEEKABOO_WIN_DIR = "C:\Users\<你的用户名>\PeekabooWin"

# 方式2: 永久设置（推荐，所有窗口生效）
[System.Environment]::SetEnvironmentVariable(
    "PEEKABOO_WIN_DIR",
    "C:\Users\<你的用户名>\PeekabooWin",
    "User"
)
```

> 设置永久环境变量后，**需要重新打开 PowerShell 窗口**才能生效。

### 验证安装

```powershell
# 检查 Node.js 版本
node --version
# 应显示 v22.x.x 或更高

# 检查 PeekabooWin 是否可用
node C:\Users\<你的用户名>\PeekabooWin\bin\peekaboo-win.js --help

# 列出所有窗口
node C:\Users\<你的用户名>\PeekabooWin\bin\peekaboo-win.js windows list

# 截取微信窗口
node C:\Users\<你的用户名>\PeekabooWin\bin\peekaboo-win.js screen capture --output %TEMP%\wechat_test.png
```

### 权限注意事项

- 部分操作可能需要**管理员权限**运行 PowerShell
- 确保微信窗口未被 Windows "专注助手" (Focus Assist) 屏蔽
- Windows OCR 运行时通常已内置，无需额外安装
- 某些安全软件可能拦截模拟输入，需添加白名单

### 命令速查

#### 截图类

| 命令 | 用途 |
|------|------|
| `peekaboo-win screen capture --output FILE` | 截取全屏 |
| `peekaboo-win window capture --hwnd <id>` | 截取指定窗口 |
| `peekaboo-win see --mode window --title "微信"` | 截图 + 索引 UI 控件 |
| `peekaboo-win snapshot list` | 查看已保存的快照 |

> 以下命令中的 `peekaboo-win` 是 `node <PEEKABOO_WIN_DIR>\bin\peekaboo-win.js` 的简写。

#### 应用控制

| 命令 | 用途 |
|------|------|
| `peekaboo-win app list` | 列出所有运行中的应用 |
| `peekaboo-win app switch --name "微信"` | 切换到微信 |
| `peekaboo-win app launch --command WeChat.exe` | 启动微信 |
| `peekaboo-win app quit --name "微信"` | 退出微信 |

#### 输入操作

| 命令 | 用途 |
|------|------|
| `peekaboo-win click --on "标签"` | 通过 UI 标签点击（推荐） |
| `peekaboo-win click --on "100,200"` | 通过坐标点击 |
| `peekaboo-win mouse click --x 900 --y 780` | 鼠标点击坐标 |
| `peekaboo-win type --text "文字"` | 输入文字 |
| `peekaboo-win type --text "文字" --clear` | 清空后输入文字 |
| `peekaboo-win press --keys "Enter"` | 按单个键 |
| `peekaboo-win hotkey --keys ctrl,shift,t` | 组合键 |

#### 窗口管理

| 命令 | 用途 |
|------|------|
| `peekaboo-win window focus --hwnd <id>` | 聚焦窗口 |
| `peekaboo-win window state --title "微信" --state restore` | 恢复窗口 |
| `peekaboo-win window state --title "微信" --state maximize` | 最大化 |
| `peekaboo-win window move --title "微信" --x 100 --y 100` | 移动窗口 |

### 微信输入框定位（Windows）

PeekabooWin 比 macOS Peekaboo 更强大：支持通过 **UI 标签** 点击，无需硬编码坐标。

```powershell
# 1. 查看微信窗口中有哪些 UI 元素
peekaboo-win see --mode window --title "微信"

# 2. 找到输入框的标签（可能是 "消息", "输入" 等）
# 3. 通过标签点击
peekaboo-win click --on "消息" --title "微信"

# 4. 如果标签点击不可靠，用坐标
peekaboo-win mouse click --x 900 --y 780
```

### macOS vs Windows 命令对照表

| 操作 | macOS (Peekaboo) | Windows (PeekabooWin) |
|------|-----------------|----------------------|
| 截图 | `peekaboo image --mode window --app 微信 --path FILE` | `peekaboo-win screen capture --output FILE` |
| 切换应用 | `peekaboo app switch --to 微信` | `peekaboo-win app switch --name "微信"` |
| 点击 | `peekaboo click --coords X,Y --app 微信` | `peekaboo-win click --on "label"` 或 `mouse click --x --y` |
| 输入文字 | `peekaboo type "text" --app 微信` | `peekaboo-win type --text "text"` |
| 发送消息 | `peekaboo type "" --app 微信 --return` | `peekaboo-win press --keys "Enter"` |
| 列出应用 | `peekaboo list apps` | `peekaboo-win app list` |
| 查看元素 | `peekaboo see --app 微信 --annotate` | `peekaboo-win see --mode window --title "微信"` |

### 踩坑记录（Windows）

1. **Node.js 版本**：必须 22+，低于 22 会报错
2. **环境变量**：必须设置 `PEEKABOO_WIN_DIR`，否则监控脚本找不到 PeekabooWin
3. **微信窗口最小化**：PeekabooWin 截取全屏时，最小化的窗口不会出现。请保持微信窗口在前台或至少未最小化
4. **OCR 精度**：Windows 内置 OCR 对中文识别较好，但密集文字可能遗漏
5. **管理员权限**：某些窗口操作需要以管理员身份运行 PowerShell
6. **pyautogui failsafe**：将鼠标移到屏幕左上角会紧急停止所有操作

---

## 常见问题

### Q: PeekabooWin 的 `screen capture` 能截取最小化的窗口吗？

**不能。** `screen capture` 截取的是屏幕上的可见内容。微信窗口必须至少在桌面上可见（不需要在最前面，但不能最小化到任务栏）。

### Q: PeekabooWin 和 macOS Peekaboo 的命令一样吗？

**不一样。** PeekabooWin 是独立项目，命令语法不同。但功能类似：截图、点击、输入、窗口管理。

### Q: 可以用 PeekabooWin 的 MCP Server 吗？

可以，PeekabooWin 内置 MCP Server。但本 skill 的监控脚本使用的是 CLI 方式，不依赖 MCP。

### Q: Windows 上截图文件保存到哪里？

默认保存到 `%TEMP%\wechat_mon\` 目录，即 `C:\Users\<用户名>\AppData\Local\Temp\wechat_mon\`。


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