' +
+ __("阶段管道", "Stage pipeline") +
+ (g < 0 ? " " + __("（空闲）", "(idle)") : "") +
+ "
" +
+ ' 而不是 CSS offset-path / rAF：它由浏览器自己按
+// SVG 用户坐标跑，不需要前端维护动画循环，也没有 path() 在缩放 viewBox 下
+// 的坐标换算问题。跑完把节点摘掉，避免 DOM 累积。
+function rtSpark(pathD, color) {
+ if (!pathD) return;
+ var svg = document.getElementById("rt-topo-svg");
+ if (!svg) return;
+ var c = document.createElementNS(RT_SVGNS, "circle");
+ c.setAttribute("r", "3.2");
+ c.setAttribute("fill", color || "#ffffff");
+ c.setAttribute("class", "rt-spark");
+ var am = document.createElementNS(RT_SVGNS, "animateMotion");
+ am.setAttribute("dur", "0.85s");
+ am.setAttribute("path", pathD);
+ am.setAttribute("fill", "freeze");
+ am.setAttribute("begin", "0s");
+ c.appendChild(am);
+ svg.appendChild(c);
+ setTimeout(() => {
+ if (c.parentNode) c.parentNode.removeChild(c);
+ }, 950);
+}
+// 输入：某条 inputch 来消息了（SSE channel_input）。
+function rtSparkInput(source) {
+ rtSpark(_rtEdgeIn[source], "#88c0d0");
+}
+// 输出：某个 agent 往某条 outputch 写了东西（SSE agent_output）。
+function rtSparkOutput(agentID, channel) {
+ if (!channel || !agentID) return;
+ rtSpark(_rtEdgeOut[agentID + "\u0000" + channel], "#ff7fac");
+}
+
+function renderRuntime() {
+ var el = document.getElementById("rt-panel");
+ if (!el) return;
+ var rt = state.runtime;
+ if (!rt) {
+ el.innerHTML =
+ '' +
+ __("运行态数据不可用", "runtime unavailable") +
+ "
";
+ _rtSig = null;
+ return;
+ }
+ var sc = rt.scheduler || {};
+ var residents = rt.residents || [];
+ var channels = rt.channels || [];
+ var inputs = rt.input_channels || [];
+
+ // 数据签名（**不含 uptime**——它每秒都变，带上就等于没缓存）：整体没变就整块跳过。
+ // 签名里必须带 pipelinePhase：否则 SSE 把阶段推到下一格时，
+ // 数据没变 → 早退 → 滑块不动，只能等下一次 /runtime 轮询才追上。
+ var sig = JSON.stringify([
+ sc,
+ residents,
+ channels,
+ inputs,
+ state.pipelinePhase,
+ (state.stageTrail || [])
+ .map(
+ (t) =>
+ t.g + ":" + t.kind + ":" + (t.short || t.label) + "x" + (t.n || 1),
+ )
+ .join(","),
+ ]);
+ if (sig === _rtSig) return;
+ _rtSig = sig;
+
+ // 外壳只建一次；随后**逐段**更新。
+ //
+ // 为什么不是整块 innerHTML：设备通道列表这类数据本来就会来回变（实测远程设备
+ // 通道 11→9 条），整块重建会把没变的段落（含条形 transition）也推倒重来，
+ // 视觉上就是「一闪一闪」。逐段比较后只替换真正变了的那一段。
+ if (!document.getElementById("rt-sec-tiles")) {
+ el.innerHTML =
+ '' +
+ __("运行态", "Runtime") +
+ " " +
+ '
' +
+ '
' +
+ '
' +
+ '
' +
+ '
' +
+ "
';
+ h += rtTile(
+ ready,
+ __("排队", "Ready"),
+ "",
+ ready ? Math.min(100, ready * 20) : 0,
+ ready > 0,
+ );
+ h += rtTile(
+ pending,
+ __("中断", "Pending"),
+ "",
+ pending ? Math.min(100, pending * 25) : 0,
+ pending > 0,
+ pending > 0,
+ );
+ h += rtTile(
+ stack + "/" + maxStack,
+ __("栈", "Stack"),
+ "",
+ (stack / (maxStack || 4)) * 100,
+ stack > 0,
+ );
+ var rFull = residents.filter((r) => r.context_full).length;
+ h += rtTile(
+ residents.length,
+ __("子代理", "Subagents"),
+ rFull ? rFull + __("满", " full") : "",
+ residents.length ? Math.min(100, residents.length * 20) : 0,
+ residents.length > 0,
+ rFull > 0,
+ );
+ h += "
";
+ // 「累计：入队 … 执行 … 抢占 …」那一整行纯文字被去掉了：它对"现在忙不忙"
+ // 没有帮助，却占掉一整行，是总览里最大的一坨文字。
+ put("tiles", h);
+
+ // ---- 段 2：阶段管道（滑块，SSE stage 事件驱动）----
+ put("pipe", rtPipelineHtml(state.pipelinePhase, state.stageTrail));
+
+ // ---- 段 3：队列（四级中断 + 一条排队）----
+ //
+ // 设计是「四条中断队列（L1–L4）+ 一条排队队列」共五个，所以必须画五行：
+ // 只画四条会让「排队输入」这条线在运行态里凭空消失，而它正是
+ // 「不需要及时处理」的那一半输入。排队队列**无级别**，故用不同配色 + 虚线。
+ h = '' + __("队列", "Queues") + "
";
+ var maxQ = Math.max(1, ready, q[1] || 0, q[2] || 0, q[3] || 0, q[4] || 0);
+ var maxReg = 1;
+ var maxPre = 1;
+ RT_LEVELS.forEach((L) => {
+ maxReg = Math.max(maxReg, byLv[L.lv] || 0);
+ maxPre = Math.max(maxPre, preLv[L.lv] || 0);
+ });
+ // 槽位数按全场最大深度缩放（且至少 5 格）：0 时也有可见形状，不空着。
+ var qSlots = Math.max(5, Math.min(16, maxQ));
+ // 五个**等大表框**（四级中断 + 一条排队），与阶段管道同一套视觉语言。
+ // 此前是五行扁条，四级中断全为 0 时四行几乎全是空白，又占高度又难看。
+ h += '';
+ RT_LEVELS.forEach((L) => {
+ var depth = q[L.lv] || 0;
+ var reg = byLv[L.lv] || 0;
+ var pre = preLv[L.lv] || 0;
+ h +=
+ '
' +
+ '
' +
+ L.name +
+ " " +
+ escHtml(L.desc) +
+ "
" +
+ '
' +
+ depth +
+ "
" +
+ rtSlots(depth, qSlots, L.cls) +
+ '
' +
+ rtMini(reg, maxReg, __("登记", "registered")) +
+ rtMini(pre, maxPre, __("抢占", "preempted")) +
+ "
";
+ });
+ // 第五条：排队队列（无级别，纯 FIFO）。
+ // 它不是优先级而是另一**类别**（排队 vs 中断），所以用虚线框区分。
+ h +=
+ '
' +
+ '
' +
+ __("排队", "queued") +
+ " FIFO
" +
+ '
' +
+ ready +
+ "
" +
+ rtSlots(ready, qSlots, "rt-lv-q") +
+ '
' +
+ __("无级别", "no priority") +
+ "
";
+ h += "
' +
+ RT_ICO.bolt +
+ " " +
+ __("立即运行", "immediate") +
+ "：" +
+ escHtml(sc.immediate.kind || "") +
+ " #" +
+ sc.immediate.id +
+ 'L' +
+ (sc.immediate.level || 0) +
+ "
";
+ }
+ put("levels", h);
+
+ // ---- 段 4：中断栈 ----
+ h = '' + __("栈", "Stack") + "
";
+ // 深度先给一条进度条（"压了几层 / 上限几层"一眼可读），下面再列具体帧。
+ h += rtSlider(stack, maxStack, __("深度", "depth"), stack + " / " + maxStack);
+ if (frames.length) {
+ h += '';
+ frames.forEach((f, i) => {
+ var t = (f && f.task) || {};
+ h +=
+ '
' +
+ escHtml(t.kind || "") +
+ " #" +
+ (t.id || "?") +
+ 'L' +
+ (t.level || 0) +
+ (i === frames.length - 1 ? " · " + __("栈顶", "top") : "") +
+ "
";
+ });
+ h += "
' +
+ __(
+ "中断栈为空（当前无被抢占的现场）",
+ "stack empty (nothing preempted)",
+ ) +
+ "
";
+ }
+ if (sc.running) {
+ h +=
+ '' +
+ __("正在运行", "running") +
+ "：" +
+ escHtml(sc.running.kind || "") +
+ " #" +
+ sc.running.id +
+ " (L" +
+ (sc.running.level || 0) +
+ ")
";
+ }
+ put("stack", h);
+
+ // ---- 段 5：Agent 拓扑 ----
+ //
+ // 每个 agent 一条横带：左是归它的 inputch、中间是它自己（圆环 = 负载）、
+ // 右是它能写的 outputch，连线即路由。归属、路由、容量、负载全部画进
+ // 同一张 SVG，不再单开"通道分配"一节——那本来就是这个拓扑的一部分。
+ put("topo", rtAgentTopology(rtAgents(rt)));
+}
+
+// loadRuntime 拉运行态小快照并就地重绘面板（约 2KB，可秒级轮询）。
+async function loadRuntime() {
+ try {
+ var rt = await api("/runtime");
+ state.runtime = rt;
+ renderRuntime();
+ } catch (e) {
+ state.runtime = null;
+ }
+}
+
+// startRuntimeTicker 起 3s 轮询：运行态只在总览页可见时才有意义，
+// 其它页签上不浪费请求。切回总览时 renderAll 会立刻再拉一次，不必等下一拍。
+// startChatTicker：聊天页可见时 3s 轮询一次增量（与运行态同一节奏）。
+// SSE 仍在（token 级流式靠它），轮询是「数据查询 api」那条腿：
+// 界面最终状态由轮询拉到的数据决定，SSE 只负责让流式看起来即时。
+function startChatTicker() {
+ if (state._chatTicker) return;
+ state._chatTicker = setInterval(() => {
+ var tab = document.querySelector("#tab-chat");
+ if (tab && tab.classList.contains("active")) {
+ syncChatFromHistory().catch(() => {});
+ }
+ }, 3000);
+}
+
+function startRuntimeTicker() {
+ if (state._runtimeTicker) return;
+ state._runtimeTicker = setInterval(() => {
+ var tab = document.querySelector("#tab-overview");
+ if (tab && tab.classList.contains("active")) {
+ loadRuntime();
+ }
+ }, 3000);
+}
+
+// ===== Overview =====
+//
+// 总览页是**静态骨架 + 数据绑定**：DOM 只在首帧建一次，之后所有刷新只改
+// 文本/类名，绝不重建节点。此前 renderAll 每 15s 把整个总览（含运行态面板）
+// innerHTML 重建一遍 —— 那是页面上最刺眼的周期性闪烁的来源。
+//
+// 文字也压到最少：状态用彩色圆点表达，其余只留数字与两字标签，不再堆
+// 「未初始化 / 不可用」这类整句描述。
+var OV_ICONS = {
+ activity:
+ '' +
+ icon +
+ ' ' +
+ (dot ? '— ' +
+ '' +
+ label +
+ "
"
+ );
+}
+
+function renderOverview() {
+ var host = document.getElementById("tab-overview");
+ if (!host) return;
+ // 只在首帧建骨架；之后（renderAll 每 15s 一次）只 updateOverview。
+ // 一个节点都不重建，所以不会闪。
+ if (!document.getElementById("ov-kpis")) {
+ host.innerHTML =
+ '
' +
+ '' +
+ ovKpi("status", OV_ICONS.activity, __("状态", "Status"), true) +
+ ovKpi("uptime", OV_ICONS.clock, __("运行", "Uptime")) +
+ ovKpi("plugins", OV_ICONS.puzzle, __("插件", "Plugins")) +
+ ovKpi("version", OV_ICONS.tag, __("版本", "Version")) +
+ ovKpi("llm", OV_ICONS.brain, "LLM", true) +
+ ovKpi("memory", OV_ICONS.db, __("记忆", "Memory")) +
+ ovKpi("docs", OV_ICONS.file, __("文档", "Docs")) +
+ ovKpi("runtime", OV_ICONS.cpu, __("运行时", "Runtime")) +
+ "
' +
+ __("记忆星图", "Memory Star Map") +
+ ' ' +
+ '
';
+ }
+ updateOverview();
+ // 星图在主页常驻：容器已建好，首次就拉数据 + 初始化 3D。
+ if (document.getElementById("sm-container-home") && !state.starmapInit) {
+ renderChatStarmap();
+ }
+}
+
+function ovSet(id, text) {
+ var el = document.getElementById(id);
+ if (el && el.textContent !== String(text)) el.textContent = String(text);
+}
+function ovDot(id, cls) {
+ var el = document.getElementById(id);
+ if (el && el.className !== cls) el.className = cls;
+}
+
+// updateOverview 只写值与类名，从不改结构。
+function updateOverview() {
+ var s = state.status || {};
+ var k = state.kernel;
+ var running = s.status === "running";
+ ovSet("ov-status", running ? __("运行中", "running") : s.status || "unknown");
+ ovDot("ov-status-dot", "ov-dot " + (running ? "ok" : "warn"));
+ ovSet(
+ "ov-uptime",
+ state.startedAt ? fmtUptime(Date.now() - state.startedAt) : "-",
+ );
+ ovSet("ov-plugins", ((k && k.plugins) || []).length || 0);
+ // 内核身份：光有版本号分不清是哪个内核、哪次构建 —— 补上内核名与 commit。
+ // 之前 36b577b 改图标 KPI 时把 kernel_name 丢了，只剩余 "v1.4.0"。
+ var kb = (k && k.build) || {};
+ var kv = kb.version || s.version || "";
+ ovSet("ov-version", kv ? "v" + kv : "—");
+ ovSet(
+ "ov-version-sub",
+ kv
+ ? (kb.kernel_name || "HomeAgent") +
+ (kb.commit && kb.commit !== "unknown"
+ ? " · " + String(kb.commit).slice(0, 7)
+ : "")
+ : "",
+ );
+ var llm = (k && k.llm) || {};
+ ovDot("ov-llm-dot", "ov-dot " + (llm.available ? "ok" : "bad"));
+ ovSet("ov-llm", llm.provider || "—");
+ var mem = (k && k.memory) || {};
+ ovSet(
+ "ov-memory",
+ mem.available ? mem.entity_count + "/" + mem.relation_count : "—",
+ );
+ var docs = (k && k.documents) || {};
+ ovSet("ov-docs", docs.available ? docs.doc_count : "—");
+ var rt = (k && k.runtime) || {};
+ ovSet(
+ "ov-runtime",
+ rt.goroutines
+ ? rt.goroutines + (rt.memory_mb ? " · " + rt.memory_mb + "M" : "")
+ : "—",
+ );
+ // 开源许可卡：协议标识 + 协议全文 + 源码仓库。
+ //
+ // 为什么单独成框、且三者都给：AGPL-3.0 §13 的义务是「向网络使用者提供
+ // 取得 Corresponding Source 的机会」——只给一个仓库链接、不写协议名，
+ // 使用者看不出这受什么许可约束，也看不出网络服务场景下还有 §13 的义务。
+ // 内容对一次构建是常量，所以填一次就够（__html 比对避免重复重建）。
+ var legal = document.getElementById("ov-legal");
+ if (legal) {
+ var lb = (k && k.build) || {};
+ var src = lb.source_url || "";
+ var lic = lb.license || "";
+ var licURL = lb.license_url || "";
+ var rows = "";
+ if (lic) {
+ rows +=
+ '";
+ }
+ if (src) {
+ rows +=
+ '";
+ }
+ // 网络条款只在 AGPL 系的许可下才成立，所以按标识判断，不硬写协议名。
+ var note =
+ lic && lic.toUpperCase().indexOf("AGPL") >= 0
+ ? '' +
+ __(
+ "网络服务条款（§13）：把修改后的版本作为网络服务对外提供时，必须向使用者提供取得对应源码的途径。",
+ "Network clause (section 13): offering a modified version as a network service requires giving users a way to obtain the Corresponding Source.",
+ ) +
+ "
"
+ : "";
+ var want = rows
+ ? "" + __("开源许可", "License") + " " + rows + note
+ : "";
+ if (legal.__html !== want) {
+ legal.__html = want;
+ legal.innerHTML = want;
+ }
+ }
+}
+
+// ===== Chat =====
+var _chatLayoutBuilt = false;
+
+function buildChatLayout() {
+ var cont = document.getElementById("tab-chat");
+ var k = state.kernel || {};
+ var html = '';
+ html +=
+ '
' +
+ '' +
+ __("对话", "Chat") +
+ " " +
+ "" +
+ __("星图", "Star Map") +
+ " " +
+ "" +
+ __("终端", "Terminal") +
+ " " +
+ "" +
+ __("运行中命令", "Running Commands") +
+ " " +
+ "" +
+ __("记忆", "Memory") +
+ " " +
+ "" +
+ __("上下文", "Context") +
+ " " +
+ "" +
+ __("知识", "Knowledge") +
+ "
";
+ html +=
+ '
';
+ html +=
+ '
' +
+ __("对话", "Chat") +
+ ' ' +
+ escHtml(state.chatStage || "") +
+ ' ';
+ if (state.messages.length === 0) {
+ html +=
+ '
' +
+ __(
+ "开始对话以测试 Agent 回复",
+ "Start a conversation to test Agent replies",
+ ) +
+ "
";
+ }
+ html +=
+ "
" +
+ '
";
+ html +=
+ '
' +
+ __("星图", "Star Map") +
+ " " +
+ '
';
+ html +=
+ '
' +
+ __("终端", "Terminal") +
+ ' 0 ' +
+ '
';
+ html +=
+ '
' +
+ __("命令历史", "Command History") +
+ ' 0 ' +
+ '
';
+ html +=
+ '
' +
+ __("记忆", "Memory") +
+ " " +
+ '
' +
+ __("实体", "Entities") +
+ ' ' +
+ (k?.memory?.entity_count || "-") +
+ "
" +
+ '
' +
+ __("关系", "Relations") +
+ ' ' +
+ (k?.memory?.relation_count || "-") +
+ "
" +
+ '
' +
+ '' +
+ __("查询", "Query") +
+ " " +
+ '
' +
+ "
";
+ html +=
+ '
' +
+ __("上下文", "Context") +
+ " " +
+ '
' +
+ '' +
+ __("获取上下文", "Get Context") +
+ " " +
+ '
' +
+ "
";
+ html +=
+ '
' +
+ __("知识", "Knowledge") +
+ " " +
+ '
' +
+ __("项目", "Items") +
+ ' ' +
+ (k?.knowledge?.item_count ?? "-") +
+ "
" +
+ '
' +
+ '' +
+ __("按分类浏览", "Browse by category") +
+ " " +
+ '
' +
+ " " +
+ '
' +
+ '' +
+ __("搜索", "Search") +
+ " " +
+ '' +
+ __("全库", "All") +
+ " " +
+ '
' +
+ '
' +
+ '
' +
+ '
' +
+ '
' +
+ '
' +
+ __("创建", "Create") +
+ " " +
+ '
" +
+ "
";
+ html += "
' +
+ ' ";
+ });
+ return s;
+ }
+ var html = "";
+ if (msgs.length === 0) {
+ html =
+ '' +
+ __(
+ "开始对话以测试 Agent 回复",
+ "Start a conversation to test Agent replies",
+ ) +
+ "
' +
+ ' ';
+ } else if (att.type === "audio") {
+ // 音频用原生播放器：与图片同理，附件能在聊天里直接消费才算可见。
+ // preload="metadata" 只拉时长不拉全部字节，避免历史消息满屏时并发下载。
+ attHtml =
+ '' +
+ escHtml(att.name || "audio") +
+ (att.size ? " (" + formatBytes(att.size) + ")" : "") +
+ " ";
+ } else {
+ var sizeStr = att.size ? formatBytes(att.size) : "";
+ attHtml =
+ '' +
+ '" +
+ escHtml(att.name || "附件") +
+ (sizeStr ? " (" + sizeStr + ") " : "") +
+ " ";
+ }
+ html +=
+ '' +
+ '
' +
+ srcLabel +
+ "
" +
+ attHtml +
+ (c ? '
' + renderMd(c) + "
" : "") +
+ "
' +
+ __("已拒绝", "Denied") +
+ " "
+ : running
+ ? '' +
+ __("调用中", "Running") +
+ " "
+ : '' +
+ __("完成", "Done") +
+ " ";
+ var pluginHtml = tc.plugin
+ ? '' + escHtml(tc.plugin) + " "
+ : "";
+ tcs +=
+ '";
+ });
+ }
+ var body = rc + tcs;
+ var growCls = m._grow ? " grow-in" : "";
+ if (m._grow) m._grow = false;
+ var isStreamingLast = i === msgs.length - 1 && streamingLast;
+ if (isStreamingLast) {
+ var liveRow =
+ '' + pillHtml() + " "
+ : "");
+ if (c) {
+ body +=
+ '' +
+ liveRow +
+ '
' +
+ c +
+ "
' + liveRow + "
";
+ }
+ } else if (c) {
+ body +=
+ '";
+ }
+ if (role === "system") {
+ html +=
+ '";
+ } else if (isChan) {
+ html +=
+ '' +
+ '
' +
+ chanLetter(m.source) +
+ "
" +
+ '
' +
+ escHtml(m.source) +
+ "
" +
+ body +
+ "
' +
+ '
' +
+ (role === "user" ? userAvatar : aiAvatar) +
+ "
" +
+ '
' +
+ body +
+ "
" +
+ "
' +
+ aiAvatarL +
+ '
' +
+ '' + pillHtml() + " "
+ : "") +
+ "
' +
+ '
' +
+ '
' +
+ '
' +
+ (isStreaming ? __("思考中...", "Thinking...") : __("思考", "Thinking")) +
+ " " +
+ '
' +
+ RT_ICO.caret +
+ " " +
+ '
' +
+ (isStreaming
+ ? '
' +
+ escHtml(preview) +
+ '
'
+ : '
' + renderMd(text) + "
") +
+ "
' +
+ __(
+ "3D 星图不可用（CDN 加载失败）",
+ "Star map unavailable (CDN load failed)",
+ ) +
+ "
";
+ state.starmapInit = true;
+ state.starmapLoading = false;
+ return;
+ }
+ if (!window.THREE) {
+ cont.innerHTML =
+ '';
+ state.starmapInit = false;
+ state.starmapLoading = false;
+ return;
+ }
+ if (cont.querySelector("canvas")) {
+ var rect = cont.getBoundingClientRect();
+ if (starmapRen && rect.width > 0)
+ starmapRen.setSize(rect.width, Math.max(rect.height, 250));
+ return;
+ }
+ if (state.starmapInit) {
+ if (starmapRen) {
+ var rect = cont.getBoundingClientRect();
+ if (rect.width > 0)
+ starmapRen.setSize(rect.width, Math.max(rect.height, 250));
+ cont.appendChild(starmapRen.domElement);
+ starmapRen.domElement.style.display = "block";
+ } else {
+ // starmapRen was destroyed (e.g. re-render cycle), restart
+ state.starmapInit = false;
+ state.starmapLoading = false;
+ }
+ return;
+ }
+ if (state.starmapLoading) return;
+ state.starmapLoading = true;
+ loadChatStarmapData();
+}
+
+async function loadChatStarmapData() {
+ try {
+ var resp = await api("/memory/graph");
+ if (
+ !resp ||
+ !resp.success ||
+ !resp.data ||
+ !resp.data.nodes ||
+ resp.data.nodes.length === 0
+ ) {
+ document.getElementById("sm-container-chat").innerHTML =
+ '' +
+ __("暂无记忆数据", "No memory data") +
+ "
";
+ state.starmapInit = true;
+ state.starmapLoading = false;
+ return;
+ }
+ var d = resp.data;
+ starmapNodes = d.nodes || [];
+ starmapEdges = d.edges || [];
+ state.starmapInit = true;
+ state.starmapLoading = false;
+ initChatStarmap();
+ } catch (e) {
+ document.getElementById("sm-container-chat").innerHTML =
+ '' +
+ __("加载失败", "Load failed") +
+ "
";
+ state.starmapInit = true;
+ state.starmapLoading = false;
+ }
+}
+
+function initChatStarmap() {
+ // 容器可以是独立星图页签 / 总览页 / 聊天面板 —— 同一套 renderer
+ // 会在多个容器间搬运 canvas（appendChild 即可）。
+ var cont = starmapActiveContainer();
+ if (!cont) return;
+ var rect = cont.getBoundingClientRect();
+ var w = Math.max(rect.width || 300, 100);
+ var h = Math.max(rect.height || 250, 100);
+ if (starmapRen) {
+ starmapRen.setSize(w, h);
+ // 换父节点前先把旧角标从旧容器里拨掉，否则它会残留在旧位置。
+ if (starmapLabelEl && starmapLabelEl.parentElement === cont) {
+ starmapLabelEl.style.display = "none";
+ }
+ cont.appendChild(starmapRen.domElement);
+ starmapRen.domElement.style.display = "block";
+ return;
+ }
+ starmapScene = new THREE.Scene();
+ starmapScene.fog = new THREE.FogExp2(0x0a0a1a, 0.015);
+ starmapCam = new THREE.PerspectiveCamera(60, w / h, 0.1, 2000);
+ starmapCam.position.set(0, 20, 40);
+ starmapRen = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+ starmapRen.setSize(w, h);
+ starmapRen.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+ starmapRen.setClearColor(0x0a0a1a, 1);
+ cont.innerHTML = "";
+ cont.appendChild(starmapRen.domElement);
+ starmapCtrl = new THREE.OrbitControls(starmapCam, starmapRen.domElement);
+ starmapCtrl.enableDamping = true;
+ starmapCtrl.dampingFactor = 0.05;
+ starmapCtrl.rotateSpeed = 0.5;
+ starmapCtrl.zoomSpeed = 0.8;
+ var al = new THREE.AmbientLight(0x444466, 0.6);
+ starmapScene.add(al);
+ var dl = new THREE.DirectionalLight(0xffffff, 0.8);
+ dl.position.set(50, 100, 50);
+ starmapScene.add(dl);
+ createStarField();
+ createNebula();
+ // 共享几何（低规格）：所有节点/光晕球复用这两份。
+ starmapGeo = new THREE.SphereGeometry(0.5, 8, 6);
+ starmapGlowGeo = new THREE.SphereGeometry(1.0, 8, 6);
+ buildChatStarmapGraph();
+ starmapRen.domElement.addEventListener("mousemove", onStarmapMove);
+ starmapRen.domElement.addEventListener("click", onStarmapClick);
+ window.addEventListener("resize", onStarmapResize);
+ if (starmapRaf) cancelAnimationFrame(starmapRaf);
+ starmapAnimate();
+ // 活动数据源：/runtime 3s + /memory/graph/pulse 10s。
+ // 只在星图真正初始化后启动，避免在隐藏页签空跑。
+ starmapStartActivity();
+}
+
+// starmapStartActivity 启动两路活动轮询（幂等）。
+function starmapStartActivity() {
+ if (state.starmapPulseTimer) return;
+ starmapPullActivity();
+ starmapPullPulse();
+ state.starmapPulseTimer = setInterval(() => {
+ starmapPullActivity();
+ }, 3000);
+ var pulseTimer = setInterval(() => {
+ starmapPullPulse();
+ }, 10000);
+ // 两个 id 合并到一个字段会导致 setInterval 被覆盖，这里分开记。
+ state.starmapActivityTimer = pulseTimer;
+}
+
+function buildChatStarmapGraph() {
+ starmapNodeMeshes.forEach((m) => {
+ starmapScene.remove(m);
+ });
+ starmapEdgeLines.forEach((l) => {
+ starmapScene.remove(l);
+ });
+ starmapNodeMeshes = [];
+ starmapEdgeLines = [];
+ if (starmapNodes.length === 0) return;
+ // Calculate node degrees for leaf node detection
+ var nodeDegs = {};
+ starmapNodes.forEach((n) => {
+ nodeDegs[n.id] = 0;
+ });
+ starmapEdges.forEach((e) => {
+ nodeDegs[e.source_id] = (nodeDegs[e.source_id] || 0) + 1;
+ nodeDegs[e.target_id] = (nodeDegs[e.target_id] || 0) + 1;
+ });
+ var nodeMap = {};
+ starmapNodes.forEach((n) => {
+ nodeMap[n.id] = n;
+ });
+ var sorted = starmapNodes
+ .slice()
+ .sort((a, b) => (b.mention_count || 0) - (a.mention_count || 0));
+ var mc = sorted.map((n) => n.mention_count || 0);
+ var maxMc = Math.max(...mc, 1),
+ minMc = Math.min(...mc, 0),
+ rng = maxMc - minMc || 1;
+ // Layout positions
+ var pos = {};
+ var baseR = 15,
+ maxR = 80;
+ var total = sorted.length;
+ var acc = 0;
+ sorted.forEach((n, i) => {
+ var m = n.mention_count || 0,
+ mn = rng > 0 ? (m - minMc) / rng : 0;
+ var radius = baseR + mn * (maxR - baseR);
+ var baseStep = (Math.PI * 2) / total;
+ var extra = mn * baseStep * 2;
+ var angle = acc + extra / 2;
+ acc += baseStep + extra;
+ pos[n.id] = {
+ x: radius * Math.cos(angle),
+ y: (Math.random() - 0.5) * (10 + mn * 20),
+ z: radius * Math.sin(angle),
+ mn: mn,
+ rad: radius,
+ };
+ });
+ // Leaf nodes (degree 1) reposition near parent
+ sorted.forEach((n) => {
+ var deg = nodeDegs[n.id] || 0;
+ if (deg !== 1) return;
+ var edge = starmapEdges.find(
+ (e) => e.source_id === n.id || e.target_id === n.id,
+ );
+ if (!edge) return;
+ var parentId = edge.source_id === n.id ? edge.target_id : edge.source_id;
+ if (!pos[parentId]) return;
+ var pp = pos[parentId];
+ var m = n.mention_count || 0,
+ mn = rng > 0 ? (m - minMc) / rng : 0;
+ var off = 6 + mn * 8 + Math.random() * 4;
+ var a2 = Math.random() * Math.PI * 2;
+ pos[n.id] = {
+ x: pp.x + off * Math.cos(a2),
+ y: pp.y + (Math.random() - 0.5) * (4 + mn * 6),
+ z: pp.z + off * Math.sin(a2),
+ mn: mn,
+ rad: off,
+ };
+ });
+ // Force-directed simulation
+ for (var it = 0; it < 50; it++) {
+ var ids = Object.keys(pos);
+ // Repulsion
+ for (var i = 0; i < ids.length; i++) {
+ for (var j = i + 1; j < ids.length; j++) {
+ var a = pos[ids[i]],
+ b = pos[ids[j]];
+ var dx = a.x - b.x,
+ dy = a.y - b.y,
+ dz = a.z - b.z,
+ d = Math.sqrt(dx * dx + dy * dy + dz * dz) + 0.1;
+ var rf = 0.5 + (a.mn + b.mn) * 0.5;
+ if (d < 25) {
+ var force = (0.06 * rf) / Math.max(d, 0.5);
+ a.x += (dx / d) * force;
+ a.y += (dy / d) * force;
+ a.z += (dz / d) * force;
+ b.x -= (dx / d) * force;
+ b.y -= (dy / d) * force;
+ b.z -= (dz / d) * force;
+ }
+ }
+ }
+ // Attraction along edges
+ starmapEdges.forEach((e) => {
+ var a = pos[e.source_id],
+ b = pos[e.target_id];
+ if (!a || !b) return;
+ var dx = b.x - a.x,
+ dy = b.y - a.y,
+ dz = b.z - a.z,
+ d = Math.sqrt(dx * dx + dy * dy + dz * dz) + 0.1;
+ var af = Math.max(0.3, 1.0 - (a.mn + b.mn) * 0.3);
+ if (d > 20) {
+ var force = 0.04 * af;
+ a.x += (dx / d) * force;
+ a.y += (dy / d) * force;
+ a.z += (dz / d) * force;
+ b.x -= (dx / d) * force;
+ b.y -= (dy / d) * force;
+ b.z -= (dz / d) * force;
+ }
+ });
+ // Centering constraint
+ ids.forEach((id) => {
+ var p = pos[id];
+ var dist = Math.sqrt(p.x * p.x + p.y * p.y + p.z * p.z);
+ var maxA = maxR * 1.5;
+ if (dist > maxA) {
+ var s = maxA / dist;
+ p.x *= s;
+ p.y *= s;
+ p.z *= s;
+ }
+ });
+ }
+ // Create nodes
+ //
+ // ★ 低规格渲染（1151 节点实测后定的方案）：保留**全部**节点，
+ // 但把每节点开销从「一个独立球 + 一个独立球光晕 + 一张 256x64
+ // 文字贴图」降到「共享几何 + 共享材质 + 无常驻文字」。
+ //
+ // 改之前的实际开销（生产实例 1151 节点）：
+ // - SphereGeometry(16,12) 主球 + 同样规格的光晕球 = 2302 个独立
+ // BufferGeometry，共约 88 万三角形
+ // - 每节点一张 256x64 CanvasTexture = 1151 张 +
+ // 1151 个纹理，仅文字就吃约 72MB 显存
+ // 这两样在「星图只是个展示」的前提下纯属浪费：星图全图远看根本
+ // 读不清标签（256x64 贴在半径 0.5~2.5 的球上，本来就糊）。
+ //
+ // 现在：共享一份 SphereGeometry(8,6)（约 84 三角形/节点），
+ // 颜色靠每 mesh 的 material.color（材质本身仍每节点一份，
+ // 因为 MeshPhongMaterial 要独立发光强度才能做活动脉冲）。
+ // 标签改为「hover / 选中时才在容器角上显示 HTML 文本」——
+ // 文字清晰度反而比 3D 贴图好，且零显存。
+ starmapNodes.forEach((n) => {
+ var p = pos[n.id];
+ if (!p) return;
+ var mn = n.mention_count || 0,
+ mnr = rng > 0 ? (mn - minMc) / rng : 0;
+ var rad = 0.5 + mnr * 2.0;
+ // 服务端 type 是首字母大写（"Concept" / "Person" …），
+ // 原 smTypeColors 的键全是小写，永远匹配不上 ⇒ 全图单色 0xcccccc。
+ // 这里统一小写归一化，并补上服务端实际会产出的类型。
+ var col = smTypeColors[String(n.type || "").toLowerCase()] || 0xcccccc;
+ var ei = 0.3 + mnr * 0.7;
+ var mat = new THREE.MeshPhongMaterial({
+ color: col,
+ emissive: col,
+ emissiveIntensity: ei,
+ shininess: 30,
+ });
+ var mesh = new THREE.Mesh(starmapGeo, mat);
+ mesh.position.set(p.x, p.y, p.z);
+ mesh.scale.setScalar(rad / 0.5); // 共享几何半径 0.5，按需缩放
+ mesh.userData.nodeData = n;
+ mesh.userData.nodeId = n.id;
+ mesh.userData.baseEmissive = ei;
+ mesh.userData.baseScale = rad / 0.5;
+ mesh.userData.baseGlow = 0.12 + mnr * 0.08;
+ // Glow sphere：共享几何 + 各自材质（发光强度要独立才能做脉冲）
+ var gm = new THREE.MeshBasicMaterial({
+ color: col,
+ transparent: true,
+ opacity: mesh.userData.baseGlow,
+ side: THREE.BackSide,
+ blending: THREE.AdditiveBlending,
+ });
+ var gs = new THREE.Mesh(starmapGlowGeo, gm);
+ gs.scale.setScalar(rad * 1.2 + mnr * 0.5);
+ mesh.add(gs);
+ mesh.userData.glowSphere = gs;
+ // 名字不再烘成贴图；hover 时由 onStarmapMove 写进角标。
+ starmapScene.add(mesh);
+ starmapNodeMeshes.push(mesh);
+ });
+ // Create edges
+ //
+ // 866 条边原本每条一个 BufferGeometry + Line + LineBasicMaterial
+ // （866 个 draw call）。改为**按关系类型分组**的少量 LineSegments：
+ // 同类型边合并成一个几何体，draw call 从 866 降到「关系类型数」
+ // （生产实例实测 6 种左右）。
+ //
+ // 副作用：单条边不再能单独点选。星图此前也没有点选边的交互
+ // （onStarmapClick 只处理节点），所以这是纯粹的成本削减。
+ var edgeByColor = {};
+ starmapEdges.forEach((e) => {
+ var a = pos[e.source_id],
+ b = pos[e.target_id];
+ if (!a || !b) return;
+ var col = smEdgeColors[e.relation_type] || smEdgeColors[e.type] || 0x444466;
+ var k = String(col);
+ if (!edgeByColor[k]) edgeByColor[k] = { col: col, pts: [] };
+ edgeByColor[k].pts.push(a.x, a.y, a.z, b.x, b.y, b.z);
+ });
+ Object.keys(edgeByColor).forEach((k) => {
+ var g = edgeByColor[k];
+ if (!g.pts.length) return;
+ var geo = new THREE.BufferGeometry();
+ geo.setAttribute("position", new THREE.Float32BufferAttribute(g.pts, 3));
+ var mat = new THREE.LineBasicMaterial({
+ color: g.col,
+ transparent: true,
+ opacity: 0.4,
+ });
+ var seg = new THREE.LineSegments(geo, mat);
+ starmapScene.add(seg);
+ starmapEdgeLines.push(seg);
+ });
+}
+
+// 回合收尾：由 SSE 事件（agent_output final / reset 帧）或 watchdog 驱动。
+// POST 结束 ≠ 回合结束：agent 可能还在生成（排队+长生成），提前复位
+// chatLoading 会让后续 delta 走全量重建、停止按钮消失、用户误发重复消息。
+function endChatTurn() {
+ if (!state.chatLoading) return;
+ state.chatLoading = false;
+ state.chatStage = "";
+ if (state._turnWatchdog) {
+ clearTimeout(state._turnWatchdog);
+ state._turnWatchdog = null;
+ }
+ var btn = document.getElementById("chat-send-btn");
+ if (btn) {
+ btn.disabled = false;
+ btn.textContent = __("发送", "Send");
+ }
+ var sb = document.getElementById("chat-stop-btn");
+ if (sb) sb.style.display = "none";
+ rerenderChat(true);
+}
+
+// 回合看门狗：POST 已 abort 且 SSE 迟迟无终帧时兕底收尾（连接不稳/事件丢失），
+// 提示用户回复可能已生成、可刷新查看历史。避免回合永久卡在 loading。
+function armTurnWatchdog() {
+ if (state._turnWatchdog) clearTimeout(state._turnWatchdog);
+ state._turnWatchdog = setTimeout(() => {
+ state._turnWatchdog = null;
+ if (state.chatLoading) {
+ endChatTurn();
+ toast(
+ __(
+ "长时间未收到回复，连接可能不稳定；回复可能已生成，可刷新页面查看",
+ "No reply received for a long time; the reply may have been generated, refresh to check",
+ ),
+ true,
+ );
+ }
+ }, 120000);
+}
+
+// 上传文件并注入 agent：multipart POST /api/v1/chat/file。
+// 服务端落盘 uploads/ 后注入「[用户发送了文件: 名字 (大小)] 已保存到 <路径>」；
+// 回复与普通消息一样走 SSE 流式渲染。可选附言从输入框读取。
+// 拖拽文件到聊天区即发送（可选：先在输入框写附言）
+function initChatDragDrop() {
+ var panel = document.getElementById("chat-panel-chat");
+ if (!panel || panel.__dnd) return;
+ panel.__dnd = true;
+ panel.addEventListener("dragover", (e) => {
+ e.preventDefault();
+ panel.style.outline = "2px dashed var(--accent, #4a90d9)";
+ });
+ panel.addEventListener("dragleave", () => {
+ panel.style.outline = "";
+ });
+ panel.addEventListener("drop", (e) => {
+ e.preventDefault();
+ panel.style.outline = "";
+ if (e.dataTransfer.files && e.dataTransfer.files.length) {
+ sendChatFile(e.dataTransfer.files[0]);
+ }
+ });
+ // 粘贴截图/复制的文件直接发送
+ document.addEventListener("paste", (e) => {
+ var chatVisible =
+ document.getElementById("chat-panel-chat") &&
+ document.getElementById("chat-input");
+ if (!chatVisible) return;
+ var items = e.clipboardData && e.clipboardData.files;
+ if (items && items.length && document.activeElement !== null) {
+ sendChatFile(items[0]);
+ }
+ });
+}
+
+async function sendChatFile(fileObj, extraText) {
+ if (!fileObj || state.chatLoading) return;
+ var inp = document.getElementById("chat-input");
+ var message = (extraText || inp.value || "").trim();
+ if (inp) inp.value = "";
+ var fd = new FormData();
+ fd.append("file", fileObj);
+ if (message) fd.append("message", message);
+ state.messages.push({
+ role: "user",
+ content: message,
+ attachment: {
+ // 与服务端的 attType 判定保持一致（image/audio/file），
+ // 否则乐观渲染的卡片会在 SSE 回流后变成另一种样式。
+ type: /^image\//.test(fileObj.type)
+ ? "image"
+ : /^audio\//.test(fileObj.type)
+ ? "audio"
+ : "file",
+ url: URL.createObjectURL(fileObj),
+ name: fileObj.name,
+ size: fileObj.size,
+ },
+ });
+ rerenderChat(true);
+ state.chatLoading = true;
+ state.chatStage = __("等待AI回复...", "Waiting for AI...");
+ rerenderChat(true);
+ try {
+ await api("/chat/file", { method: "POST", body: fd, rawBody: true });
+ // 回复经 SSE 流式到达，这里无需处理响应体
+ } catch (e) {
+ toast(
+ __("文件发送失败：" + e.message, "File send failed: " + e.message),
+ true,
+ );
+ state.chatLoading = false;
+ endChatTurn();
+ }
+}
+
+async function sendChat() {
+ var inp = document.getElementById("chat-input");
+ var btn = document.getElementById("chat-send-btn");
+ var stopBtn = document.getElementById("chat-stop-btn");
+ var text = inp.value.trim();
+ if (!text || state.chatLoading) return;
+ state.chatStick = true;
+ state.chatFinalIdx = -1;
+ state.messages.push({ role: "user", content: text });
+ inp.value = "";
+ rerenderChat(true);
+ state.chatLoading = true;
+ state.chatStage = __("等待AI回复...", "Waiting for AI...");
+ btn.disabled = true;
+ btn.textContent = "";
+ if (stopBtn) stopBtn.style.display = ""; // 生成期间可停止
+ rerenderChat(true);
+ // 触发式 POST：短超时仅确认受理；回复靠 SSE 流式渲染（对齐 GUI 行为）。
+ try {
+ var ctrl = new AbortController();
+ var ackTimer = setTimeout(() => {
+ ctrl.abort();
+ }, 15000);
+ var r = null;
+ try {
+ r = await api("/chat", {
+ method: "POST",
+ body: JSON.stringify({ message: text }),
+ signal: ctrl.signal,
+ });
+ } catch (ackErr) {
+ // 同步超时/失败：不阻塞 UI，等 SSE 兑底；明确提示"可能已发送"
+ console.warn("[sendChat] trigger failed: " + ackErr.message);
+ toast(
+ __(
+ "请求超时（可能已发送，请稍候或在收到回复前勿重复发送）",
+ "Request timeout (may have been sent; wait for reply before resending)",
+ ),
+ true,
+ );
+ r = null;
+ } finally {
+ clearTimeout(ackTimer);
+ }
+ var last = state.messages[state.messages.length - 1];
+ if (r && r.response) {
+ if (last && last.role === "assistant" && last._streaming) {
+ last.content = r.response || __("(无响应)", "(no response)");
+ last._grow = true;
+ if (!last.reasoning_content) {
+ last.reasoning_content = r.reasoning_content || "";
+ }
+ last._final = true;
+ delete last._streaming;
+ } else {
+ state.messages.push({
+ role: "assistant",
+ content: r.response || __("(无响应)", "(no response)"),
+ reasoning_content: r.reasoning_content,
+ tool_calls:
+ last && last.role === "assistant" && last.tool_calls
+ ? last.tool_calls
+ : [],
+ _final: true,
+ _grow: true,
+ });
+ }
+ state.chatFinalIdx = state.messages.length - 1;
+ }
+ rerenderChat(true);
+ } catch (e) {
+ // 真实错误（非受理超时）：展示错误信息
+ if (!String(e.message || "").includes("aborted")) {
+ state.messages.push({
+ role: "assistant",
+ content: __("错误: ", "Error: ") + e.message,
+ _final: true,
+ });
+ rerenderChat(true);
+ toast(__("请求失败: ", "Request failed: ") + e.message, true);
+ }
+ } finally {
+ if (r && r.response) {
+ // 同步兜底已拿到完整回复：回合结束
+ endChatTurn();
+ } else {
+ // 触发式受理（POST 已 abort/失败）：回合仍打开，等 SSE 流式渲染；
+ // 由 agent_output final / reset 帧 / watchdog 收尾
+ armTurnWatchdog();
+ }
+ }
+}
+
+// 停止生成 / 发送中断消息。核心拦截语义：有 LLM 在跑则取消当前
+// 请求并以 [中断消息] 重启轮次；无则在跑则作为普通消息处理。
+async function interruptChat() {
+ try {
+ await api("/chat/interrupt", {
+ method: "POST",
+ body: JSON.stringify({}),
+ });
+ toast(__("已发送中断信号", "Interrupt signal sent"));
+ } catch (e) {
+ toast(__("中断失败: ", "Interrupt failed: ") + e.message, true);
+ }
+}
+
+async function queryMemoryChat() {
+ var q = document.getElementById("mem-query")?.value;
+ var r = document.getElementById("mem-result-chat");
+ if (!r || !q) return;
+ r.innerHTML = '
';
+ try {
+ var data = await api("/memory?q=" + encodeURIComponent(q) + "&depth=2");
+ r.innerHTML =
+ '' +
+ escHtml(JSON.stringify(data, null, 2)) +
+ " ";
+ } catch (e) {
+ r.innerHTML =
+ '' +
+ __("查询失败: ", "Query failed: ") +
+ escHtml(e.message) +
+ "
";
+ }
+}
+
+async function queryMemoryContext() {
+ var q = document.getElementById("ctx-query")?.value;
+ var r = document.getElementById("ctx-result");
+ if (!r) return;
+ r.innerHTML = '
';
+ try {
+ var data = await api("/memory/context?q=" + encodeURIComponent(q || ""));
+ var ctx = data?.context || __("无上下文", "No context");
+ var summary = data?.summary || "";
+ var entities = data?.entities || [];
+ var tk = data?.token_estimate || 0;
+ var html = '';
+ if (summary)
+ html +=
+ '
' +
+ __("摘要", "Summary") +
+ ' ' +
+ escHtml(summary) +
+ "
";
+ html +=
+ '
Token ' +
+ __("预估", "Estimate") +
+ ' ' +
+ tk +
+ "
";
+ if (entities.length) {
+ html +=
+ '
' +
+ __("实体", "Entities") +
+ ' ' +
+ entities.map((e) => escHtml(e.name || e.id || "")).join(", ") +
+ "
";
+ }
+ html +=
+ '
' +
+ escHtml(ctx) +
+ " ' +
+ __("获取失败: ", "Get failed: ") +
+ escHtml(e.message) +
+ "
";
+ }
+}
+
+// 知识库面板：搜索 / 创建 / 删除 / 刷新计数。
+//
+// 此前三处问题：搜索把裸 JSON 直接 stringify 丢进 （用户看到一坨
+// 机器码）；创建后不刷新计数（1644 行读的是 state.kernel 快照，创建
+// 完仍是旧值）；没有任何删除入口，也没有媒体上传。
+function knowEsc(v) {
+ return String(v == null ? "" : v)
+ .replace(/&/g, "&")
+ .replace(//g, ">");
+}
+
+async function refreshKnowledgeCount() {
+ try {
+ var d = await api("/knowledge");
+ var el = document.getElementById("know-count");
+ if (el && d && d.names) el.textContent = d.names.length;
+ // 稠密路（多模态）状态提示
+ var hint = document.getElementById("know-media-hint");
+ if (hint && d && d.dense) {
+ if (d.dense.enabled) {
+ hint.textContent =
+ __("多模态已就绪 ", "Multimodal ready ") +
+ (d.dense.ready || 0) +
+ "/" +
+ ((d.dense.ready || 0) + (d.dense.stale || 0));
+ } else {
+ hint.textContent = __(
+ "未接入多模态：图片只记录不参与召回",
+ "Multimodal off: images recorded but not searchable",
+ );
+ }
+ }
+ } catch (e) {
+ /* 计数刷新失败不该打断用户操作 */
+ }
+}
+
+function renderKnowledgeResults(views, q) {
+ if (!views || !views.length) {
+ return (
+ '' +
+ __("未找到相关知识", "No matching knowledge") +
+ "
"
+ );
+ }
+ var html = "";
+ views.forEach((v) => {
+ html +=
+ '';
+ html += '
';
+ html +=
+ '' +
+ knowEsc(v.name) +
+ " ";
+ if (v.size) {
+ html += '' + v.size + " B ";
+ }
+ html +=
+ '' +
+ __("删除", "Delete") +
+ " ";
+ html += "
";
+ if (v.media && v.media.length) {
+ html += '
';
+ v.media.forEach((m) => {
+ var kind = m.kind || "file";
+ html +=
+ '[' +
+ knowEsc(kind) +
+ "] " +
+ knowEsc(m.digest.slice(0, 8)) +
+ "… ";
+ });
+ html += "
";
+ }
+ if (v.preview) {
+ html +=
+ '
' +
+ knowEsc(v.preview) +
+ "
";
+ }
+ html += "
' +
+ '▸ ' +
+ '' +
+ knowEsc(it.name) +
+ " " +
+ (it.size
+ ? ' ' + it.size + "B "
+ : "") +
+ (it.media && it.media.length
+ ? ' [' +
+ it.media.length +
+ __(" 媒体", " media") +
+ "] "
+ : "") +
+ "
";
+ });
+ // 子分类
+ (node.children || []).forEach((c) => {
+ var isCur = _knowCat === c.path;
+ var mark = isCur ? "● " : "";
+ html +=
+ '' +
+ mark +
+ knowEsc(c.name) +
+ ' ' +
+ c.item_count +
+ "/" +
+ c.total_count +
+ "
";
+ html += renderKnowTree(c, depth + 1);
+ });
+ return html;
+}
+
+async function loadKnowledgeTree() {
+ var box = document.getElementById("know-tree");
+ if (!box) return;
+ box.innerHTML = '
';
+ try {
+ var d = await api("/knowledge/tree?items=1");
+ if (!d || !d.tree) {
+ box.innerHTML =
+ '' +
+ __("暂无分类", "No categories yet") +
+ "
";
+ return;
+ }
+ box.innerHTML = renderKnowTree(d.tree, 0);
+ } catch (e) {
+ box.innerHTML =
+ '' +
+ __("加载分类失败: ", "Load categories failed: ") +
+ knowEsc(e.message) +
+ "
";
+ }
+}
+
+function selectKnowledgeCategory(path) {
+ _knowCat = path || "";
+ var lbl = document.getElementById("know-cat-scope");
+ if (lbl) {
+ lbl.textContent = _knowCat
+ ? __("范围：", "scope: ") + _knowCat
+ : __("范围：全库", "scope: all");
+ }
+ loadKnowledgeTree();
+ // 立刻按新范围搜一次，省一次点击
+ var q = document.getElementById("know-query")?.value;
+ if (q) searchKnowledgeChat();
+}
+
+function clearKnowledgeCategory() {
+ selectKnowledgeCategory("");
+}
+
+async function searchKnowledgeChat() {
+ var q = document.getElementById("know-query")?.value;
+ var cat = _knowCat || "";
+ var r = document.getElementById("know-result-chat");
+ if (!r) return;
+ if (!q) {
+ r.innerHTML =
+ '' +
+ __("请输入查询关键词", "Enter a keyword") +
+ "
";
+ return;
+ }
+ r.innerHTML = '
';
+ try {
+ var url = "/knowledge?q=" + encodeURIComponent(q);
+ if (cat) url += "&category=" + encodeURIComponent(cat);
+ var data = await api(url);
+ r.innerHTML = renderKnowledgeResults(data && data.results, q);
+ } catch (e) {
+ r.innerHTML =
+ '' +
+ __("搜索失败: ", "Search failed: ") +
+ knowEsc(e.message) +
+ "
";
+ }
+}
+
+async function deleteKnowledge(name) {
+ if (
+ !confirm(
+ __("确定删除知识「", 'Delete knowledge "') +
+ name +
+ __("」？此操作不可撤销。", '"? This cannot be undone.'),
+ )
+ ) {
+ return;
+ }
+ try {
+ await api("/knowledge?name=" + encodeURIComponent(name), {
+ method: "DELETE",
+ });
+ toast(__("知识「", 'Knowledge "') + name + __("」已删除", '" deleted'));
+ refreshKnowledgeCount();
+ searchKnowledgeChat();
+ } catch (e) {
+ toast(__("删除失败: ", "Delete failed: ") + e.message, true);
+ }
+}
+
+async function createKnowledgeChat() {
+ var name = document.getElementById("know-name")?.value;
+ var content = document.getElementById("know-content")?.value;
+ var fileInput = document.getElementById("know-media");
+ var files = fileInput && fileInput.files ? fileInput.files : null;
+ if (!name) {
+ toast(__("名称不能为空", "Name is required"), true);
+ return;
+ }
+ if ((!content || !content.trim()) && (!files || !files.length)) {
+ toast(__("内容与媒体至少要有一项", "Content or media is required"), true);
+ return;
+ }
+ try {
+ var r;
+ if (files && files.length) {
+ // 有文件走 multipart：服务端按**探测到的真实类型**分流，
+ // 图片/音视频入媒体库并按 digest 挂到条目上，文本存正文。
+ var fd = new FormData();
+ fd.append("name", name);
+ if (content) fd.append("content", content);
+ for (var i = 0; i < files.length; i++) fd.append("file", files[i]);
+ r = await api("/knowledge", { method: "POST", body: fd });
+ } else {
+ r = await api("/knowledge", {
+ method: "POST",
+ body: JSON.stringify({ name: name, content: content }),
+ });
+ }
+ var msg = __("知识「", 'Knowledge "') + name + __("」已创建", '" created');
+ if (r && r.media)
+ msg += __("，含 ", " with ") + r.media + __(" 个媒体", " media item(s)");
+ if (r && r.rejected && r.rejected.length) {
+ msg += __("；", "; ") + r.rejected.length + __(" 项被跳过", " skipped");
+ }
+ toast(msg);
+ document.getElementById("know-name").value = "";
+ document.getElementById("know-content").value = "";
+ if (fileInput) fileInput.value = "";
+ refreshKnowledgeCount();
+ } catch (e) {
+ toast(__("创建失败: ", "Create failed: ") + e.message, true);
+ }
+}
+
+function switchChatPanel(tab, el) {
+ // 切到知识面板时拉实时计数：面板里的数字来自 state.kernel 快照，
+ // 而知识条目会经工具/上传增删，快照不会自己变（实测创建后仍显示 "-"）。
+ if (tab === "knowledge") {
+ refreshKnowledgeCount();
+ var lbl = document.getElementById("know-cat-scope");
+ if (lbl && !lbl.textContent) {
+ lbl.textContent = _knowCat
+ ? __("范围：", "scope: ") + _knowCat
+ : __("范围：全库", "scope: all");
+ }
+ loadKnowledgeTree();
+ }
+ var panels = {
+ chat: document.getElementById("chat-panel-chat"),
+ starmap: document.getElementById("chat-panel-starmap"),
+ terminal: document.getElementById("chat-panel-terminal"),
+ cmd: document.getElementById("chat-panel-cmd"),
+ memory: document.getElementById("chat-panel-memory"),
+ context: document.getElementById("chat-panel-context"),
+ knowledge: document.getElementById("chat-panel-knowledge"),
+ };
+ Object.keys(panels).forEach((k) => {
+ var p = panels[k];
+ if (p) p.classList.toggle("active", k === tab);
+ });
+ if (el) {
+ var parent = el.parentElement;
+ if (parent) {
+ Array.from(parent.children).forEach((ch) => {
+ ch.classList.remove("active");
+ });
+ el.classList.add("active");
+ }
+ }
+ if (tab === "starmap") {
+ if (!state.starmapInit) {
+ state.starmapLoading = false;
+ renderChatStarmap();
+ } else if (starmapRen) {
+ var cont = document.getElementById("sm-container-chat");
+ if (cont) {
+ var rect = cont.getBoundingClientRect();
+ if (rect.width > 0)
+ starmapRen.setSize(rect.width, Math.max(rect.height, 250));
+ if (!cont.contains(starmapRen.domElement))
+ cont.appendChild(starmapRen.domElement);
+ }
+ }
+ }
+ if (tab === "chat") {
+ state.chatStick = true;
+ var msgsEl = document.getElementById("chat-msgs");
+ if (msgsEl) {
+ try {
+ msgsEl.scrollTo({ top: msgsEl.scrollHeight, behavior: "smooth" });
+ } catch (e) {
+ msgsEl.scrollTop = msgsEl.scrollHeight;
+ }
+ }
+ }
+ if (tab === "context") queryMemoryContext();
+}
+
+// 首屏分段加载条数：只拉最新 N 条，向上滚动触顶时再拉更早的。
+var CHAT_PAGE_SIZE = 40;
+async function loadChatHistory() {
+ try {
+ var data = await api("/chat/history?limit=" + CHAT_PAGE_SIZE);
+ if (data && data.messages) {
+ state.messages = data.messages;
+ state.chatOffset = typeof data.offset === "number" ? data.offset : 0;
+ state.chatTotal =
+ typeof data.total === "number" ? data.total : data.messages.length;
+ state.chatHasMore = !!data.has_more;
+ state.chatLastSeq = historyLastSeq(data);
+ }
+ } catch (e) {}
+}
+
+// historyLastSeq 从一次 /chat/history 响应里取出「已见到的最大 seq」：
+// 优先用服务端给的 last_seq，缺了就取消息里的最大值。
+function historyLastSeq(data) {
+ if (!data) return 0;
+ if (typeof data.last_seq === "number") return data.last_seq;
+ var mx = 0;
+ (data.messages || []).forEach((m) => {
+ if (m && m.seq > mx) mx = m.seq;
+ });
+ return mx;
+}
+
+// applyServerMessages 把服务端消息并进 state.messages，按 seq 对账：
+// - 同 seq 已存在 → 原地替换（工具调用/最终文本是原地更新）；
+// - 不存在 → 追加（若末尾是无 seq 的乐观消息且 role+content 一致，则替换它，
+// 避免"自己刚发的那条"重复成两条）。
+// tailOnly=true 时只做原地更新与"比本地新才追加"，不把尾探测当成新消息。
+// @returns {boolean} 是否真的改动了 state.messages
+function applyServerMessages(list, tailOnly) {
+ if (!list || !list.length) return false;
+ var msgs = state.messages;
+ var changed = false;
+ function carry(prev, sm) {
+ if (prev && prev._final) sm._final = true;
+ if (prev && prev._grow) sm._grow = true;
+ return sm;
+ }
+ list.forEach((sm) => {
+ if (!sm) return;
+ var seq = sm.seq;
+ var found = -1;
+ for (var j = msgs.length - 1; j >= 0 && j >= msgs.length - 12; j--) {
+ if (seq && msgs[j] && msgs[j].seq === seq) {
+ found = j;
+ break;
+ }
+ }
+ if (found >= 0) {
+ if (JSON.stringify(msgs[found]) !== JSON.stringify(sm)) {
+ msgs[found] = carry(msgs[found], sm);
+ changed = true;
+ }
+ return;
+ }
+ if (tailOnly) {
+ var lastS = msgs.length ? msgs[msgs.length - 1].seq : 0;
+ if (seq && (!lastS || seq > lastS)) {
+ msgs.push(sm);
+ changed = true;
+ }
+ return;
+ }
+ if (msgs.length) {
+ var last = msgs[msgs.length - 1];
+ if (
+ !last.seq &&
+ (last.role || "") === (sm.role || "") &&
+ (last.content || "") === (sm.content || "")
+ ) {
+ msgs[msgs.length - 1] = carry(last, sm);
+ changed = true;
+ return;
+ }
+ }
+ msgs.push(sm);
+ changed = true;
+ });
+ list.forEach((sm) => {
+ if (sm && sm.seq > (state.chatLastSeq || 0)) state.chatLastSeq = sm.seq;
+ });
+ if (changed) rerenderChat();
+ return changed;
+}
+
+// pollChatIncremental 轮询「自上次以来新增了什么」。
+//
+// 这就是「暴露数据查询 api，前端轮询后 patch 视图」那条路：after=游标
+// 只拿增量，再单独探一次尾部做原地更新（工具调用/最终文本是原地改的，
+// 不会产生新 seq，只靠 after 拿不到）。视图更新走 commitChatList 的
+// keyed 对账，未变消息节点一个字节都不动 —— 闪烁由此消失。
+function pollChatIncremental() {
+ var after = state.chatLastSeq || 0;
+ if (!after) {
+ // 还没建立游标（首次 / 本地为空）：退回一次性全量，交给已有一致性逻辑
+ return api("/chat/history?limit=" + CHAT_PAGE_SIZE).then((data) => {
+ state.chatLastSeq = historyLastSeq(data);
+ return mergeChatFromHistory(data);
+ });
+ }
+ return api("/chat/history?after=" + after)
+ .then((data) => {
+ if (!data) return;
+ state.chatLastSeq = historyLastSeq(data) || after;
+ applyServerMessages(data.messages || [], false);
+ return api("/chat/history?limit=1");
+ })
+ .then((tail) => {
+ if (tail && tail.messages && tail.messages.length) {
+ applyServerMessages(tail.messages.slice(-1), true);
+ }
+ });
+}
+
+// loadOlderChat 向上翻页：拉 offset 之前的一页，前置到 messages 头部。
+// 保持滚动位置（插入前后 scrollHeight 差值补偿），避免视口跳动。
+var _loadingOlder = false;
+async function loadOlderChat() {
+ if (_loadingOlder || !state.chatHasMore) return;
+ _loadingOlder = true;
+ var msgsEl = document.getElementById("chat-msgs");
+ var prevH = msgsEl ? msgsEl.scrollHeight : 0;
+ var prevTop = msgsEl ? msgsEl.scrollTop : 0;
+ try {
+ var before = state.chatOffset || 0;
+ if (before <= 0) {
+ state.chatHasMore = false;
+ return;
+ }
+ var data = await api(
+ "/chat/history?limit=" + CHAT_PAGE_SIZE + "&before=" + before,
+ );
+ if (data && data.messages && data.messages.length) {
+ state.messages = data.messages.concat(state.messages);
+ state.chatOffset = typeof data.offset === "number" ? data.offset : 0;
+ state.chatHasMore = !!data.has_more;
+ state.chatStick = false; // 向上翻页时不自动粘底
+ renderChat();
+ if (msgsEl) {
+ // 补偿新增内容高度，保持用户视觉位置不变
+ msgsEl.scrollTop = prevTop + (msgsEl.scrollHeight - prevH);
+ }
+ } else {
+ state.chatHasMore = false;
+ }
+ } catch (e) {
+ } finally {
+ _loadingOlder = false;
+ }
+}
+
+// syncChatFromHistory 增量同步：先做一次极轻的"尾巴探测"，只有尾巴变了才拉整页。
+//
+// 原先每 30s（以及每次 SSE 报错）都直接拉一页 40 条：本地实测 180KB、
+// 生产消息更大时可达 ~1MB —— 这是"每次都在发完整聊天记录"的观感来源。
+// 探测只需 1 条（约几 KB），尾巴一致就直接跳过。
+var _syncingChat = false;
+// syncChatFromHistory 保留旧名（多处调用点）：内部改走游标增量轮询。
+function syncChatFromHistory() {
+ if (_syncingChat) return Promise.resolve();
+ _syncingChat = true;
+ return pollChatIncremental()
+ .catch(() => {})
+ .then(() => {
+ _syncingChat = false;
+ });
+}
+
+// mergeChatFromHistory 把服务端的一页历史并进本地：只追加新消息，不重建已有节点。
+// 关键约束：**绝不**用更短的服务端页替换更长的本地列表（那会让用户翻上来的旧页
+// 凭空消失、视口跳回顶部）。
+function mergeChatFromHistory(data) {
+ if (!data || !data.messages || data.messages.length === 0) return;
+ var serverMsgs = data.messages;
+ var localMsgs = state.messages;
+ // 首次加载（空列表）→ 全量赋值
+ if (localMsgs.length === 0) {
+ state.messages = serverMsgs;
+ state.chatOffset = typeof data.offset === "number" ? data.offset : 0;
+ state.chatHasMore = !!data.has_more;
+ rerenderChat(true);
+ return;
+ }
+ // 以「本地末尾 vs 服务端末尾」做依据。分段拉取只会回传最新页，
+ // 本地已向上翻页加载了更早内容，长度上本地可能 ≥ 服务端。
+ var lastLocal = localMsgs[localMsgs.length - 1];
+ var lastServer = serverMsgs[serverMsgs.length - 1];
+ var localContent = lastLocal.content || lastLocal.Content || "";
+ var serverContent = lastServer.content || lastServer.Content || "";
+ // 服务端末尾和本地末尾内容相同 → 无新增（可能裁剪过的轻量项因不含 tool_calls args/result，
+ // 依赖 content+role+time 足以识别）
+ if (localContent === serverContent) {
+ // 检查是否本地末尾被服务端改写（如 stage 插件改写最终文本）
+ if (
+ lastServer.role === "assistant" &&
+ localContent !== serverContent &&
+ serverContent
+ ) {
+ lastLocal.content = serverContent;
+ if (lastServer.ReasoningContent)
+ lastLocal.reasoning_content = lastServer.ReasoningContent;
+ var msgsEl0 = document.getElementById("chat-msgs");
+ if (msgsEl0 && msgsEl0.lastElementChild) {
+ var textEl0 =
+ msgsEl0.lastElementChild.querySelector(".msg-bubble .text");
+ if (textEl0) textEl0.innerHTML = renderMd(serverContent);
+ }
+ }
+ return;
+ }
+ // 有新增消息：服务端末尾与本地末尾不同 → 找出本地新增的差异，追加到 DOM。
+ // 服务端只回传最新页，我们需在 localMsgs 末尾取交集起点（本地末尾在服务端页的位置）
+ // 简化：取服务端末尾3条与本地末尾3条比对，找到重含点的下标；若找不到全量替换最新页。
+ var overlap = -1;
+ for (
+ var k = Math.min(3, serverMsgs.length - 1, localMsgs.length - 1);
+ k >= 1;
+ k--
+ ) {
+ var sMsg = serverMsgs[serverMsgs.length - 1 - k];
+ var lMsg = localMsgs[localMsgs.length - 1 - k];
+ if (
+ lMsg &&
+ (lMsg.content || "") === (sMsg.content || "") &&
+ lMsg.role === sMsg.role
+ ) {
+ overlap = k;
+ break;
+ }
+ }
+ var newMsgs;
+ if (overlap >= 0) {
+ // 本地末尾 overlap 条在服务端页里，之后的部分是新增
+ newMsgs = serverMsgs.slice(serverMsgs.length - overlap);
+ if (newMsgs.length === 0) return; // 无新增（内容改写走上面的分支）
+ } else {
+ // 找不到重合点：**不能**直接拿服务端页覆盖本地。
+ // 服务端只回一页，本地翻上来的旧页更长；覆盖会同时造成两个后果：
+ // 用户翻过的旧消息凭空消失、容器变矮后视口被夹回顶部。
+ // 只有在服务端页不短于本地时才整体替换（那种情况下不丢内容）。
+ if (serverMsgs.length >= localMsgs.length) {
+ state.messages = serverMsgs;
+ rerenderChat(true);
+ }
+ return;
+ }
+ var msgsEl = document.getElementById("chat-msgs");
+ if (msgsEl) {
+ var aiAvatar = '
';
+ if (role === "system") {
+ msgsEl.insertAdjacentHTML(
+ "beforeend",
+ '",
+ );
+ } else if (isChan) {
+ msgsEl.insertAdjacentHTML(
+ "beforeend",
+ '' +
+ (m.source || "?")[0].toUpperCase() +
+ '
' +
+ escHtml(m.source) +
+ "
" +
+ bubble +
+ "
' +
+ (role === "user" ? userAvatar : aiAvatar) +
+ '
' +
+ bubble +
+ "
' +
+ aiAvatar +
+ '
' + pillHtml + " "
+ : "") +
+ "
' +
+ __("暂无终端会话", "No terminal sessions") +
+ "
";
+ return;
+ }
+ var html = "";
+ list.forEach((t, i) => {
+ var detailId = "term-detail-" + i;
+ var scr = (state.termScreens && state.termScreens[t.id]) || null;
+ var running = scr ? scr.running : !!t.running;
+ var fullOut = scr ? scr.output : t.output || "";
+ if (!fullOut) {
+ fullOut =
+ '' +
+ __("[终端暂无输出]", "[No terminal output]") +
+ " ";
+ } else {
+ fullOut = escHtml(fullOut);
+ }
+ html +=
+ '';
+ html +=
+ '
";
+ html +=
+ '' +
+ escHtml(t.id || "-") +
+ " ";
+ html +=
+ '' +
+ escHtml(t.command || "") +
+ " ";
+ html +=
+ '' +
+ (running ? __("运行中", "Running") : __("已关闭", "Closed")) +
+ " ";
+ html +=
+ '' +
+ escHtml(t.created_at || "") +
+ " ";
+ html += "
";
+ html +=
+ '
';
+ html += '
';
+ html +=
+ '
' +
+ escHtml(t.id) +
+ " " +
+ escHtml(t.command || "") +
+ ' ' +
+ escHtml(t.uptime || "") +
+ "
";
+ html +=
+ '
' +
+ fullOut +
+ " ";
+ html += "
' +
+ __("暂无运行中的命令", "No running commands") +
+ "
";
+ return;
+ }
+ var html =
+ ' ' +
+ __("命令", "Command") +
+ " " +
+ __("状态", "Status") +
+ " " +
+ __("运行时长", "Uptime") +
+ " " +
+ '' +
+ escHtml(t.command || t.id || "") +
+ " " +
+ '' +
+ __("运行中", "Running") +
+ " ' +
+ escHtml(t.uptime || "-") +
+ " " +
+ " ";
+ if (out) {
+ html +=
+ "" +
+ '' +
+ escHtml(out.substring(0, 2000)) +
+ " ";
+ }
+ });
+ html += "
";
+ r.innerHTML = html;
+}
+
+function connectSSE() {
+ if (state.eventSource) {
+ console.log("[SSE] closing old connection");
+ state.eventSource.close();
+ }
+ var es;
+ try {
+ es = new EventSource("/api/v1/chat/events", {
+ withCredentials: true,
+ });
+ state.eventSource = es;
+ } catch (ex) {
+ console.error("[SSE] create failed", ex);
+ return;
+ }
+ if (!es) {
+ console.error("[SSE] es is null");
+ return;
+ }
+ console.log("[SSE] connected");
+ es.addEventListener("agent_output", (e) => {
+ try {
+ var ev = JSON.parse(e.data);
+ var p = ev.payload || {};
+ // 光点：agent → 输出通道。总览页拓扑靠它做"消息出去了"的动画；
+ // 其它页没有该 SVG，rtSparkOutput 查不到元素就是 no-op。
+ if (p.channel) rtSparkOutput(ev.source || "", p.channel);
+ // 星图跟随：agent 输出是一次完整活动的收尾，给一记强脉冲。
+ starmapPulse("output", p.channel || null);
+ console.log(
+ "[SSE] agent_output received",
+ p.content ? p.content.substring(0, 50) : "(empty)",
+ );
+ if (!p.content) return;
+ state.chatStage = __("AI 回复中...", "AI replying...");
+ if (p.kind === "channel_output") {
+ // 附件输出（output_type=image/file）：渲染为图片预览/下载卡片
+ var att = null;
+ if (
+ p.output_type === "image" ||
+ p.output_type === "audio" ||
+ p.output_type === "file"
+ ) {
+ att = {
+ type: p.output_type,
+ url: p.url || p.content,
+ size: p.size || 0,
+ name: (p.url || "").split("/").pop() || "附件",
+ };
+ }
+ var cm = {
+ role: "assistant",
+ content: att ? "" : p.content,
+ source: p.channel || "",
+ _final: true,
+ _grow: true,
+ attachment: att,
+ };
+ if (
+ state.chatFinalIdx >= 0 &&
+ state.chatFinalIdx < state.messages.length
+ ) {
+ state.messages.splice(state.chatFinalIdx, 0, cm);
+ state.chatFinalIdx++;
+ } else {
+ state.messages.push(cm);
+ }
+ rerenderChat();
+ return;
+ }
+ var lastM2 = state.messages.length
+ ? state.messages[state.messages.length - 1]
+ : null;
+ if (lastM2 && lastM2.role === "assistant" && !lastM2._final) {
+ // 聚合最终响应：覆盖 delta 累积的中间内容（以聚合为准，
+ // 含 stage 插件改写后的最终文本），并置 final 结束本轮流式。
+ lastM2._grow = true;
+ lastM2.content = p.content;
+ lastM2._final = true;
+ rerenderChat();
+ endChatTurn();
+ return;
+ }
+ if (
+ lastM2 &&
+ lastM2.role === "assistant" &&
+ lastM2._final &&
+ !lastM2.source
+ ) {
+ // 去重：同一轮的重复帧（如 SSE 重连回放）内容相同则忽略；
+ // 内容不同视为新一轮输出（上一轮已 final 且无 source），开新消息。
+ // 旧逻辑无条件 return 会丢弃多轮连发时新一轮的最终回复。
+ if (lastM2.content === p.content) {
+ endChatTurn();
+ return;
+ }
+ }
+ state.messages.push({
+ role: "assistant",
+ content: p.content,
+ _streaming: true,
+ _grow: true,
+ _final: true,
+ });
+ rerenderChat();
+ endChatTurn();
+ } catch (ex) {
+ console.error("[SSE] agent_output error", ex);
+ }
+ });
+ // token 级流式增量：逐块追加到当前回复内容（流式生成中）；
+ // reset 帧表示轮次作废（用户中断）：定格已显示的部分内容，置 final。
+ es.addEventListener("content_delta", (e) => {
+ try {
+ var ev = JSON.parse(e.data);
+ var p = ev.payload || {};
+ if (p.channel === "_consolidation_") return;
+ if (p.reset) {
+ var lm = state.messages.length
+ ? state.messages[state.messages.length - 1]
+ : null;
+ if (lm && lm.role === "assistant" && !lm._final) {
+ lm._final = true;
+ rerenderChat();
+ }
+ // 轮次作废（用户中断）：定格已显示内容；核心会以 [中断消息]
+ // 重启轮次，保持回合打开让确认回复继续流式渲染，
+ // 由其 agent_output final / watchdog 收尾。
+ armTurnWatchdog();
+ return;
+ }
+ if (!p.content) return;
+ state.chatStage = __("AI 回复中...", "AI replying...");
+ var last =
+ state.messages.length > 0
+ ? state.messages[state.messages.length - 1]
+ : null;
+ if (!last || last.role !== "assistant" || last._final) {
+ state.messages.push({
+ role: "assistant",
+ content: "",
+ tool_calls: [],
+ _streaming: true,
+ _grow: true,
+ });
+ last = state.messages[state.messages.length - 1];
+ }
+ last.content += p.content;
+ rerenderChat();
+ } catch (ex) {}
+ });
+ es.addEventListener("terminal_output", (e) => {
+ try {
+ var ev = JSON.parse(e.data);
+ var p = ev.payload || {};
+ if (!p.terminal_id) return;
+ var id = p.terminal_id;
+ if (!state.termScreens) state.termScreens = {};
+ var scr =
+ state.termScreens[id] ||
+ (state.termScreens[id] = { output: "", running: true });
+ if (p.output) scr.output += p.output;
+ if (typeof p.running === "boolean") scr.running = p.running;
+ var bufel = document.getElementById("term-buf-" + id);
+ if (bufel) {
+ appendTermBuf(bufel, p.output || "");
+ var dot = document.getElementById("term-dot-" + id);
+ if (dot) dot.className = "term-dot" + (scr.running ? "" : " stopped");
+ }
+ } catch (ex) {
+ console.error("[SSE] terminal_output error", ex);
+ }
+ });
+ es.addEventListener("reasoning", (e) => {
+ try {
+ var ev = JSON.parse(e.data);
+ var p = ev.payload || {};
+ if (p.channel === "_consolidation_") return;
+ if (p.content) {
+ state.chatStage = __("AI 思考中...", "AI thinking...");
+ var last =
+ state.messages.length > 0
+ ? state.messages[state.messages.length - 1]
+ : null;
+ if (!last || last.role !== "assistant" || last._final) {
+ state.messages.push({
+ role: "assistant",
+ content: "",
+ reasoning_content: "",
+ tool_calls: [],
+ _streaming: true,
+ });
+ last = state.messages[state.messages.length - 1];
+ }
+ // 聚合 reasoning 帧携带全文：直接覆盖（若已有 delta 累积则等价）
+ last.reasoning_content = p.content;
+ rerenderChat();
+ }
+ } catch (ex) {}
+ });
+ // token 级流式增量：逐块追加到当前思考内容；reset 帧表示轮次作废
+ es.addEventListener("reasoning_delta", (e) => {
+ try {
+ var ev = JSON.parse(e.data);
+ var p = ev.payload || {};
+ if (p.channel === "_consolidation_") return;
+ if (p.reset) return; // 轮次作废（用户中断）：清空累积中的思考
+ if (!p.content) return;
+ state.chatStage = __("AI 思考中...", "AI thinking...");
+ var last =
+ state.messages.length > 0
+ ? state.messages[state.messages.length - 1]
+ : null;
+ if (!last || last.role !== "assistant" || last._final) {
+ state.messages.push({
+ role: "assistant",
+ content: "",
+ reasoning_content: "",
+ tool_calls: [],
+ _streaming: true,
+ });
+ last = state.messages[state.messages.length - 1];
+ }
+ last.reasoning_content = (last.reasoning_content || "") + p.content;
+ rerenderChat();
+ } catch (ex) {}
+ });
+ es.addEventListener("tool_call", (e) => {
+ try {
+ var ev = JSON.parse(e.data);
+ var p = ev.payload || {};
+ console.log("[SSE] tool_call", p);
+ if (!p.tool) return;
+ var last =
+ state.messages.length > 0
+ ? state.messages[state.messages.length - 1]
+ : null;
+ if (!last || last.role !== "assistant" || last._final) {
+ state.messages.push({
+ role: "assistant",
+ content: "",
+ tool_calls: [],
+ _streaming: true,
+ });
+ last = state.messages[state.messages.length - 1];
+ }
+ if (!last.tool_calls) last.tool_calls = [];
+ last.tool_calls.push({
+ tool: p.tool,
+ name: p.tool,
+ args: p.args || {},
+ result: p.result || "",
+ status: p.status || "ok",
+ plugin: p.plugin || "",
+ });
+ var pidx = (state.pendingTools || []).indexOf(p.tool);
+ if (pidx !== -1) state.pendingTools.splice(pidx, 1);
+ state.chatStage = __("工具调用: ", "Tool: ") + (p.tool || "");
+ // 星图跟随：工具调用是最可靠的活动信号。工具名（如
+ // knowledge_list / qq_send）会拿去匹配相关实体节点并点亮。
+ starmapPulse("tool", p.tool);
+ rerenderChat();
+ } catch (ex) {
+ console.error("[SSE] tool_call error", ex);
+ }
+ });
+ // 注：后端不发布 tool_result 类型事件（工具结果随 EventToolCall 一次发出），无此监听器。
+ es.addEventListener("stage", (e) => {
+ try {
+ var ev = JSON.parse(e.data);
+ var p = ev.payload || {};
+ var phase = p.phase || "";
+ var tool = p.tool || "";
+ if (p.channel === "_consolidation_") return;
+ console.log("[SSE] stage event", phase, tool);
+ // 驱动总览页的"阶段管道"滑块：滑到当前阶段；一轮跑完（或 2.5s 无新
+ // 事件）自动回到空闲，避免留下一个永远停在 after_output 的假状态。
+ // 阶段轨迹：本轮真实发生过什么，交给阶段管道画成 chip 序列。
+ // 工具调用会反复出现（多轮 toolcall），output_* 单独配色。
+ if (phase === "on_input") {
+ state.stageTrail = [];
+ rtTrailPush(0, "stage", __("输入", "input"), __("输入", "input"));
+ } else if (phase === "pre_action") {
+ rtTrailPush(
+ 1,
+ "stage",
+ __("组装上下文并思考", "assemble context and think"),
+ __("思考", "think"),
+ );
+ } else if (phase === "before_toolcall" && tool) {
+ var isOut = tool.indexOf("output_") === 0;
+ rtTrailPush(2, isOut ? "output" : "tool", tool, rtShortTool(tool));
+ state.toolFlash = true;
+ } else if (phase === "before_output") {
+ rtTrailPush(
+ 3,
+ "stage",
+ __("生成回复", "generate reply"),
+ __("生成", "gen"),
+ );
+ } else if (phase === "after_output") {
+ rtTrailPush(
+ 4,
+ "stage",
+ __("本轮完成", "turn complete"),
+ __("完成", "done"),
+ );
+ }
+ // 星图跟随：阶段推进也作为活动信号（工具名优先匹配节点）。
+ starmapPulse("stage", tool || phase);
+ state.pipelinePhase = phase;
+ if (state.pipelineTimer) clearTimeout(state.pipelineTimer);
+ state.pipelineTimer = setTimeout(() => {
+ state.pipelinePhase = "";
+ if (document.getElementById("rt-sec-pipe")) renderRuntime();
+ }, 2500);
+ if (document.getElementById("rt-sec-pipe")) renderRuntime();
+ // 渲染后再放动画：morph 已经把 chip 文本更新成最新那条。
+ if (state.toolFlash) {
+ state.toolFlash = false;
+ rtFlashLatestTool();
+ }
+ if (phase === "pre_action") {
+ state.chatStage = __("AI 思考中...", "AI thinking...");
+ } else if (phase === "before_toolcall") {
+ state.chatStage = __("工具调用: ", "Tool: ") + (tool || "");
+ if (tool && (state.pendingTools || []).indexOf(tool) === -1) {
+ if (!state.pendingTools) state.pendingTools = [];
+ state.pendingTools.push(tool);
+ rerenderChat();
+ }
+ } else if (phase === "before_output") {
+ state.chatStage = __("生成回复中...", "Generating response...");
+ }
+ var badge = document.getElementById("chat-stage");
+ if (badge) {
+ badge.textContent = state.chatStage || "";
+ badge.style.display = "none";
+ }
+ } catch (ex) {
+ console.error("[SSE] stage error", ex);
+ }
+ });
+ // channel_input：内核在输入进来时另发的一条轻量事件（只带通道名与 agent
+ // id，不带正文）。总览页拓扑靠它画"光点进入 agent"。
+ es.addEventListener("channel_input", (e) => {
+ try {
+ var d = JSON.parse(e.data);
+ var src = d.source || "";
+ if (src) rtSparkInput(src);
+ } catch (ex) {
+ console.error("[SSE] channel_input error", ex);
+ }
+ });
+ es.onopen = () => {
+ console.log("[SSE] connection opened");
+ };
+ es.onerror = (e) => {
+ console.error("[SSE] error", e);
+ // 1) 立即 close 阻止浏览器原生自动重连与手动 setTimeout(connectSSE) 双连接竞态
+ try {
+ state.eventSource && state.eventSource.close();
+ state.eventSource = null;
+ } catch (ex) {}
+ // 2) 连接错误期间可能丢失事件，增量补拉历史（无闪烁）
+ syncChatFromHistory().catch(() => {});
+ // 3) 2s 后手动重连（比原 5s 更快恢复）
+ setTimeout(connectSSE, 2000);
+ };
+ // sync_required：Server 因 Last-Event-ID 不在 ring（delta ID / 已到 tip）无法重放，
+ // 通知前端增量补拉历史——避免前端空等后续聚合事件导致「消息同步不及时」。
+ es.addEventListener("sync_required", (e) => {
+ console.log("[SSE] sync_required received, incremental sync");
+ syncChatFromHistory().catch(() => {});
+ });
+ // Periodically refresh sidebar data
+ if (state._sidebarRefresh) clearInterval(state._sidebarRefresh);
+ state._sidebarRefresh = setInterval(async () => {
+ try {
+ var td = await api("/terminals");
+ if (td && td.terminals) state.terminals = td.terminals;
+ } catch (e) {}
+ try {
+ var ch = await api("/cmd/history");
+ if (ch && ch.history) state.cmdHistory = ch.history;
+ } catch (e) {}
+ renderTerminals();
+ renderCmdHistory();
+ }, 5000);
+}
+
+// ===== Plugins =====
+// 「服务入口」：被反代的插件服务，点一下直接打开。
+//
+// 为什么单独一张卡而不是塞进每个插件的详情：入口是**跨插件**的（同一个
+// webui 端口、不同子域），用户的心智是「我要打开某个服务」，不是
+// 「我要进某个插件的管理页」。
+//
+// 链接带 ?__token=：子域与门户不同源，浏览器不会带上会话 cookie；
+// 不带 token 会 401（这是刻意的受保护默认）。页面已登录，此处复用同一把 key。
+function renderProxyServicesCard() {
+ var svcs = state.proxyServices || [];
+ var base = state.proxyBaseDomain || "localhost";
+ var html =
+ '' + __("服务入口", "Service Entry Points") + " ";
+ if (!svcs.length) {
+ return (
+ html +
+ '
' +
+ __(
+ "暂无被反代的插件服务。插件在 plugin.json 的 proxies 字段里声明后会自动出现在这里。",
+ "No proxied plugin services yet. Declare them in plugin.json's proxies field.",
+ ) +
+ "
' +
+ __(
+ "插件服务经 HomeAgent 同一端口反代。子域形态需要 DNS 能解析 ",
+ "Proxied through the same port. The subdomain form needs DNS for ",
+ ) +
+ "" +
+ escHtml("*." + base) +
+ " " +
+ __(
+ "；路径形态无 DNS 依赖，穿透场景下更可靠（点「打开」优先用它）。",
+ "; the path form has no DNS dependency and is more reliable behind a tunnel (Open prefers it).",
+ ) +
+ "
";
+ html += '';
+ svcs.forEach((s) => {
+ var url = s.url || "";
+ if (url && token) url += "?__token=" + encodeURIComponent(token);
+ var dot = s.ok ? "var(--ok, #22c55e)" : "var(--danger, #d1383d)";
+ html +=
+ '
' +
+ '
' +
+ '
' +
+ escHtml(s.plugin_name || s.plugin) +
+ " " +
+ '
' +
+ escHtml(s.name) +
+ " " +
+ (s.websocket ? '
WS ' : "") +
+ (s.auth === "none"
+ ? '
' +
+ __("未保护", "unprotected") +
+ " "
+ : "") +
+ '
' +
+ escHtml(s.host + "." + base) +
+ " ";
+ // 「打开」优先用**路径形态**（url_portal）：
+ // - 它没有 DNS 依赖，单端口穿透 / 子域无证书时都能用；
+ // - 子域形态要求 DNS 能解析
.<基域名>，而这些域名
+ // 在外部常常不可达（实测：外层只放行一个 Host，三级子域
+ // 因通配证书不匹配而握手失败）。
+ // 保留子域链接作为次选（局域网内直连时它更直观）。
+ var primary = s.url_portal || url;
+ if (s.ok && primary) {
+ html +=
+ '' +
+ __("打开", "Open") +
+ " ";
+ if (url && s.url_portal && url !== s.url_portal) {
+ html +=
+ '' +
+ __("子域", "subdomain") +
+ " ";
+ }
+ } else {
+ html +=
+ '' +
+ escHtml(s.error || __("不可用", "unavailable")) +
+ " ";
+ }
+ html += " ";
+ });
+ html += "
' +
+ __("所有插件", "All Plugins") +
+ " (" +
+ Object.keys(allPluginNames).length +
+ ") ";
+ var names = Object.keys(allPluginNames).sort();
+ if (names.length === 0) {
+ html +=
+ '
' +
+ __("暂无插件", "No plugins") +
+ "
";
+ } else {
+ html +=
+ "
" +
+ __("名称", "Name") +
+ " " +
+ __("状态", "Status") +
+ " " +
+ __("操作", "Actions") +
+ " ' +
+ __("已加载", "Loaded") +
+ " "
+ : loaded && isDisabled
+ ? '' +
+ __("运行中(禁用待生效)", "Running (disable pending)") +
+ " "
+ : isDisabled
+ ? '' +
+ __("已禁用", "Disabled") +
+ " "
+ : '' +
+ __("未加载", "Not Loaded") +
+ " ";
+ var actionsHtml = "";
+ if (loaded) {
+ actionsHtml +=
+ '' +
+ __("禁用", "Disable") +
+ " ";
+ } else {
+ actionsHtml +=
+ '' +
+ __("启用", "Enable") +
+ " ";
+ }
+ if (isExternal) {
+ actionsHtml +=
+ '" +
+ __("卸载", "Unload") +
+ " ";
+ }
+ html +=
+ "" +
+ escHtml(name) +
+ " " +
+ "" +
+ statusHtml +
+ " " +
+ "" +
+ actionsHtml +
+ "
";
+ }
+ html += "
' +
+ __("已安装外部插件", "Installed Plugins") +
+ " (" +
+ installed.length +
+ ") " +
+ "
" +
+ __("名称", "Name") +
+ " " +
+ __("版本", "Version") +
+ " " +
+ __("描述", "Description") +
+ " " +
+ __("操作", "Actions") +
+ " " +
+ escHtml(p.name) +
+ " " +
+ "" +
+ escHtml(p.version || "-") +
+ " " +
+ "" +
+ escHtml((p.description || "").substring(0, 50)) +
+ " " +
+ '" +
+ __("详情", "Details") +
+ " " +
+ '" +
+ __("卸载", "Unload") +
+ "
' +
+ __("插件详情", "Plugin Details") +
+ ": " +
+ escHtml(state.pluginInfo.name) +
+ " " +
+ "
" +
+ escHtml(JSON.stringify(state.pluginInfo, null, 2)) +
+ " " +
+ '
' +
+ __("关闭", "Close") +
+ " ' +
+ __("已注册工具", "Registered Tools") +
+ " (" +
+ tools.length +
+ ") " +
+ '
';
+ tools.forEach((t) => {
+ html +=
+ '' +
+ escHtml(t.name) +
+ " ";
+ });
+ html += "
' +
+ __("系统操作", "System Operations") +
+ " " +
+ '' +
+ __("重载插件", "Reload Plugins") +
+ " ";
+ html +=
+ '
' +
+ __("健康检查", "Health Check") +
+ ' ' +
+ __("运行", "Run") +
+ ' ';
+ if (state.healthResult) {
+ html += renderHealthResult(state.healthResult);
+ } else {
+ html +=
+ '
' +
+ __("尚未运行,点击右上角「运行」开始", "Not run yet, click Run to start") +
+ "
";
+ }
+ html += "
' +
+ __("运行中...", "Running...") +
+ "
";
+ try {
+ var r = await api("/kernel");
+ var tools = r?.tools || [];
+ var healthTool = tools.find((t) => t.name === "healthcheck");
+ if (!healthTool) {
+ panel.innerHTML =
+ '' +
+ __("healthcheck 工具未注册", "healthcheck tool not registered") +
+ "
";
+ return;
+ }
+ panel.innerHTML =
+ '' +
+ __(
+ "通过 Agent 对话触发 healthcheck...",
+ "Triggering healthcheck via Agent...",
+ ) +
+ "
";
+ var chatR = await api("/chat", {
+ method: "POST",
+ body: JSON.stringify({
+ message: __(
+ "请运行 healthcheck 工具进行全面健康检查并报告结果",
+ "Please run the healthcheck tool for a full system check and report the results",
+ ),
+ }),
+ });
+ panel.innerHTML =
+ "" + escHtml(JSON.stringify(chatR, null, 2)) + " ";
+ } catch (e) {
+ panel.innerHTML =
+ '' +
+ __("错误: ", "Error: ") +
+ escHtml(e.message) +
+ "
";
+ toast(__("健康检查失败: ", "Health check failed: ") + e.message, true);
+ }
+}
+
+function renderHealthResult(r) {
+ if (!r || !r.checks)
+ return (
+ '' +
+ __("暂无健康检查数据", "No health check data") +
+ "
"
+ );
+ var checks = r.checks || [];
+ var passed = checks.filter((c) => c.pass).length;
+ var failed = checks.filter((c) => !c.pass).length;
+ var html =
+ '' +
+ '' +
+ __("通过: ", "Pass: ") +
+ passed +
+ " " +
+ '' +
+ __("失败: ", "Fail: ") +
+ failed +
+ " " +
+ '' +
+ __("总计: ", "Total: ") +
+ checks.length +
+ "
";
+ checks.forEach((c) => {
+ var passClass = c.pass ? "check-pass" : "check-fail";
+ if (c.status === "skip") passClass = "check-skip";
+ html +=
+ '' +
+ '' +
+ escHtml(c.name) +
+ " " +
+ '' +
+ (c.status || "unknown") +
+ " " +
+ '' +
+ escHtml(c.detail || "") +
+ "
";
+ });
+ return html;
+}
+
+// ===== Kernel =====
+function renderKernel() {
+ var k = state.kernel;
+ if (!k) {
+ document.getElementById("tab-kernel").innerHTML =
+ '' +
+ __("内核未响应", "Kernel not responding") +
+ "
' +
+ __("构建", "Build") +
+ " " +
+ '
' +
+ __("内核", "Kernel") +
+ ' ' +
+ escHtml(b.kernel_name || "HomeAgent") +
+ "
" +
+ '
' +
+ __("内核版本", "Kernel version") +
+ ' ' +
+ escHtml(b.version ? "v" + b.version : "-") +
+ "
" +
+ '
Commit ' +
+ escHtml(b.commit || "-") +
+ "
" +
+ '
' +
+ __("构建时间", "Build time") +
+ ' ' +
+ escHtml(b.build_time || "-") +
+ "
" +
+ '
' +
+ __("SDK 兼容", "SDK compat") +
+ ' ' +
+ escHtml(b.sdk_compatible || "-") +
+ "
" +
+ (b.source_url
+ ? '
"
+ : "") +
+ "
' +
+ __("运行时", "Runtime") +
+ " " +
+ '
Goroutines ' +
+ (k?.runtime?.goroutines || "-") +
+ "
" +
+ '
' +
+ __("内存", "Memory") +
+ ' ' +
+ (k?.runtime?.memory_mb ? k.runtime.memory_mb + " MB" : "-") +
+ "
" +
+ '
Go ' +
+ __("版本", "Version") +
+ ' ' +
+ (k?.runtime?.go_version || "-") +
+ "
LLM ' +
+ '
Provider ' +
+ (k.llm?.provider || __("未配置", "Not configured")) +
+ "
" +
+ '
' +
+ __("可用源", "Sources") +
+ ' ' +
+ (k.llm?.sources || 0) +
+ "
" +
+ '
' +
+ __("状态", "Status") +
+ '
' +
+ __("记忆", "Memory") +
+ " " +
+ '
' +
+ __("图记忆", "Graph Memory") +
+ ' ' +
+ (k.memory?.available
+ ? k.memory.entity_count +
+ __(" 实体, ", " entities, ") +
+ k.memory.relation_count +
+ __(" 关系", " relations")
+ : __("未初始化", "Uninitialized")) +
+ "
" +
+ '
' +
+ __("文档记忆", "Document Memory") +
+ ' ' +
+ (k.documents?.available
+ ? k.documents.doc_count + __(" 文档", " docs")
+ : __("未初始化", "Uninitialized")) +
+ "
" +
+ '
' +
+ __("文本记忆", "Text Memory") +
+ ' ' +
+ (k.text_memory?.available
+ ? k.text_memory.file_count + __(" 文件", " files")
+ : __("未初始化", "Uninitialized")) +
+ "
" +
+ '
' +
+ __("知识库", "Knowledge") +
+ ' ' +
+ (k.knowledge?.available
+ ? k.knowledge.item_count + __(" 项", " items")
+ : __("未初始化", "Uninitialized")) +
+ "
' +
+ __("插件", "Plugins") +
+ " (" +
+ (k.plugins?.length || 0) +
+ ") ";
+ if (k.plugins?.length) {
+ html += '
';
+ k.plugins.forEach((p) => {
+ html += '' + escHtml(p.name) + " ";
+ });
+ html += "
";
+ } else {
+ html += '
' + __("无", "None") + "
";
+ }
+ html += "
' +
+ __("记忆星图", "Memory Star Map") +
+ ' ' +
+ '
' +
+ '
' +
+ smLegend("person", __("人物", "Person")) +
+ smLegend("concept", __("概念", "Concept")) +
+ smLegend("object", __("对象", "Object")) +
+ smLegend("location", __("地点", "Location")) +
+ smLegend("source", __("来源", "Source")) +
+ "
" +
+ '
' +
+ __(
+ "星图跟随 agent 活动脉动：工具调用 / 阶段推进 / 输出 / 调度器繁忙 / 新记忆生长。",
+ "The map pulses with agent activity: tool calls, stage progress, output, scheduler load, new memory.",
+ ) +
+ "
' +
+ ' "
+ );
+}
+
+// smUpdateStat 在星图页签头部显示节点/边/活动状态。
+function smUpdateStat() {
+ var el = document.getElementById("sm-page-stat");
+ if (!el) return;
+ var act = state.starmapActivity;
+ var busy = act && (act.ready_queue_depth || act.pending_interrupts);
+ var txt = starmapNodes.length + " " + __("节点", "nodes");
+ if (starmapEdges.length)
+ txt += " / " + starmapEdges.length + " " + __("关系", "edges");
+ if (busy) txt += " · " + __("调度中", "busy");
+ el.textContent = txt;
+}
+
+function onStarmapClick(e) {
+ if (!starmapRen || !starmapCam) return;
+ var rect = starmapRen.domElement.getBoundingClientRect();
+ var mouse = new THREE.Vector2(
+ ((e.clientX - rect.left) / rect.width) * 2 - 1,
+ -((e.clientY - rect.top) / rect.height) * 2 + 1,
+ );
+ var rc = new THREE.Raycaster();
+ rc.setFromCamera(mouse, starmapCam);
+ var hits = rc.intersectObjects(starmapNodeMeshes);
+ if (hits.length > 0) {
+ var n = hits[0].object;
+ starmapSelected = starmapSelected === n ? null : n;
+ if (starmapAutoView && starmapSelected)
+ flyStarmapTo(starmapSelected.userData.nodeId, 500);
+ onStarmapMove(e);
+ } else {
+ starmapSelected = null;
+ }
+}
+
+function flyStarmapTo(nodeId, dur) {
+ if (!starmapAutoView) return;
+ var m = starmapNodeMeshes.find((x) => x.userData.nodeId === nodeId);
+ if (!m) return;
+ var tp = m.position.clone(),
+ sp = starmapCam.position.clone(),
+ st = starmapCtrl.target.clone();
+ var dist = tp.length() + 25,
+ ep = new THREE.Vector3(tp.x, tp.y + dist * 0.4, tp.z + dist * 0.8);
+ var t0 = Date.now();
+ (function lerp() {
+ var t = Math.min((Date.now() - t0) / dur, 1),
+ e = 1 - (1 - t) ** 3;
+ starmapCam.position.lerpVectors(sp, ep, e);
+ starmapCtrl.target.lerpVectors(st, tp, e);
+ if (t < 1) requestAnimationFrame(lerp);
+ })();
+}
+
+function onStarmapResize() {
+ if (!starmapRen || !starmapCam) return;
+ var cont = starmapRen.domElement.parentElement;
+ if (!cont) return;
+ var rect = cont.getBoundingClientRect();
+ var w = rect.width || 800,
+ h = Math.max(rect.height || 250, 100);
+ if (w > 0 && h > 0) {
+ starmapCam.aspect = w / h;
+ starmapCam.updateProjectionMatrix();
+ starmapRen.setSize(w, h);
+ }
+}
+
+function starmapAnimate() {
+ starmapRaf = requestAnimationFrame(starmapAnimate);
+ if (starmapCtrl) starmapCtrl.update();
+ if (starmapStarField) starmapStarField.rotation.y += 0.0001;
+ // 推进活动脉冲 / 生长 / 呼吸（无活动时开销≈0）。
+ if (starmapNodeMeshes.length) starmapTickActivity();
+ if (starmapRen && starmapScene && starmapCam)
+ starmapRen.render(starmapScene, starmapCam);
+}
+
+function createNebula() {
+ var nc = 500;
+ var p = new Float32Array(nc * 3),
+ cl = new Float32Array(nc * 3);
+ for (var i = 0; i < nc; i++) {
+ var i3 = i * 3;
+ p[i3] = (Math.random() - 0.5) * 800;
+ p[i3 + 1] = (Math.random() - 0.5) * 800;
+ p[i3 + 2] = (Math.random() - 0.5) * 800;
+ var ch = Math.random();
+ if (ch < 0.33) {
+ cl[i3] = 0.5 + Math.random() * 0.3;
+ cl[i3 + 1] = 0.2 + Math.random() * 0.2;
+ cl[i3 + 2] = 0.7 + Math.random() * 0.3;
+ } else if (ch < 0.66) {
+ cl[i3] = 0.2 + Math.random() * 0.2;
+ cl[i3 + 1] = 0.3 + Math.random() * 0.3;
+ cl[i3 + 2] = 0.8 + Math.random() * 0.2;
+ } else {
+ cl[i3] = 0.7 + Math.random() * 0.3;
+ cl[i3 + 1] = 0.2 + Math.random() * 0.2;
+ cl[i3 + 2] = 0.5 + Math.random() * 0.3;
+ }
+ }
+ var g = new THREE.BufferGeometry();
+ g.setAttribute("position", new THREE.BufferAttribute(p, 3));
+ g.setAttribute("color", new THREE.BufferAttribute(cl, 3));
+ var m = new THREE.PointsMaterial({
+ size: 8,
+ vertexColors: true,
+ transparent: true,
+ opacity: 0.15,
+ sizeAttenuation: true,
+ blending: THREE.AdditiveBlending,
+ });
+ var np = new THREE.Points(g, m);
+ starmapScene.add(np);
+}
+
+// ===== Settings =====
+function pluginDisplayName(p) {
+ if (p === "core") return __("核心", "Core");
+ var name = p.replace("plugin.", "");
+ var meta = state.pluginMeta && state.pluginMeta[name];
+ if (meta)
+ return state.lang === "en" ? meta.name_en || name : meta.name_zh || name;
+ return name;
+}
+
+function renderSettingsSidebar() {
+ var el = document.querySelector(".settings-tabs");
+ if (!el) return;
+ el.innerHTML = "";
+ // 「外观」不是插件设置，但它是 webui 自己的配置，放在设置页最前面。
+ var ap = document.createElement("span");
+ ap.textContent = __("外观", "Appearance");
+ if (state.selectedSection === "appearance") ap.className = "active";
+ ap.onclick = () => {
+ state.selectedSection = "appearance";
+ renderOneSettings();
+ };
+ el.appendChild(ap);
+ state.settingsPlugins.forEach((p) => {
+ var a = document.createElement("span");
+ a.textContent = pluginDisplayName(p);
+ if (p === state.selectedSection) a.className = "active";
+ a.onclick = () => {
+ state.selectedSection = p;
+ renderOneSettings();
+ };
+ el.appendChild(a);
+ });
+}
+
+// 外观设置区：主题（浅/深）+ 配色 + 背景图。与侧栏那个 palette-pop 同一套
+// setColor/applyBgImg/applyBgBlur，只是给它一个正式的、可发现的落点
+// （原来只有侧栏底部一个调色盘图标，找不到）。
+function appearanceHtml() {
+ var theme = document.documentElement.getAttribute("data-theme") || "light";
+ var color = localStorage.getItem("ha-color") || "mono";
+ var dots = "";
+ Object.keys(PALETTES).forEach((k) => {
+ dots +=
+ '' +
+ __("外观", "Appearance") +
+ " " +
+ '
' +
+ __("主题", "Theme") +
+ ' ' +
+ '' +
+ __("浅色", "Light") +
+ " " +
+ '' +
+ __("深色", "Dark") +
+ " " +
+ "
" +
+ '
' +
+ __("配色", "Color") +
+ ' ' +
+ dots +
+ "
" +
+ "
" +
+ __("背景图片 URL", "Background image URL") +
+ " " +
+ '
' +
+ '
' +
+ '' +
+ __("应用", "Apply") +
+ " " +
+ "" +
+ __("清除", "Clear") +
+ " " +
+ "
" +
+ '
' +
+ __("背景模糊", "Background blur") +
+ '：' +
+ blur +
+ "px " +
+ '
" +
+ '
' +
+ __(
+ "配色只影响本站点界面的强调色，不改动 Agent 的人格或数据。",
+ "Colors only affect this dashboard's accent; agent behavior and data are unchanged.",
+ ) +
+ "
' +
+ appearanceHtml() +
+ "
';
+ if (
+ regularKeys.length === 0 &&
+ Object.keys(sourceMap).length === 0 &&
+ Object.keys(mcpServerMap).length === 0 &&
+ state.selectedSection !== "plugin.mcp"
+ ) {
+ html +=
+ '
' +
+ escHtml(state.selectedSection) +
+ ' ' +
+ __("暂无设置项", "No settings") +
+ "
";
+ } else {
+ regularKeys.forEach((k) => {
+ var v = state.settings[k];
+ var sv = typeof v === "object" ? JSON.stringify(v) : String(v);
+ var m = state.meta?.[k];
+ var shortName = k.split(".").pop().replace(/_/g, " ");
+ var label = m?.display_name || shortName;
+ var desc = m?.description || "";
+ var typ = m?.type || "string";
+ var ph = m?.placeholder || "";
+ var opts = m?.options || [];
+ var inpId = "inp-" + k.replace(/\./g, "_");
+ var inp = "";
+ if (typ === "bool") {
+ var chk = sv === "true" ? "checked" : "";
+ inp =
+ '
";
+ } else if (typ === "select") {
+ var selOpts = "";
+ opts.forEach((o) => {
+ selOpts +=
+ '
" +
+ o +
+ " ";
+ });
+ inp =
+ "
" +
+ label +
+ ' " +
+ selOpts +
+ " ";
+ } else if (typ === "text") {
+ inp =
+ "
" +
+ label +
+ ' ";
+ } else {
+ inp =
+ "
" +
+ label +
+ ' ";
+ }
+ var extra = "";
+ if (m?.extra) {
+ m.extra.forEach((f) => {
+ var fk = (k ? k + "." : "") + f.key;
+ var fv = state.settings?.[fk];
+ var fph = f.placeholder || __("输入", "Enter ") + f.label;
+ extra +=
+ '
' +
+ f.label +
+ " ";
+ if (f.type === "select") {
+ var fopts = "";
+ if (f.options)
+ f.options.forEach((o) => {
+ fopts +=
+ '" +
+ o +
+ " ";
+ });
+ extra +=
+ "" +
+ fopts +
+ " ";
+ } else {
+ extra +=
+ '
";
+ });
+ }
+ var descHtml = desc
+ ? '
' +
+ escHtml(desc) +
+ "
"
+ : "";
+ html +=
+ '
' +
+ escHtml(k) +
+ "
" +
+ inp +
+ descHtml +
+ extra +
+ '
" +
+ __("保存", "Save") +
+ " ";
+ });
+ // LLM Sources
+ Object.keys(sourceMap)
+ .sort()
+ .forEach((src) => {
+ var baseKey = "core.llm.sources." + src;
+ var srcData =
+ state.settings?.[baseKey + ".adapter"] ||
+ state.settings?.[baseKey + ".base_url"] ||
+ "";
+ var fields = [
+ {
+ key: "adapter",
+ label: __("适配器", "Adapter"),
+ type: "text",
+ },
+ { key: "base_url", label: "Base URL", type: "text" },
+ { key: "model", label: __("模型", "Model"), type: "text" },
+ { key: "api_key", label: "API Key", type: "text" },
+ {
+ key: "thinking_enabled",
+ label: __("思考模式", "Thinking Mode"),
+ type: "select",
+ options: ["true", "false"],
+ },
+ {
+ key: "adapter_path",
+ label: __("适配器路径", "Adapter Path"),
+ type: "text",
+ },
+ ];
+ var headerLabel = mL10n(src, "LLM Source: " + src);
+ html += '
' + escHtml(headerLabel) + " ";
+ fields.forEach((f) => {
+ var fk = baseKey + "." + f.key;
+ var fv = state.settings?.[fk] || "";
+ var flabel = f.label;
+ var fieldId = "inp-" + fk.replace(/\./g, "_");
+ if (f.type === "select") {
+ var fopts = "";
+ f.options.forEach((o) => {
+ fopts +=
+ '
" +
+ o +
+ " ";
+ });
+ html +=
+ "
" +
+ flabel +
+ ' ' +
+ fopts +
+ " ";
+ } else {
+ html +=
+ "
" +
+ flabel +
+ ' ';
+ }
+ });
+ html +=
+ '
' +
+ '" +
+ __("保存", "Save") +
+ " " +
+ '" +
+ __("删除", "Delete") +
+ "
";
+ });
+ if (
+ Object.keys(sourceMap).length > 0 ||
+ state.selectedSection === "core.llm"
+ ) {
+ html +=
+ '
+ ' +
+ __("添加 LLM 源", "Add LLM Source") +
+ " ";
+ }
+ // MCP Servers
+ if (
+ state.selectedSection === "plugin.mcp" ||
+ Object.keys(mcpServerMap).length > 0
+ ) {
+ html +=
+ '
' +
+ __("MCP 服务器", "MCP Servers") +
+ ' ' +
+ __(
+ "配置 Model Context Protocol 服务端连接",
+ "Configure Model Context Protocol server connections",
+ ) +
+ "
";
+ Object.keys(mcpServerMap)
+ .sort()
+ .forEach((srv) => {
+ var baseKey = "plugin.mcp.servers." + srv;
+ var fields = [
+ {
+ key: "command",
+ label: __("启动命令", "Command"),
+ type: "text",
+ },
+ { key: "url", label: "SSE URL", type: "text" },
+ {
+ key: "args",
+ label: __("参数(JSON数组)", "Args (JSON array)"),
+ type: "text",
+ },
+ {
+ key: "env",
+ label: __("环境变量(JSON数组)", "Env (JSON array)"),
+ type: "text",
+ },
+ ];
+ html += '
' + escHtml(srv) + " ";
+ fields.forEach((f) => {
+ var fk = baseKey + "." + f.key;
+ var fv = state.settings?.[fk] || "";
+ var fieldId = "inp-" + fk.replace(/\./g, "_");
+ html +=
+ "
" +
+ f.label +
+ ' ';
+ });
+ html +=
+ '
' +
+ '" +
+ __("保存", "Save") +
+ " " +
+ '" +
+ __("删除", "Delete") +
+ "
";
+ });
+ html +=
+ '
+ ' +
+ __("添加 MCP 服务器", "Add MCP Server") +
+ " ";
+ }
+ }
+ html += "
' +
+ __("设置", "Settings") +
+ ' ' +
+ __("设置面板已加载", "Settings panel loaded") +
+ "
' +
+ __("已加载的适配器", "Loaded Adapters") +
+ " (" +
+ adapters.length +
+ ") ";
+ if (adapters.length === 0) {
+ html +=
+ '
' +
+ __("暂无适配器", "No adapters") +
+ "
";
+ } else {
+ html +=
+ "
" +
+ __("名称", "Name") +
+ " " +
+ __("版本", "Version") +
+ " " +
+ __("操作", "Actions") +
+ " " +
+ escHtml(a.name) +
+ " " +
+ escHtml(a.version || "-") +
+ " " +
+ '" +
+ __("删除", "Delete") +
+ "
";
+ }
+ html += "
' +
+ __("上传新适配器", "Upload New Adapter") +
+ " " +
+ "" +
+ __("适配器名称（不带 .lua）", "Adapter name (without .lua)") +
+ " " +
+ '" +
+ __("Lua 脚本代码", "Lua Script Code") +
+ " " +
+ '' +
+ '' +
+ __("上传", "Upload") +
+ " ";
+ } catch (e) {
+ html +=
+ '' +
+ __("加载适配器失败: ", "Failed to load adapters: ") +
+ escHtml(e.message) +
+ "
';
- html +=
- '