feat: v2.8.0 无头运行器、考试自动交卷、改为退避重试不跳课

新增无头运行能力,解决 Linux 无图形化服务器上无法常驻的问题;同时改掉
"遇到考试课/无进展课就跳过"的策略,改为在同门课上退避重试。

- runner/:自己起无头 Chromium,用 CDP 把构建产物注入页面主世界(等价
  @grant none),不装插件、不需要桌面环境或 Xvfb;含浏览器探测与启动参数、
  持久化 profile、陈旧 SingletonLock 清理、优雅退出、日志轮转、启动预检
- runner.config.mjs / start-headless.cmd:通用配置 + Windows 一键入口;
  凭据只走 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD 环境变量
- src/exam.js:含考试章节的课程自动进考试 → 开始/继续 → 空卷提交 → 确定,
  交卷后靠平台记账推进课程;maxExamTries 限制同门课交卷次数,防不记账时死循环
- 去掉跳过与黑名单:没学完就退避重试(30s 起翻倍,最长 5 分钟),
  同门课超过 maxCourseRetries 次才停整轮并提示,替代原 maxConsecutiveFailures
- 每完成一门都重新拉列表接口取平台实时状态再选下一门,避免用陈旧队列
- 学习进度改存 sessionStorage(yun-xue-tang-run-state-v3),整页跳转/刷新可续;
  运行开关不跨会话,浏览器重启后必须显式开跑
- dev/:新增 real-cdp / real-run / real-test / real-e2e 实跑脚本与 check.mjs
  统一静态检查(JS 22 + 批处理 2),替代逐文件 node --check
- docs/evidence/headless-linux-evidence.txt + 实跑截图,README 补无头部署章节
This commit is contained in:
void committed 2026-10-25 23:04:40 +08:00
1 parent 8193326b70
commit ae117222df
47 files changed
+6182 -821

No files matched your search

+5
View File
@@ -4,6 +4,9 @@ node_modules/
# ---- 运行 / 调试产物 ----
# 本地实跑会在这里生成浏览器配置目录、截图和一次性调试脚本,体积很大,不入库
.run-tmp/
# 无头运行器的持久化 profile(含登录 cookie,绝不能入库)和运行日志
.run-profile/
run-logs/
*.log
*.tmp
@@ -18,3 +21,5 @@ desktop.ini
# ---- 本地私有配置(不要提交账号信息) ----
.env
.env.*
# 个人临时覆盖用的运行器配置(放进仓库的 runner.config.mjs 保持通用)
runner.local.mjs
+262 -27
View File
@@ -1,7 +1,8 @@
# 云学堂助手
在云学堂(`*.yunxuetang.cn`)上自动登录、按目录顺序听课、自动切节,并在课程列表页批量推进的
Tampermonkey 用户脚本。支持多课时课程与单视频/音频课程;一门课学完会自动回列表选下一门。
在云学堂(`*.yunxuetang.cn`)上自动登录、按目录顺序听课、自动切节,并在课程列表页逐门推进的
Tampermonkey 用户脚本。支持多课时课程与单视频/音频课程;含考试章节的课程会自动进入考试、
不答题直接交卷;一门课学完会自动回列表选下一门。
平台按**真实播放时长**计时,脚本只负责「自动点播放、自动切下一节、处理防挂机弹窗」,
不快进、不改进度、不伪造学时。
@@ -12,22 +13,24 @@ Tampermonkey 用户脚本。支持多课时课程与单视频/音频课程;一
| 能力 | 说明 |
| --- | --- |
| 一键登录 | 面板里填账号密码,自动填充表单、勾选协议、点击登录;支持记住密码与自动登录 |
| 顺序听课 | 进入课程(手动打开或批量进入)后先对齐到「第一个未学完的课时」,从第一章第一节顺序往下学 |
| 顺序听课 | 进入课程(列表刷课或自己点开)后先对齐到「第一个未学完的课时」,从第一章第一节顺序往下学 |
| 自动切节 | 本节播完(`video.ended` 或平台倒计时归零)后自动进入下一节,并等平台记账后再继续 |
| 完成即跳课 | 平台汇总变成 `已完成学习`、进度 100% 或 `x/y` 满时判定整门课完成,自动回列表选下一门;不会停在已完成页,也不会把播完的视频从头重播 |
| 多类型播放页 | 识别 `#/course/play`、`#/video/play`、`#/audio/play`、`#/ppt/play` 等播放页;单视频课程同样自动点「开始学习」 |
| 防挂机验证 | 识别「已触发防挂机验证」弹窗并点「继续学习」;滑块/拼图类验证不绕过,提示人工处理 |
| 批量刷课 | 在列表页逐门进入未学完的课程,本次门数与连续失败上限见下方配置表 |
| 短课程优先 | 批量模式默认按课程总时长**从短到长**选课(跨页),先完成 1 分钟的课再学 1 小时的课;面板可关闭 |
| 失败隔离 | 答题/考试类课程、长时间无计时进展的课程会被跳过并记录原因,不影响后续课程 |
| 进度可续 | 运行状态存在 `localStorage`,刷新、热更新后继续上次的队列和页码 |
| 课程列表自动刷课 | 在列表页逐门进入未学完的课程;每完成一门都重新调列表接口拿平台实时状态再选下一门,本次门数上限见下方配置表 |
| 短课程优先 | 列表刷课默认按课程总时长**从短到长**选课(跨页),先完成 1 分钟的课再学 1 小时的课;面板可关闭 |
| 考试自动空卷 | 含考试章节的课程不再跳过:自动点进考试节 → 开始/继续考试 → 一题不做直接「提交考试」→ 点「确定」交卷,交卷后课程进度被平台记账,课程即可完成;同一门课最多交卷 `maxExamTries` 次,防平台不记账时死循环 |
| 不跳过课程 | 没有任何「跳过本课」入口,也不会把某门课加入黑名单;没学完就退避重试(30 秒起翻倍,最长 5 分钟),同一门课最多重试 `maxCourseRetries` 次,超过才停下整轮刷课并提示原因,等人工处理 |
| 进度可续 | 学习进度存在 `sessionStorage`(`yun-xue-tang-run-state-v3`),整页跳转/刷新后继续上次的队列和页码;**运行开关不跨会话** —— 浏览器重启、运行器新建标签页后一律回到待机,必须显式开跑(避免未登录就报「运行中」) |
| 无头运行 | 在有/无图形界面的机器上都能跑;`runner/` 可自己起无头 Chromium 并注入脚本,适合 Linux 服务器 / Windows 无人值守常驻(见下方「无头运行」) |
## 安装
1. 浏览器安装 [Tampermonkey](https://www.tampermonkey.net/)。
2. 打开 Tampermonkey 面板 → 添加新脚本 → 粘贴 [`yun-xue-tang-assistant.user.js`](yun-xue-tang-assistant.user.js) 全文 → 保存。
3. 打开 <https://kfmic.yunxuetang.cn/login.html>,右下角出现「云学堂助手」面板:
- 填账号密码 → 点「一键登录并刷课」,登录后自动进入列表并开始批量学习;
- 填账号密码 → 点「一键登录并刷课」,登录后自动进入列表并开始逐门学习;
- 或手动登录后,在列表页点「一键刷课」。
脚本 `@grant none`,不依赖任何本地服务,可独立运行。
@@ -39,23 +42,220 @@ Tampermonkey 用户脚本。支持多课时课程与单视频/音频课程;一
| 配置项 | 默认 | 作用 |
| --- | --- | --- |
| `mute` | `true` | 静音播放(自动播放更稳) |
| `autoNext` | `true` | 手动打开课程时,本节结束自动下一节 |
| `autoNext` | `true` | 当前课程自动连播:本节结束自动下一节 |
| `tickMs` | `2000` | 主循环间隔 |
| `startClickCooldownMs` | `3000` | 「开始学习」重复点击冷却:3 秒内没起播就补点 |
| `entryGraceMs` | `30000` | 进课后标题/课程 id 尚未就绪的宽限,避免慢加载被误判为「课程不一致」 |
| `stuckMs` | `5 分钟` | 连续多久没有计时进展就放弃当前课程 |
| `maxCourses` | `10` | 本次最多完成多少门;`0` = 不限 |
| `maxConsecutiveFailures` | `5` | 连续失败多少门后自动停止 |
| `maxCourseRetries` | `5` | 同一门课最多重试多少次;超过则停止整轮刷课并提示(不会跳过该课) |
| `courseRetryDelayMs` | `30000` | 首次重试前的等待;每次翻倍,最长 5 分钟 |
| `alignToFirstIncomplete` | `true` | 进入课程先从第一个未学完的课时学起;`false` = 沿用平台上次位置 |
| `preferShortCourses` | `true` | 批量选课时优先总时长更短的课程(正序);面板勾选框「优先短课程(时长正序)」可随时切换 |
| `preferShortCourses` | `true` | 列表刷课时优先总时长更短的课程(正序);面板勾选框「优先短课程(时长正序)」可随时切换 |
| `maxExamTries` | `2` | 同一门课「空卷交卷」的最大次数;超过仍没计入进度就按普通未完成重试(防死循环) |
| `examClickCooldownMs` | `1500` | 考试页内两次点击的间隔(毫秒) |
对齐起点对「一键刷课」和手动打开课程(需勾选「手动课程自动连播」)都生效,
对齐起点对「一键刷课」和自己点开的课程(需勾选「当前课程自动连播」)都生效,
每门课只在进入时对齐一次,之后手动点其它课时不会被拉回。
短课程优先开启时,批量任务启动会先读取一次列表接口里的课程总时长(首次约 5–10 秒,
短课程优先开启时,列表刷课启动会先读取一次列表接口里的课程总时长(首次约 5–10 秒,
结果在当前标签页缓存 5 分钟),把未学完课程按 `studyHours` 正序排队,再跳到目标页
逐个进入。接口不可用(未登录、跨域、平台改版)时自动降级为「当前页按时长正序」,
再不行就回到原来的列表顺序,不会让批量任务卡住。
再不行就回到原来的列表顺序,不会让刷课任务卡住。
## 无头运行(Linux / Windows 服务器)
用 `runner/headless.mjs` 把整套逻辑跑在一个无头 Chromium 里:自己起浏览器、用 CDP 把构建产物
注入页面主世界(等价 Tampermonkey `@grant none`),不需要装浏览器插件、不需要桌面环境、
不需要 Xvfb。Linux 与 Windows 都支持,macOS 也能跑。
支持的环境:
| 环境 | 说明 |
| --- | --- |
| Linux 服务器 | 机房机器、云主机、容器;root 运行、`/dev/shm` 只有 64MB 都自动适配 |
| Windows 桌面 | 后台挂着跑;关掉控制台窗口或 `Ctrl+C` 都能让它收尾 |
| Windows 服务器核心版 / 无桌面 | 无交互桌面也能跑(Chromium 无头不需要窗口站) |
| Windows 服务 / 计划任务 Session 0 | 会检测到 `SESSIONNAME=Services` 强制无头,`headless: false` 被忽略 |
| macOS | 无头可用(本机调试场景) |
**Linux / macOS:**
```bash
# 1. 依赖(Ubuntu / Debian 为例)
sudo apt install -y chromium # 或安装官方包:google-chrome-stable
# 2. 构建产物
npm install && npm run build
# 3. 调参:改仓库根目录的 runner.config.mjs(maxCourses、budgetMinutes、preferShort…)
# 只想临时覆盖就用命令行,例如 npm run headless -- --max-courses 3
# 4. 凭据走环境变量(不要写进配置文件)
export YUN_XUE_TANG_USR='你的账号'
export YUN_XUE_TANG_PWD='你的密码'
# 5. 先自检(只读:不登录、不点课程、不改进度)
npm run headless:check
# 6. 正式跑,前台常驻,Ctrl+C 结束
npm run headless
```
Linux 上建议用 `tmux` / `nohup` 托管,因为运行器是**前台进程**(不内置守护模式):
```bash
tmux new -d -s yun-xue-tang 'cd ~/yun-xue-tang-assistant && npm run headless'
tmux attach -t yun-xue-tang # 看实时输出
tail -f run-logs/headless.log # 也可以直接看日志文件
```
**Windows:**
```powershell
# 1. 浏览器:Chrome 或 Edge 都行(Edge 是 Chromium 内核,同样可用)
winget install --id Google.Chrome
# 2. 构建产物
npm install; npm run build
# 3. 调参:改 runner.config.mjs(无需重新 build)
# 4. 凭据(PowerShell;用 CMD 请改成 set YUN_XUE_TANG_USR=...)
$env:YUN_XUE_TANG_USR='你的账号'
$env:YUN_XUE_TANG_PWD='你的密码'
# 5. 自检 + 正式跑
npm run headless:check
npm run headless
```
也可以直接双击 [`start-headless.cmd`](start-headless.cmd):它会自动构建、检查 Node、跑完后
用 `pause` 留住退出码信息(方便看报错)。注意这个批处理文件**只写 ASCII 字符**——中文提示
全部由 Node 侧输出,原因见下方常见坑表里的「`'鍏?npm' 不是内部或外部命令`」。
Windows 上常驻的三种方式:
```powershell
# A. 隐藏窗口后台跑(立刻返回,日志看 run-logs\headless.log)
Start-Process -WindowStyle Hidden node -ArgumentList "runner/headless.mjs" -WorkingDirectory $PWD
# B. 计划任务:登录时自动开始(勾「不管用户是否登录」也能跑,会强制无头)
schtasks /create /tn "云学堂助手" /tr "node runner\headless.mjs" /sc onlogon /rl highest
# C. 只跑一段(例如每天凌晨跑 2 小时):命令行临时覆盖配置
npm run headless -- --budget-minutes 120
# 或把 budgetMinutes: 120 写进 runner.config.mjs,然后直接 npm run headless
```
Windows 上要注意:`Ctrl+C` 会让运行器优雅收尾(暂停视频、停批量、关浏览器)。
但如果是在任务管理器里「结束任务」或 `taskkill /F`,进程会被直接终止、收尾代码不会执行;
这种情况下次启动时会自动清理残留的浏览器进程与 `lockfile`,不需要手工处理。
运行器做的事:
| 能力 | 说明 |
| --- | --- |
| 脚本注入 | 每次整页跳转(新 document)后自动补注入,和 Tampermonkey 按 `@match` 重注入等价 |
| 持久化登录 | 浏览器 profile 固定到 `./.run-profile`,cookie / localStorage 都留着,重启不用重登 |
| 掉登录自动重登 | cookie 失效或被踢回登录页时,用 `YUN_XUE_TANG_USR` / `YUN_XUE_TANG_PWD` 自动登录并接着刷课 |
| 崩溃自愈 | CDP 断线、浏览器崩溃、90 秒读不到脚本状态都会重启浏览器,并由看护循环在新会话里显式重新开跑(浏览器重启后 sessionStorage 清空,进度里的「完成书目」会重新从平台接口取) |
| 无进展保护 | 连续 30 分钟没有任何进展(`YUN_XUE_TANG_IDLE_RESTART_MINUTES`)时退出,避免无意义挂机 |
| 优雅退出 | `Ctrl+C` / `SIGTERM` 时先 `pauseAllMedia`、停批量、再关浏览器,不留脏状态(Windows 上监听 `SIGINT` / `SIGBREAK` / `SIGHUP`) |
| 残留自愈 | 上次被强杀(`kill -9` / 任务管理器「结束任务」)留下的浏览器进程与锁文件,启动时按 profile 目录自动清理,端口不会一直被占 |
| 平台适配 | 平台差异集中在 `runner/platform.mjs`:有无图形会话、沙箱参数、进程树收尾、端口排查命令都按系统出 |
| 日志 | 同时写终端和 `./run-logs/headless.log`(`YUN_XUE_TANG_LOG_MAX_BYTES` 默认 5MB,超出轮转成 `.1`) |
### 代码结构
`runner/` 按职责拆成小模块,入口只有 90 行,改哪块就看哪个文件:
| 文件 | 行数级别 | 职责 |
| --- | --- | --- |
| `runner/headless.mjs` | ~130 | 入口:解析参数 → 预检 → 交给 supervisor,只做组装 |
| `runner/config.mjs` | ~360 | 三层合并(配置文件 / 环境变量 / 命令行)+ 校验 + `--help`,其它模块只读导出常量 |
| `runner.config.mjs`(仓库根) | ~50 | **日常调参就改这里**:普通 JS 模块,可写注释,改完不用 build |
| `runner/platform.mjs` | ~230 | 平台差异:有无图形会话、沙箱参数、进程树收尾、残留进程清理、排查命令 |
| `runner/preflight.mjs` | ~95 | 启动前检查:产物、Node 版本、凭据、浏览器、调试端口(端口被占会先自愈) |
| `runner/log.mjs` | ~50 | 终端 + 文件日志,超上限轮转成 `.1` |
| `runner/stop.mjs` | ~60 | 终止信号优雅退出(Windows 走 SIGINT/SIGBREAK/SIGHUP) |
| `runner/browser.mjs` | ~230 | 浏览器探测、启动参数、陈旧锁与孤儿进程清理 |
| `runner/cdp.mjs` | ~90 | 极简 CDP 客户端(Node 22+ 原生 WebSocket,无第三方依赖) |
| `runner/page.mjs` | ~150 | 注入后要调用的页面 JS 表达式 + `page.evalJS/json/tryEval` 封装 |
| `runner/session.mjs` | ~310 | 单次会话:起浏览器 → 注入 → 自动重登 → 刷课 → 监控 → 收尾 |
| `runner/selfcheck.mjs` | ~60 | `--check` 的只读环境自检 |
| `runner/supervisor.mjs` | ~75 | 崩溃重启循环与退出码 |
模块之间是单向依赖(`headless` → `supervisor` → `session` → `page`/`selfcheck` → `cdp`),
平台相关的判断全部下沉到 `platform.mjs`(`browser.mjs` 转发它的导出,老代码不用改),
没有循环引用,也没有需要打包的步骤:`node runner/headless.mjs` 直接跑多文件 ESM。
改脚本内部 API(`window.__yunXueTangAuto` 上的方法)只需要动 `runner/page.mjs`。
命令行参数(**日常改配置文件就行**;这里的开关只是临时覆盖,适合写进 `tmux` 命令或 `~/.bashrc`):
优先级:**内置默认值 < `runner.config.mjs` < 环境变量 `YUN_XUE_TANG_*` < 命令行参数**。
| 参数 | 环境变量 | 配置文件字段 | 默认 | 作用 |
| --- | --- | --- | --- | --- |
| `--check` | — | (不支持) | 关 | 只做环境自检:浏览器能启动、页面能打开、脚本能注入、视频编解码可用;不登录、不动进度,通过则退出码 0 |
| `--max-courses N`(旧名 `--max`) | `YUN_XUE_TANG_MAX_COURSES` | `maxCourses` | `10` | 本次最多完成 N 门课,`0` = 不限 |
| `--budget-minutes N`(旧名 `--budget`) | `YUN_XUE_TANG_BUDGET_MINUTES` | `budgetMinutes` | `0` | 运行 N 分钟后收尾退出(适合放进 cron 定长跑) |
| `--restart-minutes N`(旧名 `--restart`) | `YUN_XUE_TANG_RESTART_MINUTES` | `restartMinutes` | `0` | 脚本自己停下后等待多少分钟再开新一轮;`0` = 直接退出 |
| `--idle-restart-minutes N`(旧名 `--idle`) | `YUN_XUE_TANG_IDLE_RESTART_MINUTES` | `idleRestartMinutes` | `30` | 连续多少分钟无进展判定卡死 |
| `--prefer-short 0\|1` | `YUN_XUE_TANG_PREFER_SHORT` | `preferShort` | `1` | 是否优先短课程(时长正序) |
| `--headless 0\|1`(旧名 `--visible`) | `YUN_XUE_TANG_HEADLESS` | `headless` | `1` | `1` = 无头;`0` = 开有界面浏览器(仅本机调试;无图形会话时被忽略并强制无头) |
| `--origin URL` | `YUN_XUE_TANG_ORIGIN` | `origin` | `https://kfmic.yunxuetang.cn` | 站点根地址(换分公司环境时改这个) |
| `--url URL` | `YUN_XUE_TANG_URL` | `url` | `<origin>/login.html` | 起始页面 |
| `--port N` | `YUN_XUE_TANG_CDP_PORT` | `port` | `9336` | CDP 调试端口,同机多实例时分开 |
| `--profile DIR` | `YUN_XUE_TANG_PROFILE_DIR` | `profile` | `./.run-profile` | 持久化 profile 目录,删掉即重置登录态与进度缓存 |
| `--chrome PATH` | `YUN_XUE_TANG_CHROME_BIN` | `chrome` | 自动探测 | 指定 Chrome/Chromium 可执行文件 |
| `--extra-args "…"` | `YUN_XUE_TANG_EXTRA_ARGS` | `extraArgs` | 空 | 追加给浏览器的命令行参数(空格分隔) |
| `--log-file PATH`(旧名 `--log`) | `YUN_XUE_TANG_LOG_FILE` | `logFile` | `./run-logs/headless.log` | 日志文件路径 |
| `--log-max-bytes N`(旧名 `--log-max`) | `YUN_XUE_TANG_LOG_MAX_BYTES` | `logMaxBytes` | `5242880` | 单文件上限,超出轮转 |
| `--config PATH` | `YUN_XUE_TANG_CONFIG` | — | `./runner.config.mjs` | 指定另一个配置文件 |
| `--help` / `-h` | — | — | — | 打印完整参数表(含配置文件字段、环境变量、当前生效值) |
| — | `YUN_XUE_TANG_HAS_DISPLAY` | — | 自动判断 | `1`/`0` 强制认定「有无图形会话」(Linux 看 `DISPLAY`,Windows 看 `SESSIONNAME`;判断不准时用) |
| — | `YUN_XUE_TANG_USR` / `YUN_XUE_TANG_PWD` | **不写入配置文件** | 必填 | 账号密码。故意只走环境变量:命令行会进进程列表/计划任务历史 |
未知参数、缺值参数、非数字值都会**直接报错并以退出码 2 退出**(不再静默忽略,避免 `--prefer-short` 拼错却以为生效了)。
### 配置文件
日常调参改仓库根目录的 `runner.config.mjs` 即可,它是普通 JS 模块(可写注释、可写表达式),
改完**不需要 `npm run build`**(构建只打包注入浏览器的 `src/`):
```js
// runner.config.mjs
export default {
maxCourses: 0, // 0 = 不限,一直刷到没有未学完的课
budgetMinutes: 0, // 0 = 不限运行时长
preferShort: true, // 时长正序选课
restartMinutes: 0, // 0 = 停下就退出
idleRestartMinutes: 30,
port: 9336,
profile: './.run-profile',
logFile: './run-logs/headless.log',
};
```
- 想看全部字段与当前生效值:`node runner/headless.mjs --help`
- 想只为一个场景换配置:`node runner/headless.mjs --config ./my.mjs`
- 个人机器的差异建议放 `runner.local.mjs`(已在 `.gitignore` 里)并用 `--config ./runner.local.mjs`
- 配置文件里写 `username` / `password` 会被**忽略并告警**(凭据只认环境变量);写未知字段也会告警
退出码:`0` 正常收尾(达到 `maxCourses` / `budgetMinutes` / 无更多可学课程)、`1` 无进展卡死、
`2` 环境或参数问题(缺构建产物、缺凭据、找不到浏览器、端口被占、参数写错)、`3` 连续 5 次登录失败(见 runner/)
(多半是密码错误或站点要求验证码)。
无图形环境常见的坑:
| 现象 | 平台 | 原因与处理 |
| --- | --- | --- |
| 启动报 `Missing X server or $DISPLAY` | Linux | 有界面模式需要显示服务。运行器已自动判断:无 `DISPLAY` 强制无头 |
| `Running as root without --no-sandbox is not supported` | Linux | 运行器在 Linux 上默认加 `--no-sandbox --disable-setuid-sandbox` |
| 标签页莫名崩溃 / `Target closed` | Linux 容器 | `/dev/shm` 太小(默认 64MB)。运行器自动加 `--disable-dev-shm-usage` |
| 中文显示成方块 | Linux | 只影响截图观感(脚本靠 DOM 文本匹配,不依赖字体)。需要截图时 `apt install fonts-noto-cjk` |
| 视频一直 0 秒、`error.code=4` | 全平台 | 该 Chromium 不带 H.264/AAC 专有编解码器。Linux 上改装 `google-chrome-stable`(官方包带);Windows 上用官方 Chrome/Edge 即可。`npm run headless:check` 会直接告诉你 |
| 登录页自动登录失败 | 全平台 | 站点要求验证码/滑块时无头环境无法完成,需要人工在 `headless: false`(有界面)模式下登录一次,之后靠持久化 profile 的 cookie |
| 端口被占 | 全平台 | 运行器会先清理「命令行带本 profile」的残留浏览器(自愈);仍被别的程序占用时按提示换 `--port`。提示命令按平台出:Linux `pkill -f "remote-debugging-port=9336"`,Windows `netstat -ano \| findstr :9336` + `taskkill /PID <PID> /T /F` |
| `"无法创建数据目录"` / `配置文件正在使用中` | Windows | 上次浏览器被强杀后 profile 还锁着。运行器启动时会自动清理;也可手动删掉 `.run-profile`(会丢失登录态) |
| `Ctrl+C` 后浏览器没关 | Windows | 用了任务管理器「结束任务」/ `taskkill /F` 时收尾代码不执行(TerminateProcess)。下次启动会自动清理残留进程 |
| 计划任务里一起床就退出 | Windows | 运行在 Session 0 没有桌面。运行器检测 `SESSIONNAME=Services` 后强制无头,正常;若仍失败看 `run-logs/headless.log` |
| `'鍏?npm' 不是内部或外部命令` / `'01' 不是内部或外部命令` / `'rofile' 不是内部或外部命令` | Windows | 批处理文件里出现了**中文(非 ASCII)字符**或**裸 LF 行尾**。cmd.exe 按当前代码页逐字节读批处理,多字节字符和 LF 都会让行偏移错位,于是把一行拆成几段当命令执行。修法:`.cmd` 只用 ASCII 且必须 CRLF。`npm run check` 会直接拦下这类文件 |
Linux 上不需要 Xvfb,但如果你确实想跑有界面模式(例如远程看面板、人工过验证码),
可以 `apt install xvfb x11vnc` 后 `xvfb-run -s "-screen 0 1360x940x24" npm run headless -- --headless 0`。
## 开发热加载
@@ -68,7 +268,7 @@ npm run build:watch # 监听 src/,保存即自动重新打包
npm run dev # 等价于 node dev/serve.mjs,默认 127.0.0.1:8899
```
Windows 下也可以直接双击 [`dev/start-dev.cmd`](dev/start-dev.cmd)。脚本暴露 `window.__ytDispose()`,
Windows 下也可以直接双击 [`dev/start-dev.cmd`](dev/start-dev.cmd)。脚本暴露 `window.__yunXueTangDispose()`,
加载器在注入新版本前先释放旧实例(定时器、监听器、面板),因此视频播放不会被打断。
## 目录结构
@@ -85,12 +285,28 @@ src/ 业务脚本源码(拆成多个模块,日
login.js 登录 / 一键刷课
list.js 列表页 + 短课程优先
player.js 播放器 / 防挂机 / 课时切换
exam.js 考试自动空卷交卷
course.js 课程页主循环
complete.js 完成 / 失败
complete.js 完成 / 未完成重试
index.js 主循环 / 启动 / 调试入口
build.mjs esbuild 打包脚本
runner.config.mjs 无头运行器配置文件(日常调参改这里,不用 build)
start-headless.cmd Windows 一键启动无头运行器(双击即可)
runner/ 无头运行器(Linux / Windows,无图形化环境)
headless.mjs 入口:组装 配置 → 预检 → supervisor
config.mjs 参数 / 配置文件 / 环境变量三层合并 + --help
platform.mjs 平台差异(图形会话、沙箱、进程树、残留清理、排查命令)
preflight.mjs 启动前检查(产物 / Node / 凭据 / 浏览器 / 端口)
log.mjs 终端 + 文件日志
stop.mjs 终止信号优雅退出
browser.mjs 浏览器探测、启动参数、陈旧锁与孤儿进程清理
cdp.mjs 极简 CDP 客户端(Node 22+ 原生 WebSocket)
page.mjs 页面求值封装与注入后调用的表达式
session.mjs 单次会话:起浏览器 / 注入 / 自动重登 / 崩溃自愈
selfcheck.mjs --check 只读环境自检
supervisor.mjs 崩溃重启循环与退出码
package-lock.json 依赖锁(esbuild)
package.json npm scripts(build / build:watch / dev / check)
package.json npm scripts(build / build:watch / dev / headless / check)
yun-xue-tang-assistant.user.js 构建产物(唯一需要安装的文件,不要手改)
dev/ 本地热加载开发工具(HTTP 服务 + 薄加载器)
docs/screenshots/ 实跑截图
@@ -100,16 +316,27 @@ docs/evidence/ 实跑日志与接口证据
## 本机数据
| `localStorage` 键 | 内容 |
| --- | --- |
| `yt-batch-v2` | 批量刷课队列、当前课程、页码、已完成/失败记录 |
| `yt-login-v1` | 勾选「记住密码」时的账号密码(base64 混淆,**不是加密**) |
| `yt-auto-play-enabled` | 「手动课程自动连播」开关 |
| `yt-prefer-short` | 「优先短课程(时长正序)」开关(`1` / `0`) |
| `yt-auto-start-after-login` | 登录后自动开始刷课的一次性标记(5 分钟内有效) |
本机数据分三层存放,按「这条信息跨会话是否还成立」区分:
短课程队列缓存在 `sessionStorage` 的 `yt-short-catalog-v1`,关闭标签页即清空,
不写入长期存储。
| `localStorage` 键(用户偏好,跨会话有效) | 内容 |
| --- | --- |
| `yun-xue-tang-login-v1` | 勾选「记住密码」时的账号密码(base64 混淆,**不是加密**) |
| `yun-xue-tang-auto-play-enabled` | 「当前课程自动连播」开关 |
| `yun-xue-tang-prefer-short` | 「优先短课程(时长正序)」开关(`1` / `0`) |
| `yun-xue-tang-target-catalog-url` | 目标目录 URL:决定刷哪个学院/目录的课(短课程队列的缓存键也来自它) |
| `yun-xue-tang-auto-start-after-login` | 登录后自动开始刷课的一次性标记(5 分钟内有效) |
| `sessionStorage` 键(本次运行,关掉标签页即清空) | 内容 |
| --- | --- |
| `yun-xue-tang-run-state-v3` | 本轮是否在跑、页码、当前课程、本轮已完成与待重试记录 |
| `yun-xue-tang-short-catalog-v1` | 短课程时长队列缓存(TTL 5 分钟) |
旧版本(v2.8.0 之前)把所有状态整块存在 `localStorage` 的 `yun-xue-tang-batch-v2` 里,
包括「是否在跑」。现在这个键只在启动时做一次性迁移:只迁进度(已完成书目、
待重试、页码、目标目录),**不再恢复运行状态与当前课程**,迁移完即删除。
无头运行时这些键存在 `./.run-profile/` 下的浏览器 profile 里(不在仓库、不入库),
删掉该目录即等于「清空登录态 + 重置进度」。
公用电脑请不要勾选「记住密码」;面板上的「清除密码」可随时删除本机保存的凭据。
@@ -119,7 +346,7 @@ docs/evidence/ 实跑日志与接口证据
- 直接改 URL 或刷新课程页时,脚本优先用 URL 里的 `kngId` 校验课程;只有 URL 没有 id、
且页面标题超过 30 秒仍是 `loading...` 时才可能误判并回到列表。从列表正常进入不受影响。
- 验证码、滑块、拼图类验证需要人工完成,脚本不会绕过。
- 平台存在同名课程(同一门课出现在多个目录)。脚本按课程 id 精确点击,但完成/失败记录仍沿用
- 平台存在同名课程(同一门课出现在多个目录)。脚本按课程 id 精确点击,但完成/重试记录仍沿用
按标题去重的旧逻辑,同名课程不会重复安排。
- 平台改版(目录结构、弹窗、倒计时文案、列表接口字段、完成文案变化)可能导致识别失败,
需要更新选择器/完成判定。
@@ -140,6 +367,14 @@ v2.6.0 新增「优先短课程(时长正序)」:真实站点读取 5148
实跑记录与 3 个回归用例,见 [`docs/evidence/short-course-evidence.txt`](docs/evidence/short-course-evidence.txt);
面板效果见 [`docs/screenshots/panel-short.png`](docs/screenshots/panel-short.png)。
v2.8.0 状态分层重构:刷课开关不再进 localStorage(修「还没登录就开始刷课」)、字段名语义化、
短课程模式下页码导航所有权归一到 `chooseShortCourse`(省掉每次多跳一页+白等 3.5 秒)。
v2.7.0 修复「进入课程有概率不自动播放」和「学完后不转下一门」:新增单视频/音频/课件播放页识别,
完成判定同时支持 `已完成 x/y`、`已完成 N%`、`已完成学习`;真机复现、修复前后对比与回归结果见
[`docs/evidence/completion-next-evidence.txt`](docs/evidence/completion-next-evidence.txt)。
无头运行(Linux 服务器 / Windows 无人值守):新增 `runner/`,自己起无头 Chromium + CDP 注入,
持久化登录、掉登录自动重登、崩溃自愈;环境自检、真实刷课、断线重启、优雅退出的实跑记录见
[`docs/evidence/headless-linux-evidence.txt`](docs/evidence/headless-linux-evidence.txt),
平台差异与 Windows 侧适配见其中「九、跨平台适配」一节。
+4 -4
View File
@@ -35,16 +35,16 @@ const common = {
target: ['chrome80', 'firefox78', 'safari13'],
minify,
charset: 'utf8',
// __YT_VERSION__ 由 src/config.js 引用,构建时替换成 package.json 的版本号
define: { __YT_VERSION__: JSON.stringify(version) },
// __YUN_XUE_TANG_VERSION__ 由 src/config.js 引用,构建时替换成 package.json 的版本号
define: { __YUN_XUE_TANG_VERSION__: JSON.stringify(version) },
// 用原生 import/export + format=iife,esbuild 不会注入 __export 等辅助代码。
logLevel: 'info',
};
// src/meta.js 里的 @version 写成 __YT_VERSION__,由这里按 package.json 替换
// src/meta.js 里的 @version 写成 __YUN_XUE_TANG_VERSION__,由这里按 package.json 替换
async function bannerText() {
const raw = await readFile(META, 'utf8');
return raw.replace('__YT_VERSION__', version).trimEnd() + '\n';
return raw.replace('__YUN_XUE_TANG_VERSION__', version).trimEnd() + '\n';
}
const buildOptions = (banner) => ({ ...common, banner: { js: banner }, outfile: OUT });
+82 -3
View File
@@ -13,9 +13,10 @@
| `serve.mjs` | 本地 HTTP 服务,向浏览器提供源码与版本哈希(127.0.0.1:8899) |
| `dev-loader.user.js` | Tampermonkey 里的薄加载器,轮询版本、释放旧实例、注入新实例 |
| `start-dev.cmd` | 双击启动服务 |
| `check.mjs` | `npm run check` 的实现:自动遍历 `runner/`、`dev/` 与顶层文件跑 `node --check`,同时检查 `.cmd` 必须是纯 ASCII + CRLF(cmd.exe 逐字节按代码页读批处理,中文和裸 LF 会让行偏移错位);新增模块不用再手改命令 |
原理:加载器每 1 秒请求 `/version`,发现哈希变化就调用旧实例暴露的
`window.__ytDispose()`(清定时器 / 监听器 / 面板),再把新源码以 `<script>` 形式注入页面主世界。
`window.__yunXueTangDispose()`(清定时器 / 监听器 / 面板),再把新源码以 `<script>` 形式注入页面主世界。
因为脚本依赖页面里的 `__vue__`(登录组件),注入必须发生在主世界,不能走普通沙箱。
## 一次性安装
@@ -32,10 +33,88 @@
- 改完 `src/` 下的模块保存 → `npm run build:watch` 自动重新打包,约 1 秒内页面控制台打印
`[云学堂·热加载] 热更新 → <新哈希>`,面板会重建,视频播放不中断。
- 批量刷课的进度存在 `localStorage`(`yt-batch-v2`),热替换 / 刷新都不会丢。
- 列表刷课的进度存在 `localStorage`(`yun-xue-tang-batch-v2`),热替换 / 刷新都不会丢。
- 改坏了(语法错误):构建失败,加载器会拒绝注入并弹出左下角红条提示,**旧版本继续运行**,修好再保存即可。
- 想完全回到「手动刷新才生效」:把加载器里的 `MODE` 改成 `'reload'`。
## 真机测试
在**真实浏览器 + 真实云学堂页面**上验证脚本,不靠 Node 里的 DOM 桩。
```bash
npm run build # 先出产物
npm run test:real # 有界面 Chrome,能看见面板真实渲染
npm run test:real:headless # 无头模式(CI / 无人值守)
node dev/real-test.mjs --keep # 跑完不关浏览器,便于人工复核
```
三个真机脚本(`real-test` / `real-e2e` / `real-run`)会自动适配当前平台:
没有图形会话时强制 `--headless=new`(即使没传 `--headless`),并补上该平台需要的参数
(Linux:`--no-sandbox --disable-setuid-sandbox --disable-dev-shm-usage`;Windows:不弹崩溃恢复气泡),
因此可以原样在无图形化服务器 / 容器 / CI / Windows 后台里跑。平台判断复用
`runner/platform.mjs`,不在这里重复实现。
> 想在生产环境长期无头挂机(持久化登录、掉登录自动重登、崩溃自愈),用 `runner/headless.mjs`,
> 见主 README 的「无头运行(Linux / Windows 服务器)」。
原理:用独立临时用户目录启动 Chrome(不影响日常配置),开 CDP 端口后新建标签页打开
`https://kfmic.yunxuetang.cn/login.html`,把 `yun-xue-tang-assistant.user.js` 注入页面主世界
(等价 Tampermonkey `@grant none`),然后在真实 DOM 上断言:
| 断言 | 说明 |
| --- | --- |
| 面板渲染 | `#yun-xue-tang-panel` 可见、`position:fixed`、距右下各 16px、含密码框与 4 个按钮 |
| 版本号 | `#yun-xue-tang-version` = `v2.7.0`(与 package.json 一致) |
| 页面识别 | 真实登录页 `isLoginPage() === true`、`readSummary/readCountdown` 安全返回 `null` |
| 点击不崩 | 真点「一键登录并刷课」后脚本仍存活、无自身 error 日志 |
| 持久化 | 真实 `localStorage` 可读写 |
| 热替换 | `__yunXueTangDispose()` 后真实 DOM 面板移除、`__yunXueTangAuto` 被删;再注入面板唯一 |
| 路由 | SPA 内改 `location.hash` 后 `route()` 自动跟随,无需重新注入 |
| 整页重定向 | 未登录访问 `#/list` 被站点跳回登录页(新 document),脚本无残留、重注入后正常 |
产物:截图存到 `docs/screenshots/real-chrome-login.png`。
需要 Node 22+(全局 `WebSocket` / `fetch`),无需 puppeteer / playwright。
测试**只读**:不填账号密码、不点登录、不改线上数据。
## 真机登录 / 进课测试(E2E)
带**真实账号**跑完整媒体链路。凭据从环境变量读,不写进代码、不打印明文:
```bash
# 环境变量(已在当前环境配置)
# YUN_XUE_TANG_USR 员工邮箱 / 账号
# YUN_XUE_TANG_PWD 密码
npm run test:e2e # 登录 + 列表;默认只读,不碰学习进度
npm run test:e2e:play # 额外进入最短的未学完课程,采样 25 秒后立即暂停
npm run test:e2e:play -- --seconds 60
node dev/real-e2e.mjs --headless # 无头
node dev/real-e2e.mjs --keep # 跑完不关浏览器
```
覆盖的断言(`--play` 时是 19 项,否则 12 项):
| 阶段 | 断言 |
| --- | --- |
| 登录页 | 脚本注入、识别到账号/密码框、`setNativeValue` 写入真实输入框值一致、隐私政策勾选 |
| 登录 | 真点「一键登录并刷课」后**真正登录成功**(离开登录页);无脚本 error |
| 新 document | 登录是整页跳转,模拟 Tampermonkey 按 `@match` 重新注入后面板恢复 |
| 列表 | 16 张卡片(共 322 页)、`scanCards` 标题/状态解析、Vue 组件 `kngListData` 可读、`studyHours` 时长可用 |
| 进课(`--play`)| 挑**最短的未学完课程**进入(减少对真实进度影响)、`readSummary`/`readCountdown`/`lessonItems` 读到真实数据 |
| 播放(`--play`)| 真实 `<video>` 被接管:`muted=true`、`playbackRate=1`、`paused=false`、`currentTime` 真实推进 |
| 收尾 | 立即 `pauseAllMedia` + `S.batchRunning=false`,`__yunXueTangDispose()` 后面板/API 清理干净 |
行为与安全:
- 不加 `--play` 时会在登录成功后**立即停用列表刷课**(清 `yun-xue-tang-auto-start-after-login`、`S.batchRunning=false`),
避免在真实账号上意外推进课程。
- 加 `--play` 只采样默认 25 秒就暂停并释放,不会把整节课刷完;结束时会打印进度快照(如
`进入前「已完成2/3」→ 采样后「已完成2/3」`)便于核对是否被改动。
- 实测:进课 `2025坚持的力量`(273s 的第 3 节)采样 25 秒,`currentTime` 推进到 63s,进度保持 `2/3` 未变。
> 登录后收集的日志里会出现一条 `填写账号密码后,点「一键登录并刷课」`,这是
> `loginPageTick` 轮询刷新状态文案造成的噪声(发生在点击登录之前),不影响登录结果。
## 常见问题
| 现象 | 处理 |
@@ -44,7 +123,7 @@
| 改完没反应 | 看控制台是否有 `热更新` 日志;确认 `npm run build:watch` 在跑,改的是 `src/` 下的模块 |
| 页面出现两个面板 | 旧完整脚本没停用,去 Tampermonkey 停用它 |
| 端口冲突 | `node dev/serve.mjs 8900`,同时把加载器里的 `SERVER` 常量改成对应端口 |
| 服务没开也想用 | 加载器回退到上次缓存的源码(`GM_getValue('yt-dev-src')`) |
| 服务没开也想用 | 加载器回退到上次缓存的源码(`GM_getValue('yun-xue-tang-dev-src')`) |
## 关闭开发模式
+115
View File
@@ -0,0 +1,115 @@
#!/usr/bin/env node
/**
* 静态检查:对仓库里会直接 `node` 执行的脚本跑 `node --check`,
* 并对批处理文件做两项硬性检查(这两项一旦坏掉就极难排查):
* 1. 必须是纯 ASCII —— cmd.exe 按当前代码页逐字节读批处理,
* 多字节字符(中文)会让行偏移错位,报出 "'鍏?npm' is not recognized" 这种怪错;
* 2. 必须用 CRLF 行尾 —— 只有 LF 时 cmd.exe 会把上一行的尾部当成命令的一部分,
* 同样报出莫名其妙的 "'01' is not recognized"。
*
* 以前 package.json 的 check 脚本是一长串 `node --check a && node --check b && …`,
* 每次新增模块都要手改那行命令(漏了就默默不检查)。现在改为自动遍历目录。
*
* 用法:npm run check
*/
import fs from 'node:fs';
import path from 'node:path';
import { spawnSync } from 'node:child_process';
import { fileURLToPath } from 'node:url';
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
/** 要遍历的目录(JS 与 bat 一起收) */
const DIRS = ['runner', 'dev'];
/** 顶层要单独检查的文件(runner.config.mjs 是配置文件,也要求语法正确) */
const FILES = ['build.mjs', 'runner.config.mjs', 'yun-xue-tang-assistant.user.js'];
const TOP_CMD = ['start-headless.cmd'];
const SKIP_DIRS = new Set(['node_modules', '.git', '.run-profile', 'run-logs', '.run-tmp']);
function walk(dir, out = []) {
for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
const p = path.join(dir, ent.name);
if (ent.isDirectory()) {
if (!SKIP_DIRS.has(ent.name)) walk(p, out);
} else if (/\.m?js$|\.cmd$|\.bat$/i.test(ent.name)) {
out.push(p);
}
}
return out;
}
const jsTargets = [];
const cmdTargets = [];
for (const d of DIRS) {
const dir = path.join(ROOT, d);
if (fs.existsSync(dir)) {
for (const f of walk(dir)) {
if (/\.m?js$/.test(f)) jsTargets.push(f);
else cmdTargets.push(f);
}
}
}
for (const f of FILES) {
const p = path.join(ROOT, f);
if (fs.existsSync(p)) jsTargets.push(p);
}
for (const f of TOP_CMD) {
const p = path.join(ROOT, f);
if (fs.existsSync(p)) cmdTargets.push(p);
}
let failed = 0;
// ---- 1. JS 语法 ----
for (const file of jsTargets.sort()) {
const r = spawnSync(process.execPath, ['--check', file], { encoding: 'utf8' });
if (r.status !== 0) {
failed++;
console.error(' FAIL ' + path.relative(ROOT, file));
console.error((r.stderr || '').trim());
}
}
// ---- 2. 批处理文件:纯 ASCII + CRLF ----
for (const file of cmdTargets.sort()) {
const rel = path.relative(ROOT, file);
const buf = fs.readFileSync(file);
const bad = [];
const nonAscii = [];
for (let i = 0; i < buf.length; i++) {
if (buf[i] > 0x7f) nonAscii.push(i);
}
if (nonAscii.length) {
const first = nonAscii[0];
const ctx = buf.slice(Math.max(0, first - 20), first + 20).toString('utf8');
bad.push('含 ' + nonAscii.length + ' 个非 ASCII 字节(首次出现在偏移 ' + first + ',上下文 “' + ctx + '”);'
+ 'cmd.exe 按代码页逐字节读取,中文会让行偏移错位');
}
let lf = 0;
let crlf = 0;
for (let i = 0; i < buf.length; i++) {
if (buf[i] === 0x0a) {
lf++;
if (i > 0 && buf[i - 1] === 0x0d) crlf++;
}
}
if (lf !== crlf) {
bad.push('有 ' + (lf - crlf) + ' 处裸 LF 行尾(共 ' + lf + ' 个 LF / ' + crlf + ' 个 CRLF);'
+ 'cmd.exe 会把上一行尾部当成命令的一部分');
}
if (bad.length) {
failed++;
console.error(' FAIL ' + rel);
for (const b of bad) console.error(' - ' + b);
}
}
const total = jsTargets.length + cmdTargets.length;
if (failed) {
console.error('\n静态检查:' + failed + '/' + total + ' 个文件失败');
process.exit(1);
}
console.log('静态检查:' + total + '/' + total + ' 个文件通过'
+ '(JS ' + jsTargets.length + ' · 批处理 ' + cmdTargets.length + ')');
+9 -9
View File
@@ -31,7 +31,7 @@
const MODE = 'hot'; // 'hot' | 'reload'
const POLL_MS = 1000; // 轮询间隔
const RETRY_MS = 15000; // 服务不可用时的重试间隔
const CACHE_KEY = 'yt-dev-src'; // 最近一次成功拉取的源码
const CACHE_KEY = 'yun-xue-tang-dev-src'; // 最近一次成功拉取的源码
const TAG = '[云学堂·热加载]';
const isTop = (function () {
try { return window.top === window.self; } catch (e) { return true; }
@@ -78,8 +78,8 @@
function disposePrevious() {
try {
if (page && typeof page.__ytDispose === 'function') {
page.__ytDispose();
if (page && typeof page.__yunXueTangDispose === 'function') {
page.__yunXueTangDispose();
return true;
}
} catch (e) {
@@ -91,7 +91,7 @@
function inject(src) {
const el = document.createElement('script');
el.type = 'text/javascript';
el.setAttribute('data-yt-dev-injected', '1');
el.setAttribute('data-yun-xue-tang-dev-injected', '1');
el.textContent = src;
(document.head || document.documentElement).appendChild(el);
el.remove();
@@ -109,11 +109,11 @@
return false;
}
const hadInstance = !!(page && (page.__ytAuto || document.getElementById('yt-auto-panel')));
const hadInstance = !!(page && (page.__yunXueTangAuto || document.getElementById('yun-xue-tang-panel')));
const disposed = disposePrevious();
// 首次注入不存在旧实例,直接注入;之后若旧实例没有 __ytDispose 或指定了 reload 模式,才刷新整页
// 首次注入不存在旧实例,直接注入;之后若旧实例没有 __yunXueTangDispose 或指定了 reload 模式,才刷新整页
if (hadInstance && (MODE === 'reload' || !disposed)) {
console.log(TAG, MODE === 'reload' ? '源码变更,刷新页面' : '旧实例无 __ytDispose,刷新页面');
console.log(TAG, MODE === 'reload' ? '源码变更,刷新页面' : '旧实例无 __yunXueTangDispose,刷新页面');
location.reload();
return false;
}
@@ -123,10 +123,10 @@
GM_setValue(CACHE_KEY, src);
clearBadge();
console.log(TAG, '已注入 ' + src.length + ' 字节源码');
if (isTop && !page.__ytAuto && !document.getElementById('yt-auto-panel')) {
if (isTop && !page.__yunXueTangAuto && !document.getElementById('yun-xue-tang-panel')) {
// 站点 CSP 若禁掉 inline script,退一步用页面主世界的 eval(需要 unsafe-eval)
try { page.eval(src); } catch (e) { /* 两种方式都不行再看下一条 */ }
if (!page.__ytAuto && !document.getElementById('yt-auto-panel')) {
if (!page.__yunXueTangAuto && !document.getElementById('yun-xue-tang-panel')) {
badge('源码已注入但未生效:页面 CSP 可能拦截了注入,请查看控制台');
}
}
+88
View File
@@ -0,0 +1,88 @@
// 极简 CDP 客户端:Node 18+ 原生 WebSocket,无需 puppeteer / playwright。
// 只实现本项目真机测试用到的部分:send / waitEvent / 事件堆积。
// Linux 无图形化服务器 / 容器的浏览器探测与启动参数统一放在 runner/browser.mjs,
// 这里一并转发,避免 dev 测试脚本和 runner 两套逻辑跑偏。
import fs from 'node:fs';
import {
resolveBrowser as _resolveBrowser, safetyArgs as _safetyArgs, hasDisplay,
} from '../runner/browser.mjs';
export { cleanStaleSingleton } from '../runner/browser.mjs';
export async function connect(wsUrl) {
const ws = new WebSocket(wsUrl);
await new Promise((res, rej) => {
ws.addEventListener('open', res, { once: true });
ws.addEventListener('error', rej, { once: true });
});
let id = 0;
const pending = new Map();
const events = [];
const waiters = [];
const listeners = [];
ws.addEventListener('message', (ev) => {
const msg = JSON.parse(ev.data);
if (msg.id != null && pending.has(msg.id)) {
const { res, rej } = pending.get(msg.id);
pending.delete(msg.id);
if (msg.error) rej(new Error(msg.error.message));
else res(msg.result);
return;
}
events.push(msg);
for (const fn of listeners) {
try { fn(msg); } catch (e) { /* 忽略订阅者异常 */ }
}
for (let i = waiters.length - 1; i >= 0; i--) {
if (waiters[i].match(msg)) waiters.splice(i, 1)[0].res(msg);
}
});
const send = (method, params = {}) => new Promise((res, rej) => {
const mid = ++id;
pending.set(mid, { res, rej });
ws.send(JSON.stringify({ id: mid, method, params }));
});
const waitEvent = (name, timeoutMs = 30000) => new Promise((res, rej) => {
const timer = setTimeout(() => rej(new Error('等待事件超时: ' + name)), timeoutMs);
waiters.push({
match: (m) => m.method === name,
res: (m) => { clearTimeout(timer); res(m.params); },
});
});
const onEvent = (fn) => { listeners.push(fn); };
return { ws, send, waitEvent, onEvent, events, close: () => { try { ws.close(); } catch (e) {} } };
}
export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
export async function httpJson(url, method = 'GET') {
const r = await fetch(url, { method });
const t = await r.text();
try { return JSON.parse(t); } catch (e) { return t; }
}
// ---- Linux 无图形化服务器 / 容器适配 ----
// 无显示环境:Linux 上没有 DISPLAY / WAYLAND_DISPLAY 就只能无头
// (跑在 Xvfb 下时 Xvfb 会设置 DISPLAY,因此这里只判断变量)
export function forceHeadless() {
return !hasDisplay();
}
// 按环境变量 / 常见安装位置找到真实存在的浏览器;找不到时返回 null
export function findChrome(candidates) {
return _resolveBrowser() || candidates.filter(Boolean).find(function (p) {
try { return fs.statSync(p).isFile(); } catch (e) { return false; }
}) || null;
}
// 必须追加给浏览器的平台安全参数(容器 /dev/shm 小、root 无沙箱)
export function safetyArgs() {
return _safetyArgs();
}
+421
View File
@@ -0,0 +1,421 @@
#!/usr/bin/env node
/**
* 真机端到端测试:真实 Chrome + 真实云学堂账号,跑「登录 → 列表 → 进课 → 播放」全链路。
*
* 账号来源(环境变量,不写进代码、不打印明文):
* YUN_XUE_TANG_USR 员工邮箱 / 账号
* YUN_XUE_TANG_PWD 密码
*
* 用法:
* node dev/real-e2e.mjs 登录 + 列表断言(不动任何课程进度)
* node dev/real-e2e.mjs --play 额外进入最短的一门课,采样播放 N 秒后停止
* node dev/real-e2e.mjs --play --seconds 60
* node dev/real-e2e.mjs --headless 无头模式
* node dev/real-e2e.mjs --keep 跑完不关浏览器(便于人工复核)
* node dev/real-e2e.mjs --shotdir X 截图目录
*
* 安全约束(刻意保守):
* - 只有显式传 --play 才会进入课程页;默认全程只读,不改任何学习进度。
* - --play 默认只采样 25 秒,采完立刻 pause + 释放脚本,不会把整节课刷完。
* - 结束前会打印本轮进度变化(开课前 / 结束后 的 已完成 x/y),便于核对影响。
*/
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import { spawn } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { connect, sleep, httpJson, findChrome, forceHeadless, safetyArgs } from './real-cdp.mjs';
const HERE = path.dirname(fileURLToPath(import.meta.url));
const ROOT = path.resolve(HERE, '..');
const SCRIPT_SRC = fs.readFileSync(path.join(ROOT, 'yun-xue-tang-assistant.user.js'), 'utf8');
const argv = process.argv.slice(2);
const flag = (n) => argv.includes(n);
const opt = (n, d) => {
const i = argv.indexOf(n);
return i >= 0 && argv[i + 1] ? argv[i + 1] : d;
};
const USR = process.env.YUN_XUE_TANG_USR || '';
const PWD = process.env.YUN_XUE_TANG_PWD || '';
const PLAY = flag('--play');
const SAMPLE_SECONDS = Number(opt('--seconds', 25));
const HEADLESS = flag('--headless') || process.env.YUN_XUE_TANG_HEADLESS === '1';
const KEEP = flag('--keep');
const PORT = Number(process.env.YUN_XUE_TANG_CDP_PORT || 9334);
const SHOT_DIR = opt('--shotdir', path.join(ROOT, 'docs/screenshots'));
const ORIGIN = 'https://kfmic.yunxuetang.cn';
const CANDIDATES = [
process.env.YUN_XUE_TANG_CHROME,
'C:/Program Files/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
'/usr/bin/google-chrome',
'/usr/bin/chromium',
].filter(Boolean);
const CHROME = findChrome(CANDIDATES);
const results = [];
const consoleLogs = [];
const log = (...a) => console.log(...a);
function check(name, ok, detail) {
results.push({ name, ok: !!ok, detail });
log((ok ? ' PASS ' : ' FAIL ') + name + (detail === undefined ? '' : ' → ' + JSON.stringify(detail)));
}
if (!CHROME) { console.error('找不到 Chrome/Edge,可用 YUN_XUE_TANG_CHROME=... 指定'); process.exit(2); }
if (!USR || !PWD) { console.error('缺少环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD'); process.exit(2); }
if (typeof WebSocket !== 'function' || typeof fetch !== 'function') {
console.error('需要 Node 22+,当前 ' + process.version);
process.exit(2);
}
log('[E2E] 账号:' + USR.slice(0, 3) + '***' + USR.slice(-2) + ' 密码:' + '*'.repeat(Math.min(PWD.length, 8)) + '(长度 ' + PWD.length + ')');
// Linux 无图形化服务器:没有 DISPLAY 时强制无头,并补容器/root 必需参数
const HEADLESS_ONLY = HEADLESS || forceHeadless();
log('[E2E] 浏览器:' + CHROME + (HEADLESS_ONLY ? '(headless)' : '(有界面)') + ' 进课采样:' + (PLAY ? SAMPLE_SECONDS + ' 秒' : '否(只读)'));
const userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'yun-xue-tang-e2e-'));
const args = [
`--remote-debugging-port=${PORT}`,
`--user-data-dir=${userDataDir}`,
'--no-first-run', '--no-default-browser-check', '--disable-sync',
'--disable-background-timer-throttling', '--disable-renderer-backgrounding',
'--disable-backgrounding-occluded-windows',
'--autoplay-policy=no-user-gesture-required',
'--window-size=1360,940',
].concat(safetyArgs(), ['about:blank']);
if (HEADLESS_ONLY) args.unshift('--headless=new');
let chrome = null;
let cdp = null;
try {
chrome = spawn(CHROME, args, { stdio: 'ignore', windowsHide: true });
let version = null;
for (let i = 0; i < 100; i++) {
try { const v = await httpJson(`http://127.0.0.1:${PORT}/json/version`); if (v && v.webSocketDebuggerUrl) { version = v; break; } } catch (e) {}
await sleep(250);
}
if (!version) throw new Error('Chrome CDP 未就绪');
log('[E2E] ' + version.Browser);
const target = await httpJson(`http://127.0.0.1:${PORT}/json/new?${encodeURIComponent(ORIGIN + '/login.html')}`, 'PUT');
cdp = await connect(target.webSocketDebuggerUrl);
await cdp.send('Page.enable');
await cdp.send('Runtime.enable');
await cdp.send('Log.enable');
cdp.onEvent((m) => {
if (m.method === 'Runtime.consoleAPICalled') {
const text = (m.params.args || []).map((a) => (a.value !== undefined ? a.value : a.description || '')).join(' ');
consoleLogs.push({ type: m.params.type, text: String(text) });
} else if (m.method === 'Log.entryAdded') {
consoleLogs.push({ type: m.params.entry.level, text: m.params.entry.text });
}
});
const evalJS = async (expr) => {
const r = await cdp.send('Runtime.evaluate', { expression: expr, returnByValue: true, awaitPromise: true, userGesture: true });
if (r.exceptionDetails) {
const d = r.exceptionDetails;
throw new Error((d.exception && d.exception.description) || d.text);
}
return r.result.value;
};
const json = async (expr) => JSON.parse(await evalJS(expr));
const waitFor = async (exprFn, timeoutMs, label) => {
const started = Date.now();
while (Date.now() - started < timeoutMs) {
try { if (await evalJS(exprFn)) return true; } catch (e) {}
await sleep(500);
}
return false;
};
const shot = async (name) => {
try {
fs.mkdirSync(SHOT_DIR, { recursive: true });
const s = await cdp.send('Page.captureScreenshot', { format: 'png' });
const f = path.join(SHOT_DIR, name);
fs.writeFileSync(f, Buffer.from(s.data, 'base64'));
return path.relative(ROOT, f);
} catch (e) { return '截图失败: ' + e.message; }
};
const loaded = cdp.waitEvent('Page.loadEventFired', 45000).catch(() => null);
await cdp.send('Page.navigate', { url: ORIGIN + '/login.html' });
await loaded;
await sleep(2000);
// ---------- 1. 登录页 + 注入 ----------
await evalJS(SCRIPT_SRC);
await sleep(1000);
const loginInfo = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
return {
url: location.href,
title: document.title,
isLoginPage: a.isLoginPage(),
panel: !!document.getElementById('yun-xue-tang-panel'),
fields: (() => { const f = a.loginFields(); return { user: !!f.user, pwd: !!f.pwd, ph: f.user ? f.user.placeholder : null }; })(),
};
})())`);
check('登录页加载 + 脚本注入', loginInfo.isLoginPage === true && loginInfo.panel === true, loginInfo.url);
check('识别到账号/密码输入框', loginInfo.fields.user && loginInfo.fields.pwd, loginInfo.fields);
// ---------- 2. 填账号密码(走真实的 setNativeValue + Vue 双向绑定) ----------
const filled = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
const u = ${JSON.stringify(USR)};
const p = ${JSON.stringify(PWD)};
document.getElementById('yun-xue-tang-login-user').value = u;
document.getElementById('yun-xue-tang-login-pass').value = p;
const okForm = a.fillLoginForm(u, p);
const f = a.loginFields();
return {
okForm,
userValueLen: f.user ? f.user.value.length : -1,
pwdValueLen: f.pwd ? f.pwd.value.length : -1,
userMatched: f.user ? f.user.value === u : false,
pwdMatched: f.pwd ? f.pwd.value === p : false,
panelUser: document.getElementById('yun-xue-tang-login-user').value.length,
};
})())`);
check('账号密码写入真实输入框', filled.okForm === true && filled.userMatched === true && filled.pwdMatched === true,
{ 长度: [filled.userValueLen, filled.pwdValueLen], 一致: [filled.userMatched, filled.pwdMatched] });
const agree = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
const before = [...document.querySelectorAll('label')].filter(x => /已阅读并同意|隐私政策/.test(x.innerText||''))
.map(x => { const c = x.querySelector('input[type=checkbox]'); return c ? c.checked : null; });
const ok = a.checkLoginAgreement ? a.checkLoginAgreement() : 'no-api';
const after = [...document.querySelectorAll('label')].filter(x => /已阅读并同意|隐私政策/.test(x.innerText||''))
.map(x => { const c = x.querySelector('input[type=checkbox]'); return c ? c.checked : null; });
return { before, after, ok };
})())`);
check('隐私政策勾选处理正常', agree.ok === true || agree.ok === 'no-api', agree);
// ---------- 3. 点「一键登录并刷课」,等真实登录成功 ----------
// 注意:这个按钮会写 LS_PENDING,登录后自动开启列表刷课(脚本设计行为)。
// 默认(不加 --play)测完登录马上刹住,避免动到真实学习进度。
await evalJS(`(document.getElementById('yun-xue-tang-oneclick').click(), true)`);
const loginOk = await waitFor(`(() => {
if (/\\/login/.test(location.pathname)) return false;
if (!document.body) return false;
if (document.querySelector('input[type=password]')) return false;
return true;
})()`, 45000);
await sleep(2000);
const afterLogin = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
const status = (document.getElementById('yun-xue-tang-status') || {}).textContent || '';
const bodyText = document.body ? (document.body.innerText || '').replace(/\\s+/g, ' ').slice(0, 400) : '';
return {
url: location.href, title: document.title, status,
alive: typeof window.__yunXueTangAuto,
isLoginPage: a ? a.isLoginPage() : null,
captcha: /验证码|滑块|安全验证/.test(bodyText),
errText: (bodyText.match(/(用户名密码错误|账号或密码错误|密码错误|账号不存在|登录失败)[^ ]{0,40}/) || [''])[0],
panel: !!document.getElementById('yun-xue-tang-panel'),
};
})())`);
check('真实登录成功(离开登录页)', loginOk === true, afterLogin);
const scriptErrs = () => consoleLogs.filter((l) => l.type === 'error' && /云学堂助手/.test(l.text));
check('登录流程无脚本 error', scriptErrs().length === 0, scriptErrs().map((e) => e.text.slice(0, 140)));
log(' 截图:' + await shot('e2e-01-after-login.png'));
// 登录是整页跳转(新 document),真实 Tampermonkey 会按 @match 重新注入;
// 这里模拟同样的行为。
if ((await evalJS('typeof window.__yunXueTangAuto')) === 'undefined') {
log('[E2E] 登录后是新 document(' + afterLogin.url + '),重新注入脚本');
await evalJS(SCRIPT_SRC);
await sleep(1200);
}
check('登录后新 document 上脚本已注入', (await evalJS('typeof window.__yunXueTangAuto')) === 'object', await evalJS('document.title || location.pathname'));
if (!PLAY) {
// 立即刹住列表刷课:清 pending 标记 + 关闭 running,防止在真实账号上推进课程
const halted = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
try { localStorage.removeItem('yun-xue-tang-auto-start-after-login'); } catch (e) {}
if (a) { a.S.batchRunning = false; a.S.batchFinished = false; a.S.activeCourse = null; a.S.coursePhase = 'idle'; a.save(); }
return { running: a ? a.S.batchRunning : null, current: a ? a.S.activeCourse : null };
})())`);
check('默认只读:登录后立即停用列表刷课', halted.running === false && halted.current === null, halted);
}
// ---------- 4. 列表页断言 ----------
const listNavStarted = Date.now();
await evalJS(`(location.href = 'https://kfmic.yunxuetang.cn/kng/#/list', true)`);
await cdp.waitEvent('Page.loadEventFired', 30000).catch(() => null);
await sleep(2500);
// 换页后可能又是新 document,重新注入
if ((await evalJS('typeof window.__yunXueTangAuto')) === 'undefined') {
log('[E2E] 列表页是新 document,重新注入脚本');
await evalJS(SCRIPT_SRC);
await sleep(1000);
}
if (!PLAY) {
// 新 document 里 S 从 sessionStorage 恢复了 batchRunning=true,再次刹住
await evalJS(`(() => {
try { localStorage.removeItem('yun-xue-tang-auto-start-after-login'); } catch (e) {}
const a = window.__yunXueTangAuto;
if (a) { a.S.batchRunning = false; a.S.activeCourse = null; a.S.coursePhase = 'idle'; a.save(); }
return true;
})()`);
await sleep(400);
}
const listReady = await waitFor(`!!window.__yunXueTangAuto && document.querySelectorAll('li.kng-list-new__item').length > 0`, 45000);
await sleep(1500);
const listInfo = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto; const cards = a.scanCards();
const vm = (() => {
const ul = document.querySelector('ul.kng-list-new');
let v = ul && ul.__vue__;
while (v && !(v.kngListData && v.kngListData.length)) v = v.$parent;
return v || null;
})();
const data = (vm && vm.kngListData) || [];
return {
url: location.href,
route: a.route(),
cards: cards.length,
page: a.currentPage(),
maxPage: a.maxPageNumber(),
first3: cards.slice(0, 3).map((c) => ({ title: c.title.slice(0, 30), status: c.status })),
vmCount: data.length,
vmFirst: data.slice(0, 3).map((d) => ({ title: String(d.title || d.name || '').slice(0, 26), studyHours: d.studyHours, id: String(d.id || d.kngId || '').slice(0, 12) })),
pending: cards.filter((c) => c.title && !/已学完|已完成|已学习/.test(c.status)).length,
};
})())`);
check('列表页卡片渲染', listReady === true && listInfo.cards > 0, { 卡片数: listInfo.cards, 页码: listInfo.page + '/' + listInfo.maxPage });
check('scanCards 解析标题与状态', listInfo.first3.every((c) => c.title.length > 0), listInfo.first3);
check('列表 Vue 组件可读(时长来源)', listInfo.vmCount > 0, { 条数: listInfo.vmCount, 样例: listInfo.vmFirst });
const dur = listInfo.vmFirst.filter((d) => Number.isFinite(d.studyHours) && d.studyHours > 0);
check('studyHours 时长可用(短课程优先的数据源)', dur.length > 0, dur);
// ---------- 5. 可选:真实进课 + 采样播放 ----------
let beforeProgress = null;
let playInfo = null;
if (PLAY) {
// 选一门「最短」的未学完课程,尽量减小对真实进度的影响
const pick = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
const cards = a.scanCards();
const ul = document.querySelector('ul.kng-list-new');
let v = ul && ul.__vue__;
while (v && !(v.kngListData && v.kngListData.length)) v = v.$parent;
const data = (v && v.kngListData) || [];
const byTitle = new Map();
for (const d of data) byTitle.set(String(d.title || d.name || '').trim(), d);
const cand = cards
.filter((c) => c.title && !/已学完|已完成|已学习/.test(c.status))
.map((c) => ({ c, d: byTitle.get(c.title) }))
.filter((x) => x.d && Number(x.d.studyHours) > 0)
.sort((x, y) => Number(x.d.studyHours) - Number(y.d.studyHours));
if (!cand.length) {
const any = cards.find((c) => c.title && !/已学完|已完成|已学习/.test(c.status));
return any ? { title: any.title, studyHours: null, idx: any.i, fallback: true } : null;
}
return { title: cand[0].c.title, studyHours: Number(cand[0].d.studyHours), idx: cand[0].c.i };
})())`);
check('找到可学的最短课程', !!pick, pick);
if (pick) {
log('[E2E] 选课:' + pick.title + '(' + (pick.studyHours ? Math.round(pick.studyHours / 60) + ' 分钟' : '时长未知') + ')');
// 用脚本自己的 startCourse 走真实进课流程(会写 S.activeCourse 并点卡片)
await evalJS(`(() => {
const a = window.__yunXueTangAuto;
const card = a.scanCards().find((c) => c.i === ${pick.idx});
if (!card) return 'no-card';
a.startCourse(card);
return 'started';
})()`);
const entered = await waitFor(`window.__yunXueTangAuto && window.__yunXueTangAuto.route() === 'course' && /\\/play/.test(location.hash)`, 40000);
await sleep(2500);
const before = await json(`JSON.stringify((() => ({
url: location.hash,
summary: window.__yunXueTangAuto.readSummary(),
countdown: window.__yunXueTangAuto.readCountdown(),
lessons: window.__yunXueTangAuto.lessonItems().length,
active: window.__yunXueTangAuto.lessonItems().length ? (document.querySelector('.yxtulcdsdk-catalog .liactive') || {}).innerText || '' : '',
}))())`);
beforeProgress = before.summary && before.summary.text;
check('进入真实课程播放页', entered === true, before.url);
check('读取到课程汇总/目录', !!before.summary || before.lessons > 0, { 汇总: before.summary && before.summary.text, 目录: before.lessons });
// 触发「开始学习」并观察播放器
const play = await waitFor(`(() => {
const v = document.querySelector('video, audio');
return !!v && v.duration > 0;
})()`, 25000);
const t0 = Date.now();
// 让主循环自己动起来(模拟用户手动打开课程时的自动连播开关)
await evalJS(`(() => { window.__yunXueTangAuto.tick(); return true; })()`);
await sleep(SAMPLE_SECONDS * 1000);
playInfo = await json(`JSON.stringify((() => {
const v = document.querySelector('video, audio');
const a = window.__yunXueTangAuto;
return {
found: !!v,
muted: v ? v.muted : null,
paused: v ? v.paused : null,
rate: v ? v.playbackRate : null,
currentTime: v ? Math.round(v.currentTime) : null,
duration: v ? Math.round(v.duration) : null,
summary: a.readSummary(),
countdown: a.readCountdown(),
status: (document.getElementById('yun-xue-tang-status') || {}).textContent || '',
elapsedSec: Math.round((Date.now() - ${t0}) / 1000),
};
})())`);
check('播放器被找到并接管(静音 1x)', playInfo.found === true && playInfo.muted === true && playInfo.rate === 1, playInfo);
check('视频真实在播放(时间在走)', playInfo.paused === false && playInfo.currentTime > 0, { 已播到: playInfo.currentTime + 's / ' + playInfo.duration + 's' });
check('采样期间无脚本 error', scriptErrs().length === 0, scriptErrs().map((e) => e.text.slice(0, 140)));
log(' 截图:' + await shot('e2e-02-playing.png'));
// 立刻停手:暂停媒体 + 关闭批量 + dispose
await evalJS(`(() => {
const a = window.__yunXueTangAuto;
a.S.batchRunning = false;
a.save();
a.pauseAllMedia ? a.pauseAllMedia() : document.querySelectorAll('video, audio').forEach((x) => x.pause());
return true;
})()`);
await sleep(1200);
const stopped = await json(`JSON.stringify((() => {
const v = document.querySelector('video, audio');
return { paused: v ? v.paused : null, running: window.__yunXueTangAuto ? window.__yunXueTangAuto.S.batchRunning : null,
summary: window.__yunXueTangAuto ? window.__yunXueTangAuto.readSummary() : null };
})())`);
check('停止后媒体已暂停', stopped.paused === true && stopped.running === false, stopped);
}
}
// ---------- 6. 释放脚本,确认无残留 ----------
if (PLAY) {
const disposed = await json(`JSON.stringify((() => {
window.__yunXueTangDispose();
return { panel: !!document.getElementById('yun-xue-tang-panel'), api: typeof window.__yunXueTangAuto };
})())`);
check('dispose 后面板与 API 清理干净', disposed.panel === false && disposed.api === 'undefined', disposed);
}
log('\n[E2E] 脚本日志(' + consoleLogs.filter((l) => /云学堂助手/.test(l.text)).length + ' 条脚本相关):');
for (const l of consoleLogs.filter((x) => /云学堂助手/.test(x.text)).slice(-25)) log(' [' + l.type + '] ' + l.text.slice(0, 170));
if (beforeProgress) log('[E2E] 进度快照:进入前「' + beforeProgress + '」→ 采样后「' + (playInfo && playInfo.summary && playInfo.summary.text) + '」');
} catch (e) {
check('E2E 流程执行完毕', false, e && e.stack ? e.stack.split('\n').slice(0, 5).join(' | ') : String(e));
} finally {
if (cdp && !KEEP) cdp.close();
if (chrome && !KEEP) { try { chrome.kill(); } catch (e) {} }
if (!KEEP) { await sleep(700); try { fs.rmSync(userDataDir, { recursive: true, force: true }); } catch (e) {} }
else log('[E2E] --keep:浏览器保持打开 ' + userDataDir);
}
const failed = results.filter((r) => !r.ok);
log('\n===== E2E 结果:' + (results.length - failed.length) + '/' + results.length + ' 通过,失败 ' + failed.length + ' =====');
for (const f of failed) log(' FAIL ' + f.name + ' → ' + JSON.stringify(f.detail));
process.exit(failed.length ? 1 : 0);
+467
View File
@@ -0,0 +1,467 @@
#!/usr/bin/env node
/**
* 真机持续运行测试:跨章节 + 跨课程。
*
* 真实 Chrome + 真实账号,让脚本自己跑列表刷课,观察它能否
* 1) 在一门多课时课程里自动从第 N 节切到第 N+1 节(跨章节)
* 2) 一门课完成后回到列表、进下一门课(跨课程)
* 3) 每次整页跳转(新 document)后重新注入并接续运行
* 4) 全程视频持续推进、无脚本 error、没学完的课程按退避重试而不是被跳过
*
* 用法:
* node dev/real-run.mjs --scan 只登录 + 列表,打印所有卡片(只读)
* node dev/real-run.mjs --probe 8 读前 8 门课最短的「未学完」课的目录(不进播放,不动进度)
* node dev/real-run.mjs --max 2 --budget 15 跑批量,最多完成 2 门 / 最多 15 分钟
* node dev/real-run.mjs --title 坚持 --max 2 先把匹配标题的课程跑完,再自动跑下一门
* node dev/real-run.mjs --headless --keep 无头 / 跑完不关浏览器
* node dev/real-run.mjs --out run.json 时间线写到指定文件(默认临时目录)
*
* 注意:这个测试会**真实推进学习进度**(这就是它的目的)。
* 只读的登录/列表测试请看 dev/real-e2e.mjs。
*/
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import { spawn } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { connect, sleep, httpJson, findChrome, forceHeadless, safetyArgs } from './real-cdp.mjs';
const HERE = path.dirname(fileURLToPath(import.meta.url));
const ROOT = path.resolve(HERE, '..');
const SCRIPT_SRC = fs.readFileSync(path.join(ROOT, 'yun-xue-tang-assistant.user.js'), 'utf8');
const argv = process.argv.slice(2);
const flag = (n) => argv.includes(n);
const opt = (n, d) => {
const i = argv.indexOf(n);
return i >= 0 && argv[i + 1] ? argv[i + 1] : d;
};
const USR = process.env.YUN_XUE_TANG_USR || '';
const PWD = process.env.YUN_XUE_TANG_PWD || '';
const SCAN = flag('--scan');
const PROBE = flag('--probe') ? Number(opt('--probe', 8)) : 0;
const HEADLESS = flag('--headless') || process.env.YUN_XUE_TANG_HEADLESS === '1';
const KEEP = flag('--keep');
const MAX_COURSES = Number(opt('--max', 2));
const BUDGET_MIN = Number(opt('--budget', 15));
const PIN_TITLE = opt('--title', '');
const PORT = Number(process.env.YUN_XUE_TANG_CDP_PORT || 9335);
const ORIGIN = 'https://kfmic.yunxuetang.cn';
const OUT = opt('--out', path.join(os.tmpdir(), 'yun-xue-tang-run-' + Date.now() + '.json'));
const CANDIDATES = [
process.env.YUN_XUE_TANG_CHROME,
'C:/Program Files/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
'/usr/bin/google-chrome',
'/usr/bin/chromium',
].filter(Boolean);
const CHROME = findChrome(CANDIDATES);
const results = [];
const consoleLogs = [];
const timeline = [];
const log = (...a) => console.log(...a);
const clock = () => new Date().toISOString().slice(11, 19);
function check(name, ok, detail) {
results.push({ name, ok: !!ok, detail });
log((ok ? ' PASS ' : ' FAIL ') + name + (detail === undefined ? '' : ' → ' + JSON.stringify(detail)));
}
if (!CHROME) { console.error('找不到 Chrome/Edge,可用 YUN_XUE_TANG_CHROME=... 指定'); process.exit(2); }
if (!USR || !PWD) { console.error('缺少环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD'); process.exit(2); }
if (typeof WebSocket !== 'function' || typeof fetch !== 'function') {
console.error('需要 Node 22+,当前 ' + process.version);
process.exit(2);
}
log('[RUN] 账号:' + USR.slice(0, 3) + '***' + USR.slice(-2));
log('[RUN] 模式:' + (SCAN ? '只读扫描列表' : (PROBE ? '只读探测前 ' + PROBE + ' 门课的目录' : '批量持续运行(最多 ' + MAX_COURSES + ' 门 / ' + BUDGET_MIN + ' 分钟)')) +
(PIN_TITLE ? ' 指定课程:' + PIN_TITLE : ''));
// Linux 无图形化服务器:没有 DISPLAY 时强制无头,并补容器/root 必需参数
const HEADLESS_ONLY = HEADLESS || forceHeadless();
const userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'yun-xue-tang-run-'));
const args = [
`--remote-debugging-port=${PORT}`,
`--user-data-dir=${userDataDir}`,
'--no-first-run', '--no-default-browser-check', '--disable-sync',
// 后台标签页/最小化时不要把定时器和视频节流,否则「持续运行」测不准
'--disable-background-timer-throttling', '--disable-renderer-backgrounding',
'--disable-backgrounding-occluded-windows',
'--autoplay-policy=no-user-gesture-required',
'--window-size=1360,940',
].concat(safetyArgs(), ['about:blank']);
if (HEADLESS_ONLY) args.unshift('--headless=new');
let chrome = null;
let cdp = null;
log('[RUN] 浏览器:' + CHROME + (HEADLESS_ONLY ? '(headless)' : '(有界面)'));
try {
chrome = spawn(CHROME, args, { stdio: 'ignore', windowsHide: true });
let version = null;
for (let i = 0; i < 100; i++) {
try { const v = await httpJson(`http://127.0.0.1:${PORT}/json/version`); if (v && v.webSocketDebuggerUrl) { version = v; break; } } catch (e) {}
await sleep(250);
}
if (!version) throw new Error('Chrome CDP 未就绪');
log('[RUN] ' + version.Browser);
const target = await httpJson(`http://127.0.0.1:${PORT}/json/new?${encodeURIComponent(ORIGIN + '/login.html')}`, 'PUT');
cdp = await connect(target.webSocketDebuggerUrl);
await cdp.send('Page.enable');
await cdp.send('Runtime.enable');
await cdp.send('Log.enable');
cdp.onEvent((m) => {
if (m.method === 'Runtime.consoleAPICalled') {
const text = (m.params.args || []).map((a) => (a.value !== undefined ? a.value : a.description || '')).join(' ');
consoleLogs.push({ t: Date.now(), type: m.params.type, text: String(text) });
} else if (m.method === 'Log.entryAdded') {
consoleLogs.push({ t: Date.now(), type: m.params.entry.level, text: m.params.entry.text });
}
});
const evalJS = async (expr) => {
const r = await cdp.send('Runtime.evaluate', { expression: expr, returnByValue: true, awaitPromise: true, userGesture: true });
if (r.exceptionDetails) {
const d = r.exceptionDetails;
throw new Error((d.exception && d.exception.description) || d.text);
}
return r.result.value;
};
const json = async (expr) => JSON.parse(await evalJS(expr));
const waitFor = async (exprFn, timeoutMs) => {
const started = Date.now();
while (Date.now() - started < timeoutMs) {
try { if (await evalJS(exprFn)) return true; } catch (e) {}
await sleep(500);
}
return false;
};
// ---------- 整页跳转后自动重新注入(等价 Tampermonkey 按 @match 重注入) ----------
let injections = 0;
let reinjectTimer = null;
const injectIfMissing = async () => {
let t;
try { t = await evalJS('typeof window.__yunXueTangAuto'); } catch (e) { return false; }
if (t === 'object') return false;
try {
await evalJS(SCRIPT_SRC);
injections++;
return true;
} catch (e) { return false; }
};
// 每 1.5 秒兜底检查一次:任何原因导致脚本不在,就补注入(真实环境里由 @match 保证)
const startWatchdog = () => {
if (reinjectTimer) clearInterval(reinjectTimer);
reinjectTimer = setInterval(() => {
injectIfMissing().then((did) => {
if (did) console.log('[RUN] ' + clock() + ' 新 document 已重新注入(第 ' + injections + ' 次)');
}).catch(() => {});
}, 1500);
};
const loaded = cdp.waitEvent('Page.loadEventFired', 45000).catch(() => null);
await cdp.send('Page.navigate', { url: ORIGIN + '/login.html' });
await loaded;
await sleep(2000);
// ---------- 登录 ----------
await evalJS(SCRIPT_SRC);
injections++;
await sleep(1200);
const loginPage = await evalJS(`!!(window.__yunXueTangAuto && window.__yunXueTangAuto.isLoginPage())`);
check('登录页脚本就绪', loginPage === true, await evalJS('location.pathname'));
await evalJS(`(() => {
const a = window.__yunXueTangAuto;
a.fillLoginForm(${JSON.stringify(USR)}, ${JSON.stringify(PWD)});
try { a.checkLoginAgreement(); } catch (e) {}
return true;
})()`);
await evalJS(`(document.getElementById('yun-xue-tang-oneclick').click(), true)`);
const loginOk = await waitFor(`(() => {
if (/\\/login/.test(location.pathname)) return false;
if (!document.body) return false;
return !document.querySelector('input[type=password]');
})()`, 45000);
check('真实登录成功', loginOk === true, await evalJS('location.pathname'));
// 进列表(新 document)
const loaded2 = cdp.waitEvent('Page.loadEventFired', 30000).catch(() => null);
await evalJS(`(location.href = '${ORIGIN}/kng/#/list', true)`);
await loaded2;
await sleep(2500);
await injectIfMissing();
if (injections === 1) injections++; // 上面那次是列表页注入
await waitFor(`!!window.__yunXueTangAuto && window.__yunXueTangAuto.scanCards().length > 0`, 45000);
await sleep(1500);
// 优先短课程(缩短验证耗时;真机上这是默认勾选行为)
await evalJS(`(() => { try { localStorage.setItem('yun-xue-tang-prefer-short', '1'); } catch (e) {} const a = window.__yunXueTangAuto; if (a) a.state.preferShortCourses = true; return true; })()`);
// ---------- --probe:只读探测目录(关掉自动播放,避免动进度) ----------
if (PROBE) {
// 当前课程自动连播开关关掉:进课后脚本不会自动起播、也不会自动切节
await evalJS(`(() => { localStorage.setItem('yun-xue-tang-auto-play-enabled', '0'); const a = window.__yunXueTangAuto; if (a) a.state.autoPlayEnabled = false; return true; })()`);
const picks = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
const ul = document.querySelector('ul.kng-list-new');
let v = ul && ul.__vue__;
while (v && !(v.kngListData && v.kngListData.length)) v = v.$parent;
const data = (v && v.kngListData) || [];
const byTitle = new Map();
for (const d of data) byTitle.set(String(d.title || d.name || '').trim(), d);
return a.scanCards()
.filter((c) => c.title && !/已学完|已完成|已学习/.test(c.status))
.map((c) => {
const d = byTitle.get(c.title) || {};
return { i: c.i, title: c.title, studyHours: Number(d.studyHours) || 0, id: String(d.id || '') };
})
.filter((c) => c.studyHours > 0)
.sort((x, y) => x.studyHours - y.studyHours)
.slice(0, ${PROBE});
})())`);
log('\n[RUN] 探测 ' + picks.length + ' 门课(按总时长正序):');
const report = [];
for (const p of picks) {
await evalJS(`(() => {
try { localStorage.setItem('yun-xue-tang-auto-play-enabled', '0'); } catch (e) {}
const a = window.__yunXueTangAuto;
a.state.autoPlayEnabled = false;
const card = a.scanCards().find((c) => c.i === ${p.i});
if (card) a.startCourse(card);
return true;
})()`).catch(() => {});
const ok = await waitFor(`(() => {
const a = window.__yunXueTangAuto;
return !!a && a.route() === 'course' && a.lessonItems().length > 0;
})()`, 25000);
let info = null;
if (ok) {
await sleep(1200);
info = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
const items = a.lessonItems();
return {
lessons: items.length,
completed: items.filter((li) => a.isLessonCompleted(li)).length,
quiz: /考试|测验|问卷|答题/.test((document.querySelector('.yxtulcdsdk-catalog') || {}).innerText || ''),
names: items.map((li) => ((li.innerText || '').replace(/\\s+/g, ' ').trim()).slice(0, 22)),
summary: a.readSummary(),
};
})())`);
}
const remaining = info ? info.lessons - info.completed : 0;
log(' ' + (info ? (info.lessons + ' 节/剩 ' + remaining + (info.quiz ? ' [含考试]' : '')) : '进课失败').padEnd(18) +
' ' + String(Math.round(p.studyHours / 60)).padStart(4) + ' 分 ' + p.title.slice(0, 40));
report.push({ ...p, ...(info || {}), remaining });
// 回列表
await evalJS(`(location.href = '${ORIGIN}/kng/#/list', true)`).catch(() => {});
await sleep(2500);
await injectIfMissing();
await waitFor(`!!window.__yunXueTangAuto && window.__yunXueTangAuto.scanCards().length > 0`, 40000);
await sleep(1200);
}
const multi = report.filter((r) => r.remaining >= 2 && !r.quiz);
log('\n[RUN] 适合测「跨章节」的候选(≥2 节未学完且不含考试):');
for (const m of multi) log(' ' + m.remaining + ' 节待学 ' + m.title.slice(0, 40) + ' → ' + m.names.join(' / '));
check('找到可跨章节验证的课程(≥2 节未学完)', multi.length > 0, multi.slice(0, 5).map((m) => ({ title: m.title.slice(0, 30), remaining: m.remaining })));
fs.writeFileSync(path.join(os.tmpdir(), 'yun-xue-tang-probe.json'), JSON.stringify(report, null, 2));
} else if (SCAN) {
const cards = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
const ul = document.querySelector('ul.kng-list-new');
let v = ul && ul.__vue__;
while (v && !(v.kngListData && v.kngListData.length)) v = v.$parent;
const data = (v && v.kngListData) || [];
const byTitle = new Map();
for (const d of data) byTitle.set(String(d.title || d.name || '').trim(), d);
return a.scanCards().map((c) => {
const d = byTitle.get(c.title) || {};
return { title: c.title, status: c.status, studyHours: d.studyHours, id: String(d.id || '') };
});
})())`);
log('\n[RUN] 列表卡片(' + cards.length + ' 张):');
for (const c of cards) {
log(' ' + (c.status || '-').padEnd(4) + ' ' +
(c.studyHours ? String(Math.round(c.studyHours / 60)).padStart(5) + ' 分' : ' ? 分') +
' ' + c.title.slice(0, 46));
}
check('列表可读', cards.length > 0, { 卡片数: cards.length });
} else {
// ---------- 启动批量 ----------
await evalJS(`(() => {
const a = window.__yunXueTangAuto;
a.S.completedThisRun = 0;
a.S.batchFinished = false;
a.startBatch();
return true;
})()`);
await sleep(1500);
// 指定课程:进入列表后抢先开始它(S.batchRunning 先关掉,避免 listTick 抢选别的课)
if (PIN_TITLE) {
const armed = await waitFor(`window.__yunXueTangAuto && window.__yunXueTangAuto.route() === 'list' && window.__yunXueTangAuto.scanCards().length > 0`, 60000);
if (armed) {
const pinned = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
a.S.batchRunning = false; a.save();
const card = a.scanCards().find((c) => c.title.indexOf(${JSON.stringify(PIN_TITLE)}) >= 0);
if (!card) { a.S.batchRunning = true; a.save(); return { ok: false }; }
a.startCourse(card);
a.S.batchRunning = true; a.save();
return { ok: true, title: card.title };
})())`);
check('已指定首门课程并开始', pinned.ok === true, pinned);
} else {
check('已指定首门课程并开始', false, '列表未就绪');
}
}
// ---------- 持续监控 ----------
const startedAt = Date.now();
const deadline = startedAt + BUDGET_MIN * 60 * 1000;
let lastSig = '';
let lastSample = null;
let lastAdvanceAt = Date.now();
let lastCt = 0;
let maxStallMs = 0;
const perCourse = new Map(); // title -> lesson keys seen
const transitions = []; // { t, from, to, course }
let playEvidence = 0; // currentTime 增长次数
const sample = async () => {
try {
return await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
if (!a) return { gone: true, href: location.href };
const v = document.querySelector('video, audio');
const items = a.lessonItems();
return {
href: location.href,
route: a.route(),
phase: a.S.coursePhase,
running: a.S.batchRunning,
runFinished: a.S.batchFinished,
completed: a.S.completedThisRun,
pendingRetries: Object.keys(a.S.courseRetries || {}).length,
cur: a.S.activeCourse ? a.S.activeCourse.title : null,
curId: a.S.activeCourse ? a.S.activeCourse.id : null,
lesson: a.readActiveLessonKey ? a.readActiveLessonKey() : '',
lessonCount: items.length,
summary: a.readSummary(),
countdown: a.readCountdown(),
status: (document.getElementById('yun-xue-tang-status') || {}).textContent || '',
video: v ? { ct: Math.round(v.currentTime), dur: Math.round(v.duration), paused: v.paused, muted: v.muted, rate: v.playbackRate } : null,
done: Object.keys(a.S.completedTitles || {}).length,
retryTitles: Object.keys(a.S.courseRetries || {}).length,
};
})())`);
} catch (e) {
return null; // 跳转中 DOM 不可用
}
};
log('\n[RUN] 开始持续监控(Ctrl+C 或到点自动结束)…\n');
while (Date.now() < deadline) {
const s = await sample();
if (s && !s.gone) {
lastSample = s;
// 视频推进证据
if (s.video && !s.video.paused && s.video.ct > lastCt) {
playEvidence++;
lastAdvanceAt = Date.now();
lastCt = s.video.ct;
} else if (s.video && s.video.paused && s.video.ct !== lastCt) {
lastCt = s.video.ct;
}
if (Date.now() - lastAdvanceAt > maxStallMs) maxStallMs = Date.now() - lastAdvanceAt;
// 每门课出现过的课时
if (s.cur) {
if (!perCourse.has(s.cur)) perCourse.set(s.cur, []);
const keys = perCourse.get(s.cur);
if (s.lesson && keys[keys.length - 1] !== s.lesson) keys.push(s.lesson);
}
const sig = [s.cur, s.lesson, s.completed, s.phase, s.runFinished].join('|');
if (sig !== lastSig) {
const prev = lastSample && lastSig ? lastSig.split('|') : null;
log('[RUN] ' + clock() + ' ' + (s.cur ? s.cur.slice(0, 26) : '(列表)') +
' ' + (s.phase || '-') + (s.runFinished ? ' [已停止]' : '') +
' 完成 ' + s.completed + ' 待重试 ' + s.pendingRetries +
(s.lesson ? ' 课时:' + s.lesson.slice(0, 30) : '') +
(s.summary ? ' 汇总:' + s.summary.text : '') +
(s.countdown != null ? ' 倒计时 ' + s.countdown + 's' : ''));
if (prev && prev[0] && s.cur && prev[0] === s.cur && prev[1] && s.lesson && prev[1] !== s.lesson) {
transitions.push({ t: Date.now() - startedAt, course: s.cur, from: prev[1], to: s.lesson });
}
timeline.push({ at: Date.now() - startedAt, ...s });
lastSig = sig;
}
if (s.completed >= MAX_COURSES) { log('\n[RUN] 已完成 ' + s.completed + ' 门,达到上限,收尾'); break; }
if (s.runFinished) { log('\n[RUN] 脚本自己停止了:' + s.status); break; }
if (s.runFinished && /重试 .* 次仍未完成/.test(s.status || '')) { log('[RUN] 重试用尽,脚本已停止,收尾'); break; }
}
await sleep(2000);
}
const elapsed = Math.round((Date.now() - startedAt) / 1000);
const errors = consoleLogs.filter((l) => l.type === 'error' && /云学堂助手/.test(l.text));
const final = (await sample()) || lastSample || {};
check('持续运行未因脚本 exception 中断', errors.length === 0, errors.map((e) => e.text.slice(0, 140)));
check('批处理仍在运行或已按上限结束', final.runFinished !== undefined, { running: final.running, runFinished: final.runFinished });
check('至少完成 2 门课程(跨课程)', (final.completed || 0) >= 2, { 完成: final.completed, 用时秒: elapsed });
check('观察到课时自动切换(跨章节)', transitions.length >= 1, { 切换次数: transitions.length, 明细: transitions.map((x) => x.from.slice(0, 14) + ' → ' + x.to.slice(0, 14)) });
check('视频持续推进(无长时间卡死)', playEvidence >= 3 && maxStallMs < 120000, { 推进采样: playEvidence, 最长停滞秒: Math.round(maxStallMs / 1000) });
check('整页跳转后自动恢复(重新注入)', injections >= 2, { 注入次数: injections });
check('没有课程被永久跳过(重试计数可控)', (final.retryTitles || 0) < 5, { 待重试标题: final.retryTitles });
log('\n[RUN] 每门课观察到的课时:');
for (const [title, keys] of perCourse) {
log(' ' + title.slice(0, 34) + ' → ' + keys.length + ' 节:' + keys.map((k) => k.slice(0, 18)).join(' / '));
}
log('[RUN] 完成后本地已记录 done:' + (final.done || 0) + ' 门;用时 ' + Math.round(elapsed / 60) + ' 分 ' + (elapsed % 60) + ' 秒');
// 收尾:停批量 + 暂停媒体
await evalJS(`(() => {
const a = window.__yunXueTangAuto;
if (a) { a.S.batchRunning = false; a.save(); if (a.pauseAllMedia) a.pauseAllMedia(); }
return true;
})()`).catch(() => {});
await sleep(1000);
const disposed = await json(`JSON.stringify((() => {
try { window.__yunXueTangDispose(); } catch (e) {}
return { panel: !!document.getElementById('yun-xue-tang-panel'), api: typeof window.__yunXueTangAuto };
})())`).catch(() => ({ panel: null, api: 'n/a' }));
check('dispose 后面板与 API 清理干净', disposed.panel === false && disposed.api === 'undefined', disposed);
}
log('\n[RUN] 脚本日志(' + consoleLogs.filter((l) => /云学堂助手/.test(l.text)).length + ' 条):');
for (const l of consoleLogs.filter((x) => /云学堂助手/.test(x.text)).slice(-40)) log(' [' + l.type + '] ' + l.text.slice(0, 170));
} catch (e) {
check('持续运行流程执行完毕', false, e && e.stack ? e.stack.split('\n').slice(0, 5).join(' | ') : String(e));
} finally {
if (cdp && !KEEP) cdp.close();
if (chrome && !KEEP) { try { chrome.kill(); } catch (e) {} }
if (!KEEP) { await sleep(700); try { fs.rmSync(userDataDir, { recursive: true, force: true }); } catch (e) {} }
else log('[RUN] --keep:浏览器保持打开 ' + userDataDir);
try {
fs.writeFileSync(OUT, JSON.stringify({ timeline, results, logs: consoleLogs.slice(-400) }, null, 2));
log('[RUN] 时间线已写入 ' + OUT);
} catch (e) { /* ignore */ }
}
const failed = results.filter((r) => !r.ok);
log('\n===== RUN 结果:' + (results.length - failed.length) + '/' + results.length + ' 通过,失败 ' + failed.length + ' =====');
for (const f of failed) log(' FAIL ' + f.name + ' → ' + JSON.stringify(f.detail));
process.exit(failed.length ? 1 : 0);
+325
View File
@@ -0,0 +1,325 @@
#!/usr/bin/env node
/**
* 真机测试:真实 Chrome + 真实 https://kfmic.yunxuetang.cn 页面。
*
* 做法:启动一个独立用户目录的 Chrome(不碰你日常配置),通过 CDP 把打包产物
* yun-xue-tang-assistant.user.js 注入页面主世界——这与 Tampermonkey 在
* @grant none 下的执行环境一致,所以断言的是脚本在真实浏览器 / 真实站点
* DOM 上的行为,而不是 Node 里的 DOM 桩。
*
* 用法:
* node dev/real-test.mjs 有界面浏览器(默认,最接近真机)
* node dev/real-test.mjs --headless 无头模式(CI 用)
* node dev/real-test.mjs --keep 跑完不关浏览器(便于人工肉眼复核)
*
* 环境变量:
* YUN_XUE_TANG_CHROME Chrome/Edge 可执行文件路径
* YUN_XUE_TANG_CDP_PORT 调试端口,默认 9333
* YUN_XUE_TANG_URL 起始页面,默认 https://kfmic.yunxuetang.cn/login.html
* YUN_XUE_TANG_SHOT_DIR 截图目录,默认 docs/screenshots
*
* 需要 Node 22+(用到全局 WebSocket 与 fetch);只做只读探测:
* 不填写账号密码、不点登录、不修改线上数据。
*/
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import { spawn } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { connect, sleep, httpJson, findChrome, forceHeadless, safetyArgs } from './real-cdp.mjs';
const HERE = path.dirname(fileURLToPath(import.meta.url));
const ROOT = path.resolve(HERE, '..');
const SCRIPT_FILE = path.join(ROOT, 'yun-xue-tang-assistant.user.js');
const SCRIPT_SRC = fs.readFileSync(SCRIPT_FILE, 'utf8');
const CANDIDATES = [
process.env.YUN_XUE_TANG_CHROME,
'C:/Program Files/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
'C:/Program Files/Microsoft/Edge/Application/msedge.exe',
'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
'/usr/bin/google-chrome',
'/usr/bin/chromium',
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
].filter(Boolean);
const CHROME = findChrome(CANDIDATES);
const PORT = Number(process.env.YUN_XUE_TANG_CDP_PORT || 9333);
const START_URL = process.env.YUN_XUE_TANG_URL || 'https://kfmic.yunxuetang.cn/login.html';
const HEADLESS = process.env.YUN_XUE_TANG_HEADLESS === '1' || process.argv.includes('--headless');
const KEEP = process.env.YUN_XUE_TANG_KEEP === '1' || process.argv.includes('--keep');
const SHOT_DIR = process.env.YUN_XUE_TANG_SHOT_DIR || path.join(ROOT, 'docs/screenshots');
const results = [];
const consoleLogs = [];
const log = (...a) => console.log(...a);
function check(name, ok, detail) {
results.push({ name, ok: !!ok, detail });
log((ok ? ' PASS ' : ' FAIL ') + name + (detail === undefined ? '' : ' → ' + JSON.stringify(detail)));
}
if (typeof WebSocket !== 'function' || typeof fetch !== 'function') {
console.error('需要 Node 22 及以上(依赖全局 WebSocket / fetch),当前 ' + process.version);
process.exit(2);
}
if (!CHROME) {
console.error('找不到 Chrome/Edge,可用 YUN_XUE_TANG_CHROME=/path/to/chrome 指定');
process.exit(2);
}
if (!fs.existsSync(SCRIPT_FILE)) {
console.error('缺少构建产物,先运行 npm run build');
process.exit(2);
}
// Linux 无图形化服务器:没有 DISPLAY 时强制无头,并补容器/root 必需参数
const HEADLESS_ONLY = HEADLESS || forceHeadless();
const userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'yun-xue-tang-chrome-'));
const args = [
`--remote-debugging-port=${PORT}`,
`--user-data-dir=${userDataDir}`,
'--no-first-run', '--no-default-browser-check', '--disable-sync',
'--disable-background-timer-throttling', '--disable-renderer-backgrounding',
'--disable-backgrounding-occluded-windows',
'--window-size=1280,900',
].concat(safetyArgs(), ['about:blank']);
if (HEADLESS_ONLY) args.unshift('--headless=new');
let chrome = null;
let cdp = null;
try {
log('[真机] 浏览器:' + CHROME + (HEADLESS_ONLY ? '(headless=new)' : '(有界面)'));
chrome = spawn(CHROME, args, { stdio: 'ignore', windowsHide: true });
// ---- 1. 等 CDP 就绪 ----
let version = null;
for (let i = 0; i < 100; i++) {
try {
const v = await httpJson(`http://127.0.0.1:${PORT}/json/version`);
if (v && v.webSocketDebuggerUrl) { version = v; break; }
} catch (e) { /* 还没起来 */ }
await sleep(250);
}
if (!version) throw new Error('Chrome CDP 端口未就绪(' + PORT + ')');
check('真实浏览器进程启动', /^(Chrome|HeadlessChrome|Edg)\//.test(version.Browser || ''), version.Browser);
// ---- 2. 打开真实页面 ----
const target = await httpJson(`http://127.0.0.1:${PORT}/json/new?${encodeURIComponent(START_URL)}`, 'PUT');
cdp = await connect(target.webSocketDebuggerUrl);
await cdp.send('Page.enable');
await cdp.send('Runtime.enable');
await cdp.send('Log.enable');
await cdp.send('Network.enable');
cdp.onEvent((m) => {
if (m.method === 'Runtime.consoleAPICalled') {
const text = (m.params.args || []).map((a) => (a.value !== undefined ? a.value : a.description || '')).join(' ');
consoleLogs.push({ type: m.params.type, text: String(text) });
} else if (m.method === 'Log.entryAdded') {
consoleLogs.push({ type: m.params.entry.level, text: m.params.entry.text });
}
});
const evalJS = async (expr) => {
const r = await cdp.send('Runtime.evaluate', {
expression: expr, returnByValue: true, awaitPromise: true, userGesture: true,
});
if (r.exceptionDetails) {
const d = r.exceptionDetails;
throw new Error((d.exception && d.exception.description) || d.text);
}
return r.result.value;
};
const json = async (expr) => JSON.parse(await evalJS(expr));
const loaded = cdp.waitEvent('Page.loadEventFired', 45000).catch(() => null);
await cdp.send('Page.navigate', { url: START_URL });
await loaded;
await sleep(1800);
const page = await json(`JSON.stringify({ url: location.href, title: document.title, host: location.host, ua: navigator.userAgent })`);
log('[真机] 页面:' + page.url);
log('[真机] 标题:' + page.title);
check('落在真实云学堂页面', /(^|\.)yunxuetang\.cn$/.test(page.host), page.host);
check('真实浏览器内核', /Chrome\//.test(page.ua), page.ua.slice(0, 96) + '…');
// ---- 3. 注入(等价 Tampermonkey @grant none 主世界执行)----
check('注入前页面无残留实例', (await evalJS('typeof window.__yunXueTangAuto')) === 'undefined', await evalJS('typeof window.__yunXueTangAuto'));
await evalJS(SCRIPT_SRC);
await sleep(1200);
const loadedLog = consoleLogs.find((l) => /云学堂助手 v[\d.]+ 已加载/.test(l.text));
check('控制台打印加载日志', !!loadedLog, loadedLog && loadedLog.text);
// ---- 4. 面板在真实 DOM 里的渲染 ----
const panel = await json(`JSON.stringify((() => {
const el = document.getElementById('yun-xue-tang-panel');
if (!el) return null;
const r = el.getBoundingClientRect();
const cs = getComputedStyle(el);
return {
version: (document.getElementById('yun-xue-tang-version') || {}).textContent || '',
w: Math.round(r.width), h: Math.round(r.height),
right: Math.round(innerWidth - r.right), bottom: Math.round(innerHeight - r.bottom),
visible: cs.display !== 'none' && cs.visibility !== 'hidden' && Number(cs.opacity) > 0,
position: cs.position, zIndex: cs.zIndex,
buttons: [...el.querySelectorAll('button')].map((b) => b.textContent.trim()),
inputTypes: [...el.querySelectorAll('input')].map((i) => i.type),
text: el.innerText.replace(/\\s+/g, ' ').trim().slice(0, 220),
};
})())`);
check('面板渲染进真实 DOM 且可见', panel && panel.visible && panel.w > 0 && panel.h > 0,
panel && { 宽: panel.w, 高: panel.h, position: panel.position, zIndex: panel.zIndex });
check('面板版本号 v2.7.0', panel && panel.version === 'v2.7.0', panel && panel.version);
check('固定在右下角', panel && panel.right >= 0 && panel.right < 40 && panel.bottom >= 0 && panel.bottom < 40,
panel && { 距右: panel.right, 距下: panel.bottom });
check('面板含按钮与密码框', panel && panel.buttons.length >= 2 && panel.inputTypes.includes('password'),
panel && { 按钮: panel.buttons, 输入框: panel.inputTypes });
// ---- 5. 真实页面上调试入口 / 页面识别 ----
const api = await json(`JSON.stringify((() => {
const a = window.__yunXueTangAuto;
if (!a) return null;
return {
keys: Object.keys(a).length,
route: a.route(),
isLoginPage: a.isLoginPage(),
hasDispose: typeof window.__yunXueTangDispose === 'function',
courseId: a.courseIdFromUrl(),
summary: a.readSummary(),
countdown: a.readCountdown(),
};
})())`);
check('window.__yunXueTangAuto 调试入口存在', !!api && api.keys > 20, api && { 导出项: api.keys });
check('真实登录页被正确识别', api && api.isLoginPage === true, api && { route: api.route, isLoginPage: api.isLoginPage });
check('__yunXueTangDispose 可用(热替换前提)', api && api.hasDispose === true, api && api.hasDispose);
check('登录页上 readSummary/readCountdown 安全返回 null',
api && api.summary === null && api.countdown === null, api && { summary: api.summary, countdown: api.countdown });
// ---- 6. 真实点击面板按钮(不填账号,只验证不崩)----
const click = await json(`JSON.stringify((() => {
const panel = document.getElementById('yun-xue-tang-panel');
const btn = document.getElementById('yun-xue-tang-oneclick');
if (!btn) return { error: 'no #yun-xue-tang-oneclick' };
btn.click();
return {
label: btn.textContent.trim(),
panelVisibleAfter: getComputedStyle(panel).display !== 'none',
statusLine: (document.getElementById('yun-xue-tang-status') || {}).textContent || '',
panelText: panel.innerText.replace(/\\s+/g, ' ').slice(0, 200),
};
})())`);
await sleep(800);
const afterClick = await json(`JSON.stringify(({
url: location.href,
alive: typeof window.__yunXueTangAuto,
panel: !!document.getElementById('yun-xue-tang-panel'),
}))`);
check('点击「一键登录并刷课」不崩溃', afterClick.alive === 'object' && afterClick.panel === true, { 点击前标签: click.label, ...afterClick });
const scriptErrors = () => consoleLogs.filter((l) => l.type === 'error' && /云学堂助手/.test(l.text));
check('无脚本自身 error 日志', scriptErrors().length === 0, scriptErrors().map((e) => e.text.slice(0, 140)));
// ---- 7. 真实 localStorage 读写 ----
const ls = await json(`JSON.stringify((() => {
const before = localStorage.getItem('yun-xue-tang-auto-play-enabled');
localStorage.setItem('yun-xue-tang-auto-play-enabled', '0');
const read = localStorage.getItem('yun-xue-tang-auto-play-enabled');
if (before === null) localStorage.removeItem('yun-xue-tang-auto-play-enabled'); else localStorage.setItem('yun-xue-tang-auto-play-enabled', before);
return { read, keys: Object.keys(localStorage).filter((k) => k.indexOf('yun-xue-tang-') === 0) };
})())`);
check('真实 localStorage 可读写', ls.read === '0', ls);
// ---- 8. 真实热替换:dispose → 重新注入 ----
const hot = await json(`JSON.stringify((() => {
window.__yunXueTangDispose();
return { panel: !!document.getElementById('yun-xue-tang-panel'), api: typeof window.__yunXueTangAuto, dispose: typeof window.__yunXueTangDispose };
})())`);
await evalJS(SCRIPT_SRC);
await sleep(900);
const hot2 = await json(`JSON.stringify({
count: document.querySelectorAll('#yun-xue-tang-panel').length,
api: typeof window.__yunXueTangAuto,
version: (document.getElementById('yun-xue-tang-version') || {}).textContent,
timers: 'n/a',
})`);
check('dispose 后真实 DOM 面板被移除', hot.panel === false && hot.api === 'undefined',
hot);
check('重新注入后面板唯一且版本正确', hot2.count === 1 && hot2.api === 'object' && hot2.version === 'v2.7.0', hot2);
// ---- 9. 截图存证 ----
try {
fs.mkdirSync(SHOT_DIR, { recursive: true });
const shot = await cdp.send('Page.captureScreenshot', { format: 'png' });
const file = path.join(SHOT_DIR, 'real-chrome-login.png');
fs.writeFileSync(file, Buffer.from(shot.data, 'base64'));
const size = fs.statSync(file).size;
check('真机截图已保存', size > 5000, path.relative(ROOT, file) + ' (' + size + ' 字节)');
} catch (e) {
check('真机截图已保存', false, e.message);
}
// ---- 10. SPA 内 hash 路由(不换 document):脚本靠 hashchange 自更新,不需要重新注入 ----
const hashNav = await json(`JSON.stringify((() => {
location.hash = '#/list';
return { hash: location.hash, route: window.__yunXueTangAuto.route(), panel: !!document.getElementById('yun-xue-tang-panel') };
})())`);
await sleep(600);
const hashAfter = await json(`JSON.stringify({ hash: location.hash, route: window.__yunXueTangAuto.route(), alive: typeof window.__yunXueTangAuto })`);
check('SPA 内 hash 切换后脚本自动跟随路由', hashAfter.route === 'list' && hashAfter.alive === 'object', { 切前: hashNav, 切后: hashAfter });
// ---- 11. 未登录访问 #/list:站点整页重定向到登录页(新 document)----
// 真实 Tampermonkey 会在新 document 上按 @match 重新注入,这里同样重新注入后再断言。
// 先订阅 load 事件再触发跳转,避免竞态。
const redirected = cdp.waitEvent('Page.loadEventFired', 30000).catch(() => null);
await evalJS(`(() => { window.__yunXueTangDocMarker = 'before-nav'; location.href = 'https://kfmic.yunxuetang.cn/kng/#/list'; return true; })()`);
await redirected;
await sleep(2500);
const afterNav = await json(`JSON.stringify({
url: location.href,
host: location.host,
title: document.title,
newDocument: window.__yunXueTangDocMarker === undefined,
alive: typeof window.__yunXueTangAuto,
})`);
check('未登录访问 #/list 被站点重定向(document 已换新)',
/(^|\.)yunxuetang\.cn$/.test(afterNav.host) && afterNav.newDocument === true, afterNav);
check('新 document 上脚本未残留(重定向后必须重新注入)', afterNav.alive === 'undefined', afterNav.alive);
// 模拟 Tampermonkey 在新 document 上按 @match 自动注入
await evalJS(SCRIPT_SRC);
await sleep(1200);
const reinjected = await json(`JSON.stringify({
url: location.href,
route: window.__yunXueTangAuto ? window.__yunXueTangAuto.route() : 'no-api',
isLoginPage: window.__yunXueTangAuto ? window.__yunXueTangAuto.isLoginPage() : null,
panel: document.querySelectorAll('#yun-xue-tang-panel').length,
version: (document.getElementById('yun-xue-tang-version') || {}).textContent,
bodyScrollable: document.body.scrollHeight > 0,
})`);
check('重定向后重新注入:面板唯一且脚本正常',
reinjected.panel === 1 && reinjected.version === 'v2.7.0' && reinjected.route !== 'no-api', reinjected);
check('列表页导航无脚本报错', scriptErrors().length === 0, scriptErrors().map((e) => e.text.slice(0, 140)));
// ---- 汇总控制台 ----
log('\n[真机] 控制台共 ' + consoleLogs.length + ' 条,最后 15 条:');
for (const l of consoleLogs.slice(-15)) log(' [' + l.type + '] ' + l.text.slice(0, 170));
} catch (e) {
check('真机流程执行完毕', false, e && e.stack ? e.stack.split('\n').slice(0, 4).join(' | ') : String(e));
} finally {
if (cdp && !KEEP) cdp.close();
if (chrome && !KEEP) { try { chrome.kill(); } catch (e) {} }
if (!KEEP) {
await sleep(600);
try { fs.rmSync(userDataDir, { recursive: true, force: true }); } catch (e) {}
} else {
log('[真机] YUN_XUE_TANG_KEEP=1,浏览器保持打开:' + userDataDir);
}
}
const failed = results.filter((r) => !r.ok);
log('\n===== 真机结果:' + (results.length - failed.length) + '/' + results.length + ' 通过,失败 ' + failed.length + ' =====');
for (const f of failed) log(' FAIL ' + f.name + ' → ' + JSON.stringify(f.detail));
process.exit(failed.length ? 1 : 0);
+3 -3
View File
@@ -1,6 +1,6 @@
#!/usr/bin/env node
/**
* 云学堂自动刷课 · 本地开发服务器
* 云学堂助手 · 本地开发服务器
*
* 作用:把工作目录里的 yun-xue-tang-assistant.user.js 暴露给浏览器里的
* Tampermonkey 热加载器(dev/dev-loader.user.js)拉取。
@@ -22,7 +22,7 @@ import { fileURLToPath } from 'node:url';
const HERE = path.dirname(fileURLToPath(import.meta.url));
const ROOT = path.resolve(HERE, '..');
const HOST = '127.0.0.1';
const PORT = Number(process.env.YT_DEV_PORT || process.argv[2] || 8899);
const PORT = Number(process.env.YUN_XUE_TANG_DEV_PORT || process.argv[2] || 8899);
const FILES = {
'/src': path.join(ROOT, 'yun-xue-tang-assistant.user.js'),
@@ -59,7 +59,7 @@ function indexHtml() {
<style>body{font:14px/1.7 system-ui,"Microsoft YaHei";max-width:760px;margin:40px auto;padding:0 16px;color:#222}
code{background:#f2f2f4;padding:1px 5px;border-radius:4px}a{color:#2f7d5b}
.ok{color:#2f7d5b;font-weight:600}</style>
<h2>云学堂自动刷课 · 本地开发服务 <span class="ok">运行中</span></h2>
<h2>云学堂助手 · 本地开发服务 <span class="ok">运行中</span></h2>
<p>源码文件:<code>${path.join(ROOT, 'yun-xue-tang-assistant.user.js')}</code></p>
<ul>
<li><a href="/loader.user.js">安装 / 更新热加载器</a>(Tampermonkey 会弹出安装页)</li>
+5 -2
View File
@@ -1,10 +1,13 @@
@echo off
rem NOTE: keep this file PURE ASCII, see start-headless.cmd for why.
rem (cmd.exe parses batch files byte-by-byte with the current code page;
rem multi-byte characters corrupt line offsets.)
chcp 65001 >nul
cd /d "%~dp0.."
title YXT Cruise · 本地开发服务
title YXT Cruise - dev server
where node >nul 2>nul
if errorlevel 1 (
echo 未找到 node.exe,请先安装 Node.js(https://nodejs.org/)
echo [error] node.exe not found. Install Node.js from https://nodejs.org/
pause
exit /b 1
)
+361
View File
@@ -0,0 +1,361 @@
云学堂助手 · 无头运行(Linux 无图形化服务器)证据
==================================================
一、需求
- 用户诉求:「支持无头模式运行在linux无图形化服务器上」。
- 澄清后的范围:新增无头运行器 + 部署说明;常驻方式为手动前台跑(tmux/nohup,
不做 systemd / Docker);持久化 profile,掉登录时用环境变量账号自动重登。
二、方案
新增 `runner/`,不装 Tampermonkey、不装桌面环境、不需要 Xvfb:
| 文件 | 作用 |
| --- | --- |
| runner/headless.mjs | 入口(约 90 行):解析参数 → 预检 → 交给 supervisor |
| runner/config.mjs | 命令行参数与环境变量(--max / YUN_XUE_TANG_* 集中在此) |
| runner/preflight.mjs | 启动前检查:产物、Node 版本、凭据、浏览器、调试端口 |
| runner/log.mjs | 终端 + 文件日志(5MB 轮转) |
| runner/stop.mjs | SIGINT / SIGTERM 优雅退出(注册式收尾) |
| runner/browser.mjs | 浏览器探测(含 Linux/容器常见路径)、启动参数、陈旧 SingletonLock 清理 |
| runner/cdp.mjs | 极简 CDP 客户端(Node 22+ 原生 WebSocket + fetch,无第三方依赖) |
| runner/page.mjs | 注入后要调用的页面 JS 表达式 + page.evalJS/json/tryEval |
| runner/session.mjs | 单次会话:起浏览器 → 注入 → 自动重登 → 起批量 → 监控 → 收尾 |
| runner/selfcheck.mjs | --check 的只读环境自检 |
| runner/supervisor.mjs | 崩溃重启循环与退出码 |
依赖方向是单向的:headless → supervisor → session → page/selfcheck → cdp,无循环引用。
按需求不打包:node runner/headless.mjs 直接跑多文件 ESM,部署时整个 runner/ 目录一起带走。
改脚本内部 API(window.__yunXueTangAuto 上的方法)时只需要改 runner/page.mjs。
注入方式与 Tampermonkey 等价:用 `Runtime.evaluate` 把构建产物源码注入页面主世界
(脚本 `@grant none`,不需要沙箱隔离),因此每次整页跳转(新 document)都要重新注入,
运行器用 1.5 秒的看护循环检测 `window.__yunXueTangAuto` 是否存在并补注入。
三、Linux 无图形化环境的三个必踩坑(与代码对应)
1) 没有 DISPLAY:有界面模式直接报 `Missing X server or $DISPLAY` 并退出。
- `runner/browser.mjs:hasDisplay()` 判 `DISPLAY` / `WAYLAND_DISPLAY`;
- `runner/headless.mjs` 里 `VISIBLE = WANT_VISIBLE && hasDisplay()`,
即**即使传了 `--visible` 也会被强制无头并打警告**;
- `dev/real-cdp.mjs:forceHeadless()` 让三个真机测试脚本同样自动无头。
2) root 运行:Chromium 拒绝启动(`Running as root without --no-sandbox is not supported`)。
- `safetyArgs()` 在 `process.getuid()===0` 时补 `--no-sandbox --disable-setuid-sandbox --disable-gpu`;
- `buildArgs()` 在 Linux 上恒加 `--no-sandbox --disable-setuid-sandbox`。
3) 容器 /dev/shm 只有 64MB:标签页会莫名崩溃(`Target closed`)。
- Linux 上恒加 `--disable-dev-shm-usage`。
另外补的稳定性参数:`--no-zygote`、`--disable-gpu`、`--mute-audio`、
`--autoplay-policy=no-user-gesture-required`(无人值守必须能自己起播)、
`--disable-background-timer-throttling` / `--disable-renderer-backgrounding` /
`--disable-backgrounding-occluded-windows`(后台标签页不节流,否则计时会停)。
实测(在 Windows 上把 process.platform 覆盖成 linux、getuid 覆盖成 0 验证分支取值):
safetyArgs() root ["--disable-dev-shm-usage","--no-sandbox","--disable-setuid-sandbox","--disable-gpu"]
hasDisplay() 无 DISPLAY false
hasDisplay() 有 DISPLAY true
关键参数(root 无头) ["--autoplay-policy=no-user-gesture-required","--mute-audio","--disable-dev-shm-usage",
"--disable-gpu","--no-zygote","--no-sandbox","--disable-setuid-sandbox","--headless=new"]
有界面+关沙箱 [] ← 非 Linux 不注入任何沙箱参数,保留本机 Chrome 沙箱
陈旧的 `SingletonLock`(上次被 kill -9 留下的符号链接指向已不存在的 pid)会被清理,
活跃的锁保留;清理后普通文件形式的 `SingletonCookie` 也一并删除(实测:lock=false, cookie=false)。
四、可观测能力与容错
- 持久化:profile 固定到 `./.run-profile`(`YUN_XUE_TANG_PROFILE_DIR` 可改),cookie / localStorage 都在里面;
删掉该目录 = 重置登录态 + 进度缓存。
- 自动重登:看护循环每 1.5 秒读一次 `isLoginPage()`,是登录页就填账号密码 + 勾协议 + 点登录;
20 秒限速、连续 5 次失败则退出码 3(多半是密码错或站点要验证码)。
- 崩溃自愈:CDP 断线 / 90 秒读不到脚本状态 → 抛错 → 外层等 15s、30s… 最多 120s 后重建浏览器,
进度由页面 localStorage(`yun-xue-tang-batch-v2`)接续。
- 无进展保护:课程/课时/进度/视频任一有变化即重置计时,连续 30 分钟(`YUN_XUE_TANG_IDLE_RESTART_MINUTES`)
没变化则判定卡死退出。
- 编解码自检:`--check` 会探测 `video/mp4; codecs="avc1.42E01E"`;运行中若
`video.error.code >= 3` 立刻告警「这个 Chromium 不带 H.264/AAC」。
- 优雅退出:SIGINT/SIGTERM → 页面内 `pauseAllMedia()` + `S.running=false` + `save()` → 关浏览器。
- 日志:终端 + `./run-logs/headless.log`,超 5MB 轮转成 `.1`。
- 端口占用:启动前先探 `/json/version`,被占时直接提示 `pkill -f "remote-debugging-port=9336"`
或换 `--port`(实测提示正确,exit 2)。
五、实跑验证(真实站点 kfmic.yunxuetang.cn,真实账号)
1) 环境自检 `npm run headless:check`(只读、不登录、不动进度):
PASS 页面可访问 → https://kfmic.yunxuetang.cn/login.html
PASS 脚本已注入 window.__yunXueTangAuto → object
PASS 面板渲染唯一 → {"面板数":1,"可见":true}
PASS 脚本版本可读 → "v2.7.0"
PASS 视频编解码 H.264 可用 → {"h264":"probably","aac":"probably","vp9":"probably"}
页面识别的路由:other 是否登录页:true
2) 真跑 `node runner/headless.mjs --max 1`(无头、自动登录、真实刷课):
浏览器就绪:Chrome/155.0.8059.85
已注入脚本(第 1 次):https://kfmic.yunxuetang.cn/login.html
登录页:自动登录(第 1 次尝试)
已注入脚本(第 2 次):https://kfmic.yunxuetang.cn/sparring/#/web/drillmate
已注入脚本(第 3 次):https://kfmic.yunxuetang.cn/kng/#/list?...
页面:优先短课程:共 5109 门待学,最短 2 分钟
页面:跳过:如何制定渠道战略(课程包含考试/测验章节)
页面:起点已对齐:第 1 节 视频如何读懂留存曲线?
页面:学习中:视频如何读懂留存曲线?
页面:课程完成: 如何读懂留存曲线? 第 1 门,返回列表选下一门
页面:本次已完成 1 门,已停止。
本次会话结束:已完成 1 门(达到 --max 上限) 用时 2 分 19 秒 本次完成 1 门,累计 1 门
=== 运行器退出 === (退出码 0)
3) 崩溃自愈(kill -F 掉浏览器主进程后):
会话异常:CDP 连接断开,重启浏览器
浏览器/连接异常,15 秒后重试(第 1 次)
--- 第 2 次尝试 ---
浏览器就绪:Chrome/ ...
登录页:自动登录(第 1 次尝试) ← profile 里的 cookie 过期后被站点踢回登录页,自动重登成功
已注入脚本(第 3 次):...#/list... ← 列表页新 document 重新注入
状态:进入课程(3 分钟):什么是增长黑客
页面:点击开始学习 继续学习
页面:学习中:视频什么是增长黑客?
4) 优雅退出(kill -TERM 运行器进程):
[浏览器] 进程退出 code=143 ← 浏览器被 SIGTERM 收掉
残留 chrome 进程数:0 ← 没有孤儿进程
5) 缺凭据时直接拒绝并给原因:`缺少环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD。`,退出码 2。
六、回归(改动没有破坏原有链路)
- `npm run check`:12 个文件逐个 `node --check` 全通过(新增 runner/*.mjs 与 dev/real-run.mjs 也已纳入)。
- `npm run test:real:headless`(真机只读断言):**24/24 通过,失败 0**。
- `node dev/real-e2e.mjs --headless`:**12/12 通过,失败 0**(真实登录 → 新 document → 列表 16 张卡片 / 322 页)。
- `node dev/real-run.mjs --headless --scan`:**3/3 通过,失败 0**。
七、已知限制
- 无头环境无法完成滑块/拼图类验证码:需要先在有界面模式(本机或 `xvfb-run` + `x11vnc`)
人工登录一次,之后靠持久化 profile 的 cookie 免登录。
- 服务器上如果装的是 `chromium`(Debian/Ubuntu 的 Chromium 包),可能不带 H.264/AAC:
课程视频会一直 0 秒。`--check` 会直接给出提示,改装 `google-chrome-stable` 即可。
- 运行器是前台进程,进程管理交给 tmux / nohup / screen,不内置守护模式(按需求如此)。
八、拆分重构(单文件过长 → 模块化)与回归
------------------------------------------
用户反馈「单文件代码太多了,考虑拆分」。runner/headless.mjs 从 626 行拆成 11 个模块、
入口只剩 90 行(结构见第二节表格),**不引入打包步骤**(按用户选择:保持直接 import)。
同时把 package.json 的 check 从「一长串 node --check a && node --check b …」
改成 dev/check.mjs 自动遍历 runner/、dev/ 与顶层文件 —— 以前新增模块必须手改那行命令,
漏改就会静默不被检查。现在输出:语法检查:20/20 个文件通过。
拆分过程中发现并修掉 3 个真实缺陷(都是原单文件里藏着的):
1) 端口占用检查被自己的 try/catch 吞掉
- preflight 里 fail() 在 try 块内抛出,又被同一个 catch 接住,等于端口占用永不报警;
- 而 Chrome 起来后会拒绝启动,外层只是不断重试。现在只捕获探测本身的异常。
- 实测:假 CDP 服务占住 9336 → 退出码 2,三行提示(占用者、pkill 命令、换端口建议)。
2) 连续登录失败不会退出(最严重)
- 原代码在看护循环里 throw,但 setInterval 的 catch 把它当「看护循环异常」打印成警告,
主循环永远看不到这个错误:错误凭据下会无限刷日志、永不退出。
- 修法:致命错误寄存到 fatalError + 停掉定时器,主循环抛出;supervisor 据此返回退出码 3。
- 实测(故意错的账号密码):5 次尝试(每次 20 秒限速)→
会话异常:连续 5 次登录失败:请检查 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD,… → 退出码 3。
3) 会话抛错时浏览器没收干净
- 异常路径跳过了 disposeSession,浏览器进程残留会占住 CDP 端口,下一轮重启撞端口。
- 修法:session 暴露 disposeActiveSession()(幂等),supervisor 在 catch 里先调用它。
- 实测:退出码 3 之后残留 chrome 进程数 0。
回归(重构后全部重跑,真实站点、真实账号):
npm run check 语法检查:20/20 个文件通过(原 12 个,新增 8 个模块)
npm run headless:check 5/5 PASS,退出码 0
node runner/headless.mjs --max 1 真实完成 1 门,退出码 0(多次重跑:2 分 16 秒 / 3 分 39 秒)
kill 浏览器主进程 会话异常:CDP 连接断开 → 15 秒后第 2 次尝试 → 自动重登 → 继续刷课
SIGTERM 浏览器 code=143,残留 chrome 进程数 0
npm run test:real:headless 24/24 通过
node dev/real-e2e.mjs --headless 12/12 通过
node dev/real-run.mjs --headless --scan 3/3 通过
stop.mjs 的单元核查(一次性脚本,未入库):注册的收尾函数全部执行、已注销的不执行、
重复信号不重复执行、收尾后调用 onExit(0)。
stop.mjs 全部断言通过:{"order":["browser.kill","log.close"],"exited":0,"lines":["收到 SIGTERM,正在收尾…"]}
======================================================================
九、跨平台适配(追加 Windows / macOS 支持,实测于 Windows)
======================================================================
背景:无头运行器最初只按「Linux 无图形化服务器」设计,但项目主开发机是 Windows。
实际运行暴露了一批 Windows 专属问题(强杀后残留、锁文件名字不同、SIGTERM 收不到、
Session 0 没有桌面、spawn 会闪黑框),因此把平台差异从各模块里抽出来集中处理。
9.1 新增 runner/platform.mjs(平台差异唯一出口)
isWindows / isLinux / isMac / platformName
isRunningAsRoot() getuid()===0
hasDisplay() 有无图形会话;支持 YUN_XUE_TANG_HAS_DISPLAY=0/1 强制覆盖
Linux 看 DISPLAY/WAYLAND_DISPLAY
Windows 看 SESSIONNAME(Services = Session 0,无桌面)
noDisplayReason() 给日志用的人话原因
safetyArgs() 本平台需要的额外启动参数
Linux: --disable-dev-shm-usage(+ root: --no-sandbox 等)
Windows: 不注入 --no-sandbox;只加 --disable-session-crashed-bubble
--hide-crash-restore-bubble(避免无人值守时弹窗等人点)
killTree(child) 进程树收尾:POSIX SIGTERM→SIGKILL;Windows TerminateProcess
+ 兜底 taskkill /T /F
killProfileOrphans(profileDir) 按 --user-data-dir 找残留浏览器进程并杀掉(自愈)
Linux: ps -eo pid=,args=
Windows: Get-CimInstance Win32_Process + taskkill
portInUseHint(port) 按平台出排查命令
browserInstallHint() / residentHint() 按平台出安装与常驻建议
browser.mjs 转发 platform.mjs 的导出(safetyArgs / hasDisplay / isRunningAsRoot 等),
老的调用方(dev/real-cdp.mjs、dev/real-*.mjs)不需要改 import。
9.2 各模块的改动点
browser.mjs CANDIDATES 补 Windows 用户级安装(LOCALAPPDATA)与 Edge/Chromium 路径,
可执行名匹配改为 EXE_RE(认 .exe);
buildArgs 把 --disable-dev-shm-usage / --no-zygote 限定为非 Windows;
spawn 加 windowsHide(否则无人值守时闪黑框);
kill() 改为 platform.killTree();
cleanStaleSingleton 在 Windows 上额外清 lockfile(普通文件,无法反查 pid,
所以先 killProfileOrphans 再清)。
preflight.mjs 浏览器缺失提示、Node 升级提示、端口排查命令全部按平台出;
端口被占时先 killProfileOrphans 自愈一次,再判断是否真的失败。
stop.mjs 监听 SIGINT + SIGBREAK + SIGHUP(Windows 上 SIGTERM 根本收不到,
Ctrl+C 是 SIGINT,Ctrl+Break 是 SIGBREAK,关窗口是 SIGHUP)。
config.mjs VISIBLE = WANT_VISIBLE && hasDisplay(),导出 platformName / noDisplayReason。
supervisor.mjs 启动横幅打平台名;--visible 被忽略时用 noDisplayReason() 说原因。
headless.mjs 注释补 Windows 用法(set / $env:)与代码结构。
dev/real-*.mjs spawn 补 windowsHide: true。
9.3 实测(Windows 11 / Chrome 155.0.8059.85 / Node v24.19.0)
平台判断
hasDisplay() → true(SESSIONNAME=Console)
safetyArgs() → ["--disable-session-crashed-bubble",
"--hide-crash-restore-bubble"]
buildArgs 平台相关参数 → --disable-gpu / --disable-session-crashed-bubble
/ --hide-crash-restore-bubble / --headless=new
(无 --no-sandbox / --disable-dev-shm-usage)
模拟 SESSIONNAME=Services → hasDisplay() false,--visible 被忽略
killTree(进程树收尾)
启动后同 profile chrome 进程数 10
b.kill() 返回用时 206ms
kill 后进程数 0 ✔ 无残留
killProfileOrphans(残留自愈)—— 用 detached 造出「父进程退出后仍活着」的浏览器
detached 浏览器进程数 10
端口 9358 可响应 true
killProfileOrphans 返回 10
清理后进程数 / 端口 9358 0 / false ✔
预检自愈(端到端)
先用残留浏览器占住默认端口 9336 端口可响应 true
node runner/headless.mjs --check
[预检] 已清理 11 个占用本 profile 的残留进程,重新检测端口…
PASS 页面可访问 / 脚本已注入 / 面板渲染唯一 / 版本可读 / H.264 可用
退出码 0 ✔ 自愈成功(不再误报退出码 2)
Windows 上的信号事实(一次性脚本核查,未入库)
process.kill(pid, 'SIGINT') 子进程被直接终止,SIGINT 处理函数不执行
process.kill(pid, 'SIGTERM') 报 ESRCH,不可用
taskkill /pid <pid>(不带 /F) 报「无法终止」;必须 /F,而 /F 是 TerminateProcess
→ 结论:Windows 上跨进程没有优雅信号,只有当前控制台的 Ctrl+C 能触发 SIGINT。
因此 stop.mjs 监听 SIGINT/SIGBREAK/SIGHUP,并把「强杀留下残局」交给 killProfileOrphans 兜底。
真实链路回归(真实站点 kfmic.yunxuetang.cn、真实账号)
npm run headless:check 5/5 PASS,退出码 0
node runner/headless.mjs --max 1 已完成 1 门(用时 3 分 9 秒),退出码 0
npm run test:real:headless 24/24 通过
node dev/real-e2e.mjs --headless 12/12 通过
node dev/real-run.mjs --headless --scan 3/3 通过
npm run check(dev/check.mjs) 21/21 个文件通过
9.4 Windows 额外交付
start-headless.cmd 一键启动(自动构建 / 检查 Node / 退出码说明 + pause)
README「无头运行」一节 改成 Linux / Windows 双栏,补「Windows 常驻三种方式」
与按平台分的「无图形环境常见坑」表
环境变量 YUN_XUE_TANG_HAS_DISPLAY 0/1 强制认定有无图形会话(自动判断不准时用)
9.5 buildArgs 参数去重(Linux 分支在 Windows 上模拟验证)
platform.mjs 在模块加载时就用 process.platform 定下了常量,因此模拟 Linux 必须在
import 之前改写(一次性脚本 .run-tmp/linux-sim.mjs,用 Object.defineProperty 覆盖
process.platform='linux'、process.getuid=()=>0、清掉 DISPLAY/WAYLAND_DISPLAY)。
hasDisplay() → false(无 DISPLAY)
noDisplayReason() → 当前环境没有图形显示(DISPLAY / WAYLAND_DISPLAY 都为空)
safetyArgs() → ["--disable-dev-shm-usage","--no-sandbox",
"--disable-setuid-sandbox","--disable-gpu"]
buildArgs(去重后) → --disable-gpu / --disable-dev-shm-usage / --no-zygote
/ --no-sandbox / --disable-setuid-sandbox / --headless=new
portInUseHint(9336) → ["ss -lptn \"sport = :9336\"", "pkill -f \"remote-debugging-port=9336\""]
发现并修掉:手写的 Linux 参数与 safetyArgs() 有重叠(--disable-dev-shm-usage /
--no-sandbox / --disable-setuid-sandbox 各出现两次),Chrome 收到重复开关没有意义,
改为 [...new Set(args)] 去重后再拼 extraArgs。Windows 侧核查重复项:无。
======================================================================
十、Windows 批处理启动脚本的编码陷阱(start-headless.cmd 报「不是内部或外部命令」)
======================================================================
10.1 现象
双击 start-headless.cmd,控制台输出:
'e' 不是内部或外部命令,也不是可运行的程序或批处理文件。
'鍏?npm' 不是内部或外部命令,也不是可运行的程序或批处理文件。
'rofile' 不是内部或外部命令,也不是可运行的程序或批处理文件。
'nner' 不是内部或外部命令,也不是可运行的程序或批处理文件。
'姝e父鏀跺熬' 不是内部或外部命令,也不是可运行的程序或批处理文件。
即:整行被拆成几段、中文乱码(UTF-8 字节被按 GBK 解释)、还丢了字符。
10.2 根因(两个独立问题叠加)
a) 行尾是裸 LF。cmd.exe 逐行读取批处理,但它只认 CRLF;只有 LF 时会漏掉换行,
把上一行的尾部当成下一行命令的一部分 —— 于是出现 'e' / 'rofile' / 'nner'
这种「从单词中间开始」的片段。
b) 文件里有非 ASCII 字符(中文)。cmd.exe 按当前代码页(中文 Windows 是 936/GBK)
逐字节读,UTF-8 编码的中文占 3 字节,被当成 3 个 GBK 字符,行读取指针随之错位,
后续命令也跟着被截断 —— 于是出现 '鍏?npm'(UTF-8 的「关」被读成 GBK 乱码,
连后面的空格和 npm 一起粘进来)和 '姝e父鏀跺熬'(「正常收尾」的乱码)。
对照实验(同一台机器,同一目录):
CRLF + chcp 65001 + 中文 → 输出「中文提示 CRLF」「second line」 ✔ 正常
LF + chcp 65001 + 中文 → '01' 不是内部或外部命令 / '文提示' 不是内部或外部命令 ✘ 错位
所以 chcp 65001 并不能救 UTF-8 中文 —— 偏移发生在解析阶段,而不是显示阶段。
GBK 编码 + 不 chcp 的方案虽然能执行,但显示是乱码(终端代码页不匹配),
且文件必须随系统区域设置改动,不适合入库。
10.3 采用方案:批处理只用 ASCII,中文交给 Node 输出
start-headless.cmd 与 dev/start-dev.cmd 全部改写为纯 ASCII + CRLF:
- 注释里写明「本文件必须保持纯 ASCII」及原因,避免以后有人手改回去;
- 所有面向用户的提示(构建中 / 启动中 / 退出码含义 / 缺 Node)改用英文短句
(如 [build] / [run] / [exit] / [error]),中文提示由 Node 侧日志输出;
- 文件仍保留 chcp 65001,这样 Node 输出的 UTF-8 中文在控制台正常显示。
验证:
file start-headless.cmd → DOS batch file, ASCII text, with CRLF line terminators
非 ASCII 字节数 → 0(dev/start-dev.cmd 同样为 0,原为 50)
cmd /c start-headless.cmd --check → 5/5 PASS,退出码 0
cmd /c start-headless.cmd(错误凭据) → 连续 5 次登录失败 → [exit] code 3 → pause
10.4 防回归:dev/check.mjs 增加批处理检查
`npm run check` 原来只跑 node --check,对 .cmd 完全无感知(所以这个 bug 是双击才发现)。
现在 dev/check.mjs 同时遍历 *.cmd / *.bat 并断言两件事:
1. 不含任何 >0x7F 的字节(报错时给出首次出现的偏移与上下文片段);
2. LF 与 CRLF 数量相等(存在裸 LF 就报错)。
自测(临时文件,验证完即删):
造一个 UTF-8 + LF 的坏文件 → FAIL,两条都被指出
造一个 ASCII + CRLF 的对照文件 → PASS
现在输出:静态检查:23/23 个文件通过(JS 21 · 批处理 2)
同时把这两条写进 README 的「无图形环境常见的坑」表(新增一行,症状列直接给出
'鍏?npm' / '01' / 'rofile' 这三个典型报错原文,方便以后按报错搜索)。
+2 -2
View File
@@ -62,8 +62,8 @@ orderBy 传 studyHours 不会被服务端接受(返回默认顺序),所以
- 课程完成回到列表时,深页码(短课程优先会到 300+ 页)直接跳回,不逐页翻。
六、实现要点
- 面板新增「优先短课程(时长正序)」复选框,默认开启,保存在 localStorage `yt-prefer-short`。
- 队列缓存在 sessionStorage `yt-short-catalog-v1`,5 分钟有效,关闭标签页即清空。
- 面板新增「优先短课程(时长正序)」复选框,默认开启,保存在 localStorage `yun-xue-tang-prefer-short`。
- 队列缓存在 sessionStorage `yun-xue-tang-short-catalog-v1`,5 分钟有效,关闭标签页即清空。
- 选课时按 studyHours 升序;时长未知的排最后。
- 目标课程在其他页时先 jumpToPage,落地后按 id(不可用时按标题)匹配卡片。
- 失败降级链:跨页队列 → 当前页时长排序 → 原列表顺序,不会卡住批量任务。
Binary file not shown.

After

Width:  |  Height:  |  Size: 5.1 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 453 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 677 KiB

+8 -2
View File
@@ -1,13 +1,19 @@
{
"name": "yun-xue-tang-assistant",
"version": "2.7.0",
"version": "2.8.0",
"private": true,
"description": "云学堂(*.yunxuetang.cn)Tampermonkey 助手:自动登录、顺序听课、自动切节、批量刷课",
"scripts": {
"build": "node build.mjs",
"build:watch": "node build.mjs --watch",
"dev": "node dev/serve.mjs",
"check": "node --check yun-xue-tang-assistant.user.js && node --check dev/dev-loader.user.js && node --check dev/serve.mjs && node --check build.mjs"
"check": "node dev/check.mjs",
"test:real": "node dev/real-test.mjs",
"test:real:headless": "node dev/real-test.mjs --headless",
"test:e2e": "node dev/real-e2e.mjs",
"test:e2e:play": "node dev/real-e2e.mjs --play",
"headless": "node runner/headless.mjs",
"headless:check": "node runner/headless.mjs --check"
},
"engines": {
"node": ">=18"
+49
View File
@@ -0,0 +1,49 @@
/**
* 无头运行器配置文件(JS 模块,可以写注释、也可以写表达式)。
*
* 生效优先级(后者覆盖前者):
* 内置默认值 < 本文件 < 环境变量 YUN_XUE_TANG_* < 命令行参数 --x
*
* 账号密码不在这里:仍然只认环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD,
* 这样本文件可以放心提交,也不会出现在 `ps` / 任务管理器 / 计划任务历史里。
*
* 改完直接重新运行 `node runner/headless.mjs` 即生效,不需要 npm run build
* (build 只打包注入浏览器的 src/ 脚本)。
*
* 每一项的覆盖方式见 README「无头运行 → 配置文件」;`--help` 会打印带默认值的完整清单。
*/
export default {
// ---------- 选课 / 刷课策略 ----------
/** 本次最多完成多少门课;0 = 不限(一直刷到没有未学完的课) */
maxCourses: 10,
/** 运行多少分钟后收尾退出;0 = 不限(适合 cron 定长跑时设成 60) */
budgetMinutes: 0,
/** 优先总时长最短的课程(正序);false = 按列表原顺序 */
preferShort: true,
/** 脚本自己停下后等多少分钟再开新一轮;0 = 直接退出。配合 --max 可以实现分段刷完 */
restartMinutes: 0,
/** 连续多少分钟没有任何进展就判定卡死并退出(0 = 用内置的 30 分钟) */
idleRestartMinutes: 30,
// ---------- 站点 / 浏览器 ----------
/** 站点根地址(换分公司环境只改这一行) */
origin: 'https://kfmic.yunxuetang.cn',
/** 起始页面;留空 = <origin>/login.html */
url: '',
/** CDP 调试端口;同机跑多个实例时分开 */
port: 9336,
/** true = 无头(默认);false = 开有界面浏览器,需要图形会话,没有时会被强制无头 */
headless: true,
/** Chrome/Chromium 可执行文件路径;留空 = 自动探测 */
chrome: '',
/** 追加给浏览器的命令行参数(空格分隔),例如 '--proxy-server=socks5://127.0.0.1:1080' */
extraArgs: '',
// ---------- 文件 / 日志 ----------
/** 持久化 profile 目录(cookie / localStorage);留空 = ./.run-profile,删掉即重置登录态 */
profile: './.run-profile',
/** 日志文件;留空 = ./run-logs/headless.log */
logFile: './run-logs/headless.log',
/** 单个日志文件上限(字节),超出后轮转成 .1 */
logMaxBytes: 5 * 1024 * 1024,
};
+271
View File
@@ -0,0 +1,271 @@
// 浏览器探测与启动:Linux 无图形化服务器(含 root / 容器)与 Windows 无人值守都适配。
//
// 关键点:
// - 无显示环境下必须 --headless=new(或回退 --headless),否则 Chrome 起不来;
// - 以 root 运行时 Chromium 拒绝启动,必须 --no-sandbox;
// - 容器里 /dev/shm 通常只有 64MB,必须 --disable-dev-shm-usage,否则标签页会崩;
// - 服务器上没有 GPU/音频设备,关闭相关初始化可减少噪声与卡顿;
// - user-data-dir 固定到可配置目录(持久化 cookie),并清理上次被强杀留下的残局:
// Linux 的 SingletonLock 符号链接、Windows 的 lockfile,以及两个平台上
// 「被任务管理器/ kill -9 杀掉后留下来占着端口的孤儿浏览器进程」。
//
// 平台相关的判断(有无图形会话、沙箱参数、进程树怎么收)全部在 platform.mjs,
// 这里只负责「探测路径 + 拼参数 + 启动 + 等端口就绪」。
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { spawn } from 'node:child_process';
import { httpJson, sleep } from './cdp.mjs';
import {
isWindows, isLinux, isRunningAsRoot, safetyArgs, killTree, killProfileOrphans,
} from './platform.mjs';
// 由本模块统一再导出,老的调用方(dev/real-cdp.mjs 等)不用改
// (hasDisplay / safetyArgs 只在这里转发,本模块内部不直接用)
export {
hasDisplay, safetyArgs, isRunningAsRoot, platformName, noDisplayReason,
} from './platform.mjs';
// 各平台常见的 Chrome / Chromium 安装位置(按优先级)
const CANDIDATES = [
process.env.YUN_XUE_TANG_CHROME_BIN,
process.env.YUN_XUE_TANG_CHROME,
// Linux(发行版包管理器)
'/usr/bin/google-chrome',
'/usr/bin/google-chrome-stable',
'/usr/bin/chromium',
'/usr/bin/chromium-browser',
'/snap/bin/chromium',
'/opt/google/chrome/chrome',
// 常见容器镜像(playwright / puppeteer 预装)
'/root/.cache/ms-playwright/chromium-latest-linux/chrome-linux/chrome',
'/ms-playwright/chromium-*/chrome-linux/chrome',
'/usr/lib/chromium/chromium',
'/usr/lib/chromium-browser/chromium-browser',
// Windows:Chrome / Edge / Chromium 的常见安装位置(含按用户安装的 LOCALAPPDATA)
process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, 'Google/Chrome/Application/chrome.exe'),
process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, 'Chromium/Application/chrome.exe'),
process.env.PROGRAMFILES && path.join(process.env.PROGRAMFILES, 'Google/Chrome/Application/chrome.exe'),
process.env['PROGRAMFILES(X86)'] && path.join(process.env['PROGRAMFILES(X86)'], 'Google/Chrome/Application/chrome.exe'),
process.env.PROGRAMFILES && path.join(process.env.PROGRAMFILES, 'Microsoft/Edge/Application/msedge.exe'),
process.env['PROGRAMFILES(X86)'] && path.join(process.env['PROGRAMFILES(X86)'], 'Microsoft/Edge/Application/msedge.exe'),
'C:/Program Files/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
'C:/Program Files/Microsoft/Edge/Application/msedge.exe',
// macOS
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
'/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
'/Applications/Chromium.app/Contents/MacOS/Chromium',
].filter(Boolean);
// 运行时的可执行名(Windows 上文件名带 .exe,Linux 上可执行名不带扩展名)
const EXE_RE = /(^|[\/])(chrome|chromium|msedge)(\.exe)?$/i;
function isFile(p) {
try { return fs.statSync(p).isFile(); } catch (e) { return false; }
}
// 通配符路径(例如 playwright 缓存目录带哈希后缀)逐个展开
function expandGlob(patterns) {
const out = [];
const seen = new Set();
const walk = function (dir, depth) {
if (depth > 6) return;
let entries;
try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (e) { return; }
for (const en of entries) {
const full = path.join(dir, en.name);
if (en.isFile() && EXE_RE.test(full) && isFile(full)) {
if (!seen.has(full)) { seen.add(full); out.push(full); }
} else if (en.isDirectory()) {
walk(full, depth + 1);
}
}
};
for (const p of patterns) {
if (p.indexOf('*') < 0) continue;
const base = p.slice(0, p.indexOf('*'));
walk(base.endsWith('/') ? base : base.slice(0, base.lastIndexOf('/') + 1), 0);
}
return out;
}
export function resolveBrowser() {
const globbed = expandGlob(CANDIDATES);
const all = CANDIDATES.concat(globbed);
for (const p of all) {
if (p && p.indexOf('*') < 0 && isFile(p)) return p;
}
return null;
}
export function listCandidatePaths() {
return CANDIDATES.concat(expandGlob(CANDIDATES));
}
// 上次进程被强杀(kill -9 / 任务管理器「结束任务」)时,profile 目录会留下锁文件,
// Chrome 可能因此拒绝启动或一直弹「配置文件正在使用中」。
//
// 两套锁的名字不同:
// POSIX SingletonLock / SingletonSocket / SingletonCookie,lock 是指向 hostname-pid 的符号链接,
// 目标 pid 不存在即视为陈旧(还存在就说明真有浏览器在跑,不能动)。
// Windows 用普通的空文件 lockfile;Windows 上没法从文件反查 pid,
// 所以由调用方先用 killProfileOrphans() 把残留进程收掉,再清文件。
export function cleanStaleSingleton(profileDir) {
const names = isWindows
? ['lockfile', 'SingletonLock', 'SingletonSocket', 'SingletonCookie']
: ['SingletonLock', 'SingletonSocket', 'SingletonCookie'];
for (const name of names) {
const p = path.join(profileDir, name);
let st;
try { st = fs.lstatSync(p); } catch (e) { continue; }
try {
if (st.isSymbolicLink()) {
const target = fs.readlinkSync(p);
const m = /-(\d+)$/.exec(target);
const pid = m ? Number(m[1]) : 0;
let alive = false;
if (pid > 0) {
try { process.kill(pid, 0); alive = true; } catch (e) { alive = false; }
}
if (alive) continue; // 真的有浏览器在跑,别动
fs.unlinkSync(p);
} else {
fs.unlinkSync(p);
}
} catch (e) { /* ignore */ }
}
}
export function buildArgs({
profileDir, port, headless, noSandbox, windowSize = '1360,940', extraArgs = [],
}) {
const args = [
`--remote-debugging-port=${port}`,
`--remote-debugging-address=127.0.0.1`,
`--user-data-dir=${profileDir}`,
'--no-first-run',
'--no-default-browser-check',
'--disable-sync',
'--disable-background-networking',
'--disable-component-update',
'--disable-features=Translate,MediaRouter,OptimizationHints',
// 后台标签页/最小化时不要把定时器与视频节流,否则「持续听课」测不准
'--disable-background-timer-throttling',
'--disable-renderer-backgrounding',
'--disable-backgrounding-occluded-windows',
// 无人值守必须自己能起播,不能等用户手势
'--autoplay-policy=no-user-gesture-required',
'--mute-audio',
// 服务器 / 无人值守机器上没有可用的 GPU 加速,关掉能少一类崩溃与噪声
'--disable-gpu',
'--window-size=' + windowSize,
];
// 下面这些都是 POSIX 概念,Windows 上不认(加了也无害,但没必要)
if (!isWindows) {
args.push(
// 容器里 /dev/shm 通常只有 64MB,不加会随机崩标签页
'--disable-dev-shm-usage',
// 部分发行版 / 容器里 zygote 起不来
'--no-zygote',
);
}
if (noSandbox && (isLinux || isRunningAsRoot())) {
// Linux 服务器常见两种情况都需要它:以 root 运行、容器内 namespace 受限
args.push('--no-sandbox', '--disable-setuid-sandbox');
}
// 本平台额外需要的稳定性参数(Windows:不弹崩溃恢复气泡,免得无人值守时卡在等点击)
args.push(...safetyArgs());
if (headless) args.push('--headless=new', '--hide-scrollbars');
// 去重:上面手写的 Linux 参数和 safetyArgs() 有重叠,同一个开关重复传给 Chrome 没意义
// (但 --disable-features 这类「后面的覆盖前面的」要注意,所以按首次出现保留并合并)
return [...new Set(args)].concat(extraArgs, ['about:blank']);
}
// 启动浏览器并等 CDP 端口就绪。失败时回退到老的无头开关(老版本 Chromium 不认 --headless=new)。
export async function launchBrowser(opts) {
const {
binary, profileDir, port, headless = true, noSandbox = true,
extraArgs = [], timeoutMs = 45000, log = () => {},
} = opts;
fs.mkdirSync(profileDir, { recursive: true });
// 先收残留进程(被强杀后留下的孤儿会一直占着 CDP 端口),再清锁文件
const orphans = await killProfileOrphans(profileDir, { log });
if (orphans) log('[浏览器] 已清理 ' + orphans + ' 个残留浏览器进程');
cleanStaleSingleton(profileDir);
// headless=true 先试 --headless=new,起不来再试 --headless
const modes = headless ? [true, 'old'] : [false];
let lastErr = null;
for (const mode of modes) {
const isNew = mode === true || mode === 'old';
let args = buildArgs({
profileDir, port, headless: isNew, noSandbox, extraArgs,
});
if (mode === 'old') {
args = args.map((a) => (a === '--headless=new' ? '--headless' : a));
}
log('[浏览器] 启动:' + binary + ' ' + (isNew ? (mode === 'old' ? '(headless 旧模式)' : '(headless=new)') : '(有界面)'));
// windowsHide:Windows 上不加会闪一个黑色控制台窗口,无人值守时必须隐藏
const child = spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
let stderrTail = '';
child.stderr.on('data', (b) => { stderrTail = (stderrTail + String(b)).slice(-4000); });
child.stdout.on('data', () => {});
let exited = false;
child.on('exit', (code, signal) => {
exited = true;
if (code !== 0 && code !== null) log('[浏览器] 进程退出 code=' + code + ' signal=' + signal);
});
const started = Date.now();
let version = null;
while (Date.now() - started < timeoutMs) {
if (exited) break;
try {
const v = await httpJson(`http://127.0.0.1:${port}/json/version`);
if (v && v.webSocketDebuggerUrl) { version = v; break; }
} catch (e) { /* 还没起来 */ }
await sleep(300);
}
if (version) {
return {
child, version, args,
headless: isNew,
kill: function () {
// 跨平台收进程树(Windows 走 TerminateProcess + taskkill /T,POSIX 走 SIGTERM→SIGKILL)
return killTree(child, { log });
},
};
}
await killTree(child, { log, timeoutMs: 3000 });
await sleep(500);
lastErr = new Error('CDP 端口未就绪(' + port + ')');
if (stderrTail.trim()) {
lastErr.message += '\n浏览器 stderr(尾部):\n' + stderrTail.trim().split('\n').slice(-12).join('\n');
}
// 只有 headless 才需要回退,非 headless 直接报错
if (!headless) break;
}
throw lastErr || new Error('浏览器启动失败');
}
// 建议的持久化 profile 目录:默认放项目内的 .run-profile(可用 YUN_XUE_TANG_PROFILE_DIR 覆盖)
export function defaultProfileDir(root) {
if (process.env.YUN_XUE_TANG_PROFILE_DIR) return path.resolve(process.env.YUN_XUE_TANG_PROFILE_DIR);
return path.join(root, '.run-profile');
}
export function tmpProfileDir(prefix = 'yun-xue-tang-headless-') {
return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
}
+87
View File
@@ -0,0 +1,87 @@
// 极简 CDP 客户端:Node 22+ 原生 WebSocket,无需 puppeteer / playwright。
// 与 dev/real-cdp.mjs 同一套思路,额外提供「连接断开回调」与事件订阅失败隔离,
// 供无人值守的 runner/headless.mjs 在断线时判断是否需要重建浏览器。
export async function connect(wsUrl, opts = {}) {
const ws = new WebSocket(wsUrl);
await new Promise(function (res, rej) {
ws.addEventListener('open', res, { once: true });
ws.addEventListener('error', rej, { once: true });
});
let id = 0;
const pending = new Map();
const events = [];
const waiters = [];
const listeners = [];
const state = { closed: false };
ws.addEventListener('close', function () {
state.closed = true;
// 断线后所有未完成的调用直接拒绝,避免 runner 卡死在 await 上
for (const [, p] of pending) {
try { p.rej(new Error('CDP 连接已断开')); } catch (e) { /* ignore */ }
}
pending.clear();
if (typeof opts.onClose === 'function') {
try { opts.onClose(); } catch (e) { /* ignore */ }
}
});
ws.addEventListener('message', function (ev) {
const msg = JSON.parse(ev.data);
if (msg.id != null && pending.has(msg.id)) {
const { res, rej } = pending.get(msg.id);
pending.delete(msg.id);
if (msg.error) rej(new Error(msg.error.message));
else res(msg.result);
return;
}
events.push(msg);
for (const fn of listeners) {
try { fn(msg); } catch (e) { /* 忽略订阅者异常 */ }
}
for (let i = waiters.length - 1; i >= 0; i--) {
if (waiters[i].match(msg)) waiters.splice(i, 1)[0].res(msg);
}
});
const send = function (method, params = {}) {
return new Promise(function (res, rej) {
if (state.closed) { rej(new Error('CDP 连接已断开')); return; }
const mid = ++id;
pending.set(mid, { res, rej });
try {
ws.send(JSON.stringify({ id: mid, method, params }));
} catch (e) {
pending.delete(mid);
rej(e);
}
});
};
const waitEvent = function (name, timeoutMs = 30000) {
return new Promise(function (res, rej) {
const timer = setTimeout(function () { rej(new Error('等待事件超时: ' + name)); }, timeoutMs);
waiters.push({
match: (m) => m.method === name,
res: (m) => { clearTimeout(timer); res(m.params); },
});
});
};
const onEvent = function (fn) { listeners.push(fn); };
return {
ws, send, waitEvent, onEvent, events,
get closed() { return state.closed; },
close: function () { try { ws.close(); } catch (e) { /* ignore */ } },
};
}
export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
export async function httpJson(url, method = 'GET') {
const r = await fetch(url, { method });
const t = await r.text();
try { return JSON.parse(t); } catch (e) { return t; }
}
+356
View File
@@ -0,0 +1,356 @@
// 运行参数与路径:配置文件 / 环境变量 / 命令行在这里集中解析,其它模块只读导出的常量。
//
// 优先级(后者覆盖前者):
// 内置默认值 < runner.config.mjs < 环境变量 YUN_XUE_TANG_* < 命令行参数 --x
//
// 配置文件是 JS 模块(见仓库根目录的 runner.config.mjs),可以写注释和表达式。
// 账号密码不在配置文件里,只认环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD,
// 避免凭据进入版本库、进程列表和计划任务历史。
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
import { defaultProfileDir } from './browser.mjs';
import { hasDisplay, noDisplayReason, platformName } from './platform.mjs';
export { platformName, noDisplayReason };
const HERE = path.dirname(fileURLToPath(import.meta.url));
export const ROOT = path.resolve(HERE, '..');
/** 构建产物(注入页面的单文件脚本) */
export const SCRIPT_FILE = path.join(ROOT, 'yun-xue-tang-assistant.user.js');
// ---------------------------------------------------------------------------
// 一层:内置默认值
// ---------------------------------------------------------------------------
const DEFAULTS = {
maxCourses: 0, // 0 = 不限(一直刷到没有未学完的课)
budgetMinutes: 0, // 0 = 不限
preferShort: true,
restartMinutes: 0, // 0 = 停下就退出
idleRestartMinutes: 30,
origin: 'https://kfmic.yunxuetang.cn',
url: '', // 留空 = <origin>/login.html
port: 9336,
headless: true,
chrome: '',
extraArgs: '',
profile: '', // 留空 = ./.run-profile
logFile: '', // 留空 = ./run-logs/headless.log
logMaxBytes: 5 * 1024 * 1024,
};
const argv = process.argv.slice(2);
// 已废弃 / 旧版参数别名:老脚本里的写法继续可用,不报错
const DEPRECATED = {
'--visible': '已废弃:等价于设置 headless: false(或 --headless 0),本版本仍然可用',
};
/** 旧参数名 -> 配置字段(保持向后兼容,dev/ 下的脚本还在用) */
const ALIASES = {
'--max': 'maxCourses',
'--budget': 'budgetMinutes',
'--restart': 'restartMinutes',
'--idle': 'idleRestartMinutes',
'--log': 'logFile',
'--log-max': 'logMaxBytes',
};
// ---------------------------------------------------------------------------
// 两层:读配置文件(JS 模块)
// ---------------------------------------------------------------------------
/** 配置文件路径:命令行 --config > 环境变量 YUN_XUE_TANG_CONFIG > 仓库根目录 runner.config.mjs */
function configPath() {
const i = argv.indexOf('--config');
if (i >= 0 && argv[i + 1]) return path.resolve(argv[i + 1]);
if (process.env.YUN_XUE_TANG_CONFIG) return path.resolve(process.env.YUN_XUE_TANG_CONFIG);
const def = path.join(ROOT, 'runner.config.mjs');
return fs.existsSync(def) ? def : '';
}
export const CONFIG_FILE = configPath();
const CONFIG_KNOWN = new Set([...Object.keys(DEFAULTS), 'username', 'password', 'check']);
let fileConfig = {};
const configWarnings = [];
if (CONFIG_FILE) {
try {
const mod = await import(pathToFileURL(CONFIG_FILE).href + '?t=' + Date.now());
const raw = mod.default;
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
throw new Error('默认导出必须是一个对象:export default { ... }');
}
for (const [k, v] of Object.entries(raw)) {
if (!CONFIG_KNOWN.has(k)) configWarnings.push('配置文件里有未知字段「' + k + '」,已忽略');
else if (v !== undefined) fileConfig[k] = v;
}
// 配置里写了账号:不采纳,只提示一次,避免有人以为这样能生效
if (fileConfig.username !== undefined || fileConfig.password !== undefined) {
configWarnings.push('配置文件里的 username / password 已忽略:凭据只认环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD');
}
} catch (e) {
const explicit = argv.includes('--config') || !!process.env.YUN_XUE_TANG_CONFIG;
const msg = e && e.code === 'ERR_MODULE_NOT_FOUND'
? (explicit ? '指定的配置文件不存在' : '配置文件导入失败')
: '配置文件内容有误';
console.error(msg + ':' + CONFIG_FILE + '\n ' + (e && e.message ? e.message.split('\n')[0] : e));
process.exit(2);
}
}
// ---------------------------------------------------------------------------
// 命令行解析:--key value / --key=value / --flag
// ---------------------------------------------------------------------------
const BOOL_KEYS = ['preferShort', 'headless', 'check'];
const NUM_KEYS = ['maxCourses', 'budgetMinutes', 'restartMinutes', 'idleRestartMinutes', 'port', 'logMaxBytes'];
const STR_KEYS = ['origin', 'url', 'profile', 'logFile', 'chrome', 'extraArgs', 'config'];
/** kebab-case → camelCase:--max-courses → maxCourses */
function toCamel(flag) {
return flag.replace(/^--/, '').replace(/-([a-z])/g, (m, c) => c.toUpperCase());
}
const camelToFlag = (k) => '--' + k.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase());
function parseBool(v, raw) {
const s = String(v).trim().toLowerCase();
if (['1', 'true', 'yes', 'on', 'y'].includes(s)) return true;
if (['0', 'false', 'no', 'off', 'n'].includes(s)) return false;
console.error('参数值不是布尔值:' + raw + '(可用 1/0、true/false、on/off)');
process.exit(2);
}
const cliRaw = {};
const unknownFlags = [];
const missingValues = [];
for (let i = 0; i < argv.length; i++) {
const a = argv[i];
if (!a.startsWith('--')) {
unknownFlags.push(a);
continue;
}
const eq = a.indexOf('=');
let name;
let inline;
if (eq > 0) {
name = a.slice(0, eq);
inline = a.slice(eq + 1);
} else {
name = a;
}
if (DEPRECATED[name]) configWarnings.push(DEPRECATED[name]);
let key = toCamel(name);
if (ALIASES[name]) key = ALIASES[name];
if (name === '--visible') key = 'headless'; // --visible = headless false
if (name === '--help' || name === '-h') key = 'help';
if (name === '--check') key = 'check';
const known = CONFIG_KNOWN.has(key) || key === 'help' || key === 'config';
if (!known) {
unknownFlags.push(name);
// 把未知参数的值一并吞掉,否则它会被当成一个独立的多余位置参数一起报
if (inline === undefined && argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) i++;
continue;
}
if (!BOOL_KEYS.includes(key) && !NUM_KEYS.includes(key) && !STR_KEYS.includes(key) && key !== 'help' && key !== 'config') {
unknownFlags.push(name);
if (inline === undefined && argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) i++;
continue;
}
// 布尔量可以不带值(--check 等于 --check 1);数值和字符串必须带值
let val;
if (inline !== undefined) val = inline;
else if (BOOL_KEYS.includes(key) && (argv[i + 1] === undefined || argv[i + 1].startsWith('--'))) val = '1';
else if (argv[i + 1] !== undefined && !argv[i + 1].startsWith('--')) val = argv[++i];
else {
missingValues.push(name);
continue;
}
if (name === '--visible') val = String(parseBool(val, name) ? 0 : 1); // --visible 0 → headless 1
cliRaw[key] = val;
}
// ---------------------------------------------------------------------------
// 三层:环境变量
// ---------------------------------------------------------------------------
const envNum = (name, cur) => {
const v = process.env[name];
if (v === undefined || v === '') return cur;
const n = Number(v);
if (!Number.isFinite(n)) {
configWarnings.push(name + ' 不是数字,已忽略:' + v);
return cur;
}
return n;
};
const envBool = (name, cur) => {
const v = process.env[name];
if (v === undefined || v === '') return cur;
return !/^(0|false|no|off)$/i.test(v);
};
const envStr = (name, cur) => {
const v = process.env[name];
return v === undefined || v === '' ? cur : v;
};
// ---------------------------------------------------------------------------
// 合并:defaults < 配置文件 < 环境变量 < 命令行
// ---------------------------------------------------------------------------
const merged = { ...DEFAULTS, ...fileConfig };
merged.maxCourses = envNum('YUN_XUE_TANG_MAX_COURSES', merged.maxCourses);
merged.budgetMinutes = envNum('YUN_XUE_TANG_BUDGET_MINUTES', merged.budgetMinutes);
merged.restartMinutes = envNum('YUN_XUE_TANG_RESTART_MINUTES', merged.restartMinutes);
merged.idleRestartMinutes = envNum('YUN_XUE_TANG_IDLE_RESTART_MINUTES', merged.idleRestartMinutes);
merged.port = envNum('YUN_XUE_TANG_CDP_PORT', merged.port);
merged.logMaxBytes = envNum('YUN_XUE_TANG_LOG_MAX_BYTES', merged.logMaxBytes);
merged.preferShort = envBool('YUN_XUE_TANG_PREFER_SHORT', merged.preferShort);
merged.headless = envBool('YUN_XUE_TANG_HEADLESS', merged.headless);
merged.origin = envStr('YUN_XUE_TANG_ORIGIN', merged.origin);
merged.url = envStr('YUN_XUE_TANG_URL', merged.url);
merged.logFile = envStr('YUN_XUE_TANG_LOG_FILE', merged.logFile);
merged.profile = envStr('YUN_XUE_TANG_PROFILE_DIR', merged.profile);
merged.chrome = envStr('YUN_XUE_TANG_CHROME_BIN', merged.chrome);
merged.extraArgs = envStr('YUN_XUE_TANG_EXTRA_ARGS', merged.extraArgs);
// 命令行最后覆盖
const numBad = [];
for (const [key, raw] of Object.entries(cliRaw)) {
if (key === 'help' || key === 'config') continue;
if (key === 'check') { merged.check = parseBool(raw, '--check'); continue; }
if (BOOL_KEYS.includes(key)) { merged[key] = parseBool(raw, camelToFlag(key)); continue; }
if (NUM_KEYS.includes(key)) {
const n = Number(raw);
if (!Number.isFinite(n)) numBad.push(camelToFlag(key) + ' 需要数字,收到「' + raw + '」');
else merged[key] = n;
continue;
}
merged[key] = raw;
}
// ---------------------------------------------------------------------------
// 校验
// ---------------------------------------------------------------------------
const problems = [...numBad];
if (numBad.length === 0) {
if (!(merged.port >= 1 && merged.port <= 65535)) problems.push('port 必须在 1-65535 之间,收到 ' + merged.port);
if (!(merged.maxCourses >= 0)) problems.push('maxCourses 不能为负,收到 ' + merged.maxCourses);
if (!(merged.budgetMinutes >= 0)) problems.push('budgetMinutes 不能为负,收到 ' + merged.budgetMinutes);
if (!(merged.restartMinutes >= 0)) problems.push('restartMinutes 不能为负,收到 ' + merged.restartMinutes);
if (!(merged.idleRestartMinutes >= 0)) problems.push('idleRestartMinutes 不能为负,收到 ' + merged.idleRestartMinutes);
if (!(merged.logMaxBytes >= 0)) problems.push('logMaxBytes 不能为负,收到 ' + merged.logMaxBytes);
}
if (unknownFlags.length) {
const uniq = [...new Set(unknownFlags)];
problems.push('无法识别的参数:' + uniq.join(' ') + '(用 --help 查看支持的参数)');
}
if (missingValues.length) {
const uniq = [...new Set(missingValues)];
problems.push('这些参数缺少值:' + uniq.join(' '));
}
export const HELP = argv.includes('--help') || argv.includes('-h');
if (problems.length && !HELP) {
console.error('参数有误:');
for (const p of problems) console.error(' · ' + p);
console.error('\n用 --help 查看支持的参数与配置文件字段。');
process.exit(2);
}
// ---------------------------------------------------------------------------
// 导出(保持原有大写下划线命名,其它模块不用改)
// ---------------------------------------------------------------------------
export const CHECK_ONLY = !!merged.check;
export const ORIGIN = String(merged.origin || DEFAULTS.origin).replace(/\/+$/, '');
export const START_URL = merged.url ? String(merged.url) : ORIGIN + '/login.html';
export const USR = process.env.YUN_XUE_TANG_USR || '';
export const PWD = process.env.YUN_XUE_TANG_PWD || '';
export const PORT = merged.port;
/** 本次最多完成几门课(0 = 不限) */
export const MAX_COURSES = merged.maxCourses;
/** 运行多少分钟后收尾(0 = 不限) */
export const BUDGET_MINUTES = merged.budgetMinutes;
export const PROFILE_DIR = merged.profile
? path.resolve(ROOT, merged.profile)
: defaultProfileDir(ROOT);
// 没有图形显示的环境(Linux 无 DISPLAY、Windows 的 Session 0)上开不了有界面浏览器,
// 即使配置成有界面也强制无头:否则 Chrome 在 Linux 上报「Missing X server」然后退出,
// 在 Windows 服务会话里则是起来就崩。
export const WANT_VISIBLE = !merged.headless;
export const VISIBLE = WANT_VISIBLE && hasDisplay();
export const PREFER_SHORT = merged.preferShort;
/** 脚本自己停下后等待多少分钟再开新一轮(0 = 直接退出) */
export const RESTART_MINUTES = merged.restartMinutes;
/** 连续多少分钟没有任何进展判定卡死 */
export const IDLE_RESTART_MINUTES = merged.idleRestartMinutes;
export const LOG_FILE = merged.logFile
? path.resolve(ROOT, merged.logFile)
: path.join(ROOT, 'run-logs/headless.log');
export const LOG_MAX_BYTES = merged.logMaxBytes;
export const EXTRA_ARGS = String(merged.extraArgs || '').split(/\s+/).filter(Boolean);
/** 配置文件里指定的浏览器路径(空 = 自动探测;优先级低于 YUN_XUE_TANG_CHROME_BIN,见 browser.mjs) */
export const CHROME_BIN = merged.chrome || '';
export const WARNINGS = configWarnings;
/** 一条便于粘贴到 issue / 日志的自述 */
export function describeRun() {
return {
configFile: CONFIG_FILE || '(未找到,使用内置默认值)',
platform: platformName,
checkOnly: CHECK_ONLY,
headless: !VISIBLE,
port: PORT,
maxCourses: MAX_COURSES > 0 ? MAX_COURSES : '不限',
budgetMinutes: BUDGET_MINUTES > 0 ? BUDGET_MINUTES : '不限',
preferShort: PREFER_SHORT,
restartMinutes: RESTART_MINUTES,
idleRestartMinutes: IDLE_RESTART_MINUTES,
profileDir: PROFILE_DIR,
logFile: LOG_FILE,
};
}
/** --help 文本:字段、命令行名、环境变量、当前生效值一起列出 */
export function helpText() {
const rows = [
['配置字段', '命令行', '环境变量', '当前生效', '说明'],
['maxCourses', '--max-courses', 'YUN_XUE_TANG_MAX_COURSES', MAX_COURSES, '本次最多完成几门课;0 = 不限'],
['budgetMinutes', '--budget-minutes', 'YUN_XUE_TANG_BUDGET_MINUTES', BUDGET_MINUTES, '跑多少分钟后收尾;0 = 不限'],
['preferShort', '--prefer-short', 'YUN_XUE_TANG_PREFER_SHORT', PREFER_SHORT, '优先总时长最短的课程'],
['restartMinutes', '--restart-minutes', 'YUN_XUE_TANG_RESTART_MINUTES', RESTART_MINUTES, '脚本停下后等几分钟开新一轮;0 = 退出'],
['idleRestartMinutes', '--idle-restart-minutes', 'YUN_XUE_TANG_IDLE_RESTART_MINUTES', IDLE_RESTART_MINUTES, '多少分钟无进展判卡死'],
['origin', '--origin', 'YUN_XUE_TANG_ORIGIN', ORIGIN, '站点根地址'],
['url', '--url', 'YUN_XUE_TANG_URL', START_URL, '起始页面;空 = <origin>/login.html'],
['port', '--port', 'YUN_XUE_TANG_CDP_PORT', PORT, 'CDP 调试端口'],
['headless', '--headless 0|1', 'YUN_XUE_TANG_HEADLESS', !VISIBLE, '1 = 无头,0 = 有界面'],
['chrome', '--chrome', 'YUN_XUE_TANG_CHROME_BIN', CHROME_BIN || '(自动探测)', '浏览器可执行文件'],
['extraArgs', '--extra-args', 'YUN_XUE_TANG_EXTRA_ARGS', EXTRA_ARGS.join(' ') || '(无)', '追加给浏览器的参数'],
['profile', '--profile', 'YUN_XUE_TANG_PROFILE_DIR', PROFILE_DIR, '持久化 profile 目录'],
['logFile', '--log-file', 'YUN_XUE_TANG_LOG_FILE', LOG_FILE, '日志文件'],
['logMaxBytes', '--log-max-bytes', 'YUN_XUE_TANG_LOG_MAX_BYTES', LOG_MAX_BYTES, '单文件上限,超出轮转'],
['(字段 check)', '--check', '', CHECK_ONLY, '只做环境自检,不动进度'],
['(无字段)', '--config', 'YUN_XUE_TANG_CONFIG', CONFIG_FILE || '(内置默认)', '指定配置文件路径'],
];
const widths = [0, 1, 2, 3].map((c) => Math.max(...rows.map((r) => String(r[c]).length)));
const lines = [];
lines.push('云学堂无头运行器');
lines.push('');
lines.push('用法:node runner/headless.mjs [参数…]');
lines.push('优先级:内置默认值 < 配置文件 < 环境变量 YUN_XUE_TANG_* < 命令行参数');
lines.push('配置文件:' + (CONFIG_FILE || '(未找到)') + (CONFIG_FILE ? '' : ' —— 复制仓库里的 runner.config.mjs 即可'));
lines.push('账号密码:只认环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD(不写进配置文件)');
lines.push('');
for (let i = 0; i < rows.length; i++) {
const r = rows[i].map((v, c) => (c < 4 ? String(v).padEnd(widths[c]) : String(v)));
lines.push((i === 0 ? '' : '') + r.join(' '));
if (i === 0) lines.push(' '.repeat(0) + widths.map((w) => '-'.repeat(w)).join(' '));
}
lines.push('');
lines.push('示例:');
lines.push(' node runner/headless.mjs --check # 只做环境自检');
lines.push(' node runner/headless.mjs --max-courses 3 # 本次最多 3 门');
lines.push(' node runner/headless.mjs --headless 0 # 开有界面浏览器调试');
lines.push(' node runner/headless.mjs --config ./runner.config.mjs # 显式指定配置文件');
lines.push('');
lines.push('旧参数名(仍然兼容):--max / --budget / --restart / --idle / --log / --log-max / --visible');
return lines.join('\n');
}
+106
View File
@@ -0,0 +1,106 @@
#!/usr/bin/env node
/**
* 无头运行器入口:在**无图形化环境**里跑云学堂助手。
* 支持 Linux 服务器(机房机器 / 云主机 / 容器)与 Windows(桌面后台、服务器核心版、
* 计划任务、Session 0 服务),也能在 macOS 上无头跑。
*
* 这个文件只做「组装」:解析参数 → 启动前预检 → 交给 supervisor 跑。
* 具体实现在同目录的模块里:
*
* config.mjs 参数与环境变量(--max / YUN_XUE_TANG_* 全部集中在这里)
* platform.mjs 平台差异(有无图形会话、沙箱参数、进程树收尾、端口排查命令)
* preflight.mjs 启动前检查(产物 / Node 版本 / 凭据 / 浏览器 / 端口)
* log.mjs 终端 + 文件日志(超上限轮转)
* stop.mjs 终止信号优雅退出(Windows 上按 SIGINT/SIGBREAK/SIGHUP)
* browser.mjs 浏览器探测、启动参数(root / 容器 / Windows 无人值守适配)、残局清理
* cdp.mjs 极简 CDP 客户端
* page.mjs 注入后要调用的页面 JS 表达式 + page 求值封装
* session.mjs 单次会话:起浏览器 → 注入 → 自动登录 → 刷课 → 监控 → 收尾
* selfcheck.mjs --check 的只读环境自检
* supervisor.mjs 崩溃重启循环与退出码
*
* 用法(详见 README「无头运行」):
* npm run build # 先出构建产物
* Linux/macOS: export YUN_XUE_TANG_USR=... export YUN_XUE_TANG_PWD=...
* Windows CMD: set YUN_XUE_TANG_USR=... set YUN_XUE_TANG_PWD=...
* Windows PS: $env:YUN_XUE_TANG_USR='...'
* npm run headless # 前台常驻,Ctrl+C 结束
* npm run headless:check # 只做环境自检(只读,不登录、不刷课)
*
* 常用参数 / 环境变量:
* --check 只自检:浏览器可启动、页面可访问、脚本可注入、视频编解码可用,
* 不登录、不点课程、不动进度
* --max N 本次最多完成 N 门课(0 = 不限,默认读脚本自身配置)
* --budget N 运行 N 分钟后收尾(0 = 不限,默认 0)
* --profile DIR 持久化 profile 目录(默认 ./.run-profile)
* --port N CDP 调试端口(默认 9336)
* --visible 不无头(无图形环境里会被忽略;本机调试用)
* --url URL 起始页面(默认 https://kfmic.yunxuetang.cn/login.html)
* YUN_XUE_TANG_CHROME_BIN Chrome/Chromium 可执行文件路径(默认自动探测)
* YUN_XUE_TANG_EXTRA_ARGS 追加给浏览器的命令行参数(空格分隔)
* YUN_XUE_TANG_PREFER_SHORT 1/0,是否优先短课程(默认 1)
* YUN_XUE_TANG_RESTART_MINUTES 脚本停止/无进展后等待多久重新开始(0 = 直接退出,默认 0)
* YUN_XUE_TANG_IDLE_RESTART_MINUTES 连续无进展多少分钟后判定卡死(默认 30)
* YUN_XUE_TANG_LOG_FILE 日志文件路径(默认 ./run-logs/headless.log)
* YUN_XUE_TANG_LOG_MAX_BYTES 单个日志文件上限,超过就轮转成 .1(默认 5MB)
* YUN_XUE_TANG_HAS_DISPLAY 0/1,强制认定「有没有图形显示会话」(自动判断不准时用)
*
* 退出码:0 正常收尾 / 1 无进展卡死 / 2 环境或参数问题 / 3 连续登录失败
*/
import * as cfg from './config.mjs';
import { log, warn, error, closeLog } from './log.mjs';
import { createStopHandler } from './stop.mjs';
import { runPreflight, PreflightError } from './preflight.mjs';
import { runSupervisor } from './supervisor.mjs';
async function main() {
// --help:打印完整参数表(含配置文件字段、环境变量、当前生效值)后直接退出
if (cfg.HELP) {
console.log(cfg.helpText());
process.exit(0);
}
// 配置文件里有未知字段 / 废弃参数 / 被忽略的凭据:起来先提醒一句,不阻断
for (const w of cfg.WARNINGS || []) warn('配置:' + w);
const stop = createStopHandler({ log });
let pre;
try {
pre = await runPreflight({
checkOnly: cfg.CHECK_ONLY,
scriptFile: cfg.SCRIPT_FILE,
usr: cfg.USR,
pwd: cfg.PWD,
port: cfg.PORT,
profileDir: cfg.PROFILE_DIR,
chromeBin: cfg.CHROME_BIN,
log,
});
} catch (e) {
closeLog();
if (e instanceof PreflightError) {
for (const l of e.lines) error(l);
process.exit(e.exitCode);
}
throw e;
}
const { exitCode } = await runSupervisor({
cfg,
binary: pre.browser,
scriptSrc: pre.scriptSrc,
stop,
log,
warn,
error,
});
closeLog();
process.exit(exitCode);
}
main().catch((e) => {
error('致命错误:' + (e && e.stack ? e.stack : e));
closeLog();
process.exit(1);
});
+51
View File
@@ -0,0 +1,51 @@
// 日志:同时写终端和日志文件(文件超上限就轮转成 .1)。
//
// 用法:
// import { openLog, closeLog, log, warn, error } from './log.mjs';
// openLog(file, maxBytes); // 不调用就只打终端
// log('信息A', { x: 1 }); // → [2026-01-01 00:00:00] [信息] 信息A {"x":1}
//
// 注意:openLog 必须在任何写文件之前调用;closeLog 在进程退出路径上兜底调用。
import fs from 'node:fs';
import path from 'node:path';
let stream = null;
/** 打开日志文件;maxBytes 为单文件上限,超出时把现有文件改名成 .1 */
export function openLog(file, maxBytes) {
try {
fs.mkdirSync(path.dirname(file), { recursive: true });
try {
const st = fs.statSync(file);
if (st.size > maxBytes) fs.renameSync(file, file + '.1');
} catch (e) { /* 文件还不存在 */ }
stream = fs.createWriteStream(file, { flags: 'a' });
} catch (e) {
console.error('[日志] 无法写入 ' + file + ':' + e.message);
}
}
/** 关闭日志文件(可重复调用) */
export function closeLog() {
if (!stream) return;
try { stream.end(); } catch (e) { /* ignore */ } finally { stream = null; }
}
export function isLogOpen() {
return stream !== null;
}
const clock = () => new Date().toISOString().replace('T', ' ').slice(0, 19);
function line(level, args) {
const text = '[' + clock() + '] [' + level + '] ' + args.map(function (a) {
if (typeof a === 'string') return a;
try { return JSON.stringify(a); } catch (e) { return String(a); }
}).join(' ');
console.log(text);
if (stream) { try { stream.write(text + '\n'); } catch (e) { /* ignore */ } }
}
export const log = (...a) => line('信息', a);
export const warn = (...a) => line('警告', a);
export const error = (...a) => line('错误', a);
+149
View File
@@ -0,0 +1,149 @@
// 页面侧接口:所有「注入后要调用的 JS 表达式」集中在这里,外加把 CDP 的求值包成
// 好用的 page 对象。改脚本内部 API 时只需要动这一个文件。
//
// page.evalJS(expr) 求值并返回值(异常会抛出)
// page.json(expr) 求值并把返回的 JSON 字符串解析成对象
// page.tryEval(expr) 求值但吞掉异常,返回 undefined(页面正在跳转时用)
import { sleep } from './cdp.mjs';
/**
* @param {object} cdp cdp.mjs 的客户端
*/
export function createPage(cdp) {
const evalJS = async (expr) => {
const r = await cdp.send('Runtime.evaluate', {
expression: expr, returnByValue: true, awaitPromise: true, userGesture: true,
});
if (r.exceptionDetails) {
const d = r.exceptionDetails;
throw new Error((d.exception && d.exception.description) || d.text);
}
return r.result.value;
};
const json = async (expr) => JSON.parse(await evalJS(expr));
const tryEval = async (expr) => {
try { return await evalJS(expr); } catch (e) { return undefined; }
};
return { evalJS, json, tryEval };
}
/** 环境自检:脚本是否注入、面板是否渲染、视频编解码能力、中文字体 */
export const EXPR_SELF_CHECK = `JSON.stringify((function () {
var a = window.__yunXueTangAuto;
var probe = document.createElement('video');
var codecs = {
h264: probe.canPlayType('video/mp4; codecs="avc1.42E01E"') || '',
aac: probe.canPlayType('audio/mp4; codecs="mp4a.40.2"') || '',
vp9: probe.canPlayType('video/webm; codecs="vp9"') || '',
};
return {
url: location.href,
ua: navigator.userAgent,
api: typeof a,
version: (document.getElementById('yun-xue-tang-version') || {}).textContent || '',
panels: document.querySelectorAll('#yun-xue-tang-panel').length,
panelVisible: (function () {
var el = document.getElementById('yun-xue-tang-panel');
if (!el) return false;
var r = el.getBoundingClientRect();
return r.width > 0 && r.height > 0;
})(),
isLoginPage: a ? a.isLoginPage() : null,
route: a ? a.route() : null,
codecs: codecs,
fonts: (function () {
// 中文字体缺失不影响逻辑(靠 DOM 文本匹配),仅影响截图观感
var c = document.createElement('canvas').getContext('2d');
if (!c) return 'n/a';
c.font = '16px sans-serif';
var w = c.measureText('云学堂助手').width;
var w2 = c.measureText('abcd').width;
return w > 0 && w2 > 0 ? 'ok' : 'unknown';
})(),
};
})())`;
/** 看护循环:判断是否需要注入 / 是否在登录页 / 当前 --max 生效值 */
export const EXPR_WATCH = `JSON.stringify({
href: location.href,
ready: typeof window.__yunXueTangAuto === 'object',
onLogin: !!(window.__yunXueTangAuto && window.__yunXueTangAuto.isLoginPage()),
hasPwd: !!document.querySelector('input[type=password]'),
bodyLen: (document.body && document.body.innerText || '').length,
maxCourses: (window.__yunXueTangAuto && window.__yunXueTangAuto.CFG) ? window.__yunXueTangAuto.CFG.maxCourses : null,
})`;
/** 主监控快照:课程、课时、进度、倒计时、视频状态 */
export const EXPR_SNAPSHOT = `JSON.stringify((function () {
var a = window.__yunXueTangAuto;
if (!a) return { noApi: true, href: location.href };
var v = document.querySelector('video, audio');
var items = [];
try { items = a.lessonItems(); } catch (e) {}
return {
href: location.href,
route: a.route(),
running: a.S.batchRunning,
runFinished: a.S.batchFinished,
phase: a.S.coursePhase,
completed: a.S.completedThisRun,
pendingRetries: Object.keys(a.S.courseRetries || {}).length,
course: a.S.activeCourse ? a.S.activeCourse.title : null,
lesson: (a.readActiveLessonKey ? a.readActiveLessonKey() : ''),
lessons: items.length,
summary: a.readSummary(),
countdown: a.readCountdown(),
status: (document.getElementById('yun-xue-tang-status') || {}).textContent || '',
doneCount: Object.keys(a.S.completedTitles || {}).length,
retryCount: Object.keys(a.S.courseRetries || {}).length,
retryWait: (a.retryWaitSeconds ? a.retryWaitSeconds() : 0),
retryTitle: a.R.retryTitle || '',
video: v ? {
t: Math.round(v.currentTime), d: Math.round(v.duration || 0),
paused: v.paused, err: v.error ? v.error.code : 0, src: v.currentSrc ? 1 : 0,
} : null,
};
})())`;
/** 会话结尾的累计统计 */
export const EXPR_FINAL_STATS = `JSON.stringify((function () {
var a = window.__yunXueTangAuto;
if (!a) return {};
return {
completed: a.S.completedThisRun,
doneCount: Object.keys(a.S.completedTitles || {}).length,
retryCount: Object.keys(a.S.courseRetries || {}).length,
};
})())`;
/** 收尾:暂停媒体、停批量、存进度(浏览器关掉前调用) */
export const EXPR_PAUSE_AND_SAVE = `(function () {
var a = window.__yunXueTangAuto;
if (a) { try { a.pauseAllMedia(); a.S.batchRunning = false; a.save(); } catch (e) {} }
return true;
})()`;
/** 把 maxCourses 同步到页面(0 = 不限,必须一并推送) */
export const exprSetMaxCourses = (max) =>
`(function(){ var a = window.__yunXueTangAuto; if (a && a.CFG) a.CFG.maxCourses = ${Number(max)}; return true; })()`;
/** 启动 / 接续批量刷课,同时同步「优先短课程」偏好 */
export const exprStartBatch = (preferShort) => `(function () {
var a = window.__yunXueTangAuto;
try { localStorage.setItem('yun-xue-tang-prefer-short', '${preferShort ? '1' : '0'}'); } catch (e) {}
a.state.preferShortCourses = ${preferShort ? 'true' : 'false'};
a.startBatch();
return true;
})()`;
/** 登录页:填账号密码、勾协议、点登录并接着刷课 */
export const exprAutoLogin = (usr, pwd) => `(function () {
var a = window.__yunXueTangAuto;
if (!a) return 'no-api';
var ok = a.fillLoginForm(${JSON.stringify(usr)}, ${JSON.stringify(pwd)});
try { a.checkLoginAgreement(); } catch (e) {}
a.doLoginAndStart();
return ok ? 'filled' : 'no-fields';
})()`;
export { sleep };
+230
View File
@@ -0,0 +1,230 @@
// 平台差异集中在这里,其它模块不再直接判断 process.platform。
//
// 三个操作系统要处理的差异:
// Linux 无 DISPLAY 必须无头;root 必须 --no-sandbox;容器 /dev/shm 小;SIGTERM 可优雅退出
// Windows 会话 0(服务 / 计划任务「不管用户是否登录」)没有交互桌面;
// 关闭终端窗口发的是 SIGHUP、Ctrl+Break 发的是 SIGBREAK(SIGTERM 根本收不到);
// 跨进程只能用 taskkill 强杀(process.kill 是 TerminateProcess,子进程来不及收尾);
// 浏览器进程树要用 taskkill /T 收;spawn 要 windowsHide 避免弹黑框
// macOS 与 Linux 类似但没有 root 沙箱问题,SIGTERM 可用
import { spawnSync } from 'node:child_process';
export const isWindows = process.platform === 'win32';
export const isLinux = process.platform === 'linux';
export const isMac = process.platform === 'darwin';
/** 给人看的平台名(日志 / 提示里用) */
export const platformName = isWindows ? 'Windows' : isMac ? 'macOS' : 'Linux';
export function isRunningAsRoot() {
return typeof process.getuid === 'function' && process.getuid() === 0;
}
/**
* 有没有图形显示会话(决定能不能开有界面浏览器)。
* 拿不准时返回 true(宁可按有界面处理,免得把正常桌面环境误判成无头)。
* 可用 YUN_XUE_TANG_HAS_DISPLAY=0/1 强制覆盖。
*/
export function hasDisplay() {
const force = process.env.YUN_XUE_TANG_HAS_DISPLAY;
if (force !== undefined && force !== '') return !/^(0|false|no|off)$/i.test(force);
if (isLinux) {
// 跑在 Xvfb / x11vnc 下时这两个变量会被设置
return !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
}
if (isWindows) {
// SESSIONNAME=Services 表示当前在 Session 0(服务、计划任务勾了「不管用户是否登录」),
// 那里没有交互式桌面,带界面的 Chrome 起不来。正常控制台是 Console,远程桌面是 RDP-Tcp#N。
const sess = process.env.SESSIONNAME || '';
if (/^Services$/i.test(sess)) return false;
return true;
}
return true; // macOS:登录会话里默认有 WindowServer
}
/** 为什么判定没有图形显示(无图形时的日志用,有图形时返回 '') */
export function noDisplayReason() {
if (isLinux) {
return '当前环境没有图形显示(DISPLAY / WAYLAND_DISPLAY 都为空)';
}
if (isWindows) {
return '当前进程运行在 Session 0(SESSIONNAME=Services,服务或「不管用户是否登录」的计划任务),没有交互式桌面';
}
return '当前环境没有图形显示';
}
// 平台安全参数验证:Windows 不注入 --no-sandbox(沙箱能正常工作,关掉只会削弱安全)
// 注意:不要在这里返回 --disable-features,因为 Chrome 对同名开关只认最后一个,
// 会抵消 buildArgs 里已有的 --disable-features=Translate,MediaRouter,OptimizationHints。
export function safetyArgs() {
if (isWindows) {
// Windows 上不存在 /dev/shm 与 zygote;需要的是「别弹崩溃恢复气泡」,
// 否则无人值守时会卡在一个等点击的窗口上。
return ['--disable-session-crashed-bubble', '--hide-crash-restore-bubble'];
}
if (isLinux) {
const args = ['--disable-dev-shm-usage'];
if (isRunningAsRoot()) args.push('--no-sandbox', '--disable-setuid-sandbox', '--disable-gpu');
return args;
}
return [];
}
/**
* 按 --user-data-dir 找出属于本 profile 的残留浏览器进程并杀掉。
*
* 很必要的自愈:Windows 上用户常用任务管理器「结束任务」(= TerminateProcess),
* 信号收尾根本不会执行,浏览器就成了孤儿进程占着 CDP 端口,下次启动直接失败;
* Linux 上 kill -9 同理。这里只杀命令行里带我们专属 profile 目录的进程,
* 不碰用户自己的 Chrome。
*
* @param {string} profileDir
* @param {{ log?: Function, timeoutMs?: number }} [opts]
* @returns {Promise<number>} 杀掉的进程数
*/
export async function killProfileOrphans(profileDir, opts = {}) {
const log = opts.log || (() => {});
const timeoutMs = opts.timeoutMs || 5000;
if (!profileDir) return 0;
const self = process.pid;
let pids = [];
try {
if (isWindows) {
// 注意:PowerShell 的各条语句必须用 '; ' 分隔,不能用空格连——
// 否则 "$p -join ','" 会被当成上一条 Select-Object 的参数,变量永远为空。
const pattern = profileDir.replace(/'/g, "''");
const ps = [
"$p = Get-CimInstance Win32_Process -Filter \"Name='chrome.exe' or Name='msedge.exe' or Name='chromium.exe'\"",
' | Where-Object { $_.CommandLine -like \'*' + pattern + '*\' }',
' | Select-Object -ExpandProperty ProcessId;',
'$p -join \",\"',
].join(' ');
const r = spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps], {
encoding: 'utf8', windowsHide: true, timeout: timeoutMs,
});
if (opts.debug) log('[浏览器] 排查命令输出:' + JSON.stringify(String(r.stdout || '').trim()));
pids = String(r.stdout || '').trim().split(/[,\s]+/).filter(Boolean).map(Number);
} else {
const r = spawnSync('sh', ['-c', 'ps -eo pid=,args= 2>/dev/null || ps ax -o pid=,args='], {
encoding: 'utf8', timeout: timeoutMs,
});
pids = String(r.stdout || '').split('\n')
.filter((line) => line.includes(profileDir) && /(chrome|chromium|msedge)/i.test(line))
.map((line) => Number(String(line).trim().split(/\s+/)[0]))
.filter(Boolean);
}
} catch (e) {
return 0;
}
pids = pids.filter((pid) => Number.isFinite(pid) && pid > 0 && pid !== self);
if (!pids.length) return 0;
log('[浏览器] 发现 ' + pids.length + ' 个占用本 profile 的残留进程(pid ' + pids.join(', ') + '),先收掉');
if (isWindows) {
spawnSync('taskkill', ['/pid', String(pids[0]), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
for (const pid of pids) {
spawnSync('taskkill', ['/pid', String(pid), '/F'], { windowsHide: true, stdio: 'ignore' });
}
} else {
for (const pid of pids) {
try { process.kill(pid, 'SIGKILL'); } catch (e) { /* 已经没了 */ }
}
}
await new Promise((r) => setTimeout(r, 600));
return pids.length;
}
/**
* 收掉浏览器进程(含子进程)。跨平台差异都在这里。
* @param {import('node:child_process').ChildProcess} child
* @param {{ log?: Function, timeoutMs?: number, profileDir?: string }} [opts]
*/
export async function killTree(child, opts = {}) {
const log = opts.log || (() => {});
const timeoutMs = opts.timeoutMs || 8000;
const pid = child && child.pid;
if (!pid) return;
const exited = () => child.exitCode !== null || child.signalCode !== null;
const waitExit = async (ms) => {
const t0 = Date.now();
while (!exited() && Date.now() - t0 < ms) await new Promise((r) => setTimeout(r, 150));
};
if (isWindows) {
// Windows 上 child.kill() 就是 TerminateProcess:不优雅但立即生效。
// 主进程若被 updater / crashpad handler 之类接管没退掉,退回 taskkill /T /F 收整棵树。
try { child.kill(); } catch (e) { /* ignore */ }
await waitExit(timeoutMs);
if (!exited()) {
log('[浏览器] 主进程未退出,用 taskkill /T /F 收整棵树(pid=' + pid + ')');
try {
spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
} catch (e) { /* ignore */ }
await waitExit(3000);
}
return;
}
// POSIX:先 SIGTERM 让它自己收拾(Chrome 会 flush profile),超时再 SIGKILL
try { child.kill('SIGTERM'); } catch (e) { /* ignore */ }
await waitExit(timeoutMs);
if (!exited()) { try { child.kill('SIGKILL'); } catch (e) { /* ignore */ } }
}
/**
* 端口被占用时给用户可以照抄的命令(按平台出)。
* @param {number} port
*/
export function portInUseHint(port) {
if (isWindows) {
return [
'netstat -ano | findstr :' + port + ' (最后一列是 PID)',
'taskkill /PID <上一步的 PID> /T /F',
];
}
if (isMac) {
return ['lsof -nP -iTCP:' + port + ' -sTCP:LISTEN', 'kill <PID>'];
}
return [
'ss -lptn "sport = :' + port + '"',
'pkill -f "remote-debugging-port=' + port + '"',
];
}
/** 启动前提示:本平台的浏览器装在哪 / 怎么装 */
export function browserInstallHint() {
if (isWindows) {
return [
'装一个 Chrome 或 Edge 即可(Edge 是 Chromium 内核,同样可用):',
' winget install --id Google.Chrome',
' 或 YUN_XUE_TANG_CHROME_BIN="C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"',
];
}
if (isMac) {
return ['安装 Chrome:brew install --cask google-chrome(或下载 .dmg)',
'或 YUN_XUE_TANG_CHROME_BIN="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"'];
}
return [
'安装浏览器:sudo apt install -y chromium (或 google-chrome-stable)',
'或指定路径:YUN_XUE_TANG_CHROME_BIN=/usr/bin/chromium',
];
}
/** 常驻方式提示(README 里也有,这里给的是「照着敲」的命令) */
export function residentHint() {
if (isWindows) {
return [
'前台:npm run headless (Ctrl+C 结束)',
'后台:Start-Process -WindowStyle Hidden node -ArgumentList "runner/headless.mjs"',
'开机自启:把上面一行做成「登录时运行」的计划任务(勾「不管用户是否登录」也支持)',
];
}
return [
'前台:npm run headless (Ctrl+C 结束)',
'后台:tmux new -d -s yun-xue-tang "npm run headless"',
'看日志:tail -f run-logs/headless.log',
];
}
+97
View File
@@ -0,0 +1,97 @@
// 启动前预检:构建产物、Node 版本、凭据、浏览器、调试端口。
//
// 目标是把「失败」变成一段人能照着做的说明,而不是一个栈。所有检查失败都抛
// PreflightError(exitCode=2),由 headless.mjs 统一打印并退出。
import fs from 'node:fs';
import { httpJson } from './cdp.mjs';
import { resolveBrowser, listCandidatePaths } from './browser.mjs';
import {
isWindows, platformName, portInUseHint, browserInstallHint, killProfileOrphans,
} from './platform.mjs';
export class PreflightError extends Error {
constructor(lines, exitCode = 2) {
super(Array.isArray(lines) ? lines.join('\n') : String(lines));
this.name = 'PreflightError';
this.lines = Array.isArray(lines) ? lines : [String(lines)];
this.exitCode = exitCode;
}
}
/**
* 逐项检查,全部通过后返回 { browser, scriptSrc }。
* @param {object} o
* @param {boolean} o.checkOnly 自检模式不校验凭据
* @param {string} o.scriptFile 构建产物路径
* @param {string} o.usr
* @param {string} o.pwd
* @param {number} o.port
* @param {string} o.profileDir 端口被占时用来找出「自己的」残留浏览器
* @param {string} [o.chromeBin] 配置文件里指定的浏览器路径(空 = 自动探测)
* @param {Function} [o.log]
*/
export async function runPreflight(o) {
const fail = (lines) => { throw new PreflightError(lines); };
// 1) 构建产物:没有它就没东西可注入
if (!fs.existsSync(o.scriptFile)) {
fail([
'缺少构建产物 ' + o.scriptFile + ',先运行 npm run build',
'(仓库里只提交源码 src/,产物由 esbuild 生成)',
]);
}
// 2) Node 运行时能力:cdp.mjs 用全局 WebSocket / fetch,Node 22 起才稳定
if (typeof WebSocket !== 'function' || typeof fetch !== 'function') {
fail([
'需要 Node 22+(依赖全局 WebSocket / fetch),当前 ' + process.version,
isWindows
? 'Windows 上升级:winget install OpenJS.NodeJS.LTS 或到 nodejs.org 下载 LTS 安装包'
: 'Linux 上可用 nvm / nodesource 升级:curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -',
]);
}
// 3) 凭据:自检模式不需要(只读检查不登录)
if (!o.checkOnly && (!o.usr || !o.pwd)) {
fail([
'缺少环境变量 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD。',
'(即使 profile 里有有效 cookie,也建议填上:cookie 失效时才能自动重登)',
]);
}
// 4) 浏览器:找不到就把所有尝试过的路径列出来,省得用户猜
const browser = o.chromeBin || resolveBrowser();
if (!browser || !fs.existsSync(browser)) {
fail(['找不到 Chrome/Chromium(' + platformName + '),可用 YUN_XUE_TANG_CHROME_BIN=/path/to/chrome '
+ '或配置文件里的 chrome 字段指定。已尝试:']
.concat(listCandidatePaths().map((p) => ' ' + p))
.concat(browserInstallHint()));
}
// 5) 调试端口:被占用意味着上一次的浏览器还在跑,Chrome 会直接拒绝启动。
// 无人值守场景下「自己上次没退干净」是最常见的原因,先按 profile 自愈一次:
// 只杀命令行里带本 profile 目录的进程,不碰用户自己的浏览器。
const probe = async () => {
try { return await httpJson('http://127.0.0.1:' + o.port + '/json/version'); } catch (e) { return null; }
};
let live = await probe();
if (live && live.webSocketDebuggerUrl) {
const killed = await killProfileOrphans(o.profileDir, { log: o.log });
if (killed) {
o.log('[预检] 已清理 ' + killed + ' 个占用本 profile 的残留进程,重新检测端口…');
await new Promise((r) => setTimeout(r, 1200));
live = await probe();
}
}
if (live && live.webSocketDebuggerUrl) {
const hint = portInUseHint(o.port);
fail([
'CDP 端口 ' + o.port + ' 已被占用(' + (live.Browser || '未知浏览器') + ')。',
'先结束占用该端口的进程:' + hint[0],
hint[1],
'或换端口重跑:--port ' + (o.port + 1) + ' / YUN_XUE_TANG_CDP_PORT=' + (o.port + 1),
]);
}
return { browser, scriptSrc: fs.readFileSync(o.scriptFile, 'utf8') };
}
+62
View File
@@ -0,0 +1,62 @@
// 环境自检(--check):只读,不登录、不点课程、不动进度。
//
// 检查项:页面能不能打开、脚本能不能注入、面板是否唯一可见、版本是否可读、
// 这个 Chromium 到底带不带 H.264/AAC(服务器上最常见的问题:装了发行版 chromium 却放不了视频)。
import { sleep } from './cdp.mjs';
import { EXPR_SELF_CHECK } from './page.mjs';
/**
* @param {object} o
* @param {object} o.page page.mjs 的 page 对象
* @param {Function} o.tickWatchdog 会话里负责注入 / 重登的看护函数
* @param {Function} o.isDisconnected 判断 CDP 是否已断开
* @param {number} [o.timeoutMs] 注入自检的最长等待
* @returns {Promise<{ok:boolean, failed:string[], reason:string}>}
*/
export async function runSelfCheck(o) {
const timeoutMs = o.timeoutMs || 60000;
const log = o.log;
// 等页面加载完 + 注入成功(tickWatchdog 会补注入)
const info = await (async () => {
const started = Date.now();
while (Date.now() - started < timeoutMs) {
if (o.isDisconnected()) throw new Error('CDP 连接断开');
try {
await o.tickWatchdog();
const v = await o.page.json(EXPR_SELF_CHECK);
if (v && v.api === 'object') return v;
} catch (e) { /* 页面仍在加载 */ }
await sleep(1000);
}
throw new Error(Math.round(timeoutMs / 1000) + ' 秒内未能完成注入自检');
})();
const failed = [];
const ck = (name, ok, detail) => {
log((ok ? ' PASS ' : ' FAIL ') + name + (detail === undefined ? '' : ' → ' + JSON.stringify(detail)));
if (!ok) failed.push(name);
};
log('--- 无头环境自检(只读)---');
ck('页面可访问', /yunxuetang\.cn$/.test(new URL(info.url).host), info.url);
ck('脚本已注入 window.__yunXueTangAuto', info.api === 'object', info.api);
ck('面板渲染唯一', info.panels === 1 && info.panelVisible, { 面板数: info.panels, 可见: info.panelVisible });
ck('脚本版本可读', /^v\d+\.\d+\.\d+$/.test(info.version || ''), info.version);
ck('视频编解码 H.264 可用', info.codecs.h264 === 'probably' || info.codecs.h264 === 'maybe',
{ h264: info.codecs.h264, aac: info.codecs.aac, vp9: info.codecs.vp9 });
log(' 提示:H.264 为 "maybe" 通常仍可播放;为空字符串说明该 Chromium 不带专有编解码器,');
log(' 请改装 google-chrome-stable(官方包带 H.264/AAC),否则课程视频会一直是 0 秒。');
log(' 页面识别的路由:' + info.route + ' 是否登录页:' + info.isLoginPage);
log(' UA:' + String(info.ua).slice(0, 110));
if (info.fonts && info.fonts !== 'ok') {
log(' 提示:中文字体可能缺失(fonts=' + info.fonts + '),只影响截图观感;需要截图时 apt install fonts-noto-cjk');
}
return {
ok: failed.length === 0,
failed,
reason: failed.length ? '自检失败:' + failed.join('、') : '',
};
}
+342
View File
@@ -0,0 +1,342 @@
// 单次会话:一个浏览器进程的生命周期。
//
// 顺序:起浏览器 → 建标签页 → 连 CDP → 转发页面日志 → 每 1.5 秒看护
// (补注入 / 自动重登 / 启动批量 / 同步 --max)→ 主监控(进度、卡死、退出条件)→ 收尾。
// 崩溃或断线时直接抛错,由 supervisor.mjs 负责重建浏览器。
import { connect, httpJson, sleep } from './cdp.mjs';
import { launchBrowser } from './browser.mjs';
import {
createPage, EXPR_WATCH, EXPR_SNAPSHOT, EXPR_FINAL_STATS, EXPR_PAUSE_AND_SAVE,
exprSetMaxCourses, exprStartBatch, exprAutoLogin,
} from './page.mjs';
import { runSelfCheck } from './selfcheck.mjs';
/** 看护循环间隔:既不能太密(CDP 往返),也要能及时补注入 */
export const WATCHDOG_MS = 1500;
/** 状态读不到多久后判定浏览器不可用 */
const STATE_TIMEOUT_MS = 90000;
/** 连续多少次登录失败判定为凭据/验证码问题(退出码 3) */
const MAX_LOGIN_ATTEMPTS = 5;
// 当前会话的清理句柄。runSession 抛错时(CDP 断线、登录失败…)内部收尾代码不会执行,
// 由 supervisor 在 catch 里调用 disposeActiveSession() 保证浏览器被收干净、端口能立刻复用。
let activeCleanup = null;
/** 收掉当前会话(幂等,可在任何时刻调用) */
export async function disposeActiveSession() {
const fn = activeCleanup;
activeCleanup = null;
if (fn) await fn();
}
/** 两次自动登录之间的最小间隔,避免把账号刷到风控 */
const LOGIN_COOLDOWN_MS = 20000;
/**
* @param {object} o
* @param {object} o.cfg config.mjs 的常量集合(见 headless.mjs 传入的 cfg 对象)
* @param {string} o.binary 浏览器可执行文件
* @param {string} o.scriptSrc 构建产物源码(注入用)
* @param {object} o.stop stop.mjs 的 stop 句柄
* @param {Function} o.log / o.warn / o.error 日志函数
*/
export async function runSession(o) {
const { cfg, binary, scriptSrc, stop } = o;
const log = o.log, warn = o.warn, error = o.error;
let browser = null;
let cdp = null;
let watchdog = null;
let disconnected = false;
let injected = 0;
let loginAttempts = 0;
let loginLastAt = 0;
let finished = false;
let finishReason = '';
let limitReached = false;
let lastSig = '';
let lastStateAt = Date.now();
let codecWarned = false;
// 看护循环里抛出的致命错误(如连续登录失败)不能就地丢掉:定时器的 catch
// 拿不到主循环的控制流,必须把错误寄存下来,由主循环抛出。
let fatalError = null;
const consoleErrors = [];
/** 是否达到配置的上限(maxCourses=0 表示不限) */
const limitReachedByConfig = (completed) => cfg.MAX_COURSES > 0 && completed >= cfg.MAX_COURSES;
const page = {
evalJS: null, json: null, tryEval: null,
};
const disposeSession = async () => {
if (watchdog) { clearInterval(watchdog); watchdog = null; }
if (page.evalJS && cdp && !cdp.closed) {
try { await page.evalJS(EXPR_PAUSE_AND_SAVE); } catch (e) { /* ignore */ }
}
if (cdp) { cdp.close(); cdp = null; }
if (browser) { await browser.kill(); browser = null; }
};
const unregister = stop.add(disposeSession);
activeCleanup = async () => { await disposeSession(); unregister(); };
// ---- 起浏览器 + 建标签页 + 连 CDP ----
browser = await launchBrowser({
binary,
profileDir: cfg.PROFILE_DIR,
port: cfg.PORT,
headless: !cfg.VISIBLE,
extraArgs: cfg.EXTRA_ARGS,
log,
});
log('浏览器就绪:' + browser.version.Browser + ' profile=' + cfg.PROFILE_DIR);
const target = await httpJson('http://127.0.0.1:' + cfg.PORT + '/json/new?' + encodeURIComponent(cfg.START_URL), 'PUT');
const wsUrl = target && target.webSocketDebuggerUrl;
if (!wsUrl) throw new Error('无法创建标签页(/json/new 未返回 webSocketDebuggerUrl)');
cdp = await connect(wsUrl, { onClose: () => { disconnected = true; } });
await cdp.send('Page.enable');
await cdp.send('Runtime.enable');
await cdp.send('Log.enable');
const p = createPage(cdp);
page.evalJS = p.evalJS;
page.json = p.json;
page.tryEval = p.tryEval;
// 页面 console / Log 转发:只关心脚本自己打的日志,其它 UA 噪声不看
cdp.onEvent((m) => {
if (m.method === 'Runtime.consoleAPICalled') {
const text = (m.params.args || []).map((a) => (a.value !== undefined ? a.value : a.description || '')).join(' ');
if (!/云学堂助手/.test(String(text))) return;
if (m.params.type === 'error') {
consoleErrors.push(String(text));
error('页面脚本报错:' + String(text).slice(0, 300));
} else {
log('页面:' + String(text).slice(0, 300));
}
} else if (m.method === 'Log.entryAdded') {
const t = m.params.entry;
if (t.level === 'error' && /云学堂助手/.test(t.text)) {
consoleErrors.push(t.text);
error('页面报错:' + t.text.slice(0, 300));
}
}
});
// ---------------- 看护循环 ----------------
// 每 WATCHDOG_MS 跑一次:新 document 补注入;掉登录自动重登;启动/接续批量;同步 --max。
const tickWatchdog = async () => {
if (disconnected || stop.stopping) return;
const s = await page.tryEval(EXPR_WATCH).then((v) => (v ? JSON.parse(v) : null));
if (!s || !s.href) return;
// 新 document / 首次加载:注入脚本(等价 Tampermonkey 按 @match 重注入)
if (!s.ready) {
if (/^(about:|chrome-error:|data:)/.test(String(s.href))) return; // 还没导航到真页面
if (!s.bodyLen && !s.hasPwd) return; // 页面还在渲染
try {
await page.evalJS(scriptSrc);
const t = await page.evalJS('typeof window.__yunXueTangAuto');
if (t === 'object') {
injected++;
log('已注入脚本(第 ' + injected + ' 次):' + String(s.href).slice(0, 90));
} else {
warn('注入后未生成 window.__yunXueTangAuto(typeof=' + t + ')');
}
} catch (e) {
warn('注入失败:' + (e && e.message ? e.message : e));
}
return;
}
// 运行策略同步到页面:maxCourses > 0 时覆盖脚本内置的 CFG.maxCourses;
// 配成 0 表示「不限」,也要推 0 过去,否则页面里仍是脚本自己的 10 门上限。
if (s.maxCourses !== null && s.maxCourses !== cfg.MAX_COURSES) {
await page.tryEval(exprSetMaxCourses(cfg.MAX_COURSES));
}
// 掉登录:用环境变量里的账号自动重登(限速 + 次数上限)
if (s.onLogin) {
if (loginAttempts >= MAX_LOGIN_ATTEMPTS) {
throw new Error('连续 ' + MAX_LOGIN_ATTEMPTS + ' 次登录失败:请检查 YUN_XUE_TANG_USR / YUN_XUE_TANG_PWD,'
+ '或站点要求人工验证码(无头环境无法完成)');
}
if (Date.now() - loginLastAt < LOGIN_COOLDOWN_MS) return;
loginLastAt = Date.now();
loginAttempts++;
log('登录页:自动登录(第 ' + loginAttempts + ' 次尝试)');
try {
const r = await page.evalJS(exprAutoLogin(cfg.USR, cfg.PWD));
if (r === 'no-fields') warn('登录页没找到账号/密码输入框:可能站点改版或页面尚未渲染完');
} catch (e) {
warn('自动登录调用失败:' + (e && e.message ? e.message : e));
}
return;
}
if (loginAttempts) {
loginAttempts = 0;
log('已离开登录页,登录成功');
}
// 启动 / 接续批量。注意:脚本的运行状态存在 sessionStorage,
// 每个会话都是新标签页 → 必然从「未运行」开始,所以这里每次都会显式启动一次,
// 不会出现「浏览器重启后自动接着刷」或「未登录就报运行中」。
const raw = await page.tryEval(`JSON.stringify((function () {
var a = window.__yunXueTangAuto;
return { route: a.route(), batchRunning: a.S.batchRunning, batchFinished: a.S.batchFinished, completed: a.S.completedThisRun };
})())`);
if (!raw) return; // 路由跳转中,下一轮再试
const st = JSON.parse(raw);
if (st.batchFinished) {
if (limitReachedByConfig(st.completed)) {
limitReached = true;
finishReason = '已完成 ' + st.completed + ' 门(达到上限 maxCourses=' + cfg.MAX_COURSES + ')';
} else if (cfg.RESTART_MINUTES > 0) {
finishReason = '脚本已停止(本次完成 ' + st.completed + ' 门),按 YUN_XUE_TANG_RESTART_MINUTES 稍后重新开始';
} else {
finishReason = '脚本已停止(本次完成 ' + st.completed + ' 门;无更多可学课程或达到脚本内上限)';
}
finished = true;
return;
}
if (!st.batchRunning && st.route !== 'other') {
const ok = await page.tryEval(exprStartBatch(cfg.PREFER_SHORT));
if (ok) log('已启动列表刷课' + (cfg.PREFER_SHORT ? '(优先短课程)' : ''));
}
};
// ---------------- 自检模式 ----------------
if (cfg.CHECK_ONLY) {
const result = await runSelfCheck({
page,
tickWatchdog,
isDisconnected: () => disconnected,
log,
});
await disposeSession();
unregister();
activeCleanup = null;
return result;
}
log('模式:无头 ' + (browser.headless ? 'headless' : '否') +
' 上限 ' + (cfg.MAX_COURSES > 0 ? cfg.MAX_COURSES + ' 门' : '不限') +
' 预算 ' + (cfg.BUDGET_MINUTES > 0 ? cfg.BUDGET_MINUTES + ' 分钟' : '不限') +
' 短课程优先 ' + (cfg.PREFER_SHORT ? '开' : '关') +
' 无进展 ' + cfg.IDLE_RESTART_MINUTES + ' 分钟');
watchdog = setInterval(() => {
tickWatchdog().catch((e) => {
if (stop.stopping || disconnected) return;
// 登录次数用尽这类错误是终局的,不能只警告后继续轮询
if (/连续 \d+ 次登录失败/.test(e && e.message ? e.message : '')) {
fatalError = e;
if (watchdog) { clearInterval(watchdog); watchdog = null; }
return;
}
warn('看护循环异常:' + (e && e.message ? e.message : e));
});
}, WATCHDOG_MS);
await tickWatchdog();
if (fatalError) throw fatalError;
// ---------------- 主监控 ----------------
const startedAt = Date.now();
const stallLimit = cfg.IDLE_RESTART_MINUTES > 0 ? cfg.IDLE_RESTART_MINUTES * 60 * 1000 : 30 * 60 * 1000;
const deadline = cfg.BUDGET_MINUTES > 0 ? startedAt + cfg.BUDGET_MINUTES * 60 * 1000 : Infinity;
let lastProgressAt = Date.now();
let lastProgressKey = '';
let doneReported = 0;
while (!stop.stopping) {
if (fatalError) throw fatalError;
if (disconnected) throw new Error('CDP 连接断开,重启浏览器');
if (Date.now() > deadline) { finishReason = '达到运行预算 ' + cfg.BUDGET_MINUTES + ' 分钟'; break; }
if (finished) break;
const raw = await page.tryEval(EXPR_SNAPSHOT);
if (!raw) {
if (Date.now() - lastStateAt > STATE_TIMEOUT_MS) {
throw new Error('超过 ' + Math.round(STATE_TIMEOUT_MS / 1000) + ' 秒读不到脚本状态,重启浏览器');
}
await sleep(2000);
continue;
}
const snap = JSON.parse(raw);
if (snap.noApi) {
if (Date.now() - lastStateAt > STATE_TIMEOUT_MS) {
throw new Error('超过 ' + Math.round(STATE_TIMEOUT_MS / 1000) + ' 秒读不到脚本状态,重启浏览器');
}
await sleep(2000);
continue;
}
lastStateAt = Date.now();
// 编解码器缺失:视频元素有源但解码错误(MEDIA_ERR_DECODE / SRC_NOT_SUPPORTED)
if (!codecWarned && snap.video && snap.video.src && snap.video.err >= 3) {
codecWarned = true;
warn('视频解码失败(error.code=' + snap.video.err + '):这个 Chromium 很可能不带 H.264/AAC 编解码器。');
warn('请改装官方 google-chrome-stable,或换用带专有编解码器的 Chromium 构建。');
}
// 有进展就重置停滞计时:课程/课时/进度/视频在播任一都算
const key = [snap.course, snap.lesson, snap.completed, snap.summary && snap.summary.text, snap.doneCount].join('|');
if (key !== lastProgressKey || (snap.video && !snap.video.paused)) {
lastProgressKey = key;
lastProgressAt = Date.now();
}
// 只在状态变化时打日志,避免刷屏
const sig = [snap.route, snap.course, snap.lesson, snap.completed, snap.phase, snap.runFinished].join('|');
if (sig !== lastSig) {
lastSig = sig;
const parts = [];
parts.push(snap.course ? ('课程「' + String(snap.course).slice(0, 28) + '」')
: (snap.route === 'list' ? '列表页' : snap.route));
if (snap.lesson) parts.push('课时 ' + String(snap.lesson).slice(0, 24));
if (snap.summary && snap.summary.text) parts.push(String(snap.summary.text).slice(0, 24));
if (snap.countdown != null) parts.push('倒计时 ' + snap.countdown + 's');
parts.push('本次完成 ' + snap.completed + (cfg.MAX_COURSES > 0 ? '/' + cfg.MAX_COURSES : ''));
if (snap.retryWait) parts.push('等待重试 ' + snap.retryWait + 's');
else if (snap.retryCount) parts.push('待重试 ' + snap.retryCount);
log(parts.join(' '));
if (snap.status) log(' 状态:' + String(snap.status).slice(0, 120));
}
if (snap.completed > doneReported) {
doneReported = snap.completed;
log('✔ 已完成 ' + snap.completed + ' 门(累计记录 ' + snap.doneCount + ' 门)');
}
// 到达上限 / 脚本停止 / 长时间无进展
if (limitReachedByConfig(snap.completed)) {
limitReached = true;
finishReason = '已完成 ' + snap.completed + ' 门(达到上限 maxCourses=' + cfg.MAX_COURSES + ')';
break;
}
if (snap.runFinished) { finishReason = '脚本已停止:' + (snap.status || '未知原因'); break; }
if (Date.now() - lastProgressAt > stallLimit) {
finishReason = '超过 ' + Math.round(stallLimit / 60000) + ' 分钟没有任何进展(最后停在 ' +
(snap.course || '列表') + '),退出等待重启';
break;
}
await sleep(2000);
}
// ---------------- 收尾 ----------------
const elapsed = Math.round((Date.now() - startedAt) / 1000);
const final = await page.tryEval(EXPR_FINAL_STATS).then((v) => (v ? JSON.parse(v) : {})).catch(() => ({}));
log('本次会话结束:' + (finishReason || '收到退出信号') +
' 用时 ' + Math.floor(elapsed / 60) + ' 分 ' + (elapsed % 60) + ' 秒' +
' 本次完成 ' + (final.completed || 0) + ' 门,累计 ' + (final.doneCount || 0) + ' 门');
if (consoleErrors.length) {
warn('本次共 ' + consoleErrors.length + ' 条页面脚本报错,最后一条:' + consoleErrors.slice(-1)[0].slice(0, 200));
}
await disposeSession();
unregister();
activeCleanup = null;
return { finishReason, limitReached, completed: final.completed || 0, elapsed, injected, ok: true };
}
+64
View File
@@ -0,0 +1,64 @@
// 优雅退出:收到终止信号时按注册顺序并行执行收尾函数,然后退出。
//
// 用法:把「怎么把浏览器关干净」注册进来,主程序不用到处写信号处理。
// const stop = createStopHandler({ log });
// const unregister = stop.add(() => browser.kill());
// if (stop.stopping) return; // 主循环里轮询这个开关
//
// 收尾完成后会 closeLog() 并以 0 退出,所以主循环不用自己处理信号。
//
// 各平台的信号差异(很重要,不然 Windows 上会「关不掉」):
// Linux/macOS Ctrl+C = SIGINT,kill = SIGTERM,两者都能收
// Windows Ctrl+C = SIGINT(可用),Ctrl+Break = SIGBREAK,关闭控制台窗口 = SIGHUP
// SIGTERM 根本收不到;用 taskkill /F 或任务管理器「结束任务」是 TerminateProcess,
// 任何处理函数都不会执行 —— 那种情况只能靠下次启动时清理残留进程+锁文件。
import { closeLog, log as defaultLog } from './log.mjs';
/** 各平台实际可能收到的终止信号 */
const SIGNALS = process.platform === 'win32'
? ['SIGINT', 'SIGBREAK', 'SIGHUP']
: ['SIGINT', 'SIGTERM', 'SIGHUP'];
/**
* @param {{ log?: Function, onExit?: (code:number)=>void }} [opts]
*/
export function createStopHandler(opts = {}) {
const say = opts.log || defaultLog;
const exit = opts.onExit || ((code) => process.exit(code));
const cleaners = [];
let stopping = false;
let triggered = null;
const run = async (signal) => {
if (stopping) return;
stopping = true;
triggered = signal;
say('收到 ' + signal + ',正在收尾…');
// 收尾函数并行跑,谁也挡不住谁(浏览器关不掉也要退)
await Promise.allSettled(cleaners.map((fn) => {
try { return Promise.resolve(fn()); } catch (e) { return Promise.reject(e); }
}));
closeLog();
exit(0);
};
process.on('SIGINT', () => run('SIGINT'));
process.on('SIGTERM', () => run('SIGTERM'));
process.on('SIGBREAK', () => run('SIGBREAK')); // Windows:Ctrl+Break
process.on('SIGHUP', () => run('SIGHUP')); // Windows:关闭控制台窗口
return {
/** 注册一个收尾函数,返回取消注册的函数 */
add(fn) {
cleaners.push(fn);
return () => {
const i = cleaners.indexOf(fn);
if (i >= 0) cleaners.splice(i, 1);
};
},
get stopping() { return stopping; },
get signal() { return triggered; },
/** 本平台实际监听的信号列表(自检 / 日志里用) */
signals: SIGNALS,
};
}
+80
View File
@@ -0,0 +1,80 @@
// 进程层:日志开关、启动横幅、崩溃重启循环、退出码。
//
// 一次会话(session.mjs)只管一个浏览器进程;这里管「崩了就重来」以及「什么情况该放弃」。
// 重试等待递增:15s → 30s → 45s …,上限 120s,避免持续失败时疯狂刷 CDP 端口。
import { sleep } from './cdp.mjs';
import { cleanStaleSingleton } from './browser.mjs';
import { runSession, disposeActiveSession } from './session.mjs';
import { openLog } from './log.mjs';
import { noDisplayReason, platformName } from './platform.mjs';
const RETRY_BASE_MS = 15000;
const RETRY_MAX_MS = 120000;
/**
* @param {object} o
* @param {object} o.cfg
* @param {string} o.binary
* @param {string} o.scriptSrc
* @param {object} o.stop
* @param {Function} o.log / o.warn / o.error
*/
export async function runSupervisor(o) {
const { cfg, stop } = o;
const log = o.log, warn = o.warn, error = o.error;
// 自检不写文件日志:避免每次 --check 都改仓库内容
if (!cfg.CHECK_ONLY) openLog(cfg.LOG_FILE, cfg.LOG_MAX_BYTES);
log('=== 云学堂助手 · 无头运行器' + (cfg.CHECK_ONLY ? '(自检)' : '') + ' 启动 ===');
log('Node ' + process.version + ' ' + platformName + '/' + process.arch);
log('配置 ' + (cfg.CONFIG_FILE || '(未找到 runner.config.mjs,使用内置默认值)'));
log('浏览器 ' + o.binary);
log('profile ' + cfg.PROFILE_DIR + '(cookie / localStorage 持久化,删掉即重置登录态与进度缓存)');
if (cfg.WANT_VISIBLE && !cfg.VISIBLE) {
warn(noDisplayReason() + ',配置里的 headless: false 被忽略,强制无头运行。');
}
if (!cfg.CHECK_ONLY) {
log('日志 ' + cfg.LOG_FILE + '(' + (process.platform === 'win32' ? 'Ctrl+C 结束' : 'Ctrl+C 结束') + ')');
}
let attempt = 0;
let last = null;
while (!stop.stopping) {
attempt++;
if (attempt > 1) log('--- 第 ' + attempt + ' 次尝试 ---');
try {
last = await runSession({ ...o, cfg });
if (stop.stopping) break;
if (cfg.CHECK_ONLY) break;
// 正常结束:只有「脚本自己停了 / 无进展」且配了重启间隔才再来一轮
const restartable = !last.limitReached && cfg.RESTART_MINUTES > 0;
if (!restartable) break;
log('按 YUN_XUE_TANG_RESTART_MINUTES=' + cfg.RESTART_MINUTES + ' 等待后重新开始…');
const until = Date.now() + cfg.RESTART_MINUTES * 60000;
while (!stop.stopping && Date.now() < until) await sleep(2000);
if (stop.stopping) break;
cleanStaleSingleton(cfg.PROFILE_DIR);
} catch (e) {
if (stop.stopping) break;
// 会话抛错时内部的收尾代码已被跳过,这里补上:否则浏览器进程会残留、端口被占
await disposeActiveSession();
error('会话异常:' + (e && e.message ? e.message : e));
// 连登 5 次失败基本都是密码错 / 要验证码,重试没意义,直接用专门的退出码结束
if (e && e.message && /连续 \d+ 次登录失败/.test(e.message)) {
return { exitCode: 3, last };
}
const waitMs = Math.min(RETRY_BASE_MS * attempt, RETRY_MAX_MS);
warn('浏览器/连接异常,' + Math.round(waitMs / 1000) + ' 秒后重试(第 ' + attempt + ' 次)');
await sleep(waitMs);
}
}
log('=== 运行器退出 ===');
if (cfg.CHECK_ONLY) return { exitCode: last && last.ok ? 0 : 1, last };
// 0 = 正常收尾(达到上限 / 预算 / 无更多课程);1 = 无进展卡死
if (last && /没有任何进展/.test(last.finishReason || '')) return { exitCode: 1, last };
return { exitCode: 0, last };
}
+94 -36
View File
@@ -1,27 +1,48 @@
// ======== 完成 / 失败 ========
// ======== 完成 / 未完成 ========
import { CFG, TAG } from './config.js';
import { R, S, save } from './state.js';
import { R, S, saveRunState, invalidateShortCatalog, PHASE_IDLE } from './state.js';
import { goToList } from './route.js';
import { later } from './lifecycle.js';
import { truncate } from './utils.js';
import { truncate, isGenericCourseTitle, norm } from './utils.js';
import { setStatus, updatePanel } from './panel.js';
import { courseTitle, pauseAllMedia } from './player.js';
import { forgetShortCourse } from './list.js';
// 取本次要记录的课程名:优先用队列里启动时抓到的真课程名,
// 不要在切页瞬间用页面标题(会变成「在线课堂」这类占位文案,
// 导致 completedTitles 记错名、下轮又重复进同一门课)。
function recordTitle() {
const queued = S.activeCourse ? S.activeCourse.title : '';
if (queued && !isGenericCourseTitle(queued)) return queued;
const page = courseTitle();
if (page && !isGenericCourseTitle(page)) return page;
return queued || page;
}
// 这门课本轮已试过几次(按标题归一化后的键,同名课程共用一条记录)
export function retryCount(title) {
const t = norm(title);
if (!t) return 0;
const rec = (S.courseRetries || {})[t];
return rec && rec.n ? rec.n : 0;
}
export function completeCurrent() {
const title = S.current ? S.current.title : courseTitle();
const title = recordTitle();
if (title) {
S.done[title] = Date.now();
forgetShortCourse(title);
S.completedTitles[title] = Date.now();
delete S.courseRetries[norm(title)];
}
S.completedThisRun = (S.completedThisRun || 0) + 1;
S.consecutiveFailures = 0;
S.current = null;
S.phase = 'idle';
S.returning = true;
save();
S.activeCourse = null;
S.coursePhase = PHASE_IDLE;
S.awaitingListReturn = true;
saveRunState();
R.doneLatchKey = '';
R.lastSummary = null;
R.retryWaitUntil = 0;
R.retryTitle = '';
// 完成一门就丢掉时长队列:下一轮重新调列表接口拿平台实时状态
invalidateShortCatalog();
// 平台在完成后会把播放器重置到 0 秒,先暂停,避免又从头播一遍
pauseAllMedia();
@@ -29,9 +50,9 @@ export function completeCurrent() {
const limit = CFG.maxCourses > 0 ? CFG.maxCourses : Infinity;
if (S.completedThisRun >= limit) {
S.running = false;
S.runFinished = true;
save();
S.batchRunning = false;
S.batchFinished = true;
saveRunState();
setStatus('本次已完成 ' + S.completedThisRun + ' 门,已停止。可重新勾选开始新一轮。');
} else {
setStatus('课程完成:' + truncate(title, 26) + '(本次 ' + S.completedThisRun + ')');
@@ -40,34 +61,71 @@ export function completeCurrent() {
later(function () { goToList(true); }, 1200);
}
// 课程没学完(不是「跳过」,是「重试」):
// 同一门课最多重试 CFG.maxCourseRetries 次,退避等待后重新进这门课;
// 超过次数才停止整轮刷课并明确提示——不会把这门课悄悄拉黑、换下一门。
export function failCurrent(reason) {
const title = S.current ? S.current.title : courseTitle();
if (title) {
S.failed[title] = { reason: reason, at: Date.now() };
forgetShortCourse(title);
}
S.current = null;
S.phase = 'idle';
S.returning = true;
S.consecutiveFailures = (S.consecutiveFailures || 0) + 1;
const title = recordTitle();
const key = norm(title);
const rec = key ? (S.courseRetries[key] || { n: 0 }) : { n: 0 };
rec.n = (rec.n || 0) + 1;
rec.reason = reason;
rec.at = Date.now();
if (key) S.courseRetries[key] = rec;
if (S.consecutiveFailures >= CFG.maxConsecutiveFailures) {
S.running = false;
S.runFinished = true;
setStatus('连续失败 ' + S.consecutiveFailures + ' 门,已暂停:' + reason);
save();
S.activeCourse = null;
S.coursePhase = PHASE_IDLE;
S.awaitingListReturn = false;
if (rec.n > CFG.maxCourseRetries) {
// 重试用尽:停下整轮刷课,把原因留在面板上,等人工处理
S.batchRunning = false;
S.batchFinished = true;
R.retryWaitUntil = 0;
R.retryTitle = '';
saveRunState();
setStatus('「' + truncate(title || '当前课程', 22) + '」重试 ' + CFG.maxCourseRetries +
' 次仍未完成,已停止刷课:' + reason);
console.warn(TAG, '重试用尽,停止刷课:', title, reason);
pauseAllMedia();
updatePanel();
return;
}
save();
setStatus('跳过:' + truncate(title, 24) + '(' + reason + ')');
later(function () { goToList(true); }, 1000);
// 退避:30 秒起,每次翻倍,最长 5 分钟;整轮连续重试次数越多等得越久,
// 避免「进课就失败 → 立刻重进」把页面刷爆。
const backoff = Math.min(300000, CFG.courseRetryDelayMs * Math.pow(2, Math.min(rec.n - 1, 4)));
R.retryWaitUntil = Date.now() + backoff;
R.retryTitle = title;
R.retryStatusSec = -1;
// 重试前重新拉一次列表接口:同一门课可能已被手动学完/状态已变化
invalidateShortCatalog();
S.awaitingListReturn = true;
saveRunState();
console.warn(TAG, '课程未完成,' + Math.round(backoff / 1000) + ' 秒后重试(第 ' +
rec.n + '/' + CFG.maxCourseRetries + ' 次):', title, reason);
setStatus('未学完:' + truncate(title, 20) + '(' + reason + '),' +
Math.round(backoff / 1000) + ' 秒后重试第 ' + rec.n + '/' + CFG.maxCourseRetries + ' 次');
updatePanel();
// 回列表等退避结束(listTick 会在等待期内不进课,到点后重新挑最短的未完成课)
later(function () { goToList(true); }, 1200);
}
// 重试退避是否还在等待期内
export function retryWaiting() {
return !!(R.retryWaitUntil && Date.now() < R.retryWaitUntil);
}
// 重试等待剩余秒数(面板/日志用)
export function retryWaitSeconds() {
if (!R.retryWaitUntil) return 0;
return Math.max(0, Math.ceil((R.retryWaitUntil - Date.now()) / 1000));
}
export function stopBatch(reason) {
S.running = false;
S.runFinished = true;
save();
setStatus(reason || '批量任务结束');
S.batchRunning = false;
S.batchFinished = true;
saveRunState();
setStatus(reason || '列表刷课结束');
updatePanel();
}
+23 -11
View File
@@ -1,26 +1,38 @@
// ======== 配置 ========
export const CFG = {
mute: true, // 静音(自动播放更稳)
autoNext: true, // 手动打开课程时,本节结束后自动下一节
autoNext: true, // 当前课程自动连播:本节结束后自动下一节
tickMs: 2000, // 主循环间隔
startClickCooldownMs: 3000, // 「开始学习」重复点击冷却(3 秒内没起播就补点)
entryGraceMs: 30000, // 进课后标题/课程 id 尚未就绪的宽限,避免慢加载被误判为「课程不一致」
stuckMs: 5 * 60 * 1000, // 连续多久没有计时进展就放弃当前课程
maxCourses: 10, // 本次最多完成多少门;0 = 不限
maxConsecutiveFailures: 5, // 连续失败多少门后自动停止
maxCourseRetries: 5, // 同一门课最多重试多少次(不跳过课程,超次数就停下整轮刷课)
courseRetryDelayMs: 30000, // 首次重试前的等待;之后每次翻倍,最长 5 分钟
alignToFirstIncomplete: true, // 进入课程先从「第一个未学完的课时」学起;false = 沿用平台上次位置
preferShortCourses: true, // 批量选课时优先总时长更短的课程(正序)
preferShortCourses: true, // 列表刷课时优先总时长更短的课程(正序)
maxExamTries: 2, // 同一门课「空卷交卷」的最大次数(平台没记账时避免死循环)
examClickCooldownMs: 1500, // 考试页内两次点击的间隔
staleCourseMs: 10 * 60 * 1000, // 恢复「当前课程」时允许的最大年龄,更旧的一律丢弃
};
// 版本号:由 build.mjs 从 package.json 注入,不要手改
export const VERSION = __YT_VERSION__;
export const VERSION = __YUN_XUE_TANG_VERSION__;
export const LS_ENABLED = 'yt-auto-play-enabled';
export const LS_BATCH = 'yt-batch-v2';
export const LS_LOGIN = 'yt-login-v1';
export const LS_PENDING = 'yt-auto-start-after-login';
export const LS_PREFER_SHORT = 'yt-prefer-short';
export const SS_SHORT_CATALOG = 'yt-short-catalog-v1';
// ---- localStorage:用户偏好(跨会话成立) ----
export const LS_ENABLED = 'yun-xue-tang-auto-play-enabled';
export const LS_PREFER_SHORT = 'yun-xue-tang-prefer-short';
export const LS_TARGET_CATALOG_URL = 'yun-xue-tang-target-catalog-url';
export const LS_LOGIN = 'yun-xue-tang-login-v1';
export const LS_PENDING = 'yun-xue-tang-auto-start-after-login';
// ---- sessionStorage:本次进度 + 本次运行状态(换标签页/重启即作废) ----
export const SS_RUN_STATE = 'yun-xue-tang-run-state-v3';
export const SS_SHORT_CATALOG = 'yun-xue-tang-short-catalog-v1';
export const SHORT_CATALOG_TTL = 5 * 60 * 1000;
export const PANEL_ID = 'yt-auto-panel';
// 旧版本把「进度 + 运行意图」整块塞进 localStorage,只用于一次性迁移(迁移后即删除)
export const LEGACY_LS_BATCH = 'yun-xue-tang-batch-v2';
export const PANEL_ID = 'yun-xue-tang-panel';
export const TAG = '[云学堂助手]';
+81 -16
View File
@@ -1,6 +1,6 @@
// ======== 课程页 ========
import { CFG, TAG } from './config.js';
import { R, S, save } from './state.js';
import { R, S, saveRunState, PHASE_LEARNING } from './state.js';
import { goToList, mediaPage } from './route.js';
import { courseIdFromUrl, norm, textOf, truncate, findVisibleClickable } from './utils.js';
import { later } from './lifecycle.js';
@@ -10,12 +10,14 @@ import {
hookAllVideos, findPlayableVideo, ensurePlaying, readSummary, readCountdown,
readActiveLessonKey, findNextLessonElement, findNextButton, clickNode,
fireClickSequence, lessonClickNodes, syncManualCourse, pauseAllMedia,
findPendingExamLesson, lessonItems, isLessonCompleted, lessonActiveLi, clickLesson,
} from './player.js';
import { examTick, examPhase } from './exam.js';
import { completeCurrent, failCurrent } from './complete.js';
export function courseTick() {
R.listWithCurrentSince = 0;
if (!S.current) {
if (!S.activeCourse) {
goToList();
return;
}
@@ -26,10 +28,10 @@ export function courseTick() {
const isMedia = mediaPage();
const urlId = courseIdFromUrl();
const curId = S.current.id || '';
const curId = S.activeCourse.id || '';
const title = courseTitle();
const nt = norm(title);
const nc = norm(S.current.title);
const nc = norm(S.activeCourse.title);
const genericTitle = !nt || /^(loading|加载中|在线课堂|江丰云课堂|云课堂|课程详情|课程)$/.test(nt);
const titleSame = genericTitle || !nc || nt === nc ||
nt.indexOf(nc) >= 0 || nc.indexOf(nt) >= 0;
@@ -37,7 +39,7 @@ export function courseTick() {
// 在线课堂,旧逻辑会把它当成「课程不一致」在 12 秒后把课退回列表。
const idKnown = !!(urlId && curId);
const sameCourse = idKnown ? urlId === curId : titleSame;
const graceOver = Date.now() - (S.current.startedAt || 0) > CFG.entryGraceMs;
const graceOver = Date.now() - (S.activeCourse.startedAt || 0) > CFG.entryGraceMs;
if (!sameCourse) {
if (graceOver) {
console.warn(TAG, '页面课程与队列不一致:队列', nc, curId,
@@ -48,9 +50,9 @@ export function courseTick() {
return;
}
if (S.phase !== 'learning') {
S.phase = 'learning';
save();
if (S.coursePhase !== PHASE_LEARNING) {
S.coursePhase = PHASE_LEARNING;
saveRunState();
}
// #/scan 只是进课过渡页:此时页面组件里可能还残留上一门课的汇总,
@@ -60,22 +62,30 @@ export function courseTick() {
// 1) 防挂机验证(每 10 分钟弹一次,120 秒内不点「继续学习」就停止计时)
if (handleAntiIdle()) return;
// 2) 答题/考试检测
// 2) 考试页(说明页 / 答卷页 / 结果页):自动进考试并空卷交卷
if (examTick(false)) return;
// 3) 答题/测验/问卷仍需人工处理
if (detectQuiz()) {
failCurrent('检测到答题/考试,需要手动处理');
failCurrent('检测到答题/测验,需要手动处理');
return;
}
// 3) 课程是否包含考试/测验类章节(只需检查一次)
// 4) 课程是否包含答题/测验类章节(只需检查一次)
if (!R.quizChecked && document.querySelector('.yxtulcdsdk-catalog ul > li .tag-type')) {
R.quizChecked = true;
if (courseHasQuizLesson()) {
failCurrent('课程包含考试/测验章节');
failCurrent('课程包含答题/测验章节');
return;
}
}
// 4) 整门课程是否已完成 / 平台是否刚记录了一节
// 5) 有未完成的考试课时且当前不在考试页:先点进考试节(进去后下一轮 examTick 接管)
// 汇总已满时不再进考试:个别课程考试节未做但平台已算完成,
// 再进考试只会白白多交一次卷。
if (!examPhase() && !isSummaryComplete() && enterPendingExamLesson()) return;
// 6) 整门课程是否已完成 / 平台是否刚记录了一节
const summary = readSummary();
const prevSummaryX = R.lastSummary ? R.lastSummary.x : -1;
if (summary) {
@@ -158,7 +168,7 @@ export function courseTick() {
if (!localDone) {
if (v) {
ensurePlaying(v);
const want = '学习中:' + truncate(lessonKey || S.current.title, 30);
const want = '学习中:' + truncate(lessonKey || S.activeCourse.title, 30);
if (statusEl && (statusEl.textContent === '点击开始学习…' ||
(isMedia && statusEl.textContent !== want))) {
setStatus(want);
@@ -300,7 +310,58 @@ export function advanceLesson() {
}
}
// ======== 手动课程自动连播 ========
// ======== 考试课时 ========
// 平台汇总已算完成(个别课考试节没做也判完成)时不再进考试,
// 否则只会白白多交一次卷。
function isSummaryComplete() {
const s = readSummary();
return !!(s && s.complete);
}
// 目录里有未完成的考试课时时,先点进考试节。点完后平台会渲染考试说明页,
// 下一轮 tick 由 examTick() 接管(开始考试 → 不答题 → 提交 → 确定)。
// 顺序上把考试放到最后:还有普通课时没学完就不进考试,
// 避免「进考试→交卷→重进课程页」的额外跳转打断正常播放。
// 返回 true = 本 tick 已在处理,调用方直接 return。
export function enterPendingExamLesson() {
const li = findPendingExamLesson();
if (!li) return false;
// 换课/离课后重置「点考试节」的计数,否则下一门课会凭空背着上一门课的次数
const courseKey = (S.activeCourse && S.activeCourse.id) || courseIdFromUrl() || '';
if (R.examLessonKey !== courseKey) {
R.examLessonKey = courseKey;
R.examLessonTries = 0;
R.examLessonAt = 0;
}
const pendingNormal = lessonItems().some(function (item) {
const tag = item.querySelector('.tag-type');
const isExam = !!tag && /考试/.test(textOf(tag));
return !isExam && !isLessonCompleted(item);
});
if (pendingNormal) return false;
if (Date.now() - R.examLessonAt < CFG.examClickCooldownMs * 2) return true;
// 已经停在这一节(说明页/答卷页由 examTick 管),不重复点
const activeLi = lessonActiveLi();
if (activeLi && activeLi === li && examPhase()) return false;
if (R.examLessonTries >= 10) {
failCurrent('点击考试章节多次后仍未进入考试页');
return true;
}
R.examLessonAt = Date.now();
R.examLessonTries++;
setStatus('进入考试章节:' + truncate(textOf(li), 20) +
(R.examLessonTries > 1 ? '(第 ' + R.examLessonTries + ' 次)' : ''));
clickLesson(li, R.examLessonTries);
return true;
}
// ======== 当前课程自动连播(手动打开的课) ========
export function manualCourseTick() {
hookAllVideos();
if (handleAntiIdle()) return;
@@ -314,6 +375,10 @@ export function manualCourseTick() {
syncManualCourse();
if (!mediaPage() && alignToFirstIncomplete()) return;
// 考试页:同样自动进考试、空卷交卷(出错只提示,不影响手动听课)
if (examTick(true)) return;
if (!examPhase() && !isSummaryComplete() && enterPendingExamLesson()) return;
const lessonKey = readActiveLessonKey();
if (lessonKey && lessonKey !== R.lastLessonKey) {
R.lastLessonKey = lessonKey;
@@ -325,7 +390,7 @@ export function manualCourseTick() {
const summary = readSummary();
if (summary && summary.complete) {
pauseAllMedia();
setStatus('课程已完成:' + truncate(S.current ? S.current.title : title, 24));
setStatus('课程已完成:' + truncate(S.activeCourse ? S.activeCourse.title : title, 24));
return;
}
+302
View File
@@ -0,0 +1,302 @@
// ======== 考试:自动进入考试并空卷交卷 ========
// 平台的考试章节不是可播放的课时:进课后显示的是「考试说明页」(开始考试 / 继续考试),
// 点进去是答卷页(答题卡 + 提交考试),交卷后是结果页(查看答卷详情 / 返回考试说明页)。
// 这里的目标只有一个:进入考试后一题不做,直接交卷,让考试章节计入课程进度,
// 从而让「含考试章节的课程」也能被刷完,而不是整门课被跳过。
import { CFG, TAG } from './config.js';
import { R, S, saveRunState } from './state.js';
import { textOf, isVisible, courseIdFromUrl } from './utils.js';
import { later } from './lifecycle.js';
import { setStatus } from './panel.js';
import { failCurrent, completeCurrent } from './complete.js';
import { readSummary } from './player.js';
// 只认「考试」相关文案:答题/测验/问卷仍按「需要人工处理」跳过
const START_RE = /^(开始考试|继续考试|进入考试)$/;
const SUBMIT_RE = /^(提交考试|提交试卷|交卷|交卷并退出)$/;
// 「交卷」类文案里只有考试独有的几个能用来判定「当前是考试答卷页」;
// 「提交试卷」同样会出现在答题/测验页上,不能拿来当考试标志(否则会误抢答题页)。
const EXAM_SUBMIT_RE = /^(提交考试|交卷|交卷并退出)$/;
const CONFIRM_RE = /^(确定|确认|确定交卷|确认交卷|提交|提交试卷)$/;
const RESULT_RE = /^(查看答卷详情|返回考试说明页)$/;
function visibleAll(sel, root) {
let list = [];
try {
list = [...(root || document).querySelectorAll(sel)];
} catch (e) {
return [];
}
return list.filter(isVisible);
}
// 点击优先级:真正的 button > 按钮类样式 > a > span > 其它。
// 站点把点击回调绑在 <button> 上,点到外层 div 不会有任何反应。
function rankOf(el) {
const tag = el.tagName;
if (tag === 'BUTTON' || tag === 'INPUT') return 0;
if (/yxtf?-button|btn/i.test(String(el.className || ''))) return 1;
if (tag === 'A') return 2;
if (tag === 'SPAN') return 3;
return 4;
}
// 有些节点是 svg 包装,没有 click();统一派发鼠标事件序列
export function examClick(el) {
if (!el) return false;
try {
el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, view: window }));
el.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window }));
el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
return true;
} catch (e) {
try { el.click(); return true; } catch (e2) { return false; }
}
}
// 按「去掉全部空白后的完整文案」匹配可点元素(平台按钮文案带大量换行缩进)
function findClickableByText(re, root) {
const cands = visibleAll('button, [role="button"], a, span, div', root);
const hit = cands.filter(function (el) {
const t = textOf(el);
return !!t && t.length <= 12 && re.test(t);
});
if (!hit.length) return null;
hit.sort(function (a, b) {
const d = rankOf(a) - rankOf(b);
if (d) return d;
return textOf(a).length - textOf(b).length;
});
return hit[0];
}
// ---- 考试页的三种形态 ----
export function examPreviewRoot() {
return visibleAll('.yxtulcdsdk-uexam-preview, [class*="uexam-preview"]')[0] || null;
}
export function examPaperRoot() {
return visibleAll('[class*="answer-card"], [class*="answerSheet"], [class*="answer-sheet"]')[0] || null;
}
export function examResultRoot() {
const btns = visibleAll('button, [role="button"], a');
for (const b of btns) {
const t = textOf(b);
if (t && t.length <= 12 && RESULT_RE.test(t)) return b;
}
return null;
}
// 'preview' = 考试说明页 | 'paper' = 答卷页 | 'result' = 交卷后的结果页 | '' = 不在考试页
export function examPhase() {
if (examResultRoot()) return 'result';
if (examPaperRoot()) return 'paper';
if (examPreviewRoot()) return 'preview';
// 兜底:容器类名改版时按按钮文案判断。
// 「提交试卷」不单独作数:答题/测验页也有这个按钮,只有从考试说明页进来后才认它,
// 避免把需要人工处理的答题页误当成考试自动交卷。
if (findClickableByText(EXAM_SUBMIT_RE)) return 'paper';
if (R.examPhase === 'preview' && findClickableByText(SUBMIT_RE)) return 'paper';
if (findClickableByText(START_RE)) return 'preview';
return '';
}
// 交卷确认框里的「确定」按钮:只认可见、文案短、且提到交卷/未做的弹层,避免点到隐藏的弹窗模板。
// 注意:弹层里文案最短的一层往往是「还有 N 道题未做,是否确认交卷?」的消息体,
// 它本身不包含底部按钮,所以按文案长度升序逐个尝试,谁里面有「确定」就用谁。
function confirmState() {
const boxes = visibleAll('.yxtf-dialog__wrapper, .yxt-dialog__wrapper, [class*="dialog"], [class*="modal"], [role="dialog"]');
const cands = boxes.filter(function (b) {
const t = textOf(b);
return !!t && t.length <= 300 && /交卷|未做|确认提交|是否确认/.test(t);
});
if (!cands.length) return { shown: false, btn: null };
cands.sort(function (a, b) { return textOf(a).length - textOf(b).length; });
for (const b of cands) {
const btn = findClickableByText(CONFIRM_RE, b);
if (btn) return { shown: true, btn: btn };
}
return { shown: true, btn: null };
}
// 手动刷课(自己点开的课)里出错不应该动队列,只停下并提示;
// 批量刷课走 failCurrent(重试退避,超过次数才停止整轮)。
function examAbort(reason, manual) {
if (manual) {
setStatus('考试:' + reason);
return true;
}
failCurrent(reason);
return true;
}
function examCourseKey() {
return (S.activeCourse && S.activeCourse.id) || courseIdFromUrl() || (location.pathname + location.hash);
}
export function examTriedTimes(key) {
const m = S.examEmptySubmits || {};
return m[key || examCourseKey()] || 0;
}
// 交卷后返回课程页有两种真实情况:
// 1) 结果页是课程页里的一个视图,location.href 目标与当前 URL 相同,赋值不会触发任何导航
// → 必须 reload,否则会停在结果页无限循环交卷;
// 2) 正常的跨路由跳转,href 赋值即可。
export function backToCourse() {
const id = (S.activeCourse && S.activeCourse.id) || courseIdFromUrl() || '';
const target = id ? location.origin + '/kng/#/course/play?kngId=' + encodeURIComponent(id) : '';
// 重新进课要重新对齐起点,否则会停在考试节点上没有任何可播内容
R.initialLessonChecked = false;
R.alignTries = 0;
R.alignStable = 0;
R.alignFailed = false;
R.phaseSince = 0;
R.lastLessonKey = '';
R.doneLatchKey = '';
R.waitStart = 0;
R.lastCountdown = null;
R.lastSummary = null;
R.examLeaving = false;
try {
const cur = location.href;
if (!target || cur === target) {
location.reload();
return;
}
location.href = target;
// 兜底:SPA 有时只换 hash 不重渲染,1.5 秒后仍在原地址就强制刷新
later(function () {
if (location.href === cur) {
try { location.reload(); } catch (e) { /* ignore */ }
}
}, 1500);
} catch (e) { /* ignore */ }
}
function finishExam() {
if (R.examLeaving) return;
R.examLeaving = true;
const key = examCourseKey();
if (!S.examEmptySubmits) S.examEmptySubmits = {};
S.examEmptySubmits[key] = examTriedTimes(key) + 1;
saveRunState();
const times = S.examEmptySubmits[key];
console.log(TAG, '考试已空卷交卷(第', times, '次),返回课程页继续学习');
// 交卷后平台会立刻更新课程汇总;已经「已完成学习」就直接判这门课完成,不必再跳一轮
const s = readSummary();
if (s && s.complete) {
setStatus('考试已交卷(未答题),课程已完成');
later(completeCurrent, 1500);
return;
}
if (times >= Math.max(1, CFG.maxExamTries)) {
examAbort('已空卷交卷 ' + times + ' 次,仍未计入课程进度,请手动处理', false);
return;
}
setStatus('考试已交卷(未答题),返回课程继续…');
later(backToCourse, 1800);
}
// 每个 tick 调用。返回 true = 本 tick 已在处理考试页,调用方应直接 return。
export function examTick(manual) {
const now = Date.now();
const phase = examPhase();
if (!phase) {
// 不在考试页:清掉考试引导状态,交回正常播放逻辑
if (R.examPhase) {
R.examPhase = '';
R.examPaperAt = 0;
R.examSubmits = 0;
R.examConfirms = 0;
R.examStarts = 0;
R.examActionAt = 0;
}
return false;
}
// 换形态(说明页 → 答卷页 → 结果页)时重置本形态的点击节奏
if (R.examPhase !== phase) {
R.examPhase = phase;
R.examActionAt = 0;
R.examSubmits = 0;
R.examConfirms = 0;
R.examStarts = 0;
R.examPaperAt = 0;
if (phase === 'preview') {
console.log(TAG, '检测到考试章节:进入考试后不答题,直接交卷');
setStatus('检测到考试:进入考试后直接交卷…');
}
}
if (phase === 'result') {
finishExam();
return true;
}
// 同一门课空卷交卷次数上限:平台没记账时避免「进考试→交卷→再进考试」死循环
const key = examCourseKey();
if (examTriedTimes(key) >= Math.max(1, CFG.maxExamTries)) {
return examAbort('已空卷交卷 ' + examTriedTimes(key) + ' 次,仍未计入课程进度,请手动处理', manual);
}
if (now - R.examActionAt < CFG.examClickCooldownMs) return true;
if (phase === 'preview') {
const root = examPreviewRoot();
const btn = findClickableByText(START_RE, root) || findClickableByText(START_RE);
if (!btn) {
setStatus('考试:未找到「开始考试」按钮,等待页面渲染…');
return true;
}
R.examActionAt = now;
R.examStarts++;
if (R.examStarts > Math.max(3, CFG.maxExamTries + 3)) {
return examAbort('点击「开始考试」多次仍不进答卷页', manual);
}
setStatus(R.examStarts > 1
? '考试:再次点击「' + textOf(btn) + '」…(第 ' + R.examStarts + ' 次)'
: '考试:进入考试(不答题,随后直接交卷)');
examClick(btn);
return true;
}
// ---- 答卷页:等题目渲染出来 → 点提交考试 → 在确认框点确定 ----
if (!R.examPaperAt) R.examPaperAt = now;
if (now - R.examPaperAt < 2000) return true;
const cs = confirmState();
if (cs.shown) {
if (!cs.btn) {
setStatus('考试:交卷确认框里没找到「确定」按钮');
return true;
}
R.examActionAt = now;
R.examConfirms++;
if (R.examConfirms > 6) {
return examAbort('交卷确认框点了多次仍未交卷', manual);
}
setStatus('考试:不答题,确认交卷…');
examClick(cs.btn);
return true;
}
const sub = findClickableByText(SUBMIT_RE);
if (!sub) {
setStatus('考试:等待「提交考试」按钮…');
return true;
}
if (R.examSubmits >= 6) {
return examAbort('「提交考试」点了多次仍无结果', manual);
}
R.examActionAt = now;
R.examSubmits++;
setStatus('考试:不答题,直接交卷…');
examClick(sub);
return true;
}
+35 -10
View File
@@ -1,22 +1,31 @@
// ======== 主循环 ========
'use strict';
import { CFG, VERSION, TAG } from './config.js';
import { R, S, state, save } from './state.js';
import { R, S, state, saveRunState, flushRunState, invalidateShortCatalog } from './state.js';
import { every, later, onWindow } from './lifecycle.js';
import { courseIdFromUrl } from './utils.js';
import { route, mediaPage } from './route.js';
import { ensurePanel, setStatus } from './panel.js';
import { isLoginPage, loginPageTick, doLoginAndStart, fillLoginForm, startBatch, consumePendingStart, setTick } from './login.js';
import { isLoginPage, loginPageTick, doLoginAndStart, fillLoginForm, startBatch, consumePendingStart, setTick, loginFields, findLoginVm, checkLoginAgreement, setNativeValue, saveCreds, loadCreds, clearSavedCreds } from './login.js';
import {
listTick, listVm, shortCatalogKey, courseIdOfCard, ensureShortCatalog,
chooseShortCourse, sortCardsByDuration, formatDuration,
pendingShortItems, forgetShortCourse,
pendingShortItems, scanCards, currentPage, maxPageNumber,
startCourse, jumpToPage, nextPage,
} from './list.js';
import { courseTick, manualCourseTick } from './course.js';
import {
stopBatch, retryCount, retryWaiting, retryWaitSeconds,
completeCurrent, failCurrent,
} from './complete.js';
import { examTick, examPhase } from './exam.js';
import {
hookAllVideos, readSummary, readCountdown, lessonItems,
findNextLessonElement, clickLesson, alignToFirstIncomplete,
isLessonCompleted, findFirstIncompleteLessonElement, dumpCatalog,
pauseAllMedia, findPlayableVideo, ensurePlaying, readActiveLessonKey,
detectQuiz, courseTitle, findNextButton, clickNode,
examLessonElements, findPendingExamLesson,
} from './player.js';
function tick() {
@@ -26,8 +35,8 @@ function tick() {
if (isLoginPage()) loginPageTick();
if (consumePendingStart()) return;
if (!S.running) {
if (route() === 'course' && state.enabled) {
if (!S.batchRunning) {
if (route() === 'course' && state.autoPlayEnabled) {
manualCourseTick();
} else {
R.manualCourseKey = ''; // 离开课程页后,下次进入同一门课要重新对齐
@@ -65,9 +74,11 @@ if (window.top !== window.self) {
// 调试入口(仅本地使用,可在控制台查看状态)
try {
Object.defineProperty(window, '__ytAuto', {
Object.defineProperty(window, '__yunXueTangAuto', {
value: {
S, R, state, tick, save, route,
S, R, state, tick, save: saveRunState, flush: flushRunState, route,
// CFG 暴露给无头运行器:可用 --max / YUN_XUE_TANG_MAX_COURSES 覆盖本次运行的门数上限
CFG,
mediaPage, courseIdFromUrl,
readCountdown, readSummary,
isLoginPage, loginPageTick,
@@ -82,13 +93,27 @@ try {
courseIdOfCard,
ensureShortCatalog, chooseShortCourse,
sortCardsByDuration, formatDuration,
pendingShortItems, forgetShortCourse,
pendingShortItems, invalidateShortCatalog,
retryCount, retryWaiting, retryWaitSeconds,
completeCurrent, failCurrent,
// 以下供开发/真机测试驱动内部路径使用:
scanCards, currentPage, maxPageNumber, startCourse, jumpToPage, nextPage,
listTick, courseTick, manualCourseTick,
loginFields, findLoginVm, checkLoginAgreement, setNativeValue,
saveCreds, loadCreds, clearSavedCreds,
pauseAllMedia, findPlayableVideo, ensurePlaying, readActiveLessonKey,
detectQuiz, courseTitle, findNextButton, clickNode,
stopBatch,
// 考试:调试/真机验证用
examTick, examPhase, examLessonElements, findPendingExamLesson,
},
configurable: true,
});
} catch (e) { /* ignore */ }
console.log('%c云学堂助手 v' + VERSION + ' 已加载', 'color:#3c9;font-weight:bold');
setStatus(S.runFinished
// 刷课是否在跑由 sessionStorage 里的本标签页状态决定:
// 浏览器重启 / 运行器新建标签页后一定是待机,不会在未登录的页面上谎报「运行中」。
setStatus(S.batchFinished
? '本次已完成 ' + S.completedThisRun + ' 门(已停止)'
: (S.running ? '自动刷课运行中' : '待机'));
: (S.batchRunning ? '列表刷课运行中' : '待机'));
+5 -5
View File
@@ -48,19 +48,19 @@ export function dispose() {
drain(WINDOW_LISTENERS, detachListener);
drain(ELEMENT_LISTENERS, detachListener);
try {
document.querySelectorAll('video[data-yt-hooked]').forEach(function (v) {
v.removeAttribute('data-yt-hooked');
document.querySelectorAll('video[data-yun-xue-tang-hooked]').forEach(function (v) {
v.removeAttribute('data-yun-xue-tang-hooked');
});
} catch (e) {}
const panel = document.getElementById(PANEL_ID);
if (panel && panel.parentNode) panel.parentNode.removeChild(panel);
try { delete window.__ytAuto; } catch (e) {}
try { if (window.__ytDispose === dispose) delete window.__ytDispose; } catch (e) {}
try { delete window.__yunXueTangAuto; } catch (e) {}
try { if (window.__yunXueTangDispose === dispose) delete window.__yunXueTangDispose; } catch (e) {}
console.log(TAG, '旧实例已释放');
}
try {
Object.defineProperty(window, '__ytDispose', {
Object.defineProperty(window, '__yunXueTangDispose', {
value: dispose, configurable: true, writable: true,
});
} catch (e) { /* 重复注入时忽略 */ }
+100 -49
View File
@@ -1,10 +1,14 @@
// ======== 列表页 ========
import { SHORT_CATALOG_TTL, SS_SHORT_CATALOG, TAG } from './config.js';
import { R, S, state, save, resetCourseRuntime } from './state.js';
import {
R, S, state, saveRunState, setTargetCatalogUrl, resetCourseRuntime, invalidateShortCatalog,
PHASE_ENTERING, PHASE_LEARNING, PHASE_IDLE,
} from './state.js';
import { norm, textOf, truncate } from './utils.js';
import { clickNode } from './player.js';
import { setStatus, updatePanel } from './panel.js';
import { failCurrent, stopBatch } from './complete.js';
import { retryWaiting, retryWaitSeconds } from './complete.js';
export function scanCards() {
return [...document.querySelectorAll('li.kng-list-new__item')].map((li, i) => {
@@ -95,7 +99,7 @@ export function nextPage() {
// 列表卡片本身不显示时长,但列表组件(ul.kng-list-new.__vue__)的 kngListData
// 里每门课都带 studyHours(秒)。当前页可据此按时长排序;要进一步跨页优先,
// 再用同一套列表接口一次性读取全部课程,按 studyHours 正序排队。
// 接口失败时逐级降级:跨页队列 → 当前页时长排序 → 原列表顺序,绝不卡住批量任务。
// 接口失败时逐级降级:跨页队列 → 当前页时长排序 → 原列表顺序,绝不卡住刷课任务。
export function formatDuration(seconds) {
const n = Number(seconds);
@@ -197,6 +201,9 @@ export function shortCatalogRequest(vm) {
return { body: body, headers: headers };
}
// 刚完成的课程平台记账有延迟,这段窗口内不剔除 done 里的旧记录
const DONE_STALE_MS = 10 * 60 * 1000;
// 一次性读取列表接口(limit=6000 可覆盖当前 5000+ 门课程的站点),
// 只保留「未学完」的课程,并映射到它所在的页码。
async function fetchShortCatalog(vm) {
@@ -229,18 +236,31 @@ export function shortCatalogRequest(vm) {
}
const items = [];
let pruned = 0;
datas.forEach(function (item, index) {
if (!item || !item.title) return;
const title = norm(item.title);
if (Number(item.status) === 2 || item.studyComplete === 1 || item.studyComplete === true) return;
// 平台说这门课还没学完,但本地 done 里有记录:说明本地快照旧了
// (例如平台回滚了进度、或之前是在另一目录下学完的同名课)。
// 刚完成的那门课平台记账有延迟,所以只剔除超过 DONE_STALE_MS 的旧记录。
if (S.completedTitles[title] && Date.now() - Number(S.completedTitles[title]) > DONE_STALE_MS) {
delete S.completedTitles[title];
pruned++;
}
const seconds = Number(item.studyHours);
items.push({
id: item.id ? String(item.id) : '',
title: norm(item.title),
title: title,
duration: Number.isFinite(seconds) && seconds > 0 ? seconds : 0,
status: item.status,
page: Math.floor(index / q.pageSize) + 1,
});
});
if (pruned) {
saveRunState();
console.log(TAG, '平台显示未学完,已重新纳入队列的旧记录:', pruned, '门');
}
// 时长未知的排最后;相同时按原来的列表顺序(页码)
items.sort(function (a, b) {
const da = a.duration > 0 ? a.duration : Number.MAX_SAFE_INTEGER;
@@ -253,7 +273,7 @@ export function shortCatalogRequest(vm) {
// 返回 'off' | 'loading' | 'ready' | 'failed'
export function ensureShortCatalog() {
if (!state.preferShort) return 'off';
if (!state.preferShortCourses) return 'off';
const vm = listVm();
if (!vm) {
@@ -298,7 +318,7 @@ export function ensureShortCatalog() {
setStatus('正在读取课程时长,优先安排短课程…');
fetchShortCatalog(vm).then(function (cat) {
R.shortCatalogLoading = false;
if (!state.preferShort) return;
if (!state.preferShortCourses) return;
R.shortCatalogFailedAt = 0;
R.shortCatalog = cat;
writeShortCatalog(cat);
@@ -312,7 +332,7 @@ export function ensureShortCatalog() {
}).catch(function (e) {
R.shortCatalogLoading = false;
R.shortCatalogFailedAt = Date.now();
if (!state.preferShort) return;
if (!state.preferShortCourses) return;
console.warn(TAG, '读取课程时长失败,退回当前页时长排序:',
e && e.message ? e.message : e);
setStatus('未能读取全部课程时长,先按当前页时长排序');
@@ -337,7 +357,8 @@ export function pendingShortItems() {
if (!cat) return [];
return cat.items.filter(function (item) {
if (!item || !item.title) return false;
if (S.done[item.title] || S.failed[item.title]) return false;
// 只排除「本轮已完成」;不再排除任何「失败/跳过」——没过就是重试,不是拉黑
if (S.completedTitles[item.title]) return false;
return true;
});
}
@@ -396,9 +417,15 @@ export function forgetShortCourse(title) {
if (R.shortCatalog.items.length !== before) writeShortCatalog(R.shortCatalog);
}
// 时长队列是否可用(可用时页码导航由 chooseShortCourse 独占,listTick 不再恢复页码)
export function isShortCatalogActive() {
return !!(state.preferShortCourses && R.shortCatalog &&
Date.now() - (R.shortCatalog.at || 0) < SHORT_CATALOG_TTL);
}
// 返回 { card } 表示本 tick 可以进入该课程;{ wait: true } 表示正在加载/翻页。
export function chooseShortCourse(cards, pending) {
if (!state.preferShort) return null;
if (!state.preferShortCourses) return null;
const status = ensureShortCatalog();
if (status === 'loading') return { wait: true };
@@ -413,7 +440,7 @@ export function chooseShortCourse(cards, pending) {
R.shortJumpAt = Date.now();
if (jumpToPage(target.page)) {
S.listPage = target.page;
save();
saveRunState();
setStatus('优先短课程:转到第 ' + target.page + ' 页(' +
formatDuration(target.duration) + ')');
return { wait: true };
@@ -423,7 +450,7 @@ export function chooseShortCourse(cards, pending) {
} else {
const card = cardForShortItem(cards, target);
if (card) {
if (card.status === '已学完' || S.done[card.title] || S.failed[card.title]) {
if (card.status === '已学完' || S.completedTitles[card.title]) {
// 缓存与实际状态不一致:剔除这一门,下一 tick 继续挑下一门
forgetShortCourse(card.title);
return { wait: true };
@@ -451,6 +478,16 @@ export function chooseShortCourse(cards, pending) {
return null;
}
// 短课程优先时页码归 chooseShortCourse 管:它知道下一门课在第几页,会直接跳过去。
// 只有「没开短课程优先」或「时长队列拿不到(已明确失败)」时,listTick 才去恢复页码。
function shouldRestorePage() {
if (!state.preferShortCourses) return true;
if (isShortCatalogActive()) return false;
// 队列还在加载:先别跳,等 chooseShortCourse 一次跳到位
if (R.shortCatalogLoading) return false;
return !!R.shortCatalogFailedAt;
}
export function listTick() {
const cards = scanCards();
if (!cards.length) return; // 列表还没渲染
@@ -465,22 +502,26 @@ export function listTick() {
}
if (R.pageChangeAt && Date.now() - R.pageChangeAt < 1500) return;
if (S.listUrl !== location.href) {
S.listUrl = location.href;
save();
}
// 列表 URL 同时是「目标目录」偏好:它决定刷哪个学院的课,
// 也是短课程队列的缓存键来源,所以单独存 localStorage。
if (S.catalogUrl !== location.href) setTargetCatalogUrl(location.href, { silent: true });
const page = currentPage();
// 回到列表后,恢复到课程所在的页码
if (S.returning) {
// 回到列表后,恢复到课程所在的页码(仅在拿不到时长队列时才需要)
if (S.awaitingListReturn && !shouldRestorePage()) {
// 页码不需要恢复:直接交给 chooseShortCourse / 当前页继续
S.awaitingListReturn = false;
R.pageRestoreAttempts = 0;
saveRunState();
} else if (S.awaitingListReturn) {
if (page != null && S.listPage && page !== S.listPage) {
R.restoreAttempts++;
if (R.restoreAttempts > 12) {
R.pageRestoreAttempts++;
if (R.pageRestoreAttempts > 12) {
console.warn(TAG, '页码恢复失败,改用当前页继续');
S.listPage = page || 1;
S.returning = false;
save();
S.awaitingListReturn = false;
saveRunState();
} else if (S.listPage > page) {
// 短课程优先会直接跳到很靠后的页(例如第 307 页),
// 不能一页一页 nextPage,否则要翻几百次;优先用页码输入框直跳。
@@ -492,36 +533,36 @@ export function listTick() {
return;
}
} else {
S.returning = false;
R.restoreAttempts = 0;
save();
S.awaitingListReturn = false;
R.pageRestoreAttempts = 0;
saveRunState();
setStatus('回到列表第 ' + (page || 1) + ' 页,继续…');
}
}
// 记录当前页
if (!S.returning && page != null && page !== S.listPage) {
if (!S.awaitingListReturn && page != null && page !== S.listPage) {
S.listPage = page;
save();
saveRunState();
}
// 已在进入课程的过程中:等路由跳转
if (S.current && S.phase === 'entering') {
const waited = Date.now() - (S.current.startedAt || 0);
if (S.activeCourse && S.coursePhase === PHASE_ENTERING) {
const waited = Date.now() - (S.activeCourse.startedAt || 0);
if (waited > 15000) {
failCurrent('未能进入课程页面');
return;
}
// 列表卡片点击偶尔会落在脚本/路由就绪之前(页面毫无反应)。还停在列表时
// 最多补点两次,而不是直接把这门课记成失败跳过。
// 最多补点两次,而不是提前判这门课未完成。
if (waited > 4000 && R.entryRetries < 2 &&
Date.now() - R.lastCardClickAt > 4000) {
const card = cards.find(function (c) { return c.title === S.current.title; });
const card = cards.find(function (c) { return c.title === S.activeCourse.title; });
if (card) {
R.entryRetries++;
R.lastCardClickAt = Date.now();
console.log(TAG, '进入课程超时,重试点击卡片(第', R.entryRetries, '次)');
setStatus('重新进入课程:' + truncate(S.current.title, 22));
setStatus('重新进入课程:' + truncate(S.activeCourse.title, 22));
try { clickNode(card.li); } catch (e) { /* ignore */ }
}
}
@@ -529,37 +570,50 @@ export function listTick() {
}
// 从课程页意外回到列表:判断当前课程是已完成还是中断
if (S.current && S.phase === 'learning') {
if (S.activeCourse && S.coursePhase === PHASE_LEARNING) {
if (!R.listWithCurrentSince) R.listWithCurrentSince = Date.now();
if (Date.now() - R.listWithCurrentSince < 5000) return;
const card = cards.find(function (c) { return c.title === S.current.title; });
const card = cards.find(function (c) { return c.title === S.activeCourse.title; });
if (card && /已学完|已完成|已学习/.test(card.status)) {
S.done[S.current.title] = Date.now();
forgetShortCourse(S.current.title);
S.completedTitles[S.activeCourse.title] = Date.now();
S.completedThisRun = (S.completedThisRun || 0) + 1;
}
S.current = null;
S.phase = 'idle';
S.returning = false;
S.activeCourse = null;
S.coursePhase = PHASE_IDLE;
S.awaitingListReturn = false;
R.listWithCurrentSince = 0;
save();
// 回到列表就重新拿平台实时状态(不用本地旧快照选课)
invalidateShortCatalog();
saveRunState();
setStatus('已重置中断的课程状态,继续…');
}
if (S.current) return; // 其他异常情况,等路由
if (S.activeCourse) return; // 其他异常情况,等路由
// 上一门没学完、正在退避等待时不进任何课:到点后直接重进同一门(它仍是最短的未完成课)
if (retryWaiting()) {
const left = retryWaitSeconds();
// 只在秒数变化时刷状态,避免每 tick 都打一行日志
if (R.retryStatusSec !== left) {
R.retryStatusSec = left;
setStatus('等待重试:' + truncate(R.retryTitle || '上一门课', 20) +
'(' + left + ' 秒后)');
}
return;
}
R.retryStatusSec = -1;
const pending = cards.filter((c) => {
if (!c.title) return false;
if (/已学完|已完成|已学习/.test(c.status)) return false;
if (S.done[c.title]) return false;
if (S.failed[c.title]) return false;
if (S.completedTitles[c.title]) return false;
return true;
});
// 优先短课程:先读时长队列,跨页挑总时长最短的未学完课程;
// 接口不可用时 chooseShortCourse 会退回当前页时长排序或原列表顺序。
if (state.preferShort) {
if (state.preferShortCourses) {
const choice = chooseShortCourse(cards, pending);
if (choice && choice.wait) return;
if (choice && choice.card) {
@@ -586,21 +640,18 @@ export function listTick() {
export function startCourse(card) {
const page = currentPage() || S.listPage || 1;
S.current = {
S.activeCourse = {
title: card.title,
id: courseIdOfCard(card),
status: card.status,
startedAt: Date.now(),
page: page,
duration: card.duration || 0,
};
S.listPage = page;
S.phase = 'entering';
S.returning = false;
S.coursePhase = PHASE_ENTERING;
S.awaitingListReturn = false;
R.lastCardClickAt = Date.now();
R.shortJumpAt = 0;
resetCourseRuntime();
save();
saveRunState();
const durationText = card.duration ? '(' + formatDuration(card.duration) + ')' : '';
setStatus('进入课程' + durationText + ':' + truncate(card.title, 28));
console.log(TAG, '进入课程', card.title, '状态', card.status,
+14 -9
View File
@@ -1,6 +1,6 @@
// ======== 登录 / 一键刷课 ========
import { LS_LOGIN, LS_PENDING } from './config.js';
import { R, S, save } from './state.js';
import { R, S, saveRunState, invalidateShortCatalog, PHASE_IDLE } from './state.js';
import { route, goToList } from './route.js';
import { truncate, isVisible, findVisibleButton } from './utils.js';
import { later, onElement } from './lifecycle.js';
@@ -139,17 +139,22 @@ export function clearSavedCreds() {
}
export function startBatch() {
if (S.runFinished) {
if (S.batchFinished) {
S.completedThisRun = 0;
S.consecutiveFailures = 0;
S.runFinished = false;
S.batchFinished = false;
// 重新开启一轮时清掉重试计数:之前那些课允许重新尝试
S.courseRetries = {};
R.retryWaitUntil = 0;
R.retryTitle = '';
}
S.running = true;
if (!S.current) S.phase = 'idle';
save();
setStatus('自动刷课已开启');
S.batchRunning = true;
// 开跑时丢掉旧的时长队列:第一门课也要按平台实时状态挑
invalidateShortCatalog();
if (!S.activeCourse) S.coursePhase = PHASE_IDLE;
saveRunState();
setStatus('列表刷课已开启');
const r = route();
if (r === 'list' || (r === 'course' && S.current)) {
if (r === 'list' || (r === 'course' && S.activeCourse)) {
tick();
} else {
goToList();
+25 -10
View File
@@ -1,8 +1,8 @@
// ==UserScript==
// @name 云学堂助手
// @namespace yun-xue-tang-assistant.local
// @version __YT_VERSION__
// @description 云学堂助手:自动登录、从第一节顺序听课、自动切节、处理防挂机验证,并按列表批量推进课程(单视频/音频课程也支持,学完自动进入下一门,可优先短课程)
// @version __YUN_XUE_TANG_VERSION__
// @description 云学堂助手:自动登录、从第一节顺序听课、自动切节、处理防挂机验证,并在课程列表页逐门自动刷课(单视频/音频课程也支持,含考试章节的课自动空卷交卷,学完自动进入下一门,可优先短课程;不跳过任何课程)
// @match *://kfmic.yunxuetang.cn/*
// @match *://*.yunxuetang.cn/*
// @grant none
@@ -13,7 +13,7 @@
* 用法:
* 1. 浏览器安装 Tampermonkey,新建脚本,粘贴本文件全部内容并保存。
* 2. 打开 https://kfmic.yunxuetang.cn/login.html,在右下角面板填账号/密码,
* 点「一键登录并刷课」;登录成功后会自动进入课程列表并开始批量学习。
* 点「一键登录并刷课」;登录成功后会自动进入课程列表并开始逐门学习。
* 3. 也可以手动登录后,在列表页点「一键刷课」。
*
* 密码保存:
@@ -26,23 +26,38 @@
* - 同时支持多课时课程(#/course/play)和单视频/音频/课件播放页(#/video/play 等):
* 单视频课程会自动点「开始学习」;平台汇总变成「已完成学习」/100%/x=y 时判定整门课
* 完成,自动回列表并进入下一门。
* - 进入课程(批量或手动打开)都会先对齐到「第一个未学完的课时」,即从第一章第一节起
* - 进入课程(列表刷课或自己点开)都会先对齐到「第一个未学完的课时」,即从第一章第一节起
* 顺序学习,不沿用平台上次停留的位置(否则前面的课时会被跳过,整门课永远学不完)。
* 切换成功与否以目录高亮为准:没切过去会重试并如实提示「未能切换」,不会假装已切换。
* - 试跑稳定后,把 config.js 里的 CFG.maxCourses 改成 0 即可不限门数(会持续很久)。
* - 平台若有防挂机检测/答题环节,脚本会跳过该课程并在面板提示。
* 防挂机验证(每 10 分钟一次、120 秒限时)会自动点「继续学习」;
* 答题/考试、滑块拼图类验证仍会跳过该课程。
* - 脚本不跳过任何课程:没有「跳过本课」,也不会把课程拉黑。某门课没学完(例如遇到
* 需要人工完成的滑块/拼图验证、答题/测验章节、长时间无计时进展)就退避重试:
* 30 秒起每次翻倍、最长 5 分钟,同一门课最多重试 CFG.maxCourseRetries 次,
* 超过才停下整轮刷课并在面板写明原因,等人工处理后点「一键刷课」接着跑。
* - 选课每次都动态查询:每完成一门课都重新调列表接口,拿平台实时的已完成/未完成状态,
* 再按总时长从短到长挑下一门,不使用本地缓存的旧快照。
* - 防挂机验证(每 10 分钟一次、120 秒限时)会自动点「继续学习」。
* - 考试章节支持:自动进入考试、不答题直接交卷(空白交卷)。交卷后平台会把考试节点
* 计入课程进度,含考试章节的课程也能学完。
* 同一门课最多交卷 CFG.maxExamTries 次,超过仍没计入进度就按普通未完成退避重试。
* - 验证码/滑块需要手动完成,脚本不会绕过。
* - 课程/单位如有相关规定,请自行确认风险。
*
* 短课程优先:
* - 面板勾选「优先短课程(时长正序)」后,批量刷课会先读课程列表接口里的总时长,
* - 面板勾选「优先短课程(时长正序)」后,列表刷课会先读课程列表接口里的总时长,
* 按「未学完课程的总时长从短到长」选课,而不是按列表顺序。接口不可用时会自动
* 退回为「当前页按时长正序」,再不行就按原来的列表顺序,不会卡住批量任务。
* 退回为「当前页按时长正序」,再不行就按原来的列表顺序,不会卡住刷课任务。
*
* 无头运行(Linux 服务器 / Windows 无人值守):
* - 不装 Tampermonkey 也能跑:仓库里的 runner/headless.mjs 会自己起一个无头 Chromium,
* 用 CDP 把本文件注入页面主世界(等价 @grant none),并用固定 profile 持久化登录。
* npm run build && npm run headless:check && npm run headless(凭据读环境变量)。
* Windows 上也可以直接双击 start-headless.cmd。
* - 需要在无头环境里调试本文件时,可以把 window.__yunXueTangAuto 当成调试入口,
* 用 runtime.evaluate 直接调 tick()/startBatch()/readSummary() 等,不必开界面。
*
* 开发热加载:
* - 本文件可直接被 dev/dev-loader.user.js 热注入:脚本暴露 window.__ytDispose(),
* - 本文件可直接被 dev/dev-loader.user.js 热注入:脚本暴露 window.__yunXueTangDispose(),
* 加载器在注入新版本前会先调用它清理定时器、监听器与面板,因此保存文件后
* 约 1 秒内即可生效,无需手动刷新页面。
*/
+44 -77
View File
@@ -1,9 +1,8 @@
// ======== 面板 ========
import { CFG, VERSION, LS_ENABLED, LS_PREFER_SHORT, SS_SHORT_CATALOG, PANEL_ID, TAG } from './config.js';
import { R, S, state, save } from './state.js';
import { R, S, state, saveRunState } from './state.js';
import { route } from './route.js';
import { isLoginPage, startBatch, doLoginAndStart, clearSavedCreds } from './login.js';
import { failCurrent } from './complete.js';
// 会话时长:面板 footer 显示本次脚本会话自加载起已运行多久
const SESSION_START_AT = Date.now();
@@ -11,7 +10,6 @@ export let statusEl = null;
let statsEl = null;
let footerEl = null;
let cbBatch = null;
let btnSkip = null;
let labelAuto = null;
let labelBatch = null;
let labelShort = null;
@@ -28,15 +26,6 @@ let btnClearCreds = null;
// 面板里两个复选框行共用同一套 label 样式
const LABEL_CSS = 'display:flex;align-items:center;gap:6px;cursor:pointer;margin-top:4px;';
// 「跳过本课」/「清除失败记录」共用一套按钮样式,只有 display 不同
function smallBtnCss(display) {
return [
'display:' + display, 'margin-top:6px', 'padding:2px 8px', 'cursor:pointer',
'background:#444', 'color:#eee', 'border:1px solid #666', 'border-radius:4px',
'font-size:12px',
].join(';');
}
function formatElapsed(ms) {
const total = Math.max(0, Math.floor(ms / 1000));
const h = Math.floor(total / 3600);
@@ -52,22 +41,23 @@ export function setStatus(text) {
}
export function updatePanel() {
if (cbBatch) cbBatch.checked = S.running;
if (cbBatch) cbBatch.checked = S.batchRunning;
if (statsEl) {
const limit = CFG.maxCourses > 0 ? CFG.maxCourses : '∞';
statsEl.textContent =
'本次 ' + S.completedThisRun + '/' + limit +
' · 失败 ' + Object.keys(S.failed).length +
(R.idlePassed ? ' · 验证 ' + R.idlePassed : '');
let text = '本次 ' + S.completedThisRun + '/' + limit;
const retryTitles = Object.keys(S.courseRetries || {}).length;
if (retryTitles) text += ' · 待重试 ' + retryTitles;
if (R.retryWaitUntil && Date.now() < R.retryWaitUntil) {
text += ' · ' + Math.ceil((R.retryWaitUntil - Date.now()) / 1000) + 's 后重试';
}
text += (R.idlePassed ? ' · 验证 ' + R.idlePassed : '');
statsEl.textContent = text;
}
if (footerEl) {
footerEl.textContent = '会话时长 ' + formatElapsed(Date.now() - SESSION_START_AT);
}
if (btnSkip) {
btnSkip.style.display = S.current && route() === 'course' ? 'block' : 'none';
}
if (cbAuto) cbAuto.checked = state.enabled;
if (cbPreferShort) cbPreferShort.checked = state.preferShort;
if (cbAuto) cbAuto.checked = state.autoPlayEnabled;
if (cbPreferShort) cbPreferShort.checked = state.preferShortCourses;
const onLogin = isLoginPage();
if (loginBox) loginBox.style.display = onLogin ? 'block' : 'none';
@@ -77,11 +67,11 @@ export function updatePanel() {
if (statsEl) statsEl.style.display = onLogin ? 'none' : 'block';
if (btnOne) {
// 「停止刷课」只在播放页出现;列表页等位置始终显示「一键刷课」
const onCourse = route() === 'course' && !!S.current;
const onCourse = route() === 'course' && !!S.activeCourse;
btnOne.textContent = onLogin
? '一键登录并刷课'
: (onCourse && S.running ? '停止刷课' : '一键刷课');
btnOne.title = onCourse && S.running ? '停止批量刷课' : '开始 / 继续批量刷课';
: (onCourse && S.batchRunning ? '停止刷课' : '一键刷课');
btnOne.title = onCourse && S.batchRunning ? '停止列表刷课' : '开始 / 继续列表刷课';
}
}
@@ -107,7 +97,7 @@ export function buildPanel() {
titleText.style.cssText = 'font-weight:600;';
const titleVer = document.createElement('span');
titleVer.id = 'yt-version';
titleVer.id = 'yun-xue-tang-version';
titleVer.textContent = 'v' + VERSION;
titleVer.title = '脚本版本 v' + VERSION;
titleVer.style.cssText = 'font-weight:400;font-size:10px;color:#8ee6c0;opacity:.85;';
@@ -117,7 +107,7 @@ export function buildPanel() {
btnOne = document.createElement('button');
btnOne.type = 'button';
btnOne.id = 'yt-oneclick';
btnOne.id = 'yun-xue-tang-oneclick';
btnOne.textContent = '一键刷课';
btnOne.style.cssText = [
'width:100%', 'margin:2px 0 6px', 'padding:5px 8px', 'cursor:pointer',
@@ -130,10 +120,10 @@ export function buildPanel() {
return;
}
// 只有播放页的按钮才是「停止」;列表页/门户页点它一律是开始/继续,避免误停
if (route() === 'course' && S.current && S.running) {
S.running = false;
save();
setStatus('自动刷课已暂停');
if (route() === 'course' && S.activeCourse && S.batchRunning) {
S.batchRunning = false;
saveRunState();
setStatus('列表刷课已暂停');
} else {
startBatch();
}
@@ -141,7 +131,7 @@ export function buildPanel() {
});
loginBox = document.createElement('div');
loginBox.id = 'yt-login-box';
loginBox.id = 'yun-xue-tang-login-box';
loginBox.style.cssText = 'display:none;margin-bottom:6px;';
const mkInput = function (id, type, ph) {
@@ -157,8 +147,8 @@ export function buildPanel() {
].join(';');
return el;
};
loginUserEl = mkInput('yt-login-user', 'text', '员工邮箱/账号');
loginPassEl = mkInput('yt-login-pass', 'password', '密码');
loginUserEl = mkInput('yun-xue-tang-login-user', 'text', '员工邮箱/账号');
loginPassEl = mkInput('yun-xue-tang-login-pass', 'password', '密码');
const mkCheck = function (id, text) {
const label = document.createElement('label');
@@ -170,9 +160,9 @@ export function buildPanel() {
label.appendChild(document.createTextNode(text));
return { label: label, cb: cb };
};
const rem = mkCheck('yt-login-remember', '记住密码');
const rem = mkCheck('yun-xue-tang-login-remember', '记住密码');
loginRememberEl = rem.cb;
const auto = mkCheck('yt-login-auto', '自动登录');
const auto = mkCheck('yun-xue-tang-login-auto', '自动登录');
loginAutoEl = auto.cb;
loginRememberEl.addEventListener('change', function () {
if (!loginRememberEl.checked) clearSavedCreds();
@@ -211,46 +201,46 @@ export function buildPanel() {
labelAuto.style.cssText = 'display:flex;align-items:center;gap:6px;cursor:pointer;';
cbAuto = document.createElement('input');
cbAuto.type = 'checkbox';
cbAuto.id = 'yt-auto-enabled';
cbAuto.checked = state.enabled;
cbAuto.id = 'yun-xue-tang-auto-enabled';
cbAuto.checked = state.autoPlayEnabled;
cbAuto.addEventListener('change', function () {
state.enabled = cbAuto.checked;
state.autoPlayEnabled = cbAuto.checked;
try { localStorage.setItem(LS_ENABLED, cbAuto.checked ? '1' : '0'); } catch (e) {}
setStatus(cbAuto.checked ? '自动连播已开启' : '自动连播已关闭');
});
labelAuto.appendChild(cbAuto);
labelAuto.appendChild(document.createTextNode('手动课程自动连播'));
labelAuto.appendChild(document.createTextNode('当前课程自动连播'));
labelBatch = document.createElement('label');
labelBatch.style.cssText = LABEL_CSS;
cbBatch = document.createElement('input');
cbBatch.type = 'checkbox';
cbBatch.id = 'yt-batch-enabled';
cbBatch.checked = S.running;
cbBatch.id = 'yun-xue-tang-batch-enabled';
cbBatch.checked = S.batchRunning;
cbBatch.addEventListener('change', function () {
if (cbBatch.checked) {
startBatch();
} else {
S.running = false;
save();
setStatus('自动刷课已暂停');
S.batchRunning = false;
saveRunState();
setStatus('列表刷课已暂停');
}
updatePanel();
});
labelBatch.appendChild(cbBatch);
labelBatch.appendChild(document.createTextNode('自动刷课(批量)'));
labelBatch.appendChild(document.createTextNode('课程列表自动刷课'));
labelShort = document.createElement('label');
labelShort.style.cssText = LABEL_CSS;
cbPreferShort = document.createElement('input');
cbPreferShort.type = 'checkbox';
cbPreferShort.id = 'yt-prefer-short';
cbPreferShort.checked = state.preferShort;
cbPreferShort.id = 'yun-xue-tang-prefer-short';
cbPreferShort.checked = state.preferShortCourses;
cbPreferShort.title = '按课程总时长从短到长选课';
cbPreferShort.addEventListener('change', function () {
state.preferShort = cbPreferShort.checked;
try { localStorage.setItem(LS_PREFER_SHORT, state.preferShort ? '1' : '0'); } catch (e) {}
if (!state.preferShort) {
state.preferShortCourses = cbPreferShort.checked;
try { localStorage.setItem(LS_PREFER_SHORT, state.preferShortCourses ? '1' : '0'); } catch (e) {}
if (!state.preferShortCourses) {
R.shortCatalog = null;
R.shortCatalogLoading = false;
R.shortCatalogFailedAt = 0;
@@ -266,41 +256,20 @@ export function buildPanel() {
labelShort.appendChild(document.createTextNode('优先短课程(时长正序)'));
statusEl = document.createElement('div');
statusEl.id = 'yt-status';
statusEl.id = 'yun-xue-tang-status';
statusEl.textContent = '待机';
statusEl.style.cssText = 'margin-top:6px;color:#8ee6c0;word-break:break-all;';
statsEl = document.createElement('div');
statsEl.id = 'yt-stats';
statsEl.id = 'yun-xue-tang-stats';
statsEl.style.cssText = 'margin-top:2px;color:#aaa;';
btnSkip = document.createElement('button');
btnSkip.type = 'button';
btnSkip.textContent = '跳过本课';
btnSkip.style.cssText = smallBtnCss('none');
btnSkip.addEventListener('click', function () {
if (S.current) failCurrent('手动跳过');
});
const clearFail = document.createElement('button');
clearFail.type = 'button';
clearFail.textContent = '清除失败记录';
clearFail.style.cssText = smallBtnCss('inline-block');
clearFail.addEventListener('click', function () {
S.failed = {};
S.consecutiveFailures = 0;
S.runFinished = false;
save();
updatePanel();
setStatus('已清除失败记录');
});
const hint = document.createElement('div');
hint.textContent = '真实播放计时 · 保持窗口可见';
hint.style.cssText = 'margin-top:6px;color:#777;font-size:11px;';
const footer = document.createElement('div');
footer.id = 'yt-session-duration';
footer.id = 'yun-xue-tang-session-duration';
footer.textContent = '会话时长 ' + formatElapsed(0);
footer.style.cssText = 'margin-top:4px;color:#8ee6c0;font-size:11px;';
footerEl = footer;
@@ -313,8 +282,6 @@ export function buildPanel() {
box.appendChild(labelShort);
box.appendChild(statusEl);
box.appendChild(statsEl);
box.appendChild(btnSkip);
box.appendChild(clearFail);
box.appendChild(hint);
box.appendChild(footer);
document.documentElement.appendChild(box);
+26 -10
View File
@@ -16,7 +16,7 @@ export function applyMute(v) {
export function playVideo(v) {
if (!v) return;
if (state.enabled || S.running) {
if (state.autoPlayEnabled || S.batchRunning) {
try {
const p = v.play();
if (p && typeof p.catch === 'function') p.catch(() => {});
@@ -26,10 +26,10 @@ export function playVideo(v) {
export function hookVideo(v) {
if (!v) return;
if (v.getAttribute && v.getAttribute('data-yt-hooked') === '1') return;
if (v.getAttribute && v.getAttribute('data-yun-xue-tang-hooked') === '1') return;
if (R.hooked.has(v)) return;
R.hooked.add(v);
try { v.setAttribute('data-yt-hooked', '1'); } catch (e) {}
try { v.setAttribute('data-yun-xue-tang-hooked', '1'); } catch (e) {}
applyMute(v);
@@ -70,7 +70,7 @@ export function findPlayableVideo() {
export function ensurePlaying(v) {
if (!v) return;
applyMute(v);
if (S.current) {
if (S.activeCourse) {
try {
if (Math.abs(v.playbackRate - 1) > 0.01) v.playbackRate = 1;
} catch (e) { /* ignore */ }
@@ -360,14 +360,30 @@ export function findNextButton() {
return null;
}
// 目录里的考试课时(.tag-type 文案为「考试」)。考试不再跳过,而是自动进考试空卷交卷,
// 所以单独提供 finder 给课程页调用。
export function examLessonElements() {
return lessonItems().filter(function (li) {
const tag = li.querySelector('.tag-type');
return !!tag && /考试/.test(textOf(tag));
});
}
// 第一个还没完成的考试课时
export function findPendingExamLesson() {
return examLessonElements().find(function (li) { return !isLessonCompleted(li); }) || null;
}
// 课程是否包含「答题/测验/问卷」类章节(这类仍需人工,考试已改为自动交卷)
export function courseHasQuizLesson() {
// 没有标签课时,some() 本身就返回 false,不必先判 length
return [...document.querySelectorAll('.yxtulcdsdk-catalog ul > li .tag-type')]
.some(function (t) { return /考试|测验|问卷|答题/.test(textOf(t)); });
.some(function (t) { return /答题|测验|问卷/.test(textOf(t)); });
}
export function detectQuiz() {
const pat = /^(开始答题|继续答题|提交答案|提交试卷|开始考试)$/;
// 「开始考试/继续考试」由 exam.js 单独接管(自动空卷交卷),这里只留需要人工的答题类
const pat = /^(开始答题|继续答题|提交答案|提交试卷)$/;
for (const doc of collectDocuments()) {
let els;
try {
@@ -383,7 +399,7 @@ export function detectQuiz() {
for (const d of dialogs) {
if (!isVisible(d)) continue;
const t = textOf(d);
if (/开始考试|提交试卷|开始答题/.test(t)) return true;
if (/开始答题|提交试卷/.test(t)) return true;
}
return false;
}
@@ -456,8 +472,8 @@ export function handleAntiIdle() {
const btn = findAntiIdleButton(dialog);
if (!btn) {
if (antiIdleNeedsHuman(dialog)) {
setStatus('防挂机验证需要人工完成(滑块/拼图)');
failCurrent('防挂机验证需要人工完成');
setStatus('防挂机验证需要人工完成(滑块/拼图),本课稍后重试');
failCurrent('防挂机验证需要人工完成(滑块/拼图)');
} else {
setStatus('检测到防挂机验证,未找到「继续学习」按钮');
}
@@ -571,7 +587,7 @@ export function alignToFirstIncomplete() {
return true;
}
// 手动模式没有 S.current,用课程标题判断是否换了一门课,换课时重新对齐
// 手动模式没有 S.activeCourse,用课程标题判断是否换了一门课,换课时重新对齐
export function syncManualCourse() {
const key = courseTitle() || location.href;
if (R.manualCourseKey === key) return true;
+7 -4
View File
@@ -1,5 +1,5 @@
// ======== 路由 ========
import { R, S, save } from './state.js';
import { R, S, saveRunState } from './state.js';
// 平台不同内容类型进入的播放页不同:
// 多课时课程 #/course/play?kngId=… 单个视频 #/video/play?kngId=…
@@ -20,13 +20,16 @@ export function mediaPage() {
return /^#\/(?:video|audio|ppt|document|article)\/play(?:[?/]|$)/i.test(location.hash || '');
}
// 回列表页。
// catalogUrl 决定「刷的是哪个目录」——它同时也是短课程队列的缓存键来源,
// 用错目录会把队列建在另一批课程上,所以这里优先用它而不是裸的 /kng/#/list。
export function goToList(force) {
if (!force && Date.now() - R.lastGoListAt < 5000) return;
R.lastGoListAt = Date.now();
const url = S.listUrl || location.origin + '/kng/#/list';
const url = S.catalogUrl || location.origin + '/kng/#/list';
if (route() === 'list') {
S.returning = true;
save();
S.awaitingListReturn = true;
saveRunState();
return;
}
try {
+202 -27
View File
@@ -1,47 +1,188 @@
// ======== 状态 ========
import { CFG, LS_ENABLED, LS_PREFER_SHORT, LS_BATCH } from './config.js';
//
// 状态分三层,持久化位置按「这条信息跨会话是否还成立」来分:
//
// 用户偏好(localStorage) —— state / targetCatalogUrl:跨会话、跨标签页都成立
// 本次运行状态(sessionStorage)—— S:整页跳转要活,换标签页/重启浏览器即作废
// 纯内存(R) —— 运行时计数器、节流时间戳:丢了自愈
//
// 关键约定:S.batchRunning(是否正在刷课)属于「用户/运行器的授权意图」,
// 只活在本标签页内。这样浏览器重启、运行器重建标签页之后都必然是待机状态,
// 必须由 runner/session.mjs 或面板显式重新开跑,不会出现「还没登录就开始刷课」。
import {
CFG, LS_ENABLED, LS_PREFER_SHORT, LS_TARGET_CATALOG_URL,
SS_RUN_STATE, SS_SHORT_CATALOG, LEGACY_LS_BATCH,
} from './config.js';
// ======== 用户偏好(localStorage) ========
export const state = {
enabled: true, // 手动打开的课程:自动连播
preferShort: CFG.preferShortCourses, // 批量选课:优先时长短的课程(正序)
autoPlayEnabled: true, // 当前课程自动连播(自己点开的课)
preferShortCourses: CFG.preferShortCourses, // 列表刷课时优先后时长更短的课程(正序)
};
try {
state.enabled = localStorage.getItem(LS_ENABLED) !== '0';
state.autoPlayEnabled = localStorage.getItem(LS_ENABLED) !== '0';
} catch (e) { /* ignore */ }
try {
const v = localStorage.getItem(LS_PREFER_SHORT);
if (v === '0' || v === '1') state.preferShort = v === '1';
if (v === '0' || v === '1') state.preferShortCourses = v === '1';
} catch (e) { /* ignore */ }
export function defaultBatch() {
// ======== 本次运行状态(sessionStorage) ========
export const PHASE_ENTERING = 'entering';
export const PHASE_LEARNING = 'learning';
export const PHASE_IDLE = 'idle';
const VALID_PHASES = new Set([PHASE_IDLE, PHASE_ENTERING, PHASE_LEARNING]);
export function defaultRunState() {
return {
running: false,
runFinished: false,
completedThisRun: 0,
consecutiveFailures: 0,
listUrl: '',
listPage: 1,
current: null, // { title, id, status, startedAt, page, duration }
returning: false,
phase: 'idle', // idle | entering | learning
done: {}, // title -> timestamp
failed: {}, // title -> { reason, at }
// ---- 运行意图 ----
batchRunning: false, // 列表刷课是否在跑(只在本标签页内有效)
batchFinished: false, // 本轮已停止(达上限 / 重试用尽 / 无课可学)
completedThisRun: 0, // 本轮已完成门数
// ---- 选课范围 ----
// 目标目录 URL:决定「刷哪个学院/目录」的课,也是短课程队列的缓存键来源。
// 值同时镜像到 localStorage(LS_TARGET_CATALOG_URL),所以跨会话仍然有效。
catalogUrl: '', // 例:https://kfmic.yunxuetang.cn/kng/#/list?cid=…
listPage: 1, // 列表页码(短课程队列不可用时是唯一的页码来源)
// ---- 当前课程 ----
activeCourse: null, // { title, id, startedAt }
coursePhase: PHASE_IDLE, // idle | entering | learning
awaitingListReturn: false,// 刚学完/失败,正在回列表途中
// ---- 本轮记录 ----
completedTitles: {}, // 课程名 -> 完成时间戳(防平台记账延迟时重进同一门)
courseRetries: {}, // 课程名 -> { n, reason, at }(未完成重试次数)
examEmptySubmits: {}, // 课程 id -> 空卷交卷次数(防死循环)
};
}
export let S = defaultBatch();
try {
const raw = localStorage.getItem(LS_BATCH);
if (raw) S = Object.assign(defaultBatch(), JSON.parse(raw));
} catch (e) { /* ignore */ }
export const S = defaultRunState();
export function save() {
function asMap(v) {
return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
}
function restoreFrom(obj) {
if (!obj || typeof obj !== 'object') return null;
const out = defaultRunState();
// ---- 运行意图:只有「同一个标签页」内的整页跳转才走到这里,可以整体接续 ----
out.batchRunning = obj.batchRunning === true;
out.batchFinished = obj.batchFinished === true;
const done = Number(obj.completedThisRun);
out.completedThisRun = Number.isFinite(done) && done >= 0 ? Math.floor(done) : 0;
// ---- 选课范围 ----
out.catalogUrl = typeof obj.catalogUrl === 'string' ? obj.catalogUrl : '';
const page = Number(obj.listPage);
out.listPage = Number.isFinite(page) && page >= 1 ? Math.floor(page) : 1;
// ---- 当前课程 ----
// learning 阶段:说明是同一标签页内的整页跳转(sessionStorage 跨跳转存活、跨标签页不存活),
// 所以「多年前开始学的课」也是真实的,必须接续,不能用时间戳判过期。
// entering 阶段:「正在进课」超过 15 秒就会被 failCurrent,若是重启/长时间挂起后
// 恢复一个很旧的 startedAt,只会让 course.js 的进课宽限期立刻判过期,把正常加载
// 误判成「课程不一致」—— 所以只有这一段才用 staleCourseMs 守门。
const cur = obj.activeCourse;
const startedAt = cur && Number(cur.startedAt);
const visiblePhase = VALID_PHASES.has(obj.coursePhase) ? obj.coursePhase : PHASE_ENTERING;
if (cur && cur.title && Number.isFinite(startedAt)) {
const stale = Date.now() - startedAt > CFG.staleCourseMs;
const keep = visiblePhase === PHASE_LEARNING || !stale;
out.activeCourse = keep
? { title: String(cur.title), id: String(cur.id || ''), startedAt }
: null;
out.coursePhase = keep ? visiblePhase : PHASE_IDLE;
} else {
out.activeCourse = null;
out.coursePhase = PHASE_IDLE;
}
// 「正在回列表途中」不依赖当前课程:completeCurrent / failCurrent 会先清课程
// 再跳回列表,若把它一起丢掉,新页面就不知道需要恢复页码。
out.awaitingListReturn = obj.awaitingListReturn === true;
// ---- 本轮记录 ----
out.completedTitles = asMap(obj.completedTitles);
out.courseRetries = asMap(obj.courseRetries);
out.examEmptySubmits = asMap(obj.examEmptySubmits);
return out;
}
// 旧版 localStorage 里的整块状态(yun-xue-tang-batch-v2):只挑「进度」迁移,
// 运行意图、当前课程一律不接续。迁移完即删除,避免旧数据一直复活。
function migrateLegacy() {
let raw = null;
try { raw = localStorage.getItem(LEGACY_LS_BATCH); } catch (e) { return; }
if (!raw) return;
try {
localStorage.setItem(LS_BATCH, JSON.stringify(S));
const old = JSON.parse(raw);
if (old && typeof old === 'object') {
const done = asMap(old.done);
// 清掉一眼过期的完成记录(超过 DONE 有效期的不再迁移)
for (const k of Object.keys(done)) {
const at = Number(done[k]);
if (!Number.isFinite(at) || Date.now() - at > CFG.staleCourseMs) delete done[k];
}
S.completedTitles = done;
S.courseRetries = asMap(old.retries);
S.examEmptySubmits = asMap(old.examTried);
const page = Number(old.listPage);
if (Number.isFinite(page) && page >= 1) S.listPage = Math.floor(page);
const url = typeof old.listUrl === 'string' ? old.listUrl : '';
if (url) setTargetCatalogUrl(url, { silent: true });
}
console.log('[云学堂助手] 已迁移旧版本进度记录(不再恢复旧的运行状态)');
} catch (e) { /* ignore */ }
try { localStorage.removeItem(LEGACY_LS_BATCH); } catch (e) { /* ignore */ }
}
(function restore() {
let restored = null;
try {
const raw = sessionStorage.getItem(SS_RUN_STATE);
if (raw) restored = restoreFrom(JSON.parse(raw));
} catch (e) { /* ignore */ }
if (restored) Object.assign(S, restored);
// 目标目录是偏好:localStorage 里的值优先,会话里没有就沿用会话内的
S.catalogUrl = readTargetCatalogUrl() || S.catalogUrl;
migrateLegacy();
})();
// 上次写盘的快照:内容没变就不重复序列化+写入
let lastWritten = '';
export function saveRunState() {
try {
const text = JSON.stringify(S);
if (text === lastWritten) return;
lastWritten = text;
sessionStorage.setItem(SS_RUN_STATE, text);
} catch (e) { /* ignore */ }
}
// 运行时状态(不持久化)
// 收尾/退出前强制落盘(内容没变也会写,防止 lastWritten 与实际不同步)
export function flushRunState() {
lastWritten = '';
saveRunState();
}
// ======== 目标目录 URL(偏好,localStorage + 会话镜像) ========
export function readTargetCatalogUrl() {
try { return localStorage.getItem(LS_TARGET_CATALOG_URL) || ''; } catch (e) { return ''; }
}
export function setTargetCatalogUrl(url, opt) {
const next = String(url || '');
if (!next) return;
const changed = S.catalogUrl !== next;
S.catalogUrl = next;
try { localStorage.setItem(LS_TARGET_CATALOG_URL, next); } catch (e) { /* ignore */ }
if (changed && !(opt && opt.silent)) saveRunState();
}
// ======== 运行时状态(纯内存,不持久化) ========
export const R = {
hooked: new WeakSet(),
lastCardClickAt: 0,
@@ -63,6 +204,17 @@ export const R = {
waitSummaryX: -1,
waitLessonKey: '',
quizChecked: false,
// 考试(空卷交卷)自动处理状态
examPhase: '', // '' | preview | paper | result
examActionAt: 0, // 上次考试页内点击时间
examStarts: 0, // 本形态点了多少次「开始考试」
examSubmits: 0, // 本形态点了多少次「提交考试」
examConfirms: 0, // 本形态点了多少次交卷确认「确定」
examPaperAt: 0, // 进入答卷页的时间(等题目渲染)
examLeaving: false, // 已交卷,正在返回课程页
examLessonAt: 0, // 上次点「考试节」的时间(防抖)
examLessonTries: 0, // 本次进考试节已点次数
examLessonKey: '', // examLessonTries 所属课程(换课重置,同课重进保留)
initialLessonChecked: false,
phaseSince: 0,
alignTries: 0,
@@ -74,7 +226,9 @@ export const R = {
idleDialogText: '',
idleDialogClicks: 0,
idleGaveUp: false,
restoreAttempts: 0,
pageRestoreAttempts: 0,
retryWaitUntil: 0, // 重试退避的结束时间(未到点不进课)
retryTitle: '', // 正在等待重试的课程名(面板提示用)
loginFilled: false,
loginSubmittingAt: 0,
loginAutoTried: false,
@@ -88,8 +242,20 @@ export const R = {
shortJumpAt: 0,
shortNoVmSince: 0,
shortWarnedAt: 0,
retryStatusSec: -1, // 「等待重试」提示上次写出的剩余秒数(只在变化时刷状态)
};
// 丢掉时长队列缓存:下一次选课会重新调列表接口,拿平台实时的
// 未学完/已完成状态,而不是用本地旧快照。
// 放在 state.js 而不是 list.js,是为了避开 complete.js <-> list.js 的循环引用。
export function invalidateShortCatalog() {
R.shortCatalog = null;
R.shortCatalogLoading = false;
R.shortCatalogFailedAt = 0;
R.shortNoVmSince = 0;
try { sessionStorage.removeItem(SS_SHORT_CATALOG); } catch (e) { /* ignore */ }
}
export function resetCourseRuntime() {
R.lastLessonKey = '';
R.doneLatchKey = '';
@@ -100,6 +266,15 @@ export function resetCourseRuntime() {
R.waitSummaryX = -1;
R.waitLessonKey = '';
R.quizChecked = false;
R.examPhase = '';
R.examActionAt = 0;
R.examStarts = 0;
R.examSubmits = 0;
R.examConfirms = 0;
R.examPaperAt = 0;
R.examLeaving = false;
// 注意:examLessonAt / examLessonTries 不在这里清。交卷后 backToCourse() 会重进同一门课,
// 若清掉冷却就会立即重复点考试节,形成循环。它们在下一次 init() 进入新课时自然重置。
R.initialLessonChecked = false;
R.phaseSince = 0;
R.alignTries = 0;
@@ -107,6 +282,6 @@ export function resetCourseRuntime() {
R.alignFailed = false;
R.manualCourseKey = '';
R.lastAdvanceAt = 0;
R.restoreAttempts = 0;
R.pageRestoreAttempts = 0;
R.entryRetries = 0;
}
+9
View File
@@ -54,6 +54,15 @@ export function courseIdFromUrl() {
try { return decodeURIComponent(m[1]); } catch (e) { return m[1]; }
}
// 课程标题的「占位文案」:SPA 切换时页面标题会短暂变成这些通用词。
// 用它区分「真的课程名」和「还没加载出来的兜底文案」,避免把兜底文案
// 当成课程名写进 done/failed 记录(否则下次会重复进入同一门课)。
const GENERIC_TITLE_RE = /^(loading|加载中|在线课堂|云课堂|云学堂|江丰云课堂|课程详情|课程|首页|我的学习)$/i;
export function isGenericCourseTitle(t) {
return !norm(t) || GENERIC_TITLE_RE.test(norm(t));
}
export function collectDocuments(win, out) {
win = win || window;
out = out || [];
+60
View File
@@ -0,0 +1,60 @@
@echo off
rem ---------------------------------------------------------------
rem This file must stay PURE ASCII.
rem cmd.exe reads batch files byte-by-byte with the current code page;
rem multi-byte characters (e.g. Chinese) corrupt line offsets and make
rem it report nonsense like "'npm' is not recognized".
rem All Chinese messages come from the Node runner output instead.
rem
rem Usage:
rem start-headless.cmd use runner.config.mjs
rem start-headless.cmd --help print all options
rem start-headless.cmd --max 3 command line overrides config file
rem ---------------------------------------------------------------
setlocal
chcp 65001 >nul
cd /d "%~dp0"
title YunXueTang Assistant - headless runner
where node >nul 2>nul
if errorlevel 1 goto no_node
if exist "yun-xue-tang-assistant.user.js" goto have_build
echo [build] build output not found, running npm run build ...
call npm run build
if errorlevel 1 goto build_fail
:have_build
if not exist "runner.config.mjs" goto no_config
echo [config] runner.config.mjs found, editing it is enough (no rebuild needed)
goto run
:no_config
echo [warn] runner.config.mjs not found, built-in defaults will be used
:run
echo [run] headless runner starting, press Ctrl+C to stop
echo.
node "runner/headless.mjs" %*
set RC=%ERRORLEVEL%
if "%RC%"=="0" goto done
echo.
echo [exit] code %RC%
echo 0 finished 1 no progress 2 env/args error 3 login failed
echo full log: run-logs\headless.log
pause
exit /b %RC%
:done
exit /b 0
:no_node
echo [error] node.exe not found. Install Node.js 22+ from https://nodejs.org/
pause
exit /b 1
:build_fail
echo [error] build failed. Run npm install first.
pause
exit /b 1
File diff suppressed because it is too large. Load diff