hob-bot 0.0.0-stage → 1.0.2

package/server/src/models.ts

@@ -0,0 +1,358 @@
+// 模型名单：从引擎的模型注册表拿可用的聊天模型，解析每个角色 / 每个任务用哪个模型。
+import type { Model } from "@earendil-works/pi-ai";
+import type {
+  Assistant,
+  ModelInfo,
+  ModelPick,
+  ModelSettings,
+  RosterEntry,
+  SettingsPatch,
+  ThinkingLevel,
+  ThinkingLevelMapSetting,
+} from "../../shared/types.ts";
+import { contextText, guessModelScores, scoreSummary } from "../../shared/model-note.ts";
+import {
+  THINKING_LEVELS,
+  THINKING_TEXT,
+  THINKING_TEXT_MAX,
+  isThinkingLevel,
+  normalizeThinkingMap,
+  thinkingPlan,
+} from "../../shared/thinking.ts";
+import type { PiHost } from "./pi.ts";
+
+// 思考档的规则（档位、默认范围、默认字符、规整）在 shared/thinking.ts：前后端和假后端共用一份。
+export { THINKING_LEVELS, isThinkingLevel };
+
+/** 保存自定义思考档前的校验：不合法就报错（http 回 400），界面原样显示原因。 */
+export function checkThinkingMap(raw: unknown): ThinkingLevelMapSetting {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("思考档格式无效：应为「档位: 字符」的对象。");
+  }
+  const input = raw as Record<string, unknown>;
+  const map: ThinkingLevelMapSetting = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (!isThinkingLevel(key)) throw new Error(`思考档无效：可选值为 ${THINKING_LEVELS.join("、")}。`);
+    if (value === null) {
+      map[key] = null;
+      continue;
+    }
+    if (typeof value !== "string") throw new Error(`「${THINKING_TEXT[key]}」这一档的字符无效。`);
+    // 空串 = 按服务商协议的默认，不算错
+    const text = value.trim();
+    if (text.length > THINKING_TEXT_MAX) {
+      throw new Error(`「${THINKING_TEXT[key]}」这一档的字符最多 ${THINKING_TEXT_MAX} 个字。`);
+    }
+    map[key] = text;
+  }
+  if (map.off === null) throw new Error("「关闭」这一档不能删。");
+  return map;
+}
+
+/** 这个模型能用哪些思考档（Hob 按设置算出来的）：不会推理的模型只有 off。 */
+export function thinkingLevelsOf(model: ModelInfo | undefined): ThinkingLevel[] {
+  return model?.thinkingLevels ?? ["off"];
+}
+
+/** 想要的档模型没有时往下取最近的一档；一档都没有才是 off。 */
+export function fitThinking(levels: ThinkingLevel[], wants: ThinkingLevel): ThinkingLevel {
+  const rank = THINKING_LEVELS.indexOf(wants);
+  return [...levels].reverse().find((level) => THINKING_LEVELS.indexOf(level) <= rank) ?? "off";
+}
+
+/** 这一轮（对话或任务）的思考档：设置里的档这个模型没有，就往下取最近的一档。 */
+export function thinkingForPick(pick: ModelPick, catalog: ModelCatalog): ThinkingLevel {
+  return fitThinking(thinkingLevelsOf(catalog.find(pick.ref)), pick.thinking);
+}
+
+function infoOf(model: Model<any>, settings: ModelSettings): ModelInfo {
+  const ref = `${model.provider}/${model.id}`;
+  const reasoning = Boolean(model.reasoning);
+  const plan = thinkingPlan(model.id, reasoning, settings.thinking?.[ref], model.api);
+  return {
+    ref,
+    provider: model.provider,
+    id: model.id,
+    name: model.name || model.id,
+    reasoning,
+    thinkingLevels: plan.levels,
+    input: model.input.filter((kind): kind is "text" | "image" => kind === "text" || kind === "image"),
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    cost: { input: model.cost?.input ?? 0, output: model.cost?.output ?? 0 },
+  };
+}
+
+/** 有凭据可用的聊天模型，缓一小会儿（设置页和每次分派任务都要看它）。 */
+export class ModelCatalog {
+  private list: ModelInfo[] = [];
+  private loadedAt = 0;
+  private loading?: Promise<void>;
+
+  constructor(
+    private readonly pi: PiHost,
+    /** 每次现读设置：思考档只看 Hob 自己的设置，不看引擎注册表里自带的映射 */
+    private readonly settings: () => ModelSettings,
+  ) {}
+
+  /** 上一次拿到的名单（同步，提示词用；还没拉过就是空）。 */
+  snapshot(): ModelInfo[] {
+    return this.list;
+  }
+
+  /** 服务商变了：下一次 get() 重新拉。 */
+  reset(): void {
+    this.list = [];
+    this.loadedAt = 0;
+  }
+
+  find(ref: string): ModelInfo | undefined {
+    return this.list.find((model) => model.ref === ref);
+  }
+
+  async get(maxAgeMs = 30_000): Promise<ModelInfo[]> {
+    if (this.list.length && Date.now() - this.loadedAt < maxAgeMs) return this.list;
+    this.loading ??= this.load().finally(() => {
+      this.loading = undefined;
+    });
+    await this.loading;
+    return this.list;
+  }
+
+  private async load(): Promise<void> {
+    const runtime = await this.pi.runtime();
+    const models = await runtime.getAvailableOfType("chat");
+    this.list = models.map((model) => infoOf(model, this.settings())).sort((a, b) => a.ref.localeCompare(b.ref));
+    this.loadedAt = Date.now();
+  }
+}
+
+/** 旧名单没有分数时按模型名称推测，保留用户的补充说明。 */
+export function noteOf(entry: RosterEntry, catalog: ModelCatalog): string {
+  const info = catalog.find(entry.ref);
+  const scores = entry.scores ?? guessModelScores(info ?? { id: entry.ref.split("/").at(-1) ?? entry.ref, name: "", reasoning: false });
+  return [scoreSummary(scores), ...(info?.input.includes("image") ? ["能看图"] : []), ...(info ? [`上下文 ${contextText(info.contextWindow)}`] : []), ...(entry.note.trim() ? [`补充：${entry.note.trim()}`] : [])].join(" · ");
+}
+
+/** 助手的名字：注册表里有名字就用，没有就用 ref。 */
+export function nameOf(ref: string, catalog: ModelCatalog): string {
+  return catalog.find(ref)?.name ?? ref;
+}
+
+/** 这个助手能派的模型 ref：缺省名单全部。 */
+export function allowedRefs(roster: RosterEntry[], assistant: Assistant): string[] {
+  const inRoster = new Set(roster.map((entry) => entry.ref));
+  const allowed = assistant.models?.allowed?.length ? assistant.models.allowed : roster.map((entry) => entry.ref);
+  return allowed.filter((ref) => inRoster.has(ref));
+}
+
+/** 这个助手能派、而且现在可用的模型 ref。 */
+export function usableRefs(settings: ModelSettings, assistant: Assistant, catalog: ModelCatalog): string[] {
+  return allowedRefs(settings.roster, assistant).filter((ref) => catalog.find(ref));
+}
+
+/** 不指定模型时用哪个：助手的默认任务模型 → 全局默认任务模型 → 名单里第一个可用的。 */
+export function defaultWorkRef(
+  settings: ModelSettings,
+  assistant: Assistant,
+  catalog: ModelCatalog,
+): string | undefined {
+  const usable = usableRefs(settings, assistant, catalog);
+  const wanted = [assistant.models?.work?.ref, settings.work.ref];
+  return wanted.find((ref): ref is string => !!ref && usable.includes(ref)) ?? usable[0];
+}
+
+export class NoModelError extends Error {}
+
+/** 一个模型都用不了时的说法：指到 设置 → 服务商 和 设置 → 模型。 */
+export const NO_MODEL_NOTE =
+  "尚未配置模型。请在「设置 → 服务商」中添加服务商，再到「设置 → 模型」选择模型";
+
+function missingModel(): NoModelError {
+  return new NoModelError(NO_MODEL_NOTE);
+}
+
+/** Router 这一轮用哪个模型：助手自己的对话模型，没有就全局。 */
+export function conversationPick(settings: ModelSettings, assistant: Assistant): ModelPick {
+  const pick = assistant.models?.conversation ?? settings.conversation;
+  if (!pick.ref) throw missingModel();
+  return pick;
+}
+
+export interface JobModelInput {
+  settings: ModelSettings;
+  assistant: Assistant;
+  catalog: ModelCatalog;
+  /** 助手分派任务时填的 model / thinking */
+  requested?: { model?: string; thinking?: string };
+  /** 任务带图片：所选模型不能看图就换一个能看的 */
+  hasImages?: boolean;
+}
+
+export interface JobModelPick {
+  model: ModelPick;
+  modelReason?: string;
+}
+
+function thinkingFor(
+  ref: string,
+  settings: ModelSettings,
+  role: { ref: string; thinking: ThinkingLevel },
+  wants: ThinkingLevel | undefined,
+  catalog: ModelCatalog,
+): ThinkingLevel {
+  const levels = thinkingLevelsOf(catalog.find(ref));
+  // 角色指定的模型用角色的思考档；另选的模型用它自己在名单里的默认思考档
+  const fallback =
+    ref === role.ref
+      ? role.thinking
+      : (settings.roster.find((entry) => entry.ref === ref)?.thinking ?? role.thinking);
+  // 填了模型没有的档不报错，往下取最近的一档（和设置里的默认档一样）
+  return fitThinking(levels, wants ?? fallback);
+}
+
+/**
+ * 分派任务时定模型：助手指定的优先，其次助手的默认任务模型，最后全局的。
+ * 都要落在助手允许的范围里，并且当前可用。
+ */
+export function jobModel(input: JobModelInput): JobModelPick {
+  const { settings, assistant, catalog, requested } = input;
+  const allowed = allowedRefs(settings.roster, assistant);
+  if (!allowed.length) {
+    throw new Error("该助手暂无可用模型。请在「设置 → 服务商」中添加服务商，再到「设置 → 模型」选择模型。");
+  }
+  const usable = allowed.filter((ref) => catalog.find(ref));
+  const listText = usable.length ? usable.join("、") : "（均不可用：服务商已删除或未配置 Key）";
+
+  const wantedModel = requested?.model?.trim();
+  if (wantedModel && !allowed.includes(wantedModel)) {
+    throw new Error(`无法分派 ${wantedModel}：该助手可分派的模型为 ${listText}。`);
+  }
+  if (wantedModel && !catalog.find(wantedModel)) {
+    throw new Error(
+      `${wantedModel} 当前不可用（该模型的服务商已删除或未配置 Key）。可分派的模型为 ${listText}。`,
+    );
+  }
+
+  const role = {
+    ref: assistant.models?.work?.ref ?? settings.work.ref,
+    thinking: assistant.models?.work?.thinking ?? settings.work.thinking,
+  };
+  let ref = wantedModel ?? defaultWorkRef(settings, assistant, catalog);
+  if (!ref || !usable.includes(ref)) {
+    if (!usable.length) throw new Error(`可分派的模型当前均不可用：${listText}。`);
+    ref = usable[0];
+  }
+
+  const wants = settings.thinkingChoice === "fixed" ? undefined : requested?.thinking;
+  if (wants !== undefined && !isThinkingLevel(wants)) {
+    throw new Error(`思考档无效：可选值为 ${THINKING_LEVELS.join("、")}。`);
+  }
+  let thinking = thinkingFor(ref, settings, role, wants, catalog);
+
+  let modelReason: string | undefined;
+  if (input.hasImages) {
+    const info = catalog.find(ref);
+    if (!info?.input.includes("image")) {
+      const withImage = usable.find((candidate) => catalog.find(candidate)?.input.includes("image"));
+      if (!withImage) {
+        throw new Error(
+          `任务包含图片，但可分派的模型均不支持图片输入（${listText}）。请在「设置 → 模型」中添加支持图片输入的模型。`,
+        );
+      }
+      modelReason = `任务包含图片，已更换为 ${nameOf(withImage, catalog)}`;
+      ref = withImage;
+      thinking = thinkingFor(ref, settings, role, wants, catalog);
+    }
+  }
+
+  return { model: { ref, thinking }, ...(modelReason ? { modelReason } : {}) };
+}
+
+/** 设置里填的思考档只校验档位本身合法：模型没有这一档时不拒绝，用的时候往下收（见 fitThinking）。 */
+function checkThinking(thinking: unknown): void {
+  if (thinking === undefined) return;
+  if (!isThinkingLevel(thinking)) throw new Error(`思考档无效：可选值为 ${THINKING_LEVELS.join("、")}。`);
+}
+
+/** PUT /api/settings 里 models 这一节的结构校验（可用性要现查，所以是异步的）。 */
+export async function checkModelsPatch(
+  patch: SettingsPatch,
+  current: ModelSettings,
+  catalog: ModelCatalog,
+): Promise<void> {
+  const next = patch.models;
+  if (!next) return;
+  await catalog.get();
+  const currentRefs = new Set(current.roster.map((entry) => entry.ref));
+  if (next.roster) {
+    const seen = new Set<string>();
+    for (const entry of next.roster) {
+      const ref = typeof entry?.ref === "string" ? entry.ref.trim() : "";
+      if (!ref) throw new Error("模型列表中存在空项。");
+      if (seen.has(ref)) throw new Error(`模型列表中重复：${ref}。`);
+      seen.add(ref);
+      if (!catalog.find(ref) && !currentRefs.has(ref)) {
+        throw new Error(`${ref} 当前不可用（该模型的服务商已删除或未配置 Key）。`);
+      }
+      checkThinking(entry.thinking);
+    }
+  }
+  const rosterRefs = new Set((next.roster ?? current.roster).map((entry) => entry.ref));
+  // 自定义思考档：走设置接口时也照规矩校验（界面用的是 /api/models/thinking）
+  for (const [ref, levels] of Object.entries(next.thinking ?? {})) {
+    if (!ref.trim()) throw new Error("思考档里存在空的模型项。");
+    checkThinkingMap(levels);
+  }
+  // 只校补丁里真的改了的角色；只删名单里的模型时，角色会自动退到名单里的其他模型
+  for (const [label, pick] of [
+    ["对话", next.conversation],
+    ["任务执行", next.work],
+  ] as const) {
+    if (!pick) continue;
+    if (!pick.ref) throw new Error(`未选择${label}模型。`);
+    if (!rosterRefs.has(pick.ref)) throw new Error(`${label}模型 ${pick.ref} 不在模型列表中。`);
+    checkThinking(pick.thinking);
+  }
+}
+
+/**
+ * PATCH /api/assistants/:id 里的 models / abilities：不合法就抛错（http 回 400）。
+ * models.allowed 为空数组 = 名单全部，等于没限制。
+ */
+export function checkAssistantModels(
+  raw: { models?: Assistant["models"]; abilities?: Assistant["abilities"] },
+  roster: RosterEntry[],
+  catalog: ModelCatalog,
+): { models?: Assistant["models"]; abilities?: Assistant["abilities"] } {
+  const out: { models?: Assistant["models"]; abilities?: Assistant["abilities"] } = {};
+  const rosterRefs = new Set(roster.map((entry) => entry.ref));
+  if (raw.models) {
+    const models: NonNullable<Assistant["models"]> = {};
+    for (const key of ["conversation", "work"] as const) {
+      const pick = raw.models[key];
+      if (!pick) continue;
+      const ref = typeof pick.ref === "string" ? pick.ref.trim() : "";
+      if (!ref) continue; // 空 = 跟随全局
+      if (!rosterRefs.has(ref)) throw new Error(`模型 ${ref} 不在模型列表中。`);
+      if (!catalog.find(ref)) throw new Error(`模型 ${ref} 当前不可用（该模型的服务商已删除或未配置 Key）。`);
+      checkThinking(pick.thinking);
+      models[key] = { ref, thinking: pick.thinking };
+    }
+    if (raw.models.allowed) {
+      const allowed = raw.models.allowed.map((ref) => String(ref));
+      const unknown = allowed.filter((ref) => !rosterRefs.has(ref));
+      if (unknown.length) throw new Error(`以下模型不在模型列表中：${unknown.join("、")}。`);
+      models.allowed = allowed;
+    }
+    out.models = models;
+  }
+  if (raw.abilities) {
+    out.abilities = {
+      exec: raw.abilities.exec !== false,
+      write: raw.abilities.write !== false,
+      image: raw.abilities.image !== false,
+    };
+  }
+  return out;
+}

package/server/src/overview.ts

@@ -0,0 +1,116 @@
+import { Type } from "@earendil-works/pi-ai";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { Job } from "../../shared/types.ts";
+import type { HobRuntime } from "./runtime.ts";
+
+const SUMMARY_CHARS = 100;
+const LOG_LIMIT = 10;
+
+const STATUS_TEXT: Record<Job["status"], string> = {
+  queued: "排队中",
+  running: "进行中",
+  waiting: "待确认",
+  done: "已完成",
+  stuck: "受阻",
+  failed: "失败",
+  stopped: "已停止",
+};
+
+function whenText(timezone: string, iso: string): string {
+  return new Intl.DateTimeFormat("zh-CN", {
+    timeZone: timezone,
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  }).format(new Date(iso));
+}
+
+function oneLine(text: string, max: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
+function isLive(job: Job): boolean {
+  return job.status === "queued" || job.status === "running" || job.status === "waiting";
+}
+
+/** 各助手最近这段时间的记录：工作日志、结束的任务、进行中的任务、待确认的审批。 */
+export function overviewText(runtime: HobRuntime, sinceHours = 24): string {
+  const hours = Math.min(Math.max(Math.round(sinceHours), 1), 24 * 7);
+  const since = new Date(Date.now() - hours * 3600 * 1000).toISOString();
+  const timezone = runtime.settings.settings.general.timezone;
+  const jobs = runtime.store.jobs();
+  const pending = runtime.store.approvals().filter((approval) => approval.status === "pending");
+
+  const blocks: string[] = [];
+  let endedCount = 0;
+  let liveCount = 0;
+
+  for (const assistant of runtime.store.assistants()) {
+    const mine = jobs.filter((job) => job.assistantId === assistant.id);
+    const ended = mine
+      .filter((job) => job.endedAt && job.endedAt >= since)
+      .sort((a, b) => (b.endedAt ?? "").localeCompare(a.endedAt ?? ""));
+    const live = mine.filter(isLive);
+    const asks = pending.filter((approval) => approval.assistantId === assistant.id);
+    const log = runtime.store
+      .worklog(assistant.id, 100)
+      .filter((entry) => entry.at >= since)
+      .slice(0, LOG_LIMIT);
+    if (!ended.length && !live.length && !asks.length && !log.length) continue;
+    endedCount += ended.length;
+    liveCount += live.length;
+
+    const lines = [`## ${assistant.name}（${assistant.id}）`];
+    if (live.length) {
+      lines.push("进行中：");
+      for (const job of live) {
+        const started = job.startedAt ? `，${whenText(timezone, job.startedAt)} 开始` : "";
+        lines.push(`- ${job.title} · ${STATUS_TEXT[job.status]}${started}`);
+      }
+    }
+    if (ended.length) {
+      lines.push("结束的任务：");
+      for (const job of ended) {
+        const summary = job.summary ? oneLine(job.summary, SUMMARY_CHARS) : job.statusReason ?? "没有摘要";
+        lines.push(`- ${job.title} · ${STATUS_TEXT[job.status]} · ${summary}`);
+      }
+    }
+    if (log.length) {
+      lines.push("工作日志：");
+      for (const entry of log) lines.push(`- ${whenText(timezone, entry.at)} ${entry.text}`);
+    }
+    if (asks.length) {
+      lines.push("待确认：");
+      for (const approval of asks) lines.push(`- ${approval.title}（${whenText(timezone, approval.createdAt)}）`);
+    }
+    blocks.push(lines.join("\n"));
+  }
+
+  const head = `最近 ${hours} 小时（${whenText(timezone, since)} 之后）：${endedCount} 件结束的任务、${liveCount} 件进行中、${pending.length} 个待确认。`;
+  if (!blocks.length) return `${head}\n\n这段时间没有记录。`;
+  return `${head}\n\n${blocks.join("\n\n")}`;
+}
+
+/** 只读的 overview 工具：只给主助手（Router）和主助手的任务（Worker）。 */
+export function overviewTool(runtime: HobRuntime): ToolDefinition<any, any> {
+  return {
+    name: "overview",
+    label: "查看这段时间的记录",
+    description:
+      "只读：列出各助手最近一段时间的工作日志、结束的任务（标题、结果、摘要前 100 字）、进行中的任务和待确认的审批。写早报、汇总“昨晚/今天都做了什么”之前先调用它，照实编写。",
+    promptSnippet: "写早报/汇总时用 overview 查看各助手这段时间的记录。",
+    parameters: Type.Object({
+      sinceHours: Type.Optional(Type.Integer({ description: "往回看多少小时，默认 24，最多 168" })),
+    }),
+    execute: async (_id, params: any) => {
+      const hours = Number(params.sinceHours ?? 24);
+      return {
+        content: [{ type: "text" as const, text: overviewText(runtime, Number.isFinite(hours) ? hours : 24) }],
+        details: undefined,
+      };
+    },
+  };
+}

package/server/src/pages.ts

@@ -0,0 +1,54 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "@earendil-works/pi-ai";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { HobRuntime } from "./runtime.ts";
+import { pageHtml } from "../../shared/page-shell.ts";
+export { pageHtml } from "../../shared/page-shell.ts";
+
+const MAX = 80_000;
+
+export async function renderPage(home: string, title: string, summary: string, html: string): Promise<string> {
+  if (!html.trim()) throw new Error("页面内容不能为空。");
+  if (html.length > MAX) throw new Error(`页面内容不能超过 ${MAX} 字。`);
+  if (/<\s*(!doctype|html|head|body)\b/i.test(html)) throw new Error("html 只写正文片段，不要包含 <!doctype>、<html>、<head> 或 <body>；标题和摘要由 Hob 放在页头。");
+  const dir = join(home, "pages");
+  await mkdir(dir, { recursive: true });
+  const path = join(dir, `${randomUUID()}.html`);
+  await writeFile(path, pageHtml(title, summary, html), "utf8");
+  return path;
+}
+
+const description = `当流程、对比、架构、多步骤教程、数据表或长篇调研结论用页面比文字更易理解时使用。简短问答、闲聊或一两段能讲清的内容不要用。调用前只说一句话点题。
+html 只写正文的 HTML 片段（不要 <html>、<head>、<body>），标题和摘要由 Hob 放在页头，正文别再写 h1。页面离线显示：不能加载外部脚本、样式和字体，不能联网取数据；图片只能用 https 或 data 地址。
+已有样式（亮暗自动适配），直接用：
+- 小节用 <h2>、<h3>；段落、列表、<table>、<pre><code>、<blockquote> 都已排好。
+- 并列要点：<div class="cards"><div class="card"><h3>…</h3><p>…</p></div>…</div>
+- 左右对比：<div class="cols"><div>…</div><div>…</div></div>
+- 步骤：<ol class="steps"><li><b>步骤名</b>说明</li>…</ol>
+- 关键数字：<div class="kpis"><div class="kpi"><b>42%</b><span>说明</span></div>…</div>
+- 提示框：<div class="note">…</div>；标签：<span class="tag">…</span>；都可加 ok / warn / bad 变色。
+- 图（流程、结构、时序、关系）用 <figure> 里的内联 <svg viewBox="…">，不写死宽高，配 <figcaption>。SVG 类：box 普通框、hl 强调框、line 连线、text 加 muted 为次要文字；文字默认 13px。颜色只用变量 --ink --muted --faint --line --soft --accent --accent-soft --ok --warn --bad，写成 style="fill:var(--accent)"。
+- 先给结论再展开；能用图、表、卡片说清的就别堆长段落；强调色只点最重要的一两处。
+- 需要特别的版式可以加 <style>（颜色仍用上面的变量），可以用 <script> 做交互。最多 ${MAX} 字。`;
+
+export function pageTool(runtime: HobRuntime, assistantId: string, router: boolean): ToolDefinition<any, any> {
+  return {
+    name: "show_page", label: "展示页面", description,
+    parameters: Type.Object({ title: Type.String(), summary: Type.String(), html: Type.String({ maxLength: MAX }) }),
+    execute: async (_id, params: any) => {
+      try {
+        if (runtime.settings.settings.general.showPage === false) throw new Error("展示页面已关闭。");
+        const title = String(params.title ?? "").trim();
+        const summary = String(params.summary ?? "").trim();
+        if (!title || !summary) throw new Error("标题和摘要不能为空。");
+        const path = await renderPage(runtime.home, title, summary, String(params.html ?? ""));
+        await runtime.router.addItem(assistantId, { kind: "file", path, name: title, meta: summary });
+        return { content: [{ type: "text" as const, text: `页面已展示：${path}${router ? "。本轮到此结束。" : ""}` }], details: { path }, ...(router ? { terminate: true } : {}) };
+      } catch (error) {
+        return { content: [{ type: "text" as const, text: error instanceof Error ? error.message : String(error) }], details: undefined, isError: true };
+      }
+    },
+  };
+}

package/server/src/password.ts

@@ -0,0 +1,23 @@
+// 登录密码：config.json 只存哈希（scrypt + 每组随机盐），不存明文。
+import { randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
+
+const KEYLEN = 64;
+
+/** "scrypt$salt$hash"，salt 和 hash 都是 hex。 */
+export function hashPassword(password: string): string {
+  const salt = randomBytes(16).toString("hex");
+  const hash = scryptSync(password, salt, KEYLEN).toString("hex");
+  return `scrypt$${salt}$${hash}`;
+}
+
+export function isPasswordHash(value: string): boolean {
+  return /^scrypt\$[0-9a-f]{32}\$[0-9a-f]{128}$/.test(value);
+}
+
+export function verifyPassword(stored: string, password: string): boolean {
+  if (!isPasswordHash(stored)) return false;
+  const [, salt, hash] = stored.split("$");
+  const expected = Buffer.from(hash, "hex");
+  const given = scryptSync(password, salt, KEYLEN);
+  return expected.length === given.length && timingSafeEqual(expected, given);
+}