tiktok-scripts/tiktok-auto/tools/pc-selftest-id.js

/**
 * pc-selftest-id.js — 在 PC 上验证 ID 提取的纯函数（不碰设备）
 *
 * 为什么单独一份：设备的自检要过 MCP 下发，一轮几十秒；而 parse/filters
 * 是**零依赖纯函数**，拼起来就能在 PC 上跑。先用它把逻辑验对，
 * 再上设备验"真机环境里也没问题"，两步分开，排查时能立刻区分是逻辑错还是环境错。
 *
 * 用法：node tools/pc-selftest-id.js
 */
'use strict';

const fs = require('fs');
const path = require('path');
const vm = require('vm');

const SRC = path.join(__dirname, '..', 'src');

/* 只拼纯函数模块 —— 它们不引用 files/device/sleep 这些 AutoX 全局 */
const MODULES = ['parse', 'filters', 'uidset', 'fingerprint', 'checkpoint', 'idsource'];

const sandbox = {
    console: console,
    Date: Date, Math: Math, JSON: JSON,
    String: String, Number: Number, Object: Object,
    Array: Array, RegExp: RegExp, isNaN: isNaN, parseInt: parseInt,
    TikTokAuto: {}
};
/* uidset 与 filters 在函数体内取 logger / files，这里给最小桩。
 * files 用内存实现：断点读写的往返测试要靠它。 */
sandbox.TikTokAuto.logger = {
    info: () => { }, warn: () => { }, error: () => { }, step: () => { }
};
const memFiles = {};
sandbox.files = {
    exists: (p) => Object.prototype.hasOwnProperty.call(memFiles, p),
    read: (p) => (memFiles[p] === undefined ? '' : memFiles[p]),
    write: (p, content) => { memFiles[p] = String(content); },
    append: (p, content) => { memFiles[p] = (memFiles[p] || '') + String(content); },
    ensureDir: () => true
};

vm.createContext(sandbox);

let source = 'var TikTokAuto = this.TikTokAuto;\n';
for (const name of MODULES) {
    source += fs.readFileSync(path.join(SRC, `${name}.js`), 'utf8') + '\n';
}
vm.runInContext(source, sandbox);

const parse = sandbox.TikTokAuto.parse;
const filters = sandbox.TikTokAuto.filters;
const uidset = sandbox.TikTokAuto.uidset;
const fingerprint = sandbox.TikTokAuto.fingerprint;
const checkpoint = sandbox.TikTokAuto.checkpoint;
const idsource = sandbox.TikTokAuto.idsource;

let pass = 0;
let fail = 0;

function check(name, condition, detail) {
    if (condition === true) {
        pass += 1;
        return;
    }
    fail += 1;
    console.log('FAIL ' + name + (detail === undefined ? '' : '  → ' + detail));
}

/* ---------------------------------------------------------- 计数解析 */
const CASES = [
    ['594', 594], ['2,491', 2491], ['1.6M', 1600000], ['253.9M', 253900000],
    ['245K', 245000], ['371.7K', 371700], ['1.2万', 12000], ['1.5亿', 150000000],
    ['1.6M followers', 1600000], ['594 followers · 2.5K likes', 594],
    ['0', 0], ['12.3K', 12300], ['1,234', 1234], ['100万', 1000000]
];
for (const [input, want] of CASES) {
    const got = parse.count(input);
    check(`parseCount("${input}") = ${want}`, got === want, `实际 ${got}`);
}
check('parseCount 空串 → null', parse.count('') === null);
check('parseCount 非数字 → null', parse.count('abc') === null);
check('parseCount 全角数字 "１.２万"', parse.count('１.２万') === 12000, String(parse.count('１.２万')));

/* ---------------------------------------------------------- 语言 */
check('中文 → zh', parse.language('小美爱穿搭') === 'zh');
check('英文 → en', parse.language('Fashion Girl') === 'en');
check('中文混英文 → zh', parse.language('小美的Fashion') === 'zh', parse.language('小美的Fashion'));
check('英文混一个字 → en', parse.language('Fashion Girl 小') === 'en', parse.language('Fashion Girl 小'));
check('纯 emoji → none', parse.language('🥷🏿💗✨') === 'none');
check('阿拉伯文 → none（没有中英线索）', parse.language('عايشه حسين') === 'none', parse.language('عايشه حسين'));
check('zh 不放行 en', parse.languageMatches('zh', 'en') === false);
check('en 不放行 zh', parse.languageMatches('en', 'zh') === false);
check('any 全放行', parse.languageMatches('any', 'en') === true && parse.languageMatches('any', 'none') === true);

/* ---------------------------------------------------------- 区间 */
check('未设区间 → 无脑通过', parse.inRange(null, 0, 0) === true);
check('值在内', parse.inRange(500, 100, 1000) === true);
check('值在下限外', parse.inRange(50, 100, 1000) === false);
check('上限 0 = 不设限', parse.inRange(999999, 100, 0) === true);
check('只设上限', parse.inRange(500, 0, 1000) === true && parse.inRange(5000, 0, 1000) === false);
check('设了区间但值为 null → 拦', parse.inRange(null, 100, 1000) === false);
check('isRangeOpen 双向为 0 才算空', parse.isRangeOpen(0, 0) === true && parse.isRangeOpen(1, 0) === false);

/* ---------------------------------------------------------- 用户名 */
check('剥 @', parse.username('@abc') === 'abc');
check('剥 FID 隔离符', parse.username('\u2068ajman_fashion_week\u2069') === 'ajman_fashion_week',
    JSON.stringify(parse.username('\u2068ajman_fashion_week\u2069')));
check('合法用户名', parse.looksLikeUsername('user3670597276145') === true);
check('带点的用户名', parse.looksLikeUsername('mukhawar.shop') === true);
check('文案不是用户名', parse.looksLikeUsername('This is a caption') === false);
check('过长不是用户名', parse.looksLikeUsername('a'.repeat(31)) === false);

/* ---------------------------------------------------------- 去重集合 */
const set = uidset.create();
check('首次 add → true', set.add('a') === true);
check('重复 add → false', set.add('a') === false);
check('size 只算唯一值', set.size() === 1);
check('has 正确', set.has('a') === true && set.has('b') === false);

/* ---------------------------------------------------------- 过滤 */
check('无过滤全放行', filters.judge({ uid: 'x' }, {}).ok === true);
check('私密被拦', filters.judge({ uid: 'x', isPrivate: true }, { private: true }).ok === false);
check('公开放行', filters.judge({ uid: 'x', isPrivate: false }, { private: true }).ok === true);

check('仅中文 + 中文昵称', filters.judge({ uid: 'x', nickname: '小美' }, { langRegion: 'zh' }).ok === true);
check('仅中文 + 英文昵称被拦', filters.judge({ uid: 'x', nickname: 'Fashion' }, { langRegion: 'zh' }).ok === false);
check('仅中文 + 纯 emoji 被拦', filters.judge({ uid: 'x', nickname: '🥷🏿' }, { langRegion: 'zh' }).ok === false);
check('取样=个签：昵称英文但个签中文 → 放行',
    filters.judge({ uid: 'x', nickname: 'Fashion', signature: '小美' },
        { langRegion: 'zh', nicknameCheck: 'sign' }).ok === true);
check('取样=昵称：同上应当被拦',
    filters.judge({ uid: 'x', nickname: 'Fashion', signature: '小美' },
        { langRegion: 'zh', nicknameCheck: 'nick' }).ok === false);

check('粉丝达标', filters.judge({ uid: 'x', fans: 5940 }, { fans: { min: 1000, max: 0 } }).ok === true);
check('粉丝不足', filters.judge({ uid: 'x', fans: 594 }, { fans: { min: 1000, max: 0 } }).ok === false);
check('粉丝读不到 → 拦', filters.judge({ uid: 'x', fans: null }, { fans: { min: 1000, max: 0 } }).ok === false);
check('粉丝上界', filters.judge({ uid: 'x', fans: 99999 }, { fans: { min: 0, max: 10000 } }).ok === false);

const videoVerdict = filters.judge({ uid: 'x' }, { videos: { min: 10, max: 0 } });
check('视频量不拦人', videoVerdict.ok === true);
check('视频量要如实告知未生效', videoVerdict.soft.indexOf('视频量') >= 0, videoVerdict.soft);

check('无头像：默认剪影被拦', filters.judge({ uid: 'x', hasAvatar: false }, { noAvatar: true }).ok === false);
check('无头像：有头像放行', filters.judge({ uid: 'x', hasAvatar: true }, { noAvatar: true }).ok === true);
const noAvatarUnknown = filters.judge({ uid: 'x', hasAvatar: null }, { noAvatar: true });
check('无头像：判不了时放行', noAvatarUnknown.ok === true);
check('无头像：判不了要告知', noAvatarUnknown.soft.indexOf('无头像') >= 0, noAvatarUnknown.soft);

check('无过滤 → 不必开用户页', filters.needsProfile({}) === false);
check('只有视频量 → 不必开用户页', filters.needsProfile({ videos: { min: 10, max: 0 } }) === false);
check('有粉丝量 → 必须开', filters.needsProfile({ fans: { min: 10, max: 0 } }) === true);
check('有语言 → 必须开', filters.needsProfile({ langRegion: 'zh' }) === true);

/* 「读不到资料」必须拦下 —— 放行等于"打不开的人全都通过"，
 * 过滤看着在跑、实际放进一批没检查过的账号，比不过滤更糟。
 * 但快路径（本来不需要资料）仍然要放行。 */
check('需要资料但拿不到 → 拦下', filters.judge(null, { fans: { min: 1000, max: 0 } }).ok === false);
check('不需要资料且没有资料 → 放行（快路径）', filters.judge(null, {}).ok === true);

/* ---------------------------------------------------------- 列表遍历的停止判据 */
/*
 * 这里验的是 2026-10-28 修的那个真 bug：
 * 旧实现把"本屏没有新 uid"和"翻屏后内容不变"两件事都当成"到底了"，
 * 于是预载历史（跨轮去重）或预载上次产物（断点续跑）之后，
 * 前两屏全是旧人 → 在列表顶部就判定"列表到底"，一条新人都拿不到。
 *
 * 用一个可控的假列表驱动真正的 walkList，这样测的是生产代码而不是复述逻辑。
 */
function fakeProfile(pages) {
    let cursor = 0;
    sandbox.TikTokAuto.profile = {
        listRows: () => pages[Math.min(cursor, pages.length - 1)],
        scrollList: () => { cursor += 1; }
    };
}

/* ① 全部是旧人，但列表还在往下走 → 必须继续翻，不能判到底 */
const seenAll = uidset.create();
['a1', 'a2', 'b1', 'b2', 'c1', 'c2'].forEach((uid) => seenAll.add(uid));
fakeProfile([[{ uid: 'a1' }, { uid: 'a2' }],
             [{ uid: 'b1' }, { uid: 'b2' }],
             [{ uid: 'c1' }, { uid: 'c2' }],
             []]);
let stat = {};
let got = idsource.walkList({
    seen: seenAll, shouldStop: () => false, stat: stat,
    onRow: () => { throw new Error('全是旧人，不该处理任何一行'); }
});
check('全屏都是旧人 → 仍然继续往下翻（不判列表到底）',
      got === 0 && stat.screens >= 3, 'screens=' + stat.screens);
check('全屏都是旧人时不重复处理', got === 0, 'handled=' + got);

/* ② 翻不动了（每次读到的都是同一屏）→ 连续两次就停 */
fakeProfile([[{ uid: 'a1' }, { uid: 'a2' }]]);
stat = {};
idsource.walkList({
    seen: uidset.create(), shouldStop: () => false, stat: stat,
    onRow: () => { }
});
check('翻屏后内容不变 → 连续两次就判到底', stat.screens === 2, 'screens=' + stat.screens);

/* ③ 遇到新人要正常处理（回归：改动不能把"该收的人"也一起跳过） */
fakeProfile([[{ uid: 'n1' }, { uid: 'n2' }], []]);
const collected = [];
idsource.walkList({
    seen: uidset.create(), shouldStop: () => false,
    onRow: (row) => { collected.push(row.uid); }
});
check('新人照常处理', collected.join(',') === 'n1,n2', collected.join(','));

/* ④ maxScreens 是硬顶（续跑会按上次屏数放大它） */
fakeProfile([[{ uid: 'a1' }], [{ uid: 'a2' }], [{ uid: 'a3' }], [{ uid: 'a4' }], []]);
stat = {};
idsource.walkList({
    seen: uidset.create(), shouldStop: () => false, stat: stat, maxScreens: 2,
    onRow: () => { }
});
check('maxScreens 到顶就停', stat.screens === 2, 'screens=' + stat.screens);

/* ⑤ walkStep 纯函数：变 → 不变 → 变，stuck 必须归零 */
let step = idsource.walkStep({ screens: 1, stuck: 1 },
    { sigBefore: 'a', sigAfter: 'b', rowsAfter: 3, maxScreens: 60 });
check('内容变了就把 stuck 归零', step.action === 'continue' && step.state.stuck === 0, JSON.stringify(step));
step = idsource.walkStep({ screens: 1, stuck: 0 },
    { sigBefore: 'a', sigAfter: '', rowsAfter: 0, maxScreens: 60 });
check('翻完读不到行时不下结论（交给下一轮空行判定）', step.action === 'continue', JSON.stringify(step));

/* ---------------------------------------------------------- 配置指纹 */
/*
 * 指纹决定"断点还算不算数"。这里盯两件事：
 *   ① 该变的必须变（改了取材/过滤/输出目录 → 断点失效）
 *   ② 不该变的必须不变（改上限、时长、resolveUid → 不该让断点失效）
 * 第 ② 类最容易写错：多算一个字段，用户改个"至少运行几分钟"就白丢断点。
 */
const baseId = () => ({
    sources: [
        { key: 'src-a', kind: 'anchor', anchors: 'ajman#other', lists: ['fans'],
          expand: 'fans', searchType: '', keyword: '', videoSource: '', videoKeyword: '', path: '' },
        { key: 'src-b', kind: 'search', searchType: 'users', keyword: '小猫',
          anchors: '', lists: [], expand: '', videoSource: '', videoKeyword: '', path: '' }
    ],
    filter: { private: true, noAvatar: false, langRegion: 'any', nicknameCheck: 'any',
              follow: {}, fans: { min: 1000, max: 500000 }, likes: {}, videos: { min: 0, max: 500000 } },
    output: { dir: '/sdcard/Download/tiktok_app', historyPath: '/sdcard/Download/tiktok_app/uid_extracted.txt',
              dedupeHistory: true, dryRun: false, limit: 100, resolveUid: true },
    guard: { maxRuntimeMs: 1800000 }
});

const fpBase = fingerprint.ofIdSection(baseId());
check('指纹是四项（分项 + 总）',
      fpBase.v === 1 && !!fpBase.sources && !!fpBase.filter && !!fpBase.output && !!fpBase.all);

/* ① 不该变的：键序 */
const reordered = baseId();
const flipped = {};
Object.keys(reordered).reverse().forEach((k) => { flipped[k] = reordered[k]; });
check('换对象键序 → 指纹不变', fingerprint.compare(fpBase, fingerprint.ofIdSection(flipped)).same === true);

/* ② 不该变的：只改"跑多少/跑多久/是否解析 uid" */
[['limit', 999], ['resolveUid', false], ['dryRun', true]].forEach(([k, v]) => {
    const one = baseId();
    one.output[k] = v;
    check(`改 output.${k} → 断点仍然有效`, fingerprint.compare(fpBase, fingerprint.ofIdSection(one)).same === true);
});
check('改 guard.maxRuntimeMs → 断点仍然有效', fingerprint.compare(fpBase, fingerprint.ofIdSection(
    Object.assign(baseId(), { guard: { maxRuntimeMs: 60000 } }))).same === true);

/* ③ 不该变的：视频量门槛（filters.judge 只对它出 soft 提示，不参与判定） */
const videosChanged = baseId();
videosChanged.filter.videos = { min: 50, max: 999 };
check('改视频量门槛 → 断点仍然有效（它不参与过滤）',
      fingerprint.compare(fpBase, fingerprint.ofIdSection(videosChanged)).same === true);

/* ④ 该变的 */
const fansChanged = baseId();
fansChanged.filter.fans = { min: 500, max: 500000 };
check('改粉丝门槛 → 只有 filter 变', JSON.stringify(fingerprint.compare(fpBase, fingerprint.ofIdSection(fansChanged)).changed) === '["filter"]');

const dedupeChanged = baseId();
dedupeChanged.output.dedupeHistory = false;
check('关掉跨轮去重 → 只有 output 变',
      JSON.stringify(fingerprint.compare(fpBase, fingerprint.ofIdSection(dedupeChanged)).changed) === '["output"]');

const sourcesReordered = baseId();
sourcesReordered.sources = [baseId().sources[1], baseId().sources[0]];
check('取材顺序调换 → sources 变（顺序影响"先取到谁"）',
      fingerprint.compare(fpBase, fingerprint.ofIdSection(sourcesReordered)).changed.join(',') === 'sources');

const keywordChanged = baseId();
keywordChanged.sources[1].keyword = '小狗';
check('换关键词 → 断点失效', fingerprint.compare(fpBase, fingerprint.ofIdSection(keywordChanged)).same === false);

/* ⑤ 缺字段 / 空配置不能炸 */
check('空配置也能算出指纹', !!fingerprint.ofIdSection({}).all);
check('没 sources 时指纹稳定', fingerprint.ofIdSection({}).sources === fingerprint.ofIdSection({}).sources);

/* ⑥ ★ 两份实现必须一致（界面 / 引擎各一份，算法漂移 = 界面说能续、引擎说不能） */
const uiFpSandbox = { JSON: JSON, String: String, Number: Number, Object: Object, Array: Array, isNaN: isNaN };
vm.createContext(uiFpSandbox);
vm.runInContext(fs.readFileSync(path.join(SRC, '..', '..', 'tiktok-app', 'src', 'fingerprint.js'), 'utf8') +
                '\nthis.__F = Fingerprint;', uiFpSandbox);
const UI_FP = uiFpSandbox.__F;
check('界面侧指纹模块能加载', !!UI_FP && typeof UI_FP.ofIdSection === 'function');

let mismatch = '';
[baseId(), flipped, fansChanged, dedupeChanged, sourcesReordered, keywordChanged,
 videosChanged, {}, { sources: [] }].forEach((fixture, i) => {
    const a = fingerprint.ofIdSection(fixture);
    const b = UI_FP.ofIdSection(fixture);
    if (JSON.stringify(a) !== JSON.stringify(b)) {
        mismatch = 'fixture#' + i + ' 引擎=' + JSON.stringify(a) + ' 界面=' + JSON.stringify(b);
    }
});
check('引擎与界面算出的指纹逐字段相同（防算法漂移）', mismatch === '', mismatch);

/* ---------------------------------------------------------- 断点模型 */
const CP_PATH = '/sdcard/Download/tiktok_app/id_progress.json';
const SIG = fingerprint.ofIdSection(baseId());
const cp0 = checkpoint.empty('run-1', SIG, '/sdcard/Download/tiktok_app/uid_20261028_1200.txt',
                            [{ key: 'src-a', kind: 'anchor', label: '账号 A' },
                             { key: 'src-b', kind: 'search', label: '用户「小猫」' }]);
check('断点初始状态是 running 且两条取材都 pending',
      cp0.state === 'running' && cp0.sources.length === 2 && cp0.sources.every((s) => s.status === 'pending'));
check('断点记下了 runId 与结果文件', cp0.runId === 'run-1' && cp0.runFile.indexOf('uid_') > 0);

checkpoint.markSource(cp0, 'src-a', 'running');
check('标 running 后不算完成', checkpoint.sourceDone(cp0, 'src-a') === false);
checkpoint.markSource(cp0, 'src-a', 'done', { screens: 12, handled: 214, added: 37 });
check('标 done 后算完成且带上屏数/处理数',
      checkpoint.sourceDone(cp0, 'src-a') === true &&
      cp0.sources[0].screens === 12 && cp0.sources[0].handled === 214);
check('还没做完时 allDone 为假', checkpoint.allDone(cp0) === false);

/* 展开：同一个人的 fans 与 following 要分开记 */
checkpoint.enqueueExpand(cp0, 'u1', 'fans');
checkpoint.enqueueExpand(cp0, 'u2', 'fans');
checkpoint.enqueueExpand(cp0, 'u1', 'following');
check('展开项按 uid + 列表去重', cp0.expand.queue.length === 3, String(cp0.expand.queue.length));
checkpoint.enqueueExpand(cp0, 'u1', 'fans');
check('重复入队不再增加', cp0.expand.queue.length === 3, String(cp0.expand.queue.length));
checkpoint.markExpandDone(cp0, 'u1', 'fans');
check('u1 的 fans 完成后，following 仍然待做',
      checkpoint.expandDone(cp0, 'u1', 'fans') === true &&
      checkpoint.expandDone(cp0, 'u1', 'following') === false);
check('pendingExpand 只返回没做过的',
      checkpoint.pendingExpand(cp0, cp0.expand.queue).length === 2,
      String(checkpoint.pendingExpand(cp0, cp0.expand.queue).length));

checkpoint.markSource(cp0, 'src-b', 'done');
check('取材全 done 但展开有剩 → allDone 仍为假', checkpoint.allDone(cp0) === false);
checkpoint.markExpandDone(cp0, 'u2', 'fans');
checkpoint.markExpandDone(cp0, 'u1', 'following');
check('取材与展开都完成后 allDone 为真', checkpoint.allDone(cp0) === true);

/* 存盘 → 读回 */
checkpoint.save(CP_PATH, cp0);
const cpBack = checkpoint.read(CP_PATH);
check('断点能存能读', !!cpBack && cpBack.runId === 'run-1' && cpBack.sources.length === 2);
memFiles[CP_PATH] = '{ 半截 JSON';
check('半截文件当作没有断点（不抛异常）', checkpoint.read(CP_PATH) === null);
memFiles[CP_PATH] = '';
check('空文件当作没有断点', checkpoint.read(CP_PATH) === null);
check('清空断点给的是覆盖用的空壳', checkpoint.clearStub().state === 'none');

/* ---------------------------------------------------------- 续跑决策 */
const runExists = true;
check('没有断点 → 从零开始', checkpoint.planResume(null, SIG, runExists, {}).mode === 'fresh');
check('上次已跑完 → 不提供继续',
      checkpoint.planResume(Object.assign({}, cp0, { state: 'done' }), SIG, runExists, {}).mode === 'fresh');
check('演练模式 → 拒绝续跑',
      checkpoint.planResume(Object.assign({}, cp0, { state: 'stopped' }), SIG, runExists, { dryRun: true }).mode === 'reject');
check('配置变了 → 拒绝，并说清是哪一段',
      (() => {
          const r = checkpoint.planResume(Object.assign({}, cp0, { state: 'stopped' }),
                                          fingerprint.ofIdSection(keywordChanged), runExists, {});
          return r.mode === 'reject' && r.changed.join(',') === 'sources' && r.message.indexOf('取材') >= 0;
      })());
check('结果文件没了 → 拒绝',
      (() => {
          const r = checkpoint.planResume(Object.assign({}, cp0, { state: 'stopped' }), SIG, false, {});
          return r.mode === 'reject' && r.reason === 'run-file-missing';
      })());
check('配置一致 + 文件在 → 可以续跑',
      checkpoint.planResume(Object.assign({}, cp0, { state: 'stopped' }), SIG, runExists, {}).mode === 'resume');

/* ---------------------------------------------------------- 上限按累计算 */
check('上限按累计：30 + 70 = 100 → 到顶', checkpoint.limitReached({ limitBase: 30 }, 100, 70) === true);
check('上限按累计：30 + 69 = 99 → 没到', checkpoint.limitReached({ limitBase: 30 }, 100, 69) === false);
check('不限（0）永远不到顶', checkpoint.limitReached({ limitBase: 0 }, 0, 999) === false);

/* ---------------------------------------------------------- 文件名 */
const name = parse.timestampName('uid', new Date(2026, 9, 20, 18, 31, 0));
check('文件名带时分', name === 'uid_20261020_1831.txt', name);

console.log('');
console.log(`通过 ${pass} 项，失败 ${fail} 项`);
process.exit(fail === 0 ? 0 : 1);