Files
agent/app/server/public/index.html
T
kicer d3e64c8a2f 交互:恢复 up-card 右上角 ×——点掉卡片即发送时不再拼该文件告知行(任务目录文件不动)
- ×在上传完成/失败后显示(上传中隐藏);点掉从 DOM 移除,send() 按现存 data-done 卡片实时收集,天然排除
- 恢复 .up-x 样式;.up-info 加右内边距避免文件名省略号被 × 压住
2026-09-10 09:00:44 +08:00

4168 lines
215 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<!DOCTYPE html>
<html lang="zh">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<title>Agent 任务台</title>
<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
<meta name="theme-color" content="#3964FE">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
<meta name="apple-mobile-web-app-title" content="Agent">
<link rel="manifest" href="/manifest.json">
<link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">
<link rel="icon" type="image/png" sizes="192x192" href="/icons/icon-192.png">
<link rel="stylesheet" href="/css/style.css">
<style>
/* 「压缩」摘要卡片:与 .msg-think 同族的折叠交互,但做成更醒目的蓝色调卡片;
流式收尾(live)和历史重渲染(type='summary' 消息)共用同一套样式。
live 阶段 open=true 展开阅读;历史重渲染默认收起。 */
.msg-summary {
margin: 0 0 8px; border: 1px solid #dbe4fb; border-radius: 12px; overflow: hidden;
background: linear-gradient(180deg, #f7f9ff 0%, #ffffff 56%);
box-shadow: 0 1px 3px rgba(57, 100, 254, 0.08);
}
.msg-summary > summary {
list-style: none; cursor: pointer; user-select: none;
display: flex; align-items: center; gap: 7px;
padding: 9px 12px; font-size: 13px; font-weight: 600; color: var(--active);
}
.msg-summary > summary::-webkit-details-marker { display: none; }
.msg-summary > summary::before {
content: ''; flex: none; width: 0; height: 0; margin-left: 1px;
border-left: 5px solid var(--active); border-top: 4px solid transparent; border-bottom: 4px solid transparent;
transition: transform .15s ease;
}
.msg-summary[open] > summary::before { transform: rotate(90deg); }
.msg-summary .sum-ic { flex: none; width: 15px; height: 15px; }
.msg-summary .sum-hint { margin-left: auto; font-size: 11px; font-weight: 400; color: var(--gray); }
.msg-summary-body {
border-top: 1px dashed #dbe4fb; background: var(--page);
padding: 10px 13px 12px;
}
.msg-summary-body .bubble-ai { margin: 0; font-size: 14px; line-height: 1.7; }
/* 「仅摘要」后摘要之前的旧历史:UI 保留但变淡,尾部附存档说明(不再发给 AI) */
.msg-archived { opacity: .55; }
.archived-note {
display: flex; align-items: center; gap: 8px;
margin: 10px 0 12px; font-size: 11px; color: var(--gray);
}
.archived-note::before, .archived-note::after { content: ''; flex: 1; height: 1px; background: var(--border); }
/* 状态栏图标按钮(压缩):仅显示 SVG、去掉文字 padding;保持与文字按钮同高。 */
.stop-link.icon-only { padding: 0 8px; line-height: 0; }
.stop-link.icon-only .ic { width: 18px; height: 18px; vertical-align: middle; }
/* 状态栏「压缩」图标按钮:主操作色(蓝色),与其他 stop-link 区分(终止/选择模型是灰) */
.stop-link.icon-only.icon-primary { color: var(--active); }
.stop-link.icon-only.icon-primary:hover { color: #2854d6; }
/* 推到 phase-bar 最右侧(独立动作,与左侧状态/选择模型区分) */
.phase-bar .phase-bar-right { margin-left: auto; }
</style>
<script>
// 注册 Service Worker(PWA / 离线缓存)
if ('serviceWorker' in navigator) {
window.addEventListener('load', () => {
navigator.serviceWorker.register('/sw.js').catch((err) => {
console.warn('[SW] register failed:', err);
});
});
}
</script>
</head>
<body>
<div id="app">
<!-- ================= 顶部导航栏 ================= -->
<header class="header">
<button class="icon-btn" id="menu-btn" title="历史记录" aria-label="打开历史记录">
<svg viewBox="0 0 24 24" class="ic sm"><path stroke-width="2" stroke-linecap="round" d="M4 5h16M4 15h10"/></svg>
</button>
<div class="header-center" id="header-center"><!-- 未对话状态为空白,JS 注入对话信息 --></div>
<button class="icon-btn hidden" id="new-chat-btn" title="新建对话" aria-label="新建对话">
<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg>
</button>
</header>
<!-- ================= 会话状态栏(搬自 index 的 phase-bar;仅在对话中显示) ================= -->
<div id="phase-bar" class="phase-bar hidden">
<span class="status-pill" id="status-pill">--</span>
<button class="stop-link hidden" id="stop-btn" onclick="stopSession()">终止</button>
<button class="stop-link hidden" id="model-switch-btn" onclick="openModelSwitch()">选择模型</button>
<button class="stop-link icon-only icon-primary phase-bar-right hidden" id="compress-btn" title="压缩上下文" aria-label="压缩上下文" onclick="summarizeChat()">
<svg class="ic" viewBox="0 0 24 24"><ellipse cx="12" cy="5" rx="8" ry="2.5" fill="none" stroke="currentColor" stroke-width="1.6"></ellipse><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 5v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5V5"></path><path fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" d="M4 11v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5v-6"></path></svg>
</button>
</div>
<main>
<!-- ================= 未对话状态:模式切换区 ================= -->
<section id="welcome-view">
<div class="welcome-head">
<div class="logo-badge">
<svg class="ic" viewBox="0 0 24 24"><rect x="4" y="8" width="16" height="12" rx="3"></rect><line x1="12" y1="4" x2="12" y2="8"></line><circle cx="12" cy="3" r="1.4"></circle><circle cx="9" cy="13.5" r="1" fill="currentColor" stroke="none"></circle><circle cx="15" cy="13.5" r="1" fill="currentColor" stroke="none"></circle><line x1="9.5" y1="17" x2="14.5" y2="17"></line></svg>
</div>
<div class="welcome-slogan">选择模式开始对话</div>
</div>
<div class="mode-switch" role="tablist" id="mode-switch">
<button class="mode-chip on" data-mode="secretary" role="tab" aria-selected="true">
<svg class="ic sm" viewBox="0 0 24 24"><path d="M6 3h12l4 6-10 13L2 9z"></path><polyline points="2 9 22 9"></polyline><polyline points="10 3 8 9 12 22"></polyline><polyline points="14 3 16 9 12 22"></polyline></svg>
文秘助理
</button>
<button class="mode-chip" data-mode="vision" role="tab" aria-selected="false">
<svg class="ic sm" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></svg>
识图专家
</button>
</div>
<div class="mode-hint" id="mode-hint"></div>
</section>
<!-- ================= 对话状态:对话内容区 ================= -->
<section id="chat-view" class="hidden"></section>
</main>
<!-- ================= 底部输入区 ================= -->
<footer>
<div class="attach-chips hidden" id="attach-chips"></div>
<div class="input-shell">
<div class="up-cards hidden" id="up-cards" aria-label="已上传文件"></div>
<textarea id="msg-input" placeholder="传送信息" rows="2" enterkeyhint="enter"></textarea>
<div class="input-actions">
<div class="ia-side ia-left">
<button class="think-toggle" id="deep-think-btn" title="深度思考">
<svg viewBox="0 0 24 24" class="ic sm"><path d="M12 10.2a1.8 1.8 0 1 0 0.001 3.6A1.8 1.8 0 0 0 12 10.2z"></path><path stroke-width="1.5" d="M15.76 15.76 C10.955 20.565 5.373 22.779 3.297 20.703 C1.22 18.627 3.434 13.045 8.24 8.24 C13.045 3.435 18.627 1.22 20.703 3.297 C22.779 5.374 20.565 10.955 15.76 15.76z"></path><path stroke-width="1.5" d="M16.096 7.904 C20.905 12.713 22.965 18.298 20.703 20.703 C18.44 23.108 13.003 20.755 8.24 15.76 C3.477 10.76 1.22 5.373 3.297 3.297 C5.374 1.22 10.955 3.434 16.096 7.904z"></path></svg>
深度思考
</button>
</div>
<div class="ia-side ia-right">
<button class="plus-btn" id="files-btn" title="任务文件" aria-label="任务文件">
<svg viewBox="0 0 24 24" class="ic sm"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path></svg>
</button>
<button class="plus-btn" id="attach-btn" title="上传文件" aria-label="上传文件">
<svg viewBox="0 0 24 24" class="ic sm"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"></path></svg>
</button>
<button class="send-btn" id="send-btn" title="发送" aria-label="发送">
<svg viewBox="0 0 24 24" class="ic sm"><line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline></svg>
</button>
</div>
</div>
</div>
</footer>
<!-- 回到底部浮动按钮(搬自 index;上翻历史时出现、AI 输出中常驻转圈) -->
<button class="scroll-bottom-btn hidden" id="scroll-bottom-btn" onclick="clickScrollBottom()" title="回到底部" aria-label="回到底部">
<svg class="sb-arrow" viewBox="0 0 24 24"><polyline points="6 9 12 15 18 9"></polyline></svg>
<svg class="sb-spinner hidden" viewBox="0 0 24 24"><circle cx="12" cy="12" r="10"></circle><path d="M22 12a10 10 0 0 1-10 10"></path></svg>
</button>
<!-- ================= 历史记录抽屉 ================= -->
<div id="scrim"></div>
<aside id="drawer" aria-label="对话历史">
<div class="drawer-search">
<div class="search-box">
<svg class="ic sm" viewBox="0 0 24 24"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></svg>
<input type="search" id="search-input" placeholder="搜寻对话内容..." enterkeyhint="search">
</div>
</div>
<div class="drawer-list" id="drawer-list"></div>
<div class="drawer-user" id="drawer-user">
<div class="avatar" id="drawer-avatar">A</div>
<div class="user-name" id="drawer-user-name">Agent 用户</div>
<button class="user-more" id="user-more-btn" title="更多设置" aria-label="更多设置">
<svg class="ic sm" viewBox="0 0 24 24"><circle cx="5" cy="12" r="1.4" fill="currentColor" stroke="none"></circle><circle cx="12" cy="12" r="1.4" fill="currentColor" stroke="none"></circle><circle cx="19" cy="12" r="1.4" fill="currentColor" stroke="none"></circle></svg>
</button>
</div>
</aside>
<!-- ================= 任务文件面板(浮层:点输入行右侧文件夹按钮展开;盖住输入区+遮罩) ================= -->
<div id="files-mask" aria-hidden="true"></div>
<div class="files-panel" id="files-panel" aria-label="任务文件">
<div class="files-panel-header">
<span class="files-panel-title">任务文件</span>
<label class="file-upload" title="上传文件" aria-label="上传文件">
<input type="file" id="file-input" multiple hidden>
<svg viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line></svg>
</label>
</div>
<div class="files-list" id="files-list"></div>
<div class="files-panel-progress hidden" id="fp-progress" aria-live="polite">
<div class="fp-track"><div class="bar" id="fp-progress-bar"></div></div>
<span class="pct" id="fp-progress-pct">0%</span>
</div>
<div class="files-panel-footer">
<div class="files-panel-footer-left">
<span class="file-check files-panel-check" id="files-toggle-all" role="checkbox" aria-checked="false" aria-label="全选" title="全选" tabindex="0"></span>
<span class="files-panel-count" id="files-count">未选择文件</span>
</div>
<div class="files-panel-actions">
<button class="files-fab" id="files-bulk-download" title="批量下载" aria-label="批量下载" disabled>
<svg viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="7 10 12 15 17 10"></polyline><line x1="12" y1="15" x2="12" y2="3"></line></svg>
</button>
<button class="files-fab del" id="files-bulk-delete" title="批量删除" aria-label="批量删除" disabled>
<svg viewBox="0 0 24 24"><polyline points="3 6 5 6 21 6"></polyline><path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"></path><line x1="10" y1="11" x2="10" y2="17"></line><line x1="14" y1="11" x2="14" y2="17"></line></svg>
</button>
</div>
</div>
</div>
<!-- ================= 设置区(覆盖层;入口:侧边栏用户区) ================= -->
<section id="settings-page" class="hidden" aria-label="设置">
<!-- 垫底静态快照层:子页右滑返回时,父页快照垫在这里(仅动画背景,pointer-events:none;滑完重渲染真页) -->
<div id="set-under" aria-hidden="true"></div>
<!-- 当前页层:返回滑动只平移这一层,底下露出垫底的父页 -->
<div id="set-top">
<!-- 顶栏:左侧返回 + 中间标题 + 右侧操作按钮,风格与对话页 header 一致 -->
<header class="header">
<button class="icon-btn" id="set-back-btn" title="返回" aria-label="返回">
<svg class="ic" viewBox="0 0 24 24"><polyline points="15 18 9 12 15 6"></polyline></svg>
</button>
<div class="header-center"><div class="header-title" id="set-title">设置</div></div>
<div class="header-right" id="set-actions"><!-- JS 按页注入操作按钮 --></div>
</header>
<div id="set-body"><!-- JS 按页渲染 --></div>
</div>
</section>
<!-- 新建技能弹窗(搬自 index) -->
<div id="skill-create-modal" class="modal-overlay hidden" onclick="if(event.target===this)sUI.closeCreate()">
<div class="modal">
<button class="modal-close-btn" onclick="sUI.closeCreate()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
</button>
<h3>新建技能</h3>
<input type="text" id="skill-new-name" placeholder="技能名(字母/数字/-/_)">
<input type="text" id="skill-new-desc" placeholder="一句话描述(何时使用该技能)">
<button class="primary-btn" onclick="sUI.createSkill()">创建</button>
</div>
</div>
<!-- 平台编辑/新增弹窗(模型池共用:点卡片内任一模型=编辑整个平台;右上+模型=新增整个平台) -->
<div id="model-edit-modal" class="modal-overlay hidden" onclick="if(event.target===this)sUI.mClose()">
<div class="modal modal-wide">
<button class="modal-close-btn" onclick="sUI.mClose()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
</button>
<h3 id="mpe-title">编辑平台</h3>
<input type="text" id="mpe-name" placeholder="平台名(留空取 url 主机名首段)">
<input type="text" id="mpe-url" placeholder="平台上游地址(OpenAI 兼容 /v1)">
<div class="mpe-sec">
<div class="mpe-sec-head"><span>Key列表</span><button class="ghost-btn sm" onclick="sUI.mAddKey()">添加Key</button></div>
<div id="mpe-keys"></div>
</div>
<div class="mpe-sec">
<div class="mpe-sec-head"><span>模型</span><button class="ghost-btn sm" onclick="sUI.mAddModel()">添加模型</button></div>
<div id="mpe-models"></div>
</div>
<div class="btn-row mpe-foot">
<button class="ghost-btn danger hidden" id="mpe-del-btn" onclick="sUI.mDelPlat()">删除平台</button>
<button class="primary-btn" onclick="sUI.mSave()">保存</button>
</div>
<div class="cfg-note">仅写入配置,点击「重启服务」后生效。</div>
</div>
</div>
<!-- MCP 服务编辑/新增弹窗:配置 name / url / 多条 headers / 启用开关;保存后写入 config.yml,重启生效 -->
<div id="mcp-edit-modal" class="modal-overlay hidden" onclick="if(event.target===this)mcpUI.close()">
<div class="modal modal-wide">
<button class="modal-close-btn" onclick="mcpUI.close()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
</button>
<h3 id="mce-title">编辑 MCP 服务</h3>
<input type="text" id="mce-name" placeholder="服务名(留空取 url 主机名首段)">
<input type="text" id="mce-url" placeholder="MCP 服务 JSON-RPC 端点(完整 URL)">
<div class="mpe-sec">
<div class="mpe-sec-head"><span>请求头(headers)</span><button class="ghost-btn sm" onclick="mcpUI.addHeader()">添加 header</button></div>
<div id="mce-headers"></div>
</div>
<div class="mpe-cks" style="margin-top:14px">
<label class="mpe-ck"><input type="checkbox" id="mce-enable" checked>启用</label>
</div>
<div class="btn-row mpe-foot">
<button class="ghost-btn danger hidden" id="mce-del-btn" onclick="mcpUI.del()">删除服务</button>
<button class="primary-btn" onclick="mcpUI.save()">保存</button>
</div>
<div class="cfg-note">仅写入配置,点击「重启服务」后生效。</div>
</div>
</div>
<!-- 全局确认弹窗(替代原生 confirm;搬自 index) -->
<div id="confirm-modal" class="modal-overlay hidden" onclick="if(event.target===this)confirmClose(false)">
<div class="modal">
<h3 id="confirm-title">请确认</h3>
<div class="modal-text" id="confirm-text"></div>
<label class="del-dir hidden" id="confirm-check-wrap"><input type="checkbox" id="confirm-check"> <span id="confirm-check-label"></span></label>
<div class="btn-row">
<button class="ghost-btn" onclick="confirmClose(false)">取消</button>
<button class="primary-btn" id="confirm-ok-btn" onclick="confirmClose(true)">确定</button>
</div>
</div>
</div>
<!-- 全局输入弹窗(替代原生 prompt;搬自 index) -->
<div id="prompt-modal" class="modal-overlay hidden" onclick="if(event.target===this)promptCancel()">
<div class="modal">
<button class="modal-close-btn" onclick="promptCancel()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
</button>
<h3 id="prompt-title">请输入</h3>
<input type="text" id="prompt-input">
<div class="btn-row">
<button class="ghost-btn" onclick="promptCancel()">取消</button>
<button class="primary-btn" onclick="promptOk()">确定</button>
</div>
</div>
</div>
<!-- 已完成/已终止会话:选择模型继续(搬自 index;phase-bar「选择模型」入口) -->
<div id="bind-model-modal" class="modal-overlay hidden" onclick="if(event.target===this)closeModelSwitch()">
<div class="modal">
<div class="msw-header">
<div class="msw-titles">
<h3>切换模型</h3>
<p class="msw-sub">选择一个模型继续当前会话</p>
</div>
<button class="modal-close-btn" onclick="closeModelSwitch()">
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
</button>
</div>
<div class="msw-list" id="bind-model-list"></div>
<div class="msw-footer" id="bind-model-footer"></div>
</div>
</div>
<div id="toast" class="hidden"></div>
</div>
<!-- 图片全屏查看器(点击消息/工具卡中图片打开;双指缩放、放大后可拖动) -->
<div id="img-viewer" class="hidden">
<button class="fs-close" onclick="closeImageViewer()">✕</button>
<img id="img-viewer-img" alt="">
</div>
<!-- 消息全屏查看器(双击气泡/工具卡打开;支持双指缩放) -->
<div id="fs-viewer" class="hidden" onclick="if(event.target===this)closeFullscreen()">
<button class="fs-close" onclick="closeFullscreen()">✕</button>
<div class="fs-panel" id="fs-body"></div>
</div>
<script>
/*
* ============================================================================
* 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:marked CDN;缺失/异常时回退转义纯文本) ----------
// 返回 { 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 保持一致) ----------
async function req(method, url, body, isForm) {
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 res = await fetch(url, opt);
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: '<svg class="header-mode-icon" viewBox="0 0 24 24"><path d="M6 3h12l4 6-10 13L2 9z"></path><polyline points="2 9 22 9"></polyline><polyline points="10 3 8 9 12 22"></polyline><polyline points="14 3 16 9 12 22"></polyline></svg>',
},
vision: {
label: '识图专家', hint: '支持图片识别输入',
icon: '<svg class="header-mode-icon" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></svg>',
},
};
// ---------- 全局状态 ----------
const state = {
view: 'welcome', // welcome | chat
mode: 'secretary', // 模式选择区当前选中(仅 welcome 视图可操作)
sessionType: 'secretary', // 当前会话的助手类型(建档时锁定,后续不随模式切换变更)
deepThink: false, // 深度思考开关(仅本地视觉状态,无后端参数)
sessionId: null, // 当前会话
sessionTitle: '', // 当前会话标题
status: '', // 当前会话状态(SSE 更新)
sessions: [], // 抽屉列表缓存
attachments: [], // 待发送附件 {file, name, size}
lastImgBlobUrl: null, // 任务文件图片预览的 blob URL,下次预览或开新图时回收
es: null, // EventSource
streamText: '', // 当前流式累积文本
streamEl: null, // 当前流式 AI 气泡
streamWrap: null, // 当前流式消息容器(.msg.other);思考面板与气泡都挂它上面
streamReasoning: '', // 当前流式累积思考文本
streamThinkEl: null, // 当前流式思考面板的 body 节点(未出现思考时为 null)
toolCards: {}, // tool_call_id -> 工具卡片元素(同步 index 工具卡样式)
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 +
'<span class="header-title-text">' + esc(state.sessionTitle || state.sessionId) + '</span>';
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);
});
// ---------- 消息渲染 ----------
// 旧消息兼容:早期服务端把附件说明拼在正文前(【系统通知】用户上传了文件:...),此处拆开单独展示 📎 行;
// 新版已不再生成这种行,仅历史会话渲染时命中。
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) {
const b64 = btoa(unescape(encodeURIComponent(content)));
// 删除本条:仅已落库消息可删(传 m.id);流式未落库时无 id,不渲染
const del = msgId
? '<button class="act act-del" title="删除本条" data-msg-id="' + msgId + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><path d="M18 6 6 18"></path><path d="m6 6 12 12"></path></svg>' +
'</button>'
: '';
return '<div class="msg-actions">' +
'<span>' + fmtTime(ts) + '</span>' +
'<button class="act act-copy" title="复制" data-b64="' + b64 + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>' +
'</button>' +
del +
'</div>';
}
function userMsgHtml(m) {
const p = parseUploadNotice(m.content);
const attach = p.files && p.files.length
? '<div class="attach-line">📎 ' + esc(p.files.join('、')) + '</div>' : '';
const r = mdHtml(p.text);
// 复制内容取纯文本(不含【系统通知】附件行),与气泡里显示一致
return '<div class="msg me">' +
'<div class="bubble-user' + (r.fmt ? ' md' : '') + '">' + attach + r.html + '</div>' +
actionsHtml(m.created_at, p.text, m.id) +
'</div>';
}
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 '<div class="bubble-ai' + (r.fmt ? ' md' : '') + '">' + r.html + '</div>'; })() : '';
return '<div class="msg other">' + think + bubble + actionsHtml(m.created_at, m.content || '', m.id) + '</div>';
}
// 思考过程折叠面板:summary 固定名「思考过程」+ 右侧复制按钮,body 展示推理全文。
// 历史重渲染默认收起(与原设计一致),流式阶段的展开行为由 ensureStreamThinkPanel 显式控制。
// 复制按钮走 onCopyClick 统一代理:点击时从 DOM 取思考全文(不依赖 b64,流式增量也能复制)
const THINK_COPY_BTN = '<button class="act act-copy" title="复制思考内容">' +
'<svg class="ic sm" viewBox="0 0 24 24"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>' +
'</button>';
function thinkPanelHtml(text) {
return '<details class="msg-think"><summary>思考过程' + THINK_COPY_BTN + '</summary><div class="msg-think-body">' + esc(text) + '</div></details>';
}
// 「压缩」摘要卡片:流式收尾与历史重渲染共用的头部(图标 + 标题 + 右侧说明)。
function summaryHeaderHtml() {
return '<summary>' +
'<svg class="sum-ic" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round">' +
'<ellipse cx="12" cy="5" rx="8" ry="2.5"></ellipse>' +
'<path d="M4 5v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5V5"></path>' +
'<path d="M4 11v6c0 1.4 3.6 2.5 8 2.5s8-1.1 8-2.5v-6"></path>' +
'</svg>' +
'<span>上下文总结</span>' +
'<span class="sum-hint">后续对话以此为起点</span>' +
'</summary>';
}
// 历史重渲染:被标记 type='summary' 的摘要消息渲染成摘要卡片(默认收起,点开可重现)。
// 工具卡不挂:摘要行永远不带 tool_calls;复制/删除按钮照常提供。
function summaryMsgHtml(m) {
const r = mdHtml(m.content || '');
return '<div class="msg other">' +
'<details class="msg-summary">' + summaryHeaderHtml() +
'<div class="msg-summary-body"><div class="bubble-ai' + (r.fmt ? ' md' : '') + '">' + r.html + '</div></div>' +
'</details>' +
actionsHtml(m.created_at, m.content || '', m.id) +
'</div>';
}
// ---------- 工具调用卡片(样式/交互同步 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 '<button class="act act-copy" title="复制参数与结果" data-b64="' + b64 + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><rect x="9" y="9" width="13" height="13" rx="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg></button>';
}
// 工具卡「删除本条」:删的是 tool 消息行;后端会把它在父 assistant 里的调用同步摘除。
// msgId = tool 消息的库行 id(历史渲染传 m.id;实时由 tool_result 事件的 msg_id 携带)
function toolDelBtnHtml(msgId) {
if (!msgId) return '';
return '<button class="act act-del" title="删除本条" data-msg-id="' + msgId + '">' +
'<svg class="ic sm" viewBox="0 0 24 24"><path d="M18 6 6 18"></path><path d="m6 6 12 12"></path></svg></button>';
}
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);
div.innerHTML =
'<details' + (open ? ' open' : '') + '><summary><span class="spin">◌</span>' +
'<span class="tool-name">' + esc(name) + '</span>' +
'<span class="tool-args">' + esc(toolArgsSummary(name, argsStr)) + '</span></summary>' +
'<pre class="tool-args-full">' + esc(toolArgsFull(argsStr)) + '</pre>' +
'<pre class="tool-result">执行中…</pre>' +
// 时间行/复制按钮在折叠体内:展开卡片才可见
'<div class="tool-time">' + fmtTime(createdAt || Date.now()) + '</div></details>';
return div;
}
// 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]) continue; // tool_call 事件已经建过同一张卡,不重复创建
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',
'<div class="archived-note">以上消息已存档,不再发送给 AI;后续对话从摘要开始</div>');
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);
}
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.toolCards = {};
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 = '<div class="drawer-empty">描述你的需求,AI 会和你讨论并直接干活。</div>';
}
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')) {
while (tail.firstChild) firstArc.insertBefore(tail.firstChild, firstArc.firstChild);
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 含提示行高,差值即「新增页高 - 提示行高」,提示行被新页尾行原位覆盖
while (frag.firstChild) box.insertBefore(frag.firstChild, box.firstChild);
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
? '<div class="attach-line">📎 ' + esc(fileNames.join('、')) + '</div>' : '';
const r = mdHtml(content);
const wrap = document.createElement('div');
wrap.className = 'msg me';
wrap.innerHTML = '<div class="bubble-user' + (r.fmt ? ' md' : '') + '">' + attach + r.html + '</div>' +
actionsHtml(Date.now(), content, msgId);
$('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 = '<div class="typing"><i></i><i></i><i></i></div>';
$('chat-view').appendChild(ph);
state.typingEl = ph;
scrollBottom();
}
function removeTyping() {
if (state.typingEl) { state.typingEl.remove(); state.typingEl = null; }
}
// ---------- 会话列表(抽屉) ----------
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 '<span class="st-dot ' + esc(st) + '" aria-label="' + label + '"></span>';
}
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 = '<div class="drawer-empty">没有找到相关对话</div>'; return; }
let html = '', lastGroup = null;
for (const s of list) {
const g = groupLabel(s.updated_at);
if (g !== lastGroup) { html += '<div class="group-label">' + esc(g) + '</div>'; lastGroup = g; }
html += '<div class="conv-wrap">' +
'<button class="conv-item' + (s.id === state.sessionId ? ' active' : '') + '" data-id="' + esc(s.id) + '">' +
'<span class="conv-title">' + esc(s.title || s.id) + '</span>' + drawerStatusDot(s) +
'</button>' +
'<button class="conv-del" data-del="' + esc(s.id) + '" title="删除会话" aria-label="删除会话">' +
'<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>' +
'</button>' +
'</div>';
}
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 = '确定删除会话 <b>「' + esc(title) + '」</b> 吗?删除后无法恢复。' +
'<div class="confirm-sub">会话 ID:' + esc(id) + '</div>';
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.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;
}
async function openSession(id) {
closeStream();
removeTyping();
setFilesPanel(false); // 会话切换,收起文件面板防旧列表残留
state.sessionId = id;
state.status = '';
// 先从抽屉列表缓存取会话类型,让顶部 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.streaming = false;
state.attachments = [];
userPaused = false;
state.chatHasMore = false; // 分页状态先复位:防详情返回前用旧会话的游标/标志拉到错会话的消息
state.chatOldestId = null;
state.chatLoadedCount = 0;
renderAttachChips();
clearUploadCards(); // 切会话清掉旧会话的上传卡片
renderDrawerList(); // 会话切换后立刻重画抽屉高亮,避免下次打开才看到更新
setView('chat');
$('chat-view').innerHTML = '<div class="drawer-empty">加载中…</div>';
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.attachments = [];
state.streamEl = null;
state.streamText = '';
state.toolCards = {};
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;
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';
}
}
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 = '<div class="empty-tip">加载中…</div>';
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 = '<div class="empty-tip">还没有配置模型。</div>';
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 '<div class="msw-item' + (disabled ? ' disabled' : '') + '"' +
(disabled ? '' : ' onclick="bindModel(\'' + esc(m.id) + '\')"') + '>' +
'<div class="msw-radio"></div>' +
'<div class="msw-info">' +
'<div class="msw-name">' + esc(m.display_name || m.mid || m.id) +
(title ? ' <span class="msw-busy">' + title.trim() + '</span>' : '') + '</div>' +
'<div class="msw-tags">' +
(m.vision ? '<span class="msw-tag vision">Vision</span>' : '') +
'<span class="msw-tag thinking">Thinking</span>' +
'</div>' +
'</div>' +
'</div>';
}).join('');
return '<div class="msw-group">' +
'<div class="msw-group-header">' +
'<span class="msw-dot" style="background:' + dotColor + '"></span>' +
'<span>' + esc(g.name) + '</span>' +
'<span class="msw-group-keys">' + g.keyCount + ' key' + (g.keyCount > 1 ? 's' : '') + '</span>' +
'</div>' +
itemHtml +
'</div>';
}).join('');
footer.textContent = '共 ' + avail + ' 个模型可用';
} catch (e) {
list.innerHTML = '<div class="empty-tip">读取模型列表失败:' + e.message + '</div>';
}
}
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; }
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);
}
}
// 压缩动作选择弹窗:右上 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 =
'<div class="modal">' +
'<button class="modal-close-btn" data-act="cancel" aria-label="关闭">' +
'<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>' +
'</button>' +
'<h3 id="compress-modal-title">压缩上下文</h3>' +
'<div class="modal-body" style="font-size:14px;line-height:1.55;color:#555;padding:4px 0 12px;">' +
'AI 将基于当前上下文生成结构化总结;完成后摘要之前的旧消息都会<b>存档</b>,不再发送给 AI,后续对话从摘要开始。' +
'<br>· 「摘要」= 聊天里<b>保留全部历史展示</b>(旧消息变淡标注已存档),并多一张摘要卡片。' +
'<br>· 「清空」= 直接<b>删除本会话全部聊天记录</b>,从零开始(不可恢复,任务文件保留)。' +
'</div>' +
'<div class="btn-row">' +
'<button class="ghost-btn danger" data-act="clear">清空</button>' +
'<button class="primary-btn" data-act="generate_only">摘要</button>' +
'</div>' +
'</div>';
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',
'<div class="archived-note">以上消息已存档,不再发送给 AI;后续对话从摘要开始</div>');
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';
}
// ---------- 发送 ----------
async function uploadFiles(sessionId, files) {
const fd = new FormData();
for (const f of files) fd.append('files', f.file, f.name);
const r = await req('POST', '/api/sessions/' + sessionId + '/files', fd, true);
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' + 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();
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'); }
}
function connectStream() {
closeStream();
if (!state.sessionId) return;
const es = new EventSource('/api/sessions/' + state.sessionId + '/stream');
state.es = es;
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.streamEl.textContent = state.streamText;
state.streaming = true;
maybeAutoScroll();
updateScrollBottomBtn();
});
es.addEventListener('reasoning_delta', ev => {
const d = JSON.parse(ev.data);
removeTyping();
state.streamReasoning += d.text;
if (!state.streamWrap) ensureStreamWrap();
ensureStreamThinkPanel();
state.streamThinkEl.textContent = state.streamReasoning;
state.streaming = true;
maybeAutoScroll();
updateScrollBottomBtn();
});
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;
} 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;
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() + '<div class="msg-summary-body"></div>';
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));
}
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';
}
});
es.addEventListener('tool_call', ev => {
const d = JSON.parse(ev.data);
removeTyping(); // 工具卡出现也算即时反馈
if (state.toolCards[d.id]) return; // assistant_message 已建卡(含完整参数),不重复创建
// 流式 tool_call:展开卡片,实时看到执行参数与结果,回合结束也不自动折上
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();
});
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;
state.toolCards = {};
updateScrollBottomBtn();
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 = '';
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) ----------
function openFullscreen(el) {
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; });
body.appendChild(clone);
$('fs-viewer').classList.remove('hidden');
}
function closeFullscreen() { $('fs-viewer').classList.add('hidden'); $('fs-viewer').dispatchEvent(new Event('fs:close')); }
// 双击消息气泡/工具卡 → 全屏查看(操作钮/图片不误触全屏)
$('chat-view').addEventListener('dblclick', function (e) {
if (e.target.closest('.act') || e.target.closest('img')) return;
const el = e.target.closest('.bubble-ai, .bubble-user, .tool-card');
if (el) openFullscreen(el);
});
// 点击消息/工具卡里的图片 → 图片全屏查看器(#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 });
})();
// ---------- 输入区 ----------
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) {
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)); // 点遮罩收起
// 任务文件面板多选状态:Set 保留当前选中的文件路径;filesAllPaths 保留当前面板所有路径。
// 文件夹作为整体选中项存储(键加 d: 前缀),下载时由后端打包成 zip。
const DIR_SEL_PREFIX = 'd:';
const fileSelected = new Set();
let filesAllPaths = [];
let filesTreeRoot = null; // 最近一次渲染的目录树(供全选折叠/有效性计算)
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').forEach(dEl => {
const ck = dEl.querySelector(':scope > .file-dir-head > .file-check');
if (!ck) return;
if (fileSelected.has(dirSelKey(dEl.dataset.dir))) { ck.setAttribute('aria-checked', 'true'); return; }
const rows = Array.prototype.slice.call(dEl.querySelectorAll('.file-row'));
ck.setAttribute('aria-checked',
(rows.length > 0 && rows.every(r => isFileEffectivelySelected(r.dataset.path || ''))) ? '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();
}
// ---------- 目录分组:后端返回扁平列表(路径可含子目录),前端组树渲染 ----------
// 规则:每一级都是目录在上、文件在下;同级目录按名称排序,同级文件按时间倒序(新的在前)。
// 顶层包一个虚拟的「/」根目录(depth 0):默认只展开根目录本身,即只显示工作目录下的直接子项(一级目录/文件),
// 所有子目录一律收起,用户点到哪一层才展开那一层,不自动展开其下所有文件。
// filesDirOpen 记住用户手动展开/折叠过的目录(路径 → 是否展开;'' 为顶层「/」),上传/删除重渲染后仍生效。
const filesDirOpen = new Map();
function isDirCollapsed(path, depth) {
const ov = filesDirOpen.get(path);
if (ov !== undefined) return !ov;
return depth > 0; // 只有顶层「/」默认展开,其下所有目录默认收起
}
function fileTimeOf(f) { return f.ctime || f.mtime || 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: [] }
function buildFilesTree(files) {
const root = { name: '', path: '', dirs: new Map(), files: [] };
for (const f of files) {
const segs = String(f.filename).split('/');
let node = root, rel = '';
for (let i = 0; i < segs.length - 1; 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);
}
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 filesIndent(depth) { return 8 + Math.min(depth, 3) * 14; }
function fileRowHtml(f, depth, dirSel) {
// 预览策略:md/txt/html + 图片在 fs-viewer 预览(pdf 不预)
const low = f.filename.toLowerCase();
const fsPv = /\.(md|txt|html?|png|jpe?g|gif|webp|svg)$/.test(low);
const ico = fsPv
? '<svg class="file-ico eye" viewBox="0 0 24 24" aria-label="可预览"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"></path><circle cx="12" cy="12" r="3"></circle></svg>'
: '<svg class="file-ico doc" viewBox="0 0 24 24" aria-label="可下载"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>';
const name = esc(String(f.filename).split('/').pop() || f.filename);
const ftime = fmtTime(f.ctime || f.mtime);
const sel = !!dirSel || isFileEffectivelySelected(f.filename);
return '<div class="file-row' + (fsPv ? ' clickable' : '') + (sel ? ' selected' : '') + '" data-path="' + esc(f.filename) + '" data-preview="' + (fsPv ? '1' : '0') + '" style="padding-left:' + filesIndent(depth) + 'px">' +
'<span class="file-check" role="checkbox" aria-checked="' + (sel ? 'true' : 'false') + '" aria-label="选择"></span>' +
'<div class="file-main">' +
'<div class="file-name">' + name + '</div>' +
'<div class="file-meta">' + ico + '<span class="file-size">' + fmtSize(f.size) + '</span>' +
(ftime ? '<span class="file-time">' + ftime + '</span>' : '') + '</div>' +
'</div>' +
'</div>';
}
// 目录头带勾选框:整个文件夹作为一个选中项(下载时后端打包成 zip);点其余区域仍为折叠/展开。
// dirSel 为真时子孙目录/文件跟随父目录显示选中态。
// 顶层「/」是虚拟节点,不渲染勾选框(不可整体选中,全选语义由底部全选按钮承担),
// 并补回勾选框占位宽度(16px + 8px gap)保持与子级的缩进节奏。
function dirNodeHtml(node, depth, dirSel) {
const dirs = sortDirsByName(Array.from(node.dirs.values()));
sortFilesByTime(node.files);
const isRoot = depth === 0;
const collapsed = isDirCollapsed(node.path, depth);
const under = filesUnderDir(node);
const checked = !!dirSel || fileSelected.has(dirSelKey(node.path)) ||
(under.length > 0 && under.every(isFileEffectivelySelected));
const indent = filesIndent(depth) + (isRoot ? 24 : 0);
return '<div class="file-dir' + (collapsed ? ' collapsed' : '') + '" data-dir="' + esc(node.path) + '">' +
'<div class="file-dir-head" role="button" aria-expanded="' + (collapsed ? 'false' : 'true') + '">' +
(isRoot ? '' : '<span class="file-check" role="checkbox" aria-checked="' + (checked ? 'true' : 'false') + '" aria-label="选择文件夹"></span>') +
'<svg class="file-dir-arrow" viewBox="0 0 24 24"><polyline points="9 18 15 12 9 6"></polyline></svg>' +
'<svg class="file-dir-ico" viewBox="0 0 24 24"><path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"></path></svg>' +
'<span class="file-dir-name">' + esc(node.name || '/') + '</span>' +
'<span class="file-dir-count">' + countDirFiles(node) + ' 个文件</span>' +
'</div>' +
'<div class="file-dir-body">' +
dirs.map(function (d) { return dirNodeHtml(d, depth + 1, checked); }).join('') +
node.files.map(function (f) { return fileRowHtml(f, depth + 1, checked); }).join('') +
'</div>' +
'</div>';
}
// 顶层:整棵树包进虚拟的「/」根目录,目录在上、文件在下(根下的散文件也在该节点内平铺)
function filesTreeHtml(root) {
return dirNodeHtml(root, 0);
}
async function loadFiles() {
if (!state.sessionId) return;
// 重新拉取前清空旧选择,避免脏数据遗留
fileSelected.clear();
filesAllPaths = [];
filesTreeRoot = null;
updateFilesFooter();
try {
const files = await req('GET', '/api/sessions/' + state.sessionId + '/files');
const el = $('files-list');
if (!files.length) {
el.innerHTML = '<div class="empty-tip">还没有文件,在对话框上传或让 AI 生成</div>';
return;
}
filesAllPaths = files.map(f => f.filename);
// 按目录分组渲染(后端已按时间倒序,组内再排一次防旧排序缓存)
filesTreeRoot = buildFilesTree(files);
el.innerHTML = filesTreeHtml(filesTreeRoot);
// 重新渲染后刷新底部计数与按钮状态
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、图片用 <img>
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);
$('fs-viewer').classList.remove('hidden');
} 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 = '<div class="' + cls + '">' + html + '</div>';
openFullscreen(wrap.firstChild);
}
} 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 dirEl = head.closest('.file-dir');
if (!dirEl) return;
const dp = dirEl.dataset.dir;
if (dp && e.target.closest('.file-check')) {
toggleDirSelect(dp, dirEl);
return;
}
const collapsed = dirEl.classList.toggle('collapsed');
head.setAttribute('aria-expanded', collapsed ? 'false' : 'true');
if (dp === undefined) return; // 理论上不会发生:所有目录节点都带 data-dir(顶层「/」为空串)
filesDirOpen.set(dp, !collapsed);
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, dirEl) {
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);
}
const ck = dirEl.querySelector(':scope > .file-dir-head > .file-check');
if (ck) ck.setAttribute('aria-checked', on ? 'true' : 'false');
// 子孙目录/文件跟随父目录选中态;取消时按“自身被选或被其他祖先目录覆盖”重新计算
refreshFileSelStates(dirEl);
updateFilesFooter();
}
// 批量下载:选中项含文件夹(含全选后整目录被覆盖的情况)时,整个选择交给后端打包成
// 一个 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); }
}
// 第二阶段:隐藏 <a> + 服务器直链逐个触发;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 || '')
? '<svg class="ic" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></svg>'
: '<svg class="ic" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>';
}
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 =
'<div class="up-ico">' + uploadIconSvg(file.name) + '</div>' +
'<div class="up-info">' +
'<div class="up-name" title="' + esc(file.name) + '">' + esc(file.name) + '</div>' +
'<div class="up-meta">' + uploadTypeLabel(file.name) + ' · ' + fmtSize(file.size) + '</div>' +
'</div>' +
'<button class="up-x hidden" title="不再随消息告知该文件" aria-label="移除卡片">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>' +
'</button>' +
'<div class="up-mask"><span class="up-pct">0%</span></div>';
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 = '<span class="up-pct">上传失败</span>';
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) =>
'<span class="attach-chip"><span class="name">' + esc(f.name) + '</span>' +
'<button class="rm" data-i="' + i + '" aria-label="移除附件">' +
'<svg class="ic sm" viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>' +
'</button></span>').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();
});
// ---------- 顶栏 ----------
$('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, '&quot;'); } // 属性上下文转义(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 = '<header class="header"><button class="icon-btn" tabindex="-1"><svg class="ic" viewBox="0 0 24 24"><polyline points="15 18 9 12 15 6"></polyline></svg></button>' +
'<div class="header-center"><div class="header-title">' + esc($('set-title').textContent) + '</div></div>' +
'<div class="header-right">' + $('set-actions').innerHTML + '</div></header>' +
'<div class="set-under-body">' + $('set-body').innerHTML + '</div>';
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: '<svg class="ic" viewBox="0 0 24 24"><circle cx="12" cy="8" r="4"></circle><path d="M4 21c0-4 4-6 8-6s8 2 8 6"></path></svg>' },
{ go: 'service', name: '服务', desc: '服务状态 · 系统配置',
icon: '<svg class="ic" viewBox="0 0 24 24"><line x1="4" y1="21" x2="4" y2="14"></line><line x1="4" y1="10" x2="4" y2="3"></line><line x1="12" y1="21" x2="12" y2="12"></line><line x1="12" y1="8" x2="12" y2="3"></line><line x1="20" y1="21" x2="20" y2="16"></line><line x1="20" y1="12" x2="20" y2="3"></line><line x1="1" y1="14" x2="7" y2="14"></line><line x1="9" y1="8" x2="15" y2="8"></line><line x1="17" y1="16" x2="23" y2="16"></line></svg>' },
{ go: 'skills', name: '技能', desc: '技能管理 · 技能文件编辑',
icon: '<svg class="ic" viewBox="0 0 24 24"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon></svg>' },
{ go: 'models', name: '模型', desc: '模型池状态 · 增删改',
icon: '<svg class="ic" viewBox="0 0 24 24"><rect x="4" y="4" width="16" height="16" rx="2"></rect><rect x="9" y="9" width="6" height="6"></rect><line x1="9" y1="1" x2="9" y2="4"></line><line x1="15" y1="1" x2="15" y2="4"></line><line x1="9" y1="20" x2="9" y2="23"></line><line x1="15" y1="20" x2="15" y2="23"></line><line x1="20" y1="9" x2="23" y2="9"></line><line x1="20" y1="14" x2="23" y2="14"></line><line x1="1" y1="9" x2="4" y2="9"></line><line x1="1" y1="14" x2="4" y2="14"></line></svg>' },
{ go: 'mcp', name: 'MCP', desc: 'MCP 服务 · 增删改',
icon: '<svg class="ic" viewBox="0 0 24 24"><rect x="3" y="4" width="18" height="16" rx="2"></rect><line x1="3" y1="10" x2="21" y2="10"></line><circle cx="7" cy="15" r="1.2" fill="currentColor" stroke="none"></circle><circle cx="12" cy="15" r="1.2" fill="currentColor" stroke="none"></circle><circle cx="17" cy="15" r="1.2" fill="currentColor" stroke="none"></circle></svg>' },
];
function setPageHome(ctx) {
setTitle('设置');
setActions('');
setBody('<div class="set-scroll set-home">' + SET_CARDS.map(c =>
'<button class="set-card" data-go="' + c.go + '">' +
'<span class="set-ico">' + c.icon + '</span>' +
'<span class="set-tt"><span class="set-name">' + c.name + '</span>' +
'<span class="set-desc">' + c.desc + '</span></span>' +
'<svg class="ic sm set-arrow" viewBox="0 0 24 24"><polyline points="9 6 15 12 9 18"></polyline></svg>' +
'</button>').join('') + '</div>');
}
// ---------- 页:账户(修改密码 / 退出登录) ----------
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 '<div class="settings-card user-card">' +
'<div class="user-avatar" style="background:' + avatarColor(me) + '">' + esc(userInitials(me)) + '</div>' +
'<div class="set-user-name">' + esc(me) + '</div>' +
'<div class="user-acts">' +
'<button class="ghost-btn" onclick="sUI.changePassword()">修改密码</button>' +
'<button class="ghost-btn" onclick="sUI.logout()">退出登录</button>' +
'</div></div>';
}
async function setPageAccount(ctx) {
setTitle('账户');
setActions('');
setBody('<div class="set-scroll"><div class="empty-tip">加载中…</div></div>');
// 单个 /api/me 即可判认证开关:启用认证时中间件保证已登录,user 必有;
// 未启用时 createAuth 提前返回,该路由不存在 → 404。无需再拉 /api/system/status
let me;
try {
me = await req('GET', '/api/me');
} catch (e) {
if (ctx()) setBody('<div class="set-scroll"><div class="empty-tip">' +
(e.status === 404 ? '未启用登录认证,无账户设置。' : '加载失败:' + esc(e.message)) + '</div></div>');
return;
}
if (!ctx()) return;
if (!me || !me.user) {
setBody('<div class="set-scroll"><div class="empty-tip">未启用登录认证,无账户设置。</div></div>');
return;
}
setBody('<div class="set-scroll">' + userCardHtml(me.user) + '</div>');
}
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' },
] },
{ 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 '<div class="cfg-kv"><label>' + esc(label) + '</label><b>' + esc(dispVal(v)) + '</b></div>';
}
function svcCardHtml(st) {
let html = '<div class="settings-card"><h4>服务状态' +
(SET.pendingKeys.size ? ' <span class="badge held">待重启生效</span>' : '') + '</h4>';
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 += '<button class="primary-btn" id="restart-btn" style="margin-top:8px" onclick="sUI.restart()">重启服务</button>' +
'<div class="cfg-note">配置改动重启后生效;重启约需十几秒,期间页面暂不可用。非 Docker 部署不会自动拉起。</div></div>';
return html;
}
function cfgInputHtml(it) {
const cur = getByPath(SET.effCfg, it.path);
const v = cur == null ? '' : String(cur);
if (it.type === 'text') {
return '<div class="cfg-kv"><label>' + esc(it.label) + '</label>' +
'<input class="cfg-input" type="text"' +
' data-path="' + att(it.path) + '" data-type="text" data-label="' + att(it.label) + '" data-orig="' + att(v) + '"' +
' value="' + att(v) + '" placeholder="如:中文 / English"></div>';
}
const step = it.type === 'float' ? ' step="any"' : ' step="1"';
return '<div class="cfg-kv"><label>' + esc(it.label) + '</label>' +
'<input class="cfg-input" type="number"' + step +
' inputmode="decimal"' +
' data-path="' + att(it.path) + '" data-type="' + it.type + '" data-label="' + att(it.label) + '" data-orig="' + att(v) + '"' +
' value="' + att(v) + '"></div>';
}
function formCardHtml() {
let html = '';
for (const g of CFG_FORM) {
html += '<div class="settings-card"><h4>' + esc(g.group) + '</h4>';
html += g.items.map(cfgInputHtml).join('');
html += '</div>';
}
html += '<button class="primary-btn" id="cfg-save-btn" onclick="sUI.saveForm()">更新配置</button>' +
'<div class="cfg-note" style="margin-bottom:12px">更新即写入 config.yml(注释保留);多数配置需重启服务后生效。' +
'模型、账号、MCP 等请用右上角配置文件编辑。</div>';
return html;
}
async function setPageService(ctx) {
setTitle('服务');
setActions('<button class="icon-btn" title="编辑配置文件" onclick="sUI.openCfg()">' +
'<svg class="ic" viewBox="0 0 24 24"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.12 2.12 0 0 1 3 3L12 15l-4 1 1-4z"></path></svg></button>');
setBody('<div class="set-scroll" id="svc-body"><div class="empty-tip">加载中…</div></div>');
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('<div class="set-scroll"><div class="empty-tip">加载失败:' + esc(e.message) + '</div></div>');
}
}
// 表单保存:收集与打开时不同的项,逐项 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('<button class="icon-btn" title="校验并保存" onclick="sUI.saveCfg()">' +
'<svg class="ic" viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></svg></button>');
setBody('<div class="set-editor"><div class="cfg-err hidden" id="cfg-editor-err"></div>' +
'<textarea id="set-editor-area" spellcheck="false" autocomplete="off" autocapitalize="off"></textarea></div>');
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('<div class="set-scroll"><div class="empty-tip">读取失败:' + esc(e.message) + '</div></div>');
}
}
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('<button class="icon-btn" title="新建技能" onclick="sUI.openCreate()">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg></button>');
setBody('<div class="set-scroll" id="skills-list"><div class="empty-tip">加载中…</div></div>');
try {
const rows = await req('GET', '/api/skills');
if (!ctx()) return;
const el = $('skills-list');
if (!el) return;
if (!rows.length) {
el.innerHTML = '<div class="empty-tip">还没有技能,点右上角 + 新建一个。</div>';
return;
}
el.innerHTML = rows.map(s => {
const a = encodeURIComponent(s.name);
return '<div class="session-card" onclick="sUI.open(\'' + a + '\')">' +
'<div class="session-main">' +
'<div class="session-name">' + esc(s.name) +
(s.has_md ? '' : ' <span class="badge cancelled">缺 SKILL.md</span>') +
(s.entry ? ' <span class="badge active">' + s.entry + ' 入口</span>' : '') +
'</div>' +
'<div class="skill-desc">' + esc(s.description || '') + '</div>' +
'<div class="session-meta"><span>' + s.file_count + ' 个文件</span>' +
'<span>' + fmtSize(s.size) + '</span>' +
(s.mtime ? '<span>' + fmtTime(s.mtime) + '</span>' : '') + '</div>' +
'</div>' +
'<div class="card-acts">' +
'<button class="card-act" onclick="event.stopPropagation();sUI.renameSkill(\'' + a + '\')">改名</button>' +
'<button class="card-act del" onclick="event.stopPropagation();sUI.deleteSkill(\'' + a + '\')">删除</button>' +
'</div>' +
'</div>';
}).join('');
} catch (e) {
if (ctx()) setBody('<div class="set-scroll"><div class="empty-tip">加载失败:' + esc(e.message) + '</div></div>');
}
}
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('<label class="icon-btn" title="上传文件">' +
'<input type="file" style="display:none;" onchange="sUI.onUpload(event)">' +
'<svg class="ic" viewBox="0 0 24 24"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line></svg></label>');
setBody('<div class="set-scroll" id="skill-detail"><div class="empty-tip">加载中…</div></div>');
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 = '<button class="primary-btn" style="margin-top:10px" onclick="sUI.newFile()">+ 新建文件</button>';
if (!d.files.length) {
el.innerHTML = '<div class="skill-files"><div class="empty-tip">技能目录是空的</div></div>' + newBtn;
return;
}
el.innerHTML = '<div class="skill-files">' + d.files.map(f => {
const a = encodeURIComponent(f.filename);
return '<div class="file-row" onclick="sUI.editFile(\'' + a + '\')">' +
'<svg class="file-ico" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline></svg>' +
'<span class="file-name">' + esc(f.filename) + '</span>' +
'<span class="file-size">' + fmtSize(f.size) + '</span>' +
'<button class="file-act" onclick="event.stopPropagation();sUI.editFile(\'' + a + '\')">编辑</button>' +
'<button class="file-act del" onclick="event.stopPropagation();sUI.deleteFile(\'' + a + '\')">删除</button>' +
'</div>';
}).join('') + '</div>' + newBtn;
} catch (e) {
if (ctx()) setBody('<div class="set-scroll"><div class="empty-tip">加载失败:' + esc(e.message) + '</div></div>');
}
}
function setPageSkillEditor(ctx) {
setTitle(SET.editorLabel || '编辑文件');
setActions('<button class="icon-btn" title="保存" onclick="sUI.saveFile()">' +
'<svg class="ic" viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></svg></button>');
setBody('<div class="set-editor"><textarea id="set-editor-area" spellcheck="false" autocomplete="off" autocapitalize="off"></textarea></div>');
$('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 = '<svg viewBox="0 0 24 24"><polyline points="23 4 23 10 17 10"></polyline><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"></path></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
? '<span class="model-card-state pending">待重启</span>'
: '<span class="model-card-state off">已禁用</span>')
: run
? '<span class="model-card-state ' + (run.is_busy ? 'busy' : 'idle') + '">' + (run.is_busy ? '占用中' : '空闲') + '</span>'
: '<span class="model-card-state pending">待重启</span>';
return '<div class="model-card' + (disabled ? ' off' : '') + '" title="点击编辑平台" onclick="sUI.mEdit(' + pi + ')">' +
'<div class="model-card-head">' +
'<span class="model-card-name">' + esc(m.display_name || m.mid || m.id) + '</span>' +
'<span class="model-card-meta">' + esc(m.mid || m.id) +
(run && run.is_busy && run.current_session_id ? ' · 会话 ' + esc(run.current_session_id) : '') + '</span>' +
stateHtml +
'<label class="model-en-sw" title="' + (disabled ? '已禁用,点击启用' : '启用中,点击禁用') + '" onclick="event.stopPropagation()">' +
'<input type="checkbox"' + (disabled ? '' : ' checked') + ' onchange="sUI.mToggleEnable(\'' + encodeURIComponent(m.id) + '\')">' +
'<span class="sw-track"></span>' +
'</label>' +
'</div>' +
'<div class="cfg-kv"><label>今日 token</label><b title="输入 / 输出">' + (run ? fmtTok(run.today_prompt) + ' / ' + fmtTok(run.today_completion) : '--') + '</b></div>' +
'<div class="cfg-kv"><label>累计 token</label><b title="输入 / 输出">' + (run ? fmtTok(run.total_prompt) + ' / ' + fmtTok(run.total_completion) : '--') + '</b></div>' +
'</div>';
}
// 平台卡:头部 = 平台名 + 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 '<div class="mbal-row">' +
'<span class="mbal-key">' + esc(k.api_key ? maskKey(k.api_key) : '无 key') + '</span>' +
'<span class="mbal-val" id="mbal-' + bk + '" title="' + esc(balTitle(bk)) + '">' + balText(bk) + '</span>' +
'<button class="mbal-refresh" id="mbrg-' + bk + '" title="重新查询余额" onclick="event.stopPropagation();sUI.refreshBalance(event,' + pi + ',' + ki + ')">' + BAL_REFRESH_SVG + '</button>' +
'</div>';
}).join('') : '';
return '<div class="model-group' + (open ? ' open' : '') + '" id="mgrp-' + gk + '">' +
'<div class="model-group-head" onclick="sUI.toggleGroup(\'' + gk + '\')">' +
'<svg class="model-group-caret" viewBox="0 0 24 24"><polyline points="9 6 15 12 9 18"></polyline></svg>' +
'<span class="model-group-name">' + esc(p.name || ('平台' + pi)) + '</span>' +
'<span class="model-group-badge">' + keys.length + ' keys</span>' +
'<span class="model-group-meta">' + models.filter(m => m.enable !== false).length + ' / ' + models.length + ' 模型</span>' +
'</div>' +
'<div class="model-group-body' + (open ? '' : ' hidden') + '">' +
balHtml +
(models.length ? models.map(m => modelCardHtml(m, pi)).join('') : '<div class="model-group-empty">该平台暂无模型</div>') +
'</div>' +
'</div>';
}
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 = '<div class="empty-tip">尚未配置模型,点右上角 + 添加平台。</div>';
return;
}
let html = '';
SET.cfgPlatforms.forEach((p, pi) => { html += modelGroupHtml(pi); });
// 有待重启的变更:列表顶部常驻「重启服务」横幅(增/改/删模型、启停开关、平台弹窗保存均经 afterWrite 置位)
box.innerHTML = (SET.modelsPendingRestart
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: '') + html +
'<div class="empty-tip">token 显示格式为「输入 / 输出」。</div>';
} catch (e) {
const box = $('model-cards');
if (box && (!ctx || ctx())) box.innerHTML = '<div class="empty-tip">加载失败:' + esc(e.message) + '</div>';
}
}
function setPageModels(ctx) {
setTitle('模型池');
setActions('<button class="icon-btn" title="添加模型" onclick="sUI.openAdd()">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg></button>');
setBody('<div class="set-scroll" id="model-cards"><div class="empty-tip">加载中…</div></div>');
// 余额与展开态跨设置内导航保持(仅 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 '<div class="mpe-row">' +
'<input class="mpe-grow" type="text" placeholder="' + esc(ph) + '" value="' + esc(r.api_key) + '" oninput="sUI.mKeyApi(' + i + ',this.value)">' +
'<button class="mpe-del" title="删除此 Key" onclick="sUI.mDelKey(' + i + ')">×</button>' +
'</div>';
}
// 模型子卡片两行:上行配 id,下行勾 vision/enable。id 可改(仅改 config.yml,重启生效)。
// display_name/concurrency/type 不进弹窗:保存只按细粒度 path 改,不碰文件里其余字段。
function pfModelsRowHtml(r, i) {
return '<div class="mpe-mcard">' +
'<div class="mpe-row">' +
'<input class="mpe-grow" type="text" placeholder="id(上游模型名)" value="' + esc(r.id) + '" oninput="sUI.mModId(' + i + ',this.value)">' +
'<button class="mpe-del" title="删除此模型" onclick="sUI.mDelModel(' + i + ')">×</button>' +
'</div>' +
'<div class="mpe-cks">' +
'<label class="mpe-ck"><input type="checkbox"' + (r.vision ? ' checked' : '') + ' onchange="sUI.mModVision(' + i + ',this.checked)">图片输入</label>' +
'<label class="mpe-ck"><input type="checkbox"' + (r.enable !== false ? ' checked' : '') + ' onchange="sUI.mModEnable(' + i + ',this.checked)">启用</label>' +
'</div>' +
'</div>';
}
// 行下标变化后需重渲染(事件处理器里捕获了旧 i),故增删后重建两段行列表。
function renderPfRows() {
if (!pfEdit) return;
$('mpe-keys').innerHTML = pfEdit.keys.map(pfKeysRowHtml).join('') || '<div class="model-group-empty">至少保留一个 Key</div>';
$('mpe-models').innerHTML = pfEdit.models.map(pfModelsRowHtml).join('') || '<div class="model-group-empty">至少保留一个模型</div>';
}
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 / enable) ----------
// 与模型池共用 PATCH /api/config 的细粒度 edit 接口:
// · 新增 = append 到 mcp_servers;
// · 删 = delete mcp_servers[pi];
// · 改 = setIn mcp_servers[pi].(name|url|enable);headers 是普通键值对象,整体 setIn 一次到位。
// 运行配置(cg.effective.mcp_servers)即文件刚解析后的视图,按 pi 直接定位;重启后才会重新发现工具。
let mcpEdit = null; // 工作态:{ idx, headers:[{key, value}] };idx=-1 为新增
async function setPageMcp(ctx) {
setTitle('MCP 服务');
setActions('<button class="icon-btn" title="添加 MCP 服务" onclick="mcpUI.add()">' +
'<svg class="ic" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></svg></button>');
setBody('<div class="set-scroll" id="mcp-list"><div class="empty-tip">加载中…</div></div>');
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
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: '') + '<div class="empty-tip">尚未配置 MCP 服务,点右上角 + 添加。</div>';
return;
}
const banner = SET.mcpPendingRestart
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: '';
box.innerHTML = banner + SET.cfgMcp.map(mcpCardHtml).join('') +
'<div class="empty-tip">点卡片编辑 MCP 服务,启用后启动时发现其工具并追加到内置工具之后。</div>';
} catch (e) {
const b = $('mcp-list');
if (b && (!ctx || ctx())) b.innerHTML = '<div class="empty-tip">加载失败:' + esc(e.message) + '</div>';
}
}
// MCP 卡:头部 = 名称 + url + enable 状态;体内 = headers 键值列表。整卡点击进入编辑。
function mcpCardHtml(s, pi) {
const off = s.enable === false;
const stateHtml = off ? '<span class="model-card-state off">已禁用</span>' : '<span class="model-card-state idle">启用</span>';
const entries = Object.entries(s.headers || {});
const headersHtml = entries.length
? entries.map(([k, v]) => '<div class="cfg-kv"><label>' + esc(k) + '</label><b>' + esc(v) + '</b></div>').join('')
: '<div class="cfg-kv"><label>(无)</label><b>--</b></div>';
return '<div class="model-card" onclick="mcpUI.edit(' + pi + ')">' +
'<div class="model-card-head">' +
'<span class="model-card-name">' + esc(s.name || ('MCP-' + pi)) + '</span>' +
'<span class="model-card-meta">' + esc(s.url || '') + '</span>' +
stateHtml +
'</div>' + headersHtml +
'</div>';
}
// 弹窗打开: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} 均为编辑行;空行也保留(用户可能想填)
headers: add
? [{ key: '', value: '' }]
: Object.entries(s.headers || {}).map(([k, v]) => ({ key: k, value: String(v) })),
};
$('mce-title').textContent = add ? '添加 MCP 服务' : '编辑 MCP 服务';
$('mce-name').value = add ? '' : (s.name || '');
$('mce-url').value = add ? '' : (s.url || '');
$('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) {
return '<div class="mpe-row">' +
'<input class="mpe-grow" type="text" placeholder="Header 名(如 Authorization)" value="' + esc(r.key) + '" oninput="mcpUI.setHeader(' + i + ',\'key\',this.value)">' +
'<input class="mpe-grow" type="text" placeholder="值" value="' + esc(r.value) + '" oninput="mcpUI.setHeader(' + i + ',\'value\',this.value)">' +
'<button class="mpe-del" title="删除此 header" onclick="mcpUI.delHeader(' + i + ')">×</button>' +
'</div>';
}
function renderMcpHeaders() {
if (!mcpEdit) return;
const box = $('mce-headers');
if (!mcpEdit.headers.length) box.innerHTML = '<div class="model-group-empty">未配置 header</div>';
else box.innerHTML = mcpEdit.headers.map(mcpHeaderRowHtml).join('');
}
function addMcpHeader() {
if (!mcpEdit) return;
mcpEdit.headers.push({ key: '', value: '' });
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;
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;
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 });
// headers 仅在内容变更时整体 setIn;避免无意义重写(顺序可能不同)
const newH = {};
for (const r of mcpEdit.headers) {
const k = String(r.key || '').trim();
const v = String(r.value || '').trim();
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); // 侧边栏底部展示真实登录用户(未启用认证/拉取失败时静默回退默认占位)
})();
</script>
</body>
</html>