dsh-bagu 0.11.1 → 0.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/client.js CHANGED
@@ -324,6 +324,31 @@ window.__ModuleLoader__.load({
324
324
  onChange: () => save({ autoMeme: view.autoMeme === false }),
325
325
  })),
326
326
 
327
+ h(Row, {
328
+ label: view.autoUpdate !== false ? '每天更新词库:开' : '每天更新词库:关',
329
+ note: st.lastCheck
330
+ ? `上次查过:${st.lastCheck}。现在 ${st.memeTotal} 条。`
331
+ : `光大不更新会变旧。现在 ${st.memeTotal} 条,开了就每天去看一眼新词条。`,
332
+ }, h(Switch, {
333
+ on: view.autoUpdate !== false, label: '每天更新',
334
+ disabled: busy === 'save' || !on || view.memes === false,
335
+ onChange: () => save({ autoUpdate: view.autoUpdate === false }),
336
+ })),
337
+
338
+ view.autoUpdate !== false ? h('div', { 'data-bg-row': '' },
339
+ h('div', { 'data-bg-grow': '' },
340
+ h('div', { 'data-bg-label': '' }, '每天几点'),
341
+ h('div', { 'data-bg-note': '' },
342
+ '凌晨机器闲着,四点最稳。更新只补新词条,不动你改过的。')),
343
+ h('select', {
344
+ 'data-bg-num': '', 'data-wide': '', value: String(view.updateHour ?? 4),
345
+ disabled: busy === 'save',
346
+ onChange: (e) => save({ updateHour: Number(e.target.value) }),
347
+ },
348
+ Array.from({ length: 24 }, (_, i) =>
349
+ h('option', { key: i, value: String(i) },
350
+ String(i).padStart(2, '0') + ':00')))) : null,
351
+
327
352
  h(Row, {
328
353
  label: view.toneSwitch ? '尺度:自己定' : '尺度:交给模型',
329
354
  note: view.toneSwitch
package/data/memes.db CHANGED
Binary file
package/dsh-plugin.json CHANGED
@@ -3,7 +3,7 @@
3
3
  "manifestVersion": "0.15",
4
4
  "id": "dsh-bagu",
5
5
  "name": "dsh-bagu",
6
- "version": "0.11.1",
6
+ "version": "0.12.0",
7
7
  "license": "MIT",
8
8
  "description": "AI 对外说话两道门:八股打回,梗接住。",
9
9
  "facets": {
package/lib/config.js CHANGED
@@ -30,6 +30,10 @@ export const DEFAULTS = {
30
30
  memes: true,
31
31
  /** 每轮请求前自动查词库并注入。关掉就只在主动调工具时查。 */
32
32
  autoMeme: true,
33
+ /** 词库每天自动更新。关掉就不再联网。 */
34
+ autoUpdate: true,
35
+ /** 每天几点更新,0-23。默认凌晨 4 点。 */
36
+ updateHour: 4,
33
37
  /** 手动接管玩梗尺度。关着时交给模型自己判断。 */
34
38
  toneSwitch: false,
35
39
  /** 玩梗尺度 0-100。toneSwitch 关着时不生效。 */
package/lib/index.js CHANGED
@@ -17,6 +17,7 @@ import { guard } from './guard.js';
17
17
  import { findMemes, entry, search, bridge, stats as memeStats } from './memes.js';
18
18
  import { aiBridge } from './ai-bridge.js';
19
19
  import { captureRoute, sessionBridge } from './session-bridge.js';
20
+ import { updateOnce, dbStatus, isDue, lastUpdate } from './update.js';
20
21
  import { readConfig, writeConfig, CONFIG_FILE, DEFAULTS } from './config.js';
21
22
 
22
23
  export const name = 'dsh-bagu';
@@ -152,7 +153,9 @@ export function apply(root, config = {}) {
152
153
  order: 950,
153
154
  text: (context) => {
154
155
  try {
155
- const text = currentUserText || lastUserText(context);
156
+ // 只认当轮消息。清空之后不再翻 session —— 那会翻到历史消息,
157
+ // 注入一堆跟本轮无关的梗(实测踩过:问「有人味吗」塞进「检测到前方有XX」)。
158
+ const text = currentUserText;
156
159
  if (!text) return '';
157
160
  currentUserText = '';
158
161
  const r = bridge(text);
@@ -329,6 +332,41 @@ export function apply(root, config = {}) {
329
332
  });
330
333
  });
331
334
 
335
+ // ── 词库每日更新 ────────────────────────────────
336
+ // 每小时看一次,到点就跑。不用 setInterval(24h) —— 那会跟着启动时刻漂,
337
+ // 早上八点开机就永远早上八点更新。按小时对齐才稳定。
338
+ root.inject(['timer'], (ctx) => {
339
+ let stop = null;
340
+ try {
341
+ ctx.effect(() => {
342
+ const tick = () => {
343
+ try {
344
+ if (!live.autoUpdate) return;
345
+ const st = dbStatus();
346
+ if (!st.exists) return;
347
+ const hour = new Date().getHours();
348
+ const target = Math.max(0, Math.min(23, Number(live.updateHour) || 0));
349
+ if (hour !== target) return;
350
+ // 今天这个点已经跑过就不再跑
351
+ const last = st.lastCheck ? Date.parse(st.lastCheck) : 0;
352
+ if (last && new Date(last).toDateString() === new Date().toDateString()) return;
353
+ updateOnce({ onLog: () => {} }).catch(() => {});
354
+ } catch { /* 定时检查不能炸 */ }
355
+ };
356
+ // 启动后 30 秒看一次,之后每小时一次
357
+ const first = setTimeout(tick, 30000);
358
+ const iv = setInterval(tick, 60 * 60 * 1000);
359
+ // unref:不阻止进程退出。宿主不调清理函数时也不会挂住。
360
+ if (typeof first.unref === 'function') first.unref();
361
+ if (typeof iv.unref === 'function') iv.unref();
362
+ stop = () => { clearTimeout(first); clearInterval(iv); };
363
+ return () => { if (stop) stop(); };
364
+ }, 'dsh-bagu: 词库每日更新');
365
+ } catch {
366
+ /* 宿主没有 timer 服务就算了 */
367
+ }
368
+ });
369
+
332
370
  root.inject(['webServer'], (ctx) => {
333
371
  const handler = async (req, res) => {
334
372
  const url = new URL(req.url, 'http://127.0.0.1');
@@ -342,6 +380,14 @@ export function apply(root, config = {}) {
342
380
  promptActive: live.enabled && live.prompt,
343
381
  // 词库的规模显示在设置页上 —— 让人知道兜里有多少货
344
382
  memeTotal: (() => { try { return memeStats().total } catch { return 0 } })(),
383
+ // 词库规模与上次检查时间,设置页显示用
384
+ lastCheck: (() => {
385
+ try {
386
+ const st = dbStatus();
387
+ return st.lastCheck ? new Date(st.lastCheck).toLocaleString('zh-CN', { hour12: false }) : '';
388
+ } catch { return '' }
389
+ })(),
390
+ memeSizeMB: (() => { try { return dbStatus().sizeMB || 0 } catch { return 0 } })(),
345
391
  memeWithUsage: (() => { try { return memeStats().withUsage } catch { return 0 } })(),
346
392
  route: getRoute(),
347
393
  configFile: CONFIG_FILE,
package/lib/update.js ADDED
@@ -0,0 +1,230 @@
1
+ /**
2
+ * 词库每日更新。
3
+ *
4
+ * 只补新的,不覆盖已有 —— 手动改过的词条不能被冲掉。
5
+ * 网不稳,所以整轮失败不算数,下次再来;单条失败跳过。
6
+ *
7
+ * 数据源是梗Wiki 的公开接口,跟首次打包时用的是同一个。
8
+ */
9
+
10
+ import { DatabaseSync } from 'node:sqlite';
11
+ import { copyFileSync, existsSync, statSync, readdirSync, unlinkSync } from 'node:fs';
12
+ import { dirname, join } from 'node:path';
13
+ import { fileURLToPath } from 'node:url';
14
+
15
+ const HERE = dirname(fileURLToPath(import.meta.url));
16
+ const DB_PATH = join(HERE, '..', 'data', 'memes.db');
17
+ const BASE = 'https://cnmeme.wiki';
18
+
19
+ /** 多久跑一次。24 小时。 */
20
+ export const INTERVAL_MS = 24 * 60 * 60 * 1000;
21
+
22
+ /** 一轮最多翻多少页列表。30 条一页,300 页 = 9000 条,够覆盖当前全站还留余量。 */
23
+ const MAX_PAGES = 300;
24
+
25
+ /** 一轮最多补多少条详情。首次之后每天通常只有个位数新增。 */
26
+ const MAX_NEW = 200;
27
+
28
+ let running = false;
29
+ let lastResult = null;
30
+
31
+ async function get(path, tries = 3) {
32
+ for (let i = 0; i < tries; i++) {
33
+ try {
34
+ const res = await fetch(BASE + path, { signal: AbortSignal.timeout(25000) });
35
+ if (res.ok) return await res.json();
36
+ if (res.status === 404) return null;
37
+ if (res.status >= 400 && res.status < 500) return null;
38
+ } catch {
39
+ /* 超时或断网,重试 */
40
+ }
41
+ await new Promise((r) => setTimeout(r, 1200 * (i + 1)));
42
+ }
43
+ return null;
44
+ }
45
+
46
+ /** 翻列表,拿到当前全站的 slug 集合。翻不全就返回 null,整轮放弃。 */
47
+ async function listAllSlugs(log = () => {}) {
48
+ const slugs = new Set();
49
+ let offset = 0;
50
+ let pages = 0;
51
+ let fails = 0;
52
+ let complete = true;
53
+
54
+ while (pages < MAX_PAGES) {
55
+ const j = await get(`/api/v1/public/memes?limit=30&offset=${offset}`);
56
+
57
+ if (!j || !Array.isArray(j.items)) {
58
+ fails++;
59
+ // 连续失败太多就停,但已经拿到的照样用
60
+ if (fails >= 3) { complete = false; break; }
61
+ offset += 30;
62
+ pages++;
63
+ continue;
64
+ }
65
+ fails = 0;
66
+ if (j.items.length === 0) break;
67
+ for (const it of j.items) if (it.slug) slugs.add(it.slug);
68
+ pages++;
69
+ offset += 30;
70
+ if (!j.has_more) break;
71
+ await new Promise((r) => setTimeout(r, 120));
72
+ }
73
+
74
+ if (slugs.size === 0) return null; // 一条都没拿到 = 真失败
75
+ if (!complete) log(`(列表翻到 ${slugs.size} 条时网络断了,这轮按已拿到的补)`);
76
+ return slugs;
77
+ }
78
+
79
+ /** 只留最近 N 个备份,其余删掉。 */
80
+ function pruneBackups(log = () => {}, keep = 2) {
81
+ try {
82
+ const dir = dirname(DB_PATH);
83
+ const base = 'memes.db.bak-';
84
+ const entries = readdirSync(dir)
85
+ .filter((n) => n.startsWith(base))
86
+ .map((n) => ({ n, t: Number(n.slice(base.length)) || 0 }))
87
+ .sort((a, b) => b.t - a.t);
88
+ for (const e of entries.slice(keep)) {
89
+ try { unlinkSync(join(dir, e.n)); log('删旧备份 ' + e.n); } catch { /* 删不掉就算了 */ }
90
+ }
91
+ } catch { /* 目录读不了就算了 */ }
92
+ }
93
+
94
+ /**
95
+ * 跑一轮更新。
96
+ *
97
+ * @param {{onLog?: (msg: string) => void}} opts
98
+ * @returns {Promise<{added: number, total: number, ok: boolean, error?: string}>}
99
+ */
100
+ export async function updateOnce(opts = {}) {
101
+ const log = opts.onLog || (() => {});
102
+ if (running) return { added: 0, total: 0, ok: false, error: 'already running' };
103
+ running = true;
104
+
105
+ try {
106
+ if (!existsSync(DB_PATH)) {
107
+ return { added: 0, total: 0, ok: false, error: 'db 不存在' };
108
+ }
109
+
110
+ log('翻列表…');
111
+ const remote = await listAllSlugs(log);
112
+ if (!remote) {
113
+ log('列表一条都没拿到,这轮跳过');
114
+ return { added: 0, total: 0, ok: false, error: '列表拿不到' };
115
+ }
116
+ log(`远端 ${remote.size} 条`);
117
+
118
+ const db = new DatabaseSync(DB_PATH);
119
+ let local;
120
+ try {
121
+ local = new Set(db.prepare('SELECT slug FROM memes').all().map((r) => r.slug));
122
+ } catch (e) {
123
+ db.close();
124
+ return { added: 0, total: 0, ok: false, error: '读本地失败: ' + e.message };
125
+ }
126
+
127
+ const missing = [...remote].filter((s) => s && !local.has(s));
128
+ log(`本地 ${local.size} 条,缺 ${missing.length} 条`);
129
+
130
+ if (missing.length === 0) {
131
+ db.prepare("INSERT OR REPLACE INTO meta(key,value) VALUES('last_check',?)")
132
+ .run(new Date().toISOString());
133
+ db.close();
134
+ const total = local.size;
135
+ lastResult = { added: 0, total, ok: true };
136
+ return lastResult;
137
+ }
138
+
139
+ // 先备份,出事了能退回去。只留最近 2 个 —— 每天一个 17MB 撑不住。
140
+ try {
141
+ const bak = DB_PATH + '.bak-' + Date.now();
142
+ copyFileSync(DB_PATH, bak);
143
+ log('已备份 ' + bak.split(/[\\/]/).pop());
144
+ pruneBackups(log);
145
+ } catch {
146
+ /* 备份失败不影响更新 */
147
+ }
148
+
149
+ const ins = db.prepare(
150
+ 'INSERT OR IGNORE INTO memes(title,slug,tags,usage,origin,other,summary,aliases) VALUES(?,?,?,?,?,?,?,?)',
151
+ );
152
+
153
+ let added = 0;
154
+ const todo = missing.slice(0, MAX_NEW);
155
+ for (const slug of todo) {
156
+ const j = await get(`/api/v1/public/memes/${encodeURIComponent(slug)}`);
157
+ const it = j && j.item;
158
+ if (!it || !it.title) continue;
159
+ try {
160
+ ins.run(
161
+ it.title,
162
+ it.slug || slug,
163
+ Array.isArray(it.tags) ? it.tags.join('、') : String(it.tags || ''),
164
+ String(it.usage || ''),
165
+ String(it.origin || ''),
166
+ String(it.other || ''),
167
+ String(it.summary || ''),
168
+ Array.isArray(it.aliases) ? it.aliases.join('、') : String(it.aliases || ''),
169
+ );
170
+ added++;
171
+ } catch {
172
+ /* 单条写失败,跳过 */
173
+ }
174
+ if (added % 20 === 0) log(`已补 ${added}/${todo.length}`);
175
+ await new Promise((r) => setTimeout(r, 150));
176
+ }
177
+
178
+ const total = db.prepare('SELECT COUNT(*) c FROM memes').get().c;
179
+ db.prepare("INSERT OR REPLACE INTO meta(key,value) VALUES('count',?)").run(String(total));
180
+ db.prepare("INSERT OR REPLACE INTO meta(key,value) VALUES('last_check',?)")
181
+ .run(new Date().toISOString());
182
+ db.close();
183
+
184
+ log(`补了 ${added} 条,本地现在 ${total} 条`);
185
+ lastResult = { added, total, ok: true };
186
+ return lastResult;
187
+ } catch (e) {
188
+ log('出错: ' + e.message);
189
+ return { added: 0, total: 0, ok: false, error: e.message };
190
+ } finally {
191
+ running = false;
192
+ }
193
+ }
194
+
195
+ /** 上次更新结果,给设置页看。 */
196
+ export function lastUpdate() {
197
+ return lastResult;
198
+ }
199
+
200
+ /** 本地词库规模与最后检查时间。 */
201
+ export function dbStatus() {
202
+ if (!existsSync(DB_PATH)) return { exists: false };
203
+ try {
204
+ const db = new DatabaseSync(DB_PATH, { readOnly: true });
205
+ const count = db.prepare('SELECT COUNT(*) c FROM memes').get().c;
206
+ const rows = db.prepare('SELECT key,value FROM meta').all();
207
+ db.close();
208
+ const meta = {};
209
+ for (const r of rows) meta[r.key] = r.value;
210
+ return {
211
+ exists: true,
212
+ count,
213
+ builtAt: meta.built_at || '',
214
+ lastCheck: meta.last_check || '',
215
+ sizeMB: +(statSync(DB_PATH).size / 1048576).toFixed(1),
216
+ };
217
+ } catch {
218
+ return { exists: false };
219
+ }
220
+ }
221
+
222
+ /** 距上次检查够不够 24 小时。首次(没有记录)返回 true。 */
223
+ export function isDue() {
224
+ const st = dbStatus();
225
+ if (!st.exists) return false;
226
+ if (!st.lastCheck) return true;
227
+ const last = Date.parse(st.lastCheck);
228
+ if (!Number.isFinite(last)) return true;
229
+ return Date.now() - last >= INTERVAL_MS;
230
+ }
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "dsh-bagu",
3
- "version": "0.11.1",
4
- "description": "两道门:八股打回(聊天/评论/邮件/commit/PR/文档/注释全管);梗接住(内置梗Wiki 6792 条,说简称也认)。",
3
+ "version": "0.12.0",
4
+ "description": "两道门:八股打回(聊天/评论/邮件/commit/PR/文档/注释全管);梗接住(内置梗Wiki 6845 条,每天可自动更新)。",
5
5
  "type": "module",
6
6
  "main": "lib/index.js",
7
7
  "exports": {
@@ -57,6 +57,7 @@ test('注册了 bagu:prefetch', async () => {
57
57
  test('有梗的消息能算出注入文本', async () => {
58
58
  const { apply } = await import('../lib/index.js');
59
59
  const ctxs = [];
60
+ let stepHandler = null;
60
61
  const root = {
61
62
  inject(deps, fn) {
62
63
  if (deps.includes('llm')) return;
@@ -68,6 +69,7 @@ test('有梗的消息能算出注入文本', async () => {
68
69
  tools: { register() {} },
69
70
  webServer: { register() { return () => {} } },
70
71
  effect(fn) { return fn() },
72
+ on(evt, fn) { if (evt === 'agent/pre-step') stepHandler = fn },
71
73
  });
72
74
  },
73
75
  };
@@ -76,31 +78,64 @@ test('有梗的消息能算出注入文本', async () => {
76
78
  fs.writeFileSync('./config.json', JSON.stringify({ enabled: true, memes: true, autoMeme: true }));
77
79
  try {
78
80
  apply(root, {});
81
+ assert.ok(stepHandler, '必须注册 agent/pre-step —— 当轮消息只能从这里来');
79
82
  const c = ctxs[0];
80
- const fake = {
81
- agent: {
82
- session: {
83
- snapshotEvents: () => [
84
- { type: 'user/message', payload: { content: '康神开播了' } },
85
- ],
86
- },
87
- },
88
- };
89
- const out = c.text(fake);
83
+
84
+ // 走 pre-step 提供当轮消息
85
+ await stepHandler({ messages: [{ role: 'user', content: '康神开播了' }] }, async () => ({}));
86
+ const out = c.text({ agent: { session: { snapshotEvents: () => [] } } });
90
87
  assert.ok(out.length > 0, '含梗的消息该算出注入文本');
91
88
  assert.match(out, /康神开播了/, '该提到命中的梗');
92
89
 
93
- // 不含梗的不注入
94
- const fake2 = {
95
- agent: {
96
- session: {
97
- snapshotEvents: () => [
98
- { type: 'user/message', payload: { content: '帮我看看这个报错' } },
99
- ],
90
+ // 不含梗的不注入(同样走 pre-step)
91
+ await stepHandler({ messages: [{ role: 'user', content: '帮我看看这个报错' }] }, async () => ({}));
92
+ assert.equal(c.text({ agent: { session: { snapshotEvents: () => [] } } }), '', '不含梗不该注入');
93
+ } finally {
94
+ if (bak !== null) fs.writeFileSync('./config.json', bak);
95
+ else if (fs.existsSync('./config.json')) fs.unlinkSync('./config.json');
96
+ }
97
+ });
98
+
99
+ test('清空之后不再翻 session 拿历史消息', async () => {
100
+ const { apply } = await import('../lib/index.js');
101
+ const ctxs = [];
102
+ let stepHandler = null;
103
+ const root = {
104
+ inject(deps, fn) {
105
+ if (deps.includes('llm')) return;
106
+ fn({
107
+ systemPrompt: {
108
+ section() { return () => {} },
109
+ context(o) { ctxs.push(o); return () => {} },
100
110
  },
101
- },
111
+ tools: { register() {} },
112
+ webServer: { register() { return () => {} } },
113
+ effect(fn) { return fn() },
114
+ on(evt, fn) { if (evt === 'agent/pre-step') stepHandler = fn },
115
+ });
116
+ },
117
+ };
118
+ const fs = await import('node:fs');
119
+ const bak = fs.existsSync('./config.json') ? fs.readFileSync('./config.json', 'utf8') : null;
120
+ fs.writeFileSync('./config.json', JSON.stringify({ enabled: true, memes: true, autoMeme: true }));
121
+ try {
122
+ apply(root, {});
123
+ const c = ctxs[0];
124
+
125
+ // 当轮说了含梗的话
126
+ await stepHandler({ messages: [{ role: 'user', content: '康神开播了' }] }, async () => ({}));
127
+ const first = c.text({ agent: { session: { snapshotEvents: () => [] } } });
128
+ assert.ok(first.length > 0, '第一次该注入');
129
+
130
+ // 同一轮里再调一次:当轮消息已经用掉了,不许翻 session 拿历史
131
+ const session = {
132
+ snapshotEvents: () => [
133
+ { type: 'user/message', payload: { content: '检测到前方有XX' } },
134
+ { type: 'user/message', payload: { content: '我错了但我不能改' } },
135
+ ],
102
136
  };
103
- assert.equal(c.text(fake2), '', '不含梗不该注入');
137
+ const second = c.text({ agent: { session } });
138
+ assert.equal(second, '', '清空之后不许翻 session 注入历史梗,实际注入了: ' + second.slice(0, 60));
104
139
  } finally {
105
140
  if (bak !== null) fs.writeFileSync('./config.json', bak);
106
141
  else if (fs.existsSync('./config.json')) fs.unlinkSync('./config.json');
@@ -25,8 +25,11 @@ test('bagu_meme 的 execute 里有开关检查', () => {
25
25
  assert.match(tail, /if \(!live\.memes\)/, 'execute 里得判 live.memes,否则关了还能用');
26
26
  });
27
27
 
28
- test('预查优先用当轮消息,不靠 session 翻', () => {
29
- assert.match(SRC, /currentUserText \|\| lastUserText/, '预查得优先用 pre-step 抓到的当轮消息');
28
+ test('预查只认当轮消息,不翻 session', () => {
29
+ // 曾经 fallback 到 lastUserText,鼓一轮里第二次调用时翻到历史消息,
30
+ // 注入一堆跟本轮无关的梗(实测:问「有人味吗」塞进「检测到前方有XX」)。
31
+ assert.doesNotMatch(SRC, /currentUserText \|\| lastUserText/, '不许再 fallback 到 session');
32
+ assert.match(SRC, /const text = currentUserText;/, '只认当轮消息');
30
33
  });
31
34
 
32
35
  test('注册了 agent/pre-step 钩子', () => {
@@ -0,0 +1,50 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { readFileSync, readdirSync } from 'node:fs';
4
+
5
+ const UPDATE = readFileSync('lib/update.js', 'utf8');
6
+ const INDEX = readFileSync('lib/index.js', 'utf8');
7
+
8
+ test('定时器必须 unref,不然挂住进程', () => {
9
+ // 实际踩过:加了 setInterval 之后测试从 2 秒变成卡死 90 秒才超时。
10
+ // unref 让定时器不阻止 Node 退出,宿主不调清理函数时也不拖后腿。
11
+ assert.match(INDEX, /\.unref\(\)/, 'setTimeout / setInterval 得 unref');
12
+ assert.match(INDEX, /first\.unref/, '一次性的也得 unref');
13
+ });
14
+
15
+ test('备份要轮转,不能只增不减', () => {
16
+ // 每个备份 17MB,一天一个,一年 6GB。
17
+ assert.match(UPDATE, /pruneBackups/, '得有清理函数');
18
+ assert.match(UPDATE, /keep = 2/, '只留最近 2 个');
19
+ assert.match(UPDATE, /pruneBackups\(log\)/, '写完备份要调一下');
20
+ });
21
+
22
+ test('更新按小时对齐,不跟启动时刻漂', () => {
23
+ // 用 setInterval(24h) 会跟着启动时刻走,早上开机就永远早上更新。
24
+ assert.match(INDEX, /getHours\(\)/, '得看当前小时');
25
+ assert.match(INDEX, /live\.updateHour/, '得读配置里的小时');
26
+ });
27
+
28
+ test('同一天不重复跑', () => {
29
+ assert.match(INDEX, /toDateString\(\)/, '得比日期,跑过就跳过');
30
+ });
31
+
32
+ test('列表接口拿不到总数,翻页要容错', () => {
33
+ // 接口只返回 items / limit / offset / has_more,没有 total。
34
+ // 中途一页失败不该整轮作废。
35
+ assert.match(UPDATE, /has_more/);
36
+ assert.match(UPDATE, /fails >= 3/, '连续失败才停');
37
+ assert.match(UPDATE, /slugs\.size === 0/, '一条都没拿到才算失败');
38
+ });
39
+
40
+ test('MAX_PAGES 够覆盖全站', () => {
41
+ const m = UPDATE.match(/const MAX_PAGES = (\d+)/);
42
+ assert.ok(m, '找不到 MAX_PAGES');
43
+ const pages = Number(m[1]);
44
+ // 6845 条 / 30 = 229 页
45
+ assert.ok(pages >= 240, `MAX_PAGES=${pages} 翻不完 6845 条`);
46
+ });
47
+
48
+ test('只补新的,不覆盖已有', () => {
49
+ assert.match(UPDATE, /INSERT OR IGNORE INTO memes/, '不能 REPLACE,会冲掉手动改过的');
50
+ });