hob-bot 1.3.0 → 1.5.0

package/server/src/store.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, appendFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { archiveAssistantsDir, assistantDir, assistantJobsDir } from "./config.ts";
 import { newId } from "./ids.ts";
 import type {
   Approval,
@@ -49,14 +50,19 @@ export interface AssistantState {
 
 /**
  * HOB_HOME 下的全部 JSON / JSONL 数据。文件都小，直接同步读写，写入走临时文件 + rename。
+ *
+ * v2 布局里任务和审批、定时都跟着所属助手放（assistants/<id>/jobs|approvals.json|routines.json），
+ * 进不到目录的地方要知道 jobId 落在哪个助手下面，所以这里维护一份内存索引，启动时扫一遍、
+ * 新建任务时登记；不存索引文件，免得和实际目录对不上。
  */
 export class Store {
+  /** jobId → 任务目录（含归档助手目录里的） */
+  private jobIndex: Map<string, string> | null = null;
+
   constructor(readonly home: string) {}
 
   init(): void {
-    for (const dir of ["assistants", "jobs", "uploads"]) {
-      mkdirSync(join(this.home, dir), { recursive: true });
-    }
+    mkdirSync(join(this.home, "assistants"), { recursive: true });
     if (!existsSync(join(this.home, "rules.json"))) {
       const changedAt = new Date().toISOString();
       this.saveGlobalRules([
@@ -80,7 +86,7 @@ export class Store {
 
   // ---------- 助手 ----------
   private assistantDir(id: string): string {
-    return join(this.home, "assistants", id);
+    return assistantDir(this.home, id);
   }
 
   assistants(): Assistant[] {
@@ -110,14 +116,16 @@ export class Store {
   }
 
   /**
-   * 归档助手：整个助手目录移进 archive/assistants/<id>-<时间>/。同盘 rename，不复制也不删数据，
-   * 归档里的 profile.json 就是它原来的档案；它的定时存成目录里的 routines.json。
+   * 归档助手：整个助手目录（含自己的任务、定时、审批、文件）移进 archive/assistants/<id>-<时间>/。
+   * 同盘 rename，不复制也不删数据。
    */
   archiveAssistant(id: string, name: string, routines: Routine[] = []): string {
     if (routines.length) writeJsonAtomic(join(this.assistantDir(id), "routines.json"), routines);
-    const target = join(this.home, "archive", "assistants", name);
+    const target = join(archiveAssistantsDir(this.home), name);
     mkdirSync(dirname(target), { recursive: true });
     renameSync(this.assistantDir(id), target);
+    // 任务跟着搬走了，索引要重建
+    this.jobIndex = null;
     return target;
   }
 
@@ -151,13 +159,45 @@ export class Store {
     appendFileSync(join(dir, "worklog.jsonl"), `${JSON.stringify(entry)}\n`);
   }
 
-  // ---------- 定时 ----------
-  private routinesFile(): string {
-    return join(this.home, "routines.json");
+  // ---------- 定时和审批：跟着所属助手 ----------
+  /** 每个助手目录下的一份记录文件（含归档目录里的），有就给路径。 */
+  private recordFiles(name: string, archived: boolean): string[] {
+    const out: string[] = [];
+    const live = join(this.home, "assistants");
+    if (existsSync(live)) {
+      for (const id of readdirSync(live)) {
+        const file = join(live, id, name);
+        if (existsSync(file)) out.push(file);
+      }
+    }
+    if (!archived) return out;
+    const root = archiveAssistantsDir(this.home);
+    if (existsSync(root)) {
+      for (const folder of readdirSync(root)) {
+        const file = join(root, folder, name);
+        if (existsSync(file)) out.push(file);
+      }
+    }
+    return out;
+  }
+
+  /** 写这个助手的记录文件：助手归档了就跟到归档目录，不然就地建。 */
+  private ownerFile(assistantId: string, name: string): string {
+    const live = this.assistantDir(assistantId);
+    if (existsSync(join(live, "profile.json"))) return join(live, name);
+    const root = archiveAssistantsDir(this.home);
+    if (existsSync(root)) {
+      for (const folder of readdirSync(root)) {
+        const dir = join(root, folder);
+        const profile = readJson<{ id?: unknown }>(join(dir, "profile.json"), {});
+        if (profile.id === assistantId) return join(dir, name);
+      }
+    }
+    return join(live, name);
   }
 
   routines(): Routine[] {
-    return readJson<Routine[]>(this.routinesFile(), []);
+    return this.recordFiles("routines.json", false).flatMap((file) => readJson<Routine[]>(file, []));
   }
 
   routine(id: string): Routine | undefined {
@@ -165,22 +205,29 @@ export class Store {
   }
 
   saveRoutine(routine: Routine): void {
-    const all = this.routines().filter((r) => r.id !== routine.id);
-    all.push(routine);
-    writeJsonAtomic(this.routinesFile(), all);
+    const target = this.ownerFile(routine.assistantId, "routines.json");
+    for (const file of this.recordFiles("routines.json", true)) {
+      const list = readJson<Routine[]>(file, []);
+      const next = list.filter((r) => r.id !== routine.id);
+      if (next.length !== list.length) writeJsonAtomic(file, next);
+    }
+    const list = readJson<Routine[]>(target, []).filter((r) => r.id !== routine.id);
+    list.push(routine);
+    writeJsonAtomic(target, list);
   }
 
+  /** 只从还在的助手里拿掉；归档目录里那份是历史，留着。 */
   deleteRoutine(id: string): void {
-    writeJsonAtomic(this.routinesFile(), this.routines().filter((r) => r.id !== id));
+    for (const file of this.recordFiles("routines.json", false)) {
+      const list = readJson<Routine[]>(file, []);
+      const next = list.filter((r) => r.id !== id);
+      if (next.length !== list.length) writeJsonAtomic(file, next);
+    }
   }
 
   // ---------- 审批 ----------
-  private approvalsFile(): string {
-    return join(this.home, "approvals.json");
-  }
-
   approvals(): Approval[] {
-    return readJson<Approval[]>(this.approvalsFile(), []);
+    return this.recordFiles("approvals.json", true).flatMap((file) => readJson<Approval[]>(file, []));
   }
 
   approval(id: string): Approval | undefined {
@@ -188,14 +235,24 @@ export class Store {
   }
 
   saveApproval(approval: Approval): void {
-    const all = this.approvals().filter((a) => a.id !== approval.id);
-    all.push(approval);
-    writeJsonAtomic(this.approvalsFile(), all);
+    const target = this.ownerFile(approval.assistantId, "approvals.json");
+    for (const file of this.recordFiles("approvals.json", true)) {
+      const list = readJson<Approval[]>(file, []);
+      const next = list.filter((a) => a.id !== approval.id);
+      if (next.length !== list.length) writeJsonAtomic(file, next);
+    }
+    const list = readJson<Approval[]>(target, []).filter((a) => a.id !== approval.id);
+    list.push(approval);
+    writeJsonAtomic(target, list);
   }
 
   // ---------- 委派 ----------
+  private hobFile(name: string): string {
+    return join(this.assistantDir("hob"), name);
+  }
+
   delegations(): Delegation[] {
-    return readJson<Delegation[]>(join(this.home, "delegations.json"), []);
+    return readJson<Delegation[]>(this.hobFile("delegations.json"), []);
   }
 
   delegation(id: string): Delegation | undefined {
@@ -205,16 +262,12 @@ export class Store {
   saveDelegation(delegation: Delegation): void {
     const all = this.delegations().filter((item) => item.id !== delegation.id);
     all.push(delegation);
-    writeJsonAtomic(join(this.home, "delegations.json"), all);
+    writeJsonAtomic(this.hobFile("delegations.json"), all);
   }
 
   // ---------- 草稿 ----------
-  private draftsFile(): string {
-    return join(this.home, "drafts.json");
-  }
-
   drafts(): Draft[] {
-    return readJson<Draft[]>(this.draftsFile(), []);
+    return readJson<Draft[]>(this.hobFile("drafts.json"), []);
   }
 
   draft(id: string): Draft | undefined {
@@ -224,31 +277,61 @@ export class Store {
   saveDraft(draft: Draft): void {
     const all = this.drafts().filter((d) => d.id !== draft.id);
     all.push(draft);
-    writeJsonAtomic(this.draftsFile(), all);
+    writeJsonAtomic(this.hobFile("drafts.json"), all);
   }
 
   // ---------- 任务 ----------
+  /** 所有任务目录的根：在的助手和归档的助手都算。 */
+  private jobRoots(): string[] {
+    const out: string[] = [];
+    const live = join(this.home, "assistants");
+    if (existsSync(live)) for (const id of readdirSync(live)) out.push(assistantJobsDir(this.home, id));
+    const archived = archiveAssistantsDir(this.home);
+    if (existsSync(archived)) for (const folder of readdirSync(archived)) out.push(join(archived, folder, "jobs"));
+    return out.filter((dir) => existsSync(dir));
+  }
+
+  private rebuildJobIndex(): Map<string, string> {
+    const index = new Map<string, string>();
+    for (const root of this.jobRoots()) {
+      for (const id of readdirSync(root).sort()) {
+        const dir = join(root, id);
+        if (existsSync(join(dir, "job.json"))) index.set(id, dir);
+      }
+    }
+    this.jobIndex = index;
+    return index;
+  }
+
+  private findJobDir(id: string): string | undefined {
+    const hit = (this.jobIndex ?? this.rebuildJobIndex()).get(id);
+    if (hit) return hit;
+    return this.rebuildJobIndex().get(id);
+  }
+
   jobDir(id: string): string {
-    return join(this.home, "jobs", id);
+    return this.findJobDir(id) ?? join(this.home, "assistants", "hob", "jobs", id);
   }
 
   jobs(): Job[] {
-    const root = join(this.home, "jobs");
-    if (!existsSync(root)) return [];
     const out: Job[] = [];
-    for (const id of readdirSync(root)) {
-      const job = readJson<Job | null>(join(root, id, "job.json"), null);
+    for (const dir of this.rebuildJobIndex().values()) {
+      const job = readJson<Job | null>(join(dir, "job.json"), null);
       if (job) out.push(job);
     }
     return out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
   }
 
   job(id: string): Job | undefined {
-    return readJson<Job | null>(join(this.jobDir(id), "job.json"), null) ?? undefined;
+    const dir = this.findJobDir(id);
+    return dir ? readJson<Job | null>(join(dir, "job.json"), null) ?? undefined : undefined;
   }
 
   saveJob(job: Job): void {
-    writeJsonAtomic(join(this.jobDir(job.id), "job.json"), job);
+    const dir = this.findJobDir(job.id) ?? join(assistantJobsDir(this.home, job.assistantId), job.id);
+    writeJsonAtomic(join(dir, "job.json"), job);
+    this.jobIndex ??= new Map();
+    this.jobIndex.set(job.id, dir);
   }
 
   writeReport(jobId: string, text: string): string {
@@ -285,10 +368,10 @@ export class Store {
    */
   migrateMemories(): void {
     type OldDraft = Draft & { memories?: string[]; carry: Draft["carry"] & { memories?: number } };
-    const drafts = readJson<OldDraft[]>(this.draftsFile(), []);
+    const drafts = readJson<OldDraft[]>(this.hobFile("drafts.json"), []);
     if (drafts.some((draft) => !Array.isArray(draft.instructions))) {
       writeJsonAtomic(
-        this.draftsFile(),
+        this.hobFile("drafts.json"),
         drafts.map(({ memories, carry: { memories: _carried, ...carry }, ...draft }) => ({
           ...draft,
           instructions: draft.instructions ?? memories ?? [],

package/server/src/transcript.ts

@@ -1,11 +1,22 @@
 // 任务过程（transcript）：从任务的 worker.jsonl 推导步骤列表，实时事件和落盘推导共用一套拼装。
 import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute } from "node:path";
 import { commandSummary } from "../../shared/command.ts";
 import type { JobStep } from "../../shared/types.ts";
 import { showPath } from "./text.ts";
 
 /** 沉淀技能那一轮发给任务的话的开头：任务详情里这句显示成「沉淀技能」。 */
-export const SEDIMENT_PROMPT_HEAD = "这件事以后还会再做。回顾刚才的过程，把能复用的做法沉淀成技能";
+export const SEDIMENT_PROMPT_HEAD = "回顾刚才的过程，看看有没有能复用的做法。这类事以后还会再做的，把做法写成技能";
+
+/** 旧版用过的开头：已经存下来的任务记录里还是这些，任务详情照样显示成「沉淀技能」。 */
+const LEGACY_SEDIMENT_HEADS = [
+  "这件事以后还会再做。回顾刚才的过程，把能复用的做法写成技能",
+  "这件事以后还会再做。回顾刚才的过程，把能复用的做法沉淀成技能",
+];
+
+function isSedimentPrompt(text: string): boolean {
+  return text.startsWith(SEDIMENT_PROMPT_HEAD) || LEGACY_SEDIMENT_HEADS.some((head) => text.startsWith(head));
+}
 
 /** transcript 里单步输出最多这么多字，超出的整段落盘，页面按路径去拉。 */
 export const STEP_OUTPUT_LIMIT = 20 * 1024;
@@ -14,7 +25,7 @@ export const STEP_EVENT_LIMIT = 4 * 1024;
 /** diff 只给看得清的一段，超长的改动不整段塞进接口。 */
 const EDIT_TEXT_LIMIT = 4_000;
 
-const AUTO_FOLLOW_UP = "你还没有调用 report";
+const AUTO_FOLLOW_UP = "这一轮结束了，还没有交结果。";
 
 function oneLine(value: string, max = 120): string {
   const line = value.replace(/\s+/g, " ").trim();
@@ -38,8 +49,10 @@ function clipEdit(edits: unknown): { oldText: string; newText: string }[] {
 }
 
 /** 只留详情页要看的那几个参数（write 的正文不整段传，只给长度）。 */
-export function toolArgs(name: string, raw: Record<string, unknown>, cwd = ""): Record<string, unknown> {
-  const path = showPath(String(raw.path ?? ""), cwd);
+export function toolArgs(name: string, raw: Record<string, unknown>, cwd = "", resolvePath?: (path: string) => string): Record<string, unknown> {
+  const given = String(raw.path ?? "");
+  // 迁移前写进会话的绝对路径先按 moves.json 换成新位置再和 cwd 比：老步骤照样显示成短文件名
+  const path = showPath(isAbsolute(given) && resolvePath ? resolvePath(given) : given, cwd);
   switch (name) {
     case "bash":
       return { command: String(raw.command ?? "") };
@@ -197,11 +210,13 @@ export interface ToolStepInput {
   running?: boolean;
   /** MCP 工具的显示名映射（转义后的服务名 → 配置里的原名） */
   mcpServers?: Record<string, string>;
+  /** 会话里的老绝对路径换到新位置（迁移后显示老步骤用） */
+  resolvePath?: (path: string) => string;
 }
 
 /** 一次工具调用 → 一个步骤（还没有结果）。实时事件和落盘推导都用它，页面按 id 合并。 */
 export function toolStep(input: ToolStepInput): JobStep {
-  const args = toolArgs(input.name, input.args, input.cwd ?? "");
+  const args = toolArgs(input.name, input.args, input.cwd ?? "", input.resolvePath);
   const mcp = mcpToolDisplay(input.name, input.mcpServers);
   return {
     id: input.id,
@@ -245,6 +260,8 @@ export interface DeriveOptions {
   save?: (stepId: string, text: string) => string;
   /** MCP 工具的显示名映射（转义后的服务名 → 配置里的原名） */
   mcpServers?: Record<string, string>;
+  /** 会话里的老绝对路径换到新位置（迁移后显示老步骤用） */
+  resolvePath?: (path: string) => string;
 }
 
 /** 从任务会话文件推导整个过程：说明文字、思考摘要、工具调用（含结果）。 */
@@ -290,6 +307,7 @@ export function deriveSteps(file: string, options: DeriveOptions = {}): JobStep[
             at,
             cwd: options.cwd ?? "",
             mcpServers: options.mcpServers,
+            resolvePath: options.resolvePath,
             running: true,
           });
           toolIndex.set(step.id, steps.length);
@@ -313,12 +331,12 @@ export function deriveSteps(file: string, options: DeriveOptions = {}): JobStep[
 
     if (message.role === "user") {
       const text = textOfContent(message.content).trim();
-      if (!text || text.startsWith(AUTO_FOLLOW_UP)) continue;
+      if (!text || text.startsWith(AUTO_FOLLOW_UP) || text.startsWith("你还没有调用 report")) continue;
       if (!seenUser) {
         seenUser = true; // 第一句是任务说明，详情头部已经有
         continue;
       }
-      steps.push({ id: `u${message.timestamp ?? at}`, kind: "text", at, from: "user", text: text.startsWith(SEDIMENT_PROMPT_HEAD) ? "沉淀技能" : text });
+      steps.push({ id: `u${message.timestamp ?? at}`, kind: "text", at, from: "user", text: isSedimentPrompt(text) ? "沉淀技能" : text });
     }
   }
   return steps;

package/server/src/usage-prices.ts

@@ -0,0 +1,166 @@
+// 模型单价：默认从 models.dev 拉，一天最多更新一次；存在 HOB_HOME/cache/usage-prices.json，拉不到就用上次的。
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { TokenPrice } from "../../shared/types.ts";
+import { cacheDir } from "./config.ts";
+
+const SOURCE = "https://models.dev/api.json";
+const FILE = "usage-prices.json";
+const DAY = 24 * 3600 * 1000;
+/** 失败后这么久不再试：价格表本来就一天更新一次，失败时别让每次打开页面都等一次超时。 */
+const RETRY = 10 * 60 * 1000;
+const TIMEOUT = 10_000;
+
+/** 模型厂商自己那一家：同一个模型 id 出现在多个服务商里时优先它。 */
+const VENDOR_PROVIDERS = new Set(["openai", "anthropic", "deepseek", "google", "xai", "mistral", "zhipuai", "moonshotai"]);
+
+/** HOB_HOME/cache/usage-prices.json：拉到的单价 + 上次更新和上次尝试的时间。 */
+interface PriceFile {
+  fetchedAt: string | null;
+  attemptAt: string | null;
+  error: string | null;
+  prices: Record<string, TokenPrice>;
+}
+
+const EMPTY: PriceFile = { fetchedAt: null, attemptAt: null, error: null, prices: {} };
+
+function readFile(home: string): PriceFile {
+  const path = join(cacheDir(home), FILE);
+  if (!existsSync(path)) return EMPTY;
+  try {
+    const stored = JSON.parse(readFileSync(path, "utf8")) as Partial<PriceFile>;
+    const prices = stored.prices && typeof stored.prices === "object" ? stored.prices : {};
+    return {
+      fetchedAt: typeof stored.fetchedAt === "string" ? stored.fetchedAt : null,
+      attemptAt: typeof stored.attemptAt === "string" ? stored.attemptAt : null,
+      error: typeof stored.error === "string" ? stored.error : null,
+      prices: Object.fromEntries(Object.entries(prices).filter(([, price]) => isPrice(price))),
+    };
+  } catch {
+    return EMPTY;
+  }
+}
+
+function isPrice(value: unknown): value is TokenPrice {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const price = value as Record<string, unknown>;
+  return ["input", "output", "cacheRead", "cacheWrite"].every((key) => typeof price[key] === "number" && Number.isFinite(price[key]) && (price[key] as number) >= 0);
+}
+
+/** 用户填的单价：四项都是大于等于 0 的数字，不合法说清哪一项。 */
+export function checkPrice(raw: unknown): TokenPrice {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("单价要填四项：输入、输出、缓存读、缓存写。");
+  const input = raw as Record<string, unknown>;
+  const names: Record<keyof TokenPrice, string> = { input: "输入", output: "输出", cacheRead: "缓存读", cacheWrite: "缓存写" };
+  const out = {} as TokenPrice;
+  for (const key of Object.keys(names) as (keyof TokenPrice)[]) {
+    const value = input[key];
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      throw new Error(`「${names[key]}」的单价要填大于等于 0 的数字（美元 / 百万 token）。`);
+    }
+    out[key] = Number(value.toFixed(6));
+  }
+  return out;
+}
+
+function failureReason(error: unknown): string {
+  if (error instanceof Error) {
+    if (error.name === "TimeoutError" || error.name === "AbortError") return "请求超时";
+    return error.message;
+  }
+  return String(error);
+}
+
+/**
+ * models.dev 的整份数据 → 模型 id → 单价。
+ * 同一个模型 id 在多个服务商里都有时，优先模型厂商自己那家（`canonical_model_id` 指回自己，或 id 在厂商名单里）。
+ */
+export function indexPrices(raw: unknown): Record<string, TokenPrice> {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("返回的不是服务商列表");
+  const candidates = new Map<string, { vendor: boolean; price: TokenPrice }[]>();
+  for (const [providerId, provider] of Object.entries(raw as Record<string, unknown>)) {
+    const models = (provider as { models?: unknown } | null)?.models;
+    if (!models || typeof models !== "object" || Array.isArray(models)) continue;
+    for (const [modelId, model] of Object.entries(models as Record<string, unknown>)) {
+      const cost = (model as { cost?: unknown } | null)?.cost as Record<string, unknown> | null | undefined;
+      if (!cost || typeof cost.input !== "number" || typeof cost.output !== "number") continue;
+      const canonical = (model as { canonical_model_id?: unknown }).canonical_model_id;
+      const vendor = (typeof canonical === "string" && canonical.split("/")[0] === providerId) || VENDOR_PROVIDERS.has(providerId);
+      const price: TokenPrice = {
+        input: cost.input,
+        output: cost.output,
+        cacheRead: typeof cost.cache_read === "number" ? cost.cache_read : 0,
+        cacheWrite: typeof cost.cache_write === "number" ? cost.cache_write : 0,
+      };
+      const list = candidates.get(modelId) ?? [];
+      list.push({ vendor, price });
+      candidates.set(modelId, list);
+    }
+  }
+  const prices: Record<string, TokenPrice> = Object.fromEntries([...candidates].map(([modelId, list]) => [modelId, (list.find((item) => item.vendor) ?? list[0]).price]));
+  if (!Object.keys(prices).length) throw new Error("返回里没有模型价格");
+  return prices;
+}
+
+/**
+ * 价格表：一天最多更新一次；拉不到就留着上次的，并把原因写下来给页面显示。
+ * `fetchImpl` 和 `now` 只为测试注入（不连真实网络）。
+ */
+export class UsagePrices {
+  private file: PriceFile;
+  private loading?: Promise<void>;
+
+  constructor(private readonly options: { home: string; fetchImpl?: typeof fetch; now?: () => number }) {
+    this.file = readFile(options.home);
+  }
+
+  private get now(): number {
+    return this.options.now?.() ?? Date.now();
+  }
+
+  /** 需要更新时拉一次（同一时刻只拉一次）；要更新时会把结果写进 HOB_HOME。 */
+  async ensure(): Promise<void> {
+    this.loading ??= this.refresh().finally(() => {
+      this.loading = undefined;
+    });
+    await this.loading;
+  }
+
+  /** 现在用的价格和上次更新的状态。 */
+  table(): { fetchedAt: string | null; error: string | null; prices: Record<string, TokenPrice> } {
+    return { fetchedAt: this.file.fetchedAt, error: this.file.error, prices: this.file.prices };
+  }
+
+  private async refresh(): Promise<void> {
+    const now = this.now;
+    const fetchedAt = this.file.fetchedAt ? Date.parse(this.file.fetchedAt) : 0;
+    if (now - fetchedAt < DAY) return;
+    const attemptAt = this.file.attemptAt ? Date.parse(this.file.attemptAt) : 0;
+    if (attemptAt > fetchedAt && now - attemptAt < RETRY) return;
+    try {
+      this.file = { fetchedAt: new Date(now).toISOString(), attemptAt: new Date(now).toISOString(), error: null, prices: indexPrices(await this.fetchSource()) };
+    } catch (error) {
+      this.file = { ...this.file, attemptAt: new Date(now).toISOString(), error: failureReason(error) };
+    }
+    this.write();
+  }
+
+  private async fetchSource(): Promise<unknown> {
+    const fetchImpl = this.options.fetchImpl ?? globalThis.fetch;
+    const response = await fetchImpl(SOURCE, { signal: AbortSignal.timeout(TIMEOUT), headers: { accept: "application/json" } });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    try {
+      return await response.json();
+    } catch {
+      throw new Error("返回的不是有效 JSON");
+    }
+  }
+
+  private write(): void {
+    const path = join(cacheDir(this.options.home), FILE);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(this.file, null, 2)}\n`);
+    renameSync(tmp, path);
+  }
+}