// ==UserScript==
// @name [万能AI]全平台网课学习通刷课自动答题脚本
// @namespace cx-auto-study
// @version 2.5.9
// @description 学习通|智慧树自动刷课【🤖AI强补】题库盲区自动触发AI答题,精准无死角;【🚀极速全能】视频音频倍速秒过,文档图书自动完成,支持字体解密;【🥇全程托管】一键安装即用,自动切换任务点,作业考试自动答题提交;【📔顶配题库】整合多方题库每日更新,开放自定义参数,功能持续进化
// @author 宝藏郎
// @license MIT
// @homepageURL https://baozl.com/
// @supportURL https://baozl.com/
// @icon https://qiniu.baozang.asia/%E5%AE%9D%E8%97%8F%E9%83%8E/2026/11/20261119080504379.png
// @match *://*.chaoxing.com/*
// @run-at document-end
// @grant GM_getValue
// @grant GM_info
// @grant GM_setValue
// @grant GM_xmlhttpRequest
// @connect xuexit.baozl.com
// @connect baozl.com
// @connect 127.0.0.1
// @connect api.tikuhai.com
// @connect cx.icodef.com
// @connect tk.enncy.cn
// @connect api.muketool.com
// @connect api.deepseek.com
// @connect api.siliconflow.cn
// @connect api.minimaxi.com
// @connect open.bigmodel.cn
// @connect dashscope.aliyuncs.com
// @connect api.moonshot.cn
// @connect api.openai.com
// @connect cn.bing.com
// @connect www.bing.com
// @noframes
// ==/UserScript==
//
// ⚠️ 免责声明
// 本脚本仅供个人学习辅助与技术研究使用。使用本脚本可能违反学习通(超星)平台服务条款,
// 平台已声明使用人工智能等技术监控"刷课"行为并可能通报所在高校。请自行评估风险,
// 合理设置(原速、每日上限、拟人化),使用产生的一切后果由使用者自行承担。
(function () {
'use strict';
/* ==================== AI 平台预设(官网 / Key / 文档 / 接口 / 现役模型) ====================
2026-11 实测:7 个平台的 OpenAI 兼容 chat/completions 端点做无 Key 探活,
除 api.openai.com(国内网络需代理)外均返回标准 401 认证错误 => 端点与请求格式有效。
MiniMax 只有 api.minimaxi.com 可用,api.minimax.cn / api.minimax.io 的 /v1 路径实测 404。
模型名会换代,所以一律给「推荐 + 备选」,最终以「📋 拉取模型列表」的真实结果为准。
★ GM_xmlhttpRequest 的跨域目标必须在元数据 @connect 里声明,否则请求会被
脚本管理器静默拦掉 —— 这正是「卡密能答题、自己填 Key 不能答题」的根因:
卡密域名 xuexit.baozl.com 早已声明,而自有 AI 平台域名一个都没声明。 */
const AI_PROVIDERS = {
deepseek: {
label: 'DeepSeek(官方直连 · 推荐)',
site: 'https://platform.deepseek.com/',
keyUrl: 'https://platform.deepseek.com/api_keys',
docs: 'https://api-docs.deepseek.com/',
url: 'https://api.deepseek.com/v1/chat/completions',
model: 'deepseek-v4-flash',
alt: ['deepseek-flash', 'deepseek-v4-pro'],
note: '官方已于 2026-07-24 停用 deepseek-chat / deepseek-reasoner,现役为 V4 系列;国内可直连。/v1 与不带 /v1 两种路径都兼容。'
},
siliconflow: {
label: '硅基流动 SiliconFlow',
site: 'https://cloud.siliconflow.cn/',
keyUrl: 'https://cloud.siliconflow.cn/account/ak',
docs: 'https://docs.siliconflow.cn/',
url: 'https://api.siliconflow.cn/v1/chat/completions',
model: 'deepseek-ai/DeepSeek-V4-Flash',
alt: ['Pro/deepseek-ai/DeepSeek-V4', 'Qwen/Qwen3-8B'],
note: '注册实名后送额度。模型 ID 必须带组织前缀且区分大小写,请从「模型广场」完整复制,或点下方「拉取模型列表」。'
},
minimax: {
label: 'MiniMax',
site: 'https://platform.minimaxi.com/',
keyUrl: 'https://platform.minimaxi.com/',
docs: 'https://platform.minimaxi.com/document',
url: 'https://api.minimaxi.com/v1/chat/completions',
model: 'MiniMax-M3',
alt: ['MiniMax-M2.1', 'abab6.5s-chat'],
note: '实测 api.minimaxi.com 可用;另两个常见域名 api.minimax.cn / api.minimax.io 的 /v1/chat/completions 返回 404。Key 在控制台「账户管理 → 接口密钥」创建。'
},
zhipu: {
label: '智谱 AI(GLM)',
site: 'https://bigmodel.cn/',
keyUrl: 'https://bigmodel.cn/usercenter/apikeys',
docs: 'https://docs.bigmodel.cn/',
url: 'https://open.bigmodel.cn/api/paas/v4/chat/completions',
model: 'glm-4.7-flash',
alt: ['glm-4.7', 'glm-5'],
note: 'GLM-4.7-Flash 便宜且默认非思考模式,答题最省事;GLM-5 系列部分为纯思考模型,可能只返回思维链导致本题空答案。'
},
qwen: {
label: '通义千问(阿里云百炼)',
site: 'https://bailian.console.aliyun.com/',
keyUrl: 'https://bailian.console.aliyun.com/#/api-key',
docs: 'https://help.aliyun.com/zh/model-studio/',
url: 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions',
model: 'qwen3.8-flash',
alt: ['qwen3.7-plus', 'qwen-plus'],
note: '必须走 compatible-mode 路径才是 OpenAI 兼容格式;北京地域的 Key 不能用于国际地域,反之亦然。'
},
kimi: {
label: 'Kimi(月之暗面)',
site: 'https://platform.moonshot.cn/',
keyUrl: 'https://platform.moonshot.cn/console/api-keys',
docs: 'https://platform.moonshot.cn/docs/',
url: 'https://api.moonshot.cn/v1/chat/completions',
model: 'kimi-k2.6',
alt: ['moonshot-v1-8k', 'kimi-k2.7'],
note: '国内账号用 api.moonshot.cn,海外账号需改成 api.moonshot.ai(选「自定义」填)。部分新模型强制思考,可能只返回思维链。'
},
openai: {
label: 'OpenAI 官方',
site: 'https://platform.openai.com/',
keyUrl: 'https://platform.openai.com/api-keys',
docs: 'https://platform.openai.com/docs/api-reference/chat',
url: 'https://api.openai.com/v1/chat/completions',
model: 'gpt-5.4-mini',
alt: ['gpt-5-mini', 'gpt-4o-mini'],
note: '本机网络实测无法直连(需自备代理)。GPT-5 系列要求 max_completion_tokens 且不支持 temperature,脚本已自动适配;连不上时请改用国内平台或自建中转。'
},
custom: {
label: '其他 / 自定义(OpenAI 兼容)',
site: '', keyUrl: '', docs: '', url: '', model: '', alt: [],
note: '填任意 OpenAI 兼容中转地址(须以 /chat/completions 结尾)。首次请求会弹出 Tampermonkey 跨域授权,务必点「允许」,否则请求会被静默拦截;也可把域名加进脚本头部 @connect 永久放行。'
}
};
// 由接口地址反查平台,用于老用户没存 aiProvider 时自动回显
function detectProvider(url) {
const u = String(url || '').toLowerCase();
const hosts = {
deepseek: 'api.deepseek.com', siliconflow: 'api.siliconflow.cn',
minimax: 'api.minimaxi.com', zhipu: 'open.bigmodel.cn',
qwen: 'dashscope.aliyuncs.com', kimi: 'api.moonshot.cn', openai: 'api.openai.com'
};
for (const k of Object.keys(hosts)) if (u.indexOf(hosts[k]) >= 0) return k;
return 'custom';
}
function providerOptions(sel) {
return Object.keys(AI_PROVIDERS).map((k) =>
'').join('');
}
// 选中平台后把「官网 / 创建 Key / 接口文档 / 接口地址 / 推荐模型 / 备选 / 注意事项」直接摆给用户
function providerInfoHtml(key) {
const p = AI_PROVIDERS[key] || AI_PROVIDERS.custom;
const link = (url, text) => url
? '' + escapeHtml(text) + ' ↗'
: '自定义平台,请自行填写';
return '
📡 ' + escapeHtml(p.label) + ' · 对接信息
' +
'官网' + link(p.site, '打开官网') + '
' +
'API Key' + link(p.keyUrl, '创建 / 查看 Key') + '
' +
'接口文档' + link(p.docs, '查看文档') + '
' +
'接口地址' + escapeHtml(p.url || '自行填写') + '
' +
'推荐模型' + escapeHtml(p.model || '自行填写') + '
' +
(p.alt && p.alt.length ? '备选模型' + escapeHtml(p.alt.join(' / ')) + '
' : '') +
'' + escapeHtml(p.note || '') + '
';
}
/* ==================== 配置 ==================== */
const DEFAULT_CONFIG = {
speed: 2, // 视频倍速(默认 2x 最快;1 = 原速最安全,2x 检测风险最高,自行权衡)
autoVideo: true, // 自动处理视频任务
autoAudio: true, // 自动处理音频任务
autoWork: true, // 自动做章节测验
autoSubmit: true, // 正确率达标自动提交测验
autoJump: true, // 本章完成后自动切下一章
muted: true, // 视频静音播放(默认开);取消勾选 = 有声播放
answerIntervalMin: 2, // 每题最小间隔(秒)——拟人「读题思考」时间,0 秒答题是官方风控重点特征,不建议改回 0
answerIntervalMax: 5, // 每题最大间隔(秒)
submitDelayMin: 4, // 提交前最小延迟(秒)——拟人「检查试卷」时间
submitDelayMax: 9, // 提交前最大延迟(秒)
minAccuracy: 0.6, // 最低正确率,低于则暂存不提交
quizDelayMin: 0, // 弹题作答前等待(秒,0=最快)
quizDelayMax: 0,
dailyLimitMinutes: 0, // 每日刷课时长上限(分钟),0 = 不限
deliberateErrorRate: 0, // 故意答错率 0~0.2(0=不故意错)
aiEnabled: false, // 启用 AI 答题(需填 key;面板填了 Key 会自动勾上)
aiKey: '', // 个人 API Key:点面板 ⚙ 填写(各平台官网创建,只存本机)
aiProvider: 'deepseek', // 当前选中的 AI 平台(面板回显/官网展示用)
aiUrl: 'https://api.deepseek.com/v1/chat/completions',
aiModel: 'deepseek-v4-flash',
useTiku: false, // 在线免费题库(大多已关停/转向付费,默认关;开了则按「题库优先」出答案)
useWebSearch: true, // 必应实时搜索兜底(免费;仅当本地题库/在线题库/AI 都无结果时使用)
serverUrl: 'https://xuexit.baozl.com', // 服务端(线上题库+免 Key AI);留空=不用服务器
cardKey: '', // 服务端卡密:购买后填入并保存,免配自己的 AI Key 直接用服务端 AI
overwrite: false, // 覆盖重答:开启后已作答过的弹题/测验也会清掉旧答案重新作答
failTolerance: 3, // AI 失败容忍次数:连续失败 N 次才进入 10 分钟冷却(自定义失败容忍策略)
quizRandomFallback: true, // 弹题随机兜底:未搜到答案时随机点一个选项,避免卡住视频
autoLearnResult: true, // 结果页自动纠错:判错的答案从题库剔除,判对/公布的正确答案写入并锁定
};
/* 反检测增强:抹掉浏览器自动化痕迹(navigator.webdriver 是最常见的挂机检测点),
配合脚本里已有的随机延迟/拟人化答题间隔一起降低被风控的概率 */
try {
Object.defineProperty(navigator, 'webdriver', { get: () => false, configurable: true });
} catch (e) { /* ignore */ }
// 配置数值统一走这里,避免 `parseFloat(v) || 默认值` 把用户填的 0 悄悄改成默认值
function cfgNum(raw, fallback, min, max) {
const n = parseFloat(raw);
const v = Number.isFinite(n) ? n : fallback;
return Math.min(max, Math.max(min, v));
}
// 提交判定(纯函数,便于回归测试)。
// okCount = 真正写进提交域的题数;noAnswer = 题库/AI/搜索都没结果而主动留空的题数;
// failed = 有答案却没写进提交域的题数(真故障,一律拦住防白卷)。
// 「没答案」不是故障:它按 0 分计入测算正确率,不该把整场测验卡住不交(v2.5.4 反馈:
// 12 题里 1 道填空题没答案,测算 91.7% ≥ 90%,却因「仅 11/12 题作答成功」被暂存)。
// 旧调用只传 3 个参数时 noAnswer/failed 视为 0,行为保持不变。
function shouldSubmit(okCount, total, confidence, noAnswer, failed) {
const handled = okCount + Number(noAnswer || 0);
return !!(CONFIG.autoSubmit && total > 0 && okCount > 0
&& handled === total && Number(failed || 0) === 0
&& confidence >= CONFIG.minAccuracy);
}
function loadConfig() {
try {
const saved = (typeof GM_getValue !== 'undefined')
? GM_getValue('cxConfig', null)
: JSON.parse(localStorage.getItem('cxConfig') || 'null');
if (saved && typeof saved === 'object') {
const cfg = Object.assign({}, DEFAULT_CONFIG, saved);
// 迁移:老版本默认 serverUrl 指向本机调试地址,自动升级到线上服务端
if (!cfg.serverUrl || /127\.0\.0\.1:8790/i.test(cfg.serverUrl)) {
cfg.serverUrl = DEFAULT_CONFIG.serverUrl;
saveConfig(cfg);
}
// 迁移:老版本拟人延迟默认为 0(答题太快易被风控),自动升级为拟人间隔
if (Number(cfg.answerIntervalMin) === 0 && Number(cfg.answerIntervalMax) === 0) {
cfg.answerIntervalMin = DEFAULT_CONFIG.answerIntervalMin;
cfg.answerIntervalMax = DEFAULT_CONFIG.answerIntervalMax;
cfg.submitDelayMin = DEFAULT_CONFIG.submitDelayMin;
cfg.submitDelayMax = DEFAULT_CONFIG.submitDelayMax;
saveConfig(cfg);
}
return cfg;
}
} catch (e) { /* ignore */ }
return Object.assign({}, DEFAULT_CONFIG);
}
function saveConfig(cfg) {
try {
if (typeof GM_setValue !== 'undefined') GM_setValue('cxConfig', cfg);
else localStorage.setItem('cxConfig', JSON.stringify(cfg));
} catch (e) { /* ignore */ }
}
let CONFIG = loadConfig();
// 一次性迁移(v1.0.6):旧存储的 240 分钟上限 / 1x 倍速 强制升级为新默认(0 不限 + 2x)
try {
const MIG = 'cxMigV105';
const done = (typeof GM_getValue !== 'undefined') ? GM_getValue(MIG, false) : localStorage.getItem(MIG);
if (!done) {
CONFIG.dailyLimitMinutes = 0;
CONFIG.speed = 2;
saveConfig(CONFIG);
if (typeof GM_setValue !== 'undefined') GM_setValue(MIG, true);
else localStorage.setItem(MIG, '1');
}
} catch (e) { /* ignore */ }
if (CONFIG.speed > 2) { CONFIG.speed = 2; } // 倍速上限 2x
// 一次性迁移(v1.0.11-local):deepseek-reasoner 已于 2026-07 停用,自动换现役模型;清除废弃的 reportUrl
try {
const MIG2 = 'cxMigV110';
const done2 = (typeof GM_getValue !== 'undefined') ? GM_getValue(MIG2, false) : localStorage.getItem(MIG2);
if (!done2) {
if (CONFIG.aiModel === 'deepseek-reasoner' || CONFIG.aiModel === 'deepseek-chat') {
CONFIG.aiModel = 'deepseek-v4-flash';
}
delete CONFIG.reportUrl;
saveConfig(CONFIG);
if (typeof GM_setValue !== 'undefined') GM_setValue(MIG2, true);
else localStorage.setItem(MIG2, '1');
}
} catch (e) { /* ignore */ }
// 一次性迁移(v2.5.8):老配置没有 aiProvider,按接口地址反查补全,面板才能正确回显官网信息
try {
const MIG3 = 'cxMigV258';
const done3 = (typeof GM_getValue !== 'undefined') ? GM_getValue(MIG3, false) : localStorage.getItem(MIG3);
if (!done3) {
if (!CONFIG.aiProvider) CONFIG.aiProvider = detectProvider(CONFIG.aiUrl);
if (CONFIG.aiModel === 'deepseek-reasoner' || CONFIG.aiModel === 'deepseek-chat') {
CONFIG.aiModel = 'deepseek-v4-flash';
}
saveConfig(CONFIG);
if (typeof GM_setValue !== 'undefined') GM_setValue(MIG3, true);
else localStorage.setItem(MIG3, '1');
}
} catch (e) { /* ignore */ }
/* 题目收集器:做过的题(题干+选项+答案)自动积累,导出后交给 AI 整理成考前手册 */
let COLLECTED = [];
try {
COLLECTED = (typeof GM_getValue !== 'undefined')
? GM_getValue('cxQuestions', [])
: JSON.parse(localStorage.getItem('cxQuestions') || '[]');
if (!Array.isArray(COLLECTED)) COLLECTED = [];
// 清洗:历史上思维链泄漏会把整段推理文字当答案存入库(填空题答案不会超过 60 字),
// 启动时把这类污染记录剔除,防止每次都「查到」垃圾答案
const n0 = COLLECTED.length;
COLLECTED = COLLECTED.filter((it) => !(String(it.t) === '2' && String(it.a || '').length > 60));
if (COLLECTED.length !== n0 && typeof GM_setValue !== 'undefined') GM_setValue('cxQuestions', COLLECTED);
else if (COLLECTED.length !== n0) localStorage.setItem('cxQuestions', JSON.stringify(COLLECTED));
} catch (e) { COLLECTED = []; }
function recordQuestion(q, answer, confidence) {
try {
// 只收录「本题确实写进提交域 + 答案来源可信」的答案。
// 旧版无条件 push:答错的、AI 猜的、点击其实失败的答案全进了本地题库,
// 而且同名题目重复追加,channelLocal 取第一条 → 一次猜错,以后每章都错。
const conf = Number(confidence == null ? 1 : confidence);
if (!Number.isFinite(conf) || conf < 0.85) return;
const cleanAns = sanitizeAnswers(answer || [], q.type);
if (!cleanAns.length) return;
const key = normQ(q.question);
if (!key) return;
const rec = { q: q.question, t: String(q.type), o: (q.options || []).join('§'), a: cleanAns.join('|'), c: conf, src: 'auto' };
const at = COLLECTED.findIndex((it) => normQ(it.q) === key);
if (at >= 0) {
// 手动导入 / 结果页判分确认过的答案不许自动收录改写
if (COLLECTED[at].src === 'import' || COLLECTED[at].src === 'verified') return;
const old = Number(COLLECTED[at].c == null ? 1 : COLLECTED[at].c);
if (Number.isFinite(old) && old > conf) return; // 不拿低可信答案覆盖高可信答案
COLLECTED[at] = rec;
} else {
COLLECTED.push(rec);
if (COLLECTED.length > 20000) COLLECTED = COLLECTED.slice(-20000);
}
if (typeof GM_setValue !== 'undefined') GM_setValue('cxQuestions', COLLECTED);
else localStorage.setItem('cxQuestions', JSON.stringify(COLLECTED));
// 中央题库同步:有答案的题上报到自建后端(source=user,不覆盖已有的 AI/管理员答案)
const ans = cleanAns;
if (ans.length && CONFIG.serverUrl) {
cxFetch(serverBase() + '/api.php?r=report', {
method: 'POST', timeout: 8000,
data: JSON.stringify({ event: 'bank', platform: platformName(), course: currentCourse(), items: [{ q: q.question, t: String(q.type), o: (q.options || []).join('§'), a: ans.join('|') }] }),
headers: { 'Content-Type': 'application/json' }
}).catch(() => { /* ignore */ });
}
} catch (e) { /* ignore */ }
}
/* ===== 结果页自动纠错(让题库只留正确答案) =====
交卷后平台结果页会给出「我的答案 / 正确答案 / 对错 / 得分」。这是脚本唯一能
客观判定答案对错的来源。以前脚本从不读它,所以一条错答案进了本地题库就会被
永远优先命中(本地题库优先级最高),再也没机会被纠正 —— 越刷越错。
规则(全部带保护,绝不误删):
① 平台公布正确答案 → 写成 verified,直接覆盖旧错答案(含手动导入的错答案)
② 判对且「我的答案」有效 → 把我的答案写成 verified 锁定
③ 判错且「我的答案」非空且 == 题库里存的那条 → 删掉这条错答案,下次重新查 AI/在线题库
④ 白卷(我的答案空) → 不删!那可能是提交域没写进去,不是答案本身错
不少课程结果页不公布正确答案,只给对错+得分,所以 ③ 是主要纠错路径。 */
// 门控必须严格:只有明确出现「对错/正确答案/得分」标记才允许动题库(误删不可逆)
const RESULT_GATE_SEL = '.marking_dui, .marking_cuo, .correctAnswer, .correctAnswerBx, .rightAnswerContent, .right_answer, .newAnswerScore';
const RESULT_Q_SEL = '.TiMu, .questionLi, .mark_item';
const RESULT_CORRECT_SEL = '.correctAnswer .answerCon, .correctAnswerBx .correctAnswer, .rightAnswerContent, .mark_key .answerCon, .mark_key, .right_answer, .correctAnswer';
const RESULT_MY_SEL = '.myAnswer .answerCon, .myAnswer, .mark_answer, .answerCon';
function persistBank() {
try {
if (typeof GM_setValue !== 'undefined') GM_setValue('cxQuestions', COLLECTED);
else localStorage.setItem('cxQuestions', JSON.stringify(COLLECTED));
} catch (e) { /* ignore */ }
}
function resultStem(root) {
const el = root.querySelector('.Zy_TItle, .mark_name, .questionTitle, .q-title, .stem, .title');
const s = el ? String(el.textContent || '') : String(root.textContent || '').slice(0, 140);
return s.replace(/^\s*\d+\s*[.、).]?\s*/, '')
.replace(/【(单选题|多选题|判断题|填空题|简答题|论述题)】/g, '')
.replace(/^\s*(单选题|多选题|判断题|填空题)\s*[::]\s*/, '')
.replace(/\s+/g, ' ').trim();
}
function resultType(root, stem) {
try {
const ti = root.querySelector('input[name^=answertype], input[id^=answertype]');
if (ti && String(ti.value || '')) return String(ti.value);
} catch (e) { /* ignore */ }
// 用题目原文判断题型:resultStem 会剥掉【判断题】标记,不能拿它判
const raw = String(root.textContent || '').slice(0, 60);
if (/多选/.test(raw)) return '1';
if (/判断/.test(raw)) return '3';
if (/填空/.test(raw)) return '2';
return '0';
}
function resultAnsText(root, sel) {
const el = root.querySelector(sel);
if (!el) return '';
return String(el.textContent || '').replace(/\s+/g, ' ').trim();
}
// 结果页答案文本 → 合法答案数组。严格按题型校验,宁可不学也不写脏数据。
function normalizeResultAnswer(raw, type) {
let s = String(raw || '').replace(/\s+/g, ' ').trim();
s = s.replace(/^(正确答案|我的答案|参考答案|答案)\s*[::]\s*/i, '').trim();
s = s.replace(/\s*\(.*$/, '').trim(); // 去掉 "(推断正确)" 之类的附注
if (!s) return [];
const t = String(type);
if (t === '3') {
if (/^(正确|对|√|true|T|是)$/i.test(s)) return ['正确'];
if (/^(错误|错|×|false|F|否)$/i.test(s)) return ['错误'];
return [];
}
if (t === '0' || t === '1') {
// 只认「纯字母 + 分隔符」,防止从选项正文/解析里抓到零散字母
if (!/^[A-Ha-h\s,,、;;|/]+$/.test(s)) return [];
const letters = (s.match(/[A-Ha-h]/g) || []).map((x) => x.toUpperCase());
if (!letters.length) return [];
return t === '0' ? [letters[0]] : [...new Set(letters)];
}
return sanitizeAnswers([s], t);
}
function bankIndexOf(stem) {
const key = normQ(stem);
if (!key || key.length < 4) return -1;
const exact = COLLECTED.findIndex((it) => normQ(it.q) === key);
if (exact >= 0) return exact;
return COLLECTED.findIndex((it) => {
const n = normQ(it.q);
return n.length >= 8 && (n.includes(key) || key.includes(n));
});
}
function bankAnsSet(a) { return String(a || '').split(/[|,,、;;\s]+/).filter(Boolean).map((x) => x.toUpperCase()).sort().join(''); }
function upsertVerified(stem, type, ans) {
const rec = { q: stem, t: String(type), o: '', a: ans.join('|'), c: 1.5, src: 'verified' };
const at = bankIndexOf(stem);
if (at >= 0) {
const old = COLLECTED[at];
// 已是同一份已验证答案 → 幂等,不再重复写/重复打日志
if (old.src === 'verified' && bankAnsSet(old.a) === bankAnsSet(ans.join('|'))) return false;
COLLECTED[at] = rec;
} else {
COLLECTED.push(rec);
if (COLLECTED.length > 20000) COLLECTED = COLLECTED.slice(-20000);
}
return true;
}
function learnFromResult(doc) {
const out = { learned: 0, removed: 0, skipped: 0 };
try {
if (!doc || !doc.querySelector) return out;
// 没有判分/答案标记 = 不是结果页,绝不动题库
if (!doc.querySelector(RESULT_GATE_SEL)) return out;
const roots = Array.from(doc.querySelectorAll(RESULT_Q_SEL));
for (const r of roots) {
const stem = resultStem(r);
if (stem.length < 4) { out.skipped++; continue; }
const t = resultType(r, stem);
const published = normalizeResultAnswer(resultAnsText(r, RESULT_CORRECT_SEL), t);
const mine = normalizeResultAnswer(resultAnsText(r, RESULT_MY_SEL), t);
const dui = !!r.querySelector('.marking_dui');
const cuo = !!r.querySelector('.marking_cuo');
const scoreEl = r.querySelector('.newAnswerScore .scoreNum, .mark_score .scoreNum, .scoreNum');
const scored = scoreEl ? parseFloat(String(scoreEl.textContent || '').replace(/[^\d.]/g, '')) : NaN;
// ① 平台公布了正确答案 → 覆盖(优先级最高,连手动导入的错答案也纠正)
if (published.length) {
if (upsertVerified(stem, t, published)) out.learned++;
continue;
}
// ② 判对(对勾或得分>0)且我的答案有效 → 锁进题库
if ((dui || (Number.isFinite(scored) && scored > 0)) && mine.length) {
if (upsertVerified(stem, t, mine)) out.learned++;
continue;
}
// ③ 判错:只有「我的答案非空」且「正是题库里存的那条」才删,白卷绝不误删
if (cuo && mine.length) {
const at = bankIndexOf(stem);
if (at >= 0 && COLLECTED[at].src !== 'verified'
&& bankAnsSet(COLLECTED[at].a) === bankAnsSet(mine.join('|'))) {
COLLECTED.splice(at, 1);
out.removed++;
} else out.skipped++;
continue;
}
out.skipped++;
}
if (out.learned || out.removed) persistBank();
} catch (e) { /* ignore */ }
return out;
}
function exportQuestions() {
if (!COLLECTED.length) { log('📋 还没有收集到题目(做完学习检测/弹题后自动收集)', 'warn'); return; }
const data = JSON.stringify(COLLECTED);
const done = () => log(`📋 已导出 ${COLLECTED.length} 道题,全选复制发给 AI 助手`, 'ok');
try {
if (navigator.clipboard && navigator.clipboard.writeText) {
navigator.clipboard.writeText(data).then(done).catch(() => { showExportBox(data); });
} else showExportBox(data);
} catch (e) { showExportBox(data); }
}
function showExportBox(data) {
const ta = document.createElement('textarea');
ta.id = 'cxExportBox';
ta.value = data;
document.body.appendChild(ta);
ta.focus(); ta.select();
ta.addEventListener('blur', () => { try { ta.remove(); } catch (e) {} });
log('📋 题目数据已生成在左下角文本框,全选(Ctrl+A)复制后发给 AI 助手', 'ok');
}
/* ==================== 工具函数 ==================== */
// 暂停感知等待:挂机暂停期间所有等待挂起(任务冻结在当前步骤,不会继续跑),
// 点「开始」恢复后从原处继续——切章/答题/翻页全部感知暂停状态
const sleep = async (s) => {
let left = Math.max(0, s * 1000);
while (left > 0) {
if (PAUSED) { await new Promise((r) => setTimeout(r, 300)); continue; }
const step = Math.min(250, left);
await new Promise((r) => setTimeout(r, step));
left -= step;
}
};
const randomSleep = (min, max) => sleep(Math.floor(Math.random() * (max - min + 1)) + min);
const waitResume = async () => { while (PAUSED) await new Promise((r) => setTimeout(r, 300)); };
function waitElementLoaded(win, selector, timeoutMs = 60000) {
return new Promise((resolve, reject) => {
const start = Date.now();
const timer = setInterval(() => {
try {
if (win.document.querySelector(selector)) { clearInterval(timer); resolve(); return; }
} catch (e) { /* iframe 未就绪 */ }
if (Date.now() - start > timeoutMs) { clearInterval(timer); reject(new Error('等待元素超时: ' + selector)); }
}, 200);
});
}
function waitIframeLoaded(iframe, timeoutMs = 60000) {
return new Promise((resolve, reject) => {
const start = Date.now();
const timer = setInterval(() => {
try {
if (iframe.contentDocument && iframe.contentDocument.readyState === 'complete') { clearInterval(timer); resolve(); return; }
} catch (e) { /* ignore */ }
if (Date.now() - start > timeoutMs) { clearInterval(timer); reject(new Error('iframe 加载超时')); }
}, 200);
});
}
// HTML 转纯文本(保留 img/sub/sup/br)
function clean(html) {
if (html == null) return '';
return String(html)
.replace(/<((?!img|sub|sup|br)[^>]+)>/g, '')
.replace(/ /g, ' ')
.replace(/\s+/g, ' ')
.replace(/
/gi, '\n')
.trim();
}
// 去题型前缀【单选题】和分值后缀(2.0分)
const cl = (str) => String(str).replace(/^【.*?】\s*/, '').replace(/\s*(\d+(\.\d+)?分)$/, '');
// 跨域请求:油猴环境用 GM_xmlhttpRequest,普通环境降级 fetch
function cxFetch(url, { method = 'GET', data = null, headers = {}, timeout = 10000 } = {}) {
return new Promise((resolve, reject) => {
if (typeof GM_xmlhttpRequest !== 'undefined') {
GM_xmlhttpRequest({
method, url, data, headers, timeout,
onload: (res) => resolve(res.responseText),
onerror: (err) => reject(err),
ontimeout: () => reject(new Error('timeout'))
});
} else {
fetch(url, { method, headers, body: data }).then((r) => r.text()).then(resolve).catch(reject);
}
});
}
/* ===== 自建后端对接(题库搜集 + 服务端 AI + 使用统计 + 卡密) ===== */
function serverBase() { return (CONFIG.serverUrl || '').replace(/\/$/, ''); }
// 卡密激活:绑定当前设备,服务端返回到期时间(卡密模式下未激活用户只能查题库,不能用服务端 AI)
async function activateCard(cardKey) {
if (!serverBase()) return;
try {
const res = JSON.parse(await cxFetch(serverBase() + '/api.php?r=card/activate', {
method: 'POST', timeout: 10000,
data: JSON.stringify({ cardKey: cardKey, clientId: clientId() }),
headers: { 'Content-Type': 'application/json' }
}));
if (res.ok) log(`✅ 卡密已生效,服务端 AI 可用至: ${res.expireAt}`, 'ok');
else log('❌ 卡密激活失败: ' + (res.message || '未知错误'), 'err');
} catch (e) { log('卡密激活请求失败(检查服务器地址是否正确)', 'warn'); }
}
/* 「🔄次数」按钮/配置面板卡密状态:向后端查询剩余次数/到期时间 */
async function queryCardStatus(target) {
const show = (msg, level) => { if (target) target.textContent = msg; log(msg, level); };
if (!CONFIG.serverUrl) { show('未配置服务器地址,无法查询卡密', 'warn'); return; }
if (!CONFIG.cardKey) { show('未填卡密', 'warn'); return; }
try {
const res = JSON.parse(await cxFetch(serverBase() + '/api.php?r=card/query', {
method: 'POST', timeout: 10000,
data: JSON.stringify({ cardKey: CONFIG.cardKey, clientId: clientId() }),
headers: { 'Content-Type': 'application/json' }
}));
if (res.ok) {
if (res.type === 'count') {
show(`✅ 剩余自动答题次数:${res.left} 次(共 ${res.limit} 次,已用 ${res.used} 次)${res.active ? '' : '(已用完,请续购)'}`, res.active ? 'ok' : 'warn');
} else {
show(res.active ? `✅ 自动答题有效期至 ${res.expireAt}(累计已答 ${res.used} 题)` : `⚠ 天数卡未激活或已过期(累计已答 ${res.used} 题)`, res.active ? 'ok' : 'warn');
}
} else {
show('⚠ ' + (res.message || '卡密查询失败'), 'warn');
}
} catch (e) { show('⚠ 无法连接服务器,查询失败', 'err'); }
}
function clientId() {
try {
let id = (typeof GM_getValue !== 'undefined') ? GM_getValue('cxClientId', '') : (localStorage.getItem('cxClientId') || '');
if (!id) {
id = 'u' + Math.random().toString(36).slice(2, 12);
if (typeof GM_setValue !== 'undefined') GM_setValue('cxClientId', id);
else localStorage.setItem('cxClientId', id);
}
return id;
} catch (e) { return 'anonymous'; }
}
// 平台识别:后端按平台分类存储题库(chaoxing=学习通 zhihuishu=智慧树 icourse163=中国大学MOOC xuetangx=学堂在线 unipus=U校园)
function platformName() {
try {
const h = location.hostname;
if (h.includes('chaoxing') || h.includes('xueyitong') || h.includes('xuexitong')) return 'chaoxing';
if (h.includes('zhihuishu') || h.includes('studyvideoh5') || h.includes('shengda')) return 'zhihuishu';
if (h.includes('icourse163')) return 'icourse163';
if (h.includes('xuetangx')) return 'xuetangx';
if (h.includes('unipus')) return 'unipus';
return 'other';
} catch (e) { return 'other'; }
}
// 课程名:用于后端按课程分类存储题库(学习通标题一般是「课程名-章节名-学习通」)
function currentCourse() {
try {
return document.title
.replace(/\s*[-—_|]\s*(学习通|超星|chaoxing).*$/i, '')
.replace(/\s*[-—_|].{0,12}(章|节|单元).{0,10}$/, '')
.replace(/\s+/g, ' ').trim() || '未知课程';
} catch (e) { return '未知课程'; }
}
// 页面访问上报:后端据此统计「今日使用人数」;顺带做版本检查
function reportVisit() {
if (!CONFIG.serverUrl) return;
try {
cxFetch(serverBase() + '/api.php?r=report', {
method: 'POST', timeout: 8000,
data: JSON.stringify({ event: 'visit', clientId: clientId(), platform: platformName(), course: currentCourse() }),
headers: { 'Content-Type': 'application/json' }
}).catch(() => { /* 后端未启动则静默 */ });
checkUpdate();
} catch (e) { /* ignore */ }
}
/* 版本检查:对比后端配置的「脚本最新版本号」(后台维护),有新版就提示 + 面板显示 🔔 */
function compareVer(a, b) {
const pa = String(a).split(/[.\-]/).map((x) => parseInt(x, 10) || 0);
const pb = String(b).split(/[.\-]/).map((x) => parseInt(x, 10) || 0);
for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
const d = (pa[i] || 0) - (pb[i] || 0);
if (d !== 0) return d;
}
return 0;
}
let updateChecked = false;
async function checkUpdate() {
if (updateChecked) return;
updateChecked = true;
try {
const res = JSON.parse(await cxFetch(serverBase() + '/api.php?r=version', { method: 'GET', timeout: 8000, headers: {} }));
const mine = (typeof GM_info !== 'undefined' && GM_info.script && GM_info.script.version) || '0';
if (res.version && compareVer(res.version, mine) > 0) {
log(`🔔 发现新版本 v${res.version}(当前 v${mine}),点面板「🔔新版本」获取更新`, 'warn');
const t = document.getElementById('cxTitle');
if (t && !document.getElementById('cxUpdate')) {
const a = document.createElement('a');
a.id = 'cxUpdate';
a.href = res.url || 'https://xuexit.baozl.com/';
a.target = '_blank';
a.title = `最新 v${res.version},点击前往下载`;
a.textContent = '🔔新版本';
t.insertBefore(a, document.getElementById('cxStatus'));
}
}
} catch (e) { /* 后端不可达则静默 */ }
}
// 服务器通道:后端先查自建题库;未命中且管理员配置了 AI,则服务端作答并自动入库 → 用户免配 Key
let serverWarned = false;
async function channelServer(q) {
try {
const res = JSON.parse(await cxFetch(serverBase() + '/api.php?r=ask', {
method: 'POST', timeout: 30000,
data: JSON.stringify({ question: q.question, options: q.options || [], type: String(q.type), platform: platformName(), course: currentCourse(), clientId: clientId(), cardKey: CONFIG.cardKey || '' }),
headers: { 'Content-Type': 'application/json' }
}));
if (res.found && res.answers && res.answers.length) return { form: res.form || '服务器', answer: res.answers };
if (res.needCard) log('题库未收录,服务端 AI 需要卡密:点面板「🛒购卡」购买 → ⚙ 里填入卡密即可用服务端 AI', 'warn');
return { form: '服务器', answer: [] };
} catch (e) {
if (!serverWarned) {
serverWarned = true;
log(`无法连接自建后端(${CONFIG.serverUrl}),将只用本地通道。请确认后端已部署且「服务器地址」填写正确`, 'warn');
}
return { form: '服务器', answer: [] };
}
}
/* ==================== 日志面板 ==================== */
let logPanel = null;
let logLines = [];
function setStatus(text) {
const el = document.getElementById('cxStatus');
if (el) el.textContent = text;
// 状态文字右侧按钮:工作中(未暂停)→ 停止;待机/已暂停 → 开始
const btn = document.getElementById('cxRunBtn');
if (btn) btn.textContent = (text === '工作中' && !PAUSED) ? '⏸' : '▶';
}
// 日志转义:DOM 诊断片段含 HTML 标签,必须转义后再显示,否则被面板当真标签吞掉
function escapeHtml(s) {
return String(s).replace(/&/g, '&').replace(//g, '>').replace(/"/g, '"');
}
function log(msg, level = 'info') {
const time = new Date().toLocaleTimeString('zh-CN', { hour12: false });
const line = `[${time}] ${msg}`;
const color = level === 'ok' ? '#7ee787' : level === 'warn' ? '#f0b72f' : level === 'err' ? '#f85149' : '#58a6ff';
console.log(`%c[刷课助手] ${line}`, `color:${color}`);
if (logPanel) {
logLines.push({ line, level });
if (logLines.length > 60) logLines.shift();
const logsEl = document.getElementById('cxLogs');
if (logsEl) {
logsEl.innerHTML = logLines.map((l) => `${escapeHtml(l.line)}
`).join('');
logsEl.scrollTop = logsEl.scrollHeight;
}
}
}
// ===== 本地状态上报机制已删除(不再向任何地址推送页面状态)=====
function scriptVersion() {
try { if (typeof GM_info !== 'undefined' && GM_info.script && GM_info.script.version) return GM_info.script.version; } catch (e) { /* ignore */ }
return 'unknown';
}
function initPanel() {
if (logPanel) return;
logPanel = document.createElement('div');
logPanel.id = 'cx-panel';
logPanel.innerHTML =
'' +
'';
const style = document.createElement('style');
style.textContent = `
/* ===== 清新主题(白底 × 薄荷青 · 细边框 · 轻阴影)===== */
#cx-panel,#cxCfgPanel{--cx-bg:#ffffff;--cx-bg-soft:#f6faf9;--cx-line:#e2edeb;--cx-ink:#2f4249;--cx-ink-soft:#7d939a;--cx-accent:#3fa79c;--cx-accent-dk:#318b82;--cx-accent-bg:#e8f5f2;--cx-ok:#2e9e73;--cx-warn:#c98a2b;--cx-err:#d05c58;--cx-shadow:0 6px 24px rgba(45,96,92,.10),0 1px 3px rgba(45,96,92,.06);--cx-radius:14px}
#cx-panel{position:fixed;right:18px;bottom:18px;width:400px;max-height:280px;overflow:hidden;background:var(--cx-bg);color:var(--cx-ink);border:1px solid var(--cx-line);border-radius:var(--cx-radius);font:12px/1.65 -apple-system,"PingFang SC","Microsoft YaHei",sans-serif;z-index:2147483647;box-shadow:var(--cx-shadow)}
#cxTitle{padding:10px 12px;font-weight:600;letter-spacing:.2px;cursor:move;display:flex;flex-wrap:nowrap;gap:6px;align-items:center;min-width:0;color:var(--cx-ink);background:var(--cx-bg-soft);border-bottom:1px solid var(--cx-line);user-select:none}
#cxTitleText{flex:1 1 auto;min-width:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.cx-avatar{width:18px;height:18px;border-radius:50%;object-fit:cover;flex:0 0 auto;border:1px solid var(--cx-line);background:var(--cx-bg)}
#cxStatus{margin-left:auto;padding:1px 9px;font-size:11px;font-weight:500;color:var(--cx-accent-dk);background:var(--cx-accent-bg);border-radius:999px;white-space:nowrap;flex:0 0 auto}
#cxRunBtn,#cxToggleBtn,#cxCfgBtn{cursor:pointer;font-size:13px;line-height:1.4;color:var(--cx-accent-dk);background:var(--cx-bg);border:1px solid var(--cx-line);border-radius:8px;padding:2px 9px;transition:background .16s,border-color .16s,transform .16s;flex:0 0 auto}
#cxTutorial,#cxShop,#cxUpdate,#cxCardBtn{cursor:pointer;font-size:11px;line-height:1.5;color:var(--cx-accent-dk);background:var(--cx-bg);border:1px solid var(--cx-line);border-radius:8px;padding:2px 8px;text-decoration:none;white-space:nowrap;transition:background .16s,border-color .16s;flex:0 0 auto}
#cxUpdate{color:#d05c58;border-color:#d05c58;font-weight:600}
#cxRunBtn:hover,#cxToggleBtn:hover,#cxCfgBtn:hover,#cxTutorial:hover,#cxShop:hover,#cxUpdate:hover,#cxCardBtn:hover{background:var(--cx-accent-bg);border-color:var(--cx-accent)}
#cxRunBtn:active,#cxToggleBtn:active,#cxCfgBtn:active,#cxTutorial:active,#cxShop:active,#cxUpdate:active,#cxCardBtn:active{transform:translateY(1px);background:#dcefea}
#cxCfgBtn{margin-left:0}
#cxLogs{padding:8px 14px 10px;overflow-y:auto;max-height:220px;scrollbar-width:thin;scrollbar-color:#cfe2de transparent}
#cxLogs div{color:var(--cx-ink-soft);margin:3px 0;border-left:2px solid var(--cx-line);padding-left:9px;word-break:break-all}
#cxLogs div.ok{border-color:var(--cx-ok);color:var(--cx-ok)}
#cxLogs div.warn{border-color:var(--cx-warn);color:var(--cx-warn)}
#cxLogs div.err{border-color:var(--cx-err);color:var(--cx-err)}
#cxCfgPanel{position:fixed;right:18px;bottom:18px;width:400px;max-height:82vh;overflow-y:auto;background:var(--cx-bg);color:var(--cx-ink);border:1px solid var(--cx-line);border-radius:var(--cx-radius);padding:16px 18px;z-index:2147483647;font:13px/1.6 -apple-system,"PingFang SC","Microsoft YaHei",sans-serif;box-shadow:var(--cx-shadow);scrollbar-width:thin;scrollbar-color:#cfe2de transparent}
#cxCfgPanel .field{margin:12px 0;border-bottom:1px solid var(--cx-line);padding-bottom:12px}
#cxCfgPanel .label{font-weight:600;margin-bottom:6px;color:var(--cx-ink)}
#cxCfgPanel .hint{font-size:11.5px;color:var(--cx-ink-soft);margin-top:5px;line-height:1.55}
#cxCfgPanel input,#cxCfgPanel select{width:100%;box-sizing:border-box;background:var(--cx-bg-soft);color:var(--cx-ink);border:1px solid var(--cx-line);border-radius:9px;padding:7px 10px;transition:border-color .16s,box-shadow .16s}
#cxCfgPanel input:focus,#cxCfgPanel select:focus{outline:none;border-color:var(--cx-accent);box-shadow:0 0 0 3px rgba(63,167,156,.12);background:#fff}
#cxCfgPanel input[type=checkbox]{width:16px;height:16px;accent-color:var(--cx-accent)}
#cxCfgPanel .btns{display:flex;justify-content:flex-end;gap:8px;margin-top:8px}
#cxCfgPanel button{background:var(--cx-accent);border:1px solid var(--cx-accent);color:#fff;border-radius:9px;padding:7px 16px;cursor:pointer;font-size:13px;transition:background .16s,transform .16s}
#cxCfgPanel button:hover{background:var(--cx-accent-dk);border-color:var(--cx-accent-dk)}
#cxCfgPanel button:active{transform:translateY(1px)}
#cxCfgPanel button#cfgClose{background:transparent;color:var(--cx-ink-soft);border-color:var(--cx-line)}
#cxCfgPanel button#cfgClose:hover{background:var(--cx-bg-soft);color:var(--cx-ink);border-color:var(--cx-ink-soft)}
#cxCfgPanel .sec{margin:14px 0 8px;font-weight:700;color:var(--cx-accent-dk);font-size:12.5px;background:var(--cx-accent-bg);border-radius:9px;padding:6px 10px}
#cxCfgPanel .sec:first-child{margin-top:0}
#cxCfgPanel .field:last-of-type{border-bottom:none}
#cxCfgPanel .check{display:flex;align-items:center;gap:8px;cursor:pointer;padding:3px 0;font-weight:500}
#cxCfgPanel .check input{width:16px;height:16px;flex:0 0 auto}
#cxCfgPanel .row{display:flex;gap:10px}
#cxCfgPanel .row .field{flex:1;margin:0;border-bottom:none;padding-bottom:0}
#cxCfgPanel .inline{display:flex;gap:8px;align-items:center}
#cxCfgPanel .inline input{flex:1}
#cxCfgPanel .inline button,#cxCfgPanel button.ghost{background:var(--cx-bg);color:var(--cx-accent-dk);border:1px solid var(--cx-accent);font-size:12px;padding:6px 12px;white-space:nowrap;flex:0 0 auto}
#cxCfgPanel .inline button:hover,#cxCfgPanel button.ghost:hover{background:var(--cx-accent-bg)}
#cxCfgPanel .checks{display:flex;gap:4px 18px;flex-wrap:wrap}
#cxCfgPanel .tip{font-size:11.5px;color:var(--cx-accent-dk);background:var(--cx-accent-bg);border-radius:9px;padding:7px 10px;margin-bottom:10px;white-space:nowrap;overflow-x:auto;scrollbar-width:thin;scrollbar-color:#cfe2de transparent}
#cxCfgPanel summary.sec{list-style:none;cursor:pointer;user-select:none;display:flex;align-items:center;justify-content:space-between}
#cxCfgPanel summary.sec::-webkit-details-marker{display:none}
#cxCfgPanel summary.sec::after{content:'▾';font-size:11px;color:var(--cx-accent-dk);margin-left:8px}
#cxCfgPanel details:not([open]) > summary.sec::after{content:'▸'}
#cxCfgPanel summary.sec:hover{filter:brightness(.96)}
#cxCfgPanel .status{font-size:12px;color:var(--cx-accent-dk);background:var(--cx-bg-soft);border:1px dashed var(--cx-line);border-radius:8px;padding:5px 9px;margin-top:6px;min-height:14px}
#cxCfgPanel .pinfo{margin-top:8px;background:var(--cx-bg-soft);border:1px solid var(--cx-line);border-radius:10px;padding:9px 11px;font-size:11.5px;line-height:1.75}
#cxCfgPanel .pi-head{font-weight:600;color:var(--cx-accent-dk);margin-bottom:4px}
#cxCfgPanel .pi-row{display:flex;gap:8px;align-items:baseline;flex-wrap:wrap}
#cxCfgPanel .pi-row b{flex:0 0 62px;font-weight:500;color:var(--cx-ink-soft)}
#cxCfgPanel .pinfo a{color:var(--cx-accent-dk);text-decoration:underline}
#cxCfgPanel .pinfo code{font:11px/1.5 ui-monospace,Consolas,monospace;background:var(--cx-bg);border:1px solid var(--cx-line);border-radius:5px;padding:1px 5px;word-break:break-all}
#cxCfgPanel .pi-none{color:var(--cx-ink-soft)}
#cxCfgPanel .pi-note{margin-top:6px;padding-top:6px;border-top:1px dashed var(--cx-line);color:var(--cx-ink-soft)}
#cxCfgPanel .pi-test{font-size:11.5px;margin-top:6px;padding:5px 9px;border-radius:8px;background:var(--cx-bg-soft);border:1px dashed var(--cx-line);color:var(--cx-ink-soft);word-break:break-all}
#cxCfgPanel .pi-test.ok{color:var(--cx-ok);border-color:var(--cx-ok);border-style:solid}
#cxCfgPanel .pi-test.err{color:var(--cx-err);border-color:var(--cx-err);border-style:solid}
#cxExportBox{position:fixed;left:16px;bottom:16px;width:460px;height:220px;z-index:2147483647;background:var(--cx-bg,#fff);color:var(--cx-ink,#2f4249);border:1px solid var(--cx-line,#e2edeb);border-radius:var(--cx-radius,14px);padding:10px;font:12px/1.5 ui-monospace,Consolas,monospace;box-shadow:var(--cx-shadow,0 6px 24px rgba(45,96,92,.10))}
`;
document.head.appendChild(style);
document.body.appendChild(logPanel);
log('刷课助手 v' + scriptVersion() + ' 已加载(看这一行确认版本)');
document.getElementById('cxCfgBtn').addEventListener('click', showConfigUI);
document.getElementById('cxRunBtn').addEventListener('click', togglePause);
// 展开/收起日志(小按钮,表头其余区域留给拖拽)
document.getElementById('cxToggleBtn').addEventListener('click', () => {
const logsEl = document.getElementById('cxLogs');
const hidden = logsEl.style.display === 'none';
logsEl.style.display = hidden ? '' : 'none';
document.getElementById('cxToggleBtn').textContent = hidden ? '▼' : '▲';
});
// 表头拖拽移动面板(按住表头空白处拖动;按钮区域不触发拖拽)
const titleEl = document.getElementById('cxTitle');
titleEl.addEventListener('mousedown', (e) => {
if (e.target.closest('#cxRunBtn, #cxToggleBtn, #cxCfgBtn')) return;
e.preventDefault();
const rect = logPanel.getBoundingClientRect();
const startX = e.clientX;
const startY = e.clientY;
logPanel.style.left = rect.left + 'px';
logPanel.style.top = rect.top + 'px';
logPanel.style.right = 'auto';
logPanel.style.bottom = 'auto';
const onMove = (ev) => {
logPanel.style.left = (rect.left + ev.clientX - startX) + 'px';
logPanel.style.top = (rect.top + ev.clientY - startY) + 'px';
};
const onUp = () => {
document.removeEventListener('mousemove', onMove);
document.removeEventListener('mouseup', onUp);
};
document.addEventListener('mousemove', onMove);
document.addEventListener('mouseup', onUp);
});
// 首次启动引导(显示在日志区顶部,滚动可见)
if (logLines.length === 0) {
logLines.push({ line: '💡 打开课程章节页即自动开始挂机(无需任何操作)', level: 'info' });
logLines.push({ line: '⚙ 设置(每项都有说明) | 「开始/停止」控制挂机 | ▼ 展开收起日志', level: 'info' });
logLines.push({ line: '🤖 自动做题:请点 ⚙ → 勾选 AI 答题并填写 DeepSeek API Key', level: 'warn' });
}
const initLogs = document.getElementById('cxLogs');
if (initLogs) initLogs.innerHTML = logLines.map((l) => `${escapeHtml(l.line)}
`).join('');
}
let PAUSED = false;
function togglePause() {
PAUSED = !PAUSED;
setStatus(PAUSED ? '已暂停' : '工作中');
log(PAUSED ? '⏸ 已暂停挂机(切章/答题全部冻结在当前步骤,点「开始」继续)' : '▶ 已恢复挂机(任务从暂停处继续)', PAUSED ? 'warn' : 'ok');
}
function showConfigUI() {
const existing = document.getElementById('cxCfgPanel');
if (existing) { existing.remove(); return; }
const panel = document.createElement('div');
panel.id = 'cxCfgPanel';
// 平台回显:优先用已存的 aiProvider,老配置按接口地址反查,保证打开面板看到的就是当前对接的平台
const currentProvider = AI_PROVIDERS[CONFIG.aiProvider] ? CONFIG.aiProvider : detectProvider(CONFIG.aiUrl);
panel.innerHTML =
'💡 两种用法二选一:① 点「🛒购卡」买卡密 → 在「服务端答题」区核销,全程免配置;② 自己有 AI Key → 展开「自己对接 AI」填写
' +
'🖥 服务端答题(推荐 · 免 Key)
' +
'🔑 卡密核销
' +
'
' +
'
' + (CONFIG.cardKey ? '正在查询卡密状态...' : '未填卡密') + '
' +
'
核销后立即生效(天数卡按激活日算起,次数卡按次扣),一卡绑一台设备。没卡?点
🛒购卡购买,或点面板上方「🛒购卡」按钮。
' +
// 默认折叠:卡密是主路径,自有 AI 是可选分支;顶部 tip 已引导需要的人手动展开。
// 折叠只是 CSS 隐藏,DOM 与值仍在,保存配置时能正常读取本区所有字段。
'🤖 自己对接 AI(有 Key 才填,用卡密可跳过本区)
' +
'' +
'🏢 AI 平台
' +
'
' +
'
' +
'
选平台后自动填好接口地址与推荐模型,上方直接给出官网 / 创建 Key / 接口文档链接,你只需填 Key。
' +
'API Key
' +
'
' +
'
到上面所选平台的官网创建,只保存在你本机浏览器,不会上传。
' +
'模型名
' +
'
' +
'
' +
'
模型名会换代:填好 Key 后点「拉取模型列表」选现役模型,或直接点最下方「🔌 测试连接」自动校准。
' +
'AI 接口地址
' +
'
' +
'
OpenAI 兼容地址,须以 /chat/completions 结尾。
' +
'' +
'
未测试 · 建议先跑一次,避免挂机时才发现接不上
' +
'
用当前填的 Key / 地址 / 模型真发一次最小请求,直接告诉你通不通、错在哪;成功即自动保存并启用 AI 答题。
' +
'🎬 视频与刷课
' +
'' +
'
' +
'
' +
'
' +
'
' +
'
' +
'' +
'' +
'📚 题库备份
' +
'导出备份 / 只清掉脚本自己攒的答案(保留手动导入和判分确认的正确答案)
' +
'' +
'
' +
'
导入的答案视为最高可信度,会覆盖自动收录的旧答案(包括以前存错的),且不会被自动收录改写
' +
'';
document.body.appendChild(panel);
// 已填卡密则自动查询并直接显示剩余次数/到期时间(不用点任何按钮)
if (CONFIG.cardKey) queryCardStatus(document.getElementById('cfgCardStatus'));
document.getElementById('cfgSave').addEventListener('click', () => {
const providerKey = document.getElementById('cfgProvider').value;
const providerPreset = AI_PROVIDERS[providerKey] || AI_PROVIDERS.custom;
CONFIG.speed = cfgNum(document.getElementById('cfgSpeed').value, 1, 1, 2);
CONFIG.aiEnabled = document.getElementById('cfgAI').checked;
CONFIG.aiKey = document.getElementById('cfgAIKey').value.trim();
CONFIG.aiProvider = providerKey;
CONFIG.aiModel = document.getElementById('cfgAIModel').value.trim() || providerPreset.model || 'deepseek-v4-flash';
CONFIG.aiUrl = document.getElementById('cfgAIUrl').value.trim() || providerPreset.url || 'https://api.deepseek.com/v1/chat/completions';
// 「填了 Key 却没勾启用」是自有 AI 通道最常见的静默失败,这里直接帮他勾上并说清楚
if (CONFIG.aiKey && !CONFIG.aiEnabled) {
CONFIG.aiEnabled = true;
document.getElementById('cfgAI').checked = true;
log('🔑 检测到已填 API Key,已自动勾选「启用 AI 答题」(不勾则 AI 通道根本不会执行)', 'ok');
}
CONFIG.deliberateErrorRate = cfgNum(document.getElementById('cfgErrRate').value, 0, 0, 20) / 100;
CONFIG.dailyLimitMinutes = cfgNum(document.getElementById('cfgDaily').value, 0, 0, 1440);
CONFIG.autoSubmit = document.getElementById('cfgSubmit').checked;
CONFIG.autoJump = document.getElementById('cfgJump').checked;
CONFIG.useWebSearch = document.getElementById('cfgWeb').checked;
CONFIG.minAccuracy = cfgNum(document.getElementById('cfgMinAcc').value, 60, 0, 100) / 100;
CONFIG.cardKey = document.getElementById('cfgCard').value.replace(/\s+/g, '').toUpperCase();
CONFIG.overwrite = document.getElementById('cfgOverwrite').checked;
CONFIG.quizRandomFallback = document.getElementById('cfgQFb').checked;
CONFIG.muted = document.getElementById('cfgMuted').checked;
CONFIG.autoLearnResult = document.getElementById('cfgLearnResult').checked;
CONFIG.failTolerance = Math.round(cfgNum(document.getElementById('cfgFailTol').value, 3, 1, 10));
delete CONFIG.reportUrl; // 上报机制已移除,清除历史残留
saveConfig(CONFIG);
resetAIChannel(); // 改完配置立刻解除 AI 冷却,不用干等 10 分钟
log('配置已保存(倍速 ' + CONFIG.speed + 'x, AI ' + (CONFIG.aiEnabled ? '开' : '关') + ')', 'ok');
if (CONFIG.aiEnabled && CONFIG.aiKey) {
// 不再无条件 calibrateAIModel():旧逻辑会把用户手填的正确模型名按 /models 顺序乱改掉
log('✅ AI 通道已就绪: ' + providerPreset.label + ' | ' + CONFIG.aiUrl + ' | 模型 ' + CONFIG.aiModel, 'ok');
log('💡 建议点「🔌 测试连接」实测一次;自定义域名的首次请求需允许 Tampermonkey 跨域授权', 'info');
} else if (CONFIG.aiEnabled && !CONFIG.aiKey) {
log('⚠ 已启用 AI 答题但没填 API Key,AI 通道不会执行;请到面板显示的平台官网创建 Key', 'warn');
}
if (CONFIG.cardKey && CONFIG.serverUrl) activateCard(CONFIG.cardKey); // 卡密激活/校验(不阻塞)
panel.remove();
});
document.getElementById('cfgClose').addEventListener('click', () => panel.remove());
// 核销卡密:立即激活,不用先点「保存全部配置」;核销完自动刷新状态显示
document.getElementById('cfgRedeem').addEventListener('click', async () => {
const key = document.getElementById('cfgCard').value.replace(/\s+/g, '').toUpperCase();
const statusEl = document.getElementById('cfgCardStatus');
if (!key) { if (statusEl) statusEl.textContent = '请先粘贴卡密'; return; }
CONFIG.cardKey = key;
saveConfig(CONFIG);
if (statusEl) statusEl.textContent = '正在核销 ' + key.slice(0, 6) + '...';
log('正在核销卡密 ' + key.slice(0, 6) + '...', 'warn');
await activateCard(key);
queryCardStatus(statusEl);
});
document.getElementById('cfgExport').addEventListener('click', exportQuestions);
// 清掉「脚本自动收录」的答案(历史错答案/AI 猜的答案都在这里),手动导入的记录保留
document.getElementById('cfgPurgeAuto').addEventListener('click', () => {
// 只清「脚本自动收录」;手动导入 + 结果页判分确认过的正确答案都保留
const auto = COLLECTED.filter((it) => it.src !== 'import' && it.src !== 'verified').length;
if (!auto) { log('没有自动收录的记录,无需清理', 'info'); return; }
if (!confirm(`将清除 ${auto} 条脚本自动收录的题目答案(手动导入和结果页判分确认的正确答案会保留)。\n建议先点「📋 复制题目数据」备份。确定继续?`)) return;
COLLECTED = COLLECTED.filter((it) => it.src === 'import' || it.src === 'verified');
try {
if (typeof GM_setValue !== 'undefined') GM_setValue('cxQuestions', COLLECTED);
else localStorage.setItem('cxQuestions', JSON.stringify(COLLECTED));
} catch (e) { /* ignore */ }
log(`🧹 已清除 ${auto} 条自动收录记录,当前本地题库 ${COLLECTED.length} 条`, 'ok');
});
// 导入自建题库:支持脚本导出的 JSON 数组,也支持自整理的 [{q, a}] / [{question, answers}]
document.getElementById('cfgImport').addEventListener('click', () => {
const ta = document.getElementById('cfgImportData');
const raw = (ta.value || '').trim();
if (!raw) { log('请先把题库 JSON 粘贴到输入框再点导入', 'warn'); return; }
try {
const arr = JSON.parse(raw);
if (!Array.isArray(arr)) throw new Error('不是 JSON 数组(应为 [...] )');
let added = 0, replaced = 0, skipped = 0;
for (const it of arr) {
const question = String(it.q || it.question || '').trim();
let a = (it.a != null) ? it.a : (it.answer != null ? it.answer : it.answers);
if (Array.isArray(a)) a = a.join('|');
a = String(a || '').trim();
if (!question || !a) { skipped++; continue; }
// 同一道题以「手动导入」为准:直接替换掉自动收录的旧答案(以前存错的也能改掉)
const rec = { q: question, t: String(it.t != null ? it.t : (it.type != null ? it.type : '')),
o: String(it.o || ''), a: a, c: 1, src: 'import' };
const k = normQ(question);
const at = COLLECTED.findIndex((x) => normQ(x.q) === k);
if (at >= 0) { COLLECTED[at] = rec; replaced++; }
else { COLLECTED.push(rec); added++; }
}
if (COLLECTED.length > 20000) COLLECTED = COLLECTED.slice(-20000);
try {
if (typeof GM_setValue !== 'undefined') GM_setValue('cxQuestions', COLLECTED);
else localStorage.setItem('cxQuestions', JSON.stringify(COLLECTED));
} catch (e) { /* ignore */ }
log(`📥 题库导入完成:新增 ${added} 条、替换 ${replaced} 条、跳过 ${skipped} 条(缺答案),当前本地题库共 ${COLLECTED.length} 条`, 'ok');
ta.value = '';
} catch (e) {
log('导入失败: ' + (e.message || e), 'err');
}
});
// 平台预设统一走文件顶部的 AI_PROVIDERS(预设 / 官网信息 / 自动校准三处同源)
const renderProviderInfo = (key) => {
const box = document.getElementById('cfgProviderInfo');
if (box) box.innerHTML = providerInfoHtml(key);
};
renderProviderInfo(currentProvider);
document.getElementById('cfgProvider').addEventListener('change', (e) => {
const key = e.target.value;
const p = AI_PROVIDERS[key] || AI_PROVIDERS.custom;
document.getElementById('cfgAIUrl').value = p.url;
document.getElementById('cfgAIModel').value = p.model;
renderProviderInfo(key);
const t = document.getElementById('cfgTestResult');
if (t) { t.className = 'pi-test'; t.textContent = '已切换平台,请重新测试连接'; }
log('🏢 已切换 AI 平台: ' + p.label + (p.site ? ' (官网 ' + p.site + ')' : ''), 'info');
});
// 拉取真实模型列表:模型名会换代,拉一次就知道当前账号实际能用什么
document.getElementById('cfgFetchModels').addEventListener('click', async () => {
const base = document.getElementById('cfgAIUrl').value.trim();
const key = document.getElementById('cfgAIKey').value.trim();
const btn = document.getElementById('cfgFetchModels');
if (!base) { log('请先填写 AI 接口地址', 'warn'); return; }
if (!key) { log('请先填写 API Key,否则 /models 会直接返回 401', 'warn'); return; }
btn.disabled = true;
const old = btn.textContent;
btn.textContent = '拉取中...';
try {
const text = await cxFetch(modelsEndpointFor(base), { method: 'GET', headers: { 'Authorization': 'Bearer ' + key }, timeout: 15000 });
const obj = JSON.parse(text);
const raw = obj.data || obj.models || [];
const list = raw.map((m) => (m && (m.id || m.model || m.name)) || (typeof m === 'string' ? m : '')).filter(Boolean);
if (list.length) {
document.getElementById('cxModelList').innerHTML =
list.map((id) => '').join('');
const cur = document.getElementById('cfgAIModel').value.trim();
log('✅ 已拉取 ' + list.length + ' 个模型:点输入框选择现役模型' +
(cur && list.indexOf(cur) < 0 ? ';⚠ 当前模型 ' + cur + ' 不在列表里,请重新选一个' : ''), 'ok');
} else {
log('该平台 /models 未返回列表(部分平台不提供此接口),请到官网文档查模型名手动填写', 'warn');
}
} catch (e) {
log('拉取失败:检查 API Key、Tampermonkey 跨域授权(@connect)与网络;该平台也可能不提供 /models', 'warn');
}
btn.disabled = false;
btn.textContent = old;
});
// 一键实测:用面板当前值真发一次最小请求,把「到底能不能用」直接摊给用户
document.getElementById('cfgTestAI').addEventListener('click', async () => {
const box = document.getElementById('cfgTestResult');
const url = document.getElementById('cfgAIUrl').value.trim();
const key = document.getElementById('cfgAIKey').value.trim();
const model = document.getElementById('cfgAIModel').value.trim();
const providerKey = document.getElementById('cfgProvider').value;
if (!url || !key || !model) {
box.className = 'pi-test err';
box.textContent = '❌ 接口地址 / API Key / 模型名三项都要填';
return;
}
box.className = 'pi-test';
box.textContent = '⏳ 正在请求 ' + url + ' ...';
const r = await testAIConnection(url, key, model, providerKey);
box.className = 'pi-test ' + (r.ok ? 'ok' : 'err');
box.textContent = (r.ok ? '✅ ' : '❌ ') + r.message;
log((r.ok ? '✅ AI 连接测试通过: ' : '❌ AI 连接测试失败: ') + r.message, r.ok ? 'ok' : 'err');
if (r.ok) {
// 测通即落配置并启用,免去「测完忘了点保存」
CONFIG.aiUrl = url; CONFIG.aiKey = key; CONFIG.aiModel = r.model || model;
CONFIG.aiProvider = providerKey; CONFIG.aiEnabled = true;
document.getElementById('cfgAI').checked = true;
if (r.model && r.model !== model) document.getElementById('cfgAIModel').value = r.model;
saveConfig(CONFIG);
resetAIChannel();
log('💾 已自动保存并启用 AI 答题,现在可以直接开始挂机', 'ok');
}
});
}
/* ==================== 答案通道 ==================== */
// 免费题库站(协议参考社区成熟脚本,无 token 时部分接口仍返回免费额度答案)
async function channelTikuHai(q) {
try {
const res = JSON.parse(await cxFetch('http://api.tikuhai.com/search', {
method: 'POST',
data: JSON.stringify({ question: q.question, type: q.type }),
headers: { 'Content-Type': 'application/json' }
}));
if (res.code === -1) return { form: '题库海', answer: String(res.msg || '').split('#') };
const a = (res.data && res.data.answer) || res.msg || '';
return { form: '题库海', answer: String(a).split('#') };
} catch (e) { return { form: '题库海', answer: [] }; }
}
async function channelYizhi(q) {
try {
// 不再伪造 X-Forwarded-For/X-Real-IP 绕过限流(易触发风控且不规范),按原始请求发送
const res = JSON.parse(await cxFetch('http://cx.icodef.com/wyn-nb?v=4', {
method: 'POST',
data: JSON.stringify({ question: q.question }),
headers: { 'Content-Type': 'application/json' }
}));
if (res.code !== 1) return { form: '一之题库', answer: [] };
let data = String(res.data || '').replace(/javascript:void\(0\);/g, '').replace(/\n/g, '').trim();
if (/(叛逆|公众号|李恒雅|一之)/.test(data)) return { form: '一之题库', answer: [] };
return { form: '一之题库', answer: data.split('#') };
} catch (e) { return { form: '一之题库', answer: [] }; }
}
async function channelYanxi(q) {
try {
// 官方协议是 GET + query 参数(POST + JSON 会直接 404/参数丢失),已修正
const res = JSON.parse(await cxFetch('https://tk.enncy.cn/query?title=' + encodeURIComponent(q.question), {
method: 'GET',
headers: {}
}));
if (res.code !== 1) return { form: '言溪题库', answer: [] };
return { form: '言溪题库', answer: String(res.data.answer || '').split('#') };
} catch (e) { return { form: '言溪题库', answer: [] }; }
}
async function channelMuketool(q) {
try {
const res = JSON.parse(await cxFetch('https://api.muketool.com/cx/v2/query', {
method: 'POST',
data: JSON.stringify({ question: q.question, type: parseInt(q.type, 10) || 0 }),
headers: { 'Content-Type': 'application/json' }
}));
if (res.code !== 1) return { form: '木课工具', answer: [] };
return { form: '木课工具', answer: String(res.data || '').split('#') };
} catch (e) { return { form: '木课工具', answer: [] }; }
}
/* 本地自建题库(零成本、零延迟、优先级最高):
数据源 = 脚本自动积累的做过的题 + ⚙ 里手动导入的题库 JSON */
function normQ(s) { return String(s || '').replace(/\s+/g, '').toLowerCase(); }
function channelLocal(q) {
try {
// 题干同时用「解码后的明文」和「页面原始码点」匹配:
// 历史题库里混有旧版写回页面时攒下的半明文/生僻字记录,双 key 才能命中。
const keys = [normQ(q.question), normQ(q.rawQuestion)]
.filter((k, i, a) => k && a.indexOf(k) === i);
if (!keys.length || keys[0].length < 4) return { form: '本地题库', answer: [] };
let hit = null, bestC = -1;
for (const it of COLLECTED) {
if (!it.a) continue; // 跳过没答案的历史记录
const n = normQ(it.q);
const matched = keys.some((key) => n === key || (n.length >= 8 && (n.includes(key) || key.includes(n))));
if (matched) {
const c = Number(it.c == null ? 1 : it.c);
if (Number.isFinite(c) && c > bestC) { hit = it; bestC = c; }
}
}
if (hit) {
const ans = String(hit.a).split('|').filter(Boolean);
if (ans.length) return { form: '本地题库', answer: ans, confidence: bestC,
verified: hit.src === 'verified' || hit.src === 'import' };
}
} catch (e) { /* ignore */ }
return { form: '本地题库', answer: [], confidence: 0 };
}
/* 必应实时搜索兜底(免费):把题干拿到必应搜,从结果摘要里按「选项文本命中」推断答案。
启发式,准确率有限;不用百度是因为百度反爬严(验证码/乱码壳页),必应摘要可直接解析 */
async function channelWebSearch(q) {
try {
const url = 'https://cn.bing.com/search?q=' + encodeURIComponent(q.question.slice(0, 80) + ' 答案');
const html = await cxFetch(url, { method: 'GET', headers: {}, timeout: 12000 });
const text = String(html)
.replace(/