diff --git a/app/server/public/js/chat.js b/app/server/public/js/chat.js new file mode 100644 index 0000000..5852df9 --- /dev/null +++ b/app/server/public/js/chat.js @@ -0,0 +1,505 @@ +// 聊天消息渲染 / 历史懒加载 / 滚动跟随 / typing 效果(拆自 index.html 内联脚本,纯搬运不改逻辑;经典脚本按序加载,共享全局作用域) +'use strict'; + // ---------- 消息渲染 ---------- + // 旧消息兼容:早期服务端把附件说明拼在正文前(【系统通知】用户上传了文件:...),此处拆开单独展示 📎 行; + // 新版已不再生成这种行,仅历史会话渲染时命中。 + function parseUploadNotice(content) { + const m = /^【系统通知】用户上传了文件:([^\n]*)(?:\n([\s\S]*))?$/.exec(content || ''); + if (!m) return { text: content || '', files: null }; + const files = m[1].split('、').map(s => s.replace(/(大小[^)]*)$/, '').trim()).filter(Boolean); + return { text: m[2] || '', files: files }; + } + + function actionsHtml(ts, content, msgId, usage) { + const b64 = btoa(unescape(encodeURIComponent(content))); + // 删除本条:仅已落库消息可删(传 m.id);流式未落库时无 id,不渲染 + const del = msgId + ? '' + : ''; + // token 用量:In 输入(+缓存命中率), Out 输出;历史重渲染时 usage 是 JSON 串,流式事件里是对象 + let u = usage; + if (typeof u === 'string') { try { u = JSON.parse(u); } catch (_) { u = null; } } + const usageHtml = u && (u.pt || u.ct) + ? '' + + 'In: ' + fmtTok(u.pt || 0) + + (u.cached != null && u.pt ? '/' + Math.round(u.cached / u.pt * 100) + '%' : '') + + ', Out: ' + fmtTok(u.ct || 0) + '' + : ''; + return '
' + + '' + fmtTime(ts) + '' + + usageHtml + + '' + + del + + '
'; + } + + function userMsgHtml(m) { + const p = parseUploadNotice(m.content); + const attach = p.files && p.files.length + ? '
📎 ' + esc(p.files.join('、')) + '
' : ''; + const r = mdHtml(p.text); + // 复制内容取纯文本(不含【系统通知】附件行),与气泡里显示一致 + return '
' + + '
' + attach + r.html + '
' + + actionsHtml(m.created_at, p.text, m.id) + + '
'; + } + + function aiMsgHtml(m) { + const text = (m.content || '').trim(); + const reason = (m.reasoning || '').trim(); + if (!text && !reason) return null; // 纯工具调用的应答:不渲染气泡,工具卡由 appendToolCardsFromAssistant 铺 + const think = reason ? thinkPanelHtml(m.reasoning) : ''; + const bubble = text ? (() => { const r = mdHtml(m.content); return '
' + r.html + '
'; })() : ''; + return '
' + think + bubble + actionsHtml(m.created_at, m.content || '', m.id, m.usage) + '
'; + } + // 思考过程折叠面板:summary 固定名「思考过程」+ 右侧复制按钮,body 展示推理全文。 + // 历史重渲染默认收起(与原设计一致),流式阶段的展开行为由 ensureStreamThinkPanel 显式控制。 + // 复制按钮走 onCopyClick 统一代理:点击时从 DOM 取思考全文(不依赖 b64,流式增量也能复制) + const THINK_COPY_BTN = ''; + function thinkPanelHtml(text) { + return '
思考过程' + THINK_COPY_BTN + '
' + esc(text) + '
'; + } + + // ---------- markdown 代码块逐块复制 ---------- + // marked 把围栏代码渲染成 .md 气泡内的
;渲染完成后做一次 DOM 装饰:
+  // pre 包一层 .code-wrap(定位容器,按钮在滚动区外,横向滚动不带走按钮),右上放复制钮。
+  // 复制文本在点击时从 pre.textContent 现取(onCopyClick 的 .code-wrap 分支),不嵌 b64、不怕内容后续变化。
+  // 只碰 .md 里的 pre:工具卡 / 思考区已有自己的复制按钮,行内 code 不加。
+  const CODE_COPY_BTN = '';
+  function decorateCodePre(root) {
+    if (!root || !root.querySelectorAll) return;
+    root.querySelectorAll('.md pre').forEach(function (pre) {
+      if (pre.querySelector('code')) decorateOne(pre);
+    });
+  }
+  function decorateOne(pre) {
+    const parent = pre.parentElement;
+    if (!parent || parent === document.documentElement) return;
+    if (parent.classList.contains('code-wrap')) {
+      if (parent.querySelector('.act-copy')) return; // 已装饰过,幂等跳过
+      parent.insertAdjacentHTML('beforeend', CODE_COPY_BTN);
+      return;
+    }
+    const wrap = document.createElement('div');
+    wrap.className = 'code-wrap';
+    parent.insertBefore(wrap, pre);
+    wrap.appendChild(pre);
+    wrap.insertAdjacentHTML('beforeend', CODE_COPY_BTN);
+  }
+
+  // 「压缩」摘要卡片:流式收尾与历史重渲染共用的头部(图标 + 标题 + 右侧说明)。
+  function summaryHeaderHtml() {
+    return '' +
+      '' +
+        '' +
+        '' +
+        '' +
+      '' +
+      '上下文总结' +
+      '后续对话以此为起点' +
+    '';
+  }
+
+  // 历史重渲染:被标记 type='summary' 的摘要消息渲染成摘要卡片(默认收起,点开可重现)。
+  // 工具卡不挂:摘要行永远不带 tool_calls;复制/删除按钮照常提供。
+  function summaryMsgHtml(m) {
+    const r = mdHtml(m.content || '');
+    return '
' + + '
' + summaryHeaderHtml() + + '
' + r.html + '
' + + '
' + + actionsHtml(m.created_at, m.content || '', m.id, m.usage) + + '
'; + } + + // ---------- 工具调用卡片(样式/交互同步 index;流式与历史共用) ---------- + function toolArgsSummary(name, argsStr) { + let s = ''; + try { + const o = JSON.parse(argsStr || '{}'); + const key = ['path', 'command', 'regex', 'glob', 'url', 'query', 'source_path', 'destination_path']; + for (const k of key) if (o[k]) { s = String(o[k]); break; } + if (!s) s = argsStr || ''; + } catch (_) { s = argsStr || ''; } + if (s.length > 80) s = s.slice(0, 80) + '…'; + return s; + } + function toolArgsFull(argsStr) { + try { return JSON.stringify(JSON.parse(argsStr || '{}'), null, 2); } + catch (_) { return argsStr || ''; } + } + function toolCopyBtnHtml(text) { + if (!text) return ''; + const b64 = btoa(unescape(encodeURIComponent(text))); + return ''; + } + // 工具卡「删除本条」:删的是 tool 消息行;后端会把它在父 assistant 里的调用同步摘除。 + // msgId = tool 消息的库行 id(历史渲染传 m.id;实时由 tool_result 事件的 msg_id 携带) + function toolDelBtnHtml(msgId) { + if (!msgId) return ''; + return ''; + } + function renderToolCard(id, name, argsStr, createdAt, opts) { + const div = document.createElement('div'); + div.className = 'tool-card'; + div.id = 'tool-' + id; + // 流式执行(open=true):结果在 tool-result 里增量填入,展开才能看到实时输出,回合结束也别自动折上。 + // 历史重渲染(默认 open=false):保持原来的收起观感,用户点 summary 再展开。 + const open = !!(opts && opts.open); + // generating=true:tool_call 参数流式生成中的早卡,占位提示由 finalizeToolCardArgs 替换为完整参数 + const gen = !!(opts && opts.generating); + if (gen) div.classList.add('tool-generating'); + div.innerHTML = + '◌' + + '' + esc(name) + '' + + '' + (gen ? '生成参数中…' : esc(toolArgsSummary(name, argsStr))) + '' + + '
' + (gen ? '' : esc(toolArgsFull(argsStr))) + '
' + + '
执行中…
' + + // 时间行/复制按钮在折叠体内:展开卡片才可见 + '
' + fmtTime(createdAt || Date.now()) + '
'; + return div; + } + // 早卡收尾:回填完整参数、清「生成中」态(assistant_message / 执行时 tool_call 事件都会接手) + function finalizeToolCardArgs(id, name, argsStr) { + delete state.toolCallStreaming[id]; + const card = state.toolCards[id]; + if (!card || !card.classList.contains('tool-generating')) return; + card.classList.remove('tool-generating'); + const argsEl = card.querySelector('.tool-args'); + if (argsEl) argsEl.textContent = toolArgsSummary(name || '', argsStr || ''); + const fullEl = card.querySelector('.tool-args-full'); + if (fullEl) fullEl.textContent = toolArgsFull(argsStr || ''); + } + // tool 消息 content:纯文本,或含图片时的哨兵 JSON {"__blocks__":[...]}(read_file 读图回传) + // 顺手剥掉旧数据里的「,图片见同条消息的 image_url 内容块」尾巴(新版文案已去掉,历史行还在库里) + function parseToolContent(content) { + if (typeof content === 'string' && content.startsWith('{"__blocks__":')) { + try { + const blocks = JSON.parse(content).__blocks__ || []; + const img = blocks.find(b => b.type === 'image_url'); + return { + text: blocks.filter(b => b.type === 'text').map(b => (b.text || '').replace(/,图片见同条消息的 image_url 内容块/g, '')).join('\n'), + imageUrl: img && img.image_url && img.image_url.url || null, + }; + } catch (_) { /* 解析失败按原文显示 */ } + } + return { text: content, imageUrl: null }; + } + function fillToolResult(id, content, isError, liveImageUrl, msgId) { + const card = document.getElementById('tool-' + id); + if (!card) return; + if (isError) card.classList.add('error'); + card.querySelector('.spin').textContent = isError ? '✕' : '✓'; + const parsed = parseToolContent(content); + const pre = card.querySelector('.tool-result'); + if (!pre) return; + pre.textContent = parsed.text || '(空)'; + // 结果就绪后在卡片时间行补复制/删除按钮(删除走统一的 .act-del 委托) + const timeRow = card.querySelector('.tool-time'); + if (timeRow) { + if (msgId) card.dataset.msgId = msgId; // 记住 tool 消息行 id,多次回填不丢 + if (!timeRow.querySelector('.act-copy')) { + timeRow.insertAdjacentHTML('beforeend', toolCopyBtnHtml(parsed.text || '')); + } + if (!timeRow.querySelector('.act-del')) { + timeRow.insertAdjacentHTML('beforeend', toolDelBtnHtml(card.dataset.msgId)); + } + } + const img = liveImageUrl || parsed.imageUrl; + if (img && !card.querySelector('.tool-img')) { + const el = document.createElement('img'); + el.className = 'tool-img'; + el.src = img; + el.title = '点击放大查看'; + pre.insertAdjacentElement('afterend', el); + } + } + // 把 assistant 消息里的 tool_calls 建成工具卡片(历史渲染与 assistant_message 事件共用) + function appendToolCardsFromAssistant(m, container) { + if (!m.tool_calls) return; + let calls; + try { calls = typeof m.tool_calls === 'string' ? JSON.parse(m.tool_calls) : m.tool_calls; } catch (_) { return; } + for (const c of calls) { + const id = c.id || ('c' + Math.random().toString(36).slice(2, 10)); + if (state.toolCards[id]) { // 早卡(流式生成中):回填完整参数收尾;否则跳过不重复建卡 + finalizeToolCardArgs(id, c.function && c.function.name, c.function && c.function.arguments); + continue; + } + const card = renderToolCard(id, c.function && c.function.name || '工具', c.function && c.function.arguments, m.created_at); + container.appendChild(card); + state.toolCards[id] = card; + } + } + + // ---------- tool 卡懒加载 ---------- + // 历史接口不再返回 role=tool 消息(内容大、含 base64 图片);assistant 消息附带 + // tool_call_msg_ids 映射(tool_call.id → tool 消息行 id)。首次展开卡片时才拉取全文回填。 + function hookToolCardLazyLoad() { + const box = $('chat-view'); + if (!box || box.dataset.toolLazyHooked) return; + box.dataset.toolLazyHooked = '1'; + // toggle 事件不冒泡,用捕获阶段代理到列表容器 + box.addEventListener('toggle', e => { + const details = e.target; + if (!details || details.tagName !== 'DETAILS') return; + const card = details.closest('.tool-card'); + if (!card) return; + const pre = card.querySelector('.tool-result'); + // 仍是占位文案才拉取(已回填/流式输出中/加载失败复位后的文案都偏离占位时不重复触发) + if (pre && pre.textContent !== '执行中…') return; + loadToolCardContent(card); + }, true); + } + + async function loadToolCardContent(card) { + const toolCallId = card.id.replace(/^tool-/, ''); + const msgId = state.toolCallMsgIds && state.toolCallMsgIds[toolCallId]; + if (!msgId || card.dataset.loading) return; // 无映射(tool 结果尚未产出/实时回合):SSE 会自己填 + card.dataset.loading = '1'; + const pre = card.querySelector('.tool-result'); + if (pre) pre.textContent = '加载中…'; + try { + const m = await req('GET', '/api/sessions/' + state.sessionId + '/messages/' + msgId); + if (m && m.role === 'tool') fillToolResult(toolCallId, m.content, !!m.is_error, undefined, m.id); + else if (pre) pre.textContent = '(无结果)'; + } catch (_) { + // 复位占位,再次折叠/展开可重试 + if (pre) pre.textContent = '执行中…'; + } finally { + delete card.dataset.loading; + } + } + + function msgNode(m) { + if (m.role === 'user') return userMsgHtml(m); + // 被「压缩总结」标记的摘要消息:重渲染成摘要卡片,而不是普通 AI 气泡 + if (m.role === 'assistant') return m.type === 'summary' ? summaryMsgHtml(m) : aiMsgHtml(m); + return null; // tool 结果不单独展示 + } + + // 把一段消息渲染进目标容器(全量渲染时传 chat-view;懒加载更早页时传离屏 div 再前插进盒子)。 + // tool 行由后端过滤不返回,工具卡内容展开时由 hookToolCardLazyLoad 按 tool_call_msg_ids 拉取。 + // 返回 closeArc:若目标是分页前插且页尾存档段还要与现有顶部合并,调用方可不调它(不补「已存档」尾注)。 + function appendMessagesDom(messages, target) { + // 存档段(type='archived',「仅摘要」时摘要之前的旧历史):连成一截淡色容器, + // 段尾插一条「已存档、不再发给 AI」说明,紧接摘要卡片,一眼能看出上下文从哪里算起。 + let arcWrap = null; + const closeArc = () => { + if (!arcWrap) return; + arcWrap.insertAdjacentHTML('beforeend', + '
以上消息已存档,不再发送给 AI;后续对话从摘要开始
'); + arcWrap = null; + }; + for (const m of messages || []) { + let t = target; + if (m.type === 'archived') { + if (!arcWrap) { arcWrap = document.createElement('div'); arcWrap.className = 'msg-archived'; target.appendChild(arcWrap); } + t = arcWrap; + } else { + closeArc(); + } + const node = msgNode(m); + if (node) t.insertAdjacentHTML('beforeend', node); + if (m.role === 'assistant' && m.tool_call_msg_ids) Object.assign(state.toolCallMsgIds, m.tool_call_msg_ids); + if (m.role === 'assistant') appendToolCardsFromAssistant(m, t); + } + // 历史渲染收口:给本轮新渲染出的代码块补复制按钮(目标可能是分页离屏容器,装饰后再随节点搬迁) + decorateCodePre(target); + return { closeArc }; + } + + function renderDetail(detail) { + const s = detail.session; + state.sessionTitle = (s && s.title) || ''; + state.sessionType = (s && s.assistant_type) || 'secretary'; // 顶部 icon 跟随会话类型 + state.status = (s && s.status) || ''; + state.schedule = detail.schedule || null; // 定时任务状态条数据(随 updatePhaseBar 一并渲染) + state.toolCards = {}; + state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置 + state.toolCallMsgIds = {}; // tool_call.id → tool 消息行 id(展开时懒加载用) + userPaused = false; + removeTyping(); + renderHeader(); + updatePhaseBar({ model_id: s && s.model_id, queue_pos: detail.queue_pos }); + const box = $('chat-view'); + box.innerHTML = ''; + appendMessagesDom(detail.messages || [], box).closeArc(); + if (!(detail.messages || []).length) { + box.innerHTML = '
描述你的需求,AI 会和你讨论并直接干活。
'; + } + state.chatHasMore = !!detail.has_more; + state.chatOldestId = detail.oldest_id || null; + state.chatLoadedCount = (detail.messages || []).length; + hookToolCardLazyLoad(); + scrollBottom(); + updateScrollBottomBtn(); + // 首屏条数太少撑不满滚动区时不会产生 scroll 事件,上滑永远触发不了加载:自动补一页 + if (state.chatHasMore && box.scrollHeight <= box.clientHeight + CHAT_TOP_TRIGGER) loadOlderMessages(); + } + + // ---------- 历史懒加载:开会话先只拉最近 CHAT_INIT_PAGE_SIZE 条,上滑接近顶部后每次再补 CHAT_PAGE_SIZE 条 ---------- + const CHAT_INIT_PAGE_SIZE = 3; // 打开会话首屏非 tool 消息条数 + const CHAT_PAGE_SIZE = 10; // 上滑到顶后每页补充条数 + const CHAT_TOP_TRIGGER = 100; // 距顶不足此像素时触发拉更早页 + let chatLoadingMore = false; // 防重入(滚动事件高频触发) + async function loadOlderMessages() { + if (chatLoadingMore || state.view !== 'chat' || !state.sessionId || !state.chatHasMore) return; + chatLoadingMore = true; + const id = state.sessionId; + const box = $('chat-view'); + // 消息流顶部内联轻提示(不用底部全局 toast,太重):更早页补上后这行自动被顶掉移除 + const tip = document.createElement('div'); + tip.className = 'chat-load-earlier'; + tip.textContent = '正在加载更早消息…'; + box.insertBefore(tip, box.firstChild); + try { + const detail = await req('GET', '/api/sessions/' + id + '?limit=' + CHAT_PAGE_SIZE + '&before=' + (state.chatOldestId || 0)); + // 趁提示行还在流内量几何:下方锚点公式据此得「新 scrollTop = 旧 scrollTop + 新页高 - 提示行高」, + // 旧内容逐像素不动,新页最后一行恰好向下补进提示行的位置 + const prevH = box.scrollHeight; // 含提示行高度 + const prevTop = box.scrollTop; + tip.remove(); // 量完再移除,存档合并/几何计算中提示行不掺和 + if (state.sessionId !== id || state.view !== 'chat') return; // 请求期间已切会话/视图,丢弃 + const frag = document.createElement('div'); // 离屏容器(DocumentFragment 不支持 insertAdjacentHTML) + const { closeArc } = appendMessagesDom(detail.messages || [], frag); + // 存档段跨页合并:存档块总是从历史最开头连排到摘要前,只可能碰盒子顶部; + // 本页尾部是未收尾的存档容器且现有顶部也是存档容器时,子节点并进现有容器(不重复加尾注) + const firstArc = box.firstElementChild && box.firstElementChild.classList.contains('msg-archived') ? box.firstElementChild : null; + const tail = frag.lastChild; + if (firstArc && tail && tail.classList && tail.classList.contains('msg-archived') && !tail.querySelector('.archived-note')) { + // 逆序会打乱存档段顺序:锁住现有首位作固定锚点,尾部子节点依时间序前插进去 + const arcAnchor = firstArc.firstChild; + while (tail.firstChild) firstArc.insertBefore(tail.firstChild, arcAnchor); + frag.removeChild(tail); + } else { + closeArc(); // 本页以存档段结尾且不与现有存档段相连:补「已存档」尾注 + } + if (!detail.has_more) { + // 已翻到最早:在内容流最顶上留一行终点提示(切会话时随 renderDetail 清空) + const end = document.createElement('div'); + end.className = 'chat-load-earlier'; + end.textContent = '没有更早的消息了'; + frag.insertBefore(end, frag.firstChild); + } + // 前插保持视口锚定:prevH 含提示行高,差值即「新增页高 - 提示行高」,提示行被新页尾行原位覆盖 + // 注意先固定锚点:每轮现取 box.firstChild 会把新页插成逆序(终点提示也会随之沉到新页与现有内容之间) + const anchor = box.firstChild; + while (frag.firstChild) box.insertBefore(frag.firstChild, anchor); + box.scrollTop = box.scrollHeight - prevH + prevTop; + state.chatHasMore = !!detail.has_more; + if (detail.oldest_id) state.chatOldestId = detail.oldest_id; + state.chatLoadedCount += (detail.messages || []).length; + // 旧页太短导致补完后仍贴在触发区:继续拉下一页,避免卡在顶部要再动一下才加载 + if (box.scrollTop <= CHAT_TOP_TRIGGER && state.chatHasMore) { + chatLoadingMore = false; + await loadOlderMessages(); // await:防重入锁由整条递归链末端统一释放,避免本层 finally 提前解锁导致重复拉同一页 + } + } catch (e) { + if (state.sessionId === id) toast('加载更早消息失败:' + e.message); + } finally { + tip.remove(); // 失败/丢弃路径下也要收掉进行中提示(已移除时是空操作) + chatLoadingMore = false; + } + } + + function appendUserMsg(content, fileNames, msgId) { + const attach = fileNames && fileNames.length + ? '
📎 ' + esc(fileNames.join('、')) + '
' : ''; + const r = mdHtml(content); + const wrap = document.createElement('div'); + wrap.className = 'msg me'; + wrap.innerHTML = '
' + attach + r.html + '
' + + actionsHtml(Date.now(), content, msgId); + decorateCodePre(wrap); // 用户消息里也可能有围栏代码块 + $('chat-view').appendChild(wrap); + scrollBottom(); + } + + // ---------- 滚动跟随(同步 index:上翻历史自动暂停跟随;右下角浮动钮可回底/转圈) ---------- + const SCROLL_BOTTOM_THRESHOLD = 80; // 距底 80px 内视为「在底部」 + function isNearBottom() { + const box = $('chat-view'); + return box.scrollHeight - box.scrollTop - box.clientHeight < SCROLL_BOTTOM_THRESHOLD; + } + function scrollBottom() { + const box = $('chat-view'); + box.scrollTop = box.scrollHeight; + } + // 仅在「贴底」时跟随输出。userPaused 由 scroll 事件根据当前距底距离持续同步, + // 覆盖滚轮/拖滚动条/键盘/触屏滑动等所有方式,只要用户把视口移出底部就停止跟随, + // 重新回到底部(且无主动暂停意图)就恢复。wheel/touchmove 仍作为「主动向上」的即时信号。 + // 注意:不要在 maybeAutoScroll 里再判 isNearBottom —— 增量已经写进 DOM,一次大 delta + // 把内容推过阈值后 isNearBottom 会变 false,导致后续跟着丢失,看起来像「不跟了」。 + // 「是否贴底」在 scroll 事件里捕获就行,那一刻是 DOM 变更前的真实位置。 + let userPaused = false; + function maybeAutoScroll() { + if (!userPaused) scrollBottom(); + } + // AI 是否「正在干活」:流式输出中,或会话处于 active(含工具执行与多轮模型调用的间隙) + function scrollBusy() { return state.streaming || state.status === 'active'; } + function updateScrollBottomBtn() { + const btn = $('scroll-bottom-btn'); + if (!btn) return; + const inChat = state.view === 'chat' && !!state.sessionId; + const busy = inChat && scrollBusy(); + // 运行中即使贴着底部也保持显示:转圈即「AI 还活着」指示,多轮工具间隙不至于看着像挂掉 + const show = busy || (inChat && !isNearBottom()); + btn.classList.toggle('hidden', !show); + const spinner = btn.querySelector('.sb-spinner'); + if (spinner) spinner.classList.toggle('hidden', !busy); + const arrow = btn.querySelector('.sb-arrow'); + if (arrow) arrow.classList.toggle('hidden', !!busy); + } + function clickScrollBottom() { + userPaused = false; + scrollBottom(); + updateScrollBottomBtn(); + } + // 监听用户滚动意图:向上翻阅历史(滚轮向上/手指下拖)立即暂停跟随,回到底部时恢复。 + // 关键:用 wheel/touchmove 捕获「用户主动向上」的意图(程序滚动不会触发这二者), + // 避免被自动跟随的 scrollBottom 反复拉回底部而无法上翻。 + function bindChatScroll() { + const box = $('chat-view'); + let touchY = 0; + box.addEventListener('wheel', e => { if (e.deltaY < 0) userPaused = true; }, { passive: true }); + box.addEventListener('touchstart', e => { touchY = e.touches[0].clientY; }, { passive: true }); + box.addEventListener('touchmove', e => { + const dy = e.touches[0].clientY - touchY; + if (dy > 3) userPaused = true; + touchY = e.touches[0].clientY; + }, { passive: true }); + box.addEventListener('scroll', () => { + // 用 scroll 事件(而非 wheel/touchmove)统一收敛「是否在底部」, + // 这样拖滚动条、键盘 PageUp/Home、触屏惯性滑等都会被纳入判断。 + // 程序触发的 scrollBottom 总是精确落底,isNearBottom() 恒为 true,不会误标记。 + userPaused = !isNearBottom(); + updateScrollBottomBtn(); + if (box.scrollTop <= CHAT_TOP_TRIGGER) loadOlderMessages(); // 上滑接近顶部 → 懒加载更早历史 + }, { passive: true }); + } + + function addTyping() { + removeTyping(); + const ph = document.createElement('div'); + ph.className = 'msg other'; + ph.innerHTML = '
'; + $('chat-view').appendChild(ph); + state.typingEl = ph; + scrollBottom(); + } + function removeTyping() { + if (state.typingEl) { state.typingEl.remove(); state.typingEl = null; } + } + diff --git a/app/server/public/js/core.js b/app/server/public/js/core.js new file mode 100644 index 0000000..90aba20 --- /dev/null +++ b/app/server/public/js/core.js @@ -0,0 +1,228 @@ + /* + * ============================================================================ + * Agent 任务台 v2 —— 接入真实后端(全部沿用 /api 现有接口,未新增任何接口) + * ---------------------------------------------------------------------------- + * 已接入: + * GET /api/sessions?status=active&limit=100 抽屉「今天/昨天」活跃列表 + * GET /api/sessions?status=done&limit=50&with_total=1 抽屉归档列表 + * GET /api/sessions?q=..&limit=50 抽屉搜索 + * POST /api/sessions {title:'', model_id:''} 首条消息自动建档 + * GET /api/sessions/:id 打开会话(消息+文件) + * POST /api/sessions/:id/messages {content, attachments} 发送消息 + * POST /api/sessions/:id/files 附件上传(multipart) + * GET /api/sessions/:id/stream SSE 流式输出 + * POST /api/sessions/:id/stop | /release 状态栏「终止/断开」 + * POST /api/sessions/:id/bind {model_id} 状态栏「选择模型」(已完成/已终止会话) + * DELETE /api/sessions/:id/messages 状态栏「清空」(会话内删除已移除,清空由这里承担) + * DELETE /api/sessions/:id/messages/:messageId 删除单条消息/工具卡(删 assistant 连带工具回执;单删工具卡同步摘除父调用) + * GET /api/models 状态栏「选择模型」弹窗模型列表 + * + * 设置区(侧边栏用户区整行点击进入;页面搬自 index.html,未新增任何接口): + * GET /api/system/status | POST /api/system/restart[?force=true] 服务·状态与重启 + * GET/PUT/PATCH /api/config | POST /api/config/validate 系统配置 / 原文编辑 / 模型增删改 + * GET /api/models | GET /api/platforms/balance 模型·模型池与余额 + * GET/POST/PUT/DELETE /api/skills[/:name][/file|/upload|/rename] 技能·技能与文件管理 + * GET /api/me | POST /api/password | GET /logout 账户·信息/改密/退出 + * + * 后端已有但 v2 尚未接入 UI 的接口(先列出,不实现): + * PATCH /api/sessions/:id 重命名(后端已支持) + * GET /api/sessions/:id/files/download-token?path= 文件下载(配合文件面板) + * + * 无后端支撑、仅前端占位的概念(先不实现): + * · 「文秘助理 / 识图专家」模式 —— 后端无 mode 字段,当前仅影响提示文案 + * · 「思考过程」折叠块(已思考 N 秒) —— 后端不产出 reasoning,已移除 mock + * 鉴权:任意请求 401 时跳转 /login(与 core.js 的 req 一致)。 + * ============================================================================ + */ + 'use strict'; + + // ---------- 工具 ---------- + function $(id) { return document.getElementById(id); } + function esc(s) { const d = document.createElement('div'); d.textContent = s == null ? '' : String(s); return d.innerHTML; } + // ---------- markdown 渲染(同步 index:本地 vendor/marked.min.js;缺失/异常时回退转义纯文本) ---------- + // 返回 { html, fmt }:fmt=false 表示未做转换,气泡不带 .md 类、保持 pre-wrap 原文排版 + if (typeof marked !== 'undefined') marked.setOptions({ breaks: true, gfm: true }); + function mdHtml(text) { + if (typeof marked === 'undefined') return { html: esc(text), fmt: false }; + try { return { html: marked.parse(text || ''), fmt: true }; } + catch (_) { return { html: esc(text), fmt: false }; } + } + function fmtTime(ts) { + if (!ts) return ''; + const d = new Date(ts); + const p = n => String(n).padStart(2, '0'); + const now = new Date(); + const hm = p(d.getHours()) + ':' + p(d.getMinutes()); + if (now.toDateString() === d.toDateString()) return hm; + const md = (d.getMonth() + 1) + '/' + d.getDate(); + return (d.getFullYear() === now.getFullYear() ? md : d.getFullYear() + '/' + md) + ' ' + hm; + } + function toast(msg) { + const el = $('toast'); + el.textContent = msg; + el.classList.remove('hidden'); + clearTimeout(toast._t); + toast._t = setTimeout(() => el.classList.add('hidden'), 2000); + } + async function copyText(text) { + try { + if (navigator.clipboard && window.isSecureContext) { await navigator.clipboard.writeText(text); return true; } + } catch (_) { /* 落入降级 */ } + try { + const ta = document.createElement('textarea'); + ta.value = text; + ta.setAttribute('readonly', ''); + ta.style.position = 'fixed'; ta.style.top = '0'; ta.style.left = '-9999px'; ta.style.opacity = '0'; + document.body.appendChild(ta); + ta.select(); + ta.setSelectionRange(0, ta.value.length); + const ok = document.execCommand('copy'); + document.body.removeChild(ta); + return ok; + } catch (_) { return false; } + } + + // ---------- API(与 core.js 的 req 保持一致) ---------- + // 默认单次请求超时:机器休眠几小时后链路中间的 keep-alive 连接被静默拆线(无 FIN/RST), + // 回页面后首个 POST 会写进黑洞 socket 永远 Pending(线上已实测 /messages 挂起)。 + // 超时让黑洞变快失败,再补一次重试(重试必新建连接)。 + const FETCH_TIMEOUT_MS = 15000; + function fetchOnce(url, opt, timeoutMs) { + if (!timeoutMs) return fetch(url, opt); + const ctrl = new AbortController(); + const timer = setTimeout(() => { try { ctrl.abort(); } catch (_) {} }, timeoutMs); + const p = fetch(url, Object.assign({}, opt, { signal: ctrl.signal })); + return p.finally(() => clearTimeout(timer)); + } + // 只识别“请求铁定/极可能没进服务器”的网络层错误:TypeError=连接失败/重置,AbortError=本函数超时。 + // HTTP 4xx/5xx 不在此列(已拿到响应,不重试)。 + function isNetworkErr(e) { return !!e && (e.name === 'AbortError' || e instanceof TypeError); } + + async function req(method, url, body, isForm, timeoutMs) { + const opt = { method, headers: {} }; + // 浏览器身份只认 HttpOnly cookie:服务端所有路由(含 /api/me、SSE)统一按 cookie 认定用户。 + // 不要在此附加 sessionStorage 里的 Basic 头——sessionStorage 按标签页隔离、刷新后残留, + // 而 cookie 是浏览器全局的;两者并用会在多用户切号后出现 /api/me 是 A、列表数据是 B 的分裂。 + if (body && !isForm) { + opt.headers['Content-Type'] = 'application/json'; + opt.body = JSON.stringify(body); + } else if (body && isForm) { + opt.body = body; + } + const tmo = timeoutMs == null ? FETCH_TIMEOUT_MS : timeoutMs; + let res; + try { + try { + res = await fetchOnce(url, opt, tmo); + } catch (e) { + if (!isNetworkErr(e)) throw e; + // 黑洞/残破连接典型特征:第一次碰死、重连即活——只补发这一次 + await new Promise(r => setTimeout(r, 300)); + res = await fetchOnce(url, opt, tmo); + } + } catch (e) { + if (isNetworkErr(e)) { + const err = new Error('网络不可用或请求超时'); + err.network = true; + throw err; + } + throw e; + } + if (res.status === 401) { location.href = '/login'; throw new Error('未登录'); } + if (!res.ok) { + let msg = 'HTTP ' + res.status; + try { msg = (await res.json()).error || msg; } catch (_) {} + const err = new Error(msg); + err.status = res.status; + throw err; + } + return res.json(); + } + + // ---------- 模式配置(新增助手类型时只需在这里加一项,welcome 卡片与顶部 icon 会自动跟随) ---------- + const MODES = { + secretary: { + label: '文秘助理', hint: '支持文字输入,可起草、润色、整理文书', + icon: '', + }, + vision: { + label: '识图专家', hint: '支持图片识别输入', + icon: '', + }, + }; + + // ---------- 全局状态 ---------- + const state = { + view: 'welcome', // welcome | chat + mode: 'secretary', // 模式选择区当前选中(仅 welcome 视图可操作) + sessionType: 'secretary', // 当前会话的助手类型(建档时锁定,后续不随模式切换变更) + deepThink: false, // 深度思考开关(仅本地视觉状态,无后端参数) + sessionId: null, // 当前会话 + sessionTitle: '', // 当前会话标题 + status: '', // 当前会话状态(SSE 更新) + schedule: null, // 当前会话定时任务(详情 schedule 字段,null=无) + sessions: [], // 抽屉列表缓存 + attachments: [], // 待发送附件 {file, name, size} + lastImgBlobUrl: null, // 任务文件图片预览的 blob URL,下次预览或开新图时回收 + lastPdfBlobUrl: null, // 同上:PDF 页内预览的 blob URL(浏览器内建查看器用) + es: null, // EventSource + lastSseAt: 0, // 最近一次收到 SSE 心跳时刻(看门狗静默判死用) + streamText: '', // 当前流式累积文本 + streamEl: null, // 当前流式 AI 气泡 + streamWrap: null, // 当前流式消息容器(.msg.other);思考面板与气泡都挂它上面 + streamReasoning: '', // 当前流式累积思考文本 + streamThinkEl: null, // 当前流式思考面板的 body 节点(未出现思考时为 null) + toolCards: {}, // tool_call_id -> 工具卡片元素(同步 index 工具卡样式) + toolCallStreaming: {}, // tool_call_id -> {name, args}:参数流式生成中的累积态(早建卡卡面实时填充) + toolCallMsgIds: {}, // tool_call_id -> tool 消息行 id(历史懒加载映射,renderDetail 重建) + typingEl: null, // 「思考中」占位 + streaming: false, + pendingSummary: false, // 是否在等待「压缩」总结 AI 回复(避免重复弹窗;同时用于按钮 disabled 防重入) + lastAssistantMsgId: null, // 最近处理过的 SSE assistant_message id:重复 id 直接丢,防重渲染(补「2 遍」问题) + chatHasMore: false, // 当前会话是否还有更早的历史未加载(消息懒加载分页) + chatOldestId: null, // 已加载最早一条消息的行 id(拉更早页的 before 游标) + chatLoadedCount: 0, // 已加载消息条数(重拉详情时按同量分页,避免退回全量渲染) + }; + + // ---------- 视图切换 ---------- + function setView(view) { + state.view = view; + $('welcome-view').classList.toggle('hidden', view !== 'welcome'); + $('chat-view').classList.toggle('hidden', view !== 'chat'); + $('new-chat-btn').classList.toggle('hidden', view !== 'chat'); // 新建按钮仅对话状态显示 + renderHeader(); + updatePhaseBar(); // 状态栏仅对话视图显示 + updateScrollBottomBtn(); + } + + function renderHeader() { + const c = $('header-center'); + if (state.view !== 'chat' || !state.sessionId) { c.innerHTML = ''; return; } + // 顶部 icon 跟随会话自身的助手类型(而非 welcome 当前选中项) + const modeIcon = (MODES[state.sessionType] && MODES[state.sessionType].icon) || ''; + const title = document.createElement('div'); + title.className = 'header-title'; + title.style.cursor = 'pointer'; + title.title = '点击重命名'; + title.innerHTML = modeIcon + + '' + esc(state.sessionTitle || state.sessionId) + ''; + title.addEventListener('click', renameSession); // 点标题重命名(同步 index) + c.innerHTML = ''; + c.appendChild(title); + } + + // ---------- 模式切换区 ---------- + function selectMode(mode) { + state.mode = mode; + for (const chip of document.querySelectorAll('.mode-chip')) { + const on = chip.dataset.mode === mode; + chip.classList.toggle('on', on); + chip.setAttribute('aria-selected', on ? 'true' : 'false'); + } + $('mode-hint').textContent = MODES[mode].hint; + } + $('mode-switch').addEventListener('click', e => { + const chip = e.target.closest('.mode-chip'); + if (chip) selectMode(chip.dataset.mode); + }); + diff --git a/app/server/public/js/files.js b/app/server/public/js/files.js new file mode 100644 index 0000000..8a8d704 --- /dev/null +++ b/app/server/public/js/files.js @@ -0,0 +1,1060 @@ +// 输入区 / 任务文件面板 / 上传 / 抽屉与滑动手势(拆自 index.html 内联脚本,纯搬运不改逻辑) +'use strict'; + // ---------- 输入区 ---------- + const ta = $('msg-input'); + function autosize() { ta.style.height = 'auto'; ta.style.height = Math.min(ta.scrollHeight, 120) + 'px'; } + ta.addEventListener('input', autosize); + // 触屏设备(手机/平板)上:Enter 走默认行为(插入 \n),发消息靠发送按钮, + // 避免软键盘的回车键直接被吞走导致连换行都打不出来。桌面/笔记本继续走 Enter=发送。 + // 用 (hover:none)&&(pointer:coarse) 判定「以触摸为主」的设备,标准且不依赖 UA 字符串。 + const isTouchPrimary = window.matchMedia('(hover: none) and (pointer: coarse)').matches; + ta.addEventListener('keydown', e => { + // 输入法组合中(包括拼音输入法「确认英文上屏」那次 Enter)不拦截, + // 让 IME 自行处理。e.isComposing 是标准信号;旧版 Chrome 等环境下 + // keyCode 恒为 229,作为兜底。 + if (e.isComposing || e.keyCode === 229) return; + if (e.key !== 'Enter') return; + // 触屏:Enter 走默认(换行),不拦截、不发送。 + if (isTouchPrimary) return; + // 桌面:Ctrl/⌘/Shift+Enter 在光标处换行;普通 Enter 发送 + if (e.ctrlKey || e.metaKey || e.shiftKey) { + e.preventDefault(); + if (!document.execCommand('insertText', false, '\n')) { + const i = ta.selectionStart; + ta.setRangeText('\n', i, ta.selectionEnd, 'end'); + } + autosize(); + } else { + e.preventDefault(); + send(); + } + }); + $('send-btn').addEventListener('click', () => send()); // 发送按钮与 Enter 行为一致 + + // 深度思考开关:每次发消息随 body 传给后端,后端会合并该模型的 thinking_params + $('deep-think-btn').addEventListener('click', () => { + state.deepThink = !state.deepThink; + $('deep-think-btn').classList.toggle('on', state.deepThink); + toast(state.deepThink ? '深度思考已开启' : '深度思考已关闭'); + }); + + // ---------- 任务文件面板(底部浮层:点输入行右侧文件夹按钮展开,遮罩盖住输入区) ---------- + function setFilesPanel(open) { + const panel = $('files-panel'); + if (open) { + filesCurDir = ''; // 每次弹出回到根目录 + applyFilesPanelH(); // 沿用上次拖拽高度(会话内),无则用 CSS 默认 + loadFiles(); + // 弹出面板时收起软键盘,避免顶起布局 + if (document.activeElement && document.activeElement.blur) document.activeElement.blur(); + } + panel.classList.toggle('open', open); + $('files-mask').classList.toggle('show', open); + $('files-btn').classList.toggle('active', open); + } + let ensuringSessionForFiles = false; // 防止建会话请求发出前重复点击按钮导致连建两个会话 + async function toggleFilesPanel() { + const panel = $('files-panel'); + const open = !panel.classList.contains('open'); + if (open && !state.sessionId) { + // 新建会话页直接管理文件:自动建档会话再弹面板;建会话失败(如无可用模型)给出提示 + if (ensuringSessionForFiles) return; + ensuringSessionForFiles = true; + try { + await ensureSession(); + } catch (e) { + toast('创建会话失败:' + e.message); + return; + } finally { + ensuringSessionForFiles = false; + } + } + setFilesPanel(open); + } + $('files-btn').addEventListener('click', toggleFilesPanel); + // 附件(回形针)按钮:直接唤起文件选择写入当前会话任务目录;无会话时先建会话再弹选择器, + // 避免选完文件后因无会话被丢弃(与面板同策略)。 + let ensuringSessionForUpload = false; + $('attach-btn').addEventListener('click', async () => { + if (!state.sessionId) { + if (ensuringSessionForUpload) return; + ensuringSessionForUpload = true; + try { + await ensureSession(); + } catch (e) { + toast('创建会话失败:' + e.message); + return; + } finally { + ensuringSessionForUpload = false; + } + } + $('file-input').click(); + }); + $('files-mask').addEventListener('click', () => setFilesPanel(false)); // 点遮罩收起 + + // ---------- 面板拖拽调高(底部抽屉):拽顶部手柄上拉放大、下拉缩高,拉到最低后继续下拉→整块下滑收起 ---------- + // CSS 默认高 46%(min 240px / max 85% 视口);拖拽结果记入 filesPanelH 会话内沿用,重新打开即恢复。 + const FP_MIN_H = 240, FP_MAX_RATIO = 0.85, FP_CLOSE_PULL = 90; + let filesPanelH = 0; // 0 = 跟随 CSS 默认高度 + function filesPanelMaxH() { return Math.round(window.innerHeight * FP_MAX_RATIO); } + function applyFilesPanelH() { + const panel = $('files-panel'); + if (filesPanelH) { + filesPanelH = Math.min(Math.max(filesPanelH, FP_MIN_H), filesPanelMaxH()); + panel.style.height = filesPanelH + 'px'; + } else { + panel.style.height = ''; // 回 CSS 默认,切目录高度始终稳定 + } + } + (function bindFilesPanelDrag() { + const panel = $('files-panel'); + const handle = $('files-drag-handle'); + let drag = null; // {startY, startH} + function endDrag(close) { + if (!drag) return; + drag = null; + panel.style.transition = ''; // 恢复开合动画 + panel.style.transform = ''; + if (close) { filesPanelH = 0; panel.style.height = ''; setFilesPanel(false); } + } + handle.addEventListener('pointerdown', e => { + drag = { startY: e.clientY, startH: panel.offsetHeight }; + try { handle.setPointerCapture(e.pointerId); } catch (_) {} + panel.style.transition = 'none'; // 拖拽期间不走 transform 动画,不跟手 + e.preventDefault(); + }); + handle.addEventListener('pointermove', e => { + if (!drag) return; + const raw = drag.startH + (drag.startY - e.clientY); // 上拉为正 → 变高 + const h = Math.min(Math.max(raw, FP_MIN_H), filesPanelMaxH()); + filesPanelH = h; + panel.style.height = h + 'px'; + const over = Math.max(0, FP_MIN_H - raw); // 拉过 minHeight → 整块向下跟随,预告即收起 + panel.style.transform = over ? 'translateY(' + over + 'px)' : ''; + if (over > FP_CLOSE_PULL) endDrag(true); + }); + handle.addEventListener('pointerup', () => endDrag(false)); + handle.addEventListener('pointercancel', () => endDrag(false)); + // 转屏/窗口变化时按新视口重新限制到 min/max 区间 + window.addEventListener('resize', () => { + if (panel.classList.contains('open')) applyFilesPanelH(); + }); + })(); + + // 任务文件面板多选状态:Set 保留当前选中的文件路径;filesAllPaths 保留当前面板所有路径。 + // 文件夹作为整体选中项存储(键加 d: 前缀),下载时由后端打包成 zip。 + const DIR_SEL_PREFIX = 'd:'; + const fileSelected = new Set(); + let filesAllPaths = []; + let filesTreeRoot = null; // 最近一次拉取构建的目录树(单层列表渲染与全选/有效性计算都基于它) + let filesDirSizes = new Map(); // 目录路径('' = 根) → 其下文件递归总字节;按未过滤原始列表聚合(含隐藏的 .tmp) + let filesCurDir = ''; // 当前浏览目录(相对任务根;'' = 根)。面包屑 + 单层列表的游标 + + const dirSelKey = p => DIR_SEL_PREFIX + p; + const isDirSelKey = k => k.startsWith(DIR_SEL_PREFIX); + const selDirPath = k => k.slice(DIR_SEL_PREFIX.length); + // 文件是否被整体勾选的祖先目录覆盖 + function isPathInDirSel(p) { + for (const k of fileSelected) { + if (isDirSelKey(k) && p.startsWith(selDirPath(k) + '/')) return true; + } + return false; + } + // 文件是否被选中:自身被勾,或其某个祖先目录被整体勾选 + function isFileEffectivelySelected(p) { + return fileSelected.has(p) || isPathInDirSel(p); + } + // 目录节点内所有文件的相对路径(递归) + function filesUnderDir(node) { + let out = node.files.map(f => f.filename); + for (const d of node.dirs.values()) out = out.concat(filesUnderDir(d)); + return out; + } + // 树中全部目录节点(父在前),附各自包含的文件列表 + function collectDirNodes(node, out) { + out = out || []; + node = node || filesTreeRoot; + if (!node) return out; + for (const d of node.dirs.values()) { + out.push({ path: d.path, files: filesUnderDir(d) }); + collectDirNodes(d, out); + } + return out; + } + // 把选中集归一化为执行列表 [{path, isDir}]: + // 1) 去掉已被整体勾选目录覆盖的单项文件; + // 2) 目录内文件全部选中时折叠为目录项(父目录优先,避免重复打包)。 + function effectiveSelection() { + const dirs = []; const files = []; + for (const k of fileSelected) { + if (isDirSelKey(k)) dirs.push(selDirPath(k)); else files.push(k); + } + const covered = p => dirs.some(d => p.startsWith(d + '/')); + const kept = files.filter(p => !covered(p)); + for (const dn of collectDirNodes()) { // 父在前 + if (dirs.includes(dn.path)) continue; + if (dirs.some(d => dn.path.startsWith(d + '/'))) continue; // 祖先已选 + if (dn.files.length && dn.files.every(p => fileSelected.has(p) || covered(p))) { + for (let i = dirs.length - 1; i >= 0; i--) if (dirs[i].startsWith(dn.path + '/')) dirs.splice(i, 1); + dirs.push(dn.path); + for (let i = kept.length - 1; i >= 0; i--) if (kept[i].startsWith(dn.path + '/')) kept.splice(i, 1); + } + } + return dirs.map(path => ({ path, isDir: true })).concat(kept.map(path => ({ path, isDir: false }))); + } + + // 重算面板内(或指定范围内)文件行/目录行勾选框的视觉状态:统一按选中集推导, + // 避免各处手写 DOM 同步漏掉嵌套目录。目录勾选态 = 显式整选,或内部文件全部被覆盖。 + function refreshFileSelStates(scope) { + scope = scope || $('files-list'); + scope.querySelectorAll('.file-row').forEach(r => { + const p = r.dataset.path; + const sel = !!p && isFileEffectivelySelected(p); + r.classList.toggle('selected', sel); + const ck = r.querySelector('.file-check'); + if (ck) ck.setAttribute('aria-checked', sel ? 'true' : 'false'); + }); + scope.querySelectorAll('.file-dir-head').forEach(h => { + const dp = h.dataset.dir; + const ck = h.querySelector(':scope > .file-check'); + if (!dp || !ck) return; + const node = filesNodeAt(dp); + const under = node ? filesUnderDir(node) : []; + const sel = fileSelected.has(dirSelKey(dp)) || + (under.length > 0 && under.every(isFileEffectivelySelected)); + h.classList.toggle('selected', sel); + ck.setAttribute('aria-checked', sel ? 'true' : 'false'); + }); + } + + function updateFilesFooter() { + const n = fileSelected.size; + const total = filesAllPaths.length; + const effCount = effectiveSelection().length; + const countEl = $('files-count'); + const dlBtn = $('files-bulk-download'); + const delBtn = $('files-bulk-delete'); + const togBtn = $('files-toggle-all'); + if (countEl) countEl.textContent = effCount ? '已选择 ' + effCount + ' 项' : '未选择文件'; + if (dlBtn) dlBtn.disabled = n === 0; + if (delBtn) delBtn.disabled = n === 0; + // 全选按钮:没有文件时禁用;全部选中=打勾态;部分选中=减号态;都未选=加号态 + if (togBtn) { + // span 没有 disabled 属性,用 aria-disabled + tabindex 控制交互能力 + const disabled = total === 0; + togBtn.setAttribute('aria-disabled', disabled ? 'true' : 'false'); + togBtn.tabIndex = disabled ? -1 : 0; + let state = 'none'; + if (total > 0 && filesAllPaths.every(isFileEffectivelySelected)) state = 'all'; + else if (n > 0) state = 'some'; + togBtn.dataset.state = state; + togBtn.setAttribute('aria-checked', state === 'all' ? 'true' : (n > 0 ? 'mixed' : 'false')); + togBtn.title = state === 'all' ? '取消全选' : '全选'; + togBtn.setAttribute('aria-label', state === 'all' ? '取消全选' : '全选'); + } + } + + // 全选 / 取消全选:依据当前状态决定。全部选中 → 取消;否则 → 选中全部 + function toggleSelectAll() { + const total = filesAllPaths.length; + if (total === 0) return; + const togBtn = $('files-toggle-all'); + if (togBtn && togBtn.getAttribute('aria-disabled') === 'true') return; + if (filesAllPaths.every(p => fileSelected.has(p))) { + fileSelected.clear(); + } else { + for (const p of filesAllPaths) fileSelected.add(p); + } + // 同步文件行与目录头勾选框的视觉状态 + refreshFileSelStates(); + updateFilesFooter(); + } + + // ---------- 目录浏览:后端返回扁平列表(路径可含子目录),前端组树后按「面包屑 + 单层列表」展示 ---------- + // 规则:主体只渲染当前目录的直接子项,目录在上、文件在下;同级目录按名称排序,同级文件按时间倒序(新的在前)。 + // filesCurDir 为当前浏览目录('' = 任务根);顶部面包屑(/ > a > b)点任意节点回跳,点目录行进一层;无折叠态。 + + function fileTimeOf(f) { return f.mtime || f.ctime || 0; } + function sortFilesByTime(arr) { + arr.sort(function (a, b) { + const d = fileTimeOf(b) - fileTimeOf(a); // 时间缺失的排最后,与原逻辑一致 + if (d) return d; + return a.filename < b.filename ? -1 : a.filename > b.filename ? 1 : 0; + }); + return arr; + } + function sortDirsByName(arr) { + arr.sort(function (a, b) { return a.name < b.name ? -1 : a.name > b.name ? 1 : 0; }); + return arr; + } + + // 扁平文件列表 → 树节点 { name, path, dirs: Map, files: [] } + // 目录标记行(?dirs=1:filename 以 '/' 结尾 + dir:true)只沿途铺设路径节点、不入任何 files[], + // 不含文件的空夹子因此也能渲染;与同名文件路径铺出的节点经 dirs Map 天然去重。 + function buildFilesTree(files) { + const root = { name: '', path: '', dirs: new Map(), files: [] }; + for (const f of files) { + const isDir = f.dir === true || /\/$/.test(String(f.filename)); + const name = isDir ? String(f.filename).replace(/\/+$/, '') : String(f.filename); + if (!name) continue; + const segs = name.split('/'); + let node = root, rel = ''; + const dirDepth = isDir ? segs.length : segs.length - 1; // 文件:末段是文件名;目录:全是路径段 + for (let i = 0; i < dirDepth; i++) { + const seg = segs[i]; + rel = rel ? rel + '/' + seg : seg; + if (!node.dirs.has(seg)) node.dirs.set(seg, { name: seg, path: rel, dirs: new Map(), files: [] }); + node = node.dirs.get(seg); + } + if (!isDir) node.files.push(f); + } + return root; + } + + // 目录(含子目录)内文件总数,用于目录头计数 + function countDirFiles(node) { + let n = node.files.length; + for (const d of node.dirs.values()) n += countDirFiles(d); + return n; + } + + function fileRowHtml(f) { + // 预览策略:md/txt/html/pdf + 图片在 fs-viewer 预览(pdf 按 pdfViewerEnabled 页内/下载分流) + const low = f.filename.toLowerCase(); + const fsPv = /\.(md|txt|html?|pdf|png|jpe?g|gif|webp|svg)$/.test(low); + const ico = fsPv + ? '' + : ''; + const name = esc(String(f.filename).split('/').pop() || f.filename); + const ftime = fmtTime(f.mtime || f.ctime); + const sel = isFileEffectivelySelected(f.filename); + return '
' + + '' + + '
' + + '
' + name + '
' + + '
' + ico + '' + fmtSize(f.size) + '' + + (ftime ? '' + ftime + '' : '') + '
' + + '
' + + '
'; + } + + // 目录行(带勾选框):整个文件夹作为一个选中项(下载时后端打包成 zip); + // 点行其余区域进入该目录(单层列表,不再有折叠/展开)。 + function dirRowHtml(node) { + const under = filesUnderDir(node); + const checked = fileSelected.has(dirSelKey(node.path)) || + (under.length > 0 && under.every(isFileEffectivelySelected)); + return '
' + + '' + + '' + + '' + esc(node.name) + '' + + '' + countDirFiles(node) + ' 个文件' + + '' + + '
'; + } + + // 按相对路径取树节点('' = 根);路径不存在(如删除后重拉)返回 null + function filesNodeAt(path) { + let node = filesTreeRoot; + if (!node) return null; + if (!path) return node; + for (const seg of String(path).split('/')) { + node = node.dirs.get(seg); + if (!node) return null; + } + return node; + } + + // 渲染当前目录:顶部面包屑(根目录(home) › a › b,点任意节点回跳)+ 单层列表(目录在前、文件在后)。 + // 面包屑常显:根目录时只亮「根目录」当前层;进入子目录后逐级铺开。 + function renderFilesDir() { + const el = $('files-list'); + const crumbEl = $('files-crumbs'); + let node = filesNodeAt(filesCurDir); + if (!node) { filesCurDir = ''; node = filesNodeAt(''); } // 当前目录已被删除 → 退回根 + const sizeEl = $('files-panel-size'); + if (!node) { el.innerHTML = ''; if (sizeEl) sizeEl.textContent = ''; return; } + // 标题旁总大小:按未过滤的聚合表取当前目录递归总量(.tmp 隐藏但计数) + if (sizeEl) { + const total = filesDirSizes.get(filesCurDir) || 0; + sizeEl.textContent = total > 0 ? fmtSize(total) : ''; + } + // 根节点:home 图标 + 「根目录」,比一个孤悬的「/」醒目得多;在根时它是当前层,纯文本不可点 + const homeIc = ''; + let html = filesCurDir + ? '' + homeIc + '根目录' + : '' + homeIc + '根目录'; + if (filesCurDir) { + let acc = ''; + const segs = filesCurDir.split('/'); + segs.forEach(function (seg, i) { + acc = acc ? acc + '/' + seg : seg; + html += '›'; + html += (i === segs.length - 1) + ? '' + esc(seg) + '' // 当前层纯文本不可点 + : '' + esc(seg) + ''; + }); + } + crumbEl.innerHTML = html; + crumbEl.classList.remove('hidden'); + const dirs = sortDirsByName(Array.from(node.dirs.values())); + sortFilesByTime(node.files); + if (!dirs.length && !node.files.length) { + el.innerHTML = '
' + (filesCurDir ? '该文件夹为空' : '还没有文件,在对话框上传或让 AI 生成') + '
'; + return; + } + el.innerHTML = dirs.map(dirRowHtml).join('') + node.files.map(fileRowHtml).join(''); + } + + async function loadFiles() { + if (!state.sessionId) return; + // 重新拉取前清空旧选择,避免脏数据遗留 + fileSelected.clear(); + filesAllPaths = []; + filesTreeRoot = null; + updateFilesFooter(); + try { + const files = await req('GET', '/api/sessions/' + state.sessionId + '/files?dirs=1'); + // 会话级 .tmp(executor 的共享 /tmp 落盘处)不属于任务产物:列表/选中/下载里隐藏,但计入总大小 + const shown = files.filter(f => !/^\.tmp(\/|$)/.test(String(f.filename))); + // 目录标记行不参与选中/全选/计数,只用来铺树(空文件夹可见) + filesAllPaths = shown.filter(f => !(f.dir === true || /\/$/.test(String(f.filename)))).map(f => f.filename); + // 重建目录树后只渲染当前目录这一层(后端已按时间倒序,组内再排一次防旧排序缓存) + filesTreeRoot = buildFilesTree(shown); + // 总大小按原始列表(含 .tmp)聚合:目录标记行无字节量跳过;文件把 size 记到每一级祖先目录(根 = '') + filesDirSizes = new Map([['', 0]]); + for (const f of files) { + if (f.dir === true || /\/$/.test(String(f.filename))) continue; + const sz = Number(f.size) || 0; + if (!sz) continue; + filesDirSizes.set('', (filesDirSizes.get('') || 0) + sz); + const segs = String(f.filename).split('/'); + segs.pop(); // 末段是文件名,其余是祖先目录 + let acc = ''; + for (const seg of segs) { + acc = acc ? acc + '/' + seg : seg; + filesDirSizes.set(acc, (filesDirSizes.get(acc) || 0) + sz); + } + } + renderFilesDir(); // filesCurDir 失效时自动退回根目录 + // 重新渲染后刷新底部计数与按钮状态 + updateFilesFooter(); + } catch (e) { toast('读取文件失败:' + e.message); } + } + // 把渲染好的 Markdown HTML 里的相对图片路径,重写成可访问的任务文件下载地址: + // 预览在浏览器里以应用页面为基准解析相对 src,而图片其实在任务目录里,直接写相对路径会 404。 + // 相对路径一律按 md 文件所在目录为基准解析到任务目录下的路径,再拼下载接口。 + function rewriteMdImageSrcs(html, mdPath) { + const host = document.createElement('div'); + host.innerHTML = html; + // md 所在目录(任务根下无子目录时为 '',否则如 'docs') + const baseSegs = mdPath.includes('/') ? mdPath.split('/').slice(0, -1) : []; + const resolve = function (p) { + if (/^(https?:)?\/\//i.test(p) || p.startsWith('data:') || p.startsWith('blob:')) return null; // 已是外链/内联 + const segs = p.startsWith('/') ? [] : baseSegs.slice(); // 以 / 开头视为任务根下 + for (const part of p.split('/')) { + if (!part || part === '.') continue; + if (part === '..') { if (segs.length) segs.pop(); continue; } + segs.push(part); + } + return segs.join('/'); + }; + host.querySelectorAll('img').forEach(function (im) { + const src = im.getAttribute('src'); + if (!src) return; + const rel = resolve(src); + if (rel === null || rel === '') return; + im.setAttribute('src', '/api/sessions/' + state.sessionId + '/files/download?path=' + encodeURIComponent(rel)); + }); + return host.innerHTML; + } + // 单击可预览文件 → 全屏预览(#fs-viewer):md 按 markdown 渲染、txt 原文排版、html 用沙箱 iframe、pdf 按 pdfViewerEnabled 页内/下载分流、图片用 + async function previewInFs(name) { + try { + const r = await fetch('/api/sessions/' + state.sessionId + '/files/download?path=' + encodeURIComponent(name)); + if (r.status === 401) { location.href = '/login'; return; } + if (!r.ok) { let msg = 'HTTP ' + r.status; try { msg = (await r.json()).error || msg; } catch (_) {} throw new Error(msg); } + if (/\.html?$/i.test(name)) { + const html = await r.text(); + const body = $('fs-body'); + body.innerHTML = ''; + const iframe = document.createElement('iframe'); + iframe.className = 'fs-html-frame'; + iframe.setAttribute('sandbox', 'allow-same-origin allow-scripts'); + iframe.srcdoc = html; + body.appendChild(iframe); + setFsSource(html); // 源码钮可看页面原码 + $('fs-viewer').classList.remove('hidden'); + } else if (/\.pdf$/i.test(name)) { + // H5 方案 A:navigator.pdfViewerEnabled 是专为「能否内嵌渲染 PDF」设计的检测位 + // (桌面各浏览器/iOS Safari = true;Android Chrome/微信 webview = false) + if (navigator.pdfViewerEnabled) { + const blob = await r.blob(); // 响应 Content-Type 即 application/pdf + const url = URL.createObjectURL(blob); + if (state.lastPdfBlobUrl) { try { URL.revokeObjectURL(state.lastPdfBlobUrl); } catch (_) {} } + state.lastPdfBlobUrl = url; + const body = $('fs-body'); + body.innerHTML = ''; + body.style.zoom = ''; + const frame = document.createElement('iframe'); + frame.className = 'fs-html-frame'; + frame.title = name; // 不加 sandbox:内建查看器插件需要 unrestricted 帧 + frame.src = url; + body.appendChild(frame); + setFsSource(null); // 二进制无源码可看,隐藏 eye 钮 + $('fs-viewer').classList.remove('hidden'); + } else { + // 不支持页内嵌的浏览器:交给既有签名直链下载链路(Android 通知栏用系统查看器打开) + toast('当前浏览器不支持页内预览 PDF,已开始下载'); + downloadFile(name); + } + } else if (/\.(png|jpe?g|gif|webp|svg)$/i.test(name)) { + // 图片:复用会话里单击图片的全屏查看器(双指缩放+拖动+双击放大),大图也能看完 + const blob = await r.blob(); + const url = URL.createObjectURL(blob); + // 上一次的 blob URL 顺手释放;避免反复预览图片泄漏 + if (state.lastImgBlobUrl) { try { URL.revokeObjectURL(state.lastImgBlobUrl); } catch (_) {} } + state.lastImgBlobUrl = url; + openImageViewer(url, name); + } else { + // md/txt:复用双击气泡的全屏查看器 + const text = await r.text(); + let cls = 'bubble-ai', html; + if (/\.(md|markdown)$/i.test(name)) { + const r2 = mdHtml(text); + html = r2.html; + if (r2.fmt) { + cls += ' md'; + html = rewriteMdImageSrcs(html, name); + } + } else { + html = esc(text); + } + const wrap = document.createElement('div'); + wrap.className = 'msg other'; + wrap.innerHTML = '
' + html + '
'; + decorateCodePre(wrap); // 先装饰再克隆:按钮随 openFullscreen 的深拷贝进查看器,fs-viewer 已有 .act-copy 委托 + openFullscreen(wrap.firstChild, text); // 文件原文供 eye 钮看源码 + } + } catch (e) { toast('预览失败:' + e.message); } + } + async function downloadFile(name) { + if (!state.sessionId) return; + try { + const r = await req('GET', '/api/sessions/' + state.sessionId + '/files/download-token?path=' + encodeURIComponent(name)); + window.location.href = r.url; // 原生导航下载:同源自动带登录 cookie,文件名不乱 + } catch (e) { toast('下载失败:' + e.message); } + } + async function deleteFile(name) { + if (!await confirmModal('删除文件', '删除文件 ' + name + ' ?', '删除', true)) return; + try { + await req('DELETE', '/api/sessions/' + state.sessionId + '/files?path=' + encodeURIComponent(name)); + loadFiles(); + } catch (e) { toast('删除失败:' + e.message); } + } + // 列表事件委托(单层列表,目录不再有折叠/展开): + // 1) 目录行勾选框:整体选中/取消该文件夹(下载时后端打包成 zip);点行其余区域:进入该目录; + // 2) 点击文件行勾选框:仅选中状态,不触发预览/下载; + // 3) 一旦处于多选模式(Set 非空),整行点击仅切换选中状态,不再预览/下载; + // 4) 未进入多选模式时,点击文件名/图标根据 row.dataset.preview 决定预览或下载。 + $('files-list').addEventListener('click', e => { + // 目录行:勾选框切换整选,其余区域进入该目录 + const head = e.target.closest('.file-dir-head'); + if (head) { + const dp = head.dataset.dir; + if (!dp || !state.sessionId) return; + if (e.target.closest('.file-check')) { toggleDirSelect(dp); return; } + filesCurDir = dp; + renderFilesDir(); + return; + } + const row = e.target.closest('.file-row'); + if (!row || !state.sessionId) return; + const path = row.dataset.path; + if (!path) return; + const isCheck = !!e.target.closest('.file-check'); + // 多选模式下:任何点击(仅选框/文件名/其他)都只切换选中 + if (isCheck || fileSelected.size > 0) { + // 已被整体勾选文件夹覆盖的行:点选无效,选中与否由文件夹勾选框决定 + if (isPathInDirSel(path)) return; + if (fileSelected.has(path)) { fileSelected.delete(path); } + else { fileSelected.add(path); } + // 同步本行与所在目录链的勾选态(目录可能因内部全选/取消全选而变) + refreshFileSelStates(); + updateFilesFooter(); + return; + } + // 默认模式:依据是否可预览选择预览/下载 + if (row.dataset.preview === '1') previewInFs(path); + else downloadFile(path); + }); + + // 整体选中/取消一个文件夹:目录作为单条选中项(d: 前缀),行视觉态由 refreshFileSelStates 重算。 + // 整体勾选时取消内部单项/子目录勾选(已被覆盖,避免重复计入);取消勾选时子项恢复未选。 + function toggleDirSelect(dirPath) { + const key = dirSelKey(dirPath); + const on = !fileSelected.has(key); + if (on) { + fileSelected.add(key); + // 整体勾选后,内部单项文件/子目录勾选都被覆盖,直接移除避免重复计入 + const prefix = dirPath + '/'; + for (const k of Array.from(fileSelected)) { + if (k === key) continue; + const p = isDirSelKey(k) ? selDirPath(k) : k; + if (p.startsWith(prefix)) fileSelected.delete(k); + } + } else { + fileSelected.delete(key); + } + // 目录行/文件行勾选态统一按选中集重算 + refreshFileSelStates(); + updateFilesFooter(); + } + + // 面包屑点击:回跳到任意祖先层级(当前层节点无 data-path,不可点) + $('files-crumbs').addEventListener('click', e => { + const c = e.target.closest('.crumb[data-path]'); + if (!c) return; + filesCurDir = c.dataset.path; + renderFilesDir(); + }); + + // 批量下载:选中项含文件夹(含全选后整目录被覆盖的情况)时,整个选择交给后端打包成 + // 一个 zip 一次下载;纯文件选择保持逐文件直链下载。zip 同样走签名直链(与单文件同链路)。 + async function bulkZipDownload(paths) { + try { + const r = await req('GET', '/api/sessions/' + state.sessionId + '/files/zip-token?paths=' + encodeURIComponent(JSON.stringify(paths))); + if (!r || !r.url) throw new Error('未拿到打包链接'); + const a = document.createElement('a'); + a.href = r.url; + a.download = r.name || 'archive.zip'; + a.style.display = 'none'; + document.body.appendChild(a); + a.click(); + setTimeout(() => { try { a.remove(); } catch (_) {} }, 1000); + } catch (e) { toast('打包下载失败:' + e.message); } + } + // 批量下载:先把所有 download-token 拿完,再用服务器直链逐个触发下载。 + // 两个历史坑: + // 1) 边拿 token 边 location.href:首个下载导航会打断后续 fetch(第 2 个报失败); + // → 先批量拿完 token 再触发。 + // 2) fetch+blob 方案:手机浏览器不认 blob 文件名(变编号/.bin), + // 套壳 WebView 不处理 blob: 下载请求(点了没反应); + // → 回到服务器原始直链(文件名跟 Content-Disposition),与单文件下载同一条链路。 + async function bulkDownload() { + if (!state.sessionId || fileSelected.size === 0) return; + const eff = effectiveSelection(); + if (eff.some(x => x.isDir)) { bulkZipDownload(eff.map(x => x.path)); return; } + const names = eff.map(x => x.path); + // 第一阶段:全部 token 先拿到手(此时还没发生任何导航,fetch 不会被打断) + const items = []; + for (const name of names) { + try { + const r = await req('GET', '/api/sessions/' + state.sessionId + '/files/download-token?path=' + encodeURIComponent(name)); + if (!r || !r.url) throw new Error('未拿到下载链接'); + items.push({ url: r.url, name: String(name).split('/').pop() || name }); + } catch (e) { toast('下载失败:' + name + ' ' + e.message); } + } + // 第二阶段:隐藏 + 服务器直链逐个触发;download 属性作手机端文件名兜底, + // 小间隔避免移动端拦截连续多次下载 + for (const it of items) { + const a = document.createElement('a'); + a.href = it.url; + a.download = it.name; + a.style.display = 'none'; + document.body.appendChild(a); + a.click(); + setTimeout(() => { try { a.remove(); } catch (_) {} }, 1000); + await new Promise(res => setTimeout(res, 350)); + } + } + async function bulkDelete() { + if (!state.sessionId || fileSelected.size === 0) return; + const names = effectiveSelection().map(x => x.path); // 目录整体删除(后端 rm -r,含子项) + if (!await confirmModal('批量删除', '确认删除选中的 ' + names.length + ' 项(文件夹会连同内部文件一起删除)?', '删除', true)) return; + let ok = 0, fail = 0; + for (const name of names) { + try { + await req('DELETE', '/api/sessions/' + state.sessionId + '/files?path=' + encodeURIComponent(name)); + ok++; + } catch (e) { fail++; toast('删除失败:' + name + ' ' + e.message); } + } + if (ok) toast('已删除 ' + ok + ' 项'); + loadFiles(); // 重新拉取并重置选中 + } + $('files-bulk-download').addEventListener('click', bulkDownload); + $('files-bulk-delete').addEventListener('click', bulkDelete); + const togEl = $('files-toggle-all'); + togEl.addEventListener('click', toggleSelectAll); + togEl.addEventListener('keydown', e => { + if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); toggleSelectAll(); } + }); + // ---------- 大图上传前压缩(同步 v1:阈值/参数由 /api/system/status 透出) ---------- + const DEFAULT_UPLOAD_CFG = { image_compress_threshold_kb: 1536, image_max_dim: 2000, image_quality: 0.85 }; + let uploadCfgCache = null; + async function getUploadCfg() { + if (!uploadCfgCache) { + uploadCfgCache = Object.assign({}, DEFAULT_UPLOAD_CFG); + try { + const s = await req('GET', '/api/system/status'); + uploadCfgCache = Object.assign(uploadCfgCache, (s && s.upload) || {}); + } catch (_) { /* 取不到配置就用默认阈值 */ } + } + return uploadCfgCache; + } + function loadImageEl(file) { + return new Promise(function (resolve, reject) { + const fr = new FileReader(); + fr.onload = function () { + const im = new Image(); + im.onload = function () { resolve(im); }; + im.onerror = function () { reject(new Error('图片解码失败')); }; + im.src = fr.result; + }; + fr.onerror = function () { reject(new Error('读取文件失败')); }; + fr.readAsDataURL(file); + }); + } + // 返回待上传的 File:需要时询问并压缩;取消/失败/无收益都按原文件上传 + async function maybeCompressImage(file) { + const cfg = await getUploadCfg(); + const isImg = /^image\//.test(file.type || '') || /\.(png|jpe?g|gif|bmp|webp)$/i.test(file.name || ''); + const threshold = Number(cfg.image_compress_threshold_kb || 1536) * 1024; + if (!isImg || file.size <= threshold) return file; + const maxDim = Number(cfg.image_max_dim || 2000); + const quality = Number(cfg.image_quality || 0.85); + const ok = await confirmModal('图片文件过大', + '「' + file.name + '」有 ' + fmtSize(file.size) + ',超过 ' + fmtSize(threshold) + + '。建议在浏览器本地压缩为 JPEG(长边≤' + maxDim + 'px)后再上传。是否压缩?', '压缩后上传'); + if (!ok) return file; + try { + const img = await loadImageEl(file); + const iw = img.naturalWidth || img.width, ih = img.naturalHeight || img.height; + if (!iw || !ih) throw new Error('无法读取图片尺寸'); + const scale = Math.min(1, maxDim / Math.max(iw, ih)); + const w = Math.max(1, Math.round(iw * scale)), h = Math.max(1, Math.round(ih * scale)); + const canvas = document.createElement('canvas'); + canvas.width = w; canvas.height = h; + const ctx = canvas.getContext('2d'); + // 透明底(PNG)转 JPEG 前先铺白,避免变黑 + ctx.fillStyle = '#fff'; ctx.fillRect(0, 0, w, h); + ctx.drawImage(img, 0, 0, w, h); + const blob = await new Promise(function (res) { canvas.toBlob(function (b) { res(b); }, 'image/jpeg', quality); }); + if (!blob || blob.size >= file.size) { + toast('压缩无收益,已按原文件上传'); + return file; + } + const newName = String(file.name || 'image').replace(/\.[^.]+$/, '') + '.jpg'; + toast('已压缩 ' + fmtSize(file.size) + ' → ' + fmtSize(blob.size)); + return new File([blob], newName, { type: 'image/jpeg' }); + } catch (e) { + toast('压缩失败(' + (e && e.message || e) + '),按原文件上传'); + return file; + } + } + + // ---------- 上传文件卡片(嵌在输入框内部顶端,随卡片数撑高输入框;新卡插最前,图标 + 文件名/类型大小,逐卡上传进度遮罩;过多横向滚动) ---------- + function uploadTypeLabel(name) { + const m = /\.([A-Za-z0-9]{1,8})$/.exec(name || ''); + return m ? m[1].toUpperCase() : '文件'; + } + function uploadIconSvg(name) { + // 与文件面板同款图标语言:图片用图、其余用文档 + return /\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(name || '') + ? '' + : ''; + } + function addUploadCard(file) { + const row = $('up-cards'); + row.classList.remove('hidden'); + const card = document.createElement('div'); + card.className = 'up-card'; + card.dataset.name = file.name; // 发送时按名字在正文前拼告知行 + card.innerHTML = + '
' + uploadIconSvg(file.name) + '
' + + '
' + + '
' + esc(file.name) + '
' + + '
' + uploadTypeLabel(file.name) + ' · ' + fmtSize(file.size) + '
' + + '
' + + '' + + '
0%
'; + const mask = card.querySelector('.up-mask'); + const pctEl = card.querySelector('.up-pct'); + const closeBtn = card.querySelector('.up-x'); + // ×掉卡片 = 从 DOM 移除;send() 按现存 data-done 卡片实时拼告知行,自然不再包含该文件(文件本身仍在任务目录) + closeBtn.addEventListener('click', () => { + card.remove(); + if (!row.children.length) row.classList.add('hidden'); + }); + // 倒序:最后上传的排最前;新卡入位后横向滚回左端保证可见 + row.prepend(card); + row.scrollTo({ left: 0, behavior: 'smooth' }); + return { + setPct(p) { + const v = Math.max(0, Math.min(100, Math.round(p))); + pctEl.textContent = v + '%'; + card.style.setProperty('--up-p', v + '%'); + }, + done() { + mask.remove(); + card.classList.add('done'); + card.dataset.done = '1'; // 仅成功上传的卡片参与发送时的告知行 + closeBtn.classList.remove('hidden'); + }, + fail() { + card.classList.add('err'); + mask.innerHTML = '上传失败'; + closeBtn.classList.remove('hidden'); + }, + }; + } + function clearUploadCards() { + const row = $('up-cards'); + row.innerHTML = ''; + row.classList.add('hidden'); + } + + // 面板内上传:直接写入当前会话任务目录(>阈值的图片逐个询问压缩;多文件并行上传+总进度条+逐卡进度) + $('file-input').addEventListener('change', async e => { + const input = e.target; + const files = Array.prototype.slice.call(input.files || []); // 先快照再清空,FileList 是实时的 + input.value = ''; + if (!files.length) return; + if (!state.sessionId) { toast('先发送一条消息创建会话'); return; } + // 大图逐个串行询问压缩(模态弹窗不能并行) + const ready = []; + for (const f of files) ready.push(await maybeCompressImage(f)); + // 每张卡对应一个文件的上传进度(输入区上方;面板内总进度条保留不变) + const cards = ready.map(f => addUploadCard(f)); + // ---- 并行上传 + 实时进度 ---- + const progWrap = $('fp-progress'), progBar = $('fp-progress-bar'), progPct = $('fp-progress-pct'); + const tot = ready.reduce((s, f) => s + f.size, 0); + const loaded = { v: 0 }; // 所有文件已上传字节总和 + let done = 0, errCount = 0; + function paintProg() { + const pct = tot ? Math.min(100, Math.round(loaded.v / tot * 100)) : 0; + progBar.style.width = pct + '%'; + progPct.textContent = pct + '%'; + } + progWrap.classList.remove('hidden'); + paintProg(); + const tasks = ready.map((f, i) => new Promise(resolve => { + const card = cards[i]; + const fd = new FormData(); fd.append('files', f, f.name); + const xhr = new XMLHttpRequest(); + xhr.open('POST', '/api/sessions/' + state.sessionId + '/files'); + let lastLoaded = 0; + xhr.upload.onprogress = function (ev) { + if (!ev.lengthComputable) return; + // ev.loaded 是本文件累计已发字节,汇总时取本次增量避免多计 + loaded.v += ev.loaded - lastLoaded; + lastLoaded = ev.loaded; + paintProg(); + card.setPct(ev.loaded / ev.total * 100); + }; + xhr.onload = function () { + if (xhr.status === 200) { done++; card.done(); } else { errCount++; card.fail(); } + // 终态补齐(可能没收到最后一帧 100%) + if (lastLoaded < f.size) { loaded.v += f.size - lastLoaded; paintProg(); } + resolve(); + }; + xhr.onerror = function () { errCount++; card.fail(); resolve(); }; + xhr.send(fd); + })); + await Promise.all(tasks); + paintProg(); + // 全部成功不再弹提示(卡片已完成态即反馈);有失败才提醒 + if (errCount) toast('已上传 ' + done + ' 个,失败 ' + errCount + ' 个'); + loadFiles(); + // 1.2s 后收起进度条 + setTimeout(() => { progWrap.classList.add('hidden'); progBar.style.width = '0%'; }, 1200); + }); + + + function renderAttachChips() { + const row = $('attach-chips'); + row.classList.toggle('hidden', !state.attachments.length); + row.innerHTML = state.attachments.map((f, i) => + '' + esc(f.name) + '' + + '').join(''); + } + $('attach-chips').addEventListener('click', e => { + const rm = e.target.closest('.rm'); + if (rm) { state.attachments.splice(+rm.dataset.i, 1); renderAttachChips(); } + }); + + // ---------- 抽屉 ---------- + // 桌面端(≥960px):侧边栏常驻左侧列(由 body.drawer-open 驱动会话区偏移),不用遮罩; + // 移动端(<960px):仍为浮层抽屉 + 遮罩。 + const drawerMQ = window.matchMedia('(min-width: 960px)'); + function openDrawer(open) { + // 清掉手势拖动遗留的内联位移/透明度,改由 CSS transition 负责开合动画 + const drawer = $('drawer'), scrim = $('scrim'); + drawer.style.transform = ''; drawer.style.transition = ''; + scrim.style.opacity = ''; + drawer.classList.toggle('open', open); + scrim.classList.toggle('show', open && !drawerMQ.matches); + document.body.classList.toggle('drawer-open', open); + } + $('menu-btn').addEventListener('click', () => { + const open = !$('drawer').classList.contains('open'); + openDrawer(open); + if (open) loadSessionList(); + }); + $('scrim').addEventListener('click', () => openDrawer(false)); + + let searchTimer = null; + $('search-input').addEventListener('input', () => { + clearTimeout(searchTimer); + searchTimer = setTimeout(loadSessionList, 250); + }); + $('drawer-list').addEventListener('click', e => { + // 桌面端 hover 删除按钮:先于打开会话处理,点击弹删除确认 modal + const delBtn = e.target.closest('.conv-del'); + if (delBtn) { e.stopPropagation(); deleteSession(delBtn.dataset.del); return; } + const item = e.target.closest('.conv-item'); + if (!item) return; + openSession(item.dataset.id); + if (!drawerMQ.matches) openDrawer(false); // 桌面端侧栏常驻,选完会话不收起来 + }); + + // ---------- 移动端右滑会话行露出删除按钮(iOS 风格) ---------- + (function bindSwipeToDelete() { + const list = $('drawer-list'); + const THRESHOLD = 60; // 滑过这个距离开 + let g = null; // {x0, y0, t0, wrap, item, horiz, lastX, wasSwiped} + function onDown(e) { + if (e.touches.length !== 1) { g = null; return; } + const t = e.touches[0]; + const item = e.target.closest('.conv-item'); + const wrap = e.target.closest('.conv-wrap'); + if (!item || !wrap) { g = null; return; } + // 关闭 transform 动画,保证跟手不粘滞 + item.style.transition = 'none'; + g = { x0: t.clientX, y0: t.clientY, t0: Date.now(), wrap, item, horiz: false, lastX: t.clientX }; + } + function onMove(e) { + if (!g) return; + const t = e.touches[0]; + const dx = t.clientX - g.x0; + const dy = t.clientY - g.y0; + // 先判断为横向手势才接管 + if (!g.horiz) { + if (Math.abs(dx) < 8 && Math.abs(dy) < 8) return; + if (Math.abs(dy) > Math.abs(dx) + 6) { g = null; g.item.style.transition = ''; return; } // 竖向滚动,不接管 + g.horiz = true; + } + // 跟手 clamp 到 [-60, 0]:负值左滑,正值右滑 + const off = Math.max(-60, Math.min(0, dx)); + g.item.style.transform = 'translateX(' + off + 'px)'; + g.lastX = t.clientX; + } + function onUp(e) { + if (!g) return; + const t = (e.changedTouches && e.changedTouches[0]) || null; + const dx = t ? t.clientX - g.x0 : (g.lastX - g.x0); + const moved = Math.abs(dx); + // 恢复 transition(为 snap 提供动画) + g.item.style.transition = ''; + if (g.horiz) { + if (moved >= THRESHOLD && dx < 0) { + // 左滑到位:弹删除确认 modal(不露 conv-del) + g.wrap.classList.remove('swiped'); + g.item.style.transform = ''; + deleteSession(g.item.dataset.id); + } else { + // 右滑到位 或 未达阈值:弹回 + g.wrap.classList.remove('swiped'); + g.item.style.transform = ''; + } + } else { + // 未识别为横向:不动(交给 click 委派处理打开) + g.item.style.transform = ''; + } + g = null; + } + list.addEventListener('touchstart', onDown, { passive: true }); + list.addEventListener('touchmove', onMove, { passive: true }); + list.addEventListener('touchend', onUp, { passive: true }); + list.addEventListener('touchcancel', onUp, { passive: true }); + })(); + + // 会话页左缘右滑 → 拉出历史抽屉:跟随手指平移,超过阈值/快速右滑松手即打开。 + (function bindEdgeSwipe() { + const drawer = $('drawer'), scrim = $('scrim'); + const EDGE = 160; // 触发识别的左缘宽度(px) + const MAX_OPACITY = 0.4; // 与 #scrim.show 背景一致 + let g = null; // 当前手势 {x0,y0,t0,horiz,cancelled,off} + function uiBlocked() { + if (!$('settings-page').classList.contains('hidden')) return true; + if (!$('img-viewer').classList.contains('hidden')) return true; + if (!$('fs-viewer').classList.contains('hidden')) return true; + if ($('files-panel').classList.contains('open')) return true; // 文件面板展开时不响应 + return !!document.querySelector('.modal-overlay:not(.hidden)'); + } + function reset() { + drawer.style.transform = ''; drawer.style.transition = ''; + scrim.style.opacity = ''; + drawer.classList.remove('open'); + scrim.classList.remove('show'); + } + document.addEventListener('touchstart', e => { + if (drawer.classList.contains('open') || uiBlocked() || e.touches.length !== 1) { g = null; return; } + const t = e.touches[0]; + if (t.clientX > EDGE) { g = null; return; } // 仅左缘起手 + g = { x0: t.clientX, y0: t.clientY, t0: Date.now(), horiz: false, cancelled: false, off: 0 }; + }, { passive: true }); + document.addEventListener('touchmove', e => { + if (!g || g.cancelled) return; + const t = e.touches[0]; + const dx = t.clientX - g.x0, dy = t.clientY - g.y0; + if (!g.horiz) { + if (Math.abs(dx) < 8 && Math.abs(dy) < 8) return; // 方向未定,等待 + // 主轴判定带 6px 死区:明确右滑才接管,明确纵向/向左才放弃,模糊时继续观察。 + // 两点教训: + // 1) 必须用绝对值比较——手指上滑时 dy 为负,有符号的 dy > dx 会把「上滑+几像素 + // 右偏」误判成横向手势并 preventDefault,导致左缘向上滚动被接管卡死; + // 2) 拇指甩动轨迹天然带弧度,单帧 |dx| 略大不代表横向意图——一锤定音会误抢 + // 斜向上滑动,故模糊区间不表态,等后续位移把方向差拉开再判。 + if (dx > Math.abs(dy) + 6) g.horiz = true; // 明确右滑 → 接管 + else if (dx < -6 || Math.abs(dy) > Math.abs(dx) + 6) { g.cancelled = true; return; } // 明确向左/纵向 → 放弃 + else return; // 死区内,继续观察 + } + e.preventDefault(); // 手势归属抽屉:阻止页面滚动/系统返回 + const w = drawer.offsetWidth || 300; + g.off = Math.max(0, Math.min(dx, w)); + if (!drawer.style.transition) drawer.style.transition = 'none'; // 跟手时不走 CSS 动画 + drawer.classList.remove('open'); + scrim.classList.add('show'); + drawer.style.transform = 'translateX(calc(-102% + ' + g.off + 'px))'; + scrim.style.opacity = (g.off / w) * MAX_OPACITY; + }, { passive: false }); + function endDrag(e, commit) { + if (!g) return; + const w = drawer.offsetWidth || 300; + const dist = g.horiz ? g.off : 0; + const dt = Date.now() - g.t0; + const speed = dt > 0 ? dist / dt : 0; // px/ms + const open = commit && g.horiz && (dist >= 60 || dist / w >= 0.35 || (dist >= 24 && speed > 0.8)); + reset(); + if (open) { + openDrawer(true); + loadSessionList(); + } + g = null; + } + document.addEventListener('touchend', e => endDrag(e, true), { passive: true }); + document.addEventListener('touchcancel', e => endDrag(e, false), { passive: true }); + })(); + + // 抽屉底部用户区:整行点击 → 设置主页(逻辑见文末「设置区」一节) + $('drawer-user').addEventListener('click', () => { + if (!drawerMQ.matches) openDrawer(false); // 桌面端设置页覆盖在会话区上,侧栏保持展开 + showSettings(); + }); + + // ---------- 顶栏 ---------- diff --git a/app/server/public/js/sessions.js b/app/server/public/js/sessions.js new file mode 100644 index 0000000..2b80033 --- /dev/null +++ b/app/server/public/js/sessions.js @@ -0,0 +1,647 @@ +// 会话列表(抽屉)/ 打开新建重命名 / SSE 看门狗与挂起 / 状态栏 / 定时任务 / 上下文压缩(拆自 index.html 内联脚本,纯搬运不改逻辑) +'use strict'; + // ---------- 会话列表(抽屉) ---------- + function groupLabel(ts) { + const d = new Date(ts), n = new Date(); + const sod = t => new Date(t.getFullYear(), t.getMonth(), t.getDate()).getTime(); + const diff = (sod(n) - sod(d)) / 86400000; + if (diff <= 0) return '今天'; + if (diff === 1) return '昨天'; + return d.getFullYear() + '年' + (d.getMonth() + 1) + '月'; + } + + // 抽屉行状态指示:仅进行中的会话(排队/活跃/保持)展示彩色圆点,已完成/已终止不显示 + const DRAWER_STATUS_TEXT = { queued: '排队中', active: '活跃中', held: '保持中' }; + function drawerStatusDot(s) { + const st = s && s.status; + const label = DRAWER_STATUS_TEXT[st]; + if (!label) return ''; + return ''; + } + + function renderDrawerList() { + const list = state.sessions.slice().sort((a, b) => (b.updated_at || 0) - (a.updated_at || 0)); + const box = $('drawer-list'); + if (!list.length) { box.innerHTML = '
没有找到相关对话
'; return; } + let html = '', lastGroup = null; + for (const s of list) { + const g = groupLabel(s.updated_at); + if (g !== lastGroup) { html += '
' + esc(g) + '
'; lastGroup = g; } + html += '
' + + '' + + '' + + '
'; + } + box.innerHTML = html; + } + + async function loadSessionList() { + const q = $('search-input').value.trim(); + try { + let list; + if (q) { + const r = await req('GET', '/api/sessions?q=' + encodeURIComponent(q) + '&limit=50&with_total=1'); + list = r.rows || []; + } else { + const [active, done] = await Promise.all([ + req('GET', '/api/sessions?status=active&limit=100'), + req('GET', '/api/sessions?status=done&limit=50&with_total=1'), + ]); + list = (active || []).concat((done && done.rows) || []); + } + state.sessions = list; + renderDrawerList(); + } catch (e) { toast('加载会话失败:' + e.message); } + } + + // ---------- 会话打开 / 新建 / 状态栏(抽屉行 × 调 deleteSession; 默认含任务目录) ---------- + async function deleteSession(id) { + if (!id) return; + // 从已加载列表查出会话标题,让 modal 能显示「标题 + ID」方便核对 + const s = (state.sessions || []).find(x => x.id === id); + const title = s ? (s.title || s.id) : id; + const body = '确定删除会话 「' + esc(title) + '」 吗?删除后无法恢复。' + + '
会话 ID:' + esc(id) + '
'; + if (!await confirmModal('删除会话', body, '删除', true, + { checkbox: { label: '同时删除任务文件夹', default: true }, bodyHtml: true })) return; + const delDir = state._confirmChecked ? 'true' : 'false'; + try { + await req('DELETE', '/api/sessions/' + id + '?delete_dir=' + delDir); + // 删的是当前打开的会话:回 welcome 视图并清状态 + if (state.sessionId === id) { + closeStream(); + removeTyping(); + state.sessionId = null; + state.sessionTitle = ''; + state.sessionType = 'secretary'; + state.streamEl = null; + state.streamText = ''; + state.toolCards = {}; + state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置 + state.streaming = false; + setView('welcome'); // 复用 newChat 同样的视图切换路径 + } + toast('已删除会话'); + loadSessionList(); + } catch (e) { toast('删除失败:' + e.message); } + } + function closeStream() { + if (state.es) { state.es.close(); state.es = null; } + // SSE 一断,本地「等待压缩收尾」状态就成孤儿(再也收不到带 is_summary 的最终消息): + // 复位以免压缩按钮永久 disabled / 防重入卡死。切会话、重开流都会经过这里。 + // (后果仅是:离开期间的摘要不会自动淡出存档,重进会话后由 renderDetail 按库内标记渲染,历史保持完整。) + state.pendingSummary = false; + } + + // ---------- SSE 静默看门狗 ---------- + // 流断档期的 assistant_message/tool_* 等事件不会重放(sse.js 无客户端即丢弃),页面会停在“无回应”假死; + // 而 EventSource 本身多半已自动重连——真正缺的是重新拉一次库。服务端每 15s 发可见心跳(event: ping), + // 静默超 45s 即判死,自动做一次“切走再切回”式重同步(resyncSession);重连失败则 45s 后再试,不刷屏。 + let sseResyncing = false; + function resyncSession() { + const id = state.sessionId; + if (!id || state.view !== 'chat' || sseResyncing) return; + sseResyncing = true; + state.lastSseAt = Date.now(); // 计时从现在开始,失败也等下个周期再试 + closeStream(); + req('GET', '/api/sessions/' + id + '?limit=' + CHAT_INIT_PAGE_SIZE).then(detail => { + if (state.sessionId === id && state.view === 'chat') renderDetail(detail); + }).catch(() => {}).then(() => { + sseResyncing = false; + if (state.sessionId === id && state.view === 'chat' && !state.es) connectStream(); + }); + } + setInterval(() => { + if (document.hidden) return; // 后台不跑看门狗,免得被系统部分唤醒时空转重渲染耗能耗 + if (state.sessionId && state.view === 'chat' && state.es && Date.now() - state.lastSseAt > 45000) resyncSession(); + }, 5000); + + // ---------- 后台超时挂起 SSE ---------- + // 长时间在后台就断开 EventSource(否则长连接会阻止 Safari/App Nap 冻结整页,整晚小功耗累积成“大量能耗”被强制重载); + // 回到前台再 resyncSession() 一次性补拉数据 + 重连。 + const SSE_SUSPEND_HIDDEN_MS = 2 * 60 * 1000; + let sseSuspended = false; + let sseSuspendTimer = 0; + function suspendStream() { + if (sseSuspended || !document.hidden) return; + if (state.es) closeStream(); + sseSuspended = true; + } + function resumeStream() { + if (!sseSuspended) return; + sseSuspended = false; + resyncSession(); + } + // 后台标签页里 interval 被限频;切回前台立刻补一次判定,自动覆盖“休眠/切走醒来后页面停在半截”场景 + document.addEventListener('visibilitychange', () => { + if (document.hidden) { + clearTimeout(sseSuspendTimer); + sseSuspendTimer = setTimeout(suspendStream, SSE_SUSPEND_HIDDEN_MS); + return; + } + clearTimeout(sseSuspendTimer); + resumeStream(); + if (state.sessionId && state.view === 'chat' && state.es + && Date.now() - state.lastSseAt > 45000) resyncSession(); + }); + + async function openSession(id) { + closeStream(); + removeTyping(); + setFilesPanel(false); // 会话切换,收起文件面板防旧列表残留 + state.sessionId = id; + state.status = ''; + state.schedule = null; // 防详情返回前残留上一会话的任务状态条 + // 先从抽屉列表缓存取会话类型,让顶部 icon 立即正确;详情回来后由 renderDetail 纠正 + const cached = (state.sessions || []).find(x => x.id === id); + state.sessionType = (cached && cached.assistant_type) || 'secretary'; + state.streamEl = null; + state.streamText = ''; + state.streamWrap = null; + state.lastAssistantMsgId = null; + state.toolCards = {}; + state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置 + state.streaming = false; + state.attachments = []; + userPaused = false; + state.chatHasMore = false; // 分页状态先复位:防详情返回前用旧会话的游标/标志拉到错会话的消息 + state.chatOldestId = null; + state.chatLoadedCount = 0; + renderAttachChips(); + clearUploadCards(); // 切会话清掉旧会话的上传卡片 + renderDrawerList(); // 会话切换后立刻重画抽屉高亮,避免下次打开才看到更新 + setView('chat'); + $('chat-view').innerHTML = '
加载中…
'; + try { + const detail = await req('GET', '/api/sessions/' + id + '?limit=' + CHAT_INIT_PAGE_SIZE); + if (state.sessionId !== id) return; // 期间已切到别的会话 + renderDetail(detail); + connectStream(); + } catch (e) { + if (state.sessionId === id) toast('打开会话失败:' + e.message); + } + } + + // 确保存在当前会话:首条消息自动建档(POST /api/sessions);助手类型此时锁定,后续不可变更 + async function ensureSession() { + if (state.sessionId) return state.sessionId; + const s = await req('POST', '/api/sessions', { title: '', model_id: '', assistant_type: state.mode }); + state.sessionId = s.id; + state.sessionTitle = (s && s.title) || ''; + state.sessionType = (s && s.assistant_type) || state.mode; + setView('chat'); + renderHeader(); + updatePhaseBar(); + connectStream(); + return s.id; + } + + function newChat() { + closeStream(); + removeTyping(); + setFilesPanel(false); // 新建会话,文件面板随之收起 + state.sessionId = null; + state.sessionTitle = ''; + state.sessionType = 'secretary'; + state.status = ''; + state.schedule = null; + state.attachments = []; + state.streamEl = null; + state.streamText = ''; + state.toolCards = {}; + state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置 + state.streaming = false; + userPaused = false; + renderAttachChips(); + clearUploadCards(); + selectMode('secretary'); // 置顶逻辑:新建时自动选中【文秘助理】 + setView('welcome'); + $('chat-view').innerHTML = ''; + $('msg-input').value = ''; + autosize(); + updateScrollBottomBtn(); + } + + // ---------- 会话重命名(点击 header 标题触发;PATCH 接口,同步 index 交互) ---------- + async function renameSession() { + if (!state.sessionId) return; + const cur = state.sessionTitle || state.sessionId; + // 标题与 id 相同时(未命名)输入框留空 + const t = await promptModal('重命名会话', '输入新的会话名称', cur === state.sessionId ? '' : cur); + if (t === null) return; // 取消 + const title = String(t).trim(); + try { + await req('PATCH', '/api/sessions/' + state.sessionId, { title: title }); + toast('已重命名'); + state.sessionTitle = title; + renderHeader(); + loadSessionList(); + } catch (e) { toast('重命名失败:' + e.message); } + } + + // ---------- 会话状态栏(搬自 index 的 phase-bar 功能) ---------- + function updatePhaseBar(d) { + const bar = $('phase-bar'); + if (!bar) return; + // 定时任务状态条与会话状态栏同刷新入口(其内部自判视图/有无任务,早退路径也要走到) + updateScheduleBar(); + if (!(state.view === 'chat' && state.sessionId)) { bar.classList.add('hidden'); return; } + bar.classList.remove('hidden'); + const pill = $('status-pill'); + const stMap = { queued: '排队中', active: '活跃中', held: '保持中', completed: '已完成', cancelled: '已终止' }; + let text = stMap[state.status] || state.status || '--'; + if (d && d.queue_pos) text += '(第 ' + d.queue_pos + ' 位)'; + // active/held 时附带当前占用的模型 + if ((state.status === 'active' || state.status === 'held') && d && d.model_id) { + text += ' · ' + d.model_id; + } + pill.textContent = text; + // 状态胶囊配色:活跃中绿(执行中)、保持中黄(已答完、保持模型中)等;状态栏整体同步染色 + pill.className = 'status-pill ' + (state.status || ''); + bar.className = 'phase-bar ' + (state.status || ''); + // 活跃中提供「终止」;保持中改为「断开」(主动放弃保持租约,会话结为已完成) + const btn = $('stop-btn'); + const actionable = state.status === 'active' || state.status === 'held'; + btn.classList.toggle('hidden', !actionable); + btn.textContent = state.status === 'held' ? '断开' : '终止'; + btn.classList.toggle('muted', state.status === 'held'); + // 已完成/已终止时提供「选择模型」,手动指定空闲模型后继续对话 + const msBtn = $('model-switch-btn'); + if (msBtn) msBtn.classList.toggle('hidden', !(state.sessionId && (state.status === 'completed' || state.status === 'cancelled'))); + // 状态栏「压缩」按钮:active 时不允许(避免与正在跑的回合抢上下文); + // 其余状态可点。未发起总结时可点;发起后按钮 disabled 防双击。 + const cpBtn = $('compress-btn'); + if (cpBtn) { + const allowShow = !!(state.sessionId && state.status && state.status !== 'active'); + cpBtn.classList.toggle('hidden', !allowShow); + // 只有不在请求中时才允许 active 决定 disabled;避免总结流程中被打断时再次被 allowed + if (!state.pendingSummary) cpBtn.disabled = state.status === 'active'; + } + } + + // ---------- 定时任务状态条(整条可点→详情弹窗;创建只走 AI 工具,频次/提示词可在弹窗内改) ---------- + const CRON_DOW = ['日', '一', '二', '三', '四', '五', '六']; + // cron 人类可读化:只覆盖常见形态(每天/每周几几点、每 N 小时),其余原样显示表达式 + function cronText(expr) { + const p = String(expr || '').trim().split(/\s+/); + if (p.length !== 5) return String(expr || ''); + const min = p[0], hour = p[1], dom = p[2], mon = p[3], dow = p[4]; + const hm = /^\d+$/.test(min) && /^\d+$/.test(hour) + ? hour.padStart(2, '0') + ':' + min.padStart(2, '0') : ''; + if (dom === '*' && mon === '*') { + const everyH = hour.match(/^\*\/(\d+)$/); + if (dow === '*' && min === '0' && everyH) return '每 ' + everyH[1] + ' 小时'; + if (dow === '*' && hm) return '每天 ' + hm; + if (/^\d$/.test(dow) && hm) return '每周' + CRON_DOW[+dow] + ' ' + hm; + } + return String(expr); + } + function updateScheduleBar() { + const bar = $('schedule-bar'); + if (!bar) return; + const sc = state.schedule; + if (!(state.view === 'chat' && state.sessionId && sc)) { bar.classList.add('hidden'); bar.innerHTML = ''; return; } + let last; + // running 不精确(AI 跑完到下次 tick 间仍显示),对 UI 够用;无专用轮询,重进会话时刷新 + if (sc.last_status === 'running') last = '执行中…'; + else if (sc.last_status === 'ok') last = '上次 ok'; + else if (sc.last_status === 'error') last = '上次 error' + (sc.last_note ? ': ' + sc.last_note : ''); + else if (sc.last_status === 'skipped') last = '上次 跳过' + (sc.last_note ? ':' + sc.last_note : ''); + else last = '下次 ' + fmtTime(sc.next_run_at); + bar.innerHTML = '' + esc(cronText(sc.cron_expr)) + ' · ' + esc(last) + '' + + ''; + bar.classList.remove('hidden'); + } + // 频次控件显隐:每天=[时分] 每周=[天][时分] 每隔=[N][小时] 自定义=[cron 文本框] + function schedFreqUi() { + const f = $('sched-freq').value; + const hm = f === 'daily' || f === 'weekly'; + $('sched-dow').classList.toggle('hidden', f !== 'weekly'); + $('sched-hh').classList.toggle('hidden', !hm); + $('sched-colon').classList.toggle('hidden', !hm); + $('sched-mm').classList.toggle('hidden', !hm); + $('sched-nh').classList.toggle('hidden', f !== 'everyN'); + $('sched-nh-unit').classList.toggle('hidden', f !== 'everyN'); + $('sched-cron').classList.toggle('hidden', f !== 'custom'); + } + // 既有 cron → 控件:只认每天/每周几/每 N 小时三形态(与 cronText 覆盖一致),其余落入自定义 + function schedFillFromCron(expr) { + const f = $('sched-freq'); + const p = String(expr || '').trim().split(/\s+/); + f.value = 'custom'; + if (p.length === 5 && p[2] === '*' && p[3] === '*' && /^\d+$/.test(p[0]) && /^\d+$/.test(p[1])) { + if (p[4] === '*') f.value = 'daily'; + else if (/^[0-6]$/.test(p[4])) { f.value = 'weekly'; $('sched-dow').value = p[4]; } + if (f.value !== 'custom') { $('sched-hh').value = +p[1]; $('sched-mm').value = +p[0]; } + } else if (p.length === 5 && p[0] === '0' && /^\*\/\d+$/.test(p[1]) && p[2] === '*' && p[3] === '*' && p[4] === '*') { + f.value = 'everyN'; + $('sched-nh').value = p[1].slice(2); + } + if (f.value === 'custom') $('sched-cron').value = String(expr || ''); + schedFreqUi(); + } + // 控件 → cron 表达式;非法输入抛中文 Error(后端 validateCron 再兜底:可解析 + 间隔 ≥1h) + function schedComposeCron() { + const f = $('sched-freq').value; + if (f === 'custom') { + const c = $('sched-cron').value.trim(); + if (!c) throw new Error('请输入 cron 表达式'); + return c; + } + if (f === 'everyN') { + const n = parseInt($('sched-nh').value, 10); + if (!(n >= 1 && n <= 23)) throw new Error('间隔需为 1-23 的整小时数'); + return '0 */' + n + ' * * *'; + } + const hh = parseInt($('sched-hh').value, 10); + const mm = parseInt($('sched-mm').value, 10); + if (!(hh >= 0 && hh <= 23)) throw new Error('小时需为 0-23'); + if (!(mm >= 0 && mm <= 59)) throw new Error('分钟需为 0-59'); + return mm + ' ' + hh + ' * * ' + (f === 'weekly' ? $('sched-dow').value : '*'); + } + function openScheduleModal() { + const sc = state.schedule; + if (!sc || state.view !== 'chat') return; + schedFillFromCron(sc.cron_expr); + let meta = sc.next_run_at ? '下次执行 ' + fmtTime(sc.next_run_at) : ''; + if (sc.last_run_at) meta += (meta ? '\n' : '') + '上次执行 ' + fmtTime(sc.last_run_at) + (sc.last_status ? ' · ' + sc.last_status : ''); + $('sched-modal-meta').textContent = meta; + $('sched-modal-prompt').value = sc.prompt || ''; + $('schedule-modal').classList.remove('hidden'); + } + function closeScheduleModal() { $('schedule-modal').classList.add('hidden'); } + async function saveSchedule() { + const id = state.sessionId; + if (!id || !state.schedule) return; + const prompt = $('sched-modal-prompt').value.trim(); + if (!prompt) { toast('提示词不能为空'); return; } + let cron; + try { cron = schedComposeCron(); } catch (e) { toast(e.message); return; } + try { + await req('PATCH', '/api/sessions/' + id + '/schedule', { prompt: prompt, cron_expr: cron }); + toast('定时任务已更新'); + closeScheduleModal(); + // 频次变了 next_run_at 由后端重算,重拉详情同步状态条(与删除后同一套刷新路径) + const detail = await req('GET', '/api/sessions/' + id + '?limit=' + Math.max(CHAT_PAGE_SIZE, state.chatLoadedCount)); + if (state.sessionId === id) { renderDetail(detail); connectStream(); } + } catch (e) { toast('更新失败:' + e.message); } + } + async function deleteSchedule() { + if (!state.sessionId) return; + const id = state.sessionId; + if (!await confirmModal('删除定时任务', '删除后本会话不再定时执行。', '删除', true)) return; + try { + await req('DELETE', '/api/sessions/' + id + '/schedule'); + toast('定时任务已删除'); + closeScheduleModal(); + // 重载详情:状态条消失,会话内多出一条 scheduler_note 通知(AI 未被触发) + const detail = await req('GET', '/api/sessions/' + id + '?limit=' + Math.max(CHAT_PAGE_SIZE, state.chatLoadedCount)); + if (state.sessionId === id) { renderDetail(detail); connectStream(); } + } catch (e) { toast('删除失败:' + e.message); } + } + async function stopSession() { + if (!state.sessionId) return; + const held = state.status === 'held'; + try { + if (held) { + await req('POST', '/api/sessions/' + state.sessionId + '/release'); + toast('已断开,模型已释放'); + } else { + await req('POST', '/api/sessions/' + state.sessionId + '/stop'); + toast('已发送终止指令'); + } + } catch (e) { toast((held ? '断开失败:' : '终止失败:') + e.message); } + } + async function openModelSwitch() { + if (!state.sessionId) return; + const list = $('bind-model-list'); + const footer = $('bind-model-footer'); + list.innerHTML = '
加载中…
'; + footer.textContent = ''; + $('bind-model-modal').classList.remove('hidden'); + try { + // /api/models 已按平台补齐 platform/mid/vision/key_count(见 server.js);行本身按模型 id 唯一。 + // 已删除但重启前仍在运行池里的模型不再展示,避免误绑到重启后就消失的模型 + const rows = ((await req('GET', '/api/models')) || []).filter(m => !SET.deletedModels[m.id]); + if (!rows.length) { + list.innerHTML = '
还没有配置模型。
'; + return; + } + // 平台颜色盘(循环使用) + const DOT_COLORS = ['#3B82F6','#10B981','#F59E0B','#EF4444','#8B5CF6','#EC4899','#06B6D4','#F97316']; + // 按平台分组;models 全平台共用,一个会话占用一个 key → 平台空闲 key 数 = key_count - 占用模型数 + const platMap = new Map(); + for (const m of rows) { + const pk = m.platform || ''; + if (!platMap.has(pk)) { + platMap.set(pk, { name: pk || '未知平台', keyCount: m.key_count || 0, models: [], busyCount: 0 }); + } + const g = platMap.get(pk); + g.models.push(m); + if (m.is_busy) g.busyCount++; + } + const groups = []; + for (const g of platMap.values()) { + g.freeKeys = Math.max(0, g.keyCount - g.busyCount); + groups.push(g); + } + // 可选 = 模型自身空闲 且 该平台还有空闲 key;统计可用数供底部提示 + let avail = 0; + for (const g of groups) for (const m of g.models) if (!m.is_busy && g.freeKeys > 0) avail++; + list.innerHTML = groups.map((g, gi) => { + const dotColor = DOT_COLORS[gi % DOT_COLORS.length]; + const itemHtml = g.models.map(m => { + const disabled = !!m.is_busy || g.freeKeys <= 0; + const title = m.is_busy ? ' 占用中' : (g.freeKeys <= 0 ? ' 无空闲 Key' : ''); + return '
' + + '
' + + '
' + + '
' + esc(m.display_name || m.mid || m.id) + + (title ? ' ' + title.trim() + '' : '') + '
' + + '
' + + (m.vision ? 'Vision' : '') + + 'Thinking' + + '
' + + '
' + + '
'; + }).join(''); + return '
' + + '
' + + '' + + '' + esc(g.name) + '' + + '' + g.keyCount + ' key' + (g.keyCount > 1 ? 's' : '') + '' + + '
' + + itemHtml + + '
'; + }).join(''); + footer.textContent = '共 ' + avail + ' 个模型可用'; + } catch (e) { + list.innerHTML = '
读取模型列表失败:' + e.message + '
'; + } + } + function closeModelSwitch() { $('bind-model-modal').classList.add('hidden'); } + async function bindModel(modelId) { + if (!state.sessionId) return; + const id = state.sessionId; + closeModelSwitch(); + try { + await req('POST', '/api/sessions/' + id + '/bind', { model_id: modelId }); + toast('已绑定模型 ' + modelId); + } catch (e) { toast('绑定失败:' + e.message); } + // 无论成败都刷新会话详情(失败多为并发占用,状态可能已变);按已加载量分页重渲染,避免长会话退回全量重建 + try { + const detail = await req('GET', '/api/sessions/' + id + '?limit=' + Math.max(CHAT_PAGE_SIZE, state.chatLoadedCount)); + if (state.sessionId === id) { renderDetail(detail); connectStream(); } + loadSessionList(); + } catch (_) {} + } + // ---------- 「压缩」上下文总结 ---------- + // 用户点 phase-bar「压缩」按钮 → 弹窗选动作(右上角 X 关闭 = 不做任何事): + // 摘要(generate_only):AI 总结落库后,后端把摘要标 type='summary'、之前的消息标 type='archived' + // (UI 保留全部展示,但旧消息不再发给模型);前端把摘要前旧消息就地淡出存档。 + // 清空:直接走 clearChat()(DELETE 全部聊天记录,从零开始,不可恢复)。 + // 开始压缩后:后端响应回显 prompt,前端把它渲染成一条普通用户消息气泡(仅展示: + // 指令不再入库、也不发给模型,压缩回合的 system prompt 已整体替换为压缩提示词); + // 压缩回合中间的 AI 回复(思考/工具调用等)全部按普通消息渲染; + // 只有回合收尾的那条最终答复才带 is_summary,渲染成摘要卡片。 + // 后端 summarize 路由无需 body;runLoopInner 在最终 assistant_message SSE 上带 is_summary。 + async function summarizeChat() { + if (!state.sessionId) return; + if (state.pendingSummary) return; // 已在请求中,防重入 + if (state.status === 'active') { toast('AI 还在输出,请稍候再压缩'); return; } + // 弹窗两个动作:摘要(generate_only)/ 清空(clear → clearChat);右上 X / 点遮罩 / Esc 关闭。 + const choice = await compressModeModal(); + if (!choice) return; + if (choice === 'clear') { await clearChat(); return; } + await startSummary(); + } + + // 发起摘要压缩回合(手动「压缩→摘要」与自动压缩弹窗确认后共用): + // POST /summarize → 回显指令气泡 + 打字占位;收尾由带 is_summary 的最终答复/done 事件走既有链路。 + async function startSummary() { + if (!state.sessionId || state.pendingSummary) return; + state.pendingSummary = true; + const btn = $('compress-btn'); + if (btn) btn.disabled = true; + try { + const r = await req('POST', '/api/sessions/' + state.sessionId + '/summarize'); + // 开始压缩后直接把「压缩指令」当成普通用户消息发出来(后端回显 prompt); + // 后续中间的 AI 回复全部按普通消息渲染,直到带 is_summary 的最终答复才转摘要卡片。 + if (r && r.prompt) appendUserMsg(r.prompt); + if (r && r.delivered === 'live') addTyping(); // 已直接送达:先挂打字占位,首个 delta 到达时自动移除 + toast('已生成摘要中…'); + } catch (e) { + state.pendingSummary = false; + if (btn) btn.disabled = false; + toast('压缩失败:' + e.message); + } + } + + // 自动压缩提议(后端回合结束+宽限期后发 auto_compress 事件,不再自启):弹 modal 由用户手动确认。 + // 取消/忽略 = 本会话不再提议(服务端闸门,想压可手动点「压缩」);防重入:确认期间不叠加弹窗。 + async function proposeAutoCompress(d) { + const sid = state.sessionId; + if (!sid || state.view !== 'chat' || state.status !== 'held') return; // 会话已有新动静,提议过期 + if (_autoCompressPrompting) return; + _autoCompressPrompting = true; + let ok = false; + try { + ok = await confirmModal('自动压缩上下文', + '本轮输入 ' + fmtTok(d.prompt_tokens) + ' tokens,已达阈值 ' + fmtTok(d.threshold) + + '。AI 将生成结构化摘要,摘要之前的旧消息会存档(聊天里仍保留展示)不再发给 AI,后续对话从摘要开始。现在压缩?', + '立即压缩'); + } finally { + _autoCompressPrompting = false; + } + if (!ok) { toast('已跳过,本会话不再自动提议压缩'); return; } + if (state.sessionId !== sid) return; // 确认期间切了会话,作废 + if (state.status === 'active') { toast('AI 正在输出,本次提议作废,可稍后手动压缩'); return; } + await startSummary(); + } + + // 自动压缩确认弹窗防重入标记(见 proposeAutoCompress) + let _autoCompressPrompting = false; + + // 压缩动作选择弹窗:右上 X 关闭 + 两个动作(摘要 / 清空)。 + // 返回 'generate_only' | 'clear' | null(关闭取消)。 + // 这里手写一个独立小弹窗以避免与 confirmModal(两按钮)耦合;复用现有 modal-overlay / modal-close-btn 样式。 + // 颜色复用现有按钮语义:摘要 = primary-btn(蓝/确定风);清空 = ghost-btn.danger(红/删除风)。 + function compressModeModal() { + return new Promise(resolve => { + const wrap = document.createElement('div'); + wrap.className = 'modal-overlay'; + wrap.innerHTML = + ''; + function close(v) { + wrap.remove(); + document.removeEventListener('keydown', onKey); + resolve(v); + } + function onKey(e) { if (e.key === 'Escape') close(null); } + wrap.addEventListener('click', e => { if (e.target === wrap) close(null); }); + wrap.querySelectorAll('[data-act]').forEach(b => b.addEventListener('click', () => close(b.dataset.act === 'cancel' ? null : b.dataset.act))); + document.addEventListener('keydown', onKey); + document.body.appendChild(wrap); + // 默认聚焦关闭按钮,避免误触发两个动作 + wrap.querySelector('.modal-close-btn').focus(); + }); + } + + // 「摘要」实时收尾:后端已把摘要之前的消息行标成 type='archived',这里把 DOM 里 + // 摘要卡片(.msg-summary-live,多轮压缩取最后一张)之前的所有兄弟节点收进淡色存档容器, + // 尾部附一条「已存档」说明,与 renderDetail 重渲染样式一致。 + function archiveDomBeforeSummary() { + const box = $('chat-view'); + const cards = box.querySelectorAll('.msg-summary-live'); + const card = cards.length ? cards[cards.length - 1] : null; + if (!card) return; + const arc = document.createElement('div'); + arc.className = 'msg-archived'; + let el = box.firstChild; + while (el && el !== card) { const next = el.nextSibling; arc.appendChild(el); el = next; } + if (!arc.childNodes.length) return; // 首次就压缩:摘要前没有旧消息,不插空说明 + arc.insertAdjacentHTML('beforeend', + '
以上消息已存档,不再发送给 AI;后续对话从摘要开始
'); + box.insertBefore(arc, card); + } + + // 「清空」:删除本会话全部聊天记录(AI 后续对话不再携带这段历史),任务文件不受影响。 + // 入口:压缩动作弹窗的「清空」按钮。 + async function clearChat() { + if (!state.sessionId) return; + const id = state.sessionId; + const ok = await confirmModal('清空会话内容', + '将删除本会话的全部聊天记录,AI 后续对话不再携带这段历史(从零开始,更省 token)。任务文件全部保留,不受影响。此操作不可恢复。', + '清空', true); + if (!ok) return; + try { + await req('DELETE', '/api/sessions/' + id + '/messages'); + toast('会话内容已清空,文件已保留'); + // 服务端已将会话收尾为 completed 并清空消息:重新拉取详情即为干净起点 + const detail = await req('GET', '/api/sessions/' + id); + if (state.sessionId === id) { renderDetail(detail); connectStream(); } + loadSessionList(); + } catch (e) { toast('清空失败:' + e.message); } + const cpBtn = $('compress-btn'); + if (cpBtn) cpBtn.disabled = state.status === 'active'; + } + diff --git a/app/server/public/js/settings.js b/app/server/public/js/settings.js new file mode 100644 index 0000000..1c5cb73 --- /dev/null +++ b/app/server/public/js/settings.js @@ -0,0 +1,1432 @@ +// 设置区(页面栈/账户/服务/config/技能/模型池/MCP)+ 全局初始化(必须最后加载,初始化段在文件尾) +'use strict'; + $('new-chat-btn').addEventListener('click', newChat); + + // ============================================================================ + // 设置区(侧边栏用户区点击进入;页面搬自 index.html,接口全部复用既有 /api) + // ---------------------------------------------------------------------------- + // · 覆盖层 #settings-page:顶栏「左返回 + 中标题 + 右操作」,风格与对话页一致; + // 导航走 SET.stack 页面栈,返回弹一层、栈空即关闭;不再有底部导航。 + // · 页面:home 设置主页卡片 / account 账户 / service 服务(状态+配置) / + // cfg-editor config.yml 原文 / skills 列表 / skill-detail 详情 / + // skill-editor 技能文件编辑 / models 模型池。 + // ============================================================================ + + const SET = { + stack: [], + snaps: {}, // 页名 → 静态快照 HTML(setPush 时刷新;右滑返回垫底用) + pendingKeys: new Set(), // 已写盘、尚未重启生效的顶层配置段 + effCfg: null, cfgOrig: '', + curSkill: null, // 技能详情/编辑视图对应的技能名 + editorPath: null, editorOrig: '', editorText: '', editorLabel: '', + // 模型池(搬自 models.js) + cfgPlatforms: [], cfgModels: [], runtimeById: {}, modelsPendingRestart: false, + pendingEnable: {}, // 已写盘但重启前 effective 仍是旧值的 enable 覆盖(id → bool),防卡片回弹 + deletedModels: {}, // 已从 config.yml 删除、重启前后端仍会返回的模型(id → true):前端隐藏防回弹 + expandedGroups: {}, balanceByGroup: {}, balanceRequested: {}, balanceTypes: [], // 平台编辑弹窗工作态见 pfEdit(模块级变量) + // MCP 服务页:cfgMcp 缓存当前列表;改动待重启生效时置位,顶部常驻重启横幅 + cfgMcp: [], mcpPendingRestart: false, + }; + let setTok = 0; // 异步渲染防竞态令牌 + + // ---------- 通用小工具(搬自 core.js / settings.js) ---------- + const sleep = ms => new Promise(r => setTimeout(r, ms)); + function fmtSize(n) { + if (n == null) return ''; + if (n < 1024) return n + ' B'; + if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB'; + return (n / 1024 / 1024).toFixed(1) + ' MB'; + } + function att(s) { return esc(s).replace(/"/g, '"'); } // 属性上下文转义(esc 不处理引号) + function getByPath(obj, p) { + return String(p).split('.').reduce((o, k) => (o == null ? undefined : o[k]), obj); + } + function fmtUptime(ms) { + const s = Math.floor((ms || 0) / 1000); + const d = Math.floor(s / 86400), h = Math.floor(s % 86400 / 3600), m = Math.floor(s % 3600 / 60); + if (d) return d + ' 天 ' + h + ' 小时'; + if (h) return h + ' 小时 ' + m + ' 分'; + if (m) return m + ' 分 ' + (s % 60) + ' 秒'; + return s + ' 秒'; + } + function dispVal(v) { + if (v === undefined || v === null || v === '') return '(未设置)'; + if (typeof v === 'boolean') return v ? '是' : '否'; + return String(v); + } + + // ---------- 统一确认/输入弹窗(搬自 core.js;会话删除仍用原生 confirm) ---------- + let _dlgResolve = null; + function _dlgSettle(val) { + $('confirm-modal').classList.add('hidden'); + $('prompt-modal').classList.add('hidden'); + const r = _dlgResolve; + _dlgResolve = null; + if (r) r(val); + } + // confirmModal(title, text, okText, danger, opts?) + // opts.checkbox = {label, default=true} 可选:展示一个默认勾选状态可改的复选框 + // 确认/取消后在 state._confirmChecked 读出勾选状态(不破坏现有调用方签名) + function confirmModal(title, text, okText, danger, opts) { + state._confirmChecked = !!(opts && opts.checkbox); // 未传 opts 时 reset 为 false + const wrap = $('confirm-check-wrap'); + if (opts && opts.checkbox) { + $('confirm-check-label').textContent = opts.checkbox.label; + $('confirm-check').checked = opts.checkbox.default !== false; + state._confirmChecked = $('confirm-check').checked; + wrap.classList.remove('hidden'); + } else { + wrap.classList.add('hidden'); + } + $('confirm-check').onchange = function () { state._confirmChecked = this.checked; }; + return new Promise(resolve => { + _dlgResolve = resolve; + $('confirm-title').textContent = title || '请确认'; + // bodyHtml: 需要加粗/加附加说明时传 HTML 字符串;缺省仍走 textContent 防 XSS + const body = $('confirm-text'); + if (opts && opts.bodyHtml) body.innerHTML = text || ''; + else body.textContent = text || ''; + const ok = $('confirm-ok-btn'); + ok.textContent = okText || '确定'; + ok.style.background = danger ? 'linear-gradient(135deg,#a3352a,#d2483c)' : ''; + $('confirm-modal').classList.remove('hidden'); + }); + } + function confirmClose(v) { _dlgSettle(v); } + function promptModal(title, placeholder, initial, opts) { + return new Promise(resolve => { + _dlgResolve = resolve; + $('prompt-title').textContent = title || '请输入'; + const inp = $('prompt-input'); + inp.placeholder = placeholder || ''; + inp.value = initial || ''; + inp.type = opts && opts.type ? opts.type : 'text'; + $('prompt-modal').classList.remove('hidden'); + setTimeout(() => inp.focus(), 60); + }); + } + function promptOk() { _dlgSettle($('prompt-input').value); } + function promptCancel() { _dlgSettle(null); } + $('prompt-input').addEventListener('keydown', e => { + if (e.key === 'Enter') { e.preventDefault(); promptOk(); } + }); + + // ---------- 页面栈与顶栏 ---------- + function setTop() { return SET.stack[SET.stack.length - 1] || 'home'; } + function setUnderHide() { + const u = $('set-under'); + u.classList.remove('show'); u.innerHTML = ''; + } + function showSettings() { + SET.stack = ['home']; SET.snaps = {}; setUnderHide(); + // 桌面端:打开设置时收起侧边栏让设置页占满窗口,关闭时恢复之前的展开态 + if (drawerMQ.matches) { drawerWasOpenBeforeSet = document.body.classList.contains('drawer-open'); openDrawer(false); } + $('settings-page').classList.remove('hidden'); renderSetPage(); + } + let drawerWasOpenBeforeSet = false; + function closeSettings() { + SET.stack = []; SET.snaps = {}; setUnderHide(); + // 退回会话页才重置模型池状态:平台卡全部折叠、余额清空,下次进入重新自动查 + SET.expandedGroups = {}; SET.balanceByGroup = {}; SET.balanceRequested = {}; + $('settings-page').classList.add('hidden'); + if (drawerMQ.matches && drawerWasOpenBeforeSet) { openDrawer(true); drawerWasOpenBeforeSet = false; } + } + // 当前页静态快照(顶栏+正文):右滑返回时垫底,呈现原生导航栈的视差感。 + // 快照里的 id 全部剥除,防止重复 id 干扰 $('…') 查找;仅作动画背景,滑完由 renderSetPage 重渲染真页。 + function snapSetPage() { + const box = document.createElement('div'); + box.innerHTML = '
' + + '
' + esc($('set-title').textContent) + '
' + + '
' + $('set-actions').innerHTML + '
' + + '
' + $('set-body').innerHTML + '
'; + box.querySelectorAll('[id]').forEach(el => el.removeAttribute('id')); + return box.innerHTML; + } + function setPush(p) { + const prev = setTop(); + if (prev) SET.snaps[prev] = snapSetPage(); // 垫底快照跟随最新渲染结果刷新 + SET.stack.push(p); renderSetPage(); + } + function setPopRaw() { SET.stack.pop(); renderSetPage(); } + function onSetBack() { + const p = setTop(); + if (p === 'skill-editor') return sUI.closeEditor(); + if (p === 'cfg-editor') return sUI.closeCfg(); + if (SET.stack.length > 1) setPopRaw(); else closeSettings(); + } + $('set-back-btn').addEventListener('click', onSetBack); + + // 设置区任意页内:从左向右滑 → 返回上级(等同顶栏返回:子页弹栈/主页收起设置)。 + // 可编辑控件(输入框/文本域/下拉/启停开关)上不发起;方向锁定后才接管(不抢纵向滚动)。 + // 子页返回:只平移当前页层,底下垫父页静态快照(原生导航栈观感); + // 设置主页无父页:保持整层滑出,底下露出的就是主聊天页,观感本就正确。 + (function bindSettingsBackSwipe() { + const page = $('settings-page'); + const topLayer = $('set-top'); + const under = $('set-under'); + let g = null; // {x0,y0,t0,horiz,off,under} + let exiting = false; // 右滑退场动画中:忽略新触摸 + function blocked() { + if (exiting || page.classList.contains('hidden')) return true; + if ($('drawer').classList.contains('open')) return true; + return !!document.querySelector('.modal-overlay:not(.hidden)'); + } + page.addEventListener('touchstart', e => { + if (blocked() || e.touches.length !== 1) { g = null; return; } + if (e.target.closest('textarea, input, select, .model-en-sw')) { g = null; return; } + const t = e.touches[0]; + page.style.transition = ''; + topLayer.style.transition = ''; + g = { x0: t.clientX, y0: t.clientY, t0: Date.now(), horiz: false, off: 0, under: false }; + }, { passive: true }); + page.addEventListener('touchmove', e => { + if (!g) return; + const t = e.touches[0]; + const dx = t.clientX - g.x0, dy = t.clientY - g.y0; + if (!g.horiz) { + if (Math.abs(dx) < 8 && Math.abs(dy) < 8) return; // 方向未定,等待 + if (Math.abs(dy) >= Math.abs(dx)) { g = null; return; } // 纵向滚动,不接管 + g.horiz = true; + // 子页且父页快照存在(setPush 时已刷新) → 垫底,后续只平移当前页层 + const par = SET.stack[SET.stack.length - 2]; + if (par && SET.snaps[par]) { + g.under = true; + under.innerHTML = SET.snaps[par]; + under.classList.add('show'); + } + } + e.preventDefault(); // 横向手势归返回:屏蔽滚动/选择 + const tgt = g.under ? topLayer : page; + const w = page.offsetWidth || 360; + g.off = Math.max(0, Math.min(dx, w)); + tgt.style.transform = 'translateX(' + g.off + 'px)'; + tgt.style.opacity = String(1 - 0.25 * (g.off / w)); + }, { passive: false }); + function end(commit) { + if (!g) return; + const tgt = g.under ? topLayer : page; + const w = page.offsetWidth || 360; + const dist = g.horiz ? g.off : 0; + const dt = Date.now() - g.t0; + const speed = dt > 0 ? dist / dt : 0; + const back = commit && g.horiz && (dist >= 60 || dist / w >= 0.3 || (dist >= 24 && speed > 0.8)); + g = null; + if (back) { + // 先滑出再执行与顶栏一致的返回(编辑器页会路由到放弃确认) + exiting = true; + tgt.style.transition = 'transform .16s ease-in, opacity .16s ease-in'; + tgt.style.transform = 'translateX(100%)'; + tgt.style.opacity = '0'; + setTimeout(() => { + onSetBack(); // 重渲染父页,替换垫底快照 + tgt.style.transition = 'none'; + tgt.style.transform = ''; + tgt.style.opacity = ''; + setUnderHide(); + exiting = false; + }, 160); + } else { + tgt.style.transition = 'transform .18s ease-out, opacity .18s ease-out'; + tgt.style.transform = ''; + tgt.style.opacity = ''; + setTimeout(() => { if (!g && !exiting) tgt.style.transition = ''; setUnderHide(); }, 200); + } + } + page.addEventListener('touchend', () => end(true), { passive: true }); + page.addEventListener('touchcancel', () => end(false), { passive: true }); + })(); + + function setTitle(t) { $('set-title').textContent = t; } + function setActions(html) { $('set-actions').innerHTML = html || ''; } + function setBody(html) { $('set-body').innerHTML = html; } + + function renderSetPage() { + const tok = ++setTok; + const p = setTop(); + const ctx = () => tok === setTok && setTop() === p; // 异步回包时页面可能已切走 + if (p === 'home') return setPageHome(ctx); + if (p === 'account') return setPageAccount(ctx); + if (p === 'service') return setPageService(ctx); + if (p === 'cfg-editor') return setPageCfgEditor(ctx); + if (p === 'skills') return setPageSkills(ctx); + if (p === 'skill-detail') return setPageSkillDetail(ctx); + if (p === 'skill-editor') return setPageSkillEditor(ctx); + if (p === 'models') return setPageModels(ctx); + if (p === 'mcp') return setPageMcp(ctx); + } + // 主页卡片跳转与配置表单脏值标红(容器常驻,各自委托一次) + $('set-body').addEventListener('click', e => { + const card = e.target.closest('.set-card'); + if (card && card.dataset.go) setPush(card.dataset.go); + }); + $('set-body').addEventListener('input', e => { + const inp = e.target; + if (inp.classList && inp.classList.contains('cfg-input')) { + inp.classList.toggle('cfg-dirty', inp.value.trim() !== inp.dataset.orig); + } + }); + + // ---------- 页:设置主页(卡片入口) ---------- + const SET_CARDS = [ + { go: 'account', name: '账户', desc: '修改密码 · 退出登录', + icon: '' }, + { go: 'service', name: '服务', desc: '服务状态 · 系统配置', + icon: '' }, + { go: 'skills', name: '技能', desc: '技能管理 · 技能文件编辑', + icon: '' }, + { go: 'models', name: '模型', desc: '模型池状态 · 增删改', + icon: '' }, + { go: 'mcp', name: 'MCP', desc: 'MCP 服务 · 增删改', + icon: '' }, + ]; + function setPageHome(ctx) { + setTitle('设置'); + setActions(''); + setBody('
' + SET_CARDS.map(c => + '').join('') + '
'); + } + + // ---------- 页:账户(修改密码 / 退出登录) ---------- + const AVATAR_COLORS = ['#4285F4', '#EA4335', '#FBBC05', '#34A853', '#5C6BC0', '#00897B', '#8E24AA', '#F4511E']; + function userInitials(name) { + const s = String(name || '').trim(); + if (!s) return '?'; + const two = s.slice(0, 2); + return two.charAt(0).toUpperCase() + (two.length > 1 ? two.charAt(1).toLowerCase() : ''); + } + function avatarColor(name) { + let h = 0; + for (const ch of String(name || '')) h = (h * 31 + ch.codePointAt(0)) >>> 0; + return AVATAR_COLORS[h % AVATAR_COLORS.length]; + } + // 侧边栏底部用户区:展示真实登录用户名,头像样式与设置页 user-card 一致(按用户名取色+首两字)。 + // 启动校验已经拉到登录用户时直接传入,避免同一次加载重复请求 /api/me;未传入时自拉兜底。 + async function loadDrawerUser(knownUser) { + const av = $('drawer-avatar'), un = $('drawer-user-name'); + if (!av || !un) return; + let name = knownUser ? String(knownUser) : ''; + if (!name) { + try { + const r = await req('GET', '/api/me'); + name = r && r.user ? String(r.user) : ''; + } catch (_) { return; /* 未启用认证时无 /api/me,保留默认占位 */ } + } + if (!name) return; // 未登录态(理论上不会出现,401 已自动跳登录页) + av.textContent = userInitials(name); + av.style.background = avatarColor(name); + un.textContent = name; + } + function userCardHtml(me) { + return '
' + + '
' + esc(userInitials(me)) + '
' + + '
' + esc(me) + '
' + + '
' + + '' + + '' + + '
'; + } + async function setPageAccount(ctx) { + setTitle('账户'); + setActions(''); + setBody('
加载中…
'); + // 单个 /api/me 即可判认证开关:启用认证时中间件保证已登录,user 必有; + // 未启用时 createAuth 提前返回,该路由不存在 → 404。无需再拉 /api/system/status + let me; + try { + me = await req('GET', '/api/me'); + } catch (e) { + if (ctx()) setBody('
' + + (e.status === 404 ? '未启用登录认证,无账户设置。' : '加载失败:' + esc(e.message)) + '
'); + return; + } + if (!ctx()) return; + if (!me || !me.user) { + setBody('
未启用登录认证,无账户设置。
'); + return; + } + setBody('
' + userCardHtml(me.user) + '
'); + } + async function changePassword() { + try { + const newP = await promptModal('修改密码', '新密码,至少 6 位', '', { type: 'password' }); + if (newP == null) return; + if (newP.length < 6) { toast('新密码至少 6 位'); return; } + await req('POST', '/api/password', { new_password: newP }); + toast('密码已修改,立即生效'); + } catch (e) { toast('修改失败:' + e.message); } + } + + // ---------- 页:服务(服务状态 + 系统配置;搬自 settings.js) ---------- + const CFG_FORM = [ + { group: 'Agent 会话', items: [ + { path: 'agent.temperature', label: '温度 temperature', type: 'float' }, + { path: 'agent.max_tool_iterations', label: '单会话最大工具轮次', type: 'int' }, + { path: 'agent.max_retries', label: '上游失败重试次数', type: 'int' }, + { path: 'agent.language', label: '回复语言(留空不限)', type: 'text' }, + { path: 'agent.auto_compress_tokens', label: '自动压缩 In 阈值(0=关)', type: 'int' }, + ] }, + { group: '终端工具', items: [ + { path: 'terminal.default_timeout_ms', label: '命令默认超时(ms)', type: 'int' }, + { path: 'terminal.max_output_chars', label: '输出最大字符数', type: 'int' }, + ] }, + { group: '技能', items: [ + { path: 'skills.timeout_ms', label: '技能执行超时(ms)', type: 'int' }, + ] }, + { group: '图片上传压缩(浏览器端)', items: [ + { path: 'upload.image_compress_threshold_kb', label: '大图阈值(KB)', type: 'int' }, + { path: 'upload.image_max_dim', label: '压缩后长边上限(px)', type: 'int' }, + { path: 'upload.image_quality', label: 'JPEG 质量(0~1)', type: 'float' }, + ] }, + { group: '模型租约(会话结束后的保持)', items: [ + { path: 'model_hold.idle_release_ms', label: '无人观看释放(ms)', type: 'int' }, + { path: 'model_hold.active_max_ms', label: '最长保持(ms)', type: 'int' }, + { path: 'model_hold.sweep_ms', label: '巡检间隔(ms)', type: 'int' }, + ] }, + ]; + function kvPlain(label, v) { + return '
' + esc(dispVal(v)) + '
'; + } + function svcCardHtml(st) { + let html = '

服务状态' + + (SET.pendingKeys.size ? ' 待重启生效' : '') + '

'; + html += kvPlain('版本 / Node', st.version + ' / ' + st.node); + html += kvPlain('已运行', fmtUptime(st.uptime_ms) + '(启动于 ' + new Date(st.started_at).toLocaleString() + ')'); + html += kvPlain('端口', st.port); + html += kvPlain('配置文件', st.config_path); + html += kvPlain('工作区', st.workspace_root); + html += kvPlain('数据目录', st.data_root); + html += kvPlain('技能目录', st.skills_root); + html += kvPlain('命令执行', st.executor_url ? st.executor_url + '(远端)' : '本地'); + if (SET.pendingKeys.size) html += kvPlain('待生效改动', Array.from(SET.pendingKeys).join(', ')); + html += '' + + '
配置改动重启后生效;重启约需十几秒,期间页面暂不可用。非 Docker 部署不会自动拉起。
'; + return html; + } + function cfgInputHtml(it) { + const cur = getByPath(SET.effCfg, it.path); + const v = cur == null ? '' : String(cur); + if (it.type === 'text') { + return '
' + + '
'; + } + const step = it.type === 'float' ? ' step="any"' : ' step="1"'; + return '
' + + '
'; + } + function formCardHtml() { + let html = ''; + for (const g of CFG_FORM) { + html += '

' + esc(g.group) + '

'; + html += g.items.map(cfgInputHtml).join(''); + html += '
'; + } + html += '' + + '
更新即写入 config.yml(注释保留);多数配置需重启服务后生效。' + + '模型、账号、MCP 等请用右上角配置文件编辑。
'; + return html; + } + async function setPageService(ctx) { + setTitle('服务'); + setActions(''); + setBody('
加载中…
'); + try { + const [st, cg] = await Promise.all([ + req('GET', '/api/system/status'), + req('GET', '/api/config'), + ]); + if (!ctx()) return; + SET.effCfg = cg.effective || {}; + const el = $('svc-body'); + if (el) el.innerHTML = svcCardHtml(st) + formCardHtml(); + } catch (e) { + if (ctx()) setBody('
加载失败:' + esc(e.message) + '
'); + } + } + // 表单保存:收集与打开时不同的项,逐项 PATCH(搬自 settings.js saveForm) + async function saveForm() { + const inputs = document.querySelectorAll('#set-body .cfg-input'); + const edits = []; + for (const inp of inputs) { + const v = inp.value.trim(); + if (v === inp.dataset.orig) continue; + let val = v; + if (inp.dataset.type === 'int' || inp.dataset.type === 'float') { + val = Number(v); + if (v === '' || !isFinite(val)) { toast('「' + inp.dataset.label + '」需填数字'); return; } + if (inp.dataset.type === 'int' && !Number.isInteger(val)) { toast('「' + inp.dataset.label + '」需为整数'); return; } + } + edits.push({ path: inp.dataset.path, value: val }); + } + if (!edits.length) { toast('没有改动'); return; } + const btn = $('cfg-save-btn'); + if (btn) btn.disabled = true; + let lastChanged = []; + try { + for (const e of edits) { + const r = await req('PATCH', '/api/config', { path: e.path, value: e.value }); + lastChanged = r.changed || []; + lastChanged.forEach(k => SET.pendingKeys.add(k)); + } + toast('已保存 ' + edits.length + ' 项' + (lastChanged.length ? ',重启后生效' : '')); + } catch (e) { + toast('保存失败:' + e.message); + } finally { + if (btn) btn.disabled = false; + } + renderSetPage(); + } + // 重启服务(搬自 settings.js restart):确认弹窗 + 执行。可复用部分拆为 restartNow(模型池「重启服务」横幅按钮直用)。 + async function restart() { + if (!await confirmModal('重启服务', '重启服务使新配置生效?正在执行的 AI 会话会被打断。', '重启')) return; + await restartNow(); + } + async function restartNow() { + try { + await req('POST', '/api/system/restart'); + } catch (e) { + // 仅「有会话在跑」值得二次确认强打;配置不合法等 409 强打也无法启动,直接报给用户 + if (e.status === 409 && /个任务.*执行中/.test(e.message)) { + if (!await confirmModal('有任务在跑', e.message, '强制重启', true)) return; + try { await req('POST', '/api/system/restart?force=true'); } + catch (e2) { toast('重启失败:' + e2.message); return; } + } else { toast('重启失败:' + e.message); return; } + } + const btn = $('restart-btn'); + if (btn) { btn.disabled = true; btn.textContent = '重启中,请勿关闭页面…'; } + toast('服务重启中…'); + for (let i = 0; i < 90; i++) { + await sleep(1000); + try { const r = await fetch('/api/health'); if (r.ok) { location.reload(); return; } } catch (_) {} + } + toast('90 秒内未恢复,请检查容器状态(非 Docker 部署需手动启动)'); + if (btn) { btn.disabled = false; btn.textContent = '重启服务'; } + } + + // ---------- 页:config.yml 原文编辑器(搬自 settings.js) ---------- + function openCfgEditor() { setPush('cfg-editor'); } + async function setPageCfgEditor(ctx) { + setTitle('config.yml 原文'); + setActions(''); + setBody('
' + + '
'); + try { + const cg = await req('GET', '/api/config'); + if (!ctx()) return; + SET.cfgOrig = cg.text; + $('set-editor-area').value = cg.text; + } catch (e) { + // 读取失败不能留下空编辑器:保存会把空文本写回配置,改展示错误态 + if (ctx()) setBody('
读取失败:' + esc(e.message) + '
'); + } + } + async function saveCfg() { + const area = $('set-editor-area'); + if (!area) { toast('配置未加载'); return; } + const text = area.value; + const errEl = $('cfg-editor-err'); + if (errEl) errEl.classList.add('hidden'); + try { + await req('POST', '/api/config/validate', { text }); // 先干跑,错误信息更友好 + const r = await req('PUT', '/api/config', { text }); + SET.cfgOrig = text; + (r.changed || []).forEach(k => SET.pendingKeys.add(k)); + toast('配置已保存'); + setPopRaw(); // 保存成功直接退出编辑页,回服务页即刷新生效值展示 + } catch (e) { + if (errEl) { errEl.textContent = '校验失败:' + e.message; errEl.classList.remove('hidden'); } + toast('配置不合法,未写入'); + } + } + async function closeCfg() { + const area = $('set-editor-area'); + if (area && area.value !== SET.cfgOrig && + !await confirmModal('未保存的修改', '有未保存的修改,确定关闭并丢弃?', '关闭', true)) return; + setPopRaw(); + } + + // ---------- 页:技能(列表/详情/文件编辑;搬自 skills.js) ---------- + async function setPageSkills(ctx) { + SET.curSkill = null; + setTitle('技能管理'); + setActions(''); + setBody('
加载中…
'); + try { + const rows = await req('GET', '/api/skills'); + if (!ctx()) return; + const el = $('skills-list'); + if (!el) return; + if (!rows.length) { + el.innerHTML = '
还没有技能,点右上角 + 新建一个。
'; + return; + } + el.innerHTML = rows.map(s => { + const a = encodeURIComponent(s.name); + return '
' + + '
' + + '
' + esc(s.name) + + (s.has_md ? '' : ' 缺 SKILL.md') + + (s.entry ? ' ' + s.entry + ' 入口' : '') + + '
' + + '
' + esc(s.description || '') + '
' + + '
' + s.file_count + ' 个文件' + + '' + fmtSize(s.size) + '' + + (s.mtime ? '' + fmtTime(s.mtime) + '' : '') + '
' + + '
' + + '
' + + '' + + '' + + '
' + + '
'; + }).join(''); + } catch (e) { + if (ctx()) setBody('
加载失败:' + esc(e.message) + '
'); + } + } + async function openSkill(nameEnc) { + SET.curSkill = decodeURIComponent(nameEnc); + setPush('skill-detail'); + } + async function setPageSkillDetail(ctx) { + if (!SET.curSkill) { if (SET.stack.length > 1) setPopRaw(); return; } + setTitle(SET.curSkill); + setActions(''); + setBody('
加载中…
'); + try { + const d = await req('GET', '/api/skills/' + encodeURIComponent(SET.curSkill)); + if (!ctx()) return; + setTitle(d.name); + const el = $('skill-detail'); + if (!el) return; + const newBtn = ''; + if (!d.files.length) { + el.innerHTML = '
技能目录是空的
' + newBtn; + return; + } + el.innerHTML = '
' + d.files.map(f => { + const a = encodeURIComponent(f.filename); + return '
' + + '' + + '' + esc(f.filename) + '' + + '' + fmtSize(f.size) + '' + + '' + + '' + + '
'; + }).join('') + '
' + newBtn; + } catch (e) { + if (ctx()) setBody('
加载失败:' + esc(e.message) + '
'); + } + } + function setPageSkillEditor(ctx) { + setTitle(SET.editorLabel || '编辑文件'); + setActions(''); + setBody('
'); + $('set-editor-area').value = SET.editorText; + } + async function openSkillFile(pathEnc) { + const rel = decodeURIComponent(pathEnc); + try { + const f = await req('GET', '/api/skills/' + encodeURIComponent(SET.curSkill) + '/file?path=' + encodeURIComponent(rel)); + SET.editorPath = f.path; SET.editorOrig = f.content; + SET.editorText = f.content; + SET.editorLabel = SET.curSkill + ' / ' + f.path; + setPush('skill-editor'); + } catch (e) { toast('打开失败:' + e.message); } + } + async function newSkillFile() { + if (!SET.curSkill) return; + const p = await promptModal('新建文件', '相对技能目录的路径,可含子目录(如 scripts/run.sh)', ''); + if (p == null) return; + const rel = p.trim(); + if (!rel) { toast('路径为空'); return; } + SET.editorPath = rel; SET.editorOrig = ''; + SET.editorText = ''; + SET.editorLabel = SET.curSkill + ' / ' + rel + '(新建)'; + setPush('skill-editor'); + } + async function saveSkillFile() { + if (!SET.curSkill || SET.editorPath == null) return; + const content = $('set-editor-area').value; + try { + await req('PUT', '/api/skills/' + encodeURIComponent(SET.curSkill) + '/file', { path: SET.editorPath, content }); + SET.editorOrig = content; + toast('已保存 ' + SET.editorPath); + SET.editorPath = null; + setPopRaw(); // 保存成功直接退出编辑页,回详情即刷新文件列表 + } catch (e) { toast('保存失败:' + e.message); } + } + async function closeSkillEditor() { + const area = $('set-editor-area'); + if (area && area.value !== SET.editorOrig && + !await confirmModal('未保存的修改', '有未保存的修改,确定关闭编辑器并丢弃?', '关闭', true)) return; + SET.editorPath = null; SET.editorOrig = ''; SET.editorText = ''; + setPopRaw(); + } + async function deleteSkillFile(pathEnc) { + const rel = decodeURIComponent(pathEnc); + if (!await confirmModal('删除文件', '删除文件 ' + rel + ' ?', '删除', true)) return; + try { + await req('DELETE', '/api/skills/' + encodeURIComponent(SET.curSkill) + '/file?path=' + encodeURIComponent(rel)); + toast('已删除'); + renderSetPage(); + } catch (e) { toast('删除失败:' + e.message); } + } + // 单文件上传;重名默认 409,询问后带 overwrite 重试(搬自 skills.js) + async function uploadSkillFile(ev) { + const input = ev.target; + const file = input.files && input.files[0]; + input.value = ''; + if (!file || !SET.curSkill) return; + const send = async function (overwrite) { + const fd = new FormData(); + fd.append('file', file); + return req('POST', '/api/skills/' + encodeURIComponent(SET.curSkill) + '/upload' + (overwrite ? '?overwrite=true' : ''), fd, true); + }; + try { + await send(false); + toast('已上传 ' + file.name); + } catch (e) { + if (/已存在/.test(e.message)) { + if (!await confirmModal('文件已存在', file.name + ' 已存在,覆盖?', '覆盖')) return; + try { await send(true); toast('已覆盖 ' + file.name); } + catch (e2) { toast('上传失败:' + e2.message); } + } else { + toast('上传失败:' + e.message); + } + } + renderSetPage(); + } + function openCreateSkill() { + $('skill-new-name').value = ''; + $('skill-new-desc').value = ''; + $('skill-create-modal').classList.remove('hidden'); + $('skill-new-name').focus(); + } + function closeCreateSkill() { $('skill-create-modal').classList.add('hidden'); } + async function createSkill() { + const name = $('skill-new-name').value.trim(); + if (!name) { toast('请填写技能名'); return; } + try { + await req('POST', '/api/skills', { name, description: $('skill-new-desc').value.trim() }); + closeCreateSkill(); + toast('已创建 ' + name); + SET.curSkill = name; + setPush('skill-detail'); // 新建后直接进详情,方便继续编辑 SKILL.md + } catch (e) { toast('创建失败:' + e.message); } + } + async function renameSkill(nameEnc) { + const name = nameEnc ? decodeURIComponent(nameEnc) : SET.curSkill; + if (!name) return; + const nn = await promptModal('重命名技能', '新的技能名', name); + if (nn == null) return; + const newName = nn.trim(); + if (!newName || newName === name) return; + try { + await req('POST', '/api/skills/' + encodeURIComponent(name) + '/rename', { newName }); + toast('已重命名为 ' + newName); + if (SET.curSkill === name) SET.curSkill = newName; + renderSetPage(); + } catch (e) { toast('重命名失败:' + e.message); } + } + async function deleteSkill(nameEnc) { + const name = nameEnc ? decodeURIComponent(nameEnc) : SET.curSkill; + if (!name) return; + if (!await confirmModal('删除技能', '确定删除技能「' + name + '」?目录下所有文件将不可恢复。', '删除', true)) return; + try { + await req('DELETE', '/api/skills/' + encodeURIComponent(name)); + toast('已删除 ' + name); + if (SET.curSkill === name) SET.curSkill = null; + if (setTop() === 'skill-detail') setPopRaw(); else renderSetPage(); + } catch (e) { toast('删除失败:' + e.message); } + } + + // ---------- 页:模型池(状态 + 增/改/删;搬自 models.js) ---------- + // api_key 脱敏显示兼容后端已脱敏结果(幂等) + function maskKey(k) { + k = k || ''; + if (k.includes('***')) return k; + if (k.length > 8) return k.slice(0, 3) + '***' + k.slice(-4); + if (k.length > 0) return '***' + k.slice(-2); + return ''; + } + // token 用量紧凑显示:<1000 原样;k(1 位小数去尾零);≥1M 用 M + function fmtTok(n) { + n = Number(n) || 0; + if (n < 1000) return String(n); + if (n < 1000000) { const v = (n / 1000).toFixed(1).replace(/\.0$/, ''); return v + 'k'; } + const v = (n / 1000000).toFixed(1).replace(/\.0$/, ''); + return v + 'M'; + } + function balText(gk) { + const b = SET.balanceByGroup[gk]; + if (!b) return '余额 --'; + if (b.error) return '余额 查询失败'; + return '余额 ' + (b.total_balance == null ? '--' : b.total_balance) + (b.currency ? ' ' + esc(b.currency) : ''); + } + function balTitle(gk) { + const b = SET.balanceByGroup[gk]; + if (!b) return ''; + if (b.error) return '查询失败:' + b.error; + const parts = []; + if (b.available === false) parts.push('上游报告余额不可用'); + if (b.granted_balance != null) parts.push('赠送 ' + b.granted_balance); + if (b.topped_up_balance != null) parts.push('充值 ' + b.topped_up_balance); + return parts.join(' · '); + } + async function fetchBalance(gk, pi, ki, manual) { + SET.balanceRequested[gk] = true; // 无论成败,本页会话不再自动重查(手动刷新不受限) + const btn = $('mbrg-' + gk); + if (btn) btn.classList.add('spin'); + const el = $('mbal-' + gk); + if (el) el.textContent = '余额 …'; + try { + const r = await req('GET', '/api/platforms/balance?pi=' + pi + '&ki=' + ki); + const b = r.balance || {}; + SET.balanceByGroup[gk] = { + total_balance: b.total_balance, currency: b.currency, + granted_balance: b.granted_balance, topped_up_balance: b.topped_up_balance, + available: b.is_available, + }; + } catch (e) { + SET.balanceByGroup[gk] = { error: e.message }; + if (manual) toast('查余额失败:' + e.message); // 自动查询失败只落悬停详情,不打扰 + } + if (btn) btn.classList.remove('spin'); + const el2 = $('mbal-' + gk); + if (el2) { el2.textContent = balText(gk); el2.title = balTitle(gk); } + } + // 点刷新图标:无视「本页已查过」标记,总是重新请求 + function refreshBalance(ev, pi, ki) { + if (ev) ev.stopPropagation(); // 冒泡到分组头会误触折叠/展开 + fetchBalance(pi + '-' + ki, pi, ki, true); + } + const BAL_REFRESH_SVG = ''; + // 平台卡折叠/展开(gk = 'p'+pi)。首次展开:给该平台每个 Key 行自动查一次余额(每页会话一次;手动刷新不受限)。 + function toggleModelGroup(gk) { + const on = !SET.expandedGroups[gk]; + SET.expandedGroups[gk] = on; + const el = $('mgrp-' + gk); + if (!el) return; + el.classList.toggle('open', on); + const body = el.querySelector('.model-group-body'); + if (body) body.classList.toggle('hidden', !on); + if (on) { + const pi = Number(gk.slice(1)); + const p = SET.cfgPlatforms[pi] || {}; + if (SET.balanceTypes.indexOf(String(p.type || '')) >= 0) { + (p.keys || []).forEach((k, ki) => { + const bk = pi + '-' + ki; + if (!SET.balanceRequested[bk] && $('mbal-' + bk)) fetchBalance(bk, pi, ki, false); + }); + } + } + } + // 启停切换:写 platforms[pi].models[mi].enable(缺省启用),重启后生效。 + // 重启前后端 effective 仍返旧值,成功后本地记入 SET.pendingEnable 保持卡片显示不回弹。 + async function toggleModelEnable(rawId) { + const m = SET.cfgModels[idxOf(decodeURIComponent(rawId))]; + if (!m) return toast('模型不存在'); + const next = m.enable === false; // 当前禁用 → 目标启用 + try { + // 与 key 解耦:所有 key 共享同一份 models,enable 改在平台层 + await req('PATCH', '/api/config', { path: ['platforms', m.platform_index, 'models', m.model_index, 'enable'], value: next }); + // 本地同步:同 id 的所有副本都更新 + for (const x of SET.cfgModels) if (x.id === m.id) x.enable = next; + SET.pendingEnable[m.id] = next; + afterWrite(); + } catch (e) { + toast('切换失败:' + e.message); + loadModelCards(); // 失败时重拉,回滚开关显示 + } + } + // 单个模型卡;点击整卡弹所属平台的编辑弹窗(enable 开关点击不冒泡)。余额是 Key 级概念,在卡体顶部按 Key 分行。 + function modelCardHtml(m, pi) { + const run = SET.runtimeById[m.id]; + const disabled = m.enable === false; + // 运行池里没有 = 配置新增但还没重启生效;禁用后若仍在池里(未重启)也提示待重启 + const stateHtml = disabled + ? (run + ? '待重启' + : '已禁用') + : run + ? '' + (run.is_busy ? '占用中' : '空闲') + '' + : '待重启'; + return '
' + + '
' + + '' + esc(m.display_name || m.mid || m.id) + '' + + '' + esc(m.mid || m.id) + + (run && run.is_busy && run.current_session_id ? ' · 会话 ' + esc(run.current_session_id) : '') + '' + + stateHtml + + '' + + '
' + + '
' + (run ? fmtTok(run.today_prompt) + ' / ' + fmtTok(run.today_completion) : '--') + '
' + + '
' + (run ? fmtTok(run.total_prompt) + ' / ' + fmtTok(run.total_completion) : '--') + '
' + + '
' + + (run && run.total_prompt ? fmtTok(run.total_cached || 0) + ' · ' + Math.round((run.total_cached || 0) / run.total_prompt * 100) + '%' : '--') + + '
' + + '
'; + } + // 平台卡:头部 = 平台名 + N keys 徒章 + 启用/总数模型数;体内 = 每 Key 一行余额(仅已接入类型)+ 该平台模型列表。 + // models 从打平 cfgModels 取首份 key 副本(已含 deletedModels/pendingEnable 过滤)。 + function modelGroupHtml(pi) { + const p = SET.cfgPlatforms[pi] || {}; + const keys = p.keys || []; + const models = []; + const seen = new Set(); + for (const m of SET.cfgModels) { + if (m.platform_index === pi && !seen.has(m.id)) { seen.add(m.id); models.push(m); } + } + const gk = 'p' + pi; + const open = !!SET.expandedGroups[gk]; + // 仅已接入余额查询的类型显示余额行(未接入的显示出来也只会是报错,不如不显示) + const hasBal = SET.balanceTypes.indexOf(String(p.type || '')) >= 0; + const balHtml = hasBal ? keys.map((k, ki) => { + const bk = pi + '-' + ki; + return '
' + + '' + esc(k.api_key ? maskKey(k.api_key) : '无 key') + '' + + '' + balText(bk) + '' + + '' + + '
'; + }).join('') : ''; + return '
' + + '
' + + '' + + '' + esc(p.name || ('平台' + pi)) + '' + + '' + keys.length + ' keys' + + '' + models.filter(m => m.enable !== false).length + ' / ' + models.length + ' 模型' + + '
' + + '
' + + balHtml + + (models.length ? models.map(m => modelCardHtml(m, pi)).join('') : '
该平台暂无模型
') + + '
' + + '
'; + } + async function loadModelCards(ctx) { + const el = $('model-cards'); + if (!el || (ctx && !ctx())) return; + try { + const [rt, cg] = await Promise.all([req('GET', '/api/models'), req('GET', '/api/config')]); + if (ctx && !ctx()) return; + if (!$('model-cards')) return; // 异步期间已离开本页 + SET.runtimeById = {}; + for (const m of rt || []) SET.runtimeById[m.id] = m; + SET.cfgPlatforms = (cg.effective && cg.effective.platforms) || []; + SET.cfgModels = (cg.effective && cg.effective.models) || []; + // 已删除/已改名旧 id 的标记清理:配置(live)与运行池都已无此 id 才清——重启前池里残留时须保留标记, + // 否则会话页选择弹窗(读 /api/models 运行池)会重新列出已不可用的模型。 + const liveIds = new Set(SET.cfgModels.map(m => m.id)); + const poolIds = new Set((rt || []).map(m => m.id)); + for (const id of Object.keys(SET.deletedModels)) if (!liveIds.has(id) && !poolIds.has(id)) delete SET.deletedModels[id]; + SET.cfgModels = SET.cfgModels.filter(m => !SET.deletedModels[m.id]); + // 重启前 effective 仍是旧配置:叠加已写盘的启停结果,保证卡片显示与已保存配置一致 + for (const m of SET.cfgModels) if (m.id in SET.pendingEnable) m.enable = SET.pendingEnable[m.id]; + SET.balanceTypes = cg.balance_types || []; + const box = $('model-cards'); + if (!SET.cfgModels.length) { + box.innerHTML = '
尚未配置模型,点右上角 + 添加平台。
'; + return; + } + let html = ''; + SET.cfgPlatforms.forEach((p, pi) => { html += modelGroupHtml(pi); }); + // 有待重启的变更:列表顶部常驻「重启服务」横幅(增/改/删模型、启停开关、平台弹窗保存均经 afterWrite 置位) + box.innerHTML = (SET.modelsPendingRestart + ? '
配置已写入,重启后生效
' + : '') + html + + '
token 显示格式为「输入 / 输出」。
'; + } catch (e) { + const box = $('model-cards'); + if (box && (!ctx || ctx())) box.innerHTML = '
加载失败:' + esc(e.message) + '
'; + } + } + function setPageModels(ctx) { + setTitle('模型池'); + setActions(''); + setBody('
加载中…
'); + // 余额与展开态跨设置内导航保持(仅 closeSettings 回会话页时重置),重进本页不重复查余额 + loadModelCards(ctx); + } + function idxOf(id) { + for (let i = 0; i < SET.cfgModels.length; i++) if (SET.cfgModels[i].id === id) return i; + return -1; + } + function afterWrite() { + SET.modelsPendingRestart = true; + SET.balanceByGroup = {}; // 配置变了,旧余额不再对应现有 pi/ki 槽位 + SET.balanceRequested = {}; + toast('已写入 config.yml,到「服务」页重启后生效'); + loadModelCards(); + } + // ---------- 平台编辑/新增弹窗(共用一套 UI 与渲染) ---------- + // pfEdit 工作态:keys/models 行数组;ref=null 为弹窗新增行,ref=原配置下标(仅保存时算 diff 用)。 + // 保存 = 一次批量 PATCH(body.edits),服务端同一次读文/校验/写盘,原子生效。 + let pfEdit = null; + // 当前平台名下的去重模型列表(打平 cfgModels 取首份 key 副本,已含 deletedModels/pendingEnable 过滤) + function platformModels(pi) { + const models = []; const seen = new Set(); + for (const m of SET.cfgModels) if (m.platform_index === pi && !seen.has(m.id)) { seen.add(m.id); models.push(m); } + return models; + } + function openModelEditor(pi) { + const add = pi == null; + const p = add ? {} : (SET.cfgPlatforms[pi] || {}); + pfEdit = { + idx: add ? -1 : Number(pi), + // 已有 Key:输入框置空(留空=保持原值),masked 存脱敏值仅做 placeholder 提示;绝不把脱敏值回写文件 + keys: add ? [] : (p.keys || []).map((k, ki) => ({ ref: ki, api_key: '', masked: k.api_key || '' })), + models: add ? [] : platformModels(pi).map(m => ({ ref: m.model_index, id: m.mid || m.id, vision: !!m.vision, enable: m.enable !== false })), + }; + $('mpe-title').textContent = add ? '新增平台' : '编辑平台'; + $('mpe-name').value = add ? '' : (p.name || ''); + $('mpe-url').value = add ? '' : (p.url || ''); + if (add) { pfEdit.keys.push({ ref: null, api_key: '' }); pfEdit.models.push({ ref: null, id: '', vision: false, enable: true }); } + $('mpe-del-btn').classList.toggle('hidden', add); + renderPfRows(); + $('model-edit-modal').classList.remove('hidden'); + } + // Key 行:全部可编辑。已有 Key 输入框置空 + placeholder 提示当前脱敏值,输入新值=替换,留空=保持。 + function pfKeysRowHtml(r, i) { + const ph = r.ref == null + ? 'API KEY' + : '当前: ' + (r.masked ? maskKey(r.masked) : '无 key'); + return '
' + + '' + + '' + + '
'; + } + // 模型子卡片两行:上行配 id,下行勾 vision/enable。id 可改(仅改 config.yml,重启生效)。 + // display_name/concurrency/type 不进弹窗:保存只按细粒度 path 改,不碰文件里其余字段。 + function pfModelsRowHtml(r, i) { + return '
' + + '
' + + '' + + '' + + '
' + + '
' + + '' + + '' + + '
' + + '
'; + } + // 行下标变化后需重渲染(事件处理器里捕获了旧 i),故增删后重建两段行列表。 + function renderPfRows() { + if (!pfEdit) return; + $('mpe-keys').innerHTML = pfEdit.keys.map(pfKeysRowHtml).join('') || '
至少保留一个 Key
'; + $('mpe-models').innerHTML = pfEdit.models.map(pfModelsRowHtml).join('') || '
至少保留一个模型
'; + } + function addPfKey() { if (!pfEdit) return; pfEdit.keys.push({ ref: null, api_key: '' }); renderPfRows(); } + function addPfModel() { if (!pfEdit) return; pfEdit.models.push({ ref: null, id: '', vision: false, enable: true }); renderPfRows(); } + function delPfKey(i) { + if (!pfEdit) return; + if (pfEdit.keys.length <= 1) return toast('至少保留一个 Key'); + pfEdit.keys.splice(i, 1); renderPfRows(); + } + function delPfModel(i) { + if (!pfEdit) return; + if (pfEdit.models.length <= 1) return toast('至少保留一个模型'); + pfEdit.models.splice(i, 1); renderPfRows(); + } + function setPfKey(i, f, v) { if (pfEdit && pfEdit.keys[i]) pfEdit.keys[i][f] = v; } + function setPfModel(i, f, v) { if (pfEdit && pfEdit.models[i]) pfEdit.models[i][f] = v; } + function closeModelEditor() { $('model-edit-modal').classList.add('hidden'); } + // 根据工作态算批量编辑:原地改(值变更项) → 删行(降序) → 新增行(append)。 + // YAML 数组删项后下标收紧,同批内删/改/增按原 ref 定位,服务端依次应用。 + function buildPfEdits() { + const p = SET.cfgPlatforms[pfEdit.idx]; + const edits = []; + const name = $('mpe-name').value.trim(); + const url = $('mpe-url').value.trim().replace(/\/+$/, ''); + if (name && name !== p.name) edits.push({ path: ['platforms', pfEdit.idx, 'name'], value: name }); + if (url && url !== p.url) edits.push({ path: ['platforms', pfEdit.idx, 'url'], value: url }); + // Key:已有行输入非空=替换 api_key(留空保持原值,避免把脱敏占位写回文件);新增行直接 append + pfEdit.keys.forEach(r => { + if (r.ref == null) { + edits.push({ op: 'append', path: ['platforms', pfEdit.idx, 'keys'], value: { api_key: String(r.api_key || '').trim() } }); + } else { + const nv = String(r.api_key || '').trim(); + if (nv) edits.push({ path: ['platforms', pfEdit.idx, 'keys', r.ref, 'api_key'], value: nv }); + } + }); + const delKeys = []; + for (let ki = 0; ki < (p.keys || []).length; ki++) { + if (!pfEdit.keys.some(r => r.ref === ki)) delKeys.push(ki); + } + delKeys.sort((a, b) => b - a).forEach(ki => edits.push({ op: 'delete', path: ['platforms', pfEdit.idx, 'keys', ki] })); + // 模型:已有行只按细粒度 path 改 vision/enable(不整体覆盖,保住文件里的 display_name/extra_params 等); + // 新增行 append 最小对象(缺省项不写:display_name 后端同 id,enable 缺省启用) + pfEdit.models.forEach(r => { + if (r.ref != null) { + const om = (p.models || [])[r.ref] || {}; + const nid = String(r.id || '').trim(); + if (nid && om.id && nid !== om.id) { + edits.push({ path: ['platforms', pfEdit.idx, 'models', r.ref, 'id'], value: nid }); + SET.deletedModels[p.name + '/' + om.id] = true; // 重启前运行池里旧 id 不再可绑,标记隐藏 + delete SET.deletedModels[p.name + '/' + nid]; // 改成曾被删的 id:清掉旧标记防误屏蔽 + } + if (!!om.vision !== !!r.vision) edits.push({ path: ['platforms', pfEdit.idx, 'models', r.ref, 'vision'], value: !!r.vision }); + if ((om.enable !== false) !== (r.enable !== false)) edits.push({ path: ['platforms', pfEdit.idx, 'models', r.ref, 'enable'], value: r.enable !== false }); + } else { + const id = String(r.id || '').trim(); + const nv = { id }; + if (r.vision) nv.vision = true; + if (r.enable === false) nv.enable = false; + edits.push({ op: 'append', path: ['platforms', pfEdit.idx, 'models'], value: nv }); + } + }); + const delMods = (p.models || []).map((_, i) => i).filter(i => !pfEdit.models.some(r => r.ref === i)).sort((a, b) => b - a); + delMods.forEach(mi => { SET.deletedModels[p.name + '/' + p.models[mi].id] = true; edits.push({ op: 'delete', path: ['platforms', pfEdit.idx, 'models', mi] }); }); + return edits; + } + async function saveModelEditor() { + if (!pfEdit) return; + const add = pfEdit.idx < 0; + const name = $('mpe-name').value.trim(); + const url = $('mpe-url').value.trim().replace(/\/+$/, ''); + if (!url) return toast('请填写平台上游地址'); + if (!pfEdit.models.length) return toast('至少保留一个模型'); + if (!pfEdit.keys.length) return toast('至少保留一个 Key'); + const idSet = new Set(); + for (const r of pfEdit.models) { + const id = String(r.id || '').trim(); + if (!id) return toast('模型 id 不能为空'); + if (idSet.has(id)) return toast('模型 id 重复:' + id); + idSet.add(id); + } + let edits; + try { + if (add) { + // 新增平台:一次 append 整个对象(name 留空由服务端取主机段;type/concurrency/display_name 均不落配置,走各自缺省) + edits = [{ op: 'append', path: ['platforms'], value: { + name, url, + keys: pfEdit.keys.map(r => ({ api_key: String(r.api_key || '').trim() })), + models: pfEdit.models.map(r => { + const id = String(r.id).trim(); + const nv = { id }; + if (r.vision) nv.vision = true; + if (r.enable === false) nv.enable = false; + return nv; + }), + } }]; + } else { + // 改名不影响 pi(数组位置);其余按原 ref 定位,见 buildPfEdits + edits = buildPfEdits(); + if (!edits.length) { closeModelEditor(); return toast('没有变更'); } + } + await req('PATCH', '/api/config', { edits }); + // 重加同名模型(重启前被标记隐藏的):清掉删除标记防误屏蔽 + const pname = name || (SET.cfgPlatforms[pfEdit.idx] || {}).name || ''; + if (!add) for (const r of pfEdit.models) if (r.ref == null) delete SET.deletedModels[pname + '/' + String(r.id || '').trim()]; + closeModelEditor(); + afterWrite(); // 列表顶部出现「重启服务」横幅按钮 + } catch (e) { toast('保存失败:' + e.message); } + } + // 删除整个平台:仅改 config.yml(一次 delete platforms[pi]),重启前列表已无它(effective 实时解析文件) + async function delPlatformFromModal() { + if (!pfEdit || pfEdit.idx < 0) return; + const pi = pfEdit.idx; + const p = SET.cfgPlatforms[pi] || {}; + closeModelEditor(); + const ok = await confirmModal('删除平台', '删除平台「' + (p.name || ('平台' + pi)) + '」及其全部 Key 与模型?此操作仅修改 config.yml。', '删除', true); + if (!ok) return; + try { + await req('PATCH', '/api/config', { path: ['platforms', pi], op: 'delete' }); + // 运行池重启前仍持有该平台的模型:标记隐藏,防会话页选择弹窗误绑 + for (const m of (p.models || [])) SET.deletedModels[p.name + '/' + m.id] = true; + afterWrite(); + } catch (e) { toast('删除失败:' + e.message); } + } + + // ---------- 页:MCP 服务(增/改/删;name / url / 多 headers / timeout_ms / enable) ---------- + // 与模型池共用 PATCH /api/config 的细粒度 edit 接口: + // · 新增 = append 到 mcp_servers; + // · 删 = delete mcp_servers[pi]; + // · 改 = setIn mcp_servers[pi].(name|url|timeout_ms|enable);headers 是普通键值对象,整体 setIn 一次到位。 + // 运行配置(cg.effective.mcp_servers)即文件刚解析后的视图,按 pi 直接定位;重启后才会重新发现工具。 + let mcpEdit = null; // 工作态:{ idx, headers:[{key, value, masked}] };idx=-1 为新增 + const MCP_HEADER_MASK = '*****'; // 与后端 routes/config.js 的掩码保持一致 + async function setPageMcp(ctx) { + setTitle('MCP 服务'); + setActions(''); + setBody('
加载中…
'); + await loadMcpList(ctx); + } + async function loadMcpList(ctx) { + const box = $('mcp-list'); + if (!box || (ctx && !ctx())) return; + try { + const cg = await req('GET', '/api/config'); + if (ctx && !ctx()) return; + if (!$('mcp-list')) return; + SET.cfgMcp = (cg.effective && cg.effective.mcp_servers) || []; + if (!SET.cfgMcp.length) { + box.innerHTML = (SET.mcpPendingRestart + ? '
配置已写入,重启后生效
' + : '') + '
尚未配置 MCP 服务,点右上角 + 添加。
'; + return; + } + const banner = SET.mcpPendingRestart + ? '
配置已写入,重启后生效
' + : ''; + box.innerHTML = banner + SET.cfgMcp.map(mcpCardHtml).join('') + + '
点卡片编辑 MCP 服务,启用后启动时发现其工具并追加到内置工具之后。
'; + } catch (e) { + const b = $('mcp-list'); + if (b && (!ctx || ctx())) b.innerHTML = '
加载失败:' + esc(e.message) + '
'; + } + } + // MCP 卡:头部 = 名称 + url + enable 状态;体内 = headers 键值列表。整卡点击进入编辑。 + function mcpCardHtml(s, pi) { + const off = s.enable === false; + const stateHtml = off ? '已禁用' : '启用'; + const entries = Object.entries(s.headers || {}); + // header 值等同密码对待:后端 effective 已脱敏为固定短掩码,这里透传展示;若收到未脱敏原文也一律替换,不外显 + const maskVal = (v) => { const str = String(v == null ? '' : v); if (!str) return '--'; return str.includes('*') ? esc(str) : MCP_HEADER_MASK; }; + const headersHtml = entries.length + ? entries.map(([k, v]) => '
' + maskVal(v) + '
').join('') + : '
--
'; + return '
' + + '
' + + '' + esc(s.name || ('MCP-' + pi)) + '' + + '' + esc(s.url || '') + '' + + stateHtml + + '
' + headersHtml + + '
'; + } + // 弹窗打开:add 模式 (idx=-1) → 空工作态;edit 模式 → 从当前配置复制。 + function openMcpEditor(idx) { + const add = idx == null; + const s = add ? {} : (SET.cfgMcp[idx] || {}); + mcpEdit = { + idx: add ? -1 : Number(idx), + // headers 数组:每个 {key, value, masked} 为一条编辑行。已有行 value 置空、masked 存当前脱敏值仅做提示 + // (同平台 Key 的留空=保持原值);新行 masked=null,必须手输真值。空 key 行保存时丢弃。 + headers: add + ? [{ key: '', value: '', masked: null }] + : Object.entries(s.headers || {}).map(([k, v]) => ({ key: k, value: '', masked: String(v) })), + }; + $('mce-title').textContent = add ? '添加 MCP 服务' : '编辑 MCP 服务'; + $('mce-name').value = add ? '' : (s.name || ''); + $('mce-url').value = add ? '' : (s.url || ''); + // 运行配置里的 timeout_ms 已被 config.js 填上缺省值,所以这里显示的就是当前生效值(没配则为 60000)。 + $('mce-timeout').value = add || s.timeout_ms == null ? '' : String(s.timeout_ms); + $('mce-enable').checked = add ? true : (s.enable !== false); + $('mce-del-btn').classList.toggle('hidden', add); + renderMcpHeaders(); + $('mcp-edit-modal').classList.remove('hidden'); + } + function closeMcpEditor() { $('mcp-edit-modal').classList.add('hidden'); } + // header 行:id 由 JS 运行时下标 i 拼接,避免与服务端 path 冲突 + function mcpHeaderRowHtml(r, i) { + // 已有行:输入框置空,placeholder 提示当前脱敏值;留空=保持原值,输入新值=替换 + const ph = r.masked != null ? '当前: ' + r.masked + '(留空保持不变)' : '值'; + return '
' + + '' + + '' + + '' + + '
'; + } + function renderMcpHeaders() { + if (!mcpEdit) return; + const box = $('mce-headers'); + if (!mcpEdit.headers.length) box.innerHTML = '
未配置 header
'; + else box.innerHTML = mcpEdit.headers.map(mcpHeaderRowHtml).join(''); + } + function addMcpHeader() { + if (!mcpEdit) return; + mcpEdit.headers.push({ key: '', value: '', masked: null }); + renderMcpHeaders(); + } + function delMcpHeader(i) { + if (!mcpEdit) return; + mcpEdit.headers.splice(i, 1); + renderMcpHeaders(); + } + function setMcpHeader(i, f, v) { if (mcpEdit && mcpEdit.headers[i]) mcpEdit.headers[i][f] = v; } + // 收集弹窗内的修改为批量 PATCH:服务端一次读文/写回/校验,原子生效。 + // headers 整体替换(简单可靠;键值对场景下增量 diff 收益小):空 key 行不写入。 + function buildMcpEdits() { + if (!mcpEdit) return []; + const edits = []; + const name = $('mce-name').value.trim(); + const url = $('mce-url').value.trim(); + const enable = $('mce-enable').checked; + // 超时:留空 = 不写入该项(沿用缺省 60s)。区间在 UI 先把一道, + // 比写进 YAML 再被 config.js 静默夹掉好排查(两边上限保持 600000 一致)。 + const tmoRaw = $('mce-timeout').value.trim(); + let tmo = null; + if (tmoRaw !== '') { + tmo = Number(tmoRaw); + if (!Number.isFinite(tmo) || tmo < 1000 || tmo > 600000) throw new Error('超时要填 1000 ~ 600000 毫秒(留空 = 默认 60s)'); + tmo = Math.round(tmo); + } + const add = mcpEdit.idx < 0; + if (add) { + if (!url) throw new Error('请填写 url'); + const obj = { url }; + if (name) obj.name = name; + if (!enable) obj.enable = false; + if (tmo != null) obj.timeout_ms = tmo; + const headers = {}; + for (const r of mcpEdit.headers) { + const k = String(r.key || '').trim(); + const v = String(r.value || '').trim(); + if (k) headers[k] = v; + } + if (Object.keys(headers).length) obj.headers = headers; + edits.push({ op: 'append', path: ['mcp_servers'], value: obj }); + } else { + const cur = SET.cfgMcp[mcpEdit.idx] || {}; + if (!url) throw new Error('请填写 url'); + if (name !== (cur.name || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'name'], value: name }); + if (url !== (cur.url || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'url'], value: url }); + if (!!cur.enable !== enable) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'enable'], value: enable }); + // 超时:清空 = 删掉该键(回落到缺省);后端 deleteIn 支持嵌套键,无键时是空操作。 + const curTmo = cur.timeout_ms == null ? null : Number(cur.timeout_ms); + if (tmo !== curTmo) edits.push(tmo == null + ? { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], op: 'delete' } + : { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], value: tmo }); + // headers 仅在内容变更时整体 setIn;避免无意义重写(顺序可能不同) + const newH = {}; + for (const r of mcpEdit.headers) { + const k = String(r.key || '').trim(); + // 已有行留空 = 保持原值:把脱敏占位原样发回,由后端按键名还原真值(前端不持有真值) + const v = String(r.value || '').trim() || (r.masked != null ? r.masked : ''); + if (k) newH[k] = v; + } + const curH = cur.headers || {}; + const same = JSON.stringify(newH) === JSON.stringify(curH); + if (!same) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'headers'], value: newH }); + } + return edits; + } + async function saveMcpEditor() { + let edits; + try { edits = buildMcpEdits(); } + catch (e) { toast(e.message); return; } + if (!edits.length) { toast('没有改动'); closeMcpEditor(); return; } + try { + await req('PATCH', '/api/config', { edits }); + closeMcpEditor(); + afterMcpWrite(); + } catch (e) { toast('保存失败:' + e.message); } + } + async function delMcpEditor() { + if (!mcpEdit || mcpEdit.idx < 0) return; + const s = SET.cfgMcp[mcpEdit.idx] || {}; + closeMcpEditor(); + if (!await confirmModal('删除 MCP 服务', '删除「' + (s.name || s.url || ('MCP-' + mcpEdit.idx)) + '」?此操作仅修改 config.yml,重启后该服务的工具不再加载。', '删除', true)) return; + try { + await req('PATCH', '/api/config', { path: ['mcp_servers', mcpEdit.idx], op: 'delete' }); + afterMcpWrite(); + } catch (e) { toast('删除失败:' + e.message); } + } + function afterMcpWrite() { + SET.mcpPendingRestart = true; + toast('已写入 config.yml,到「服务」页重启后生效'); + loadMcpList(); + } + window.mcpUI = { + add: function () { openMcpEditor(null); }, + edit: openMcpEditor, + close: closeMcpEditor, + save: saveMcpEditor, + del: delMcpEditor, + addHeader: addMcpHeader, + delHeader: delMcpHeader, + setHeader: setMcpHeader, + }; + + // ---------- 设置区对外接口(动态卡片里的 onclick 均指向这里) ---------- + window.sUI = { + // 账户 + changePassword: changePassword, + logout: async function () { + sessionStorage.removeItem('agent_creds'); // 旧版本遗留的 Basic 凭据,顺带清理 + localStorage.removeItem('agent_token'); // 清 autoRestore token,防止自动恢复旧用户 + try { await fetch('/api/logout', { method: 'POST' }); } catch (_) {} + location.href = '/logout'; + }, + // 服务 + saveForm: saveForm, + restart: restart, + openCfg: openCfgEditor, + saveCfg: saveCfg, + closeCfg: closeCfg, + // 技能 + open: openSkill, + openCreate: openCreateSkill, + closeCreate: closeCreateSkill, + createSkill: createSkill, + renameSkill: renameSkill, + deleteSkill: deleteSkill, + editFile: openSkillFile, + saveFile: saveSkillFile, + closeEditor: closeSkillEditor, + newFile: newSkillFile, + deleteFile: deleteSkillFile, + onUpload: uploadSkillFile, + // 模型池(平台编辑/新增共用弹窗;mEdit 参数为平台下标 pi) + openAdd: function () { openModelEditor(null); }, + mEdit: function (pi) { openModelEditor(pi); }, + mClose: closeModelEditor, + mSave: saveModelEditor, + mAddKey: addPfKey, + mDelKey: delPfKey, + mAddModel: addPfModel, + mDelModel: delPfModel, + mKeyApi: function (i, v) { setPfKey(i, 'api_key', v); }, + mModId: function (i, v) { setPfModel(i, 'id', v); }, + mModVision: function (i, v) { setPfModel(i, 'vision', v); }, + mModEnable: function (i, v) { setPfModel(i, 'enable', v); }, + mDelPlat: delPlatformFromModal, + restartNow: restartNow, + toggleGroup: toggleModelGroup, + refreshBalance: refreshBalance, + mToggleEnable: toggleModelEnable, + }; + + // ---------- 初始化 ---------- + bindChatScroll(); // 聊天区滚动跟随/右下角回底按钮(只绑一次) + selectMode('secretary'); // 默认选中【文秘助理】 + setView('welcome'); + openDrawer(drawerMQ.matches); // 桌面端:侧边栏默认展开;跨断点缩放窗口时同步切换开合态 + drawerMQ.addEventListener('change', e => openDrawer(e.matches)); + // 页面加载时校验 cookie 身份:防止 localStorage 旧 token 通过 autoRestore 恢复错误用户 + (async () => { + let verifiedUser = null; // 校验结果顺带复用给侧边栏,避免同一次加载请求两次 /api/me + try { + const res = await fetch('/api/me', { credentials: 'include' }); + if (res.ok) { + const j = await res.json(); + if (!j.user) { + // cookie 无效或用户已从配置中移除 → 彻底清理所有前端凭据并跳登录 + localStorage.removeItem('agent_token'); + sessionStorage.removeItem('agent_creds'); // 旧版本遗留的 Basic 凭据,顺带清理 + location.href = '/logout'; + return; + } + verifiedUser = String(j.user); + } + } catch (_) { /* 网络错误放过,让后续请求正常走 */ } + loadSessionList(); + loadDrawerUser(verifiedUser); // 侧边栏底部展示真实登录用户(未启用认证/拉取失败时静默回退默认占位) + })(); diff --git a/app/server/public/js/stream.js b/app/server/public/js/stream.js new file mode 100644 index 0000000..4456bbe --- /dev/null +++ b/app/server/public/js/stream.js @@ -0,0 +1,559 @@ +// 发送 / SSE 流式渲染 / 复制与全屏查看器(拆自 index.html 内联脚本,纯搬运不改逻辑) +'use strict'; + // ---------- 发送 ---------- + async function uploadFiles(sessionId, files) { + const fd = new FormData(); + for (const f of files) fd.append('files', f.file, f.name); + // 大文件上传在慢速网络上可以远超普通请求超时:放宽到 120s + const r = await req('POST', '/api/sessions/' + sessionId + '/files', fd, true, 120000); + return (r.uploaded || []).map(u => ({ name: u.filename, size: u.size })); + } + + async function send() { + const ta = $('msg-input'); + const content = ta.value.trim(); + // 没有文字就不发(避免产生空消息);上传文件告知行在发送时拼在正文前(见下)。 + if (!content) { + if (state.attachments.length) toast('附件需随一条文字消息发送'); + return; + } + + const pending = state.attachments.slice(); + state.attachments = []; + renderAttachChips(); + ta.value = ''; + autosize(); + + try { + const id = await ensureSession(); + let atts = []; + if (pending.length) atts = await uploadFiles(id, pending); + // 输入区上传卡片里成功入库的文件:正文前拼一行告知,让 AI 知道任务目录多了哪些文件 + const upNames = Array.from($('up-cards').querySelectorAll('.up-card[data-done="1"]')) + .map(c => c.dataset.name).filter(Boolean); + const text = upNames.length + ? '用户上传了文件:' + upNames.join('、') + '\n\n' + content + : content; + const body = { content: text, deepThink: !!state.deepThink }; + const sent = await req('POST', '/api/sessions/' + id + '/messages', body); + clearUploadCards(); // 消息已发出(告知行已拼入正文),卡片使命完成清掉 + + appendUserMsg(text, atts.map(a => a.name), sent && sent.message_id); + if (!state.sessionTitle && content) { + // 标题取用户原文,不带文件告知行 + state.sessionTitle = content.length > 24 ? content.slice(0, 24) : content; + } + renderHeader(); + addTyping(); + loadSessionList(); + } catch (e) { + // 发送失败:附件还原+草稿文本回填(发送前已清空输入框,挂起/失败不能让文字蒸发), + // 用户等待期间新敲的内容排在后面不丢。 + state.attachments = pending.concat(state.attachments); + renderAttachChips(); + if (content) { + ta.value = content + (ta.value ? '\n' + ta.value : ''); + autosize(); + } + toast('发送失败:' + e.message); + } + } + + // ---------- SSE 流 ---------- + // 助手消息流式容器:首个 delta 到达时创建,同时为思考面板预留挂载点 + function ensureStreamWrap() { + if (state.streamWrap) return state.streamWrap; + const wrap = document.createElement('div'); + wrap.className = 'msg other'; + const bubble = document.createElement('div'); + bubble.className = 'bubble-ai'; + wrap.appendChild(bubble); + $('chat-view').appendChild(wrap); + state.streamWrap = wrap; + state.streamEl = bubble; + return wrap; + } + // 思考面板:首次思考 delta 到达时创建,带 open 状态(流式中默认展开) + function ensureStreamThinkPanel() { + if (state.streamThinkEl) return state.streamThinkEl; + if (!state.streamWrap) ensureStreamWrap(); + const det = document.createElement('details'); + det.className = 'msg-think streaming'; + det.open = true; // 流式阶段默认展开,看思考增量 + const sum = document.createElement('summary'); + sum.innerHTML = '思考过程' + THINK_COPY_BTN; + const body = document.createElement('div'); + body.className = 'msg-think-body'; + det.appendChild(sum); + det.appendChild(body); + // 插在气泡之前(思考 → 结论 的顺序) + state.streamWrap.insertBefore(det, state.streamEl); + state.streamThinkEl = body; + return body; + } + // 思考结束(正文开始流式或本轮收尾):自动折叠思考面板并去掉流式高亮边框;用户仍可手动点开回看 + function collapseStreamThink() { + if (!state.streamThinkEl) return; + const det = state.streamThinkEl.closest('details'); + if (det) { det.open = false; det.classList.remove('streaming'); } + } + + // ---------- 流式 delta 合帧渲染 ---------- + // 快速输出模型(如 DeepSeek)的 delta 频率远超屏幕刷新率:逐条全量重写文本节点 + + // 读布局滚动(scrollHeight/scrollTop)会把主线程挤满,页面与右下角转圈肉眼可见地卡。 + // 改为 delta 只累积进缓冲,每个动画帧统一刷一次 DOM;文本节点内容只在尾部增长时 + // 走 appendData 增量追加,避免整段文本节点重建重排。 + let streamPaintQueued = false; + function paintStreamingText(el, full) { + if (!el) return; + const tn = el.firstChild; + if (tn && tn.nodeType === 3) { + if (tn.data === full) return; // 无变化不碰 DOM,不触发布局 + if (full.startsWith(tn.data)) { tn.appendData(full.slice(tn.data.length)); return; } + } + el.textContent = full; // 结构不符(收尾后重建/罕见回退)才整段重写 + } + + function scheduleStreamPaint() { + if (streamPaintQueued) return; + streamPaintQueued = true; + requestAnimationFrame(() => { + streamPaintQueued = false; + paintStreamingText(state.streamEl, state.streamText); + paintStreamingText(state.streamThinkEl, state.streamReasoning); + maybeAutoScroll(); + updateScrollBottomBtn(); + }); + } + + function connectStream() { + closeStream(); + if (!state.sessionId) return; + const es = new EventSource('/api/sessions/' + state.sessionId + '/stream'); + state.es = es; + state.lastSseAt = Date.now(); // 建连即重置静默计时 + es.addEventListener('ping', () => { state.lastSseAt = Date.now(); }); // 服务端 15s 可见心跳 + es.addEventListener('status', ev => { + const d = JSON.parse(ev.data); + state.status = d.status; + renderHeader(); + updatePhaseBar(d); + updateScrollBottomBtn(); // 状态切换同步右下角转圈(开始/结束干活) + }); + es.addEventListener('assistant_delta', ev => { + const d = JSON.parse(ev.data); + removeTyping(); + state.streamText += d.text; + if (!state.streamEl) { + if (!state.streamText.trim()) return; // 忽略前导空白(纯工具调用回合无文本) + ensureStreamWrap(); + state.streamText = d.text; // 上面 if 已 trim 为非空 + collapseStreamThink(); // 首个正文 delta:思考已结束,折叠思考面板 + } + state.streaming = true; + scheduleStreamPaint(); // DOM 刷新合到每个动画帧一次:快速输出模型逐 token 重排会挤爆主线程 + }); + es.addEventListener('reasoning_delta', ev => { + const d = JSON.parse(ev.data); + removeTyping(); + state.streamReasoning += d.text; + if (!state.streamWrap) ensureStreamWrap(); + ensureStreamThinkPanel(); + state.streaming = true; + scheduleStreamPaint(); + }); + es.addEventListener('assistant_message', ev => { + const d = JSON.parse(ev.data); + // 防重:同 id 的 assistant_message 只处理一次(防御 EventSource 自动重连、服务端重发等情况) + if (d.id && state.lastAssistantMsgId === d.id) return; + if (d.id) state.lastAssistantMsgId = d.id; + removeTyping(); + const hasText = !!(d.content && d.content.trim()); + const r = hasText ? mdHtml(d.content) : null; + // 思考面板:本轮结束时锁定为后端返回的完整文本(不清空 streamReasoning 以防与历史回填不一致) + if (d.reasoning && d.reasoning.trim()) { + if (!state.streamWrap) ensureStreamWrap(); + ensureStreamThinkPanel(); + state.streamThinkEl.textContent = d.reasoning; + } + if (state.streamEl) { + if (r) { + state.streamEl.className = 'bubble-ai' + (r.fmt ? ' md' : ''); // 增量期间是纯文本,收尾统一换 md 排版 + state.streamEl.innerHTML = r.html; + decorateCodePre(state.streamEl); // 流式期间不插按钮(每帧整块换 innerHTML),收尾统一装饰一次 + } else { + // 无文本时去掉气泡(纯工具调用/纯思考也要保留思考面板) + state.streamEl.remove(); + } + state.streamEl = null; + state.streamText = ''; + } else if (r) { + // 没起过气泡但收到文本:现在才创建(思考先行、文本后到的罕见场景) + if (!state.streamWrap) ensureStreamWrap(); + const bubble = document.createElement('div'); + bubble.className = 'bubble-ai' + (r.fmt ? ' md' : ''); + bubble.innerHTML = r.html; + decorateCodePre(bubble); + state.streamWrap.appendChild(bubble); + } + // 「压缩」总结回合的最终答复(后端已保证只有压缩回合里首条无工具调用的收尾回复才带 is_summary, + // 中间 AI 回复已按普通消息渲染):把已流式输出的气泡装进摘要卡片(与历史重渲染同款样式), + // 并标记 wrap 为 msg-summary-live:archiveDomBeforeSummary 据此定位摘要卡片,之前的旧消息收进存档容器。 + // open=true 让用户立刻读到;后续轮次不自动折起(卡片可手动点 summary 收起)。 + // 防重:同一 streamWrap 已有卡片则不再重复插入(保护 SSE 重连重发等场景)。 + if (d.is_summary && hasText && state.streamWrap && !state.streamWrap.querySelector('.msg-summary')) { + const wrap0 = state.streamWrap; + const det = document.createElement('details'); + det.className = 'msg-summary'; + det.open = true; + det.innerHTML = summaryHeaderHtml() + '
'; + const body = det.querySelector('.msg-summary-body'); + const bubble = wrap0.querySelector('.bubble-ai'); + const ref = bubble ? bubble.nextSibling : null; + if (bubble) body.appendChild(bubble); // 把总结气泡收进卡片 body(保留原位,不打乱思考面板顺序) + wrap0.insertBefore(det, ref); + wrap0.classList.add('msg-summary-live'); + } + // 补上尾部操作行(时间戳+复制/删除),与历史重渲染(aiMsgHtml)同款; + // created_at 由后端落库时间随事件回传,重进会话后时刻不变 + if (state.streamWrap) { + state.streamWrap.insertAdjacentHTML('beforeend', actionsHtml(d.created_at, d.content || '', d.id, d.usage)); + } + if (d.tool_calls) appendToolCardsFromAssistant(d, $('chat-view')); + state.streaming = false; + // 思考面板本轮结束兜底折叠(正常已在首个正文 delta 时折过,这里是 no-op); + // 覆盖无正文的回合(如纯工具调用/纯思考),也顺带清掉 .streaming 高亮。工具卡保持展开,由用户自行收起。 + collapseStreamThink(); + state.streamWrap = null; + state.streamReasoning = ''; + state.streamThinkEl = null; + maybeAutoScroll(); + updateScrollBottomBtn(); + // 「压缩」总结完成后:后端已把摘要标成 type='summary' 并把之前的旧消息标成 type='archived' + //(不再发给模型);聊天保留全部展示,把摘要之前的旧消息就地淡出存档。 + // 仅在客户端主动点了压缩(pendingSummary)时才走收尾;避免历史重加载/跨设备重连误触发。 + // 仅有内容的总结才走后续流;空的/错误的总结只复位按钮状态。 + if (d.is_summary && state.pendingSummary && hasText) { + state.pendingSummary = false; + // 历史保留展示,但摘要之前的旧消息已存档:同步淡出 + 尾部说明,和重进入后的样式一致。 + archiveDomBeforeSummary(); + toast('已生成摘要:旧历史已存档,后续对话从摘要开始'); + const cpBtn = $('compress-btn'); + if (cpBtn) cpBtn.disabled = state.status === 'active'; + } else if (d.is_summary && state.pendingSummary && !hasText) { + // AI 总结为空/出错,复位状态。用于按钮状态还原。 + state.pendingSummary = false; + const cpBtn = $('compress-btn'); + if (cpBtn) cpBtn.disabled = state.status === 'active'; + } + }); + // 参数流式生成早卡:id+name 就绪即建卡展开,长参数(write_file 大文件)期间不再是死寂 typing + es.addEventListener('tool_call_start', ev => { + const d = JSON.parse(ev.data); + removeTyping(); + if (state.toolCards[d.id]) return; // 重连/重复广播防御 + state.toolCallStreaming[d.id] = { name: d.name || '', args: '' }; + // 保持原折叠态:参数进度看摘要行的「生成参数中… N 字符」,不自动展开 + const card = renderToolCard(d.id, d.name, '', Date.now(), { generating: true }); + $('chat-view').appendChild(card); + state.toolCards[d.id] = card; + maybeAutoScroll(); + }); + es.addEventListener('tool_call_args', ev => { + const d = JSON.parse(ev.data); + const st = state.toolCallStreaming[d.id]; + if (!st) return; // 未建早卡(无 id/name 或已收尾)则丢弃,收尾后残留碎片自然忽略 + st.args += d.args || ''; + const card = state.toolCards[d.id]; + if (!card) return; + if (card.dataset.painting) return; // 150ms 合并重绘:超大参数不逐帧刷 + card.dataset.painting = '1'; + setTimeout(() => { + delete card.dataset.painting; + if (!card.isConnected || !state.toolCallStreaming[d.id]) return; + const fullEl = card.querySelector('.tool-args-full'); + if (fullEl) { fullEl.textContent = st.args; fullEl.scrollTop = fullEl.scrollHeight; } + const argsEl = card.querySelector('.tool-args'); + const n = st.args.length; + if (argsEl) argsEl.textContent = '生成参数中… ' + (n >= 1024 ? (n / 1024).toFixed(1) + 'k 字符' : n + ' 字符'); + maybeAutoScroll(); + }, 150); + }); + es.addEventListener('tool_call', ev => { + const d = JSON.parse(ev.data); + removeTyping(); // 工具卡出现也算即时反馈 + if (state.toolCards[d.id]) { + // 执行时的完整参数事件:若为流式早卡则回填收尾(unwrap 后的干净参数),普通卡不动 + finalizeToolCardArgs(d.id, d.name, d.arguments); + return; + } + // 无早卡(旧行为/刷新后重连):直接建展开卡 + const card = renderToolCard(d.id, d.name, d.arguments, Date.now(), { open: true }); + $('chat-view').appendChild(card); + state.toolCards[d.id] = card; + maybeAutoScroll(); + }); + es.addEventListener('tool_result', ev => { + const d = JSON.parse(ev.data); + fillToolResult(d.tool_call_id, d.content, d.is_error, d.image_url, d.msg_id); + maybeAutoScroll(); + }); + // 后端回合结束+宽限期后的自动压缩提议:不再自动执行,弹 modal 请用户手动确认(见 proposeAutoCompress) + es.addEventListener('auto_compress', ev => { + proposeAutoCompress(JSON.parse(ev.data)); + }); + es.addEventListener('done', ev => { + removeTyping(); // 本轮结束,占位亦终止(如模型报错无回复) + // 压缩回合异常结束的兜底(模型报错回合直接 break / 被终止 → 不会有带 is_summary 的最终消息): + // 复位等待状态并还原压缩按钮,历史保持原样不动。 + if (state.pendingSummary) { + state.pendingSummary = false; + toast('压缩回合已结束,未收到摘要,历史未变动'); + const cpBtn = $('compress-btn'); + if (cpBtn) cpBtn.disabled = state.status === 'active'; + } + state.streaming = false; + state.streamEl = null; // 防御性清理:回合异常结束(如终止)时不留悬空气泡到下一轮 + collapseStreamThink(); // 异常收尾兜底:未折叠的思考面板收起并去掉流式高亮 + state.streamText = ''; + state.streamWrap = null; + state.streamReasoning = ''; + state.streamThinkEl = null; + // 异常收尾兜底:把参数未流完的早卡就地回填收尾,避免占位态永远呼吸 + for (const sid of Object.keys(state.toolCallStreaming)) { + const stg = state.toolCallStreaming[sid]; + finalizeToolCardArgs(sid, stg.name, stg.args); + } + state.toolCards = {}; + state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置 + updateScrollBottomBtn(); + loadSessionList(); + }); + // 服务端首次交互后自动生成的标题(finalize 后约 1s 到达):即时刷新顶栏 + 重拉会话列表(PC 常驻侧边栏/移动抽屉) + es.addEventListener('title', ev => { + const d = JSON.parse(ev.data); + if (d && d.title) { state.sessionTitle = d.title; renderHeader(); } + loadSessionList(); + }); + es.addEventListener('error', ev => { + removeTyping(); + try { + const d = JSON.parse(ev.data); + if (d && d.message) toast('错误:' + d.message); + } catch (_) { /* EventSource 连接错误,自动重连 */ } + }); + } + + // ---------- 消息区点击代理(复制;全屏查看器内的克隆按钮同样可复制) ---------- + async function onCopyClick(e) { + const copyBtn = e.target.closest('.act-copy'); + if (!copyBtn) return; + const toolCard = copyBtn.closest('.tool-card'); + const think = copyBtn.closest('.msg-think'); + if (think) e.preventDefault(); // 按钮在 summary 内:只复制,不触发折叠/展开 + let text = ''; + const codeWrap = copyBtn.closest('.code-wrap'); // 代码块逐块复制(decorateCodePre 注入):点时现取 pre 全文 + if (codeWrap) { + const pre = codeWrap.querySelector('pre'); + text = pre ? pre.textContent : ''; + } else if (toolCard) { + // 工具卡:参数 + 结果一并复制。点时取 DOM 现值,多次回填/流式更新后也不会复制旧内容 + const args = toolCard.querySelector('.tool-args-full'); + const res = toolCard.querySelector('.tool-result'); + const parts = []; + if (args) parts.push('command:\n' + args.textContent); + if (res) parts.push('result:\n' + res.textContent); + text = parts.join('\n\n'); + } else if (think) { + const b = think.querySelector('.msg-think-body'); + text = b ? b.textContent : ''; + } else { + try { text = decodeURIComponent(escape(atob(copyBtn.dataset.b64 || ''))); } catch (_) {} + } + const ok = await copyText(text); + toast(ok ? '已复制' : '复制失败'); + if (ok) { + copyBtn.classList.add('copied'); + setTimeout(() => copyBtn.classList.remove('copied'), 1200); + } + } + $('chat-view').addEventListener('click', onCopyClick); + $('fs-viewer').addEventListener('click', onCopyClick); + + // ---------- 删除本条消息(复制按钮旁) ---------- + // 后端连带删 assistant 轮的 tool 回执;成功后重拉详情重建消息区(工具卡需随该轮一起拆)。 + // 执行中也可删:库行没了,下一轮组装模型历史时自然不含这条。 + $('chat-view').addEventListener('click', async e => { + const btn = e.target.closest('.act-del'); + if (!btn) return; + const msgId = Number(btn.dataset.msgId); + if (!msgId || !state.sessionId) return; + if (!window.confirm('删除本条消息?它将不再发给 AI。')) return; + btn.disabled = true; + try { + await req('DELETE', '/api/sessions/' + state.sessionId + '/messages/' + msgId); + toast('已删除'); + // 按已加载量分页重拉(长会话删一条不该退回全量重建) + const detail = await req('GET', '/api/sessions/' + state.sessionId + '?limit=' + Math.max(CHAT_PAGE_SIZE, state.chatLoadedCount)); + if (state.view === 'chat') renderDetail(detail); + } catch (err) { + toast('删除失败:' + err.message); + btn.disabled = false; + } + }); + + // ---------- 全屏查看器(双击气泡/工具卡放大;图片单击放大;均同步 index) ---------- + // 源码查看:当前内容有源文本时(消息/文件预览)右上角 eye 钮可点,源码面板与渲染视图互切。 + // 源文本两条来路:预览调用方直接传(文件原文);双击消息时从尾部操作行复制钮取 + // (actionsHtml 本来就随消息嵌了全文 b64,零额外存储)。 + let fsSrcText = null; // null = 本轮查看无源文本,eye 钮隐藏 + let fsSrcOn = false; + function setFsSource(text) { + fsSrcText = text == null || text === '' ? null : String(text); + fsSrcOn = false; + $('fs-src-pane').classList.add('hidden'); + $('fs-body').classList.remove('hidden'); + const btn = $('fs-src-btn'); + btn.classList.toggle('hidden', fsSrcText == null); + btn.classList.remove('on'); + btn.title = '显示源码'; + btn.setAttribute('aria-label', '显示源码'); + } + function toggleFsSrc() { + if (fsSrcText == null) return; + fsSrcOn = !fsSrcOn; + if (fsSrcOn) $('fs-src-code').textContent = fsSrcText; // 点开才填,闲置期不留大 DOM + $('fs-src-pane').classList.toggle('hidden', !fsSrcOn); + $('fs-body').classList.toggle('hidden', fsSrcOn); + const btn = $('fs-src-btn'); + btn.classList.toggle('on', fsSrcOn); + const lbl = fsSrcOn ? '返回渲染视图' : '显示源码'; + btn.title = lbl; + btn.setAttribute('aria-label', lbl); + } + $('fs-src-btn').addEventListener('click', toggleFsSrc); + + function openFullscreen(el, src) { + const body = $('fs-body'); + body.innerHTML = ''; + body.style.zoom = ''; + // 深拷贝并去掉 id:保留原类名使气泡/工具卡样式在查看器内照常生效,且避免 id 重复 + const clone = el.cloneNode(true); + clone.removeAttribute('id'); + clone.querySelectorAll('[id]').forEach(function (n) { n.removeAttribute('id'); }); + // 全屏查看直接展开参数/结果,方便观看 + clone.querySelectorAll('details').forEach(function (d) { d.open = true; }); + // 克隆里摘掉删除钮:删除的委托绑在 chat-view,查看器里点了无响应,不留死按钮 + clone.querySelectorAll('.act-del').forEach(function (n) { n.remove(); }); + // 源文本:调用方传入优先(文件预览),否则从消息自带 b64 现取(双击场景) + let s = src; + if (s == null) { + const b = clone.querySelector('.act-copy[data-b64]:not([data-b64=""])'); + if (b) { try { s = decodeURIComponent(escape(atob(b.dataset.b64))); } catch (_) { s = null; } } + } + body.appendChild(clone); + setFsSource(s); + $('fs-viewer').classList.remove('hidden'); + } + function closeFullscreen() { + setFsSource(null); // 顺手收起源码面板/隐藏 eye 钮,下轮打开不残留 + $('fs-viewer').classList.add('hidden'); + $('fs-viewer').dispatchEvent(new Event('fs:close')); + } + // 双击消息气泡/工具卡 → 全屏查看(操作钮/图片不误触全屏) + // 气泡连整个 .msg 一起克隆:尾部操作行(时间/token/复制)随原文进查看器,与聊天里所见一致 + $('chat-view').addEventListener('dblclick', function (e) { + if (e.target.closest('.act') || e.target.closest('img')) return; + const card = e.target.closest('.tool-card'); + if (card) { openFullscreen(card); return; } + const bubble = e.target.closest('.bubble-ai, .bubble-user'); + if (bubble) openFullscreen(bubble.closest('.msg') || bubble); + }); + + // 点击消息/工具卡里的图片 → 图片全屏查看器(#fs-viewer 里的克隆图也生效) + function imgViewerDelegate(e) { + const im = e.target.closest('.bubble-ai img, .bubble-user img, .tool-card img'); + if (im && im.src) openImageViewer(im.src, im.alt || ''); + } + $('chat-view').addEventListener('click', imgViewerDelegate); + $('fs-viewer').addEventListener('click', imgViewerDelegate); + + // 图片全屏查看器:transform 缩放+平移。双指捻合缩放(1~6x)、放大后单指/鼠标拖动、双击切 2.5x。 + let openImageViewer, closeImageViewer; + (function () { + const viewer = document.getElementById('img-viewer'); + const img = document.getElementById('img-viewer-img'); + let scale = 1, tx = 0, ty = 0, mode = null; + let sx = 0, sy = 0, stx = 0, sty = 0, pDist = 0, pScale = 1; + const tdist = t => Math.hypot(t[0].clientX - t[1].clientX, t[0].clientY - t[1].clientY); + function apply() { + img.style.transform = 'translate(' + tx + 'px,' + ty + 'px) scale(' + scale + ')'; + img.style.cursor = scale > 1 ? 'grab' : 'zoom-in'; + } + openImageViewer = function (src, alt) { + scale = 1; tx = ty = 0; mode = null; + apply(); + img.src = src; img.alt = alt || ''; + viewer.classList.remove('hidden'); + }; + closeImageViewer = function () { viewer.classList.add('hidden'); }; + // 点背景(非图片)关闭 + viewer.addEventListener('click', function (e) { if (e.target === viewer) closeImageViewer(); }); + img.addEventListener('dblclick', function () { + scale = scale > 1 ? 1 : 2.5; + if (scale === 1) { tx = ty = 0; } + apply(); + }); + img.addEventListener('touchstart', function (e) { + if (e.touches.length === 2) { mode = 'pinch'; pDist = tdist(e.touches) || 1; pScale = scale; } + else if (e.touches.length === 1 && scale > 1) { mode = 'pan'; sx = e.touches[0].clientX; sy = e.touches[0].clientY; stx = tx; sty = ty; } + else mode = null; + }, { passive: true }); + img.addEventListener('touchmove', function (e) { + if (mode === 'pinch' && e.touches.length >= 2) { + e.preventDefault(); + scale = Math.min(6, Math.max(1, pScale * tdist(e.touches) / pDist)); + if (scale === 1) { tx = ty = 0; } + apply(); + } else if (mode === 'pan' && e.touches.length === 1) { + e.preventDefault(); + tx = stx + e.touches[0].clientX - sx; + ty = sty + e.touches[0].clientY - sy; + apply(); + } + }, { passive: false }); + img.addEventListener('touchend', function (e) { if (e.touches.length < 2) { if (mode === 'pinch') mode = null; } if (!e.touches.length) mode = null; }, { passive: true }); + img.addEventListener('touchcancel', function () { mode = null; }, { passive: true }); + // 桌面:放大后按住拖动平移 + img.addEventListener('mousedown', function (e) { + if (scale <= 1) return; + e.preventDefault(); + const x0 = e.clientX, y0 = e.clientY, tx0 = tx, ty0 = ty; + const mv = function (ev) { tx = tx0 + ev.clientX - x0; ty = ty0 + ev.clientY - y0; apply(); }; + const up = function () { window.removeEventListener('mousemove', mv); window.removeEventListener('mouseup', up); }; + window.addEventListener('mousemove', mv); window.addEventListener('mouseup', up); + }); + })(); + + // 消息全屏查看器双指缩放:viewport 是 user-scalable=no(原生捏合被禁), + // 在查看器内接管双指手势,用 CSS zoom 缩放内容(1~4 倍,关闭时重置)。 + (function () { + const viewer = document.getElementById('fs-viewer'); + if (!viewer) return; + let startDist = 0, startZoom = 1, pinching = false; + const tdist = t => Math.hypot(t[0].clientX - t[1].clientX, t[0].clientY - t[1].clientY); + viewer.addEventListener('touchstart', function (e) { + if (e.touches.length !== 2) { pinching = false; return; } + pinching = true; + startDist = tdist(e.touches) || 1; + startZoom = Number($('fs-body').style.zoom) || 1; + }, { passive: true }); + viewer.addEventListener('touchmove', function (e) { + if (!pinching || e.touches.length < 2) return; + e.preventDefault(); // 双指期间阻止滚动,手势归缩放 + $('fs-body').style.zoom = Math.min(4, Math.max(1, startZoom * tdist(e.touches) / startDist)) || ''; + }, { passive: false }); + viewer.addEventListener('touchend', function (e) { if (e.touches.length < 2) pinching = false; }, { passive: true }); + viewer.addEventListener('touchcancel', function () { pinching = false; }, { passive: true }); + })(); +