@xixka/dsh-hub 0.2.3 → 0.2.5

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.
Files changed (255) hide show
  1. package/README.md +2 -0
  2. package/lib/account-pool.d.ts +54 -1
  3. package/lib/account-pool.d.ts.map +1 -1
  4. package/lib/account-pool.js +173 -5
  5. package/lib/account-pool.js.map +1 -1
  6. package/lib/account-probe.d.ts +15 -1
  7. package/lib/account-probe.d.ts.map +1 -1
  8. package/lib/account-probe.js +27 -3
  9. package/lib/account-probe.js.map +1 -1
  10. package/lib/aggregate-adapter.d.ts +7 -0
  11. package/lib/aggregate-adapter.d.ts.map +1 -1
  12. package/lib/aggregate-adapter.js +70 -1
  13. package/lib/aggregate-adapter.js.map +1 -1
  14. package/lib/aggregate-expiry.d.ts +66 -0
  15. package/lib/aggregate-expiry.d.ts.map +1 -1
  16. package/lib/aggregate-expiry.js +142 -3
  17. package/lib/aggregate-expiry.js.map +1 -1
  18. package/lib/auto-checkin.d.ts +285 -26
  19. package/lib/auto-checkin.d.ts.map +1 -1
  20. package/lib/auto-checkin.js +701 -40
  21. package/lib/auto-checkin.js.map +1 -1
  22. package/lib/autoclaw-auth.d.ts +29 -6
  23. package/lib/autoclaw-auth.d.ts.map +1 -1
  24. package/lib/autoclaw-auth.js +32 -8
  25. package/lib/autoclaw-auth.js.map +1 -1
  26. package/lib/autoclaw-credits.d.ts +1 -1
  27. package/lib/autoclaw-credits.js +1 -1
  28. package/lib/autoclaw-oauth.d.ts +108 -9
  29. package/lib/autoclaw-oauth.d.ts.map +1 -1
  30. package/lib/autoclaw-oauth.js +393 -25
  31. package/lib/autoclaw-oauth.js.map +1 -1
  32. package/lib/autoclaw-product.d.ts +9 -4
  33. package/lib/autoclaw-product.d.ts.map +1 -1
  34. package/lib/autoclaw-product.js +9 -4
  35. package/lib/autoclaw-product.js.map +1 -1
  36. package/lib/baizhi-adapter.d.ts +182 -0
  37. package/lib/baizhi-adapter.d.ts.map +1 -0
  38. package/lib/baizhi-adapter.js +457 -0
  39. package/lib/baizhi-adapter.js.map +1 -0
  40. package/lib/baizhi-auth.d.ts +205 -0
  41. package/lib/baizhi-auth.d.ts.map +1 -0
  42. package/lib/baizhi-auth.js +387 -0
  43. package/lib/baizhi-auth.js.map +1 -0
  44. package/lib/baizhi-browser-login.d.ts +141 -0
  45. package/lib/baizhi-browser-login.d.ts.map +1 -0
  46. package/lib/baizhi-browser-login.js +216 -0
  47. package/lib/baizhi-browser-login.js.map +1 -0
  48. package/lib/baizhi-credits.d.ts +220 -0
  49. package/lib/baizhi-credits.d.ts.map +1 -0
  50. package/lib/baizhi-credits.js +507 -0
  51. package/lib/baizhi-credits.js.map +1 -0
  52. package/lib/baizhi-messages.d.ts +98 -0
  53. package/lib/baizhi-messages.d.ts.map +1 -0
  54. package/lib/baizhi-messages.js +154 -0
  55. package/lib/baizhi-messages.js.map +1 -0
  56. package/lib/baizhi-product.d.ts +126 -0
  57. package/lib/baizhi-product.d.ts.map +1 -0
  58. package/lib/baizhi-product.js +135 -0
  59. package/lib/baizhi-product.js.map +1 -0
  60. package/lib/baizhi-rpc.d.ts +103 -0
  61. package/lib/baizhi-rpc.d.ts.map +1 -0
  62. package/lib/baizhi-rpc.js +272 -0
  63. package/lib/baizhi-rpc.js.map +1 -0
  64. package/lib/baizhi.d.ts +191 -0
  65. package/lib/baizhi.d.ts.map +1 -0
  66. package/lib/baizhi.js +298 -0
  67. package/lib/baizhi.js.map +1 -0
  68. package/lib/balance-cache.d.ts +36 -0
  69. package/lib/balance-cache.d.ts.map +1 -1
  70. package/lib/balance-cache.js +23 -0
  71. package/lib/balance-cache.js.map +1 -1
  72. package/lib/buddy-adapter.d.ts +57 -0
  73. package/lib/buddy-adapter.d.ts.map +1 -1
  74. package/lib/buddy-adapter.js +70 -7
  75. package/lib/buddy-adapter.js.map +1 -1
  76. package/lib/buddy-balance-rank.d.ts +40 -3
  77. package/lib/buddy-balance-rank.d.ts.map +1 -1
  78. package/lib/buddy-balance-rank.js +24 -1
  79. package/lib/buddy-balance-rank.js.map +1 -1
  80. package/lib/buddy-growth.d.ts +135 -10
  81. package/lib/buddy-growth.d.ts.map +1 -1
  82. package/lib/buddy-growth.js +1430 -234
  83. package/lib/buddy-growth.js.map +1 -1
  84. package/lib/canonical-models.d.ts.map +1 -1
  85. package/lib/canonical-models.js +31 -3
  86. package/lib/canonical-models.js.map +1 -1
  87. package/lib/cap-pow.d.ts +82 -0
  88. package/lib/cap-pow.d.ts.map +1 -0
  89. package/lib/cap-pow.js +209 -0
  90. package/lib/cap-pow.js.map +1 -0
  91. package/lib/client/jet-hub.js +76 -31
  92. package/lib/cline-adapter.d.ts +6 -0
  93. package/lib/cline-adapter.d.ts.map +1 -1
  94. package/lib/cline-adapter.js +50 -5
  95. package/lib/cline-adapter.js.map +1 -1
  96. package/lib/cline-models-dev.d.ts +16 -0
  97. package/lib/cline-models-dev.d.ts.map +1 -1
  98. package/lib/cline-models-dev.js +49 -1
  99. package/lib/cline-models-dev.js.map +1 -1
  100. package/lib/credential-resolver.d.ts +27 -0
  101. package/lib/credential-resolver.d.ts.map +1 -1
  102. package/lib/credential-resolver.js +23 -0
  103. package/lib/credential-resolver.js.map +1 -1
  104. package/lib/credits.d.ts +18 -1
  105. package/lib/credits.d.ts.map +1 -1
  106. package/lib/credits.js.map +1 -1
  107. package/lib/index.d.ts.map +1 -1
  108. package/lib/index.js +528 -19
  109. package/lib/index.js.map +1 -1
  110. package/lib/jet-hub-rpc.d.ts +46 -0
  111. package/lib/jet-hub-rpc.d.ts.map +1 -1
  112. package/lib/jet-hub-rpc.js +1051 -37
  113. package/lib/jet-hub-rpc.js.map +1 -1
  114. package/lib/jet-hub-store.d.ts.map +1 -1
  115. package/lib/jet-hub-store.js +54 -1
  116. package/lib/jet-hub-store.js.map +1 -1
  117. package/lib/llm-adapter.d.ts +54 -1
  118. package/lib/llm-adapter.d.ts.map +1 -1
  119. package/lib/llm-adapter.js +72 -3
  120. package/lib/llm-adapter.js.map +1 -1
  121. package/lib/llm-register-compat.d.ts +57 -0
  122. package/lib/llm-register-compat.d.ts.map +1 -1
  123. package/lib/llm-register-compat.js +91 -7
  124. package/lib/llm-register-compat.js.map +1 -1
  125. package/lib/magicrew-auth.d.ts.map +1 -1
  126. package/lib/magicrew-auth.js +4 -1
  127. package/lib/magicrew-auth.js.map +1 -1
  128. package/lib/magicrew-checkin.d.ts +139 -0
  129. package/lib/magicrew-checkin.d.ts.map +1 -0
  130. package/lib/magicrew-checkin.js +536 -0
  131. package/lib/magicrew-checkin.js.map +1 -0
  132. package/lib/magicrew-credits.d.ts +24 -1
  133. package/lib/magicrew-credits.d.ts.map +1 -1
  134. package/lib/magicrew-credits.js +175 -33
  135. package/lib/magicrew-credits.js.map +1 -1
  136. package/lib/magicrew-number.d.ts +68 -0
  137. package/lib/magicrew-number.d.ts.map +1 -0
  138. package/lib/magicrew-number.js +89 -0
  139. package/lib/magicrew-number.js.map +1 -0
  140. package/lib/magicrew-product.d.ts +75 -3
  141. package/lib/magicrew-product.d.ts.map +1 -1
  142. package/lib/magicrew-product.js +100 -0
  143. package/lib/magicrew-product.js.map +1 -1
  144. package/lib/minimax-dedup.d.ts +1 -1
  145. package/lib/minimax-dedup.d.ts.map +1 -1
  146. package/lib/minimax-dedup.js +1 -1
  147. package/lib/minimax-dedup.js.map +1 -1
  148. package/lib/model-catalog.d.ts +13 -0
  149. package/lib/model-catalog.d.ts.map +1 -1
  150. package/lib/model-catalog.js +12 -1
  151. package/lib/model-catalog.js.map +1 -1
  152. package/lib/monkeycode-adapter.d.ts +164 -0
  153. package/lib/monkeycode-adapter.d.ts.map +1 -0
  154. package/lib/monkeycode-adapter.js +438 -0
  155. package/lib/monkeycode-adapter.js.map +1 -0
  156. package/lib/monkeycode-auth.d.ts +222 -0
  157. package/lib/monkeycode-auth.d.ts.map +1 -0
  158. package/lib/monkeycode-auth.js +371 -0
  159. package/lib/monkeycode-auth.js.map +1 -0
  160. package/lib/monkeycode-browser-login.d.ts +180 -0
  161. package/lib/monkeycode-browser-login.d.ts.map +1 -0
  162. package/lib/monkeycode-browser-login.js +270 -0
  163. package/lib/monkeycode-browser-login.js.map +1 -0
  164. package/lib/monkeycode-credits.d.ts +277 -0
  165. package/lib/monkeycode-credits.d.ts.map +1 -0
  166. package/lib/monkeycode-credits.js +673 -0
  167. package/lib/monkeycode-credits.js.map +1 -0
  168. package/lib/monkeycode-messages.d.ts +137 -0
  169. package/lib/monkeycode-messages.d.ts.map +1 -0
  170. package/lib/monkeycode-messages.js +207 -0
  171. package/lib/monkeycode-messages.js.map +1 -0
  172. package/lib/monkeycode-product.d.ts +178 -0
  173. package/lib/monkeycode-product.d.ts.map +1 -0
  174. package/lib/monkeycode-product.js +156 -0
  175. package/lib/monkeycode-product.js.map +1 -0
  176. package/lib/monkeycode-rpc.d.ts +61 -0
  177. package/lib/monkeycode-rpc.d.ts.map +1 -0
  178. package/lib/monkeycode-rpc.js +342 -0
  179. package/lib/monkeycode-rpc.js.map +1 -0
  180. package/lib/monkeycode.d.ts +189 -0
  181. package/lib/monkeycode.d.ts.map +1 -0
  182. package/lib/monkeycode.js +296 -0
  183. package/lib/monkeycode.js.map +1 -0
  184. package/lib/oauth.d.ts +23 -0
  185. package/lib/oauth.d.ts.map +1 -1
  186. package/lib/oauth.js +98 -13
  187. package/lib/oauth.js.map +1 -1
  188. package/lib/openai-gateway/models.d.ts +23 -0
  189. package/lib/openai-gateway/models.d.ts.map +1 -1
  190. package/lib/openai-gateway/models.js +48 -19
  191. package/lib/openai-gateway/models.js.map +1 -1
  192. package/lib/openai-gateway/server.d.ts.map +1 -1
  193. package/lib/openai-gateway/server.js +6 -3
  194. package/lib/openai-gateway/server.js.map +1 -1
  195. package/lib/openai-gateway/tencent-fingerprint.d.ts.map +1 -1
  196. package/lib/openai-gateway/tencent-fingerprint.js +11 -0
  197. package/lib/openai-gateway/tencent-fingerprint.js.map +1 -1
  198. package/lib/opencode-proxy.d.ts +63 -0
  199. package/lib/opencode-proxy.d.ts.map +1 -1
  200. package/lib/opencode-proxy.js +80 -36
  201. package/lib/opencode-proxy.js.map +1 -1
  202. package/lib/permanent-lock-store.d.ts +7 -0
  203. package/lib/permanent-lock-store.d.ts.map +1 -1
  204. package/lib/permanent-lock-store.js +85 -10
  205. package/lib/permanent-lock-store.js.map +1 -1
  206. package/lib/provider-credits.d.ts.map +1 -1
  207. package/lib/provider-credits.js +167 -2
  208. package/lib/provider-credits.js.map +1 -1
  209. package/lib/provider-expiry.d.ts.map +1 -1
  210. package/lib/provider-expiry.js +67 -1
  211. package/lib/provider-expiry.js.map +1 -1
  212. package/lib/provider-onboarding.d.ts +10 -0
  213. package/lib/provider-onboarding.d.ts.map +1 -1
  214. package/lib/provider-onboarding.js +70 -0
  215. package/lib/provider-onboarding.js.map +1 -1
  216. package/lib/provider-registry.d.ts.map +1 -1
  217. package/lib/provider-registry.js +257 -16
  218. package/lib/provider-registry.js.map +1 -1
  219. package/lib/proxy-mask.d.ts.map +1 -1
  220. package/lib/proxy-mask.js +14 -1
  221. package/lib/proxy-mask.js.map +1 -1
  222. package/lib/qoder-adapter.d.ts +60 -2
  223. package/lib/qoder-adapter.d.ts.map +1 -1
  224. package/lib/qoder-adapter.js +215 -3
  225. package/lib/qoder-adapter.js.map +1 -1
  226. package/lib/qoder-credits.d.ts.map +1 -1
  227. package/lib/qoder-credits.js +34 -4
  228. package/lib/qoder-credits.js.map +1 -1
  229. package/lib/raccoon-adapter.d.ts +27 -0
  230. package/lib/raccoon-adapter.d.ts.map +1 -1
  231. package/lib/raccoon-adapter.js +38 -2
  232. package/lib/raccoon-adapter.js.map +1 -1
  233. package/lib/raccoon-product.d.ts.map +1 -1
  234. package/lib/raccoon-product.js +10 -4
  235. package/lib/raccoon-product.js.map +1 -1
  236. package/lib/refresh-scheduler.d.ts +14 -0
  237. package/lib/refresh-scheduler.d.ts.map +1 -1
  238. package/lib/refresh-scheduler.js +28 -2
  239. package/lib/refresh-scheduler.js.map +1 -1
  240. package/lib/session-cookie.d.ts +39 -0
  241. package/lib/session-cookie.d.ts.map +1 -0
  242. package/lib/session-cookie.js +69 -0
  243. package/lib/session-cookie.js.map +1 -0
  244. package/lib/types.d.ts +153 -5
  245. package/lib/types.d.ts.map +1 -1
  246. package/lib/types.js.map +1 -1
  247. package/lib/usage-badge.d.ts +16 -1
  248. package/lib/usage-badge.d.ts.map +1 -1
  249. package/lib/usage-badge.js +47 -5
  250. package/lib/usage-badge.js.map +1 -1
  251. package/lib/zcode-upstream.d.ts +23 -5
  252. package/lib/zcode-upstream.d.ts.map +1 -1
  253. package/lib/zcode-upstream.js +27 -9
  254. package/lib/zcode-upstream.js.map +1 -1
  255. package/package.json +3 -1
@@ -23,7 +23,7 @@
23
23
  * 若抢在续期之前签到,过期凭据会让整轮变成失败。
24
24
  * 即便如此仍可能抢在续期完成前(多账号时续期本身就要几秒到几十秒),故**再加
25
25
  * 一道保险**:整轮跑完**没有任何一条能证明「今天已被处理」**时**不记日期**,
26
- * 下次启动会重试(见 `shouldMarkToday`)。延迟可用
26
+ * 下次启动会重试(见 {@link runnableSlotKey} 与逐渠道水位线)。延迟可用
27
27
  * `DSH_JET_HUB_AUTO_CHECKIN_DELAY_MS` 覆盖,`0` 合法(表示立刻跑,单测用它)。
28
28
  *
29
29
  * ## 什么算「今天已被处理」
@@ -69,15 +69,66 @@ import { descriptorOf } from './provider-registry.js';
69
69
  /** 独立文档的文件名(与 state.json / ui-preferences.json 同目录)。 */
70
70
  export const AUTO_CHECKIN_FILE = 'auto-checkin.json';
71
71
  const SCHEMA = 'dsh-codearts-auth/auto-checkin/v1';
72
- /** 默认:打开 + 无记录。 */
72
+ /**
73
+ * 默认两个执行时刻(UTC+8)。
74
+ *
75
+ * ## 为什么保持 **09:00 / 21:00**(2026-11-01 第二轮审计推翻了「改成 10:05」)
76
+ *
77
+ * 本仓库各渠道的每日额度刷新时点**不统一**:多数在 00:00,而 Qoder 活动要
78
+ * **10:00(UTC+8)** 才刷新(见文件头与 `credits.ts`)。09:00 那轮对 Qoder 拿到的是
79
+ * **昨天**的 `CLAIMED`(`coversToday === 0`)——旧实现因此整天漏领。
80
+ *
81
+ * 曾经把默认改成 10:05 来回避,但那有两个真问题:
82
+ * ① **修不到存量用户**:`FileAutoCheckinStore.save` 每轮都会把 `times` 写盘,跑过一轮的
83
+ * 文档里 09:00 已被固化 ⇒ 只有「从没跑过的新装」才变成 10:05,两批用户行为不一致;
84
+ * ② **多跑一整轮**:工作日 09:00–18:00 的用户会看到「每天两轮全渠道扫」(12 渠道
85
+ * 24 次写请求),而某些开关机组合会从「1 轮/天」变成「某天 0 轮」。
86
+ *
87
+ * 真正的修法是**逐渠道水位线 + 补领**(见 {@link AutoCheckinDoc.pendingSlot}):
88
+ * 09:00 那轮 Qoder 没证明今天 ⇒ 只重试 Qoder,10:00 刷新后自然领到;
89
+ * 窗口 3 小时(`LAG_RETRY_WINDOW_MS`)覆盖「浮动把 09:00 提前到 07:00」的最坏情形。
90
+ */
91
+ export const DEFAULT_AUTO_CHECKIN_TIMES = ['09:00', '21:00'];
92
+ /** 恰好两个时段:用户明确要求「一天两次」。 */
93
+ export const AUTO_CHECKIN_SLOT_COUNT = 2;
94
+ /** `HH:MM`(24 小时制,两位补零)。 */
95
+ const TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)$/;
96
+ /** `YYYY-MM-DD#HH:MM`(水位线)。 */
97
+ const SLOT_RE = /^(\d{4}-\d{2}-\d{2})#([01]\d|2[0-3]):([0-5]\d)$/;
98
+ /** 默认:打开 + 默认时段 + 无记录。 */
73
99
  export const DEFAULT_AUTO_CHECKIN = {
74
100
  enabled: true,
101
+ times: [...DEFAULT_AUTO_CHECKIN_TIMES],
102
+ jitterMinutes: 0,
75
103
  lastDate: '',
104
+ lastSlot: '',
105
+ pendingSlot: '',
106
+ providerSlots: {},
76
107
  lastResult: '',
77
108
  lastAt: 0,
78
109
  channels: [],
79
110
  dismissedRunAt: 0,
80
111
  };
112
+ /** 逐渠道水位线的上限(渠道共 12 个,留余量;脏数据不该撑大文档)。 */
113
+ const MAX_PROVIDER_SLOTS = 64;
114
+ /** 归一化逐渠道水位线:丢掉非法项(只认 `YYYY-MM-DD#HH:MM`),限制条数。 */
115
+ function sanitizeProviderSlots(raw) {
116
+ if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
117
+ return {};
118
+ const out = {};
119
+ let count = 0;
120
+ for (const [key, value] of Object.entries(raw)) {
121
+ if (typeof key !== 'string' || key.length === 0 || key.length > 64)
122
+ continue;
123
+ if (typeof value !== 'string' || !SLOT_RE.test(value))
124
+ continue;
125
+ out[key] = value;
126
+ count += 1;
127
+ if (count >= MAX_PROVIDER_SLOTS)
128
+ break;
129
+ }
130
+ return out;
131
+ }
81
132
  const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
82
133
  /** 逐渠道条目的上限:渠道总数就 12 个,留一点余量即可(脏数据不该撑大文档)。 */
83
134
  const MAX_CHANNEL_ENTRIES = 24;
@@ -120,13 +171,82 @@ export function sanitizeAutoCheckin(raw) {
120
171
  // 「默认保持打开状态」相反。`'false'` / `0` 这些非布尔值一律按打开处理 ——
121
172
  // 它们不是用户点出来的值。
122
173
  enabled: record.enabled !== false,
174
+ times: sanitizeTimes(record.times),
175
+ jitterMinutes: sanitizeJitter(record.jitterMinutes),
123
176
  lastDate: typeof record.lastDate === 'string' && DATE_RE.test(record.lastDate) ? record.lastDate : '',
177
+ lastSlot: typeof record.lastSlot === 'string' && SLOT_RE.test(record.lastSlot) ? record.lastSlot : '',
178
+ pendingSlot: typeof record.pendingSlot === 'string' && SLOT_RE.test(record.pendingSlot) ? record.pendingSlot : '',
179
+ providerSlots: sanitizeProviderSlots(record.providerSlots),
124
180
  lastResult: typeof record.lastResult === 'string' ? record.lastResult : '',
125
181
  lastAt: ms(record.lastAt),
126
182
  channels: sanitizeChannels(record.channels),
127
183
  dismissedRunAt: ms(record.dismissedRunAt),
128
184
  };
129
185
  }
186
+ /**
187
+ * 归一化时段列表:丢掉非法项、去重、升序,**不足回落到默认两个**、**多于保留首尾**。
188
+ *
189
+ * ⚠️ 不能「只补到两个」:旧文档没有 `times` 字段 ⇒ 空数组 ⇒ 若原样保留,自动
190
+ * 签到会**永远等不到时段**(一天都不跑),而这正是本特性的核心失效形态。回落
191
+ * 默认值让升级后立刻按 09:00/21:00 工作,用户再改。
192
+ * ⚠️ 也不能保留多于两个:用户要求「一天两次」,多留的时段会变成「一天跑三次」。
193
+ * ⚠️ 但**多余项要留首尾**,不是「排序后前两个」(2026-11-01 第二轮审计 P3):
194
+ * 取前两个会把**最晚那一轮**静默丢掉(`["09:00","14:00","21:00"]` ⇒ 只剩
195
+ * 09:00/14:00,晚上那次没了)。留首尾至少保住全天的覆盖跨度。
196
+ */
197
+ export function sanitizeTimes(raw) {
198
+ const valid = [];
199
+ if (Array.isArray(raw)) {
200
+ for (const item of raw) {
201
+ if (typeof item !== 'string' || !TIME_RE.test(item))
202
+ continue;
203
+ if (!valid.includes(item))
204
+ valid.push(item);
205
+ }
206
+ }
207
+ const sorted = valid.sort();
208
+ if (sorted.length < AUTO_CHECKIN_SLOT_COUNT)
209
+ return [...DEFAULT_AUTO_CHECKIN_TIMES];
210
+ if (sorted.length === AUTO_CHECKIN_SLOT_COUNT)
211
+ return sorted;
212
+ return [sorted[0], sorted[sorted.length - 1]];
213
+ }
214
+ /**
215
+ * 严格校验用户提交的浮动幅度(RPC 写入路径专用)。
216
+ *
217
+ * ⚠️ 与 {@link sanitizeJitter} 分开:那个面对磁盘脏数据(回落 0),本函数面对
218
+ * 用户输入(**抛错**)。回落会让「设置没生效」看起来像「保存成功」。
219
+ */
220
+ export function sanitizeJitterStrict(raw) {
221
+ if (typeof raw !== 'number' || !Number.isFinite(raw)) {
222
+ throw new Error(`jitterMinutes 必须是数字(收到:${JSON.stringify(raw)})`);
223
+ }
224
+ if (raw < 0)
225
+ throw new Error(`jitterMinutes 不能为负(收到:${raw})`);
226
+ if (raw > MAX_CHECKIN_JITTER_MINUTES) {
227
+ throw new Error(`jitterMinutes 不能超过 ${MAX_CHECKIN_JITTER_MINUTES} 分钟(收到:${raw})`);
228
+ }
229
+ return Math.floor(raw);
230
+ }
231
+ /** 随机浮动的上限(分钟)。超过 2 小时就不再是「波动」而是「随机跑」,会破坏「两次覆盖全天」的设计。 */
232
+ export const MAX_CHECKIN_JITTER_MINUTES = 120;
233
+ /**
234
+ * 归一化随机浮动幅度。
235
+ *
236
+ * ⚠️ 非法值一律回落 **0**(= 关闭浮动),而不是回落默认值:读不出「用户到底要多少」
237
+ * 时,宁可**精确执行**(可预期)也不要随机漂移 —— 后者会让「今天怎么没跑」难以排查。
238
+ * ⚠️ 上限 `MAX_CHECKIN_JITTER_MINUTES`:超过 2 小时的偏移会让某个时段的执行落到
239
+ * 另一个时段附近,两个时段可能合并成一次,破坏「两次覆盖」的前提。
240
+ */
241
+ export function sanitizeJitter(raw) {
242
+ if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0)
243
+ return 0;
244
+ return Math.min(Math.floor(raw), MAX_CHECKIN_JITTER_MINUTES);
245
+ }
246
+ /** 时段文本是否合法(`HH:MM`)。RPC 写入路径用它拒非法值。 */
247
+ export function isLegalTimeText(value) {
248
+ return typeof value === 'string' && TIME_RE.test(value);
249
+ }
130
250
  /**
131
251
  * 取「UTC+8 的当天日期」(`YYYY-MM-DD`)。
132
252
  *
@@ -138,6 +258,186 @@ export function sanitizeAutoCheckin(raw) {
138
258
  export function utc8DateString(nowMs = Date.now()) {
139
259
  return new Date(nowMs + QODER_BILLING_UTC_OFFSET_MS).toISOString().slice(0, 10);
140
260
  }
261
+ /**
262
+ * 取「UTC+8 的当前时刻」(`HH:MM`)。与 `utc8DateString` 同源平移。
263
+ *
264
+ * ⚠️ 同样不能用本机时区:时段是用户按 UTC+8 心智设定的(上游额度也按 UTC+8 结算),
265
+ * 用本机时区会在改系统时区时整体偏移。
266
+ */
267
+ export function utc8TimeString(nowMs = Date.now()) {
268
+ return new Date(nowMs + QODER_BILLING_UTC_OFFSET_MS).toISOString().slice(11, 16);
269
+ }
270
+ /**
271
+ * `YYYY-MM-DD` + `HH:MM`(UTC+8)⇒ 毫秒时刻。
272
+ *
273
+ * ⚠️ 必须手动拼 UTC 再减偏移,**不能**用 `new Date('2026-10-18T09:00')`:
274
+ * 后者按**本机时区**解析,用户改系统时区时会算错(与 `utc8DateString` 同一条理由)。
275
+ */
276
+ export function utc8MomentMs(date, time) {
277
+ const [y, m, d] = date.split('-').map(Number);
278
+ const [hh, mm] = time.split(':').map(Number);
279
+ return Date.UTC(y, m - 1, d, hh, mm, 0, 0) - QODER_BILLING_UTC_OFFSET_MS;
280
+ }
281
+ /**
282
+ * 把「日期 + 时刻」拼成可比较的水位线 key。
283
+ *
284
+ * ⚠️ 比较必须用**字符串**而非 Date:key 的字典序恰好等于时间序(定宽
285
+ * `YYYY-MM-DD#HH:MM`),而跨时区用 Date 反而容易算错 —— 本模块的日界一律按
286
+ * UTC+8 算术平移,不需要也不应该引入本地 Date 语义。
287
+ */
288
+ export function slotKey(date, time) {
289
+ return `${date}#${time}`;
290
+ }
291
+ /**
292
+ * 枚举 [昨天, 今天, 明天] 三天的全部时段,按 `realAt` 升序。
293
+ *
294
+ * ## 为什么把「偏移」算进时段本身(2026-11-01 审计 P1-2)
295
+ *
296
+ * 旧实现先按**时段时刻**取 `due`,再拿 `realAt` 比 `now`。偏移为负时
297
+ * (真实执行时刻在时段**之前**),`due` 还没轮到那个时段 ⇒ `shouldRunNow`
298
+ * 恒 false ⇒ **负偏移是死代码**,「±N 浮动」实际只有 `[0, +N]`。
299
+ * 实测:全年 730 个时段里负偏移占 49.7%、**提前执行 0 次**;而且约一半的日子
300
+ * 精确在 `HH:MM:00` 执行 —— 正是浮动想消掉的那个脚本指纹。
301
+ *
302
+ * 把 `realAt` 作为**唯一**判据(「到点」= `realAt <= now`)之后:
303
+ * - 负偏移的时段会在时段**之前**被判为到点 ⇒ `±N` 真的是双向的;
304
+ * - 「已到点但真实时刻未到」这个中间态**不存在**了 ⇒ `nextRunDelayMs` 不再
305
+ * 恒返回 0,`armNext` 的每秒空转自动消失(审计 P1-3)。
306
+ *
307
+ * ⚠️ 偏移的夹紧保证 `span <= 与下一时段间隔的一半` ⇒ `realAt` 的先后顺序与
308
+ * 时段 key 的字典序**一致**,故水位线仍可用字符串比较。
309
+ */
310
+ export function checkinSlotsAround(nowMs, times, jitterMinutes = 0) {
311
+ const sorted = [...times].sort();
312
+ if (sorted.length === 0)
313
+ return [];
314
+ const jitter = sanitizeJitter(jitterMinutes);
315
+ const out = [];
316
+ for (const dayShift of [-1, 0, 1]) {
317
+ const date = utc8DateString(nowMs + dayShift * 86_400_000);
318
+ for (let i = 0; i < sorted.length; i += 1) {
319
+ const time = sorted[i];
320
+ // 与**下一个**时段的间隔(末尾用「到明天第一个」),用于夹紧浮动幅度。
321
+ const gap = i + 1 < sorted.length
322
+ ? timeGapMinutes(time, sorted[i + 1])
323
+ : timeGapMinutes(time, sorted[0]) + 24 * 60;
324
+ out.push({ key: slotKey(date, time), realAt: slotMomentMs(date, time, jitter, gap) });
325
+ }
326
+ }
327
+ return out.sort((a, b) => a.realAt - b.realAt);
328
+ }
329
+ /**
330
+ * 当前时刻**已经真的到点**的最大时段 key(含浮动偏移)。
331
+ *
332
+ * 例(times = 09:00 / 21:00,jitter = 0):
333
+ * - 今天 08:30 ⇒ **昨天 21:00**;
334
+ * - 今天 09:05 ⇒ 今天 09:00;
335
+ * - 今天 22:00 ⇒ 今天 21:00。
336
+ *
337
+ * 配了浮动后判据换成「时段时刻 + 偏移 <= now」:偏移为负 ⇒ 会在时段之前到点。
338
+ *
339
+ * @param jitterMinutes - 浮动幅度(分钟);省略 = 0(与旧签名兼容)。
340
+ */
341
+ export function latestDueSlotKey(nowMs, times, jitterMinutes = 0) {
342
+ const slots = checkinSlotsAround(nowMs, times, jitterMinutes);
343
+ let best = '';
344
+ for (const slot of slots) {
345
+ if (slot.realAt <= nowMs)
346
+ best = slot.key;
347
+ }
348
+ return best;
349
+ }
350
+ /** 下一个**真实执行时刻还没到**的时段;没有(`times` 为空)⇒ `null`。 */
351
+ export function nextSlotRef(nowMs, times, jitterMinutes = 0) {
352
+ for (const slot of checkinSlotsAround(nowMs, times, jitterMinutes)) {
353
+ if (slot.realAt > nowMs)
354
+ return slot;
355
+ }
356
+ return null;
357
+ }
358
+ /**
359
+ * 为某个时段算一个「随机但确定」的执行偏移(毫秒)。
360
+ *
361
+ * ## 为什么要「确定」
362
+ *
363
+ * 偏移必须**同一个时段每次算出来都一样**,否则同一轮会出现两种时间:
364
+ * 面板显示的「下次执行」与实际触发时刻不一致(用户会发现「说 9:05 却 9:12 才跑」)。
365
+ * 故用 (日期, 时刻) 作为**种子**做哈希 —— 同一天同一时段恒定,换一天/换时段就变。
366
+ *
367
+ * ## 为什么不用 Math.random()
368
+ *
369
+ * `Math.random()` 每次调用都不同 ⇒ 上面那条立刻不成立;而且它不可测(单测无法固定)。
370
+ * 这里用一个极简的字符串哈希(FNV-1a 变体),纯函数、可复现、零依赖。
371
+ *
372
+ * ## 边界:偏移绝不许越过下一个时段
373
+ *
374
+ * ⚠️ 若 09:00 那轮被 +60 分钟推到 10:00,而下一时段是 10:30,就可能出现两轮贴着跑;
375
+ * 更糟的是若推到 21:00 之后,两个时段会**合并成一次**,「一天两次」就失效了。
376
+ * 故偏移幅度取 `min(jitter, 与下一时段间隔的一半)`。
377
+ *
378
+ * @param date - UTC+8 日期(`YYYY-MM-DD`)。
379
+ * @param time - 该时段的原始时刻(`HH:MM`)。
380
+ * @param jitterMinutes - 用户配置的浮动幅度(0 = 不浮动)。
381
+ * @param nextGapMinutes - 与下一时段的间隔分钟数(用于夹紧)。
382
+ * @returns 毫秒偏移;正负都可能。
383
+ */
384
+ export function checkinJitterOffsetMs(date, time, jitterMinutes, nextGapMinutes) {
385
+ const jitter = sanitizeJitter(jitterMinutes);
386
+ if (jitter <= 0)
387
+ return 0;
388
+ // 夹紧:不许越过与下一时段间隔的一半(避免两轮合并 / 贴太近)
389
+ const gapHalf = Number.isFinite(nextGapMinutes) && nextGapMinutes > 0
390
+ ? Math.floor(nextGapMinutes / 2)
391
+ : jitter;
392
+ const span = Math.min(jitter, gapHalf);
393
+ if (span <= 0)
394
+ return 0;
395
+ // 确定性哈希:同 (date, time) 恒定,换日期/时刻即变。
396
+ const seed = `${date}#${time}`;
397
+ let hash = 2166136261;
398
+ for (let i = 0; i < seed.length; i += 1) {
399
+ hash ^= seed.charCodeAt(i);
400
+ hash = Math.imul(hash, 16777619);
401
+ }
402
+ // 把 32 位无符号映射到 [0, 2*span] 的整数分钟,再减去 span ⇒ [-span, +span]
403
+ const bucket = (hash >>> 0) % (span * 2 + 1);
404
+ return (bucket - span) * 60_000;
405
+ }
406
+ /**
407
+ * 现在该为**哪个时段**跑一轮:`''` = 不用跑。
408
+ *
409
+ * 判据优先级:
410
+ * 1. `pendingSlot`(上一轮还有渠道没领到,例如 10:00 才刷新额度的渠道)——
411
+ * 只要它还没被新时段顶掉,就继续打它(审计 P1-5:旧实现只认「整轮是否
412
+ * 证明今天」,混合渠道池里只要别的渠道证明过今天,Qoder 这类 10:00 才刷新
413
+ * 的渠道就再也不会被单独重试 ⇒ 当天漏领);
414
+ * 2. 水位线落后于**已到点的最大时段** ⇒ 跑那个时段。
415
+ *
416
+ * ⚠️ 这里**不是**「今天跑过没有」:一天两个时段各自要跑一次,用「今天跑过」
417
+ * 判会让第二个时段永远不触发。
418
+ * ⚠️ `lastSlot` 为空(从未跑过)⇒ 只要有到点的时段就跑:这正是「首次启用
419
+ * 立刻补跑」的行为。
420
+ */
421
+ export function runnableSlotKey(doc, nowMs) {
422
+ if (!doc.enabled)
423
+ return '';
424
+ // ⚠️ 这里刻意**也接受 lastDate** 的旧语义(文档字段仍在写):
425
+ // 旧文档有 lastDate 但没有 lastSlot ⇒ 无法判断今天两个时段各自处理了没有。
426
+ // 取「补跑」而不是「当成已跑」:签到是幂等的(对已领的号上游返回
427
+ // alreadyClaimed),代价是一轮请求;而误判成「已跑」的代价是**当天整天漏领**。
428
+ const due = latestDueSlotKey(nowMs, doc.times, doc.jitterMinutes ?? 0);
429
+ const pending = doc.pendingSlot ?? '';
430
+ // ⚠️「还有渠道没领到」优先(`pendingSlot`),但**不许**比当前已到点的时段还旧:
431
+ // 若重试拖过了下一个时段,旧的那个已无意义 ⇒ 直接改打新时段。
432
+ if (pending !== '' && due !== '' && pending >= due)
433
+ return pending;
434
+ if (due !== '' && ((doc.lastSlot ?? '') === '' || doc.lastSlot < due))
435
+ return due;
436
+ return '';
437
+ }
438
+ export function shouldRunNow(doc, nowMs) {
439
+ return runnableSlotKey(doc, nowMs) !== '';
440
+ }
141
441
  /** 环境变量:启动后延迟多久再尝试自动签到(毫秒)。 */
142
442
  export const DSH_JET_HUB_AUTO_CHECKIN_DELAY_MS = 'DSH_JET_HUB_AUTO_CHECKIN_DELAY_MS';
143
443
  /** 默认延迟(毫秒)。理由见文件头「为什么延迟 30 秒」。 */
@@ -195,7 +495,12 @@ class FileAutoCheckinStore {
195
495
  writeFileSync(tmp, JSON.stringify({
196
496
  schema: SCHEMA,
197
497
  enabled: doc.enabled,
498
+ times: doc.times,
499
+ jitterMinutes: doc.jitterMinutes,
198
500
  lastDate: doc.lastDate,
501
+ lastSlot: doc.lastSlot,
502
+ pendingSlot: doc.pendingSlot,
503
+ providerSlots: doc.providerSlots,
199
504
  lastResult: doc.lastResult,
200
505
  lastAt: doc.lastAt,
201
506
  channels: doc.channels,
@@ -284,30 +589,6 @@ export function describeRun(totals) {
284
589
  return `${totals.providers} 个渠道:没有需要领取的账号`;
285
590
  return `${totals.providers} 个渠道:${parts.join(',')}`;
286
591
  }
287
- /**
288
- * 这一轮该不该把「今天」记为已跑。
289
- *
290
- * 判据:**至少有一个账号能证明「今天这一轮已被处理」**(`coversToday > 0`)才记。
291
- *
292
- * ⚠️⚠️ **为什么不能看 `claimed + alreadyClaimed`**(真实缺陷,2026-10-02 审查
293
- * PR !33 定位):那两项里混着「**刷新前那一轮**」的痕迹。Qoder 的活动每日
294
- * 10:00(UTC+8)才刷新,于是上午 9 点跑的那一轮看到的是**昨天**那条 `CLAIMED`
295
- * —— 记成「今天已跑」之后,当天 10 点刷新出来的新额度**整天不会再被领**,
296
- * 而且界面还显示「1 个今天已领」,用户毫无提示。渠道自己用
297
- * `ClaimOutcome.coversToday` 标出「这条不算今天」,本函数只负责数。
298
- *
299
- * 反例(不记、下次启动重试):
300
- * - 整轮零成功零已领(凭据全过期 / 网络不通 / 启动太早抢在续期之前)——
301
- * 若记了,用户当天就再也不会自动签到,且界面只说「上次:N 个失败」;
302
- * - 跑完但**没有一条能证明今天**(例如只有 Qoder 且赶在 10:00 之前)——
303
- * 同理不记,当天稍后还有机会;
304
- * - 一个渠道都没跑(全被跳过):没有意义,不记。
305
- * 反之「有成功也有失败」要记:否则一个坏账号会让插件每次启动都把好账号再领一遍
306
- * (虽然幂等,但白白多发请求)。
307
- */
308
- export function shouldMarkToday(totals) {
309
- return totals.coversToday > 0;
310
- }
311
592
  /**
312
593
  * 单个渠道的短状态(面板上那行常驻文字用它逐渠道列出,用户要求「这样才能够知道
313
594
  * **各个渠道**的签到状态」)。
@@ -346,6 +627,92 @@ export function describeChannel(summary) {
346
627
  }
347
628
  return parts.join(',');
348
629
  }
630
+ /**
631
+ * 严格校验用户提交的时段列表(RPC 写入路径专用)。
632
+ *
633
+ * ⚠️ 与 {@link sanitizeTimes} **刻意分开**,两者面对的数据源不同:
634
+ * - `sanitizeTimes` 面对**磁盘脏数据** ⇒ 必须回落默认值,因为「读不回来」不该
635
+ * 让整个特性失效;
636
+ * - 本函数面对**用户输入** ⇒ 非法值必须**抛错**。回落会让「设置没生效」看起来像
637
+ * 「保存成功」,用户之后永远等不到那轮签到却毫无提示。
638
+ *
639
+ * 约束(用户要求「一天两次」):恰好 {@link AUTO_CHECKIN_SLOT_COUNT} 个、格式
640
+ * `HH:MM`、**不许重复**、自动升序(顺序对执行时机无影响,统一排序让水位线可比较)。
641
+ */
642
+ export function sanitizeTimesStrict(raw) {
643
+ if (raw.length !== AUTO_CHECKIN_SLOT_COUNT) {
644
+ throw new Error(`需要恰好 ${AUTO_CHECKIN_SLOT_COUNT} 个时刻(收到 ${raw.length} 个)`);
645
+ }
646
+ const out = [];
647
+ for (const item of raw) {
648
+ if (!isLegalTimeText(item)) {
649
+ throw new Error(`时刻必须是 HH:MM(24 小时制,如 09:00),收到:${JSON.stringify(item)}`);
650
+ }
651
+ if (out.includes(item))
652
+ throw new Error(`两个时刻不能相同(重复:${item})`);
653
+ out.push(item);
654
+ }
655
+ return out.sort();
656
+ }
657
+ /**
658
+ * 取某时段「加上随机浮动后」的真实执行毫秒。
659
+ *
660
+ * ⚠️ `nextGapMinutes` 由调用方算好传进来(不在这里查 `times`),是为了让本函数
661
+ * 成为纯函数:`checkinJitterOffsetMs` 的夹紧逻辑依赖它,而「下一时段是谁」
662
+ * 在跨天(最后一个时段的下一个是**明天第一个**)时要特别小心 —— 交给调用方
663
+ * 在明确知道上下文的地方算,比在这里猜更可靠。
664
+ */
665
+ function slotMomentMs(date, time, jitterMinutes, gapMinutes) {
666
+ return utc8MomentMs(date, time) + checkinJitterOffsetMs(date, time, jitterMinutes, gapMinutes);
667
+ }
668
+ /** 两个 `HH:MM` 之间的分钟差。 */
669
+ function timeGapMinutes(from, to) {
670
+ const [fh, fm] = from.split(':').map(Number);
671
+ const [th, tm] = to.split(':').map(Number);
672
+ return (th - fh) * 60 + (tm - fm);
673
+ }
674
+ /**
675
+ * 下一个**尚未处理**的时段对应的毫秒时刻(UTC+8 基准)。
676
+ *
677
+ * 三种情形:
678
+ * - 有时段待跑(水位线落后,或上一轮还有渠道没领到)⇒ 返回**现在**;
679
+ * - 下一个时段的**真实执行时刻**还没到 ⇒ 返回那一刻(含浮动偏移);
680
+ * - `times` 为空 / 开关关 ⇒ 0。
681
+ *
682
+ * ⚠️ 「待跑即现在」这一步不能省:否则「22:00 启动、水位线停在昨天」会被算成
683
+ * 「下次明天 10:05」,而实际上一轮补跑马上就要执行 —— 面板会显示自相矛盾的时间。
684
+ * ⚠️ 但它**只覆盖「马上要跑」这一格**:退避重试期间真实的下一次尝试由
685
+ * `state().nextRunAt` 取 `armNext` 排定的时刻(见 `nextAttemptAt`),不再在这里
686
+ * 编一个「现在」(审计 P1-4:旧实现在退避期间一直显示「马上执行」,实际 30 分钟后)。
687
+ */
688
+ export function nextRunAtOf(nowMs, doc) {
689
+ if (!doc.enabled)
690
+ return 0;
691
+ if (doc.times.length === 0)
692
+ return 0;
693
+ if (runnableSlotKey(doc, nowMs) !== '')
694
+ return nowMs;
695
+ const next = nextSlotRef(nowMs, doc.times, doc.jitterMinutes ?? 0);
696
+ return next === null ? 0 : next.realAt;
697
+ }
698
+ /**
699
+ * 距下一次执行的毫秒数。
700
+ *
701
+ * ⚠️ 待跑(水位线落后 / 有渠道没领到)时返回 **0** —— 调用方用
702
+ * `Math.max(1_000, …)` 兜住,既保证「立刻补跑」,又不会在水位线尚未写盘时形成忙循环。
703
+ *
704
+ * ⚠️⚠️ 旧实现在这里留了一个坑(审计 P1-3):「时段已到点、但浮动后的真实时刻还没到」
705
+ * 也会返回 0 ⇒ `armNext` 每秒醒一次(实测 2 小时 2653 次唤醒)。现在「到点」的判据
706
+ * 本身含偏移(见 `checkinSlotsAround`),这个中间态不存在了 ⇒ 会返回正的等待时长。
707
+ */
708
+ export function nextRunDelayMs(nowMs, doc) {
709
+ if (runnableSlotKey(doc, nowMs) !== '')
710
+ return 0;
711
+ const target = nextRunAtOf(nowMs, doc);
712
+ if (target === 0)
713
+ return 0;
714
+ return Math.max(0, target - nowMs);
715
+ }
349
716
  /** 创建自动签到执行体。 */
350
717
  export function createAutoCheckin(deps) {
351
718
  const now = deps.now ?? (() => Date.now());
@@ -356,10 +723,21 @@ export function createAutoCheckin(deps) {
356
723
  let pending = null;
357
724
  const today = () => utc8DateString(now());
358
725
  function state() {
726
+ const nowMs = now();
727
+ const todayKey = `${today()}#`;
359
728
  return {
360
729
  enabled: doc.enabled,
730
+ times: [...doc.times],
731
+ jitterMinutes: doc.jitterMinutes,
732
+ lastSlot: doc.lastSlot,
361
733
  lastDate: doc.lastDate,
362
- ranToday: doc.lastDate !== '' && doc.lastDate === today(),
734
+ // ⚠️ 判据是**水位线落在今天**,不是「今天有没有写盘」:补跑昨天 21:00 那轮会
735
+ // 更新 `lastAt`,但今天自己的时段还一个都没跑 ⇒ 仍该说「今天尚未执行」。
736
+ ranToday: doc.lastSlot.startsWith(todayKey),
737
+ // ★ 用 `armNext` 实际排定的时刻(含退避),不要用 `nextRunAtOf` 的「现在」:
738
+ // 退避重试期间后者恒等于 now,面板会一直显示「马上执行」却什么都不发生。
739
+ nextRunAt: doc.enabled ? (nextAttemptAt > 0 ? nextAttemptAt : nextRunAtOf(nowMs, doc)) : 0,
740
+ pendingSlot: doc.pendingSlot,
363
741
  running,
364
742
  lastResult: doc.lastResult,
365
743
  lastAt: doc.lastAt,
@@ -369,6 +747,20 @@ export function createAutoCheckin(deps) {
369
747
  };
370
748
  }
371
749
  async function performRun() {
750
+ const startedAt = now();
751
+ /**
752
+ * ★ 本轮的**目标时段**在起跑时就定死(2026-11-01 审计 P1-6)。
753
+ *
754
+ * 旧实现取「跑完那一刻已到点的最大时段」,于是「08:58 启动补跑昨天 21:00、
755
+ * 09:05 跑完」会把 **09:00 那轮**标成已完成 —— 它从未单独执行过。
756
+ * 改成起跑时的时段后:跑完只推进到「这轮本来为哪个时段跑」,
757
+ * 09:00 那轮该跑还是会跑(多跑一轮幂等,漏一轮可能丢一天额度)。
758
+ *
759
+ * ⚠️ 必须复用 {@link runnableSlotKey}(**唯一**判据),不要在这里再写一遍
760
+ * 「pendingSlot 优先」:两处判据一旦漂移,就会出现「判据说跑 A、这轮打的是 B」
761
+ * ⇒ 水位线推错、或同一时段被反复打。
762
+ */
763
+ const targetSlot = runnableSlotKey(doc, startedAt);
372
764
  const totals = emptyTotals();
373
765
  let providers = [];
374
766
  try {
@@ -380,13 +772,52 @@ export function createAutoCheckin(deps) {
380
772
  return;
381
773
  }
382
774
  const channels = [];
775
+ /**
776
+ * 本轮已确认「这个时段处理过了」的渠道 —— 逐渠道水位线的写入集。
777
+ *
778
+ * ⚠️ 判据是**逐渠道**的 `coversToday`,不是整轮合计(审计 P1-5):
779
+ * 混合池里只要有别的渠道证明今天,整轮就会记账,Qoder 这类 **10:00 才刷新
780
+ * 额度**的渠道于是再也不会被单独重试 ⇒ 当天漏领。
781
+ */
782
+ const proven = new Set();
783
+ /**
784
+ * 「设计上就不该重试」的渠道(排除表 / 无签到接口)。
785
+ *
786
+ * ⚠️ 它们既不构成「今天跑过」(`proven`),也不该拖住水位线(`lagging`)——
787
+ * 否则一个 zcode 账号会让整条链永远在重试(而它每次都是零请求,纯浪费)。
788
+ */
789
+ const unretryable = new Set();
790
+ /**
791
+ * 逐渠道水位线的**当前有效值**:只保留池里还存在的渠道。
792
+ *
793
+ * ⚠️ 为什么会残留(2026-11-01 第二轮审计 P3):渠道被删 / 改名后,键还留在文档里;
794
+ * 用户再把同一渠道加回来时,那条**旧水位线**会让它被判成「本轮已处理」而跳过
795
+ * 上游签到(实测:池空 → 加回同一渠道 ⇒ 12:00 那次 `claim` 调用次数 = 0)。
796
+ * 故每轮开始时按当前池**重建**这张表。
797
+ */
798
+ const prunedSlots = {};
383
799
  for (const provider of providers) {
800
+ const value = doc.providerSlots?.[provider] ?? '';
801
+ if (value !== '')
802
+ prunedSlots[provider] = value;
803
+ }
804
+ const prunedChanged = Object.keys(prunedSlots).length !== Object.keys(doc.providerSlots ?? {}).length;
805
+ if (prunedChanged)
806
+ doc = { ...doc, providerSlots: prunedSlots };
807
+ for (const provider of providers) {
808
+ // 逐渠道水位线:该渠道在这个时段已经处理过 ⇒ 跳过(重试时不再重复打上游)。
809
+ if (targetSlot !== '' && (prunedSlots[provider] ?? '') >= targetSlot) {
810
+ channels.push({ provider, text: '本轮已处理' });
811
+ proven.add(provider);
812
+ continue;
813
+ }
384
814
  // ⚠️ 排除表先于**任何**上游请求生效(见 isAutoCheckinExcluded 的说明):
385
815
  // zcode 的代价发生在**调用期间**(拉起浏览器产 captcha),事后再判断已经
386
816
  // 太晚 —— 必须在调 `claim` 之前就把它摘掉。
387
817
  if (isAutoCheckinExcluded(provider)) {
388
818
  totals.skipped += 1;
389
819
  channels.push({ provider, text: '需手动签到' });
820
+ unretryable.add(provider);
390
821
  continue;
391
822
  }
392
823
  let result;
@@ -404,6 +835,7 @@ export function createAutoCheckin(deps) {
404
835
  if (isUnsupportedCheckin(message)) {
405
836
  totals.skipped += 1;
406
837
  channels.push({ provider, text: '无签到接口' });
838
+ unretryable.add(provider);
407
839
  continue;
408
840
  }
409
841
  totals.errors += 1;
@@ -430,19 +862,117 @@ export function createAutoCheckin(deps) {
430
862
  // ⚠️ 记账口径**只认**这一项:渠道用 `coversToday` 自己声明「这条痕迹是不是
431
863
  // 今天这一轮的」。缺省回落到 `claimed + alreadyClaimed`,是为了兼容尚未
432
864
  // 上报该字段的旧响应(缺字段 ≠ 0,否则整轮会被判成「什么都没证明」)。
433
- totals.coversToday += summary.coversToday ?? (summary.claimed + summary.alreadyClaimed);
865
+ const coversToday = summary.coversToday ?? (summary.claimed + summary.alreadyClaimed);
866
+ totals.coversToday += coversToday;
434
867
  channels.push({ provider, text: describeChannel(summary) });
868
+ if (coversToday > 0)
869
+ proven.add(provider);
870
+ }
871
+ if (providers.length === 0) {
872
+ // 一个渠道都没有:没有可领的东西,也不该推进水位线(用户随时可能加账号)。
873
+ // 与旧行为一致地记账失败 ⇒ 走退避(此时**零上游请求**,不会轰炸)。
874
+ dueFailures += 1;
875
+ // ⚠️ 但**要把清掉的逐渠道水位线落盘**:否则「渠道被删 → 又加回来」时,
876
+ // 磁盘上那条旧水位线会让它被判成「本轮已处理」而跳过签到(第二轮审计 P3)。
877
+ if (prunedChanged) {
878
+ try {
879
+ await deps.store.save(doc);
880
+ }
881
+ catch (error) {
882
+ deps.warn?.(`[jet-hub] 自动签到:清理逐渠道水位线写入失败: ${String(error)}`);
883
+ }
884
+ }
885
+ deps.warn?.(`[jet-hub] 自动签到:账号池里没有可签到的渠道(第 ${dueFailures} 次)`);
886
+ return;
887
+ }
888
+ if (proven.size === 0) {
889
+ // ⚠️ **整轮没有任何一条渠道能证明「今天已被处理」** ⇒ **不推进**水位线(保留
890
+ // 旧语义,当时由「整轮 coversToday>0」判 —— 现在逐渠道判):
891
+ // - 凭据全过期 / 网络不通 / 启动太早抢在续期之前;
892
+ // - 「只有 zcode」这类**全部被跳过**的池子:跳过不构成「今天跑过」。
893
+ // 下一次按退避重试(`dueFailures` 记账,避免退回每秒一轮的忙循环)。
894
+ //
895
+ // ★ 但**必须**把这轮的可读结果写下来(2026-11-01 第二轮审计 P2-8):旧实现
896
+ // 在这里直接 return,`lastResult` / `channels` 停在几天前那一轮 ⇒ 凭据全过期
897
+ // 时面板永远显示「上次:昨天的成功」,用户看不到「今天一直在失败」。
898
+ dueFailures += 1;
899
+ doc = {
900
+ ...doc,
901
+ lastResult: `${describeRun(totals)}(本轮未计入今日,稍后重试)`,
902
+ lastAt: now(),
903
+ channels,
904
+ // 与成功路径同一条理由:新一轮结果出来,之前「已关闭」的标记要失效。
905
+ dismissedRunAt: 0,
906
+ };
907
+ try {
908
+ await deps.store.save(doc);
909
+ }
910
+ catch (error) {
911
+ deps.warn?.(`[jet-hub] 自动签到失败结果写入失败: ${String(error)}`);
912
+ }
913
+ deps.warn?.(`[jet-hub] 自动签到未记入今日(第 ${dueFailures} 次,将退避 ${Math.round(retryBackoffMs(dueFailures) / 1000)} 秒后重试):${describeRun(totals)}`);
914
+ return;
915
+ }
916
+ const nextProviderSlots = {};
917
+ for (const provider of providers) {
918
+ const value = proven.has(provider) ? targetSlot : (prunedSlots[provider] ?? '');
919
+ if (value !== '')
920
+ nextProviderSlots[provider] = value;
921
+ }
922
+ // ★ 待补 = 「有渠道证明了今天,但这个渠道还没有,且它**有可能**领到」。
923
+ // 设计上不该重试的(排除表 / 无签到接口)不算待补,否则它们会拖住水位线。
924
+ const lagging = providers.filter((provider) => !proven.has(provider) && !unretryable.has(provider));
925
+ // 补领预算:**按时间**而不是按次数(2026-11-01 第二轮审计 P2-1)。
926
+ //
927
+ // ⚠️ 旧实现按「14 次」算 ⇒ 累计只有 7447 秒(124 分钟),而最坏情况需要
928
+ // 「09:00 时段被 -120 分钟浮动推到 07:00,等 Qoder 10:00 刷新」= **180 分钟**
929
+ // ⇒ 预算先耗尽,当天 Qoder 仍然漏领。改成时间窗 3 小时后覆盖得住;
930
+ // 次数上限只作为「时间不可信(时钟回拨)」时的兜底。
931
+ if (lagSince === 0 || doc.pendingSlot !== targetSlot) {
932
+ // 换了一个时段、或**本进程刚接手**(`lagSince` 还是 0,例如重启后文档里
933
+ // 已带着 `pendingSlot`)⇒ 预算从这一刻重新计 3 小时窗。
934
+ // ⚠️ 少了 `lagSince === 0` 这一腿,重启后的补领会**永远不计时**、也就永远不会
935
+ // 放弃(实测:3h05m 后仍在重试)。
936
+ lagSince = now();
937
+ lagAttempts = 0;
435
938
  }
436
- if (!shouldMarkToday(totals)) {
437
- // ⚠️ 刻意**不写** lastDate:让「凭据还没续上 / 网络不通 / 赶在渠道刷新前
438
- // 跑的那一轮」能在下次启动重试,而不是当天就此放弃(判据见 shouldMarkToday)。
439
- deps.warn?.(`[jet-hub] 自动签到未记入今日(下次启动会重试):${describeRun(totals)}`);
939
+ lagAttempts += 1;
940
+ const overWindow = lagSince > 0 && now() - lagSince > LAG_RETRY_WINDOW_MS;
941
+ const giveUp = lagging.length > 0 && (overWindow || lagAttempts > LAG_RETRY_MAX);
942
+ if (lagging.length > 0 && !giveUp) {
943
+ // ★ 部分完成:**不动** `lastSlot`(这个时段还没处理完),改用 `pendingSlot`
944
+ // 记住它,并按退避只重试没领到的渠道(`providerSlots` 让已领的跳过)。
945
+ dueFailures += 1;
946
+ doc = {
947
+ ...doc,
948
+ pendingSlot: targetSlot,
949
+ providerSlots: nextProviderSlots,
950
+ lastResult: `${describeRun(totals)}(${lagging.length} 个渠道待补)`,
951
+ lastAt: now(),
952
+ channels,
953
+ dismissedRunAt: 0,
954
+ };
955
+ try {
956
+ await deps.store.save(doc);
957
+ }
958
+ catch (error) {
959
+ deps.warn?.(`[jet-hub] 自动签到部分结果写入失败: ${String(error)}`);
960
+ }
961
+ deps.warn?.(`[jet-hub] 自动签到部分完成(${targetSlot}):${lagging.join('、')} 还没证明今天,`
962
+ + `第 ${lagAttempts} 次重试将在 ${Math.round(retryBackoffMs(dueFailures) / 1000)} 秒后`);
440
963
  return;
441
964
  }
965
+ // 全部渠道都处理完(或放弃重试):推进水位线。
966
+ const finishedSlot = targetSlot === '' ? doc.lastSlot : targetSlot;
442
967
  doc = {
443
968
  ...doc,
444
969
  lastDate: today(),
445
- lastResult: describeRun(totals),
970
+ lastSlot: finishedSlot,
971
+ pendingSlot: '',
972
+ providerSlots: nextProviderSlots,
973
+ lastResult: giveUp
974
+ ? `${describeRun(totals)}(${lagging.length} 个渠道放弃补领,等下一个时段)`
975
+ : describeRun(totals),
446
976
  lastAt: now(),
447
977
  channels,
448
978
  // ⚠️ 新一轮跑完要**清掉上一次的「已关闭」标记**:否则用户关过一次后,
@@ -451,23 +981,35 @@ export function createAutoCheckin(deps) {
451
981
  };
452
982
  try {
453
983
  await deps.store.save(doc);
984
+ // ★ 记账成功 ⇒ 清掉退避计数(下一轮是正常时段,不该带着旧退避),
985
+ // 同时把**补领预算**归零(下一个时段重新计 3 小时窗)。
986
+ dueFailures = 0;
987
+ lagAttempts = 0;
988
+ lagSince = 0;
454
989
  }
455
990
  catch (error) {
456
991
  // 写盘失败 ⇒ 今天可能再跑一次(幂等,代价是多发一轮请求),如实告警。
992
+ // ⚠️ 也记一次失败:否则关闭循环又变成每秒重试。
993
+ dueFailures += 1;
457
994
  deps.warn?.(`[jet-hub] 自动签到结果写入失败(今天可能重复触发一次): ${String(error)}`);
458
995
  }
459
- deps.warn?.(`[jet-hub] 自动签到完成(${today()}):${doc.lastResult}`);
996
+ deps.warn?.(`[jet-hub] 自动签到完成(${finishedSlot || today()}):${doc.lastResult}`);
460
997
  }
461
998
  function runIfDue() {
462
999
  if (inflight !== null)
463
1000
  return inflight;
464
1001
  if (!doc.enabled)
465
1002
  return Promise.resolve();
466
- if (doc.lastDate !== '' && doc.lastDate === today())
1003
+ // ⚠️ 判据是「到点的时段处理完没有」,不是「今天跑过没有」:
1004
+ // 一天两个时段各自要跑一次,用「今天跑过」判会让第二个时段永不触发。
1005
+ if (!shouldRunNow(doc, now()))
467
1006
  return Promise.resolve();
468
1007
  running = true;
469
1008
  const task = performRun().catch((error) => {
470
- deps.warn?.(`[jet-hub] 自动签到异常: ${String(error)}`);
1009
+ // ⚠️ 抛错也必须记账(2026-11-01 审计):否则 `dueFailures` 不动 ⇒ `armNext`
1010
+ // 恒走 1 秒分支 ⇒「每秒重跑一轮」的忙循环会从「异常」这个入口原样复发。
1011
+ dueFailures += 1;
1012
+ deps.warn?.(`[jet-hub] 自动签到异常(第 ${dueFailures} 次): ${String(error)}`);
471
1013
  }).finally(() => {
472
1014
  running = false;
473
1015
  inflight = null;
@@ -475,16 +1017,129 @@ export function createAutoCheckin(deps) {
475
1017
  inflight = task;
476
1018
  return task;
477
1019
  }
1020
+ /**
1021
+ * 连续「跑了但没记账」的次数 —— 用于退避。
1022
+ *
1023
+ * ⚠️⚠️ 这个计数器修的是一个**真实的忙循环**(2026-11-01 实测):上一版排定用
1024
+ * `Math.max(1_000, nextRunDelayMs(...))`,而「有时段到点但没跑成」时
1025
+ * `nextRunDelayMs` 恒返回 **0** ⇒ 每秒重跑一轮。实测 5 轮内 `claim` 被调用
1026
+ * **10 次**(2 渠道 × 5 轮);凭据持续失效时等于**每秒打一轮上游** ——
1027
+ * 既烧请求也触发风控(签到是写操作)。
1028
+ *
1029
+ * 修法:失败后按 `RETRY_BACKOFF_BASE_MS` 指数退避(1s→2s→4s→…封顶 30 分钟),
1030
+ * 成功记账后清零。
1031
+ */
1032
+ let dueFailures = 0;
1033
+ /** 退避起点:1 秒(保持「立刻补一次」的手感,但不至于每秒重来)。 */
1034
+ const RETRY_BACKOFF_BASE_MS = 1_000;
1035
+ /** 退避上限:30 分钟。超过它就该等下一个正常时段,而不是继续重试。 */
1036
+ const RETRY_BACKOFF_MAX_MS = 30 * 60_000;
1037
+ /**
1038
+ * 同一时段的补领**时间窗**:3 小时。
1039
+ *
1040
+ * 最坏情况是「09:00 时段被浮动(上限 120 分钟)推到 07:00,而 Qoder 10:00 才刷新」
1041
+ * ⇒ 需要等 **180 分钟**。窗口按时间算(而不是按次数)才覆盖得住。
1042
+ * ⚠️ 第一版按「14 次」估算,实际累计只有 7447 秒(124 分钟),少算 40% ——
1043
+ * 第二轮审计实测那条路径仍然漏领。改时间窗后不再取决于退避曲线怎么长。
1044
+ */
1045
+ const LAG_RETRY_WINDOW_MS = 3 * 3_600_000;
1046
+ /**
1047
+ * 补领次数上限(兜底)。
1048
+ *
1049
+ * 时间窗在「时钟回拨 / 系统休眠导致 `now()` 不前进」时可能永远不到期,
1050
+ * 故再加一道次数闸:40 次 ×(最长 30 分钟)远大于 3 小时窗,正常路径不会先撞到它。
1051
+ */
1052
+ const LAG_RETRY_MAX = 40;
1053
+ /** 当前时段已补领了几次(与 `dueFailures` 分开:后者是「整轮失败」的退避计数)。 */
1054
+ let lagAttempts = 0;
1055
+ /** 当前时段的补领起点(换时段时重置)。 */
1056
+ let lagSince = 0;
1057
+ /** 按连续失败次数算退避延迟(指数退避,封顶)。 */
1058
+ function retryBackoffMs(failures) {
1059
+ const exponent = Math.min(failures, 16);
1060
+ return Math.min(RETRY_BACKOFF_BASE_MS * 2 ** (exponent - 1), RETRY_BACKOFF_MAX_MS);
1061
+ }
1062
+ /**
1063
+ * 下一次真实尝试的毫秒时刻(0 = 没有排定)。
1064
+ *
1065
+ * ⚠️ 存在的理由(2026-11-01 审计 P1-4):`nextRunAtOf` 在「有时段待跑」时
1066
+ * 返回**现在**,而退避重试期间真实的下一次可能在 30 分钟后 ⇒ 面板会一直写
1067
+ * 「马上执行」却什么都不发生。故把 `armNext` 实际排定的时刻记下来供 `state()` 用。
1068
+ */
1069
+ let nextAttemptAt = 0;
1070
+ /**
1071
+ * 排定「下一次该跑的时段」,跑完后自动续排。
1072
+ *
1073
+ * 语义闭环(这是「每天两次无遗漏」的落点):
1074
+ * 1. 启动时先延迟一轮(`start()`),到点判定是否有时段落后 ⇒ 补跑错过的时段;
1075
+ * 2. 每轮跑完再排一次 —— 目标时刻 = **下一个尚未处理的时段**(或退避后的重试时刻)。
1076
+ * 故第一个时段跑完后会自动排到第二个,无需用户再做任何事;
1077
+ * 3. 用户改时段(`setTimes`)或改开关(`setEnabled`)都会**重排**,新时间立刻生效。
1078
+ *
1079
+ * ⚠️ 立刻到点的时段**不能**用 0 延迟递归 —— 那会在水位线还没写盘时形成忙循环。
1080
+ * 给 1 秒下限,让 `performRun` 有机会写盘。
1081
+ */
1082
+ function armNext() {
1083
+ pending?.cancel();
1084
+ pending = null;
1085
+ nextAttemptAt = 0;
1086
+ if (!doc.enabled)
1087
+ return;
1088
+ const normal = nextRunDelayMs(now(), doc);
1089
+ // ⚠️ 判据是「**有时段待跑**(normal === 0)」而不是「到了一秒」:
1090
+ // 只有这种情况才会形成忙循环,必须用退避延迟把它按住。
1091
+ const ms = normal > 0
1092
+ ? Math.max(1_000, normal)
1093
+ : dueFailures > 0
1094
+ ? retryBackoffMs(dueFailures)
1095
+ : RETRY_BACKOFF_BASE_MS;
1096
+ nextAttemptAt = now() + ms;
1097
+ pending = (deps.schedule ?? defaultSchedule)(() => {
1098
+ pending = null;
1099
+ void runIfDue().finally(() => { armNext(); });
1100
+ }, ms);
1101
+ }
478
1102
  return {
479
1103
  state,
480
1104
  async setEnabled(enabled) {
481
1105
  doc = { ...doc, enabled };
482
1106
  await deps.store.save(doc);
483
- // 打开开关时立刻尝试一轮(今天已跑过则由 runIfDue 内部拦住)。
1107
+ // 开关一关就撤掉定时器:否则关掉之后还挂着下一轮,用户会以为「关了还在跑」。
1108
+ if (!enabled) {
1109
+ armNext();
1110
+ return state();
1111
+ }
1112
+ // ★ 用户手点「打开」= 想让 **现在** 试一轮,不该带着上一轮的退避计数
1113
+ // (否则刚打开就显示「30 分钟后重试」)。
1114
+ dueFailures = 0;
1115
+ // 打开开关时立刻尝试一轮(有时段没跑则由 runIfDue 内部拦住)。
484
1116
  // ⚠️ 不 await:一轮要串行打十几个上游,让按钮等它会让界面像卡死;
485
1117
  // `state()` 里的 `running` 会立刻变成 true,界面据此显示「进行中」。
486
- if (enabled)
487
- void runIfDue();
1118
+ // ⚠️ 跑完必须 armNext():否则「打开开关」这条路径不会排下一轮,
1119
+ // 10:05 打开的用户当天 21:00 那轮就永远不触发。
1120
+ void runIfDue().finally(() => { armNext(); });
1121
+ return state();
1122
+ },
1123
+ async setTimes(times, jitterMinutes) {
1124
+ // ⚠️ 校验在写入**之前**、且抛错而不是回落:回落会让「设置没生效」看起来像
1125
+ // 「保存成功」。
1126
+ if (!Array.isArray(times))
1127
+ throw new Error('times 必须是字符串数组');
1128
+ const cleaned = sanitizeTimesStrict(times);
1129
+ // `jitterMinutes` 省略 = **不改动**(与 times 的语义独立:用户可能只调时刻)。
1130
+ // 给出时必须是合法数字,否则同样抛错而不是静默回落。
1131
+ const jitter = jitterMinutes === undefined
1132
+ ? doc.jitterMinutes
1133
+ : sanitizeJitterStrict(jitterMinutes);
1134
+ // ★ 改时段 = 重新开始记账:
1135
+ // - `pendingSlot` 是**旧时刻表**下的时段 key,留着会指向一个不存在的时刻;
1136
+ // - `dueFailures` 不清零的话,改完时刻后的第一次重试还要等 30 分钟
1137
+ // (审计 P1-4 的附带症状:用户改完设置却半小时没动静)。
1138
+ doc = { ...doc, times: cleaned, jitterMinutes: jitter, pendingSlot: '' };
1139
+ dueFailures = 0;
1140
+ await deps.store.save(doc);
1141
+ // 新时间立刻生效:撤掉按旧时刻排的那一轮,按新时刻重排。
1142
+ armNext();
488
1143
  return state();
489
1144
  },
490
1145
  start() {
@@ -493,7 +1148,8 @@ export function createAutoCheckin(deps) {
493
1148
  const ms = deps.delayMs ?? autoCheckinDelayMs();
494
1149
  const fire = () => {
495
1150
  pending = null;
496
- void runIfDue();
1151
+ // 跑完再排下一轮:这是「每天两次」能自动续上的关键。
1152
+ void runIfDue().finally(() => { armNext(); });
497
1153
  };
498
1154
  // 延迟为 0 = 立刻跑(单测的默认形态,也是用户把环境变量设成 0 时的语义)。
499
1155
  if (ms <= 0) {
@@ -518,6 +1174,11 @@ export function createAutoCheckin(deps) {
518
1174
  stop() {
519
1175
  pending?.cancel();
520
1176
  pending = null;
1177
+ // 清掉「已排定时刻」的记录:之后 `state().nextRunAt` 会**回落到**「按当前时刻
1178
+ // 算出的下一时段」,而不是一个本进程已经取消掉的时刻。
1179
+ // ⚠️ 别指望它变 0:开关仍是开着的,回落值可能是「现在(有待跑时段)」也可能是
1180
+ // 下一个时段的时刻。0 只在开关关闭时才出现(`armNext` 的清零 + `state()` 判 enabled)。
1181
+ nextAttemptAt = 0;
521
1182
  },
522
1183
  };
523
1184
  }