Files
yun-xue-tang-assistant/runner/session.mjs
T
void ae117222df 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 补无头部署章节
2026-10-25 23:04:40 +08:00

343 lines
15 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 单次会话:一个浏览器进程的生命周期。
//
// 顺序:起浏览器 → 建标签页 → 连 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 };
}