hob-bot 1.2.0 → 1.3.0

package/server/src/router.ts

@@ -1,6 +1,6 @@
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { parseStreamingJson } from "@earendil-works/pi-ai/utils/json-parse";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { mkdirSync } from "node:fs";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import type { AgentSession, AgentSessionEvent, SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
@@ -30,6 +30,7 @@ import { activityLabel, thinkingLine } from "./router-activity.ts";
 import { imageContents } from "./jobs.ts";
 import { nowBlock } from "./now.ts";
 import { monthDayTimeText } from "./time.ts";
+import { DesktopToolSession } from "./desktop-tools.ts";
 
 export const ITEM_TYPE = "hob.item";
 export const ITEM_UPDATE_TYPE = "hob.item.update";
@@ -65,7 +66,7 @@ interface RouterState {
   /** 这一轮最后一次有动静的时间，看门狗用它判断“没响应” */
   lastEventAt: number;
   stallTimer?: NodeJS.Timeout;
-  /** 已经因为没响应被叫停：这一轮的错误不再写一条重复的 note */
+  /** 这一轮已经被叫停（没响应，或用户按了停止）：之后的报错不再写「回复失败」 */
   stalled: boolean;
   /** 记忆提供者换了：跑着的这一轮结束就释放会话，下一轮按新提供者重新打开 */
   releaseAfterTurn?: boolean;
@@ -78,6 +79,7 @@ interface RouterState {
   knowledgeNames?: string[];
   delegationReply?: string[];
   terminatingTools?: Set<string>;
+  desktop?: DesktopToolSession;
 }
 
 function readEntries(file: string): SessionEntry[] {
@@ -186,6 +188,7 @@ export function deriveItems(entries: SessionEntry[]): Item[] {
 
 export class RouterManager {
   private routers = new Map<string, RouterState>();
+  private itemCache = new Map<string, { manager?: SessionManager; version: string; result: ReturnType<typeof walk>; positions: Map<string, number>; assistantTimes: string[]; last?: { text: string; at: Iso } }>();
   private livePages = new Map<string, Map<string, { page: PageLive; timer?: NodeJS.Timeout; last: number }>>();
   private liveJson = new Map<string, string>();
 
@@ -250,6 +253,37 @@ export class RouterManager {
     return readEntries(this.store.routerFile(assistantId));
   }
 
+  private derived(assistantId: string) {
+    const manager = this.routers.get(assistantId)?.manager;
+    const file = this.store.routerFile(assistantId);
+    let version: string;
+    if (manager) version = String(manager.getEntryCount());
+    else {
+      try {
+        const stat = statSync(file);
+        version = `${stat.size}:${stat.mtimeMs}`;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+        version = "missing";
+      }
+    }
+    const cached = this.itemCache.get(assistantId);
+    if (cached && cached.manager === manager && cached.version === version) return cached;
+    const result = walk(manager ? manager.getEntries() : readEntries(file));
+    const positions = new Map<string, number>();
+    const assistantTimes: string[] = [];
+    let last: { text: string; at: Iso } | undefined;
+    result.items.forEach((item, index) => {
+      positions.set(item.id, index);
+      if (item.kind === "assistant") assistantTimes.push(item.at);
+      if (item.kind === "assistant" || item.kind === "user" || item.kind === "note") last = { text: item.text, at: item.at };
+    });
+    assistantTimes.sort();
+    const next = { manager, version, result, positions, assistantTimes, last };
+    this.itemCache.set(assistantId, next);
+    return next;
+  }
+
   async ensure(assistantId: string): Promise<RouterState> {
     const assistant = this.assistant(assistantId);
     let state = this.routers.get(assistantId);
@@ -271,6 +305,10 @@ export class RouterManager {
     await this.runtime.models.get();
     const pick = conversationPick(this.runtime.settings.settings.models, assistant);
     state.knowledgeNames = (await boundKnowledge(this.runtime, assistant.id)).map((collection) => collection.name);
+    state.desktop = new DesktopToolSession(this.runtime, assistant.id, () => !!state.session?.model?.input.includes("image"), undefined, true);
+    const tools = [...buildRouterTools(this.runtime, assistant.id), ...state.desktop.tools().filter((tool) => tool.name.startsWith("browser_"))];
+    const desktop = this.runtime.desktop.view();
+    const enabled = desktop.enabled && !!desktop.url && desktop.tokenConfigured;
     const opened = await this.runtime.pi.open({
       file: this.store.routerFile(assistant.id),
       spillDir: join(dirname(this.store.routerFile(assistant.id)), "spill"),
@@ -280,10 +318,15 @@ export class RouterManager {
       memory: this.runtime.settings.memory().provider,
       systemPrompt: () => {
         const { timezone, aboutYou } = this.runtime.settings.settings.general;
+        const desktop = this.runtime.desktop.view();
         return buildSystemPrompt(this.store, assistant.id, {
           timezone,
           aboutYou,
           memory: this.runtime.settings.memory().provider,
+          searchEnabled: this.runtime.settings.settings.search.some((provider) => provider.enabled),
+          imageEnabled: this.runtime.settings.settings.image.source !== "off",
+          desktopEnabled: desktop.enabled && !!desktop.url && desktop.tokenConfigured,
+          publicDesktop: desktop.publicAssistants.includes(assistant.id),
           models: this.promptModels(assistant.id),
           skills: availableSkills(this.runtime.home, undefined, this.runtime.settings.settings.skills?.disabled, this.runtime.settings.memory().provider === "lore" ? this.runtime.pi.loreSkillPaths : []),
           assistantSkills: usableAssistantSkills(this.runtime.home, assistant.id),
@@ -292,8 +335,8 @@ export class RouterManager {
           knowledgeNames: state.knowledgeNames,
         });
       },
-      tools: buildRouterTools(this.runtime, assistant.id).map((tool) => tool.name),
-      customTools: buildRouterTools(this.runtime, assistant.id),
+      tools: tools.filter((tool) => enabled || !tool.name.startsWith("browser_")).map((tool) => tool.name),
+      customTools: tools,
     });
     state.session = opened.session;
     if (!state.knowledgeNames.length) refreshSystemPrompt(opened.session, opened.session.getActiveToolNames().filter((name) => name !== "search_knowledge"));
@@ -305,8 +348,10 @@ export class RouterManager {
 
   private async refreshTools(state: RouterState): Promise<void> {
     state.knowledgeNames = (await boundKnowledge(this.runtime, state.assistantId)).map((collection) => collection.name);
-    const names = state.session!.getActiveToolNames().filter((name) => name !== "search_knowledge");
+    const names = state.session!.getActiveToolNames().filter((name) => name !== "search_knowledge" && !name.startsWith("browser_"));
     if (state.knowledgeNames.length) names.push("search_knowledge");
+    const desktop = this.runtime.desktop.view();
+    if (desktop.enabled && desktop.url && desktop.tokenConfigured) names.push(...state.desktop!.tools().filter((tool) => tool.name.startsWith("browser_")).map((tool) => tool.name));
     refreshSystemPrompt(state.session!, names);
   }
 
@@ -392,7 +437,7 @@ export class RouterManager {
     }
     if (event.type === "message_start" && event.message.role === "custom" && event.message.customType === EVENT_TYPE) {
       const details = event.message.details as EventDetails | undefined;
-      const users = deriveItems(this.entries(assistantId)).filter((item) => item.kind === "user");
+      const users = this.derived(assistantId).result.items.filter((item) => item.kind === "user");
       const source = details?.sourceUserId ? users.find((item) => item.id === details.sourceUserId) : undefined;
       state.currentUserId = (source ?? users.at(-1))?.id;
       if (details?.delegationId && details.delegationId !== state.currentDelegationId) {
@@ -471,7 +516,7 @@ export class RouterManager {
             at: new Date().toISOString(),
             text: "",
             streaming: true,
-            ...(walk(this.entries(assistantId)).lead ? { lead: true } : {}),
+            ...(this.derived(assistantId).result.lead ? { lead: true } : {}),
           },
         });
       }
@@ -502,7 +547,7 @@ export class RouterManager {
   }
 
   private emitSettledAssistant(assistantId: string, text: string, expectedId?: string): void {
-    const list = deriveItems(this.entries(assistantId)).filter((item) => item.kind === "assistant");
+    const list = this.derived(assistantId).result.items.filter((item) => item.kind === "assistant");
     const item = list.find((entry) => entry.id === expectedId) ?? list.filter((entry) => entry.text === text).pop();
     if (item) this.bus.emit({ type: "item", assistantId, item });
     this.touch(assistantId);
@@ -580,8 +625,11 @@ export class RouterManager {
     if (state.idleTimer) clearTimeout(state.idleTimer);
     state.idleTimer = undefined;
     state.session?.dispose();
+    void state.desktop?.dispose();
+    state.desktop = undefined;
     state.session = undefined;
     state.manager = undefined;
+    this.itemCache.delete(state.assistantId);
   }
 
   /**
@@ -597,6 +645,7 @@ export class RouterManager {
 
   /** 助手没了（归档）：关掉它的会话，内存里也不留 —— 它的目录随后会被移进归档。 */
   forget(assistantId: string): void {
+    this.itemCache.delete(assistantId);
     const state = this.routers.get(assistantId);
     if (!state) return;
     this.close(state);
@@ -618,7 +667,7 @@ export class RouterManager {
   // ---------- 事件与条目 ----------
   async addItem(assistantId: string, item: NewItem): Promise<Item> {
     const state = await this.ensure(assistantId);
-    const lead = walk(this.entries(assistantId)).lead;
+    const lead = this.derived(assistantId).result.lead;
     const id = state.manager!.appendCustomEntry(ITEM_TYPE, item);
     const full = { ...item, ...(lead ? { lead: true } : {}), id, at: this.entryAt(state, id) } as Item;
     this.bus.emit({ type: "item", assistantId, item: full });
@@ -632,7 +681,7 @@ export class RouterManager {
 
   async updateImage(assistantId: string, id: string, update: { status: "done" | "failed"; path?: string; error?: string }): Promise<void> {
     const state = await this.ensure(assistantId);
-    const item = deriveItems(this.entries(assistantId)).find((entry) => entry.id === id && entry.kind === "image");
+    const item = this.derived(assistantId).result.items.find((entry) => entry.id === id && entry.kind === "image");
     if (!item) throw new Error(`图片条目不存在：${id}`);
     state.manager!.appendCustomEntry(ITEM_UPDATE_TYPE, { id, ...update });
     this.bus.emit({ type: "item", assistantId, item: { ...item, ...update } });
@@ -647,7 +696,7 @@ export class RouterManager {
 
   /** 取当前回合来源及其之前的可见对话；事件取最近用户消息。 */
   originalWords(assistantId: string, note?: string, recent = false, extraFiles: string[] = []): { text: string; files: string[] } {
-    const items = deriveItems(this.entries(assistantId));
+    const items = this.derived(assistantId).result.items;
     const state = this.routers.get(assistantId);
     const source = items.find((item) => item.kind === "user" && item.id === state?.currentUserId)
       ?? items.findLast((item) => item.kind === "user");
@@ -743,7 +792,8 @@ export class RouterManager {
    */
   private async reportTurnError(state: RouterState): Promise<void> {
     const last = state.session?.messages.findLast((message) => message.role === "assistant");
-    if (!last || last.role !== "assistant" || last.stopReason !== "error") return;
+    // 停下的那一轮：有的服务商（Claude 订阅桥）把停止报成 error，不是回复失败
+    if (state.stalled || !last || last.role !== "assistant" || last.stopReason !== "error") return;
     await this.addItem(state.assistantId, { kind: "note", icon: "info", text: `回复失败：${briefModelError(last.errorMessage)}。发送任意消息即可重试。` });
   }
 
@@ -876,7 +926,10 @@ export class RouterManager {
 
   async stop(assistantId: string): Promise<void> {
     const state = this.routers.get(assistantId);
-    if (state) this.setActivity(state, null);
+    if (state) {
+      state.stalled = true;
+      this.setActivity(state, null);
+    }
     if (state?.session) await state.session.abort();
   }
 
@@ -908,14 +961,12 @@ export class RouterManager {
   }
 
   items(assistantId: string, options: { before?: string; limit?: number } = {}): ItemsPage {
-    const all = deriveItems(this.entries(assistantId));
+    const derived = this.derived(assistantId);
+    const all = derived.result.items;
     const limit = Math.max(1, Math.min(options.limit ?? 50, 200));
-    let list = all;
-    if (options.before) {
-      const index = all.findIndex((item) => item.id === options.before);
-      if (index !== -1) list = all.slice(0, index);
-    }
-    const page = list.slice(-limit);
+    const end = options.before ? derived.positions.get(options.before) ?? all.length : all.length;
+    const start = Math.max(0, end - limit);
+    const page = all.slice(start, end);
     const jobIds = new Set(page.filter((item) => item.kind === "job").map((item) => (item as { jobId: string }).jobId));
     const draftIds = new Set(
       page.filter((item) => item.kind === "draft").map((item) => (item as { draftId: string }).draftId),
@@ -929,15 +980,14 @@ export class RouterManager {
       for (const id of delegation.jobIds) jobIds.add(id);
       for (const id of delegation.approvalIds ?? []) approvalIds.add(id);
     }
-    for (const approval of this.store.approvals()) if (approval.jobId && jobIds.has(approval.jobId)) approvalIds.add(approval.id);
     return {
       ...(!options.before ? { pageLive: [...(this.livePages.get(assistantId)?.values() ?? [])].map((live) => live.page) } : {}),
       items: page,
       approvals: this.store.approvals().filter((approval) => approvalIds.has(approval.id)),
-      jobs: this.store.jobs().filter((job) => jobIds.has(job.id)),
+      jobs: [...jobIds].flatMap((id) => { const job = this.store.job(id); return job ? [job] : []; }),
       drafts: this.store.drafts().filter((draft) => draftIds.has(draft.id)),
       delegations,
-      hasMore: list.length > page.length,
+      hasMore: start > 0,
     };
   }
 
@@ -947,21 +997,23 @@ export class RouterManager {
 
   unread(assistantId: string): number {
     const readAt = this.store.state(assistantId).readAt;
-    if (!readAt) return 0;
-    return deriveItems(this.entries(assistantId)).filter(
-      (item) => item.kind === "assistant" && item.at > readAt,
-    ).length;
+    // 从没记过已读：从现在开始算，以前的都当读过。不记的话未读永远是 0，前端也就永远不会来标已读
+    if (!readAt) {
+      this.read(assistantId);
+      return 0;
+    }
+    const times = this.derived(assistantId).assistantTimes;
+    let lo = 0, hi = times.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      if (times[mid] <= readAt) lo = mid + 1;
+      else hi = mid;
+    }
+    return times.length - lo;
   }
 
   last(assistantId: string): { text: string; at: Iso } | undefined {
-    const items = deriveItems(this.entries(assistantId));
-    for (let i = items.length - 1; i >= 0; i -= 1) {
-      const item = items[i];
-      if (item.kind === "user" || item.kind === "assistant" || item.kind === "note") {
-        return { text: item.text, at: item.at };
-      }
-    }
-    return undefined;
+    return this.derived(assistantId).last;
   }
 
   summary(assistant: Assistant): AssistantSummary {
@@ -970,6 +1022,7 @@ export class RouterManager {
       ...assistant,
       ...(last ? { last } : {}),
       unread: this.unread(assistant.id),
+      ...(this.store.state(assistant.id).readAt ? { readAt: this.store.state(assistant.id).readAt } : {}),
       busy: this.isBusy(assistant.id),
       activity: this.routers.get(assistant.id)?.activity ?? null,
     };
@@ -993,7 +1046,7 @@ export class RouterManager {
         .jobs()
         .filter((job) => job.status === "running" || job.status === "queued" || job.status === "waiting" || (job.endedAt ?? job.createdAt) > jobCutoff),
       routines: this.store.routines(),
-      approvals: this.store.approvals().filter((approval) => approval.status === "pending"),
+      approvals: this.store.approvals().filter((approval) => approval.status === "pending" && approval.source !== "job"),
       delegations: this.store.delegations(),
       settings: this.runtime.settings.get(),
     };
@@ -1001,11 +1054,9 @@ export class RouterManager {
 
   /** 进程退出或测试收尾：释放所有 Router 会话。 */
   disposeAll(): void {
-    for (const state of this.routers.values()) {
-      if (state.idleTimer) clearTimeout(state.idleTimer);
-      state.session?.dispose();
-    }
+    for (const state of this.routers.values()) this.close(state);
     this.routers.clear();
+    this.itemCache.clear();
   }
 
   /** 直接走事件的 followUp 队列，实际收到这条消息时才开始关联任务。 */

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 { newId } from "./ids.ts";
 import type {
   Approval,
   Assistant,
@@ -56,6 +57,25 @@ export class Store {
     for (const dir of ["assistants", "jobs", "uploads"]) {
       mkdirSync(join(this.home, dir), { recursive: true });
     }
+    if (!existsSync(join(this.home, "rules.json"))) {
+      const changedAt = new Date().toISOString();
+      this.saveGlobalRules([
+        ...["删除或覆盖文件、数据和备份", "对外发送（消息、邮件、发布）、付费、充值、改计费", "停止或重启别人正在使用的服务和设备", "修改可能让你失去远程访问的设置（网络、防火墙、登录方式）"].map((text) => ({ id: newId("r-"), text, mode: "ask" as const, changedAt })),
+        ...["过去的记录是线索不是现状：动手前先核实实际状态。", "改配置、改数据前先留好退路（备份或记下原值）；改完用实际效果验证，不只看命令返回。", "凭据（密码、密钥、令牌、Cookie）只在用的时候读取，不回显，不写进文件和报告，也不存起来。"].map((text) => ({ id: newId("r-"), text, mode: "allow" as const, changedAt })),
+      ]);
+    }
+  }
+
+  globalRules(): Rule[] {
+    const path = join(this.home, "rules.json");
+    if (!existsSync(path)) return [];
+    const rules = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    if (!Array.isArray(rules)) throw new Error("全局规则文件格式无效");
+    return rules as Rule[];
+  }
+
+  saveGlobalRules(rules: Rule[]): void {
+    writeJsonAtomic(join(this.home, "rules.json"), rules);
   }
 
   // ---------- 助手 ----------

package/server/src/worker-tools.ts

@@ -19,8 +19,8 @@ export function registerReportTool(runtime: HobRuntime, jobId: string): ToolDefi
       outcome: Type.Unsafe<"done" | "stuck" | "need_approval">(
         Type.String({ description: "done 做完 / stuck 做不下去（写明缺什么）/ need_approval 需要用户拍板" }),
       ),
-      result: Type.String({ description: "完整结果：结论、数据、链接、文件路径；写给派活的助手。" }),
-      files: Type.Optional(Type.Array(Type.String(), { description: "要给用户看的文件（绝对路径）" })),
+      result: Type.String({ description: "完整结果，按这个顺序写：结论；做了什么；验证了什么、怎么验证的；没验证或不确定的；需要用户决定的。带上数据、链接和文件路径，写给派活的助手。" }),
+      files: Type.Optional(Type.Array(Type.String(), { description: "交给助手的文件（绝对路径），比如要给用户看的图" })),
     }),
     execute: async (_id, params: any) => {
       // 不认识的结果不能当成已完成：退回让模型重新调用
@@ -46,7 +46,7 @@ export function registerAskTool(runtime: HobRuntime, jobId: string): ToolDefinit
   return {
     name: "ask_user",
     label: "询问用户",
-    description: "在对话里出选择题卡片（2 到 3 个选项），等用户选，返回用户的选择。用于用户定的规则要求先确认的事，或发送、删除、付费这类撤不回的事。",
+    description: "问你的助手，等它回复：它会自己答，或者去问用户。用于用户定的规则要求先确认的事，或发送、删除、付费这类撤不回的事。其他拿不准的不问，按合理的假设做下去，把假设写进 result。",
     promptSnippet: "规则要求执行前确认的事，执行前必须调用 ask_user。",
     parameters: Type.Object({
       title: Type.String({ description: "问题，一句话" }),
@@ -57,27 +57,20 @@ export function registerAskTool(runtime: HobRuntime, jobId: string): ToolDefinit
         }),
         { description: "2 到 3 个选项", minItems: 2, maxItems: 3 },
       ),
-      remember: Type.Optional(Type.String({ description: "同类事以后可以不再问时，填这类事的简称（如「清理临时目录」）；卡片会多一个「以后直接做」的选项。" })),
     }),
     execute: async (_id, params: any) => {
       const labels: { label: string }[] = Array.isArray(params.options) ? params.options : [];
       if (labels.length < 2 || labels.length > 3) {
         return { content: [{ type: "text" as const, text: "选项要 2 到 3 个。" }], details: undefined, isError: true };
       }
-      const remember = typeof params.remember === "string" ? params.remember.trim() : "";
-      if (remember && labels.length > 2) {
-        return { content: [{ type: "text" as const, text: "带 remember 时最多给 2 个选项。" }], details: undefined, isError: true };
-      }
       const options: ApprovalOption[] = labels.map((option, index) => ({
         key: (["A", "B", "C"] as const)[index],
         label: String(option.label),
       }));
-      if (remember) options.push({ key: "C", label: `以后「${remember}」直接做`, always: true });
       const answer = await runtime.jobs.askQuestion(jobId, {
         title: String(params.title),
         ...(params.detail ? { detail: String(params.detail) } : {}),
         options,
-        ...(remember ? { ruleText: remember } : {}),
       });
       // 用户可能没选给出的选项，而是自己写了一段：answer 已经是回给模型的整句
       return ok(answer);

package/shared/skills.ts

@@ -15,6 +15,8 @@ export interface SkillsView {
   skills: SkillView[];
   loreActive: boolean;
   loreUrl: string | null;
+  /** Lore 目录没取到的原因；其他技能照常列出。 */
+  loreError?: string;
 }
 
 export interface ImportSkill {
@@ -42,7 +44,7 @@ export interface SkillImportResult {
  */
 export interface AssistantSkill {
   name: string; // 目录名：小写字母、数字、连字符
-  title: string; // 界面上显示的名字，如「网关每日巡检」
+  title: string; // 界面上显示的名字，如「每周周报」
   description: string; // 一句话：什么时候用
   path: string; // SKILL.md 的绝对路径（预览用）
   version: number; // 每次修补 +1，旧版在 skills/<name>/.history/<版本>/

package/shared/types.ts

@@ -247,6 +247,7 @@ export type RouterActivity = { state: "thinking" | "tool"; label: string };
 export interface AssistantSummary extends Assistant {
   last?: { text: string; at: Iso }; // 对话最后一条（列表第二行）
   unread: number; // 未读条数（>0 时大头像右上角橙点）
+  readAt?: Iso; // 上次看这个助手的时间：之前结束的任务不再挂完成/受阻标记
   busy: boolean; // Router 正在回复（在跑的任务不算，任务状态看任务卡）
   activity?: RouterActivity | null;
 }
@@ -688,6 +689,7 @@ export interface Bootstrap {
 }
 
 export type HobEvent =
+  | { type: "rules" }
   | { type: "desktop-control"; screen: string; taken: boolean }
   | { type: "desktop-screens"; screens: DesktopScreen[] }
   | ({ type: "page-live" } & PageLive)