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
+6198 -837

No files matched your search

+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 };
}