|
|
@@ -1,6 +1,6 @@
|
|
|
/*! tiktok-auto v1.0.0
|
|
|
- * built 2026-10-28T10:49:20.750Z
|
|
|
- * modules: logger, bridge, config, wait, layout, ui, popups, tiktok, player, comment, interact, flow, parse, uidset, filters, profile, idsource, resolve, idflow, main
|
|
|
+ * built 2026-10-28T14:42:55.685Z
|
|
|
+ * modules: logger, bridge, config, wait, layout, ui, popups, tiktok, player, comment, interact, flow, parse, uidset, fingerprint, checkpoint, filters, profile, idsource, resolve, idflow, main
|
|
|
* 由 tools/build.js 自动生成 —— 请不要直接编辑本文件，改 src/ 后重新构建。
|
|
|
*/
|
|
|
(function () {
|
|
|
@@ -4652,6 +4652,589 @@ TikTokAuto.uidset = (function () {
|
|
|
}());
|
|
|
|
|
|
|
|
|
+/* ============================== src/fingerprint.js ============================== */
|
|
|
+/**
|
|
|
+ * fingerprint.js — 配置指纹（判断"断点还有效吗"）
|
|
|
+ *
|
|
|
+ * ## 为什么要它
|
|
|
+ * 断点续跑的前提是"配置没变过"。取材换了关键词、过滤条件调了门槛，
|
|
|
+ * 上次"已完成"的判定就不再成立 —— 接着跑会得到口径不一致的数据，而用户看不出来。
|
|
|
+ *
|
|
|
+ * ## 为什么不用 hash 库
|
|
|
+ * 项目里没有任何现成的 hash / 稳定序列化工具，而 AutoX 环境里能用的
|
|
|
+ * 也就 Rhino 那点东西（没有 `Math.imul`、没有 ES6 Map/Set 的稳定行为）。
|
|
|
+ * 所以自己写两个小函数：**稳定序列化 + djb2**。
|
|
|
+ *
|
|
|
+ * ## 覆盖哪些字段（这是设计决策，不是随手挑的）
|
|
|
+ *
|
|
|
+ * | 覆盖 | 为什么 |
|
|
|
+ * |---|---|
|
|
|
+ * | `sources[]` 的全部取值字段（**顺序敏感**） | 换账号/关键词/深度/删条目都改变"取哪些人" |
|
|
|
+ * | `filter` 的 private/noAvatar/langRegion/nicknameCheck/follow/fans/likes | 直接决定谁被拦掉 |
|
|
|
+ * | `output` 的 dir/historyPath/dedupeHistory | dir 决定产物位置；后两个决定 `seen` 的初始内容 |
|
|
|
+ *
|
|
|
+ * | 不覆盖 | 为什么 |
|
|
|
+ * |---|---|
|
|
|
+ * | `output.limit` | 约束"跑多少个"而不是"取哪些人"；续跑仍按累计数生效 |
|
|
|
+ * | `output.resolveUid` | 只影响收尾是否多产一份映射文件 |
|
|
|
+ * | `output.dryRun` | 演练不写产物，**调用方直接禁续跑**，不必进指纹 |
|
|
|
+ * | `filter.videos` | `filters.judge` 只对它出 soft 提示，不参与判定 |
|
|
|
+ * | `guard.*` / `timeouts` / `probe` / `runtime` | 与"取哪些人"无关 |
|
|
|
+ *
|
|
|
+ * ## ★ 这个文件在界面侧有一份逐字节相同的实现
|
|
|
+ * `tiktok-app/src/fingerprint.js`。**改这里必须同步改那边**，
|
|
|
+ * 否则两侧算出的指纹不同 → 界面说"可以续跑"、引擎说"配置变了"。
|
|
|
+ * `tools/pc-selftest-id.js` 里有一组断言专门比对两份实现的结果。
|
|
|
+ */
|
|
|
+TikTokAuto.fingerprint = (function () {
|
|
|
+ 'use strict';
|
|
|
+
|
|
|
+ var VERSION = 1;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 是不是数组。
|
|
|
+ *
|
|
|
+ * 不用 `v instanceof Array`：跨 realm（PC 自检把 Node 造的对象喂进 vm 沙箱）时
|
|
|
+ * `instanceof` 会返回 false，那会让"数组"被当成普通对象序列化，两边算出的指纹就不一样了。
|
|
|
+ *
|
|
|
+ * 也不用 `toString` 配 `Function.prototype.call` 的写法：那个关键字加左括号
|
|
|
+ * 命中 MCP 危险调用黑名单（`tools/build.js` 的 `DANGEROUS_RULES`），会让每次下发都要人工确认。
|
|
|
+ * 优先 `Array.isArray`（ES5，AutoX 的 Rhino 支持），没有时退回 `.apply`。
|
|
|
+ */
|
|
|
+ function isArray(v) {
|
|
|
+ if (typeof Array.isArray === 'function') {
|
|
|
+ return Array.isArray(v);
|
|
|
+ }
|
|
|
+ return Object.prototype.toString.apply(v, []) === '[object Array]';
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 自有键，排序后返回（键序无关 → 同一份配置换个键序不会让断点失效） */
|
|
|
+ function ownKeys(v) {
|
|
|
+ var keys = [];
|
|
|
+ for (var k in v) {
|
|
|
+ if (Object.prototype.hasOwnProperty.apply(v, [k]) === true) {
|
|
|
+ keys.push(k);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ keys.sort();
|
|
|
+ return keys;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 稳定序列化：对象按键名排序、数组保持顺序、每个值带类型前缀。
|
|
|
+ *
|
|
|
+ * 类型前缀是必须的 —— 否则 `"1"`（字符串）和 `1`（数字）会序列化成同一个串，
|
|
|
+ * 而界面上"粉丝下限"这类字段确实可能一个是空串一个是 0。
|
|
|
+ */
|
|
|
+ function canon(v) {
|
|
|
+ if (v === null || v === undefined) {
|
|
|
+ return 'n';
|
|
|
+ }
|
|
|
+ if (isArray(v)) {
|
|
|
+ var parts = [];
|
|
|
+ for (var i = 0; i < v.length; i += 1) {
|
|
|
+ parts.push(canon(v[i]));
|
|
|
+ }
|
|
|
+ return '[' + parts.join(',') + ']';
|
|
|
+ }
|
|
|
+ if (typeof v === 'object') {
|
|
|
+ var keys = ownKeys(v);
|
|
|
+ var out = [];
|
|
|
+ for (var j = 0; j < keys.length; j += 1) {
|
|
|
+ out.push(keys[j] + ':' + canon(v[keys[j]]));
|
|
|
+ }
|
|
|
+ return '{' + out.join(',') + '}';
|
|
|
+ }
|
|
|
+ if (typeof v === 'number') {
|
|
|
+ return 'd' + String(v);
|
|
|
+ }
|
|
|
+ if (typeof v === 'boolean') {
|
|
|
+ return v ? 'T' : 'F';
|
|
|
+ }
|
|
|
+ return 's' + JSON.stringify(String(v));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * djb2-xor 摘要。
|
|
|
+ *
|
|
|
+ * 末尾拼上原文长度：32 位散列碰撞概率本来就不高，加个长度等于多一维区分，
|
|
|
+ * 而且是"免费"的（长度本来就要算）。输出是 base36，比十六进制短。
|
|
|
+ */
|
|
|
+ function digest(text) {
|
|
|
+ var s = String(text);
|
|
|
+ var h = 5381;
|
|
|
+ for (var i = 0; i < s.length; i += 1) {
|
|
|
+ h = (((h << 5) + h) ^ s.charCodeAt(i)) | 0; /* |0 截成 32 位，避免精度丢失 */
|
|
|
+ }
|
|
|
+ return (h >>> 0).toString(36) + '-' + s.length.toString(36);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 把一条取材归一化成"只含参与指纹的字段"，缺项补默认 */
|
|
|
+ function ofSource(one, index) {
|
|
|
+ var s = one || {};
|
|
|
+ return {
|
|
|
+ key: s.key || ('i' + index + ':' + (s.kind || '')),
|
|
|
+ kind: s.kind || '',
|
|
|
+ anchors: s.anchors || '',
|
|
|
+ lists: isArray(s.lists) ? s.lists : [],
|
|
|
+ searchType: s.searchType || '',
|
|
|
+ keyword: s.keyword || '',
|
|
|
+ videoSource: s.videoSource || '',
|
|
|
+ videoKeyword: s.videoKeyword || '',
|
|
|
+ path: s.path || '',
|
|
|
+ expand: s.expand || ''
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 算 `id` 段的指纹。
|
|
|
+ *
|
|
|
+ * **分项存**（sources / filter / output 各一份）而不只存一个总串：
|
|
|
+ * 界面要能说清"是**取材**改过了"而不是含糊的"配置变了"，用户才知道该改回去什么。
|
|
|
+ *
|
|
|
+ * @param id `config.id` 整段（界面传 `Engine.buildIdConfig().config.id`，
|
|
|
+ * 引擎传解析后的 `config.id` —— 两者是同一份数据）
|
|
|
+ */
|
|
|
+ function ofIdSection(id) {
|
|
|
+ var section = id || {};
|
|
|
+
|
|
|
+ var list = isArray(section.sources) ? section.sources : [];
|
|
|
+ var sources = [];
|
|
|
+ for (var i = 0; i < list.length; i += 1) {
|
|
|
+ sources.push(ofSource(list[i], i));
|
|
|
+ }
|
|
|
+
|
|
|
+ var f = section.filter || {};
|
|
|
+ var o = section.output || {};
|
|
|
+
|
|
|
+ var sourcesHash = digest(canon(sources));
|
|
|
+ var filterHash = digest(canon({
|
|
|
+ private: f.private === true,
|
|
|
+ noAvatar: f.noAvatar === true,
|
|
|
+ langRegion: f.langRegion || 'any',
|
|
|
+ nicknameCheck: f.nicknameCheck || 'any',
|
|
|
+ follow: f.follow || {},
|
|
|
+ fans: f.fans || {},
|
|
|
+ likes: f.likes || {}
|
|
|
+ }));
|
|
|
+ var outputHash = digest(canon({
|
|
|
+ dir: o.dir || '',
|
|
|
+ historyPath: o.historyPath || '',
|
|
|
+ dedupeHistory: o.dedupeHistory !== false
|
|
|
+ }));
|
|
|
+
|
|
|
+ return {
|
|
|
+ v: VERSION,
|
|
|
+ sources: sourcesHash,
|
|
|
+ filter: filterHash,
|
|
|
+ output: outputHash,
|
|
|
+ all: digest(sourcesHash + filterHash + outputHash)
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 比两份指纹。
|
|
|
+ * @returns { same, changed: ['sources'|'filter'|'output'] }
|
|
|
+ */
|
|
|
+ function compare(a, b) {
|
|
|
+ if (!a || !b || a.v !== VERSION || b.v !== VERSION) {
|
|
|
+ return { same: false, changed: ['sources', 'filter', 'output'] };
|
|
|
+ }
|
|
|
+ var changed = [];
|
|
|
+ if (a.sources !== b.sources) {
|
|
|
+ changed.push('sources');
|
|
|
+ }
|
|
|
+ if (a.filter !== b.filter) {
|
|
|
+ changed.push('filter');
|
|
|
+ }
|
|
|
+ if (a.output !== b.output) {
|
|
|
+ changed.push('output');
|
|
|
+ }
|
|
|
+ return { same: changed.length === 0, changed: changed };
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ VERSION: VERSION,
|
|
|
+ canon: canon,
|
|
|
+ digest: digest,
|
|
|
+ ofIdSection: ofIdSection,
|
|
|
+ compare: compare
|
|
|
+ };
|
|
|
+}());
|
|
|
+
|
|
|
+
|
|
|
+/* ============================== src/checkpoint.js ============================== */
|
|
|
+/**
|
|
|
+ * checkpoint.js — ID 提取的断点（"跑到哪了"的唯一真相）
|
|
|
+ *
|
|
|
+ * ## 粒度：取材条目级，不是屏/行级
|
|
|
+ *
|
|
|
+ * TikTok 的列表内容会变、滚动位置无法复原。记"第几屏第几行"只会造成
|
|
|
+ * 漏掉别人或重复劳动；而「哪条取材已经走完」是稳定事实。
|
|
|
+ * 所以：**跳过已完成的取材；未完成的那条从头重走，靠已收集合跳人**。
|
|
|
+ *
|
|
|
+ * ## 文件
|
|
|
+ * `<id.output.dir>/id_progress.json`，与产物同目录（用户清产物时看得见）。
|
|
|
+ * 全局只保留一份（全局单跑，多份会让"哪份有效"变成判断题）。
|
|
|
+ *
|
|
|
+ * ## 几条硬约束（都踩过或差点踩）
|
|
|
+ *
|
|
|
+ * 1. **只能覆盖写，不能删文件** —— `files.remove` 命中 MCP 危险调用黑名单
|
|
|
+ * （见 `tools/build.js` 的 `DANGEROUS_RULES` 与 `uidset.js` 文件头）。
|
|
|
+ * 「清空断点」= 覆盖写成 `state:"none"`。
|
|
|
+ * 2. **read 必须容错** —— 写到一半被杀会留下半截 JSON。读不懂就当"没有断点"，
|
|
|
+ * 绝不抛异常：产物还在，丢的只是"能不能接着跑"。
|
|
|
+ * 3. **不存已收 uid 列表** —— 结果文件本身就是那份清单，重复存只会出现两份不一致。
|
|
|
+ * 4. **写盘不追每一条 uid** —— 粒度是取材条目级，每收 1 个就写只换来"少重走 19 个人"。
|
|
|
+ * 节奏是：取材边界 + 每 20 个（与产物刷盘同拍）+ 收尾。
|
|
|
+ *
|
|
|
+ * 依赖：TikTokAuto.logger、TikTokAuto.fingerprint（仅 compare 用）
|
|
|
+ */
|
|
|
+TikTokAuto.checkpoint = (function () {
|
|
|
+ 'use strict';
|
|
|
+
|
|
|
+ /** 文件名固定：不放用户配置里，避免"换个名字就找不到断点" */
|
|
|
+ var DEFAULT_NAME = 'id_progress.json';
|
|
|
+ var VERSION = 1;
|
|
|
+
|
|
|
+ function logger() { return TikTokAuto.logger; }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 是不是数组。优先 `Array.isArray`；退回用 `.apply` 而不是 `Function.prototype.call`
|
|
|
+ * —— 后者那个关键字加左括号会命中 MCP 危险调用黑名单（见 `tools/build.js`）。
|
|
|
+ */
|
|
|
+ function isArray(v) {
|
|
|
+ if (typeof Array.isArray === 'function') {
|
|
|
+ return Array.isArray(v);
|
|
|
+ }
|
|
|
+ return Object.prototype.toString.apply(v, []) === '[object Array]';
|
|
|
+ }
|
|
|
+
|
|
|
+ function dirOf(path) {
|
|
|
+ var s = String(path || '');
|
|
|
+ var i = s.lastIndexOf('/');
|
|
|
+ return i > 0 ? s.substring(0, i + 1) : '';
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 断点文件路径（由结果目录派生） */
|
|
|
+ function pathOf(output) {
|
|
|
+ var dir = (output && output.dir) || '/sdcard/Download/tiktok_app';
|
|
|
+ return dir + '/' + DEFAULT_NAME;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 新建一份断点。
|
|
|
+ *
|
|
|
+ * @param runId 当前这次运行（界面靠它把记录与断点精确对上）
|
|
|
+ * @param sig 指纹（`fingerprint.ofIdSection(config.id)`）
|
|
|
+ * @param runFile 结果文件绝对路径（续跑时复用它，不新开文件）
|
|
|
+ * @param sources `[{key, kind, label}]`，顺序与 config.id.sources 一致
|
|
|
+ */
|
|
|
+ function empty(runId, sig, runFile, sources) {
|
|
|
+ var list = [];
|
|
|
+ for (var i = 0; i < (sources || []).length; i += 1) {
|
|
|
+ var s = sources[i] || {};
|
|
|
+ list.push({
|
|
|
+ key: s.key || ('i' + i + ':' + (s.kind || '')),
|
|
|
+ kind: s.kind || '',
|
|
|
+ label: s.label || '',
|
|
|
+ status: 'pending', /* pending | running | done */
|
|
|
+ screens: 0,
|
|
|
+ handled: 0,
|
|
|
+ added: 0
|
|
|
+ });
|
|
|
+ }
|
|
|
+ var now = Date.now();
|
|
|
+ return {
|
|
|
+ v: VERSION,
|
|
|
+ state: 'running', /* running | stopped | done | none */
|
|
|
+ runId: runId || '',
|
|
|
+ beganAt: now,
|
|
|
+ updatedAt: now,
|
|
|
+ sig: sig || null,
|
|
|
+ runFile: runFile || '',
|
|
|
+ mapFile: '',
|
|
|
+ limitBase: 0,
|
|
|
+ counts: { extracted: 0, skipped: 0, duplicates: 0, openedProfiles: 0 },
|
|
|
+ sources: list,
|
|
|
+ expand: { queue: [], done: [] }
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 读断点。**任何解析问题都返回 null**（当作没有断点），绝不抛 */
|
|
|
+ function read(path) {
|
|
|
+ try {
|
|
|
+ if (!path || !files.exists(path)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var text = String(files.read(path) || '');
|
|
|
+ if (text.replace(/\s/g, '') === '') {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cp = JSON.parse(text);
|
|
|
+ if (!cp || cp.v !== VERSION) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ /* 半截文件可能缺字段：补齐，别让调用方到处判空 */
|
|
|
+ if (!isArray(cp.sources)) {
|
|
|
+ cp.sources = [];
|
|
|
+ }
|
|
|
+ if (!cp.expand || typeof cp.expand !== 'object') {
|
|
|
+ cp.expand = { queue: [], done: [] };
|
|
|
+ }
|
|
|
+ if (!isArray(cp.expand.queue)) {
|
|
|
+ cp.expand.queue = [];
|
|
|
+ }
|
|
|
+ if (!isArray(cp.expand.done)) {
|
|
|
+ cp.expand.done = [];
|
|
|
+ }
|
|
|
+ return cp;
|
|
|
+ } catch (error) {
|
|
|
+ logger().warn('checkpoint', '断点文件读不懂（当作没有断点）：' + error);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 覆盖写整份断点。返回是否写成功（失败只记 warn，不影响主流程） */
|
|
|
+ function save(path, cp) {
|
|
|
+ if (!cp) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ var dir = dirOf(path);
|
|
|
+ if (dir) {
|
|
|
+ files.ensureDir(dir);
|
|
|
+ }
|
|
|
+ cp.updatedAt = Date.now();
|
|
|
+ files.write(path, JSON.stringify(cp));
|
|
|
+ return true;
|
|
|
+ } catch (error) {
|
|
|
+ logger().warn('checkpoint', '断点写盘失败（不影响已抓到的结果）：' + error);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 「清空断点」= 覆盖成空壳。**不删文件**（`files.remove` 是危险调用） */
|
|
|
+ function clearStub() {
|
|
|
+ return { v: VERSION, state: 'none', updatedAt: Date.now() };
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 指纹不符时给用户一句人话，说清是哪一段变了 */
|
|
|
+ function nameOf(key) {
|
|
|
+ if (key === 'sources') { return '取材'; }
|
|
|
+ if (key === 'filter') { return '过滤条件'; }
|
|
|
+ if (key === 'output') { return '输出设置（目录 / 跨轮去重）'; }
|
|
|
+ return key;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 能不能续跑？—— 顺序很重要，每一步的失败都要给可操作的话。
|
|
|
+ *
|
|
|
+ * 全部判定都在**启动 App 之前**做完：拒绝时零成本返回，不折腾用户手机。
|
|
|
+ *
|
|
|
+ * @param prev 上一次读到的断点（或 null）
|
|
|
+ * @param sig 当前配置指纹
|
|
|
+ * @param runFileExists 上次的结果文件还在不在
|
|
|
+ * @param opts { dryRun }
|
|
|
+ * @returns { mode:'resume'|'fresh'|'reject', reason, message, changed }
|
|
|
+ */
|
|
|
+ function planResume(prev, sig, runFileExists, opts) {
|
|
|
+ var options = opts || {};
|
|
|
+
|
|
|
+ if (!prev || prev.v !== VERSION || prev.state === 'none') {
|
|
|
+ return { mode: 'fresh', reason: 'no-checkpoint', message: '', changed: [] };
|
|
|
+ }
|
|
|
+ if (prev.state === 'done') {
|
|
|
+ return { mode: 'fresh', reason: 'last-complete', message: '', changed: [] };
|
|
|
+ }
|
|
|
+ if (options.dryRun) {
|
|
|
+ return {
|
|
|
+ mode: 'reject', reason: 'dry-run', changed: [],
|
|
|
+ message: '断点失效：演练模式不写产物，无法续跑'
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ var cmp = TikTokAuto.fingerprint.compare(prev.sig, sig);
|
|
|
+ if (!cmp.same) {
|
|
|
+ var names = [];
|
|
|
+ for (var i = 0; i < cmp.changed.length; i += 1) {
|
|
|
+ names.push(nameOf(cmp.changed[i]));
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ mode: 'reject', reason: 'config-changed', changed: cmp.changed,
|
|
|
+ message: '断点失效：' + names.join('、') + '已改动，只能重新开始'
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!runFileExists) {
|
|
|
+ return {
|
|
|
+ mode: 'reject', reason: 'run-file-missing', changed: [],
|
|
|
+ message: '断点失效：上次的结果文件已不存在（' + (prev.runFile || '') + '）'
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ return { mode: 'resume', reason: 'ok', message: '', changed: [] };
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ 取材条目 */
|
|
|
+
|
|
|
+ function findSource(cp, key) {
|
|
|
+ if (!cp || !isArray(cp.sources)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ for (var i = 0; i < cp.sources.length; i += 1) {
|
|
|
+ if (cp.sources[i].key === key) {
|
|
|
+ return cp.sources[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function sourceDone(cp, key) {
|
|
|
+ var one = findSource(cp, key);
|
|
|
+ return !!(one && one.status === 'done');
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 更新一条取材的状态。
|
|
|
+ * @param extra 可选 { screens, handled, added }
|
|
|
+ */
|
|
|
+ function markSource(cp, key, status, extra) {
|
|
|
+ var one = findSource(cp, key);
|
|
|
+ if (!one) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ one.status = status;
|
|
|
+ if (extra) {
|
|
|
+ if (extra.screens !== undefined) { one.screens = extra.screens; }
|
|
|
+ if (extra.handled !== undefined) { one.handled = extra.handled; }
|
|
|
+ if (extra.added !== undefined) { one.added = extra.added; }
|
|
|
+ }
|
|
|
+ return one;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 已完成 / 共几条（给界面写提示条用） */
|
|
|
+ function sourceProgress(cp) {
|
|
|
+ var done = 0;
|
|
|
+ var total = cp && isArray(cp.sources) ? cp.sources.length : 0;
|
|
|
+ for (var i = 0; i < total; i += 1) {
|
|
|
+ if (cp.sources[i].status === 'done') {
|
|
|
+ done += 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return { done: done, total: total };
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 上次停在哪儿（提示条上那句"停在「xxx」"） */
|
|
|
+ function stoppedAt(cp) {
|
|
|
+ if (!cp || !isArray(cp.sources)) {
|
|
|
+ return '';
|
|
|
+ }
|
|
|
+ for (var i = 0; i < cp.sources.length; i += 1) {
|
|
|
+ if (cp.sources[i].status !== 'done') {
|
|
|
+ return cp.sources[i].label || '';
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return '';
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ 深度展开 */
|
|
|
+
|
|
|
+ function expandKey(uid, which) {
|
|
|
+ return String(uid) + '|' + String(which);
|
|
|
+ }
|
|
|
+
|
|
|
+ function enqueueExpand(cp, uid, which) {
|
|
|
+ if (!cp || !uid) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ var key = expandKey(uid, which);
|
|
|
+ if (cp.expand.done.indexOf(key) >= 0) {
|
|
|
+ return false; /* 上次已经展开过，别重复排 */
|
|
|
+ }
|
|
|
+ for (var i = 0; i < cp.expand.queue.length; i += 1) {
|
|
|
+ if (expandKey(cp.expand.queue[i].uid, cp.expand.queue[i].which) === key) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ cp.expand.queue.push({ uid: String(uid), which: String(which) });
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ function expandDone(cp, uid, which) {
|
|
|
+ return !!cp && cp.expand && cp.expand.done.indexOf(expandKey(uid, which)) >= 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ function markExpandDone(cp, uid, which) {
|
|
|
+ if (!cp || !cp.expand) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ var key = expandKey(uid, which);
|
|
|
+ if (cp.expand.done.indexOf(key) < 0) {
|
|
|
+ cp.expand.done.push(key);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 这次还要展开谁。
|
|
|
+ *
|
|
|
+ * @param queue 本轮内存里攒的待展开项（`[{uid, which}]`，由 handleRow 边收边入队）
|
|
|
+ * @returns 过滤掉"上次已完成"之后的那部分
|
|
|
+ */
|
|
|
+ function pendingExpand(cp, queue) {
|
|
|
+ var out = [];
|
|
|
+ for (var i = 0; i < (queue || []).length; i += 1) {
|
|
|
+ var one = queue[i];
|
|
|
+ if (!expandDone(cp, one.uid, one.which)) {
|
|
|
+ out.push(one);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return out;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ------------------------------------------------------------ 收尾判定 */
|
|
|
+
|
|
|
+ /** 所有取材都 done，且展开队列里没有未完成的 → 这一轮真的做完了 */
|
|
|
+ function allDone(cp) {
|
|
|
+ if (!cp || !isArray(cp.sources) || cp.sources.length === 0) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ for (var i = 0; i < cp.sources.length; i += 1) {
|
|
|
+ if (cp.sources[i].status !== 'done') {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (var j = 0; j < cp.expand.queue.length; j += 1) {
|
|
|
+ if (!expandDone(cp, cp.expand.queue[j].uid, cp.expand.queue[j].which)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ DEFAULT_NAME: DEFAULT_NAME,
|
|
|
+ VERSION: VERSION,
|
|
|
+ pathOf: pathOf,
|
|
|
+ empty: empty,
|
|
|
+ read: read,
|
|
|
+ save: save,
|
|
|
+ clearStub: clearStub,
|
|
|
+ planResume: planResume,
|
|
|
+ nameOf: nameOf,
|
|
|
+ sourceDone: sourceDone,
|
|
|
+ markSource: markSource,
|
|
|
+ sourceProgress: sourceProgress,
|
|
|
+ stoppedAt: stoppedAt,
|
|
|
+ enqueueExpand: enqueueExpand,
|
|
|
+ expandDone: expandDone,
|
|
|
+ markExpandDone: markExpandDone,
|
|
|
+ pendingExpand: pendingExpand,
|
|
|
+ allDone: allDone
|
|
|
+ };
|
|
|
+}());
|
|
|
+
|
|
|
+
|
|
|
/* ============================== src/filters.js ============================== */
|
|
|
/**
|
|
|
* filters.js — 「只要这样的账号」的判定
|
|
|
@@ -5680,11 +6263,69 @@ TikTokAuto.idsource = (function () {
|
|
|
/** 翻一个列表最多翻多少屏。防止"永远有新内容"（推荐流）把一轮拖成无限长。 */
|
|
|
var MAX_SCREENS = 60;
|
|
|
|
|
|
- /** 连续这么多屏都没有新 uid 就认为到底了（有的列表末尾会重复推荐位） */
|
|
|
+ /**
|
|
|
+ * 连续这么多次"翻屏后内容不变"就认为到头了（有的列表末尾会重复推荐位）。
|
|
|
+ *
|
|
|
+ * ★ 注意判据是**翻不动**，不是"没有新 uid"（2026-10-28 修，见 walkStep 的注释）。
|
|
|
+ */
|
|
|
var IDLE_SCREENS_TO_STOP = 2;
|
|
|
|
|
|
function logger() { return TikTokAuto.logger; }
|
|
|
|
|
|
+ /**
|
|
|
+ * 一屏处理完之后决定下一步。纯函数，便于在 PC 上回归（`tools/pc-selftest-id.js`）。
|
|
|
+ *
|
|
|
+ * ★ 这里修的是一个**真 bug**（2026-10-28）。
|
|
|
+ *
|
|
|
+ * 旧实现有两个地方同时给 `idle` 加一：
|
|
|
+ * ① 本屏 `fresh` 为空（全是已收过的人）→ idle + 1
|
|
|
+ * ② 翻屏后签名不变 → idle + 1
|
|
|
+ * 而 `idflow` 会先把 `uid_extracted.txt` 预载进 `seen`。于是**第二轮跑同一个账号**时，
|
|
|
+ * 前两屏全是历史 → idle=2 → **在列表顶部就判"到底"**，一条新人都拿不到。
|
|
|
+ * 断点续跑要把上次的产物也预载进 `seen`，这个误判会从"偶发"变成"必然"。
|
|
|
+ *
|
|
|
+ * 正解：**只看"翻得动翻不动"**。一屏全是旧人说明"旧人多"，不代表列表到头；
|
|
|
+ * 只有"滚动之后签名没变"才是真的到头。
|
|
|
+ *
|
|
|
+ * @param state { screens, stuck }
|
|
|
+ * @param view { sigBefore, sigAfter, rowsAfter, maxScreens }
|
|
|
+ * @returns { action: 'continue'|'break', state, reason }
|
|
|
+ */
|
|
|
+ function walkStep(state, view) {
|
|
|
+ var stuck = state.stuck;
|
|
|
+ var screens = state.screens;
|
|
|
+
|
|
|
+ if (view.rowsAfter === 0) {
|
|
|
+ /* 翻完这一屏读不到行了：可能还在加载，也可能真的到头。
|
|
|
+ * 不在这里下结论 —— 交给下一轮循环开头的"空行即结束"处理
|
|
|
+ * （这样"加载慢"和"列表结束"两个判断只在一处）。 */
|
|
|
+ return { action: 'continue', reason: '', state: { screens: screens, stuck: stuck } };
|
|
|
+ }
|
|
|
+
|
|
|
+ if (view.sigAfter === view.sigBefore) {
|
|
|
+ stuck += 1;
|
|
|
+ if (stuck >= IDLE_SCREENS_TO_STOP) {
|
|
|
+ return {
|
|
|
+ action: 'break',
|
|
|
+ reason: '翻屏后内容不变，认为列表到底',
|
|
|
+ state: { screens: screens, stuck: stuck }
|
|
|
+ };
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ /* 内容变了 → 列表还在往下走。**不管这一屏里有没有新人**都归零。 */
|
|
|
+ stuck = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (screens >= view.maxScreens) {
|
|
|
+ return {
|
|
|
+ action: 'break',
|
|
|
+ reason: '达到单列表翻屏上限 ' + view.maxScreens + ' 屏',
|
|
|
+ state: { screens: screens, stuck: stuck }
|
|
|
+ };
|
|
|
+ }
|
|
|
+ return { action: 'continue', reason: '', state: { screens: screens, stuck: stuck } };
|
|
|
+ }
|
|
|
+
|
|
|
/** 一行 uid 的临时载体（列表行带昵称与计数，用户页带更多资料，统一成这个形状） */
|
|
|
function rowOf(uid, nickname, extra) {
|
|
|
var one = { uid: uid, nickname: nickname || '' };
|
|
|
@@ -5703,28 +6344,32 @@ TikTokAuto.idsource = (function () {
|
|
|
/**
|
|
|
* 在"一个可滚动的用户列表"上逐行推进。
|
|
|
*
|
|
|
- * 关键设计：**用 uid 集合判断进度，不用行下标**。
|
|
|
+ * 关键设计：**用 uid 集合决定"哪一行还要处理"，不用行下标**。
|
|
|
* 因为每次点进用户页再退回来，列表的节点树都重建过一遍（引用失效），
|
|
|
* 只有 uid 是稳的。
|
|
|
*
|
|
|
- * @param ctx { seen, onRow(row), shouldStop() }
|
|
|
- * @returns 处理了多少行
|
|
|
+ * 但**停止判据不能用 uid 集合** —— 那会把"全是旧人"误判成"列表到底"（见 walkStep）。
|
|
|
+ *
|
|
|
+ * @param ctx { seen, onRow(row), shouldStop(), maxScreens?, stat?, config? }
|
|
|
+ * maxScreens：本次最多翻多少屏（续跑时按上次已翻的屏数放大，见 idflow）
|
|
|
+ * stat：传入则回填 { screens, handled }，供断点记录
|
|
|
+ * @returns 处理了多少行（本屏新收的）
|
|
|
*/
|
|
|
function walkList(ctx) {
|
|
|
var log = logger();
|
|
|
var handled = 0;
|
|
|
- var idle = 0;
|
|
|
- var screens = 0;
|
|
|
+ var maxScreens = ctx.maxScreens || MAX_SCREENS;
|
|
|
+ var state = { screens: 0, stuck: 0 };
|
|
|
|
|
|
- while (screens < MAX_SCREENS) {
|
|
|
+ while (state.screens < maxScreens) {
|
|
|
if (ctx.shouldStop()) {
|
|
|
log.info('idsource', '达到停止条件，结束当前列表');
|
|
|
break;
|
|
|
}
|
|
|
- screens += 1;
|
|
|
+ state.screens += 1;
|
|
|
|
|
|
var rows = TikTokAuto.profile.listRows();
|
|
|
- if (rows.length === 0 && screens === 1) {
|
|
|
+ if (rows.length === 0 && state.screens === 1) {
|
|
|
/* 首屏还在加载。**等一次**再判定，否则会把"慢"当成"空"：
|
|
|
* 从用户页点开粉丝列表、或从结果页切到用户页签后，
|
|
|
* 容器先出来、行后出来（实测差 1~2 秒），这时 listRows() 返回空数组 ——
|
|
|
@@ -5739,45 +6384,47 @@ TikTokAuto.idsource = (function () {
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
- var fresh = [];
|
|
|
+ /* 一行一行处理：只处理没见过的人（见过的直接跳过，但**不因此判定列表到底**）。
|
|
|
+ * 需要资料时会点进用户页再退回（实测位置保持）。 */
|
|
|
+ var stopped = false;
|
|
|
for (var i = 0; i < rows.length; i += 1) {
|
|
|
- if (!ctx.seen.has(rows[i].uid)) {
|
|
|
- fresh.push(rows[i]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (fresh.length === 0) {
|
|
|
- idle += 1;
|
|
|
- if (idle >= IDLE_SCREENS_TO_STOP) {
|
|
|
- log.info('idsource', '连续 ' + idle + ' 屏没有新 uid，认为列表到底');
|
|
|
+ if (ctx.shouldStop()) {
|
|
|
+ stopped = true;
|
|
|
break;
|
|
|
}
|
|
|
- } else {
|
|
|
- idle = 0;
|
|
|
- }
|
|
|
-
|
|
|
- /* 一行一行处理：需要资料时会点进用户页再退回（实测位置保持） */
|
|
|
- for (var j = 0; j < fresh.length; j += 1) {
|
|
|
- if (ctx.shouldStop()) {
|
|
|
- return handled;
|
|
|
+ if (ctx.seen.has(rows[i].uid)) {
|
|
|
+ continue;
|
|
|
}
|
|
|
- ctx.onRow(fresh[j]);
|
|
|
- ctx.seen.add(fresh[j].uid); /* 处理过就算见过，避免同一行被反复点开 */
|
|
|
+ ctx.onRow(rows[i]);
|
|
|
+ ctx.seen.add(rows[i].uid); /* 处理过就算见过，避免同一行被反复点开 */
|
|
|
handled += 1;
|
|
|
}
|
|
|
+ if (stopped) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
|
|
|
- /* 翻一屏再看有没有新的 */
|
|
|
+ /* 翻一屏，用"内容有没有变"判断是否到头 */
|
|
|
var before = signatureOfRows(rows);
|
|
|
TikTokAuto.profile.scrollList();
|
|
|
- var after = signatureOfRows(TikTokAuto.profile.listRows());
|
|
|
- if (after === before) {
|
|
|
- idle += 1;
|
|
|
- if (idle >= IDLE_SCREENS_TO_STOP) {
|
|
|
- log.info('idsource', '翻屏后内容不变，认为列表到底');
|
|
|
- break;
|
|
|
- }
|
|
|
+ var afterRows = TikTokAuto.profile.listRows();
|
|
|
+
|
|
|
+ var step = walkStep(state, {
|
|
|
+ sigBefore: before,
|
|
|
+ sigAfter: signatureOfRows(afterRows),
|
|
|
+ rowsAfter: afterRows.length,
|
|
|
+ maxScreens: maxScreens
|
|
|
+ });
|
|
|
+ state = step.state;
|
|
|
+ if (step.action === 'break') {
|
|
|
+ log.info('idsource', step.reason);
|
|
|
+ break;
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
+ if (ctx.stat) {
|
|
|
+ ctx.stat.screens = state.screens;
|
|
|
+ ctx.stat.handled = handled;
|
|
|
+ }
|
|
|
return handled;
|
|
|
}
|
|
|
|
|
|
@@ -6220,8 +6867,12 @@ TikTokAuto.idsource = (function () {
|
|
|
|
|
|
return {
|
|
|
MAX_SCREENS: MAX_SCREENS,
|
|
|
+ IDLE_SCREENS_TO_STOP: IDLE_SCREENS_TO_STOP,
|
|
|
run: run,
|
|
|
walkList: walkList,
|
|
|
+ /* 纯函数，供 PC 回归（`tools/pc-selftest-id.js`）——
|
|
|
+ * 停止判据是"翻不动了"而不是"没有新人"，这条必须能被离线断言。 */
|
|
|
+ walkStep: walkStep,
|
|
|
readTextSource: readTextSource,
|
|
|
describe: describe
|
|
|
};
|
梦境