balance-dsh 2.0.1 → 2.0.3

package/lib/index.js

@@ -118,28 +118,210 @@ const CN_CALENDAR = {
 
 // 节假日自动补录：内置表仅作**离线兜底**，运行时从社区维护的源拉取（其 papers 字段直接引用国务院公告）。
 // 源不可用/无网络/被 CSP 拦截时静默失败，继续用内置表；拉取结果按日期覆盖同键条目。
-const CN_CALENDAR_SOURCE = "https://cdn.jsdelivr.net/gh/NateScarlet/holiday-cn@master";
+// 节假日数据源（同一份数据、多个 CDN）。实测 cdn.jsdelivr.net 在国内经常连不上，
+// fastly / gcore 那两个镜像反而稳定，所以按「先快后慢、逐个回退」排序，
+// 任何一个能通就够 —— 这也让插件在某个 CDN 挂掉之后仍然能自己更新。
+const CN_CALENDAR_SOURCES = [
+  "https://fastly.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+  "https://gcore.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+  "https://raw.githubusercontent.com/NateScarlet/holiday-cn/master",
+  "https://cdn.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+];
+const CN_CALENDAR_SOURCE = CN_CALENDAR_SOURCES[0]; // 兼容旧引用
+const HOLIDAYS_FILENAME = "balance-holidays.json";
+/** 缓存有效期：超过这个天数就在启动时后台重拉一次（用户什么都不用做）。 */
+const CALENDAR_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const cnCalendarYears = new Set();
+// 已同步的节假日数据。days = 「YYYY-MM-DD」→ holiday / workday，
+// 落盘到 <dshHome>/balance-holidays.json —— 重启后直接用缓存，断网也不退化成内置表。
+// missing = 连上了但还没有数据的年份（典型：国务院还没发次年的放假安排）。
+// 这些年份**不受 30 天 TTL 约束**：缓存再新鲜也每次启动补试一次，
+// 否则在「11 月发了次年公告、但上次同步刚好锁住 30 天」这个窗口里会白等一个月。
+const cnCalendarState = { days: {}, fetchedAt: 0, years: [], missing: [], file: "", source: "" };
+
+/** 节假日缓存文件路径（空串 = 定位不到 home，缓存功能静默降级为纯内存）。 */
+function holidaysFilePath(ctx) {
+  const home = dshHomeDir(ctx);
+  if (home === "") return "";
+  const sep = home.includes("\\") && !home.includes("/") ? "\\" : "/";
+  return home.replace(/[\\/]+$/, "") + sep + HOLIDAYS_FILENAME;
+}
 
-/** 拉取指定年份的节假日安排并合并进 CN_CALENDAR（幂等；失败静默，不阻塞调用方）。 */
-async function ensureCnCalendar(year) {
-  if (cnCalendarYears.has(year)) return;
-  cnCalendarYears.add(year); // 先占位，避免并发重复请求
+/** 拉取单年节假日并合并进 CN_CALENDAR / cnCalendarState；返回条数，失败返回 -1。
+ *  逐个试 CN_CALENDAR_SOURCES：某个 CDN 挂掉就换下一个，全挂才算失败。 */
+async function fetchCalendarYear(year) {
+  for (const base of CN_CALENDAR_SOURCES) {
+    try {
+      const res = await fetch(base + "/" + year + ".json", { signal: AbortSignal.timeout(6000) });
+      if (!res.ok) continue;
+      const data = await res.json();
+      if (!Array.isArray(data?.days)) continue;
+      let count = 0;
+      for (const item of data.days) {
+        if (item && typeof item.date === "string" && typeof item.isOffDay === "boolean") {
+          const kind = item.isOffDay ? "holiday" : "workday";
+          CN_CALENDAR[item.date] = kind;
+          cnCalendarState.days[item.date] = kind;
+          count += 1;
+        }
+      }
+      cnCalendarState.source = base;
+      return count;
+    } catch {
+      // 这个源连不上：换下一个
+    }
+  }
+  return -1;
+}
+
+/** 读本地缓存（启动时调一次）。文件不存在 / 损坏一律当「没有缓存」。 */
+async function loadCalendarCache(ctx) {
+  cnCalendarState.file = holidaysFilePath(ctx);
+  if (cnCalendarState.file === "") return false;
   try {
-    const res = await fetch(CN_CALENDAR_SOURCE + "/" + year + ".json", { signal: AbortSignal.timeout(8000) });
-    if (!res.ok) return;
-    const data = await res.json();
-    if (!Array.isArray(data?.days)) return;
-    for (const item of data.days) {
-      if (item && typeof item.date === "string" && typeof item.isOffDay === "boolean") {
-        CN_CALENDAR[item.date] = item.isOffDay ? "holiday" : "workday";
+    const { readFile } = await import("node:fs/promises");
+    const parsed = JSON.parse(await readFile(cnCalendarState.file, "utf8"));
+    const days = parsed && typeof parsed === "object" && parsed.days && typeof parsed.days === "object" ? parsed.days : null;
+    if (days === null) return false;
+    let count = 0;
+    for (const [date, kind] of Object.entries(days)) {
+      if (typeof date === "string" && (kind === "holiday" || kind === "workday")) {
+        CN_CALENDAR[date] = kind;
+        cnCalendarState.days[date] = kind;
+        count += 1;
       }
     }
+    cnCalendarState.fetchedAt = Number(parsed.fetchedAt) || 0;
+    if (typeof parsed.source === "string") cnCalendarState.source = parsed.source;
+    cnCalendarState.years = Array.isArray(parsed.years)
+      ? parsed.years.map((y) => Number(y)).filter((y) => Number.isFinite(y)).sort()
+      : [];
+    cnCalendarState.missing = Array.isArray(parsed.missing)
+      ? parsed.missing.map((y) => Number(y)).filter((y) => Number.isFinite(y)).sort()
+      : [];
+    return count > 0;
+  } catch {
+    return false;
+  }
+}
+
+/** 写本地缓存：先写 .tmp 再 rename，避免写一半把文件写坏。 */
+async function saveCalendarCache() {
+  const file = cnCalendarState.file;
+  if (file === "") return false;
+  try {
+    const { mkdir, writeFile, rename } = await import("node:fs/promises");
+    const { dirname } = await import("node:path");
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = file + ".tmp";
+    const payload = {
+      fetchedAt: cnCalendarState.fetchedAt,
+      years: cnCalendarState.years,
+      missing: cnCalendarState.missing,
+      source: cnCalendarState.source || CN_CALENDAR_SOURCE,
+      days: cnCalendarState.days,
+    };
+    await writeFile(tmp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    await rename(tmp, file);
+    return true;
   } catch {
-    // 网络不可用：保留内置表（该年调休会退化为「周末全天空闲」）
+    return false;
   }
 }
 
+/** 当前节假日数据状态（GET /balance-api?calendar=1 直接返回它）。 */
+function calendarStatus() {
+  return {
+    fetchedAt: cnCalendarState.fetchedAt,
+    years: cnCalendarState.years.slice(),
+    missing: cnCalendarState.missing.slice(),
+    count: Object.keys(cnCalendarState.days).length,
+    source: cnCalendarState.source || CN_CALENDAR_SOURCE,
+    days: cnCalendarState.days,
+    ttlDays: Math.round(CALENDAR_TTL_MS / 86400000),
+  };
+}
+
+/** 同步当年 ±1 年（覆盖 90 天统计窗口与跨年场景）。
+ *  force=false 且缓存新鲜、且没有缺数据的年份时，完全跳过网络；
+ *  缓存新鲜但有 missing（如次年安排还没发布），只补拉那几个年份。 */
+async function refreshCnCalendar(ctx, force) {
+  // 兜底：正常路径是 apply 里先 loadCalendarCache 把 file 填好；
+  // 但只要有人直接点「立即同步」而这个状态还没初始化，这里也得能落盘。
+  if (cnCalendarState.file === "") cnCalendarState.file = holidaysFilePath(ctx);
+  const fresh = cnCalendarState.fetchedAt > 0 && Date.now() - cnCalendarState.fetchedAt < CALENDAR_TTL_MS;
+  const stale = force || !fresh;
+  if (!stale && cnCalendarState.missing.length === 0) {
+    return { ok: true, skipped: true, ...calendarStatus() };
+  }
+  const y = new Date(Date.now() + 8 * 60 * 60 * 1000).getUTCFullYear();
+  // 只缺某几年 → 只补拉那几年，不要把已有数据的年份再拉一遍
+  const targets = stale ? [y - 1, y, y + 1] : cnCalendarState.missing.slice();
+  const done = [];
+  const failed = [];
+  const stillMissing = [];
+  let added = 0;
+  for (const year of targets) {
+    const n = await fetchCalendarYear(year);
+    if (n > 0) {
+      added += n;
+      done.push(year);
+      cnCalendarYears.add(year);
+    } else if (n === 0) {
+      // 连上了、但这一年还没数据（次年放假安排尚未公布）——不是失败，但要继续补试
+      stillMissing.push(year);
+    } else {
+      failed.push(year);
+    }
+  }
+  // 已拿到数据的年份从 missing 里摘掉；「连上了但没数据」的补进去（保持升序去重）。
+  // 注意「连不上」（n < 0）不算 missing —— 那是网络问题，交给 30 天 TTL 兜，
+  // 否则断网用户每次启动都会去拉三年、白白等超时。
+  //
+  // 下限 y-1：放假安排必然在当年之前公布，比 y-1 还早却还「缺」的年份不可能是
+  // 「待公布」，只可能是历史残留（例如插件停用两年后重新打开，那几年再也不会
+  // 被 targets 命中，会一直留着）。这类年份直接丢弃，否则设置页会永久显示
+  // 「2025 待公布」这种荒谬文本。上限不需要管：y+1 就是 target 的上界。
+  const floorYear = y - 1;
+  const kept = cnCalendarState.missing.filter((year) => year >= floorYear && !done.includes(year));
+  cnCalendarState.missing = [...new Set([...kept, ...stillMissing])].sort((x, z) => x - z);
+  if (done.length === 0 && failed.length > 0 && !stale) {
+    // 只补拉 missing 且全部连不上：保持原样，不动 fetchedAt（避免把数据「洗新」）
+    await saveCalendarCache();
+    return { ok: false, error: "连不上节假日数据源，继续使用本地数据。", failedYears: failed, ...calendarStatus() };
+  }
+  if (done.length === 0 && stillMissing.length > 0) {
+    // 连上了但确实还没公布（例如次年安排还没发）——不算错误，静默保持
+    await saveCalendarCache();
+    return { ok: true, pending: stillMissing, added: 0, ...calendarStatus() };
+  }
+  if (done.length === 0) {
+    return {
+      ok: false,
+      error: "连不上节假日数据源，继续使用本地数据。",
+      failedYears: failed,
+      ...calendarStatus(),
+    };
+  }
+  cnCalendarState.fetchedAt = Date.now();
+  cnCalendarState.years = [...new Set([...cnCalendarState.years, ...done])].sort((x, z) => x - z);
+  await saveCalendarCache();
+  return { ok: true, added, years: done, failedYears: failed, pending: cnCalendarState.missing.slice(), ...calendarStatus() };
+}
+
+/** 拉取指定年份（保留旧入口）：内部走 fetchCalendarYear，成功后落盘。 */
+async function ensureCnCalendar(year) {
+  if (cnCalendarYears.has(year)) return;
+  cnCalendarYears.add(year); // 先占位，避免并发重复请求
+  const n = await fetchCalendarYear(year);
+  if (n < 0) return;
+  if (!cnCalendarState.years.includes(year)) {
+    cnCalendarState.years = [...cnCalendarState.years, year].sort((x, z) => x - z);
+  }
+  if (cnCalendarState.fetchedAt === 0) cnCalendarState.fetchedAt = Date.now();
+  void saveCalendarCache();
+}
+
 /** 北京时区日期键 YYYY-MM-DD（传入已 +8h 偏移的 Date）。 */
 function cnDateKey(d) {
   return d.getUTCFullYear() + "-" + String(d.getUTCMonth() + 1).padStart(2, "0") + "-" + String(d.getUTCDate()).padStart(2, "0");
@@ -345,7 +527,7 @@ function formatBalance(balance) {
 //                          | { status:"failed" }  （网络失败；官方明确“失败绝不变成 0 余额”）
 // client 是 AccountClientMetadata（version / locale / timezoneOffsetSeconds），
 // 缺字段会在平台侧组装请求头时抛错，所以三个字段都要给。
-const PLUGIN_VERSION = "2.0.1";
+const PLUGIN_VERSION = "2.0.3";
 
 // ─── 检查更新 ───────────────────────────────────────────────────────────────
 // 只查 npm registry 的 latest 标签（一个很小的 JSON），不下载任何东西。
@@ -354,10 +536,195 @@ const UPDATE_CACHE_MS = 10 * 60 * 1000;
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/balance-dsh/latest";
 let updateCache = { at: 0, value: null };
 
+/** 语义化版本比较：a > b 返回正、相等返回 0、a < b 返回负。
+ *  只比三段数字（忽略预发布后缀），够用来判断「npm 上的是不是比本地新」。 */
+function compareVersion(a, b) {
+  const parse = (v) =>
+    String(v ?? "")
+      .trim()
+      .replace(/^v/i, "")
+      .split("-")[0]
+      .split(".")
+      .map((x) => parseInt(x, 10) || 0);
+  const x = parse(a);
+  const y = parse(b);
+  for (let i = 0; i < Math.max(x.length, y.length); i += 1) {
+    const d = (x[i] ?? 0) - (y[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+/** 本插件的安装根目录（.../node_modules/balance-dsh），由 import.meta.url 反推。
+ *  定位不到返回空串（调用方报错，不动任何文件）。 */
+async function installedPluginDir() {
+  try {
+    const { fileURLToPath } = await import("node:url");
+    const { dirname } = await import("node:path");
+    // .../node_modules/balance-dsh/lib/index.js → 上两级就是包根
+    return dirname(dirname(fileURLToPath(import.meta.url)));
+  } catch {
+    return "";
+  }
+}
+
+/** 极简 tar.gz 解包：只取普通文件、去掉 npm 固定的 package/ 前缀，返回 [{ rel, data }]。
+ *  不处理符号链接（npm 包是禁掉 symlink 的）与 ustar 长文件名（本包路径都很短）。 */
+async function extractPackageFiles(gz) {
+  const { gunzipSync } = await import("node:zlib");
+  const tar = gunzipSync(gz);
+  const files = [];
+  let off = 0;
+  while (off + 512 <= tar.length) {
+    const header = tar.subarray(off, off + 512);
+    // 尾部是全零块，遇到就结束
+    let allZero = true;
+    for (let i = 0; i < 512; i += 1) {
+      if (header[i] !== 0) {
+        allZero = false;
+        break;
+      }
+    }
+    if (allZero) break;
+    const name = header.toString("utf8", 0, 100).replace(/\0.*$/, "");
+    const size = parseInt(header.toString("utf8", 124, 136).replace(/\0.*$/, "").trim(), 8) || 0;
+    const typeFlag = header.toString("utf8", 156, 157);
+    // "0" / "" / NUL = 普通文件；"5" = 目录，"2" = 符号链接，都跳过
+    const isFile = typeFlag === "0" || typeFlag === "" || typeFlag === "\0";
+    if (isFile && size > 0 && name !== "") {
+      const rel = name.startsWith("package/") ? name.slice("package/".length) : name;
+      if (rel !== "" && !rel.endsWith("/") && !rel.includes("..")) {
+        files.push({ rel, data: tar.subarray(off + 512, off + 512 + size) });
+      }
+    }
+    off += 512 + Math.ceil(size / 512) * 512;
+  }
+  return files;
+}
+
+/** tarball 地址（npm 的固定布局）。 */
+function updateTarballUrl(version) {
+  return "https://registry.npmjs.org/balance-dsh/-/balance-dsh-" + version + ".tgz";
+}
+
+/** 就地更新本插件：下载 npm 上的最新 tarball → 解包 → 逐文件覆盖自己的安装目录。
+ *
+ *  几个刻意的取舍：
+ *  - 只覆盖 tarball 里有的文件，不删任何东西。上游删掉的文件会残留，但残留无害，
+ *    比误删用户目录里的东西安全得多。
+ *  - 覆盖前把旧文件备份到 <dshHome>/balance-update-backup/<from>-<时间戳>/，可手工回滚。
+ *  - 逐个文件写、单个失败只记进 failed 不中断 —— 最典型的是 Windows 上 package.json
+ *    被 DSH 占着（之前同步时就踩过），但 lib/*.js 能写进去，功能不受影响。
+ *  - 覆盖后 lib/index.js 的改动**必须重启 DSH** 才生效：Node 不会热替换已加载的模块。
+ *    返回值里带 restart:true，让界面明确提示。
+ */
+async function installLatestVersion(ctx) {
+  const found = await fetchLatestVersion();
+  if (found.error) return { ok: false, error: found.error };
+  const latest = found.latest;
+  if (compareVersion(latest, PLUGIN_VERSION) <= 0) {
+    return { ok: true, installed: false, from: PLUGIN_VERSION, to: latest, note: "已是最新版本" };
+  }
+
+  const root = await installedPluginDir();
+  if (root === "") return { ok: false, error: "定位不到插件安装目录" };
+
+  let gz;
+  try {
+    const signal =
+      typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function"
+        ? AbortSignal.timeout(20000)
+        : undefined;
+    const res = await fetch(updateTarballUrl(latest), { signal });
+    if (!res || !res.ok) throw new Error("HTTP " + (res ? res.status : "?"));
+    gz = Buffer.from(await res.arrayBuffer());
+  } catch (error) {
+    return { ok: false, error: "下载 " + latest + " 失败：" + (error instanceof Error ? error.message : String(error)) };
+  }
+
+  let files;
+  try {
+    files = await extractPackageFiles(gz);
+  } catch (error) {
+    return { ok: false, error: "解包失败：" + (error instanceof Error ? error.message : String(error)) };
+  }
+  if (files.length === 0) return { ok: false, error: "下载到的包里没有文件" };
+
+  const { mkdir, writeFile, readFile, rename, unlink } = await import("node:fs/promises");
+  const { dirname, join, resolve, sep } = await import("node:path");
+
+  // 备份目录：拿不到 dshHome 就跳过备份（仍继续更新，失败项会体现在 failed 里）
+  const home = dshHomeDir(ctx);
+  const backupRoot =
+    home === "" ? "" : join(home, "balance-update-backup", PLUGIN_VERSION + "-" + Date.now());
+
+  const written = [];
+  const failed = [];
+  const rootAbs = resolve(root);
+  const rootPrefix = rootAbs.endsWith(sep) ? rootAbs : rootAbs + sep;
+
+  for (const file of files) {
+    const dst = resolve(rootAbs, file.rel);
+    // 防路径穿越：解析后必须仍在包目录里
+    if (!dst.startsWith(rootPrefix)) {
+      failed.push(file.rel + "（路径越界，已跳过）");
+      continue;
+    }
+    try {
+      if (backupRoot !== "") {
+        try {
+          const old = await readFile(dst);
+          const bak = join(backupRoot, file.rel);
+          await mkdir(dirname(bak), { recursive: true });
+          await writeFile(bak, old);
+        } catch {
+          // 旧文件不存在（新版本新增的文件）或不可读：没有可备份的，继续
+        }
+      }
+      await mkdir(dirname(dst), { recursive: true });
+      // 先写同目录临时文件再 rename：原子替换 + 断开硬链接（profile 里有些文件是
+      // pnpm 硬链接，直接 writeFile 会写进同一个 inode，可能污染 store / 其它 profile）。
+      const staging = dst + ".new-" + Date.now() + "-" + written.length;
+      try {
+        await writeFile(staging, file.data);
+        await rename(staging, dst);
+      } catch (error) {
+        try {
+          await unlink(staging);
+        } catch {
+          // 临时文件没建起来或已清理，忽略
+        }
+        throw error;
+      }
+      written.push(file.rel);
+    } catch (error) {
+      failed.push(file.rel + "：" + (error instanceof Error ? error.message : String(error)));
+    }
+  }
+
+  if (written.length === 0) {
+    return { ok: false, error: "没有文件写入成功：" + failed.join("；") };
+  }
+
+  // 缓存里的 latest 可能已经过时，更新完作废，下次检查重新问 registry
+  updateCache = { at: 0, value: null };
+
+  return {
+    ok: true,
+    installed: true,
+    from: PLUGIN_VERSION,
+    to: latest,
+    files: written.length,
+    failed,
+    backup: backupRoot,
+    restart: true,
+  };
+}
+
 /** 查 npm 上 balance-dsh 的最新版本。成功返回 { latest }，失败返回 { error }（失败不缓存，下次可重试）。 */
-async function fetchLatestVersion() {
+async function fetchLatestVersion(force) {
   const now = Date.now();
-  if (updateCache.value && now - updateCache.at < UPDATE_CACHE_MS) return updateCache.value;
+  if (!force && updateCache.value && now - updateCache.at < UPDATE_CACHE_MS) return updateCache.value;
   if (typeof fetch !== "function") return { error: "当前运行环境没有 fetch" };
   try {
     let signal;
@@ -693,6 +1060,10 @@ const DEFAULT_SETTINGS = {
   statsSessionLimit: STATS_MAX_SESSIONS, // 统计扫描的最近会话数
   statsCacheSec: 300, // 统计结果缓存秒数
   // 计费
+  // 高峰时段窗口。官方当前是「工作日北京 9-12、14-18」，但这条也是会变的
+  // （改了时段就等于改了哪几个小时翻倍）。写成文本而不是数组：输入框直接对应，
+  // 没有「数组 → 界面 → 数组」的转换损耗，用户手改也不会因为半截输入被弹回。
+  peakWindowsText: "9-12, 14-18",
   peakMultiplier: 2, // 高峰时段倍率
   priceFlash: null, // flash 覆盖价（元/百万 token），四项全填才生效
   pricePro: null, // v4-pro 覆盖价
@@ -729,6 +1100,38 @@ function normalizeNewTagSeen(raw) {
   return out;
 }
 
+/** 高峰窗口文本 → 数组。接受 "9-12, 14-18"、"9-12，14-18"、"9~12" 这几种写法。
+ *  逐段校验（0 ≤ start < end ≤ 24，整点），**任何一段不合法就整串作废返回 null** ——
+ *  宁可回退官方默认窗口，也不要拿半对半错的窗口去算钱。
+ *  end = 24 表示到当天结束（hour 最大 23，`hour < end` 覆盖 23:00-23:59）。 */
+function parsePeakWindowsText(text) {
+  if (typeof text !== "string") return null;
+  const out = [];
+  for (const chunk of text.split(/[,，;；]/)) {
+    const part = chunk.trim();
+    if (part === "") continue;
+    const m = part.match(/^(\d{1,2})\s*[-~到至]\s*(\d{1,2})$/);
+    if (!m) return null;
+    const start = Number(m[1]);
+    const end = Number(m[2]);
+    if (!Number.isInteger(start) || !Number.isInteger(end)) return null;
+    if (start < 0 || end > 24 || start >= end) return null;
+    out.push({ start, end });
+  }
+  return out.length > 0 ? out : null;
+}
+
+/** 高峰窗口文本的**类型清洗**（不校验语法）。
+ *  用户打到一半（"9-"）也要能存下来继续编辑，所以这里不判合法；
+ *  真正解析发生在 withSettings（服务端算钱）与客户端 currentPeriod（显示标签），
+ *  解析失败一律回退官方默认窗口 —— 计费永远不会因为一段烂文本而错。 */
+function normalizePeakWindowsText(raw, fallback) {
+  if (typeof raw !== "string") return fallback;
+  const text = raw.trim();
+  if (text === "") return fallback;
+  return text.slice(0, 80);
+}
+
 /** 一组覆盖价：逐个字段校验（有限非负数才收），不填的字段留空表示「用默认价」。
  *  四个字段都没填则整组丢弃（等价于不覆盖）。 */
 function normalizePriceOverride(raw) {
@@ -769,6 +1172,7 @@ function normalizeSettings(raw) {
     fabLeft: clampNumber(src.fabLeft, 0, 600, d.fabLeft),
     statsSessionLimit: clampNumber(src.statsSessionLimit, 10, 2000, d.statsSessionLimit),
     statsCacheSec: clampNumber(src.statsCacheSec, 0, 3600, d.statsCacheSec),
+    peakWindowsText: normalizePeakWindowsText(src.peakWindowsText, d.peakWindowsText),
     peakMultiplier: clampNumber(src.peakMultiplier, 1, 10, d.peakMultiplier),
     priceFlash: normalizePriceOverride(src.priceFlash),
     pricePro: normalizePriceOverride(src.pricePro),
@@ -784,6 +1188,9 @@ function withSettings(config, settings) {
   return {
     ...config,
     apiKey: s.apiKey !== "" ? s.apiKey : config?.apiKey,
+    // 设置里改的高峰窗口优先；文本解析不出来就回退官方默认窗口，
+    // 绝不能把 undefined 透给 isPeakAt（那会让 isPeakAt 自己再 fallback，语义重复）
+    peakWindows: parsePeakWindowsText(s.peakWindowsText) ?? DEFAULT_PEAK_WINDOWS,
     peakMultiplier: s.peakMultiplier,
     priceByModel,
     statsSessionLimit: s.statsSessionLimit,
@@ -791,9 +1198,9 @@ function withSettings(config, settings) {
   };
 }
 
-/** 设置文件路径：优先 DSH 自己的 home（dshHomePath 服务），再环境变量，最后 ~/.dsh。
- *  返回空串表示定位不到，此时读写一律静默降级为「用默认值、不落盘」。 */
-function settingsFilePath(ctx) {
+/** DSH 的 home 目录：优先 dshHomePath 服务，再环境变量，最后 ~/.dsh。
+ *  返回空串表示定位不到，此时设置读写与更新备份一律静默降级。 */
+function dshHomeDir(ctx) {
   let home = "";
   try {
     const svc = typeof ctx?.get === "function" ? ctx.get("dshHomePath") : null;
@@ -808,6 +1215,12 @@ function settingsFilePath(ctx) {
     const base = process.env.USERPROFILE || process.env.HOME || "";
     if (base !== "") home = `${base}${process.platform === "win32" ? "\\" : "/"}.dsh`;
   }
+  return home;
+}
+
+/** 设置文件路径。返回空串表示定位不到，此时读写一律静默降级为「用默认值、不落盘」。 */
+function settingsFilePath(ctx) {
+  const home = dshHomeDir(ctx);
   if (home === "") return "";
   const sep = home.includes("\\") && !home.includes("/") ? "\\" : "/";
   return `${home.replace(/[\\/]+$/, "")}${sep}${SETTINGS_FILENAME}`;
@@ -1423,14 +1836,17 @@ export function apply(ctx, config = {}) {
   // 时统一清理，保证重复 apply 不冲突。
   const disposers = [];
 
-  // 后台补录节假日数据（当年 ±1 年，覆盖 90 天统计窗口与跨年场景）。
-  // 故意不 await：拉取失败不能影响插件启动；isPeakAt 保持同步，未拉到时继续用内置表。
-  {
-    const y = new Date(Date.now() + 8 * 60 * 60 * 1000).getUTCFullYear();
-    void ensureCnCalendar(y - 1);
-    void ensureCnCalendar(y);
-    void ensureCnCalendar(y + 1);
-  }
+  // 节假日数据：先读本地缓存（这样断网、改过系统时间也照样按上次同步的结果算钱），
+  // 再看缓存是不是过期（默认 30 天），过期才去拉。故意不 await —— 网络慢不能拖住启动，
+  // isPeakAt 保持同步函数，缓存没到位时继续用内置表。
+  void (async () => {
+    try {
+      await loadCalendarCache(ctx);
+      await refreshCnCalendar(ctx, false);
+    } catch {
+      // 任何异常都只是「这次没更新」，不影响余额与计费
+    }
+  })();
 
   // 1) /balance 命令：保留命令行查询入口
   ctx.inject(["commands"], (commandCtx) => {
@@ -1502,12 +1918,9 @@ export function apply(ctx, config = {}) {
           }
           return;
         }
-        if (req.method !== "GET") {
-          writeJson(res, 405, { ok: false, error: "method not allowed" });
-          return;
-        }
-        // 检查更新：GET /balance-api?update=1 → 返回 npm 上的最新版本。
-        // 与余额无关，独立成一路，失败也不影响其它字段。
+        // 检查更新 / 就地更新：同一个参数，GET 查询、POST 安装。
+        // 它排在下面那道 405 之前 —— 这是除了设置写入之外唯一放开 POST 的入口，
+        // 且只认 ?update=1（其余非 GET 仍然 405）。
         let wantUpdate = false;
         try {
           wantUpdate = new URL(req.url, "http://localhost").searchParams.get("update") === "1";
@@ -1515,7 +1928,27 @@ export function apply(ctx, config = {}) {
           wantUpdate = false;
         }
         if (wantUpdate) {
-          const found = await fetchLatestVersion();
+          if (req.method === "POST") {
+            // POST → 下载 npm 上最新 tarball 覆盖本机安装（见 installLatestVersion）。
+            // 下载 + 逐文件写盘期间 await 会让出事件循环，不会卡住余额请求。
+            try {
+              const result = await installLatestVersion(httpCtx);
+              writeJson(res, 200, { current: PLUGIN_VERSION, ...result });
+            } catch (error) {
+              writeJson(res, 200, {
+                ok: false,
+                current: PLUGIN_VERSION,
+                error: error instanceof Error ? error.message : String(error),
+              });
+            }
+            return;
+          }
+          if (req.method !== "GET") {
+            writeJson(res, 405, { ok: false, error: "method not allowed" });
+            return;
+          }
+          // force：用户手动点「检查更新」时不走 10 分钟缓存，否则刚更新过会显示旧结果
+          const found = await fetchLatestVersion(true);
           if (found && found.error) {
             writeJson(res, 200, { ok: false, current: PLUGIN_VERSION, error: found.error });
           } else {
@@ -1523,6 +1956,38 @@ export function apply(ctx, config = {}) {
           }
           return;
         }
+        // 节假日数据：GET 读状态（含 days 明细，客户端据此与服务端同口径判断峰谷），
+        // POST 强制重新同步。和 update 一样排在下面那道 405 之前。
+        let wantCalendar = false;
+        try {
+          wantCalendar = new URL(req.url, "http://localhost").searchParams.get("calendar") === "1";
+        } catch {
+          wantCalendar = false;
+        }
+        if (wantCalendar) {
+          if (req.method === "POST") {
+            try {
+              writeJson(res, 200, await refreshCnCalendar(httpCtx, true));
+            } catch (error) {
+              writeJson(res, 200, {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+                ...calendarStatus(),
+              });
+            }
+            return;
+          }
+          if (req.method !== "GET") {
+            writeJson(res, 405, { ok: false, error: "method not allowed" });
+            return;
+          }
+          writeJson(res, 200, { ok: true, ...calendarStatus() });
+          return;
+        }
+        if (req.method !== "GET") {
+          writeJson(res, 405, { ok: false, error: "method not allowed" });
+          return;
+        }
         // 客户端把当前会话使用的模型通过 ?model= 传入，服务端按模型取价；
         // 可选 ?session= 传入会话 id，服务端返回该会话的分时段 usage（跨时段精确计费用）
         let model = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "balance-dsh",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "在 DeepSeek Harness 中显示 DeepSeek 账户余额和当前会话 token/费用消耗（含高峰/空闲峰谷计费）。仅支持 DeepSeek 官方模型与账号，暂不支持其他大模型。",
   "author": "Rannist",
   "type": "module",