hob-bot 1.4.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,5 +1,6 @@
 // 任务过程（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";
@@ -48,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 ?? "") };
@@ -207,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,
@@ -255,6 +260,8 @@ export interface DeriveOptions {
   save?: (stepId: string, text: string) => string;
   /** MCP 工具的显示名映射（转义后的服务名 → 配置里的原名） */
   mcpServers?: Record<string, string>;
+  /** 会话里的老绝对路径换到新位置（迁移后显示老步骤用） */
+  resolvePath?: (path: string) => string;
 }
 
 /** 从任务会话文件推导整个过程：说明文字、思考摘要、工具调用（含结果）。 */
@@ -300,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);

package/server/src/usage-prices.ts

@@ -1,7 +1,8 @@
-// 模型单价：默认从 models.dev 拉，一天最多更新一次；存在 HOB_HOME/usage-prices.json，拉不到就用上次的。
+// 模型单价：默认从 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";
@@ -13,7 +14,7 @@ const TIMEOUT = 10_000;
 /** 模型厂商自己那一家：同一个模型 id 出现在多个服务商里时优先它。 */
 const VENDOR_PROVIDERS = new Set(["openai", "anthropic", "deepseek", "google", "xai", "mistral", "zhipuai", "moonshotai"]);
 
-/** HOB_HOME/usage-prices.json：拉到的单价 + 上次更新和上次尝试的时间。 */
+/** HOB_HOME/cache/usage-prices.json：拉到的单价 + 上次更新和上次尝试的时间。 */
 interface PriceFile {
   fetchedAt: string | null;
   attemptAt: string | null;
@@ -24,7 +25,7 @@ interface PriceFile {
 const EMPTY: PriceFile = { fetchedAt: null, attemptAt: null, error: null, prices: {} };
 
 function readFile(home: string): PriceFile {
-  const path = join(home, FILE);
+  const path = join(cacheDir(home), FILE);
   if (!existsSync(path)) return EMPTY;
   try {
     const stored = JSON.parse(readFileSync(path, "utf8")) as Partial<PriceFile>;
@@ -156,7 +157,7 @@ export class UsagePrices {
   }
 
   private write(): void {
-    const path = join(this.options.home, FILE);
+    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`);

package/server/src/usage.ts

@@ -1,6 +1,6 @@
 // 消耗：不另外记账，直接从会话文件里 assistant 消息的 usage 统计（见 docs/architecture.md“消耗”）。
 import { createReadStream, existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import type { TokenPrice, UsageAssistant, UsageModelPrice, UsagePrices, UsageRow, UsageSource, UsageView } from "../../shared/types.ts";
 import type { SettingsStore } from "./settings.ts";
 import type { Store } from "./store.ts";
@@ -106,6 +106,17 @@ function readDir(path: string): string[] {
   return existsSync(path) ? readdirSync(path) : [];
 }
 
+/** 所有任务的会话目录：在的助手和归档的助手都算。 */
+function jobSessionDirs(home: string): string[] {
+  const out: string[] = [];
+  const roots = [
+    ...readDir(join(home, "assistants")).map((id) => join(home, "assistants", id, "jobs")),
+    ...readDir(join(home, "archive", "assistants")).map((folder) => join(home, "archive", "assistants", folder, "jobs")),
+  ];
+  for (const root of roots) for (const id of readDir(root)) out.push(join(root, id));
+  return out;
+}
+
 function readJson(path: string): Record<string, unknown> | undefined {
   try {
     return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
@@ -228,12 +239,11 @@ export class UsageService {
       if (!assistants.has(id)) assistants.set(id, { id, name, archived: true });
       await this.sync({ file, assistantId: id, assistantName: name, source: "chat" }, seen);
     }
-    for (const jobId of readDir(join(home, "jobs"))) {
-      const file = join(home, "jobs", jobId, "worker.jsonl");
+    for (const jobDir of jobSessionDirs(home)) {
+      const file = join(jobDir, "worker.jsonl");
       if (!existsSync(file)) continue;
-      // 没有缓存时才读 job.json：任务的所属助手建好就不变
       const cached = this.files.get(file);
-      const job = cached ? undefined : this.options.store.job(jobId);
+      const job = cached ? undefined : this.options.store.job(basename(jobDir));
       const assistantId = cached?.assistantId ?? job?.assistantId;
       if (!assistantId) continue;
       const live = this.options.store.assistant(assistantId);

package/shared/types.ts

@@ -225,6 +225,8 @@ export interface Assistant {
   prop?: CustomProp;
   primary: boolean; // 只有 hob 为 true
   pinned: boolean; // 左栏顶部大头像
+  /** 置顶区里的位置：小的在前，拖动头像换位置时改它；没排过的排在排过的后面，再按创建时间 */
+  pinOrder?: number;
   hidden: boolean; // 收起的助手
   notify: boolean; // 需要确认时通知我
   instructions: string; // 补充说明：用户可直接编辑该助手需要知道的专属事实
@@ -275,16 +277,40 @@ export interface RoutineRun {
   tokens?: number; // 技能二期：输入加输出 token
 }
 
+export interface RoutineCheck {
+  script: string; // 到点先跑的 bash 脚本：没有输出就跳过这一次
+  then: "notify" | "job"; // 有输出时：notify 把输出作为提醒发到对话；job 带着输出开始任务
+}
+
+export interface RoutineChecks {
+  total: number; // 检查了几次
+  hits: number; // 触发了几次
+  failing?: string; // 最近一次失败的原因，下次成功就清掉
+  lastAt?: Iso; // 上次检查的时间
+}
+
+/** 定时到点（或点「立即运行」）这一次的结果。 */
+export interface RoutineTick {
+  outcome: "job" | "notify" | "quiet" | "failed"; // job 开了任务；notify 已发到对话；quiet 没变化；failed 检查失败
+  job?: Job;
+  reason?: string; // failed 时的原因
+}
+
 export interface Routine {
   id: string;
   assistantId: string;
   name: string; // 如 "每日简报"
   instruction: string; // 要做什么
-  schedules: string[]; // cron 表达式，如 "0 9 * * *"；可多个（"再加一个"）
+  schedules: string[]; // cron 表达式（如 "0 9 * * *"）或具体时间（如 "2026-11-08T09:00"）；可多个（"再加一个"）
   active: boolean;
   createdAt: Iso;
   runs: RoutineRun[]; // 最近 20 次，新的在前
   skill?: string; // 绑定这个助手自己的技能（AssistantSkill.name）：每次执行按它做
+  check?: RoutineCheck; // 到点先跑脚本，多数时候没变化就不开任务
+  checks?: RoutineChecks; // 检查计数和最近一次失败的原因
+  once?: boolean; // 做成一次就停：没有检查脚本的跑完就停，有检查的第一次有输出就停
+  stoppedAt?: Iso; // 上次停下的时间
+  stopReason?: "hit" | "finished"; // hit=按 once 停了；finished=所有执行时间都跑完了
 }
 
 export interface Delegation {