@dougen/dsh-deepseek-usage 0.9.1 → 0.10.0

package/lib/pricing.js

@@ -1,27 +1,22 @@
 /**
  * dsh-deepseek-usage — 定价表（元 / 百万 tokens）。
  *
- * 价格来源优先级（0.7.0 起，三层）：
- * - remote（进程内最新）：DeepSeek 官方"模型 & 价格"页（lib/pricing-remote.js 抓取，
- *   每日首次访问/点击卡片时刷新），解析结果经 setRemotePrices() 注入本模块——官方调价
- *   只需页面更新，无需改本文件。
- * - file（本地价格配置表）：lib/pricing-store.js 维护的 pricing.json，内容是"上次同步到
- *   的官方价 + 用户手改的价"，经 setFilePrices() 注入。进程重启后 remote 层为空，卡片
- *   直接用它，因此不会再退回内置表（也就不会再出现"价格未同步（用内置表）"）。
- * - seed（内置兜底）：下方 PRICE_TABLE 内置种子表——DeepSeek 官方峰谷定价快照
- *   （2026-09-10，与当时官方价格页一致）。首次运行会拿它生成初始 pricing.json；
- *   只有"本地价格表缺失/损坏且官方页也拿不到"时才会真正被展示。
+ * 价格唯一来源：下方 PRICE_TABLE 内置表——DeepSeek 官方峰谷定价快照
+ * （2026-09-10 官方价格页）。官方调价时随插件版本更新本表。
  *
  * 模型改名（0.6.0 起）：官方会把模型改名并把旧名保留为别名（如
  * deepseek-v4-flash / deepseek-v4-flash-vision-exp → deepseek-flash）。旧名若
  * 落到内置表就会长期显示过期价且无从察觉，因此：
  *   · MODEL_ALIASES 维护"旧名 → 现名"的显式映射；
- *   · 远端表查不到时先试别名，再试"同家族唯一匹配"（flash / pro / chat /
+ *   · 查不到时先试别名，再试"同家族唯一匹配"（flash / pro / chat /
  *     reasoner），命中即按现名计价；
- *   · 两条路径都会在 unitAt() 的 via 字段里标出来源，供界面提示，避免静默算错。
+ *   · 两条路径都会在 unitAt() 的 via 字段里标出来源，供排查，避免静默算错。
  *
- * 峰谷（官方口径）：高峰时段为北京时间周一至周五 9:00–12:00、14:00–18:00，
- * 其余（含整个周末）为空闲时段；缓存写暂不计费（cacheWrite = 0）。
+ * 峰谷（官方口径）：高峰时段为北京时间周一至周五（**不含中国法定节假日**）
+ * 9:00–12:00、14:00–18:00，其余（含整个周末、法定节假日全天、以及调休上班的
+ * 周末）为空闲时段；缓存写暂不计费（cacheWrite = 0）。
+ * 因此只有"落在工作日里的法定节假日"会改变判定结果——周末无论是否调休上班都
+ * 是空闲，见 HOLIDAY_RANGES。
  *
  * 本文件用于卡片"当前档单价"展示、峰谷指示灯，以及 nextChange() 给出的
  * 「距下次峰谷切换倒计时」（卡片上显示为 `2d 15h` / `5h 47m` 这类英文单位时长）。
@@ -35,10 +30,8 @@
 export const SHANGHAI_OFFSET_MS = 8 * 60 * 60 * 1000;
 
 /**
- * 内置种子表：input（缓存未命中）/ cacheRead（缓存命中）/ output 均为
- * [高峰, 空闲] 二元组；cacheWrite 为常量 0。
- * 只用于两处：首次运行生成 pricing.json（lib/pricing-store.js），以及"价格表缺失/
- * 损坏且官方页也拿不到"时的最后兜底；正常运行时都会被 file / remote 层覆盖。
+ * 价格表：input（缓存未命中）/ cacheRead（缓存命中）/ output 均为 [高峰, 空闲]
+ * 二元组；cacheWrite 为常量 0。官方改价时更新本表并发布新版本。
  */
 const PRICE_TABLE = {
   'deepseek-flash': { input: [2, 1], cacheRead: [0.04, 0.02], cacheWrite: 0, output: [8, 4] },
@@ -57,17 +50,6 @@ export const MODEL_ALIASES = {
   'deepseek-v4-flash-vision-exp': 'deepseek-flash',
 };
 
-/** 远端官方价格（setRemotePrices 注入，按模型覆盖种子表；key 与种子一致）。 */
-let remoteTable = null;
-/** 远端同步元信息（解析策略 / 抓取时间 / 来源），供界面展示同步状态。 */
-let remoteMeta = null;
-/** 本地价格配置表（setFilePrices 注入；重启后由它接管，见 lib/pricing-store.js）。 */
-let fileTable = null;
-/** 本地价格表元信息（路径 / 上次写入时间 / 来源）。 */
-let fileMeta = null;
-/** 本地价格表里的模型别名（旧名 → 现名），与内置 MODEL_ALIASES 合并使用。 */
-let fileAliases = {};
-
 /** 默认模型（当 agentDefaultModel 不可用时的展示默认）。 */
 export const DEFAULT_MODEL = 'deepseek-flash';
 
@@ -76,18 +58,67 @@ export const PEAK_WINDOWS = [[9, 12], [14, 18]];
 /** 官方口径：高峰仅限周一至周五（北京时间），周末整天为空闲时段。 */
 export const PEAK_WEEKDAYS_ONLY = true;
 /** 高峰时段展示文案（中文）。 */
-export const PEAK_HOURS_TEXT = '周一至周五 9:00–12:00、14:00–18:00（北京时间）';
+export const PEAK_HOURS_TEXT = '周一至周五（不含法定节假日）9:00–12:00、14:00–18:00（北京时间）';
 /** 高峰时段展示文案（英文）。 */
-export const PEAK_HOURS_TEXT_EN = 'Mon–Fri 9:00–12:00, 14:00–18:00 (Beijing Time)';
+export const PEAK_HOURS_TEXT_EN = 'Mon–Fri (excluding public holidays) 9:00–12:00, 14:00–18:00 (Beijing Time)';
+
+/**
+ * 中国法定节假日放假日期（含起止，闭区间；北京时间的日历日）。
+ * 来源：国务院办公厅《关于 2026 年部分节假日安排的通知》（国办发明电〔2025〕7号）。
+ * 官方口径：法定节假日全天、调休上班的周末均为空闲时段——周末本来就空闲，所以
+ * 只需列"放假日期"，落在工作日里的那几天才会把判定从高峰翻成空闲。
+ * 下一年的安排通常在前一年 11 月发布，届时更新本表；当前年份未收录时由
+ * lib/index.js 在启动时告警（见 hasHolidayYear）。
+ */
+export const HOLIDAY_RANGES = [
+  ['2026-01-01', '2026-01-03'], // 元旦
+  ['2026-02-15', '2026-02-23'], // 春节
+  ['2026-04-04', '2026-04-06'], // 清明节
+  ['2026-05-01', '2026-05-05'], // 劳动节
+  ['2026-06-19', '2026-06-21'], // 端午节
+  ['2026-09-25', '2026-09-27'], // 中秋节
+  ['2026-10-01', '2026-10-07'], // 国庆节
+];
+
+/** 把 [起, 止] 闭区间展开成日期键集合（`yyyy-mm-dd`，O(1) 查表）。 */
+function expandHolidayRanges(ranges) {
+  const set = new Set();
+  const DAY = 24 * 60 * 60 * 1000;
+  for (const [from, to] of ranges) {
+    const start = Date.parse(`${from}T00:00:00Z`);
+    const end = Date.parse(`${to}T00:00:00Z`);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) continue;
+    for (let t = start; t <= end; t += DAY) set.add(new Date(t).toISOString().slice(0, 10));
+  }
+  return set;
+}
+
+const HOLIDAY_DAYS = expandHolidayRanges(HOLIDAY_RANGES);
 
-/** 某时刻的北京时间小时（0–23）。 */
-export function shanghaiHour(ms) {
-  return new Date(ms + SHANGHAI_OFFSET_MS).getUTCHours();
+/** 某时刻的北京时间日期键（`yyyy-mm-dd`）。 */
+export function beijingDateKey(ms) {
+  return new Date(ms + SHANGHAI_OFFSET_MS).toISOString().slice(0, 10);
 }
 
-/** 某时刻是否为高峰时段（按北京时间；周末非工作日恒为空闲）。 */
+/** 该时刻所在的北京时间日历日是否为中国法定节假日（放假日期）。 */
+export function isHoliday(ms) {
+  return HOLIDAY_DAYS.has(beijingDateKey(ms));
+}
+
+/** 是否收录了某一年（北京时间年份）的节假日安排；未收录时界面可能把节假日当高峰。 */
+export function hasHolidayYear(year) {
+  const prefix = `${year}-`;
+  for (const day of HOLIDAY_DAYS) {
+    if (day.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+/** 某时刻是否为高峰时段（按北京时间；法定节假日全天与周末恒为空闲）。 */
 export function isPeak(ms) {
-  const d = new Date(ms + SHANGHAI_OFFSET_MS);
+  const now = Number.isFinite(ms) ? ms : Date.now();
+  if (isHoliday(now)) return false; // 法定节假日：全天空闲
+  const d = new Date(now + SHANGHAI_OFFSET_MS);
   if (PEAK_WEEKDAYS_ONLY) {
     const dow = d.getUTCDay(); // 0 = 周日
     if (dow === 0 || dow === 6) return false;
@@ -106,9 +137,10 @@ export function isPeak(ms) {
  *   · 周五 18:00 之后、整个周末 → 下一次切换是下周一 09:00（跨 2 天多）。
  * 因此倒计时必须能显示「天」。
  *
- * 实现：逐分钟向前探测（上限 8 天），纯算术，无时区/日历依赖。
- * 任何口径变更必须同时改 isPeak / PEAK_WINDOWS / PEAK_WEEKDAYS_ONLY，以及
- * lib/client.js 里为浏览器侧镜像的同名常量（那边无法 import 本模块）。
+ * 实现：逐分钟向前探测（上限 16 天：覆盖春节这类"长假最后一天 18:00 → 假期后
+ * 第一个工作日 09:00"的最长空档，2026 年春节为 10 天半）。纯算术，无时区/日历依赖。
+ * 任何口径变更必须同时改 isPeak / PEAK_WINDOWS / PEAK_WEEKDAYS_ONLY / HOLIDAY_RANGES，
+ * 以及 lib/client.js 里为浏览器侧镜像的同名常量（那边无法 import 本模块）。
  *
  * @returns {{ peak: boolean, at: number, ms: number }} peak=切换后所处的时段，
  *   at=切换发生的时刻（ms 时间戳，新时段在此刻生效），ms=剩余毫秒（不会为负）。
@@ -116,8 +148,8 @@ export function isPeak(ms) {
 export function nextChange(ms) {
   const now = Number.isFinite(ms) ? ms : Date.now();
   const current = isPeak(now);
-  // 逐分钟探测（上限 8 天：覆盖"周五晚 → 下周一早"的最长空档）
-  for (let step = 1; step <= 8 * 24 * 60; step += 1) {
+  // 逐分钟探测（上限 16 天：覆盖"春节长假 → 假期后首个工作日早晨"的最长空档）
+  for (let step = 1; step <= 16 * 24 * 60; step += 1) {
     const at = now + step * 60 * 1000;
     const peak = isPeak(at);
     if (peak !== current) return { peak, at, ms: Math.max(0, at - now) };
@@ -126,73 +158,6 @@ export function nextChange(ms) {
   return { peak: !current, at: now, ms: 0 };
 }
 
-/** 清洗一张价格表（形状校验 + 档位回退），供 remote / file 两层共用。 */
-function cleanTable(table) {
-  if (!table || typeof table !== 'object') return null;
-  const okPair = (v) => Array.isArray(v) && v.length === 2 && v.every((n) => Number.isFinite(n) && n >= 0);
-  const clean = {};
-  for (const [id, e] of Object.entries(table)) {
-    if (typeof id !== 'string' || id === '' || !e || typeof e !== 'object') continue;
-    const input = okPair(e.input) ? e.input : null;
-    if (!input) continue;
-    clean[id] = {
-      input,
-      cacheRead: okPair(e.cacheRead) ? e.cacheRead : input,
-      cacheWrite: 0,
-      output: okPair(e.output) ? e.output : input,
-    };
-  }
-  return Object.keys(clean).length > 0 ? clean : null;
-}
-
-/** 注入远端官方价格（parseOfficialPrices 的结果）；传 null/空表即清除回下一层。 */
-export function setRemotePrices(table, meta) {
-  remoteTable = cleanTable(table);
-  remoteMeta = remoteTable && meta && typeof meta === 'object' ? { ...meta } : null;
-}
-
-/** 远端同步元信息（未同步/同步失败时为 null）。 */
-export function remotePriceMeta() {
-  return remoteMeta ? { ...remoteMeta } : null;
-}
-
-/** 远端价格表是否可用。 */
-export function hasRemotePrices() {
-  return remoteTable !== null;
-}
-
-/**
- * 注入本地价格配置表（lib/pricing-store.js 的读取结果）。
- * @param table 模型映射（models 字段）
- * @param meta 元信息（path / updatedAt / source / strategy / autoUpdate）
- * @param aliases 文件里的模型别名（旧名 → 现名），与内置 MODEL_ALIASES 合并
- */
-export function setFilePrices(table, meta, aliases) {
-  fileTable = cleanTable(table);
-  fileMeta = fileTable && meta && typeof meta === 'object' ? { ...meta } : null;
-  fileAliases = aliases && typeof aliases === 'object' && !Array.isArray(aliases) ? { ...aliases } : {};
-}
-
-/** 本地价格表元信息（未载入时为 null）。 */
-export function filePriceMeta() {
-  return fileMeta ? { ...fileMeta } : null;
-}
-
-/** 本地价格表是否可用。 */
-export function hasFilePrices() {
-  return fileTable !== null;
-}
-
-/** 内置种子价格表快照（深拷贝；用于首次运行生成 pricing.json）。 */
-export function seedPrices() {
-  return JSON.parse(JSON.stringify(PRICE_TABLE));
-}
-
-/** 内置模型改名映射快照（用于首次运行生成 pricing.json）。 */
-export function seedAliases() {
-  return { ...MODEL_ALIASES };
-}
-
 /** 模型家族名（用于官方改名后的兜底匹配）。 */
 function familyOf(id) {
   const m = /(flash|pro|chat|reasoner)/.exec(id);
@@ -201,51 +166,38 @@ function familyOf(id) {
 
 const has = (obj, key) => !!obj && Object.prototype.hasOwnProperty.call(obj, key);
 
-/** 别名（旧名 → 现名）：本地价格表的 aliases 覆盖内置 MODEL_ALIASES。 */
+/** 别名（旧名 → 现名）。 */
 function aliasOf(id) {
   if (typeof id !== 'string' || id === '') return undefined;
-  return has(fileAliases, id) ? fileAliases[id] : MODEL_ALIASES[id];
+  return MODEL_ALIASES[id];
 }
 
-/** 在某一层价格表里找模型：精确 → 别名 → 同家族唯一匹配。 */
-function layerLookup(table, tag, id) {
-  if (!table || typeof id !== 'string' || id === '') return null;
-  if (has(table, id)) return { id, via: tag };
+/** 在价格表里找模型：精确 → 别名 → 同家族唯一匹配。 */
+function lookupId(id) {
+  if (typeof id !== 'string' || id === '') return null;
+  if (has(PRICE_TABLE, id)) return { id, via: 'exact' };
   const alias = aliasOf(id);
-  if (alias && has(table, alias)) return { id: alias, via: `${tag}-alias` };
+  if (alias && has(PRICE_TABLE, alias)) return { id: alias, via: 'alias' };
   const fam = familyOf(id);
   if (fam) {
-    const hits = Object.keys(table).filter((k) => familyOf(k) === fam);
+    const hits = Object.keys(PRICE_TABLE).filter((k) => familyOf(k) === fam);
     // 仅在家族唯一时匹配，避免把 flash 档算成 pro 档。
-    if (hits.length === 1) return { id: hits[0], via: `${tag}-family` };
+    if (hits.length === 1) return { id: hits[0], via: 'family' };
   }
   return null;
 }
 
 /**
- * 解析模型的计价条目（优先级：remote → file → seed → chat 兜底）。
- * @returns {{ price: object, id: string, via: 'remote'|'remote-alias'|'remote-family'|'file'|'file-alias'|'file-family'|'alias'|'seed'|'fallback', source: 'remote'|'file'|'seed', known: boolean }}
+ * 解析模型的计价条目：精确 → 别名 → 同家族唯一匹配 → chat 档兜底。
+ * @returns {{ price: object, id: string, via: 'exact'|'alias'|'family'|'fallback', known: boolean }}
  */
 function lookup(model) {
-  const remote = layerLookup(remoteTable, 'remote', model);
-  if (remote) return { price: remoteTable[remote.id], id: remote.id, via: remote.via, source: 'remote', known: true };
-
-  // 进程重启后 remote 层为空 → 先用本地价格表（上次同步到的官方价 / 用户手改价）。
-  const file = layerLookup(fileTable, 'file', model);
-  if (file) return { price: fileTable[file.id], id: file.id, via: file.via, source: 'file', known: true };
-
-  // 本地表也没有（首次运行、文件损坏、或模型确实不在表里）→ 内置种子兜底。
-  const alias = aliasOf(model);
-  if (alias && has(PRICE_TABLE, alias)) {
-    return { price: PRICE_TABLE[alias], id: alias, via: 'alias', source: 'seed', known: true };
-  }
-  if (has(PRICE_TABLE, model)) {
-    return { price: PRICE_TABLE[model], id: model, via: 'seed', source: 'seed', known: true };
-  }
-  return { price: PRICE_TABLE['deepseek-chat'], id: 'deepseek-chat', via: 'fallback', source: 'seed', known: false };
+  const found = lookupId(model);
+  if (found) return { price: PRICE_TABLE[found.id], id: found.id, via: found.via, known: true };
+  return { price: PRICE_TABLE['deepseek-chat'], id: 'deepseek-chat', via: 'fallback', known: false };
 }
 
-/** 模型是否能解析出价格（远端精确/别名/家族，或本地表/内置表）。 */
+/** 模型是否能解析出价格（内置表精确命中 / 别名 / 家族匹配）。 */
 export function isKnownModel(model) {
   return lookup(model).known;
 }
@@ -253,9 +205,7 @@ export function isKnownModel(model) {
 /**
  * 某模型在某一时刻的单位价格（元/百万 tokens）。
  * 未知模型回退 chat 档；known=false 供调用方提示，避免静默算错。
- * via 说明取价路径，source 说明价格来自哪一层（remote 官方页本次同步 / file 本地价格表 /
- * seed 内置兜底）；layerAt 是该层数据的时间戳（remote.fetchedAt / file.updatedAt），
- * 供界面说明"这份价是什么时候同步的"。
+ * via 说明取价路径（exact / alias / family / fallback），供排查与回归测试。
  */
 export function unitAt(model, ms) {
   const found = lookup(model);
@@ -270,12 +220,5 @@ export function unitAt(model, ms) {
     requested: typeof model === 'string' ? model : '',
     known: found.known,
     via: found.via,
-    source: found.source,
-    layerAt:
-      found.source === 'remote'
-        ? (remoteMeta && Number.isFinite(remoteMeta.fetchedAt) ? remoteMeta.fetchedAt : null)
-        : found.source === 'file'
-          ? (fileMeta && Number.isFinite(fileMeta.updatedAt) ? fileMeta.updatedAt : null)
-          : null,
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougen/dsh-deepseek-usage",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "DeepSeek 余额侧边栏插件：余额（官方 API）、当前档单价与峰谷时段指示灯，支持中/英文界面。",
   "type": "module",
   "main": "lib/index.js",
@@ -13,8 +13,7 @@
     "url": "https://github.com/dougen/dsh-deepseek-usage/issues"
   },
   "scripts": {
-    "test": "node --test test/",
-    "check:pricing": "node lib/pricing-remote.js --check"
+    "test": "node --test test/"
   },
   "files": [
     "lib",