hob-bot 1.0.3 → 1.0.4

package/dist/web/index.html

@@ -23,8 +23,8 @@
     <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-Dyw5G8Pg.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C72gAwgN.css">
+    <script type="module" crossorigin src="/assets/index-BqkIAlk9.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BCGEZvgg.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/web/mock//347/201/253/346/230/237/346/227/245/350/220/275/347/244/272/346/204/217/345/233/276.md

@@ -0,0 +1,34 @@
+# 火星日落为什么是蓝色的
+
+火星大气很稀薄，但飘着大量**细小的尘埃**。尘埃颗粒的大小和蓝光波长相近，蓝光会被集中散射到太阳周围，所以日落时太阳附近是一圈蓝。
+
+## 和地球对比
+
+| 项目 | 地球 | 火星 |
+| --- | --- | --- |
+| 大气压 | 1013 hPa | 约 6 hPa |
+| 主要散射体 | 气体分子 | 尘埃颗粒 |
+| 白天天空 | 蓝色 | 黄褐色 |
+| 日落颜色 | 红橙 | **蓝色** |
+
+## 要点
+
+- 尘埃颗粒直径约 1.5 μm，对蓝光的**前向散射**最强
+- 太阳越低，光穿过的尘埃越多，蓝晕越明显
+- 好奇号在 2015 年拍到过完整过程
+
+1. 白天：尘埃把红光散到全天空，天空发黄
+2. 日落：前向散射的蓝光留在太阳周围
+
+> 数据来自 NASA 好奇号任务公开资料。
+
+### 示意图源码
+
+```mermaid
+graph LR
+  太阳 --> 尘埃 --> 蓝晕
+```
+
+---
+
+验证状态：**明确 token 被拒**，`401 Unauthorized`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hob-bot",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "A self-hosted personal assistant that runs real work as background jobs.",
   "license": "MIT",
   "repository": {
@@ -37,9 +37,11 @@
     "@juicesharp/rpiv-config": "2.15.0",
     "@juicesharp/rpiv-web-tools": "2.15.0",
     "croner": "^9.0.0",
+    "github-markdown-css": "^5.9.0",
     "hono": "^4.6.0",
     "katex": "^0.19.1",
-    "marked": "^15.0.0",
+    "marked": "^18.1.3",
+    "marked-cjk-friendly": "^0.1.3",
     "pi-memory": "0.4.2",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

package/server/src/actions.ts

@@ -34,6 +34,9 @@ export async function answerApproval(runtime: HobRuntime, approvalId: string, in
     answeredAt: new Date().toISOString(),
   };
   store.saveApproval(answered);
+  // 转交里 Router 问的：答案回到目标助手接着办，办完才算转交结束（任务里的提问由任务自己接着跑）
+  const delegation = approval.source === "job" ? undefined : store.delegations().find((item) => item.approvalIds?.includes(approval.id));
+  const delegationId = delegation && runtime.delegations.resume(delegation.id) ? delegation.id : undefined;
   bus.emit({ type: "approval", approval: answered });
 
   if (option?.always) {
@@ -59,7 +62,11 @@ export async function answerApproval(runtime: HobRuntime, approvalId: string, in
   // 回给模型：自己写的那句要说明是用户写的、没选给出的选项
   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);
+  else {
+    const reply = option ? `用户选择了 ${option.key}：${option.label}` : answer;
+    if (delegationId) void router.relay(approval.assistantId, reply, delegationId).catch(() => runtime.delegations.turnEnded(delegationId, "目标助手处理失败", true));
+    else await router.answerEvent(approval.assistantId, reply);
+  }
 
   return { status: 200, body: { approval: answered } };
 }

package/server/src/delegations.ts

@@ -32,7 +32,7 @@ export class DelegationManager {
       throw error;
     }
     this.runtime.bus.emit({ type: "delegation", delegation });
-    void this.runtime.router.relay(to, text, delegation.id).catch((error: unknown) => {
+    void this.runtime.router.relay(to, `转自 Hob：${text}`, delegation.id).catch((error: unknown) => {
       this.turnEnded(delegation.id, error instanceof Error ? error.message : String(error), true);
     });
     return delegation;
@@ -54,10 +54,26 @@ export class DelegationManager {
   turnEnded(id: string, reply: string, failed = false): void {
     const record = this.runtime.store.delegation(id);
     if (!record || record.turnFinished) return;
-    this.runtime.store.saveDelegation({ ...record, reply, turnFinished: true, ...(failed ? { turnFailed: true } : {}) });
+    const replies = [record.reply, reply].filter(Boolean).join("\n");
+    this.runtime.store.saveDelegation({ ...record, reply: replies, turnFinished: true, ...(failed ? { turnFailed: true } : {}) });
     this.update(id);
   }
 
+  /**
+   * 转交里派的任务结束了、或用户答了转交里的提问：结果先回到目标助手，它这一轮可能接着再派任务、再问用户。
+   * 这一轮跑完、名下没有在跑的任务，转交才算结束，Hob 才收到结果；
+   * 否则目标助手还在处理时 Hob 就会收到「已结束」，另开任务和它冲突。
+   * 调用方要在发出 job/approval 事件之前调用，再用 router.relay 把结果送给目标助手。
+   * 返回 false 表示转交已经回流过（或已退回），结果按普通事件处理。
+   */
+  resume(id: string): boolean {
+    const record = this.runtime.store.delegation(id);
+    if (!record || record.reportedAt || record.status === "returned" || record.status === "interrupted") return false;
+    const { turnFailed: _failed, ...rest } = record;
+    this.runtime.store.saveDelegation({ ...rest, turnFinished: false });
+    return true;
+  }
+
   returnToHob(id: string, text: string, reason: string): void {
     const record = this.runtime.store.delegation(id);
     if (!record || record.turnFinished) throw new Error("转交已结束，无法退回");
@@ -102,6 +118,8 @@ export class DelegationManager {
     for (const record of this.runtime.store.delegations()) {
       if (record.reportedAt || !["running", "waiting", "returned"].includes(record.status)) continue;
       if (record.jobIds.some((id) => { const job = this.runtime.store.job(id); return job && ["running", "queued", "waiting"].includes(job.status); })) continue;
+      // 目标助手在等用户选：审批卡重启后还在，答了照常继续，不算中断
+      if (record.approvalIds?.some((id) => this.runtime.store.approval(id)?.status === "pending")) continue;
       const now = new Date().toISOString();
       const next: Delegation = { ...record, status: "interrupted", endedAt: now, reportedAt: now };
       this.runtime.store.saveDelegation(next);

package/server/src/http.ts

@@ -26,6 +26,7 @@ import { answerApproval, createFromDraft, dismissDraft, mergeAssistant } from ".
 import { setPassword } from "./config.ts";
 import { newId } from "./ids.ts";
 import { listJobFiles, lookupFile, MAX_TEXT_BYTES } from "./files.ts";
+import { thumbnail } from "./thumbs.ts";
 import { localLoreHome, readLocalLore, readLocalLoreConnection } from "./imports.ts";
 import { checkImageSettings, generateImage, imageConfigured, imageKey, IMAGE_KEY_SECRET } from "./image.ts";
 import { checkAssistantModels, checkModelsPatch } from "./models.ts";
@@ -494,7 +495,8 @@ export function createApp(runtime: HobRuntime, options: { webDir?: string; home:
       files?: string[];
     };
     const text = (body.text ?? "").trim();
-    if (!text) return c.json({ error: "消息内容为空" }, 400);
+    // 和 Telegram 一样，只发图片 / 文件不写字也行
+    if (!text && !body.files?.length) return c.json({ error: "消息内容为空" }, 400);
     const item = await router.send(id, {
       text,
       ...(body.quote ? { quote: body.quote } : {}),
@@ -709,7 +711,7 @@ export function createApp(runtime: HobRuntime, options: { webDir?: string; home:
     return c.json({ files: saved.map((item) => item.path), file: saved[0] });
   });
 
-  app.get("/api/files", (c) => {
+  app.get("/api/files", async (c) => {
     const requested = c.req.query("path");
     const lookup = requested ? lookupFile(options.home, requested) : null;
     const nosniff = { "x-content-type-options": "nosniff" };
@@ -728,6 +730,11 @@ export function createApp(runtime: HobRuntime, options: { webDir?: string; home:
       const name = encodeURIComponent(info.name);
       headers["content-disposition"] = `${c.req.query("inline") === "1" ? "inline" : "attachment"}; filename*=UTF-8''${name}`;
     }
+    // 对话里的图片只要缩略图（?thumb=1）；缩不了 / 不值得缩就给原图
+    if (c.req.query("thumb") === "1" && info.kind === "image") {
+      const thumb = await thumbnail(options.home, info);
+      if (thumb) return c.body(new Uint8Array(thumb.data), 200, { ...nosniff, "content-type": thumb.mime, "cache-control": "private, max-age=604800" });
+    }
     // 文本只拉 1 MB：预览面板对超大文件只显示前 1 MB，剩下的走下载
     const whole = readFileSync(info.path);
     const body = info.text && c.req.query("truncate") === "1" ? whole.subarray(0, MAX_TEXT_BYTES) : whole;

package/server/src/jobs.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { basename, extname } from "node:path";
 import type { AgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
 import type { ImageContent } from "@earendil-works/pi-ai";
@@ -50,13 +50,17 @@ export function hasImageFiles(files: string[] | undefined): boolean {
   return (files ?? []).some((file) => isImagePath(file));
 }
 
-/** 附件里的图片读成 pi 的图片块（读不出来就跳过，不把整个任务拖死）。 */
-function imageContents(files: string[] | undefined): ImageContent[] {
+/** 一张图超过这个大小就不当图片给模型（只留路径），免得把会话撑得太大。 */
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+/** 附件里的图片读成 pi 的图片块（读不出来、太大就跳过，不把整个回合拖死）。任务和对话共用。 */
+export function imageContents(files: string[] | undefined): ImageContent[] {
   const out: ImageContent[] = [];
   for (const file of files ?? []) {
     const mimeType = IMAGE_TYPES[extname(file).toLowerCase()];
     if (!mimeType) continue;
     try {
+      if (statSync(file).size > MAX_IMAGE_BYTES) continue;
       out.push({ type: "image", data: readFileSync(file).toString("base64"), mimeType });
     } catch {
       // 文件没了或读不了：不带图片，靠任务说明的路径自己去读
@@ -91,6 +95,8 @@ interface WorkerState {
   stopped?: boolean;
   /** 正在跑的工具步骤，按 toolCallId 存：输出更新、跑完都按同一个步骤 id 替换 */
   steps: Map<string, JobStep>;
+  /** 你补的话已交给任务、还没被读到（任务做完当前这一步才读）；读到时换成正式的一行 */
+  queued: JobStep[];
 }
 
 /** 推给助手的任务结果最多带这么多字的报告。 */
@@ -166,10 +172,11 @@ export class JobManager {
   transcript(jobId: string): JobStep[] {
     const job = this.store.job(jobId);
     if (!job) return [];
-    return deriveSteps(this.store.workerFile(jobId), {
+    const steps = deriveSteps(this.store.workerFile(jobId), {
       cwd: job.cwd ?? "",
       save: (stepId, text) => this.store.writeStepOutput(jobId, stepId, text),
     });
+    return [...steps, ...(this.workers.get(jobId)?.queued ?? [])];
   }
 
   async start(assistantId: string, input: StartJobInput): Promise<Job> {
@@ -297,6 +304,7 @@ export class JobManager {
       askedFollowUp: false,
       lastActivityAt: Date.now(),
       steps: new Map(),
+      queued: [],
     };
     this.workers.set(running.id, worker);
     const images = imageContents(running.inputs);
@@ -345,6 +353,15 @@ export class JobManager {
       }
       if (event.type === "message_start" || event.type === "agent_start") {
         worker.lastActivityAt = Date.now();
+        if (event.type === "message_start" && event.message.role === "user") {
+          // 补的那句被任务读到了：id 和 transcript 推导出来的一样，前端拿它换掉「等待读取」那行
+          const text = textOfContent(event.message.content).trim();
+          const index = worker.queued.findIndex((step) => step.text === text);
+          if (index >= 0) {
+            worker.queued.splice(index, 1);
+            this.emitStep(worker, { id: `u${event.message.timestamp}`, kind: "text", at: new Date(event.message.timestamp).toISOString(), from: "user", text });
+          }
+        }
         return;
       }
       if (event.type === "agent_settled") void this.onSettled(worker);
@@ -535,6 +552,8 @@ export class JobManager {
       ...(options.files?.length ? { files: options.files } : {}),
     };
     this.store.saveJob(next);
+    // 转交里的任务：先把转交重新打开，结果由目标助手接着处理完才回流 Hob（见 DelegationManager.resume）
+    const delegationId = !job.routineId && job.delegationId && this.runtime.delegations.resume(job.delegationId) ? job.delegationId : undefined;
     this.bus.emit({ type: "job", job: next });
     pushJobEnd({ push: this.runtime.push, store: this.store }, next);
     this.publishBusy(job.assistantId);
@@ -565,13 +584,9 @@ export class JobManager {
           .catch(() => undefined);
       }
     } else if (assistant) {
-      await this.runtime.router
-        .event(
-          job.assistantId,
-          `任务「${job.title}」${statusText}${eventSummary ? `：${eventSummary}` : options.reason ? `：${options.reason}` : ""}${filesNote}`,
-          cont,
-        )
-        .catch(() => undefined);
+      const text = `任务「${job.title}」${statusText}${eventSummary ? `：${eventSummary}` : options.reason ? `：${options.reason}` : ""}${filesNote}`;
+      if (delegationId) void this.runtime.router.relay(job.assistantId, text, delegationId, cont).catch(() => this.runtime.delegations.turnEnded(delegationId, "目标助手处理失败", true));
+      else await this.runtime.router.event(job.assistantId, text, cont).catch(() => undefined);
     }
   }
 
@@ -605,8 +620,17 @@ export class JobManager {
   async reply(jobId: string, text: string): Promise<void> {
     const worker = this.workers.get(jobId);
     if (!worker?.session) throw new Error("这个任务当前未在运行。");
-    if (worker.session.isStreaming) await worker.session.steer(text);
-    else await worker.session.prompt(text);
+    // 先显示出来：任务在跑命令时要等这一步做完才读到，界面上标着「等待读取」
+    const step: JobStep = { id: `q${Date.now()}-${worker.queued.length}`, kind: "text", at: new Date().toISOString(), from: "user", text, queued: true };
+    worker.queued.push(step);
+    this.emitStep(worker, step);
+    try {
+      if (worker.session.isStreaming) await worker.session.steer(text);
+      else void worker.session.prompt(text).catch(() => { worker.queued = worker.queued.filter((item) => item !== step); });
+    } catch (error) {
+      worker.queued = worker.queued.filter((item) => item !== step);
+      throw error;
+    }
   }
 
   async stop(jobId: string): Promise<void> {
@@ -670,23 +694,31 @@ export class JobManager {
       if (worker) worker.job = next;
     }
     worker?.ask?.(answer);
-    if (worker) worker.ask = undefined;
+    if (worker) {
+      worker.ask = undefined;
+      worker.lastActivityAt = Date.now();
+    }
   }
 
   startWatchdog(): void {
     this.watchdog ??= setInterval(() => {
-      const idleMs = this.runtime.settings.settings.work.jobStallMinutes * 60_000;
-      for (const [jobId, worker] of this.workers) {
-        if (Date.now() - worker.lastActivityAt > idleMs) {
-          void this.finish(jobId, "stuck", undefined, `${Math.round(idleMs / 60_000)} 分钟无响应`);
-        }
-      }
+      this.checkStalls();
       // 并发小了以后（设置里改的），排队的任务还在等，这里补一次泵
       this.pump();
     }, 30_000);
     this.watchdog.unref?.();
   }
 
+  checkStalls(now = Date.now()): void {
+    const idleMs = this.runtime.settings.settings.work.jobStallMinutes * 60_000;
+    for (const [jobId, worker] of this.workers) {
+      // 在等用户答提问不算没响应：等多久都是用户的事
+      if (!worker.ask && now - worker.lastActivityAt > idleMs) {
+        void this.finish(jobId, "stuck", undefined, `${Math.round(idleMs / 60_000)} 分钟无响应`);
+      }
+    }
+  }
+
   stopWatchdog(): void {
     if (this.watchdog) clearInterval(this.watchdog);
     this.watchdog = undefined;

package/server/src/prompt.ts

@@ -169,6 +169,8 @@ export function buildSystemPrompt(store: Store, assistantId: string, settings: P
         .join("，")}；hob 那个火苗是主助手专用的，不要用。`,
       "- 库里没有贴合职责的道具时，可以自己画一件：sprite 填 custom，prop_art 给出 art、pal、dx 画一件 16×16 的像素道具；画得不合适会返回原因，照着改好重发就行。",
       "- 有更合适的助手时用 message_assistant 把任务转过去。",
+      "- 转交时把用户原话转过去，只补充对方需要的背景。不要替用户加验收标准、测试方案或额外要求，把小事写成大工程。",
+      "- 转交出去的事由对方负责到底。结果回来之前，不要自己 start_job 做同一件事。结果回来后如果没办完，转回同一个助手接着办，或者如实告诉用户。",
     );
   }
   lines.push("- 用户问你在做什么、有什么在运行，可依据任务事件回答，不要编造进度。");

package/server/src/push.ts

@@ -1,4 +1,5 @@
 // HOB_HOME/push.json：VAPID 密钥 + 订阅设备（0600、原子写）。推送走 web-push。
+import { plainText } from "../../shared/plain-text.ts";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
@@ -269,7 +270,7 @@ export function pushApproval(deps: NotifyDeps, approval: Approval): void {
   const assistant = deps.store.assistant(approval.assistantId);
   if (!assistant?.notify) return;
   // 推送失败不能影响审批本身（也不能变成未处理的 rejection 把进程带走）
-  void deps.push.send({ title: assistant.name, body: approval.title, url: openUrl(approval.assistantId) }).catch(() => undefined);
+  void deps.push.send({ title: assistant.name, body: plainText(approval.title), url: openUrl(approval.assistantId) }).catch(() => undefined);
 }
 
 /** 任务受阻或失败：所属助手开了通知才推送。 */
@@ -278,7 +279,7 @@ export function pushJobEnd(deps: NotifyDeps, job: Job): void {
   const assistant = deps.store.assistant(job.assistantId);
   if (!assistant?.notify) return;
   const what = job.status === "stuck" ? "受阻" : "失败";
-  const reason = job.statusReason ? `：${job.statusReason}` : "";
+  const reason = job.statusReason ? `：${plainText(job.statusReason)}` : "";
   void deps.push
     .send({ title: assistant.name, body: `任务「${job.title}」${what}${reason}`, url: openUrl(job.assistantId) })
     .catch(() => undefined);

package/server/src/router.ts

@@ -25,6 +25,7 @@ import { MEMORY_WRITE_TOOLS, memoryNoteText } from "./memory.ts";
 import { buildSystemPrompt, type PromptModel } from "./prompt.ts";
 import { availableSkills } from "./skills.ts";
 import { activityLabel, thinkingLine } from "./router-activity.ts";
+import { imageContents } from "./jobs.ts";
 
 export const ITEM_TYPE = "hob.item";
 export const USER_TYPE = "hob.user";
@@ -328,7 +329,7 @@ export class RouterManager {
     if (event.type === "agent_end" || (event.type === "message_end" && event.message.role === "assistant" && ["error", "aborted"].includes(event.message.stopReason))) this.setActivity(state, null);
     if (event.type === "message_start" && event.message.role === "custom" && event.message.customType === EVENT_TYPE) {
       const details = event.message.details as EventDetails | undefined;
-      if (details?.delegationId) {
+      if (details?.delegationId && details.delegationId !== state.currentDelegationId) {
         state.currentDelegationId = details.delegationId;
         state.delegationReply = [];
         state.terminatingTools = new Set();
@@ -340,7 +341,7 @@ export class RouterManager {
       const failed = event.message.stopReason === "error" || event.message.stopReason === "aborted";
       if (failed || !event.toolResults.length || event.toolResults.every((tool) => state.terminatingTools?.has(tool.toolCallId))) {
         const id = state.currentDelegationId;
-        const reply = state.delegationReply?.join("\n") || (failed ? event.message.errorMessage || "目标助手处理失败" : "（没有回复）");
+        const reply = state.delegationReply?.join("\n") || (failed ? event.message.errorMessage || "目标助手处理失败" : "");
         state.currentDelegationId = undefined;
         state.delegationReply = undefined;
         state.terminatingTools = undefined;
@@ -705,7 +706,7 @@ export class RouterManager {
     const lines = [body.text];
     if (body.quote) lines.unshift(`（引用我之前的话：「${body.quote.text}」）`);
     if (body.files?.length) lines.push(`附件：${body.files.join("、")}`);
-    const promptText = lines.join("\n");
+    const promptText = lines.filter(Boolean).join("\n");
 
     this.touch(assistantId);
     state.running += 1;
@@ -715,9 +716,11 @@ export class RouterManager {
       try {
         await this.applyConversationModel(state);
         refreshSystemPrompt(state.session!);
-        if (state.session!.isStreaming) await state.session!.steer(promptText);
+        // 对话模型能看图就把图片直接给它（路径照样写在「附件」里，派任务时还能交出去）；看不了图就只有路径
+        const images = state.session!.model?.input.includes("image") ? imageContents(body.files) : [];
+        if (state.session!.isStreaming) await state.session!.steer(promptText, images.length ? images : undefined);
         else {
-          await state.session!.prompt(promptText);
+          await state.session!.prompt(promptText, images.length ? { images } : undefined);
           await this.reportTurnError(state);
         }
       } catch (error) {
@@ -869,8 +872,9 @@ export class RouterManager {
   }
 
   /** 直接走事件的 followUp 队列，实际收到这条消息时才开始关联任务。 */
-  async relay(targetAssistantId: string, text: string, delegationId: string): Promise<void> {
-    const success = await this.pushEvent(targetAssistantId, `转自 Hob：${text}`, { delegationId });
+  /** 把事件当作转交的一轮送给目标助手；这一轮没正常收尾就把转交记为受阻，不会一直挂着。 */
+  async relay(targetAssistantId: string, text: string, delegationId: string, details?: EventDetails): Promise<void> {
+    const success = await this.pushEvent(targetAssistantId, text, { ...details, delegationId });
     if (!success || !this.store.delegation(delegationId)?.turnFinished) {
       this.runtime.delegations.turnEnded(delegationId, "目标助手处理失败或转交被中断", true);
     }

package/server/src/thumbs.ts

@@ -0,0 +1,49 @@
+// 对话里的图片缩略图：长边 720px 的 JPEG/PNG，按（路径、大小、修改时间）缓存在 HOB_HOME/cache/thumbs。
+// 对话列表只拉缩略图，点开预览才拉原图。原图本来就小、GIF（可能是动图）、缩不了的，都直接给原图。
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resizeImage } from "@earendil-works/pi-coding-agent";
+
+const THUMB_EDGE = 720;
+const RESIZABLE = new Set(["image/jpeg", "image/png", "image/webp"]);
+const inflight = new Map<string, Promise<Thumb | null>>();
+
+export interface Thumb {
+  data: Uint8Array;
+  mime: string;
+}
+
+export async function thumbnail(home: string, file: { path: string; size: number; modifiedAt: string; mime: string }): Promise<Thumb | null> {
+  if (!RESIZABLE.has(file.mime)) return null;
+  const key = createHash("sha1").update(`${file.path}\0${file.size}\0${file.modifiedAt}`).digest("hex");
+  const dir = join(home, "cache", "thumbs");
+  for (const [ext, mime] of [["jpg", "image/jpeg"], ["png", "image/png"]] as const) {
+    const cached = join(dir, `${key}.${ext}`);
+    if (existsSync(cached)) return { data: readFileSync(cached), mime };
+  }
+  // 原图大小就不值得缩：记一个空标记，下次直接给原图
+  if (existsSync(join(dir, `${key}.orig`))) return null;
+  let job = inflight.get(key);
+  if (!job) {
+    job = make(dir, key, file).finally(() => inflight.delete(key));
+    inflight.set(key, job);
+  }
+  return job;
+}
+
+async function make(dir: string, key: string, file: { path: string; mime: string }): Promise<Thumb | null> {
+  const resized = await resizeImage(readFileSync(file.path), file.mime, { maxWidth: THUMB_EDGE, maxHeight: THUMB_EDGE, maxBytes: 400_000, jpegQuality: 82 }).catch(() => null);
+  mkdirSync(dir, { recursive: true });
+  if (!resized || !resized.wasResized) {
+    writeFileSync(join(dir, `${key}.orig`), "");
+    return null;
+  }
+  const data = Buffer.from(resized.data, "base64");
+  const target = join(dir, `${key}.${resized.mimeType === "image/png" ? "png" : "jpg"}`);
+  // 先写临时文件再改名：并发读到的不会是半截图
+  const tmp = `${target}.${process.pid}.tmp`;
+  writeFileSync(tmp, data);
+  renameSync(tmp, target);
+  return { data, mime: resized.mimeType };
+}

package/shared/media.ts

@@ -15,3 +15,9 @@ export function isImagePath(path: string): boolean {
   if (dot === -1) return false;
   return path.slice(dot).toLowerCase() in IMAGE_TYPES;
 }
+
+/** 上传的附件存成 u-xxxxxx-原名（server 的 /api/uploads），给人看时去掉前面的编号。 */
+export function attachmentName(path: string): string {
+  const base = path.split("/").pop() ?? path;
+  return base.replace(/^u-[a-z0-9]{6}-/, "");
+}

package/shared/plain-text.ts

@@ -0,0 +1,31 @@
+// 把 Markdown 收成一行纯文字：首页列表的预览、引用条、推送通知都用它，不显示 ** # ` 这些记号。
+// 只去记号、留内容；蛇形命名里的下划线（snake_case）这种不在词边上的不动。
+
+export function plainText(md: string): string {
+  return (
+    md
+      // 代码块：留代码，去围栏和语言名
+      .replace(/```[^\n]*\n?([\s\S]*?)```/g, "$1")
+      // 图片留说明文字，链接留链接文字
+      .replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1")
+      .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+      // 行首：标题、引用、列表记号、任务框
+      .replace(/^[ \t]*#{1,6}[ \t]+/gm, "")
+      .replace(/^[ \t]*>[ \t]?/gm, "")
+      .replace(/^[ \t]*(?:[-*+]|\d+[.)])[ \t]+(?:\[[ xX]\][ \t]+)?/gm, "")
+      // 表格：分隔行整行去掉，竖线换成空格
+      .replace(/^[ \t]*\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)*\|?[ \t]*$/gm, "")
+      .replace(/[ \t]*\|[ \t]*/g, " ")
+      // 分隔线
+      .replace(/^[ \t]*(?:[-*_][ \t]*){3,}$/gm, "")
+      // 粗体、斜体、删除线、行内代码
+      .replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, "$2")
+      .replace(/~~(?=\S)([\s\S]*?\S)~~/g, "$1")
+      .replace(/(^|[^\w*])\*(?=\S)([^*\n]*?\S)\*(?![\w*])/g, "$1$2")
+      .replace(/(^|[^\w])_(?=\S)([^_\n]*?\S)_(?!\w)/g, "$1$2")
+      .replace(/`([^`\n]+)`/g, "$1")
+      // 多行收成一行
+      .replace(/\s+/g, " ")
+      .trim()
+  );
+}