agent-loft 0.2.29 → 0.2.30

package/web/settings/general.js

@@ -0,0 +1,184 @@
+import { fill, h, toast } from "../lib/dom.js";
+import { api } from "../lib/api.js";
+import { desktop, desktopQuota } from "../state.js";
+import { field, saveConfig } from "./common.js";
+
+/** 服务端版本：有新版就能一键升级（npm install -g，系统服务下自动重启） */
+export function serverVersionSection() {
+  const box = h("div", { class: "section" });
+  const load = async (refresh) => {
+    fill(box, h("h4", {}, "服务端版本", h("span", { class: "grow" }), h("span", { class: "spinner" })));
+    let v;
+    try {
+      v = await api(`/api/server/version${refresh ? "?refresh=1" : ""}`);
+    } catch (err) {
+      fill(box, h("h4", {}, "服务端版本"), h("div", { class: "error-text" }, err.message));
+      return;
+    }
+    const recheck = h("button", { class: "btn small", onclick: () => load(true) }, "检查更新");
+    const status = v.updateAvailable
+      ? `有新版本 ${v.latest}`
+      : v.latest
+        ? "已是最新版本"
+        : `查不到最新版本${v.latestError ? `：${v.latestError}` : ""}`;
+    const upgradeBtn =
+      v.updateAvailable && v.canUpgrade
+        ? h(
+            "button",
+            {
+              class: "btn small primary",
+              onclick: async () => {
+                upgradeBtn.disabled = true;
+                upgradeBtn.textContent = "正在升级…";
+                try {
+                  const r = await api("/api/server/upgrade", { method: "POST" });
+                  toast(r.restarting ? `已升级到 ${r.to}，服务正在重启，页面会自动重连` : `已升级到 ${r.to}，重启 agent-loft 后生效`, 6000);
+                  void load(false);
+                } catch (err) {
+                  toast(`升级失败：${err.message}`, 6000);
+                  upgradeBtn.disabled = false;
+                  upgradeBtn.textContent = "升级";
+                }
+              },
+            },
+            "升级",
+          )
+        : null;
+    fill(
+      box,
+      h("h4", {}, "服务端版本", h("span", { class: "grow" }), upgradeBtn, recheck),
+      h("div", { class: "health-meta" }, `当前 ${v.version} · ${status}`),
+      v.updateAvailable && !v.canUpgrade && v.reason ? h("div", { class: "health-meta" }, v.reason) : null,
+      v.updateAvailable && v.canUpgrade && !v.service ? h("div", { class: "health-meta" }, "agent-loft 是在前台手动运行的，升级后要自己重启一下。") : null,
+    );
+  };
+  void load(false);
+  return box;
+}
+
+export function generalTab(cfg, panel) {
+  const root = h("input", { value: cfg.workspaceRoot });
+  const approval = h("input", { type: "number", min: 1, value: Math.round(cfg.approvalTimeoutMs / 60000) });
+  const ttl = h("input", { type: "number", min: 0, value: Math.round(cfg.sessionTtlMs / 3600000) });
+  const quotaMin = h("input", { type: "number", min: 0, max: 1440, value: cfg.web?.quotaRefreshMin ?? 10 });
+  const quotaOn = h("input", { type: "checkbox", checked: cfg.web?.quotaEnabled !== false });
+  panel.append(
+    h(
+      "div",
+      { class: "section" },
+      h("h4", {}, "通用"),
+      field("工作目录（workspace）", root, "所有会话的默认目录，/cd 只能在它之内"),
+      field("授权等待超时（分钟）", approval, "超时按拒绝处理"),
+      field("会话闲置多久自动开新会话（小时）", ttl, "0 表示永不过期"),
+      h("label", { class: "check" }, quotaOn, "查询账号额度"),
+      h("div", { class: "muted" }, "关掉后侧栏、/status、桌面端都不再去问 agent 的额度（Claude 每次要临时起一个 CLI 进程才查得到）"),
+      field(
+        "额度自动刷新间隔（分钟）",
+        quotaMin,
+        desktopQuota
+          ? "在桌面端里额度由桌面端统一刷新，以桌面端设置里的间隔为准；这里只对浏览器打开的页面生效"
+          : "侧栏底部的额度，空闲时多久刷新一次；0 表示不自动刷新（跑完一轮、点击额度区域仍会刷新）",
+      ),
+      h(
+        "div",
+        { class: "row" },
+        h(
+          "button",
+          {
+            class: "btn primary",
+            onclick: () =>
+              saveConfig(cfg, {
+                workspaceRoot: root.value,
+                approvalTimeoutMs: Number(approval.value) * 60000,
+                sessionTtlMs: Number(ttl.value) * 3600000,
+                web: { quotaRefreshMin: Number(quotaMin.value), quotaEnabled: quotaOn.checked },
+              }),
+          },
+          "保存",
+        ),
+      ),
+    ),
+  );
+}
+
+/** 只有本机能连的监听地址（和服务端 listen.ts 的判断一致） */
+function loopbackHost(host) {
+  const v = String(host ?? "").trim().toLowerCase().replace(/^\[|\]$/g, "");
+  return v === "localhost" || v === "::1" || /^127\./.test(v);
+}
+
+/**
+ * 网络访问：要不要让局域网里的其他设备打开、监听哪个端口。保存后服务端当场换过去，不用重启；
+ * 端口被占用之类的失败会直接报出来，原来的照常工作。
+ */
+export function networkSection(cfg) {
+  const net = cfg.network ?? { lan: [], local: true, listening: null };
+  const box = h("div", { class: "section" });
+  const lanOn = h("input", { type: "checkbox", checked: !loopbackHost(cfg.web.host) });
+  const port = h("input", { type: "number", min: 1, max: 65535, value: cfg.web.port });
+  const hint = h("small", {});
+  // 现在这个页面是不是直接连的这个端口（不是经由反代 / 隧道）
+  const pagePort = Number(location.port || (location.protocol === "https:" ? 443 : 80));
+  const direct = pagePort === cfg.web.port;
+
+  const update = () => {
+    const p = Number(port.value) || cfg.web.port;
+    const lines = [];
+    if (lanOn.checked) {
+      lines.push(
+        net.lan.length
+          ? `局域网里的其他设备用 ${net.lan.map((ip) => `http://${ip}:${p}`).join(" 或 ")} 打开`
+          : "这台机器现在没连局域网，连上后其他设备可以用它的局域网地址打开",
+      );
+    } else {
+      lines.push("只有这台机器自己能打开。这台机器上的反向代理、Cloudflare Tunnel 之类不受影响");
+    }
+    if (!net.local && !lanOn.checked && !loopbackHost(cfg.web.host)) {
+      lines.push("⚠️ 你现在是从局域网里的另一台设备访问的，不能在这里关掉，请到运行 agent-loft 的机器上操作");
+    }
+    if (!direct && p !== cfg.web.port) lines.push(`⚠️ 你是经由反向代理 / 隧道访问的，改端口后要把它指向新端口 ${p}，否则这个页面会打不开`);
+    fill(hint, lines.map((l, i) => [i ? h("br") : null, l]));
+  };
+  lanOn.addEventListener("change", update);
+  port.addEventListener("input", update);
+  update();
+
+  const save = async () => {
+    const p = Number(port.value);
+    if (!Number.isInteger(p) || p < 1 || p > 65535) return toast("端口要是 1 到 65535 之间的整数");
+    // 打开：原来是本机地址就改成所有网卡；原来就是某个具体地址（手改过配置）就保留
+    const host = lanOn.checked ? (loopbackHost(cfg.web.host) ? "0.0.0.0" : cfg.web.host) : "127.0.0.1";
+    if (host === cfg.web.host && p === cfg.web.port) return toast("没有改动");
+    const oldPort = cfg.web.port;
+    let next;
+    try {
+      next = await api("/api/config", { method: "PUT", body: { web: { host, port: p } } });
+    } catch (err) {
+      toast(err.message, 5000);
+      return;
+    }
+    Object.assign(cfg, next);
+    if (p !== oldPort && direct) {
+      // 旧端口已经不再接新连接：带着当前会话跳到新端口
+      const url = new URL(location.href);
+      url.port = String(p);
+      toast(`已改为端口 ${p}，正在跳转…`);
+      // 桌面端里由它改掉存着的服务器地址再重新打开（直接跳过去会被当成外部链接）
+      if (typeof desktop?.serverMoved === "function") desktop.serverMoved(url.origin);
+      else setTimeout(() => (location.href = url.href), 600);
+      return;
+    }
+    toast(p !== oldPort ? `已改为端口 ${p}，记得把反向代理 / 隧道也指向它` : "已保存", p !== oldPort ? 6000 : 2600);
+    box.replaceWith(networkSection(cfg));
+  };
+
+  fill(
+    box,
+    h("h4", {}, "网络访问"),
+    h("label", { class: "check" }, lanOn, "允许局域网内的其他设备访问"),
+    hint,
+    field("端口", port, "改了立即生效，不用重启"),
+    h("div", { class: "row" }, h("button", { class: "btn primary", onclick: () => void save() }, "保存")),
+  );
+  return box;
+}

package/web/settings/index.js

@@ -0,0 +1,63 @@
+import { fill, h } from "../lib/dom.js";
+import { api } from "../lib/api.js";
+import { isAdmin } from "../state.js";
+import { modal } from "../lib/overlay.js";
+import { notifyTab } from "./notify.js";
+import { generalTab } from "./general.js";
+import { commandsTab } from "./commands.js";
+import { agentsTab } from "./agents.js";
+import { feishuTab } from "./feishu.js";
+import { authTab, securityTab } from "./security.js";
+import { memoryTab } from "./memory.js";
+import { systemTab, usersTab } from "./users.js";
+
+// ---------- 设置 ----------
+
+export async function openSettings() {
+  const nav = h("div", { class: "settings-nav" });
+  const panel = h("div", { class: "settings-body" });
+  // 设置弹窗高度固定，切标签页时不跟着内容一伸一缩
+  modal({ title: "设置", wide: true, tall: true, body: h("div", { class: "settings" }, nav, panel) });
+  // 普通成员只能管自己的通知、密码和登录设备；其余设置都是管理员的
+  if (!isAdmin()) {
+    const tabs = [
+      ["记忆", () => memoryTab(panel)],
+      ["通知", () => notifyTab(panel)],
+      ["账号", () => securityTab(panel)],
+    ];
+    const select = (i) => {
+      nav.querySelectorAll("button").forEach((b, j) => b.classList.toggle("on", i === j));
+      fill(panel);
+      tabs[i][1]();
+    };
+    nav.append(...tabs.map(([name], i) => h("button", { onclick: () => select(i) }, name)));
+    select(0);
+    return;
+  }
+  let cfg;
+  try {
+    cfg = await api("/api/config");
+  } catch (err) {
+    panel.append(h("div", { class: "error-text" }, err.message));
+    return;
+  }
+  const tabs = [
+    ["通用", () => generalTab(cfg, panel)],
+    ["Agent", () => agentsTab(cfg, panel)],
+    ["命令", () => commandsTab(cfg, panel)],
+    ["飞书机器人", () => feishuTab(cfg, panel)],
+    ["授权", () => authTab(panel)],
+    ["记忆", () => memoryTab(panel)],
+    ["通知", () => notifyTab(panel)],
+    ["账号", () => securityTab(panel)],
+    ["用户", () => usersTab(panel)],
+    ["系统", () => systemTab(cfg, panel)],
+  ];
+  const select = (i) => {
+    nav.querySelectorAll("button").forEach((b, j) => b.classList.toggle("on", i === j));
+    fill(panel, );
+    tabs[i][1]();
+  };
+  nav.append(...tabs.map(([name], i) => h("button", { onclick: () => select(i) }, name)));
+  select(0);
+}

package/web/settings/memory.js

@@ -0,0 +1,366 @@
+import { fill, h, toast } from "../lib/dom.js";
+import { api } from "../lib/api.js";
+import { relTime } from "../lib/time.js";
+import { copyText } from "../lib/markdown.js";
+import { agentCatalog } from "../views/topbar.js";
+import { confirmDialog } from "../lib/overlay.js";
+import { field } from "./common.js";
+
+// ---------- 记忆（每个人自己的） ----------
+
+export async function memoryTab(panel) {
+  const box = h("div", { class: "section" }, h("h4", {}, "记忆"), h("span", { class: "spinner" }));
+  fill(panel, box);
+  let mem;
+  try {
+    mem = await api("/api/account/memory");
+  } catch (err) {
+    fill(box, h("h4", {}, "记忆"), h("div", { class: "error-text" }, err.message));
+    return;
+  }
+  const reload = () => void memoryTab(panel);
+  const run = (btn, fn) => async () => {
+    btn.disabled = true;
+    try {
+      if ((await fn()) !== false) reload();
+    } catch (err) {
+      toast(err.message);
+      btn.disabled = false;
+    }
+  };
+
+  const enabled = h("input", { type: "checkbox", checked: mem.enabled });
+  enabled.onchange = async () => {
+    try {
+      await api("/api/account/memory", { method: "PUT", body: { enabled: enabled.checked } });
+      toast(enabled.checked ? "记忆已开启" : "记忆已关闭，已有的内容保留");
+    } catch (err) {
+      enabled.checked = !enabled.checked;
+      toast(err.message);
+    }
+  };
+
+  /** 一个开关：改了立刻存 */
+  const toggle = (key, label, on, off) => {
+    const box = h("input", { type: "checkbox", checked: mem[key] });
+    box.onchange = async () => {
+      try {
+        await api("/api/account/memory", { method: "PUT", body: { [key]: box.checked } });
+        toast(box.checked ? on : off);
+      } catch (err) {
+        box.checked = !box.checked;
+        toast(err.message);
+      }
+    };
+    return h("label", { class: "check" }, box, label);
+  };
+  const history = await api("/api/account/history").catch(() => null);
+  const clearHistory = h("button", { class: "btn small" }, "清空聊天记录索引");
+  clearHistory.onclick = run(clearHistory, async () => {
+    const sure = await confirmDialog({
+      title: "清空聊天记录索引？",
+      message: "agent 将搜不到以前的聊天（对话本身不删，侧栏里照样能打开）。之后的聊天还会继续记进来。",
+      confirmText: "清空",
+      danger: true,
+    });
+    if (!sure) return false;
+    await api("/api/account/history", { method: "DELETE" });
+    toast("已清空");
+  });
+
+  const about = h("textarea", { rows: 5, maxlength: mem.limits.about, placeholder: "比如：我叫小明，在深圳做后端开发，家里有台 QNAP NAS。回答尽量简短，代码用 TypeScript。" });
+  about.value = mem.about;
+  const saveAbout = h("button", { class: "btn primary" }, "保存");
+  saveAbout.onclick = run(saveAbout, async () => {
+    await api("/api/account/memory", { method: "PUT", body: { about: about.value } });
+    toast("已保存，之后的对话会用上");
+  });
+
+  const newItem = h("input", { maxlength: mem.limits.item, style: { flex: "1", minWidth: "0" }, placeholder: "手动加一条，比如：我的软路由是 iStoreOS，地址 192.168.8.2" });
+  const addBtn = h("button", { class: "btn" }, "添加");
+  addBtn.onclick = run(addBtn, async () => {
+    if (!newItem.value.trim()) return false;
+    await api("/api/account/memory/items", { method: "POST", body: { text: newItem.value } });
+  });
+  newItem.onkeydown = (e) => {
+    if (e.key === "Enter" && !e.isComposing) addBtn.click();
+  };
+
+  const items = [...mem.items].sort((a, b) => b.updatedAt - a.updatedAt);
+  const itemRow = (it) => {
+    const from = { user: "你加的", agent: "agent 在聊天里记的", auto: "聊完后自动整理的" }[it.source] ?? "agent 记的";
+    const body = h("div", { class: "grow" }, h("div", { class: "t", style: { whiteSpace: "pre-wrap" } }, it.text), h("div", { class: "s" }, `${from} · ${relTime(it.updatedAt)}`));
+    const edit = h("button", { class: "btn small" }, "编辑");
+    const del = h("button", { class: "btn small danger" }, "删除");
+    edit.onclick = () => {
+      const input = h("textarea", { rows: 2, maxlength: mem.limits.item });
+      input.value = it.text;
+      const ok = h("button", { class: "btn small primary" }, "保存");
+      ok.onclick = run(ok, () => api(`/api/account/memory/items/${it.id}`, { method: "PATCH", body: { text: input.value } }));
+      fill(body, input, h("div", { class: "row" }, ok, h("button", { class: "btn small", onclick: reload }, "取消")));
+      input.focus();
+    };
+    del.onclick = run(del, () => api(`/api/account/memory/items/${it.id}`, { method: "DELETE" }));
+    return h("div", { class: "list-item" }, body, edit, del);
+  };
+
+  const clearBtn = h("button", { class: "btn danger" }, "清空全部记忆");
+  clearBtn.onclick = run(clearBtn, async () => {
+    const sure = await confirmDialog({
+      title: "清空全部记忆？",
+      message: "「关于我」和所有记住的事都会删除，不能恢复。",
+      confirmText: "清空",
+      danger: true,
+    });
+    if (!sure) return false;
+    await api("/api/account/memory", { method: "DELETE" });
+    toast("已清空");
+  });
+
+  fill(
+    panel,
+    h(
+      "div",
+      { class: "section" },
+      h("h4", {}, "记忆", h("span", { class: "grow" }), h("label", { class: "check" }, enabled, "开启")),
+      h(
+        "div",
+        { class: "muted" },
+        "像 ChatGPT 的记忆：对话时 agent 会参考你的「关于我」和记住的事，聊天里遇到长期有用的信息也会主动记一条（会在回复里告诉你）。Claude 和 Codex、Web 和飞书共用这一份。",
+      ),
+      h(
+        "div",
+        { class: "muted" },
+        "用在哪些对话：你在 Web 上的对话；在「账号」里绑定了飞书后，和机器人的私聊也会用。飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它。",
+      ),
+    ),
+    h(
+      "div",
+      { class: "section" },
+      h("h4", {}, "自动"),
+      curateSection(mem, reload),
+      toggle("chatHistory", "参考以前的聊天", "已开启：agent 能搜你以前的聊天了", "已关闭：agent 不再搜以前的聊天"),
+      h(
+        "div",
+        { class: "muted" },
+        `agent 遇到「上次说的那个……」时，可以搜你以前的聊天（只有你自己的对话，被删掉的对话不算）。${history ? `现在收录了 ${history.conversations} 段对话、${history.count} 句话。` : ""}`,
+      ),
+      h("div", { class: "row" }, clearHistory),
+    ),
+    h("div", { class: "section" }, h("h4", {}, "关于我"), field("写给 agent 看的自我介绍：你是谁、在做什么、希望它怎么回答", about, `每次对话都会带上，最多 ${mem.limits.about} 字`), h("div", { class: "row" }, saveAbout)),
+    h(
+      "div",
+      { class: "section" },
+      h("h4", {}, `记住的事（${items.length}）`),
+      h("div", { class: "row" }, newItem, addBtn),
+      items.length ? items.map(itemRow) : h("div", { class: "muted" }, "还没有。聊天时说「记住……」，或者在上面手动加。"),
+    ),
+    h(
+      "div",
+      { class: "section" },
+      h("div", { class: "muted" }, "注意：和多用户一样，这不是安全隔离 —— 工作模式下 agent 能读到这台机器上的文件，也包括记忆文件。"),
+      h("div", { class: "row" }, clearBtn),
+    ),
+  );
+}
+
+/** 记忆页里的「整理记忆」：什么时候整理、用哪个 agent 的哪个模型、现在整理、上次的结果 */
+function curateSection(mem, reload) {
+  const c = { ...mem.curate };
+  const box = h("div");
+  const save = async (patch) => {
+    try {
+      await api("/api/account/memory", { method: "PUT", body: { curate: patch } });
+      Object.assign(c, patch);
+      if (patch.agent === "auto") c.model = "";
+      render();
+      toast("已保存");
+    } catch (err) {
+      toast(err.message);
+      render();
+    }
+  };
+  const select = (value, options, onchange) =>
+    h("select", { onchange: (e) => onchange(e.target.value) }, options.map(([v, label]) => h("option", { value: v, selected: String(v) === String(value) }, label)));
+
+  const render = () => {
+    const when = select(
+      c.when,
+      [
+        ["daily", "每天一次，把当天聊过的合起来整理（推荐）"],
+        ["idle", "每段对话聊完后就整理"],
+        ["manual", "只在我点「现在整理」时"],
+        ["off", "不整理"],
+      ],
+      (v) => save({ when: v }),
+    );
+    // 换了范围，等着整理的段数也跟着变：重新读一遍
+    const scope = select(
+      c.scope,
+      [
+        ["all", "全部对话"],
+        ["chat", "只整理聊天模式的对话"],
+        ["work", "只整理工作模式的对话"],
+      ],
+      (v) => save({ scope: v }).then(reload),
+    );
+    const timing =
+      c.when === "idle"
+        ? field("停下来多久算聊完", select(c.idleMinutes, [10, 30, 60, 120, 240].map((m) => [m, m < 60 ? `${m} 分钟` : `${m / 60} 小时`]), (v) => save({ idleMinutes: Number(v) })))
+        : c.when === "daily"
+          ? field(
+              "几点整理（服务器所在时区）",
+              select(c.dailyHour, Array.from({ length: 24 }, (_, i) => [i, `${i} 点`]), (v) => save({ dailyHour: Number(v) })),
+              "这个点之后第一次检查时整理；服务器那会儿没开机的话，开机后补上",
+            )
+          : null;
+    const agent = select(
+      c.agent,
+      [
+        ["auto", "自动：有 Claude 就用 Claude，否则 Codex"],
+        ["claude", "Claude Code"],
+        ["codex", "Codex"],
+      ],
+      (v) => save({ agent: v, model: "" }),
+    );
+    const model =
+      c.agent === "auto"
+        ? null
+        : (() => {
+            const sel = h("select", { onchange: (e) => save({ model: e.target.value }) }, h("option", { value: "" }, c.agent === "claude" ? "默认：Haiku（最省）" : "默认模型，思考程度 low（最省）"));
+            if (c.model) sel.append(h("option", { value: c.model, selected: true }, c.model));
+            agentCatalog(c.agent)
+              .then((models) => {
+                for (const m of models) {
+                  if (m.id === "default" || m.id === c.model) continue;
+                  sel.append(h("option", { value: m.id }, m.label || m.id));
+                }
+              })
+              .catch(() => sel.append(h("option", { value: "", disabled: true }, "（这个 agent 没启用，读不到模型列表）")));
+            return field("模型", sel, "整理只是读一遍对话、改几条记忆，用便宜的模型就够了；贵的模型会多占订阅额度");
+          })();
+
+    const nowBtn = h("button", { class: "btn small", disabled: c.when === "off" || !mem.enabled }, "现在整理");
+    nowBtn.onclick = async () => {
+      nowBtn.disabled = true;
+      nowBtn.textContent = "整理中…";
+      try {
+        const r = await api("/api/account/memory/curate", { method: "POST" });
+        toast(
+          r.error
+            ? `整理失败：${r.error}`
+            : r.conversations
+              ? `整理了 ${r.conversations} 段对话：新增 ${r.added.length}、更新 ${r.updated.length}、删除 ${r.removed}`
+              : "没有需要整理的对话（正在回复的那段先不整理）",
+        );
+        reload();
+      } catch (err) {
+        toast(err.message);
+        nowBtn.disabled = false;
+        nowBtn.textContent = "现在整理";
+      }
+    };
+    const last = mem.lastCuration;
+    const lastText = last
+      ? last.error
+        ? `上次整理（${relTime(last.at)}）没成功：${last.error}`
+        : `上次整理：${relTime(last.at)}，${last.conversations} 段对话${last.by ? `，用 ${last.by}` : ""}，新增 ${last.added.length}、更新 ${last.updated.length}、删除 ${last.removed}`
+      : "还没整理过";
+
+    fill(
+      box,
+      field("整理记忆", when),
+      h(
+        "div",
+        { class: "muted" },
+        {
+          daily: "攒一天再整理：每次整理都要把你现有的记忆整份带上，合起来一次最省额度，几段对话放在一起看也更容易合并重复。改了什么只显示在这里，不打扰对话。",
+          idle: "每段对话停下来就整理一次，改了什么会在那条对话里告诉你。最及时，但聊得多时调用次数也多。",
+          manual: "聊过的内容会攒着，你点「现在整理」时一次整理完。",
+          off: "不整理，聊过的内容也不攒着。聊天里 agent 照样可以自己用 remember 记东西。",
+        }[c.when],
+      ),
+      timing,
+      c.when === "off" ? null : field("整理哪些对话", scope, "按整理时对话所在的模式算；不在范围里的对话直接跳过，之后改回来也不会补整理"),
+      c.when === "off" ? null : field("用哪个 agent", agent),
+      c.when === "off" ? null : model,
+      h("div", { class: "row", style: { alignItems: "center", gap: "10px" } }, nowBtn, h("span", { class: "muted" }, `${mem.pending ? `有 ${mem.pending} 段对话等着整理。` : ""}${lastText}`)),
+      h("div", { class: "muted" }, "整理时会对照现有记忆补充、更新或删掉过时的条目；你自己加的条目它不会动。"),
+    );
+  };
+  render();
+  return box;
+}
+
+/** 「账号」页里的飞书绑定：Web 上生成绑定码，再在飞书私聊里发 /bind，两边都证明是本人 */
+export function feishuLinkSection() {
+  const box = h("div", { class: "section" });
+  const load = async () => {
+    let data;
+    try {
+      data = await api("/api/account/feishu");
+    } catch (err) {
+      fill(box, h("h4", {}, "飞书账号"), h("div", { class: "error-text" }, err.message));
+      return;
+    }
+    // 没有飞书机器人、也没绑过：整节不显示
+    if (!data.bots.length && !data.links.length) return fill(box);
+    const codeBox = h("div");
+    const gen = h("button", { class: "btn" }, data.links.length ? "再绑一个" : "生成绑定码");
+    gen.onclick = async () => {
+      gen.disabled = true;
+      try {
+        const { code, expiresAt } = await api("/api/account/feishu/code", { method: "POST" });
+        const cmd = `/bind ${code}`;
+        const copy = h("button", { class: "btn small" }, "复制");
+        copy.onclick = () => copyText(cmd, copy);
+        fill(
+          codeBox,
+          h(
+            "div",
+            { class: "list-item" },
+            h(
+              "div",
+              { class: "grow" },
+              h("div", { class: "t" }, h("code", {}, cmd)),
+              h("div", { class: "s" }, `在飞书里私聊机器人（${data.bots.map((b) => b.name).join("、") || "飞书机器人"}）发这条消息，${Math.round((expiresAt - Date.now()) / 60000)} 分钟内有效。没用过机器人的话，要先让管理员批准你的配对码。`),
+            ),
+            copy,
+          ),
+        );
+      } catch (err) {
+        toast(err.message);
+      }
+      gen.disabled = false;
+    };
+    fill(
+      box,
+      h("h4", {}, "飞书账号"),
+      h("div", { class: "muted" }, "绑定后，你和飞书机器人的私聊就是你的个人会话：用你的记忆，/sessions 只列你的会话，/web 能接上你自己的 Web 会话。群聊不受影响。"),
+      data.links.map((l) => {
+        const rm = h("button", { class: "btn small danger" }, "解除绑定");
+        rm.onclick = async () => {
+          rm.disabled = true;
+          try {
+            await api("/api/account/feishu", { method: "DELETE", body: { botId: l.botId, openId: l.openId } });
+            toast("已解除，那个私聊不再用你的记忆");
+            void load();
+          } catch (err) {
+            toast(err.message);
+            rm.disabled = false;
+          }
+        };
+        return h(
+          "div",
+          { class: "list-item" },
+          h("div", { class: "grow" }, h("div", { class: "t" }, l.botName), h("div", { class: "s" }, `${l.openIdShort} · 绑定于 ${relTime(l.boundAt)}`)),
+          rm,
+        );
+      }),
+      h("div", { class: "row" }, gen),
+      codeBox,
+    );
+  };
+  void load();
+  return box;
+}