hob-bot 0.0.0-stage → 1.0.2

package/dist/web/index.html

@@ -0,0 +1,32 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover" />
+    <meta name="theme-color" content="#f6f6f4" />
+    <script>
+      (() => {
+        let theme = "system";
+        try { theme = localStorage.getItem("hob.theme") || "system"; } catch {}
+        const dark = theme === "dark" || (theme !== "light" && theme !== "dark" && matchMedia("(prefers-color-scheme: dark)").matches);
+        document.documentElement.classList.toggle("dark", dark);
+        document.documentElement.style.colorScheme = dark ? "dark" : "light";
+        // 和 theme.ts 的 statusSurface 一致：手机用 --bg，宽屏用 --side
+        const narrow = innerWidth < 768;
+        document.querySelector('meta[name="theme-color"]').content = narrow ? (dark ? "#151516" : "#ffffff") : dark ? "#1b1b1d" : "#f6f6f4";
+      })();
+    </script>
+    <link rel="manifest" href="/manifest.webmanifest?v=3" />
+    <link rel="icon" href="/icons/favicon-32.png?v=3" sizes="32x32" type="image/png" />
+    <link rel="apple-touch-icon" sizes="180x180" href="/icons/apple-touch-icon-180.png?v=3" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-title" content="Hob" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="default" />
+    <title>Hob</title>
+    <script type="module" crossorigin src="/assets/index-DUs8nN3E.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D88l35PH.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/web/manifest.webmanifest

@@ -0,0 +1,16 @@
+{
+  "name": "Hob",
+  "short_name": "Hob",
+  "description": "常驻助手：任务交由后台执行，需要确认时才会通知你。",
+  "lang": "zh-CN",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "background_color": "#fff0e4",
+  "theme_color": "#f6f6f4",
+  "icons": [
+    { "src": "/icons/icon-192.png?v=3", "sizes": "192x192", "type": "image/png", "purpose": "any" },
+    { "src": "/icons/icon-512.png?v=3", "sizes": "512x512", "type": "image/png", "purpose": "any" },
+    { "src": "/icons/icon-maskable-512.png?v=3", "sizes": "512x512", "type": "image/png", "purpose": "maskable" }
+  ]
+}

package/dist/web/sw.js

@@ -0,0 +1,131 @@
+// Hob 的 service worker（手写，无依赖）：只缓存界面壳和带哈希的静态文件，/api 一律走网络。
+// 升级不打断用户：新版本装好后等页面提示「有新版本 · 刷新」，点了才 skipWaiting。
+const CACHE = "hob-shell-v4"; // 图标或壳变了就加一，旧缓存在 activate 时删掉
+// 图标和 manifest 不进缓存：系统添加到主屏幕时要拿到的是服务器上最新的那一份
+
+self.addEventListener("install", (event) => {
+  event.waitUntil(
+    precache().then(() => {
+      // 第一次装（之前没有 SW 在管）直接接管；已有旧版本就等用户点刷新
+      if (!self.registration.active) return self.skipWaiting();
+      return undefined;
+    }),
+  );
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(
+    caches
+      .keys()
+      .then((keys) => Promise.all(keys.filter((key) => key !== CACHE).map((key) => caches.delete(key))))
+      .then(() => self.clients.claim()),
+  );
+});
+
+self.addEventListener("message", (event) => {
+  if (event.data === "skip-waiting") void self.skipWaiting();
+});
+
+// 装的时候就把壳和构建产物一起缓存下来：构建后的文件名带哈希，从 index.html 里抠出来
+async function precache() {
+  const cache = await caches.open(CACHE);
+  try {
+    const response = await fetch("/", { cache: "reload" });
+    if (!response.ok) return;
+    const html = await response.clone().text();
+    await cache.put("/", response.clone());
+    const urls = new Set([...html.matchAll(/(?:src|href)="(\/assets\/[^"]+)"/g)].map((match) => match[1]));
+    await Promise.all(
+      [...urls].map(async (url) => {
+        const asset = await fetch(url);
+        if (asset.ok) await cache.put(url, asset);
+      }),
+    );
+  } catch {
+    // 离线时装不上就先有壳，等联网后再缓存
+  }
+}
+
+function isStatic(pathname) {
+  return (
+    pathname.startsWith("/assets/") ||
+    pathname.startsWith("/fonts/")
+  );
+}
+
+async function cacheFirst(request) {
+  const cache = await caches.open(CACHE);
+  const hit = await cache.match(request);
+  if (hit) return hit;
+  const response = await fetch(request);
+  if (response.ok) cache.put(request, response.clone());
+  return response;
+}
+
+// 导航：先走网络拿最新的 index.html，断网时用缓存里的界面壳
+async function networkFirst(request) {
+  const cache = await caches.open(CACHE);
+  try {
+    const response = await fetch(request);
+    if (response.ok) cache.put("/", response.clone());
+    return response;
+  } catch {
+    const hit = (await cache.match(request)) || (await cache.match("/"));
+    if (hit) return hit;
+    return new Response("连不上 Hob，而且这台设备还没有缓存过界面。", {
+      status: 503,
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  }
+}
+
+self.addEventListener("fetch", (event) => {
+  const request = event.request;
+  if (request.method !== "GET") return;
+  const url = new URL(request.url);
+  if (url.origin !== self.location.origin) return;
+  // 一律不拦：接口要实时的，缓存了就是给用户看假数据
+  if (url.pathname.startsWith("/api/")) return;
+  if (request.mode === "navigate") {
+    event.respondWith(networkFirst(request));
+    return;
+  }
+  if (isStatic(url.pathname)) event.respondWith(cacheFirst(request));
+});
+
+self.addEventListener("push", (event) => {
+  let payload = {};
+  try {
+    payload = event.data ? event.data.json() : {};
+  } catch {
+    payload = {};
+  }
+  const title = payload.title || "Hob";
+  const target = payload.url || "/";
+  event.waitUntil(
+    self.registration.showNotification(title, {
+      body: payload.body || "",
+      icon: "/icons/icon-192.png",
+      badge: "/icons/favicon-32.png",
+      data: { url: target },
+      tag: target,
+    }),
+  );
+});
+
+self.addEventListener("notificationclick", (event) => {
+  event.notification.close();
+  const url = new URL((event.notification.data && event.notification.data.url) || "/", self.location.origin).href;
+  event.waitUntil(
+    (async () => {
+      const windows = await self.clients.matchAll({ type: "window", includeUncontrolled: true });
+      for (const client of windows) {
+        if (!client.url.startsWith(self.location.origin)) continue;
+        await client.focus();
+        if (client.navigate) await client.navigate(url);
+        return;
+      }
+      await self.clients.openWindow(url);
+    })(),
+  );
+});

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "hob-bot",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.2",
+  "description": "A self-hosted personal assistant that runs real work as background jobs.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FFatTiger/hob.git"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "hob": "bin/hob.mjs"
+  },
+  "files": [
+    "bin",
+    "server/src",
+    "shared",
+    "dist/web",
+    "vendor"
+  ],
+  "scripts": {
+    "dev:server": "tsx watch server/src/boot.ts",
+    "dev:web": "vite",
+    "build": "vite build && tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "start": "tsx server/src/boot.ts",
+    "test": "vitest run",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@earendil-works/pi-ai": "1.3.0",
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@hono/node-server": "^2.1.6",
+    "@juicesharp/rpiv-config": "2.15.0",
+    "@juicesharp/rpiv-web-tools": "2.15.0",
+    "croner": "^9.0.0",
+    "hono": "^4.6.0",
+    "marked": "^15.0.0",
+    "pi-memory": "0.4.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsx": "^4.19.0",
+    "web-push": "^3.6.7",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@types/web-push": "^3.6.4",
+    "@types/ws": "^8.5.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "^5.6.0",
+    "vite": "^6.0.0",
+    "vitest": "^5.0.5"
+  },
+  "overrides": {
+    "undici": "^8.12.3",
+    "minimatch": "^11.0.4"
+  }
+}

package/server/src/actions.ts

@@ -0,0 +1,230 @@
+import { distinctSprite } from "../../shared/sprites.ts";
+import type { AnswerApprovalBody, Approval, Assistant, Draft, Rule } from "../../shared/types.ts";
+import { newId, slugify } from "./ids.ts";
+import type { HobRuntime } from "./runtime.ts";
+import { monthDayText } from "./time.ts";
+
+export interface ActionResult {
+  status: number;
+  body: unknown;
+}
+
+/** 其他想法的长度上限（字）。 */
+export const MAX_ANSWER_TEXT = 1000;
+
+/** 答复审批卡：记答案、写 always 规则、叫醒阻塞的 Worker 或把答案推回 Router。 */
+export async function answerApproval(runtime: HobRuntime, approvalId: string, input: AnswerApprovalBody): Promise<ActionResult> {
+  const { store, bus, router, jobs } = runtime;
+  const approval = store.approval(approvalId);
+  if (!approval) return { status: 404, body: { error: "审批不存在" } };
+  if (approval.status !== "pending") return { status: 409, body: { error: "这个审批已经答复过了" } };
+  const option = input.key ? approval.options.find((item) => item.key === input.key) : undefined;
+  if (input.key && !option) return { status: 400, body: { error: "没有这个选项" } };
+  // 没选选项就是想自己写：空白和字数都有上限，不合格的不收
+  const text = typeof input.text === "string" ? input.text.trim() : "";
+  if (!option) {
+    if (!text) return { status: 400, body: { error: "其他想法不能为空" } };
+    if (text.length > MAX_ANSWER_TEXT) return { status: 400, body: { error: `其他想法最多 ${MAX_ANSWER_TEXT} 字` } };
+  }
+
+  const answered: Approval = {
+    ...approval,
+    status: "answered",
+    ...(option ? { chosen: option.key } : { answerText: text }),
+    answeredAt: new Date().toISOString(),
+  };
+  store.saveApproval(answered);
+  bus.emit({ type: "approval", approval: answered });
+
+  if (option?.always) {
+    const assistant = store.assistant(approval.assistantId);
+    const ruleText = approval.ruleText?.trim() || option.label;
+    const rules = store.rules(approval.assistantId);
+    const existing = rules.find((rule) => rule.text === ruleText);
+    if (existing) {
+      existing.mode = "allow";
+      existing.changedAt = new Date().toISOString();
+    } else {
+      rules.push({ id: newId("r-"), text: ruleText, mode: "allow", changedAt: new Date().toISOString() });
+    }
+    store.saveRules(approval.assistantId, rules);
+    await router.addItem(approval.assistantId, {
+      kind: "note",
+      icon: "rule",
+      text: `已记入${assistant?.name ?? approval.assistantId}的规则 · ${ruleText}`,
+    });
+    bus.emit({ type: "profile", assistantId: approval.assistantId });
+  }
+
+  // 回给模型：自己写的那句要说明是用户写的、没选给出的选项
+  const answer = option ? `用户选择了：${option.label}` : `用户没有选给出的选项，而是回复：${text}`;
+  if (approval.source === "job" && approval.jobId) jobs.resolveAsk(answered, answer);
+  else await router.answerEvent(approval.assistantId, option ? `用户选择了 ${option.key}：${option.label}` : answer);
+
+  return { status: 200, body: { approval: answered } };
+}
+
+function uniqueAssistantId(name: string): string {
+  const base = slugify(name);
+  return base;
+}
+
+/** 草稿 → 真正创建助手：带规则、补充说明、定时任务，两边对话各写一行说明。 */
+export async function createFromDraft(runtime: HobRuntime, draftId: string): Promise<ActionResult> {
+  const { store, bus, router, routines } = runtime;
+  const draft = store.draft(draftId);
+  if (!draft) return { status: 404, body: { error: "草稿不存在" } };
+  if (draft.status !== "pending") return { status: 409, body: { error: "这个草稿已经处理过了" } };
+  if (store.assistant(uniqueAssistantId(draft.name))) {
+    return { status: 409, body: { error: `已存在名称为「${draft.name}」的助手` } };
+  }
+
+  const now = new Date().toISOString();
+  const assistant: Assistant = {
+    id: uniqueAssistantId(draft.name),
+    name: draft.name,
+    duty: draft.duty,
+    dutyLong: draft.dutyLong,
+    // 和已有助手撞了头像就换个颜色（自画的图案各不相同，不算撞）
+    sprite: distinctSprite(draft.sprite, store.assistants().map((a) => a.sprite)),
+    ...(draft.prop ? { prop: draft.prop } : {}),
+    primary: false,
+    pinned: false,
+    hidden: false,
+    notify: true,
+    instructions: draft.instructions.join("\n"),
+    createdAt: now,
+    splitFrom: {
+      from: draft.assistantId,
+      at: now,
+      conversations: draft.carry.conversations,
+    },
+  };
+  store.saveAssistant(assistant);
+
+  store.saveRules(
+    assistant.id,
+    draft.askFirst.map((text) => ({ id: newId("r-"), text, mode: "ask" as const, changedAt: now })),
+  );
+  for (const item of draft.routines) {
+    try {
+      routines.create({
+        assistantId: assistant.id,
+        name: item.name,
+        instruction: item.instruction,
+        schedules: [item.schedule],
+      });
+    } catch {
+      // 模型给的 cron 不合法就跳过，不阻塞创建
+    }
+  }
+
+  const splitNote = `${monthDayText(runtime.settings.settings.general.timezone)} 由 Hob 创建 · 迁移 ${draft.carry.conversations} 段对话`;
+  await router.ensure(assistant.id);
+  await router.addItem(assistant.id, { kind: "note", icon: "split", text: splitNote });
+  // 新助手自己的开场：固定模板，不过模型
+  await router.addItem(assistant.id, {
+    kind: "assistant",
+    text: [`我是${assistant.name}，负责${assistant.duty}。`, ...(draft.routinesText ? [`定时任务：${draft.routinesText}`] : [])].join(
+      "\n",
+    ),
+  });
+  await router.addItem(draft.assistantId, { kind: "note", icon: "split", text: `已创建「${assistant.name}」` });
+
+  const created: Draft = { ...draft, status: "created", createdAssistantId: assistant.id };
+  store.saveDraft(created);
+  bus.emit({ type: "draft", draft: created });
+  bus.emit({ type: "assistant", assistant: router.summary(assistant) });
+  return { status: 200, body: { assistant: router.summary(assistant) } };
+}
+
+export function dismissDraft(runtime: HobRuntime, draftId: string): ActionResult {
+  const draft = runtime.store.draft(draftId);
+  if (!draft) return { status: 404, body: { error: "草稿不存在" } };
+  if (draft.status !== "pending") return { status: 409, body: { error: "这个草稿已经处理过了" } };
+  const next: Draft = { ...draft, status: "dismissed" };
+  runtime.store.saveDraft(next);
+  runtime.bus.emit({ type: "draft", draft: next });
+  return { status: 200, body: { draft: next } };
+}
+
+/**
+ * 并回 Hob（分出的反方向）：定时转给主助手、规则去重后追加、补充说明带上来源、
+ * 对话和档案移进 archive/，主助手对话里记一行。历史任务留在 jobs/，只补上助手名。
+ */
+export async function mergeAssistant(runtime: HobRuntime, id: string): Promise<ActionResult> {
+  const { store, bus, router, routines } = runtime;
+  const target = store.assistant(id);
+  if (!target) return { status: 404, body: { error: "助手不存在" } };
+  if (target.primary) return { status: 400, body: { error: "主助手不能并回自己" } };
+  const primary = store.assistants().find((assistant) => assistant.primary);
+  if (!primary) return { status: 409, body: { error: "主助手不存在，无法并回" } };
+  const live = store
+    .jobs()
+    .filter((job) => job.assistantId === id && (job.status === "running" || job.status === "queued" || job.status === "waiting"));
+  if (live.length) return { status: 409, body: { error: "请等任务结束后再并回" } };
+
+  // 先算清楚要转多少：规则同一条文字只留一份（主助手原来那条优先）
+  const moved = store.routines().filter((routine) => routine.assistantId === id);
+  const existing = store.rules(primary.id);
+  const now = new Date().toISOString();
+  const added: Rule[] = [];
+  for (const rule of store.rules(id)) {
+    const text = rule.text.trim();
+    if (!text || existing.some((item) => item.text.trim() === text)) continue;
+    const next: Rule = { id: newId("r-"), text, mode: rule.mode, changedAt: now };
+    existing.push(next);
+    added.push(next);
+  }
+
+  // 主助手对话里那行提示：模型没配好时开不了会话，这里就停下，别留下改了一半的状态
+  try {
+    await router.addItem(primary.id, {
+      kind: "note",
+      icon: "split",
+      text: `已并回「${target.name}」：转来 ${moved.length} 个定时任务、${added.length} 条规则`,
+    });
+  } catch (error) {
+    return { status: 409, body: { error: `无法写入 Hob 的对话：${error instanceof Error ? error.message : String(error)}` } };
+  }
+
+  for (const routine of moved) {
+    const next = { ...routine, assistantId: primary.id };
+    store.saveRoutine(next);
+    bus.emit({ type: "routine", routine: next });
+  }
+  // cron 的归属和时区都在建的时候定死，改完所属助手重排一遍
+  if (moved.length) routines.reload();
+
+  if (added.length) {
+    store.saveRules(primary.id, existing);
+    bus.emit({ type: "profile", assistantId: primary.id });
+  }
+
+  const extra = target.instructions.trim();
+  const instructions = extra
+    ? [primary.instructions.trim(), `来自「${target.name}」：`, extra].filter(Boolean).join("\n")
+    : primary.instructions;
+  store.saveAssistant({ ...primary, instructions });
+
+  // 这个助手挂着没答的审批：助手没了，卡片一并结束
+  for (const approval of store.approvals()) {
+    if (approval.assistantId !== id || approval.status !== "pending") continue;
+    const expired: Approval = { ...approval, status: "expired" };
+    store.saveApproval(expired);
+    bus.emit({ type: "approval", approval: expired });
+  }
+
+  // 历史任务留在 jobs/：记下当时的助手名，详情页在助手没了以后照样显示
+  for (const job of store.jobs()) {
+    if (job.assistantId !== id || job.assistantName) continue;
+    store.saveJob({ ...job, assistantName: target.name });
+  }
+
+  router.forget(id);
+  store.archiveAssistant(id, `${id}-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+  bus.emit({ type: "assistant_removed", id });
+  const merged = router.summary(store.assistant(primary.id)!);
+  bus.emit({ type: "assistant", assistant: merged });
+  return { status: 200, body: { assistant: merged } };
+}

package/server/src/boot.ts

@@ -0,0 +1,85 @@
+// 启动入口：在加载任何引擎模块之前把环境定下来，再交给 main.ts。
+//
+// 引擎里有模块在加载时就算好目录（`utils/tools-manager.js` 的 TOOLS_DIR、`utils/shell.js`
+// 的 PATH 前缀都来自 `getAgentDir()`），靠传参管不到，只能先改环境变量。所以这个文件
+// 只能静态导入 node 内置模块和不碰引擎的小工具，main.ts 必须动态导入。
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { engineDir, loreDir, memoryDir, resolveHome } from "./config.ts";
+
+/** 从本机导入时要读的目录（只记路径，不记密钥）。 */
+export interface LocalConfigDirs {
+  /** 原 PI_CODING_AGENT_DIR，没有就是 ~/.pi/agent */
+  piDir: string;
+  /** 原 LORE_HOME，没有就是 ~/.lore */
+  loreHome: string;
+}
+
+/** 从 shell 继承、但必须由 Hob 自己管的变量：删掉，任务里的 bash 也读不到用户的凭据。 */
+const INHERITED_CONFIG_ENV = [
+  "LORE_BASE_URL",
+  "LORE_API_TOKEN",
+  "API_TOKEN",
+  "LORE_CLIENT_TYPE",
+  "LORE_SKILLS_ENABLED",
+];
+
+/**
+ * 从启动终端继承的模型密钥：Hob 的服务商 Key 只从自己的 secrets.json 来，不读环境变量。
+ * 留着的话，任务里的命令能直接拿到用户别的客户端的 Key。
+ */
+const INHERITED_MODEL_ENV = [
+  "OPENAI_API_KEY",
+  "OPENAI_BASE_URL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "OPENROUTER_API_KEY",
+  "XAI_API_KEY",
+  "GROQ_API_KEY",
+  "MISTRAL_API_KEY",
+  "CLAUDECODE",
+];
+
+/** 按前缀删：CLAUDE_CODE_OAUTH_TOKEN 这类 Claude Code 自己的变量一个不留。 */
+const INHERITED_ENV_PREFIXES = ["CLAUDE_CODE_"];
+
+/**
+ * 把引擎和记忆的环境变量指到 HOB_HOME，删掉从 shell 继承的 Lore 凭据、模型密钥和 Claude Code 的变量，
+ * 返回本机配置的目录。纯函数：只改传进来的 env，不读 process.env。
+ */
+export function applyEngineEnv(env: NodeJS.ProcessEnv, home: string): LocalConfigDirs {
+  const piDir = env.HOB_LOCAL_PI_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
+  const loreHome = env.HOB_LOCAL_LORE_HOME?.trim() || env.LORE_HOME?.trim() || join(homedir(), ".lore");
+  env.HOB_LOCAL_PI_DIR = piDir;
+  env.HOB_LOCAL_LORE_HOME = loreHome;
+  env.PI_CODING_AGENT_DIR = engineDir(home);
+  env.PI_MEMORY_DIR = memoryDir(home);
+  env.LORE_HOME = loreDir(home);
+  for (const key of [...INHERITED_CONFIG_ENV, ...INHERITED_MODEL_ENV]) delete env[key];
+  for (const key of Object.keys(env)) {
+    if (INHERITED_ENV_PREFIXES.some((prefix) => key.startsWith(prefix))) delete env[key];
+  }
+  return { piDir, loreHome };
+}
+
+/** 命令行入口：`tsx server/src/boot.ts` 和 npm 包的 `hob` 命令都走这里。 */
+export function boot(): void {
+  const home = resolveHome();
+  applyEngineEnv(process.env, home);
+  import("./main.ts")
+    .then(({ startHob }) => startHob({ home }))
+    .then((server) => {
+      console.log(`Hob 在 http://${server.runtime.config.host}:${server.port}（数据目录 ${server.runtime.home}）`);
+    })
+    .catch((error: unknown) => {
+      console.error(error instanceof Error ? error.message : error);
+      process.exit(1);
+    });
+}
+
+const isMain = process.argv[1]?.endsWith("boot.ts") || process.argv[1]?.endsWith("boot.js");
+if (isMain) boot();

package/server/src/bus.ts

@@ -0,0 +1,21 @@
+import type { HobEvent } from "../../shared/types.ts";
+
+/** 进程内事件广播：SSE 订阅者 + 内部关心状态的模块。 */
+export class Bus {
+  private listeners = new Set<(event: HobEvent) => void>();
+
+  subscribe(listener: (event: HobEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  emit(event: HobEvent): void {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(event);
+      } catch {
+        // 单个订阅者出错不影响其他订阅者
+      }
+    }
+  }
+}