Files
agent/app/server/public/js/settings.js
T
kicer 2e2e47171f refactor(ui): 全站 svg 图标收进 index.html 的 symbol sprite
前端 99 处 svg、56 个唯一图形(× 号 11 次、+ 号 6 次、复制与文档各 5 次),
43 处是纯冗余路径:改一个图标得在两三个文件里同步,加个新图标又要复制一份 path。
现在几何图形统一定义在 index.html 里的一份 sprite,引用写成
<svg 原属性><use href="#i-xxx"/></svg>——外层 class、尺寸、fill/stroke 原样保留,
所以大小和描边仍归各处 CSS 管(.ic / .tree-act svg / .files-fab svg),形状逐像素照搬。

脚本按几何指纹建映射,99 处全部命中,零未匹配;校验结果 symbol 56 个、
引用 99 处、无缺失、无未被引用、sprite 外无残留几何标签,JS 全部 node --check 通过。
同形但历史写法不同的(folder/folder-b/folder-c、x-line/x-line-b/x-path、eye/eye-sm 等)
各留一份 symbol,保证替换前后完全一致,后续要收敛只改引用指向即可。

sprite 容器用 position:absolute + 零尺寸,不用 display:none:后者在部分旧浏览器上
会让被引用的 symbol 也一并不渲染。

体积:index.html +6KB(sprite 定义),js 合计 -5.3KB,总量基本持平。
2026-11-13 15:20:10 +08:00

2100 lines
110 KiB
JavaScript
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.
// 设置区(页面栈/账户/服务/config/技能/模型池/MCP)+ 全局初始化(必须最后加载,初始化段在文件尾)
'use strict';
// 「新建会话」入口已并入顶部动作区(见 sessions.js 的 data-act="new"),此处不再单独绑 #new-chat-btn
// ============================================================================
// 设置区(侧边栏用户区点击进入;页面搬自 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 时刷新;右滑返回垫底用)
role: 'user', // 当前登录用户角色(admin | user);启动时由 /api/me 回填
authEnabled: true, // 是否启用多用户认证(/api/me 返回 auth:false = 未启用,单用户自用)
pendingKeys: new Set(), // 已写盘、尚未重启生效的顶层配置段
effCfg: null, cfgOrig: '',
users: [], userModels: [], // 用户管理页:账号/角色/默认模型 + 可选模型清单
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(模块级变量)
modelProfileNames: [], // profile 下拉选项(顶层 model_profiles 的 key)
// MCP 服务页:cfgMcp 缓存当前列表;改动待重启生效时置位,顶部常驻重启横幅
cfgMcp: [], mcpPendingRestart: false,
mcpStatus: null, // 运行态连接状态:key = name|url|mode(见 mcpStatusKey);null = 没拿到,不显示标记
presets: null, // 平台/MCP 预设(GET /api/config/presets),设置页各页共用
};
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} 可选:展示一个默认勾选状态可改的复选框
// opts.cancelText 可选:改左键文案(如「直接上传」),缺省「取消」
// resolve: true=确定 / false=取消 / null=右上 X 或点遮罩关闭(对只认布尔的旧调用方等同取消)
// 确认/取消后在 state._confirmChecked 读出勾选状态(不破坏现有调用方签名)
function confirmModal(title, text, okText, danger, opts) {
state._confirmChecked = !!(opts && opts.checkbox); // 未传 opts 时 reset 为 false
$('confirm-cancel-btn').textContent = (opts && opts.cancelText) || '取消';
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');
});
}
// 调用方语义见 confirmModal:true=确定 / false=取消 / null=X、遮罩
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 = [SET.role === 'admin' ? 'home' : 'account']; SET.snaps = {}; setUnderHide();
// 桌面端保留左侧栏:设置页是 #app 内的 absolute 覆盖层,自然只占侧栏右侧区域,
// 左栏(会话/文件)保持可见可用。
$('settings-page').classList.remove('hidden'); renderSetPage();
const b = $('da-settings'); if (b) b.classList.add('active'); // 侧栏底部图标同步选中态
}
function closeSettings() {
SET.stack = []; SET.snaps = {}; setUnderHide();
// 退回会话页才重置模型池状态:平台卡全部折叠、余额清空,下次进入重新自动查
SET.expandedGroups = {}; SET.balanceByGroup = {}; SET.balanceRequested = {};
$('settings-page').classList.add('hidden');
const b = $('da-settings'); if (b) b.classList.remove('active');
}
// 当前页静态快照(顶栏+正文):右滑返回时垫底,呈现原生导航栈的视差感。
// 快照里的 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"><use href="#i-chevron-left"/></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 === 'users') return setPageUsers(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"><use href="#i-user"/></svg>' },
{ go: 'users', name: '用户', desc: '账号 · 角色 · 默认模型', adminOnly: true, needAuth: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-users"/></svg>' },
{ go: 'service', name: '服务', desc: '服务状态 · 系统配置', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-sliders-v"/></svg>' },
{ go: 'skills', name: '技能', desc: '技能管理 · 技能文件编辑', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-zap"/></svg>' },
{ go: 'models', name: '模型', desc: '模型池状态 · 增删改', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-cpu"/></svg>' },
{ go: 'mcp', name: 'MCP', desc: 'MCP 服务 · 增删改', adminOnly: true,
icon: '<svg class="ic" viewBox="0 0 24 24"><use href="#i-layout"/></svg>' },
];
function setPageHome(ctx) {
setTitle('设置');
setActions('');
// 普通用户只保留账户页;用户管理卡另需多用户认证启用
const cards = SET_CARDS.filter(c => (!c.adminOnly || SET.role === 'admin') && (!c.needAuth || SET.authEnabled));
setBody('<div class="set-scroll set-home">' + 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"><use href="#i-chevron-right-b"/></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];
}
// 侧栏底部已改成纯图标操作栏,不再展示登录用户名(用户信息仍在设置页「账户」里),
// 所以原来的 loadDrawerUser 已随之删除。
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 必有;
// 未启用时回 auth:false + user:null → 只是没有密码/登出卡,画像仍渲染(未认证 = 空串键隐式单用户)。
let me = null;
try { const r = await req('GET', '/api/me'); if (r && r.user) me = r; } catch (_) { /* 一律按无账户信息处理 */ }
let p = null, pErr = '';
try { p = await req('GET', '/api/profile'); } catch (e) { pErr = String((e && e.message) || e); }
if (!ctx()) return;
let html = '<div class="set-scroll">';
if (me) html += userCardHtml(me.user);
// 微信内联卡排画像前(更高频入口);占位隐藏,wxInitZone 拉到状态才显形(未配置/未连且无绑定 → 始终隐藏)
html += '<div class="settings-card" id="wx-zone" style="display:none"></div>';
html += pErr
? '<div class="settings-card"><h4>用户画像</h4><div class="empty-tip">加载失败:' + esc(pErr) + '</div></div>'
: profileCardHtml(p);
setBody(html + '</div>');
wxInitZone(ctx);
}
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); }
}
// ---------- 页:账户——用户画像编辑卡直接渲染在账户页(无二级页;保存后 renderSetPage 重拉刷新停用徽标) ----------
const PROFILE_FIELDS = [
['honorific', '称谓', '希望被怎么称呼', 80],
['industry', '行业', '影响术语与默认假设', 80],
['preference', '偏好', '顿号分隔标签(AI 会在沟通中自动补充,可手动增删)', 300],
];
function profileCardHtml(p) {
let html = '<div class="settings-card"><h4>用户画像' +
(p.enabled === false ? ' <span class="badge held">已停用</span>' : '') + '</h4>' +
'<div class="cfg-kv"><label>启用</label><input type="checkbox" id="prof-enabled"' + (p.enabled === false ? '' : ' checked') + '></div>';
for (const [k, name, ph, maxLen] of PROFILE_FIELDS) {
const v = String(p[k] || '');
html += '<div class="cfg-kv"><label>' + esc(name) + '</label>' +
'<input class="cfg-input" id="prof-' + k + '" type="text" maxlength="' + (maxLen || 80) + '" data-orig="' + att(v) + '" value="' + att(v) + '" placeholder="' + esc(ph) + '"></div>';
}
html += '<button class="primary-btn" style="margin-top:8px" onclick="sUI.saveProfile()">保存</button>' +
'<div class="cfg-note">画像只记「不知道就会做错」的信息,新会话开始时作为背景注入(会话内不更新;清空字段保存即抹除)。' +
'AI 会在沟通中持续维护(尤其偏好标签,只记明确表达过的,写入自下个会话生效),这里手动改随时可覆盖。' +
'停用后不再注入,AI 的记录请求也会被拒。近期关注(最近会话标题)自动带入背景,无需维护。</div></div>';
return html;
}
async function saveProfile() {
const body = { enabled: $('prof-enabled').checked };
for (const [k] of PROFILE_FIELDS) { const el = $('prof-' + k); if (el) body[k] = el.value.trim(); }
try { await req('PUT', '/api/profile', body); toast('已保存,新会话生效'); renderSetPage(); }
catch (e) { toast('保存失败:' + e.message); }
}
// ---------- 页:用户管理(仅管理员;增删改 + 角色 + 默认模型) ----------
// 数据面全部走 /api/users:后端写盘后热更新内存,新增/删除/改角色/锁模型都即时生效,无需重启。
// 普通用户看不到本页,且后端 /api/users 与 /api/config 都有 requireAdmin 门禁(不只靠藏 UI)。
async function setPageUsers(ctx) {
setTitle('用户');
setActions('<button class="icon-btn" title="添加用户" onclick="sUI.openUserAdd()">' +
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-plus"/></svg></button>');
setBody('<div class="set-scroll" id="user-list"><div class="empty-tip">加载中…</div></div>');
try {
const r = await req('GET', '/api/users');
if (!ctx()) return;
SET.users = (r && r.users) || [];
SET.userModels = (r && r.models) || [];
renderUserList();
} catch (e) {
if (ctx()) setBody('<div class="set-scroll"><div class="empty-tip">加载失败:' + esc(e.message) + '</div></div>');
}
}
function userModelOptions(cur) {
return '<option value="">不锁定(按原逻辑)</option>' + SET.userModels.map(m =>
'<option value="' + att(m.id) + '"' + (m.id === cur ? ' selected' : '') + '>' + esc(m.name || m.id) + '</option>').join('');
}
function renderUserList() {
const box = $('user-list');
if (!box) return;
if (!SET.users.length) {
box.innerHTML = '<div class="empty-tip">还没有用户,点右上角 + 添加。</div>';
return;
}
// 与服务页同一套白卡 + 虚线 kv 行;整卡点击进弹窗编辑(同 MCP 页的列表交互)
box.innerHTML = SET.users.map((u, i) =>
'<div class="settings-card" style="cursor:pointer" onclick="sUI.openUserEdit(' + i + ')">' +
'<h4>' + esc(u.user) + (u.role === 'admin' ? ' <span class="badge active">管理员</span>' : '') + '</h4>' +
'<div class="cfg-kv"><label>角色</label><b>' + (u.role === 'admin' ? '管理员' : '普通用户') + '</b></div>' +
'<div class="cfg-kv"><label>默认模型</label><b>' + esc(u.model || '不锁定') + '</b></div>' +
'</div>').join('') +
'<div class="empty-tip">点用户卡片修改角色、默认模型或密码。</div>';
}
// 弹窗工作态:-1 = 新增;否则 SET.users 下标。用户名不可改(后端也没有改名接口)。
let userEditIdx = -1;
function openUserEditor(i) {
const u = i == null ? null : SET.users[i];
userEditIdx = u ? i : -1;
$('ue-title').textContent = u ? '编辑用户' : '添加用户';
$('ue-user').value = u ? u.user : '';
$('ue-user').disabled = !!u;
$('ue-pass').value = '';
$('ue-pass').placeholder = u ? '留空 = 不修改密码' : '初始密码(至少 6 位)';
$('ue-role').value = u ? u.role : 'user';
$('ue-model').innerHTML = userModelOptions(u ? u.model : '');
$('ue-del-btn').classList.toggle('hidden', !u);
$('user-edit-modal').classList.remove('hidden');
if (!u) $('ue-user').focus();
}
function openUserAdd() { openUserEditor(null); }
function closeUserModal() {
$('user-edit-modal').classList.add('hidden');
userEditIdx = -1;
}
async function saveUser() {
const editing = userEditIdx >= 0;
const user = $('ue-user').value.trim();
const password = $('ue-pass').value;
const role = $('ue-role').value;
const model = $('ue-model').value;
if (!user) return toast('用户名不能为空');
if (!editing && password.length < 6) return toast('密码至少 6 位');
if (editing && password && password.length < 6) return toast('新密码至少 6 位');
try {
if (editing) {
const body = { role, model };
if (password) body.password = password;
await req('PATCH', '/api/users/' + encodeURIComponent(user), body);
} else {
await req('POST', '/api/users', { user, password, role, model });
}
closeUserModal();
toast(editing ? '已保存' : '已添加用户 ' + user);
renderSetPage();
} catch (e) { toast('保存失败:' + e.message); }
}
async function userDelFromModal() {
const u = SET.users[userEditIdx];
if (!u) return;
if (!await confirmModal('删除用户', '删除「' + u.user + '」后该账号立即失效,并一并删除其会话(含任务目录)、画像、长期记忆与微信绑定。此操作不可恢复。', '删除', true)) return;
try {
const r = await req('DELETE', '/api/users/' + encodeURIComponent(u.user));
closeUserModal();
const c = (r && r.cleaned) || {};
const bits = [];
if (c.sessions) bits.push('会话 ' + c.sessions);
if (c.bindings) bits.push('微信绑定 ' + c.bindings);
toast('已删除' + (bits.length ? '(' + bits.join(' / ') + ')' : ''));
renderSetPage();
} catch (e) { toast('删除失败:' + e.message); }
}
// ---------- 微信绑定(账户页内联卡 #wx-zone;一人一绑无子页,签名比对增量更新防闪烁) ----------
// 体验约定:后端绑定/刷新/解绑全 fire-and-forget,点击秒回;QR 只在 has_qr(wxbot 实例快照里码已就绪)
// 后才 fetch 内联 SVG——不再有无码必坏的 <img> 首帧;轮询只在渲染串真的变了才动 DOM,pending 之外停表。
const WX_STATUS = { pending: ['待扫码', 'held'], online: ['已连接', 'active'], expired: ['二维码过期', 'held'], error: ['异常', 'cancelled'] };
let wxTimer = null, wxLast = null, wxCtx = null;
function wxStopTick() { if (wxTimer) { clearInterval(wxTimer); wxTimer = null; } }
async function wxFetch() {
const w = await req('GET', '/api/wechat'); // {enabled, alive, bindings:[行+has_qr]}
const b = (w && w.bindings && w.bindings[0]) || null;
let svg = '';
if (b && b.status === 'pending' && b.has_qr) {
try {
const r = await fetch('/api/wechat/' + encodeURIComponent(b.id) + '/qr?ts=' + Date.now());
if (r.ok) svg = await r.text();
} catch (_) { /* 抖动:本轮无码,下轮再取 */ }
}
return { w, b, svg };
}
function wxCardInnerHtml(w, b, svg) {
if (!w || !w.enabled) return '';
if (!b) {
if (!w.alive) return ''; // 未部署 wxbot 的新用户:整卡隐藏,零打扰
return '<h4>微信绑定</h4>' +
'<button class="primary-btn" onclick="sUI.wxBind()">生成登录二维码</button>' +
'<div class="cfg-note">一人一绑(换号先解绑)。扫码登录后微信里会出现 bot 好友,发给它的消息即进入你的 Agent 会话,回复实时推回。</div>';
}
if (!w.alive) {
return '<h4>微信绑定 <span class="badge cancelled">服务未连接</span></h4>' +
'<div class="cfg-note">wxbot 未启动或网络不通。绑定与登录凭证都在,服务恢复后自动重连。</div>' +
'<div style="margin-top:10px"><button class="ghost-btn" onclick="sUI.wxUnbind(\'' + esc(b.id) + '\')">解绑</button></div>';
}
const st = WX_STATUS[b.status] || [b.status || '-', 'held'];
let html = '<h4>微信绑定 <span class="badge ' + esc(st[1]) + '">' + esc(st[0]) + '</span><span class="wx-id">' + esc(b.id) + '</span></h4>';
if (b.note) html += '<div class="cfg-note">' + esc(b.note) + '</div>';
if (b.bot_account_id) html += '<div class="cfg-kv"><label>微信账号</label><b>' + esc(b.bot_account_id) + '</b></div>';
if (b.status === 'pending') {
html += svg
? '<div class="wx-qr">' + svg + '</div><div class="cfg-note" style="text-align:center">微信扫码 → 手机确认;二维码会过期,也可随时点刷新。</div>'
: '<div class="wx-qr wx-qr-wait">正在获取二维码…</div>';
// 首次绑定尚未成功:不给「解绑」(无物可解、误触还销毁),只留轻量的重新取码
html += '<button class="ghost-btn" onclick="sUI.wxRefresh(\'' + esc(b.id) + '\')">刷新二维码</button>';
} else {
if (b.status === 'expired' || b.status === 'error') {
html += '<button class="primary-btn" onclick="sUI.wxRefresh(\'' + esc(b.id) + '\')">重新获取二维码</button>';
} else if (b.status === 'online') {
html += '<div class="cfg-note">已在线:给 bot 好友发消息即对话(/help 看命令)。网页端可实时看到同一个会话。</div>';
}
html += '<div style="margin-top:10px"><button class="ghost-btn" onclick="sUI.wxUnbind(\'' + esc(b.id) + '\')">解绑</button></div>';
}
return html;
}
function wxPaint(st) {
const el = $('wx-zone');
if (!el) return;
const inner = wxCardInnerHtml(st.w, st.b, st.svg);
if (inner === wxLast) return; // 内容没变绝不动 DOM——轮询不闪的根治点
wxLast = inner;
el.innerHTML = inner;
el.style.display = inner ? '' : 'none';
}
async function wxInitZone(ctx) {
wxCtx = ctx;
wxStopTick();
wxLast = null; // 重新挂载 = 新元素,上一帧比对作废
let st;
try { st = await wxFetch(); } catch (_) { return; }
if (!ctx()) return;
wxPaint(st);
if (st.b && st.b.status === 'pending') {
wxTimer = setInterval(async () => {
if (!ctx()) { wxStopTick(); return; }
let s2;
try { s2 = await wxFetch(); } catch (_) { return; }
if (!ctx()) return;
wxPaint(s2);
if (!(s2.b && s2.b.status === 'pending')) wxStopTick(); // 出结果即停表
}, 2000);
}
}
// 动作统一流:请求(秒回)→ 重绘内联卡(按新状态决定要不要重启轮询)
async function wxAct(fn, okToast) {
try { await fn(); if (okToast) toast(okToast); } catch (e) { toast(e.message); return; }
if (wxCtx) wxInitZone(wxCtx);
}
function wxBind() { return wxAct(() => req('POST', '/api/wechat'), '已发起登录,二维码就绪后自动显示'); }
function wxRefresh(id) { return wxAct(() => req('POST', '/api/wechat/' + encodeURIComponent(id) + '/refresh')); }
async function wxUnbind(id) {
if (!await confirmModal('解绑微信', '解绑后该微信 bot 实例与登录凭证将被销毁,需重新扫码才能恢复;会话记录保留。', '解绑', true)) return;
await wxAct(() => req('DELETE', '/api/wechat/' + encodeURIComponent(id)), '已解绑');
}
// ---------- 页:服务(服务状态 + 系统配置;搬自 settings.js) ----------
const CFG_FORM = [
{ group: 'Agent 会话', items: [
{ path: 'agent.temperature', label: '温度 temperature', type: 'float' },
{ path: 'agent.max_tool_iterations', label: '单会话最大工具轮次', type: 'int' },
{ path: 'agent.max_retries', label: '上游失败重试次数', type: 'int' },
{ path: 'agent.language', label: '回复语言(留空不限)', type: 'text' },
{ path: 'agent.auto_compress_tokens', label: '自动压缩 In 阈值(0=关)', type: 'int' },
] },
{ group: '终端工具', items: [
{ path: 'terminal.default_timeout_ms', label: '命令默认超时(ms)', type: 'int' },
{ path: 'terminal.max_output_chars', label: '输出最大字符数', type: 'int' },
] },
{ group: '技能', items: [
{ path: 'skills.timeout_ms', label: '技能执行超时(ms)', type: 'int' },
] },
{ group: '上传预处理(浏览器端)', items: [
{ path: 'upload.image_compress_threshold_kb', label: '大图阈值(KB)', type: 'int' },
{ path: 'upload.image_max_dim', label: '压缩后长边上限(px)', type: 'int' },
{ path: 'upload.image_quality', label: 'JPEG 质量(0~1)', type: 'float' },
{ path: 'upload.confirm_size_mb', label: '大文件确认阈值(MB)', type: 'int' },
{ path: 'upload.paste_to_file_threshold_chars', label: '粘贴转文件阈值(字符,0=关)', type: 'int' },
] },
];
function kvPlain(label, v) {
return '<div class="cfg-kv"><label>' + esc(label) + '</label><b>' + esc(dispVal(v)) + '</b></div>';
}
// 容量格式化(内存/磁盘量级到 GB/TB,fmtSize 只到 MB 不够用);数字与单位不留空格
function fmtCap(n) {
if (n == null || !Number.isFinite(n)) return '?';
if (n < 1024) return n + 'B';
const units = ['KB', 'MB', 'GB', 'TB'];
let i = -1;
do { n /= 1024; i++; } while (n >= 1024 && i < units.length - 1);
return (n >= 100 ? Math.round(n) : n.toFixed(1)) + units[i];
}
// 带阈值的 kv 行:warn 时值标红(接收拼好的纯文本,内部自行 esc)
function kvWarn(label, text, warn) {
return '<div class="cfg-kv"><label>' + esc(label) + '</label><b' +
(warn ? ' style="color:#c0392b"' : '') + '>' + esc(text) + '</b></div>';
}
// 服务状态里的负载三行(内存/CPU/磁盘),数据来自 /api/system/status 的 sys 字段
function svcLoadHtml(st) {
const sys = st.sys || {};
let html = '';
const mem = sys.mem;
if (mem && mem.total_bytes) {
// 「剩余」= 主机 MemAvailable(含可回收 cache),不是容器配额剩余额度
html += kvWarn('内存', fmtCap(mem.avail_bytes) + ' / ' + fmtCap(mem.total_bytes) +
' (剩余 ' + Math.round(mem.avail_bytes / mem.total_bytes * 100) + '%)', mem.avail_bytes / mem.total_bytes < 0.15);
}
const cpu = sys.cpu;
if (cpu && cpu.cores) {
html += kvWarn('CPU', 'load ' + cpu.load1 + ' / ' + cpu.load5 + ' / ' + cpu.load15 +
' · ' + cpu.cores + ' 核' + (cpu.quota_cores ? '(配额 ' + cpu.quota_cores + ' 核)' : ''),
cpu.load1 > cpu.cores);
}
for (const d of (sys.disks || [])) {
const pct = d.total_bytes ? Math.round((1 - d.free_bytes / d.total_bytes) * 100) : 0;
html += kvWarn('磁盘', fmtCap(d.free_bytes) + ' / ' + fmtCap(d.total_bytes) + ' (已用 ' + pct + '%)', pct >= 90);
}
return html;
}
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 += svcLoadHtml(st);
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"><use href="#i-edit"/></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"><use href="#i-check"/></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"><use href="#i-plus"/></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 === 'mcp' ? 'mcp 后端' : 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"><use href="#i-upload-cloud"/></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"><use href="#i-file-doc"/></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"><use href="#i-check"/></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"><use href="#i-refresh"/></svg>';
// 平台卡折叠/展开(gk = 'p'+pi)。首次展开:给该平台每个 Key 行自动查一次余额(每页会话一次;手动刷新不受限)。
function toggleModelGroup(gk) {
const on = !SET.expandedGroups[gk];
SET.expandedGroups[gk] = on;
const el = $('mgrp-' + gk);
if (!el) return;
el.classList.toggle('open', on);
const body = el.querySelector('.model-group-body');
if (body) body.classList.toggle('hidden', !on);
if (on) {
const pi = Number(gk.slice(1));
const p = SET.cfgPlatforms[pi] || {};
if (SET.balanceTypes.indexOf(String(p.type || '')) >= 0) {
(p.keys || []).forEach((k, ki) => {
const bk = pi + '-' + ki;
if (!SET.balanceRequested[bk] && $('mbal-' + bk)) fetchBalance(bk, pi, ki, false);
});
}
}
}
// 启停切换:写 platforms[pi].models[mi].enable(缺省启用),重启后生效。
// 重启前后端 effective 仍返旧值,成功后本地记入 SET.pendingEnable 保持卡片显示不回弹。
async function toggleModelEnable(rawId) {
const m = SET.cfgModels[idxOf(decodeURIComponent(rawId))];
if (!m) return toast('模型不存在');
const next = m.enable === false; // 当前禁用 → 目标启用
try {
// 与 key 解耦:所有 key 共享同一份 models,enable 改在平台层
await req('PATCH', '/api/config', { path: ['platforms', m.platform_index, 'models', m.model_index, 'enable'], value: next });
// 本地同步:同 id 的所有副本都更新
for (const x of SET.cfgModels) if (x.id === m.id) x.enable = next;
SET.pendingEnable[m.id] = next;
afterWrite();
} catch (e) {
toast('切换失败:' + e.message);
loadModelCards(); // 失败时重拉,回滚开关显示
}
}
// 单个模型卡;点击整卡弹所属平台的编辑弹窗(enable 开关点击不冒泡)。余额是 Key 级概念,在卡体顶部按 Key 分行。
function modelCardHtml(m, pi) {
const run = SET.runtimeById[m.id];
const disabled = m.enable === false;
// 运行池里没有 = 配置新增但还没重启生效;禁用后若仍在池里(未重启)也提示待重启
const stateHtml = disabled
? (run
? '<span class="model-card-state pending">待重启</span>'
: '<span class="model-card-state off">已禁用</span>')
: run
? '<span class="model-card-state ' + (run.slots_used ? 'busy' : 'idle') + '">' + (run.slots_used ? '在用×' + run.slots_used : '空闲') + '</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.slots_used && 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 class="cfg-kv"><label>缓存命中</label><b title="今日缓存 / 累计缓存 tok;历史命中率 = 累计缓存命中 ÷ 累计输入">' +
(run && run.total_prompt ? fmtTok(run.total_cached || 0) + ' · ' + Math.round((run.total_cached || 0) / run.total_prompt * 100) + '%' : '--') +
'</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"><use href="#i-chevron-right-b"/></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'), loadPresets()]);
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) || [];
// 平台编辑器里的 profile 下拉只有名字有意义,不缓存整份 prompt
SET.modelProfileNames = Object.keys((cg.effective && cg.effective.model_profiles) || {});
// 已删除/已改名旧 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"><use href="#i-plus"/></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;
}
// 参数对象 → 弹窗里的 JSON 文本。空对象留空(placeholder 提示),避免每张卡都挂一对 {}
function pfJsonText(o) {
return o && typeof o === 'object' && Object.keys(o).length ? JSON.stringify(o) : '';
}
// 预设的模型参数缺省:抽成函数因为「选预设」和「加模型行」两处都要套
function applyModelDefaults(r, preset) {
const d = (preset && preset.model_defaults) || {};
r.extra_params = pfJsonText(d.extra_params);
r.thinking_params = pfJsonText(d.thinking_params);
r.reasoning_ack_field = d.reasoning_ack_field || '';
r.profile = d.profile || '';
}
// 该行的高级参数是否还是「空/上一个预设的缺省」:是才允许被新预设覆盖,不动用户手填的内容
function pfUsesDefaults(r, preset) {
const d = (preset && preset.model_defaults) || {};
return String(r.extra_params || '') === pfJsonText(d.extra_params) &&
String(r.thinking_params || '') === pfJsonText(d.thinking_params) &&
String(r.reasoning_ack_field || '') === String(d.reasoning_ack_field || '') &&
String(r.profile || '') === String(d.profile || '');
}
function pfNewModel() {
const r = { ref: null, id: '', vision: true, enable: true, display_name: '', profile: '',
extra_params: '', thinking_params: '', reasoning_ack_field: '', max_context: 0, adv: false };
if (pfEdit) applyModelDefaults(r, pfEdit.preset);
return r;
}
function openModelEditor(pi) {
const add = pi == null;
const p = add ? {} : (SET.cfgPlatforms[pi] || {});
pfEdit = {
idx: add ? -1 : Number(pi),
preset: null,
// 已有 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,
// 显示名缺省就是 id(config.js 归一化过):相同时留空,弹窗里不重复展示
display_name: m.display_name && m.display_name !== (m.mid || m.id) ? m.display_name : '',
profile: m.profile || '',
extra_params: pfJsonText(m.extra_params),
thinking_params: pfJsonText(m.thinking_params),
reasoning_ack_field: m.reasoning_ack_field || '',
max_context: Number(m.max_context) || 0,
adv: 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(pfNewModel()); }
$('mpe-del-btn').classList.toggle('hidden', add);
renderPfPresets();
renderPfRows();
$('model-edit-modal').classList.remove('hidden');
}
// 新增平台时的平台预设:点一下填好 url / 平台名,模型行带上该平台的参数缺省
function renderPfPresets() {
const box = $('mpe-presets');
if (!box) return;
const list = (SET.presets && SET.presets.platforms) || [];
const show = !!pfEdit && pfEdit.idx < 0 && list.length > 0;
box.classList.toggle('hidden', !show);
if (!show) { box.innerHTML = ''; return; }
const cur = pfEdit.preset ? pfEdit.preset.key : '';
box.innerHTML = list.map(p =>
'<button type="button" class="mpe-chip' + (cur === p.key ? ' on' : '') + '" onclick="sUI.mPreset(\'' + att(p.key) + '\')">' + esc(p.label || p.key) + '</button>'
).join('') +
'<button type="button" class="mpe-chip' + (cur ? '' : ' on') + '" onclick="sUI.mPreset(\'\')">自定义</button>';
}
function applyPfPreset(key) {
if (!pfEdit || pfEdit.idx >= 0) return;
// 已经是自定义:不重复清空用户正在手填的内容
if (!key && !pfEdit.preset) return;
const list = (SET.presets && SET.presets.platforms) || [];
const preset = key ? (list.find(x => x.key === key) || null) : null;
const prev = pfEdit.preset;
pfEdit.preset = preset;
if (preset) {
$('mpe-url').value = preset.url || '';
// 名称只在不覆盖手输时跟随预设(空 / 还等于上一个预设名)
const nm = $('mpe-name').value.trim();
if (!nm || nm === (prev ? prev.key : '')) $('mpe-name').value = preset.key || '';
} else {
// 自定义 = 从空白开始:清空平台字段与 Key/模型行(含刚套上的预设参数)
$('mpe-name').value = '';
$('mpe-url').value = '';
pfEdit.keys = [{ ref: null, api_key: '' }];
pfEdit.models = [pfNewModel()];
}
// 只改「新增行」且高级参数还是空/上一个预设缺省的行;已有模型与手填内容一律不动
for (const r of pfEdit.models) {
if (r.ref != null) continue;
if (pfUsesDefaults(r, prev)) applyModelDefaults(r, preset);
}
renderPfPresets();
renderPfRows();
}
// 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 + 「高级」,高级区放不常改的字段。
// 全部走细粒度 path 保存,不整体覆盖模型对象(保住文件里的手写字段)。
function pfModelsRowHtml(r, i) {
const ph = (pfEdit && pfEdit.preset && pfEdit.preset.model_hint) || 'id(上游模型名)';
const profiles = (SET.modelProfileNames || []).slice();
// 配置里引用了但不在下拉里的 profile(手工改过 YAML):补一项,避免保存时被静默改回默认
if (r.profile && profiles.indexOf(r.profile) < 0) profiles.push(r.profile);
const adv = r.adv ? '<div class="mpe-adv">' +
'<label class="mpe-line"><span>显示名</span><input type="text" placeholder="默认同 id" value="' + att(r.display_name) + '" oninput="sUI.mModField(' + i + ',\'display_name\',this.value)"></label>' +
'<label class="mpe-line"><span>Profile</span><select onchange="sUI.mModField(' + i + ',\'profile\',this.value)">' +
'<option value="">默认</option>' +
profiles.map(n => '<option value="' + att(n) + '"' + (n === r.profile ? ' selected' : '') + '>' + esc(n) + '</option>').join('') +
'</select></label>' +
'<label class="mpe-line"><span>请求参数</span><textarea rows="2" spellcheck="false" placeholder=\'{"key":"value"}\' oninput="sUI.mModField(' + i + ',\'extra_params\',this.value)">' + esc(r.extra_params) + '</textarea></label>' +
'<label class="mpe-line"><span>思考参数</span><textarea rows="2" spellcheck="false" placeholder=\'{"reasoning_effort":"max"}\' oninput="sUI.mModField(' + i + ',\'thinking_params\',this.value)">' + esc(r.thinking_params) + '</textarea></label>' +
'<label class="mpe-line"><span>思考链回传</span><input type="text" placeholder="回传字段名" value="' + att(r.reasoning_ack_field) + '" oninput="sUI.mModField(' + i + ',\'reasoning_ack_field\',this.value)"></label>' +
'<label class="mpe-line"><span>压缩阈值</span><input type="number" min="0" step="1000" placeholder="0=不自动压缩" value="' + att(r.max_context || 0) + '" oninput="sUI.mModField(' + i + ',\'max_context\',this.value)"></label>' +
'</div>' : '';
return '<div class="mpe-mcard">' +
'<div class="mpe-row">' +
'<input class="mpe-grow" type="text" placeholder="' + att(ph) + '" value="' + att(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>' +
'<button type="button" class="mpe-adv-btn" onclick="sUI.mAdvToggle(' + i + ')">' + (r.adv ? '收起' : '高级') + '</button>' +
'</div>' + adv +
'</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(pfNewModel()); 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'); }
// JSON 参数:留空 = {}(不写进文件);非空必须是 JSON 对象(数组/标量对上游没意义)
function pfParams(r, key, label) {
const txt = String(r[key] || '').trim();
if (!txt) return {};
let v;
try { v = JSON.parse(txt); } catch (_) {
throw new Error('模型「' + (String(r.id || '').trim() || '未命名') + '」的' + label + '不是合法 JSON');
}
if (!v || typeof v !== 'object' || Array.isArray(v)) {
throw new Error('模型「' + (String(r.id || '').trim() || '未命名') + '」的' + label + '要填 JSON 对象,如 {"key":"value"}');
}
return v;
}
// 新增行/新增平台时落盘的模型对象:只写非缺省项,其余交给 config.js 的默认值
function pfModelValue(r) {
const id = String(r.id || '').trim();
const nv = { id };
if (r.vision === false) nv.vision = false; // 缺省 true,只在取消勾选时显式落键
if (r.enable === false) nv.enable = false;
const dn = String(r.display_name || '').trim();
if (dn && dn !== id) nv.display_name = dn;
const prof = String(r.profile || '').trim();
if (prof) nv.profile = prof;
const ep = pfParams(r, 'extra_params', '请求参数');
if (Object.keys(ep).length) nv.extra_params = ep;
const tp = pfParams(r, 'thinking_params', '思考参数');
if (Object.keys(tp).length) nv.thinking_params = tp;
const ra = String(r.reasoning_ack_field || '').trim();
if (ra) nv.reasoning_ack_field = ra;
const mc = Math.max(0, parseInt(r.max_context, 10) || 0);
if (mc) nv.max_context = mc;
return nv;
}
// 根据工作态算批量编辑:原地改(值变更项) → 删行(降序) → 新增行(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 改(不整体覆盖,保住文件里的手写字段与其他参数);
// 新增行 append 最小对象(缺省项不写:display_name 同 id、enable 缺省启用、参数为空)
pfEdit.models.forEach(r => {
if (r.ref != null) {
const om = (p.models || [])[r.ref] || {};
const mp = ['platforms', pfEdit.idx, 'models', r.ref];
const nid = String(r.id || '').trim();
if (nid && om.id && nid !== om.id) {
edits.push({ path: mp.concat('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: mp.concat('vision'), value: !!r.vision });
if ((om.enable !== false) !== (r.enable !== false)) edits.push({ path: mp.concat('enable'), value: r.enable !== false });
// 显示名缺省 = id:空值/等于 id 都按「不写」处理
const curDn = String(om.display_name || '');
const dn = String(r.display_name || '').trim();
if (!dn || dn === (nid || om.id)) {
if (curDn && curDn !== om.id) edits.push({ path: mp.concat('display_name'), op: 'delete' });
} else if (dn !== curDn) {
edits.push({ path: mp.concat('display_name'), value: dn });
}
const curProf = String(om.profile || '');
const prof = String(r.profile || '').trim();
if (!prof) {
if (curProf) edits.push({ path: mp.concat('profile'), op: 'delete' });
} else if (prof !== curProf) {
edits.push({ path: mp.concat('profile'), value: prof });
}
// 参数类:值没变就不写(避免无意义重写丢掉节点注释);清空 = 删键,回落默认 {}
const curEp = om.extra_params || {};
const ep = pfParams(r, 'extra_params', '请求参数');
if (JSON.stringify(ep) !== JSON.stringify(curEp)) {
edits.push(Object.keys(ep).length
? { path: mp.concat('extra_params'), value: ep }
: { path: mp.concat('extra_params'), op: 'delete' });
}
const curTp = om.thinking_params || {};
const tp = pfParams(r, 'thinking_params', '思考参数');
if (JSON.stringify(tp) !== JSON.stringify(curTp)) {
edits.push(Object.keys(tp).length
? { path: mp.concat('thinking_params'), value: tp }
: { path: mp.concat('thinking_params'), op: 'delete' });
}
const curRa = String(om.reasoning_ack_field || '');
const ra = String(r.reasoning_ack_field || '').trim();
if (!ra) {
if (curRa) edits.push({ path: mp.concat('reasoning_ack_field'), op: 'delete' });
} else if (ra !== curRa) {
edits.push({ path: mp.concat('reasoning_ack_field'), value: ra });
}
// 压缩阈值:0 = 删键(缺省不写),避免无意义重写文件
const curMc = Number(om.max_context) || 0;
const mc = Math.max(0, parseInt(r.max_context, 10) || 0);
if (mc !== curMc) {
edits.push(mc ? { path: mp.concat('max_context'), value: mc } : { path: mp.concat('max_context'), op: 'delete' });
}
} else {
edits.push({ op: 'append', path: ['platforms', pfEdit.idx, 'models'], value: pfModelValue(r) });
}
});
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 整个对象
const obj = {
name, url,
keys: pfEdit.keys.map(r => ({ api_key: String(r.api_key || '').trim() })),
models: pfEdit.models.map(pfModelValue),
};
// 用预设时把余额查询类型固定下来(不展示给用户):名字与预设一致可不写(服务端缺省 = 平台名)
const presetType = pfEdit.preset ? String(pfEdit.preset.type || pfEdit.preset.key || '') : '';
if (presetType && presetType !== name) obj.type = presetType;
edits = [{ op: 'append', path: ['platforms'], value: obj }];
} else {
// 改名不影响 pi(数组位置);其余按原 ref 定位,见 buildPfEdits
edits = buildPfEdits();
if (!edits.length) { closeModelEditor(); return toast('没有变更'); }
}
} catch (e) { return toast(e.message); } // JSON 校验失败等:提示后不发请求
try {
await req('PATCH', '/api/config', { edits });
// 重加同名模型(重启前被标记隐藏的):清掉删除标记防误屏蔽
const pname = name || (SET.cfgPlatforms[pfEdit.idx] || {}).name || '';
if (!add) for (const r of pfEdit.models) if (r.ref == null) delete SET.deletedModels[pname + '/' + String(r.id || '').trim()];
closeModelEditor();
afterWrite(); // 列表顶部出现「重启服务」横幅按钮
} catch (e) { toast('保存失败:' + e.message); }
}
// 删除整个平台:仅改 config.yml(一次 delete platforms[pi]),重启前列表已无它(effective 实时解析文件)
async function delPlatformFromModal() {
if (!pfEdit || pfEdit.idx < 0) return;
const pi = pfEdit.idx;
const p = SET.cfgPlatforms[pi] || {};
closeModelEditor();
const ok = await confirmModal('删除平台', '删除平台「' + (p.name || ('平台' + pi)) + '」及其全部 Key 与模型?此操作仅修改 config.yml。', '删除', true);
if (!ok) return;
try {
await req('PATCH', '/api/config', { path: ['platforms', pi], op: 'delete' });
// 运行池重启前仍持有该平台的模型:标记隐藏,防会话页选择弹窗误绑
for (const m of (p.models || [])) SET.deletedModels[p.name + '/' + m.id] = true;
afterWrite();
} catch (e) { toast('删除失败:' + e.message); }
}
// ---------- 页:MCP 服务(增/改/删;name / url / 多 headers / timeout_ms / mode) ----------
// 与模型池共用 PATCH /api/config 的细粒度 edit 接口:
// · 新增 = append 到 mcp_servers;
// · 删 = delete mcp_servers[pi];
// · 改 = setIn mcp_servers[pi].(name|url|timeout_ms|mode);headers 是普通键值对象,整体 setIn 一次到位。
// mode 三态:advertise(默认,工具下发给模型) / skill(不下发,以技能形式暴露) / disable(不加载):
// 默认值不写进文件——选 advertise 时删键,回落到 config.js 的缺省。
// 运行配置(cg.effective.mcp_servers)即文件刚解析后的视图,按 pi 直接定位;重启后才会重新发现工具。
// 预设取一次就缓存:取不到不报错,退化成纯自定义列表,不阻塞设置页
let presetsReq = null;
function loadPresets() {
if (SET.presets) return Promise.resolve(SET.presets);
if (!presetsReq) {
presetsReq = req('GET', '/api/config/presets').then(p => {
SET.presets = { platforms: (p && p.platforms) || [], mcp: (p && p.mcp) || [] };
return SET.presets;
}).catch(() => {
presetsReq = null; // 失败不缓存,下次进页再试
return { platforms: [], mcp: [] };
});
}
return presetsReq;
}
function presetMcpList() { return (SET.presets && SET.presets.mcp) || []; }
let mcpEdit = null; // 工作态:{ idx, preset, values:{header:值}, headers:[{key, value, masked}] };idx=-1 为新增
const MCP_HEADER_MASK = '*****'; // 与后端 routes/config.js 的掩码保持一致
const MCP_MODE_LABELS = {
advertise: 'advertise(下发给模型)',
skill: 'skill(以技能形式暴露)',
disable: 'disable(不加载)',
};
// url 归一化:内置服务按 url 认亲(name 允许用户改),尾斜杠不算差异
function normUrl(u) { return String(u || '').trim().replace(/\/+$/, ''); }
function presetIdx(p) {
const url = normUrl(p.url);
let i = SET.cfgMcp.findIndex(s => normUrl(s.url) === url);
if (i < 0) i = SET.cfgMcp.findIndex(s => String(s.name || '') === p.key);
return i;
}
async function setPageMcp(ctx) {
setTitle('MCP 服务');
setActions('<button class="icon-btn" title="添加 MCP 服务" onclick="mcpUI.add()">' +
'<svg class="ic" viewBox="0 0 24 24"><use href="#i-plus"/></svg></button>');
setBody('<div class="set-scroll" id="mcp-list"><div class="empty-tip">加载中…</div></div>');
await loadMcpList(ctx);
}
// 连接状态的认亲键:name + url + mode(与后端 mcp.statusKeyOf 一致,url 去尾斜杠)
function mcpStatusKey(s) {
return [s.name, normUrl(s.url), s.mode || 'advertise'].join('|');
}
// 运行态连接标记:没有运行态记录 = 配置比进程新(刚加、改了 url/mode),需重启才生效;
// 整个状态接口没拿到(null)= 无从判断,宁可不显示也不要全部误报「待重启」。
function mcpConnChip(s) {
if (!SET.mcpStatus) return '';
const st = SET.mcpStatus.get(mcpStatusKey(s));
if (!st) return '<span class="model-card-state pending" title="配置已写入,重启后生效">待重启</span>';
if (st.disabled) return '<span class="model-card-state off">已停用</span>';
if (st.ok) {
const extra = st.hidden ? ',其中 ' + st.hidden + ' 个以技能暴露' : '';
return '<span class="model-card-state idle" title="发现 ' + (st.tools || 0) + ' 个工具' + extra + '">已连接</span>';
}
return '<span class="model-card-state busy" title="' + att(st.error || '连接失败') + '">未连接</span>';
}
async function loadMcpList(ctx) {
const box = $('mcp-list');
if (!box || (ctx && !ctx())) return;
try {
const [cg, , st] = await Promise.all([
req('GET', '/api/config'),
loadPresets(),
// 状态接口失败不该挡住整个页面(老进程没有该路由 / 网络抖动):拿不到就不显示连接标记
req('GET', '/api/config/mcp-status').catch(() => null),
]);
if ((ctx && !ctx()) || !$('mcp-list')) return;
SET.cfgMcp = (cg.effective && cg.effective.mcp_servers) || [];
const statusList = st && Array.isArray(st.servers) ? st.servers : null;
SET.mcpStatus = statusList ? new Map(statusList.map(x => [mcpStatusKey(x), x])) : null;
const presets = presetMcpList();
// 内置服务已占用的条目不再列入「其它」,避免同一服务出两张卡
const taken = new Set(presets.map(presetIdx).filter(i => i >= 0));
const others = SET.cfgMcp.map((s, i) => ({ s, i })).filter(o => !taken.has(o.i));
let html = SET.mcpPendingRestart
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: '';
if (presets.length) {
html += '<div class="mcp-sec-title">内置服务</div>' + presets.map(presetCardHtml).join('');
}
if (others.length) {
html += '<div class="mcp-sec-title">其它服务</div>' + others.map(o => mcpCardHtml(o.s, o.i)).join('');
}
if (!presets.length && !others.length) {
html += '<div class="empty-tip">尚未配置 MCP 服务,点右上角 + 添加。</div>';
}
$('mcp-list').innerHTML = html;
} catch (e) {
const b = $('mcp-list');
if (b && (!ctx || ctx())) b.innerHTML = '<div class="empty-tip">加载失败:' + esc(e.message) + '</div>';
}
}
// 内置服务卡:未配置→添加;已配置→显示当前值与状态,点击编辑。密钥类只显示「已配置」,不外显真值。
function presetCardHtml(p) {
const idx = presetIdx(p);
const s = idx >= 0 ? (SET.cfgMcp[idx] || {}) : null;
const mode = s ? (s.mode || 'advertise') : '';
// 标签用中性灰,颜色只表达连接状态(续=已连接 / 红=未连接 / 黄=待重启)
const state = !s
? '<span class="model-card-state off">未配置</span>'
: '<span class="model-card-state off">已配置</span>' +
(mode === 'disable' ? '' : mcpConnChip(s));
const h = (s && s.headers) || {};
const kv = (p.fields || []).map(f => {
const v = h[f.header];
const txt = f.secret ? (v ? '已配置' : '--') : (v ? String(v) : '--');
return '<div class="cfg-kv"><label>' + esc(f.label || f.header) + '</label><b>' + esc(txt) + '</b></div>';
}).join('');
// 地址一律显示真实配置:预设地址只是容器形态的缺省值,本地形态是 127.0.0.1:809x,
// 照抄预设会与「已连接」徽章自相矛盾。
const urlTxt = (s ? (s.url || '') : p.url) || '';
return '<div class="model-card' + (mode === 'disable' ? ' off' : '') + '"' +
' onclick="mcpUI.' + (s ? 'editPreset' : 'addPreset') + '(\'' + att(p.key) + '\')">' +
'<div class="model-card-head">' +
'<span class="model-card-name">' + esc(p.label || p.key) + '</span>' +
state +
'</div>' +
'<div class="cfg-kv"><label>地址</label><b>' + esc(urlTxt) + '</b></div>' + kv +
'</div>';
}
// MCP 卡:头部 = 名称 + url + mode 状态;体内 = headers 键值列表。整卡点击进入编辑。
function mcpCardHtml(s, pi) {
const mode = s.mode || 'advertise';
// 同样:模式文字保持中性,颜色留给连接状态
const stateHtml = '<span class="model-card-state off">' +
(mode === 'disable' ? '已禁用' : mode === 'skill' ? '以技能暴露' : '启用') + '</span>' +
(mode === 'disable' ? '' : mcpConnChip(s));
const entries = Object.entries(s.headers || {});
// 后端只对密钥类 header 脱敏(base-url/model 这类明文);掩码值统一显示「已配置」,不露长度
const maskVal = (v) => {
const str = String(v == null ? '' : v);
if (!str) return '--';
return str === MCP_HEADER_MASK ? '已配置' : esc(str);
};
const headersHtml = entries.length
? entries.map(([k, v]) => '<div class="cfg-kv"><label>' + esc(k) + '</label><b>' + maskVal(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=null) → 空工作态;edit 模式 → 从当前配置复制。
// presetKey 有值 = 内置服务模式:name/mode 是契约(只读),url 可改(地址随部署形态变,预设只给缺省值),
// 表单由预设的 fields 生成。
function openMcpEditor(idx, presetKey) {
const preset = presetKey ? (presetMcpList().find(p => p.key === presetKey) || null) : null;
const add = idx == null;
const s = add ? {} : (SET.cfgMcp[idx] || {});
const curH = s.headers || {};
const fieldHeaders = new Set(((preset && preset.fields) || []).map(f => f.header));
mcpEdit = {
idx: add ? -1 : Number(idx),
preset: preset,
values: {},
// 预设字段走 values;这里只留「配置里有、预设未声明」的 header(手加的)——
// headers 是整体替换的,不带着它们保存一次就丢了。
headers: Object.keys(curH).filter(k => !fieldHeaders.has(k)).map(k => {
const v = String(curH[k]);
// 明文值直接回填(可原地改);掩码值置空,placeholder 提示「留空保持不变」
return { key: k, value: v === MCP_HEADER_MASK ? '' : v, masked: v };
}),
};
if (preset) {
(preset.fields || []).forEach(f => {
// 明文项回填当前值(看得见才好改);密钥项只提示「已配置」,留空即保持原值
mcpEdit.values[f.header] = add
? (f.secret ? '' : String(f.default || ''))
: (f.secret ? '' : String(curH[f.header] || ''));
});
} else if (add) {
// headers 数组:每个 {key, value, masked} 为一条编辑行。已有行 value 置空、masked 存当前脱敏值仅做提示
// (同平台 Key 的留空=保持原值);新行 masked=null,必须手输真值。空 key 行保存时丢弃。
mcpEdit.headers = [{ key: '', value: '', masked: null }];
}
$('mce-title').textContent = (add ? '添加 ' : '编辑 ') + (preset ? preset.label : 'MCP 服务');
$('mce-name').value = preset ? preset.key : (add ? '' : (s.name || ''));
// 预填优先级:当前配置 > 预设缺省值。url 不锁只读——容器形态是 mcp_*:3000,本地形态是
// 127.0.0.1:809x,漏改这里用户就看不到也改不了真实地址。
$('mce-url').value = add ? (preset ? preset.url : '') : (s.url || (preset ? preset.url : ''));
$('mce-name').readOnly = !!preset;
$('mce-url').readOnly = false;
// 运行配置里的 timeout_ms 已被 config.js 填上缺省值,所以这里显示的就是当前生效值(没配则为 60000)。
$('mce-timeout').value = add || s.timeout_ms == null ? '' : String(s.timeout_ms);
// 预设的 mode 是契约(asr / image_task 必须 skill 才不会把一堆转写/生成工具塞进每轮工具表),
// 只允许在「预设值 / disable」之间切;手改成别的值时按契约值显示,不凭空改写文件。
const curMode = add ? (preset ? (preset.mode || 'advertise') : 'advertise') : (s.mode || 'advertise');
const modes = preset ? [preset.mode || 'advertise', 'disable'] : ['advertise', 'skill', 'disable'];
$('mce-mode').innerHTML = modes.map(m => '<option value="' + att(m) + '">' + esc(MCP_MODE_LABELS[m] || m) + '</option>').join('');
$('mce-mode').value = modes.indexOf(curMode) >= 0 ? curMode : modes[0];
$('mce-preset-sec').classList.toggle('hidden', !preset);
$('mce-preset-desc').textContent = preset ? (preset.desc || '') : '';
// 预设已经覆盖该服务的全部 header,不再给「其它 header」入口;
// 配置里若还留着历史多余 header,仍原样带着(保存是整体替换,不带着就丢),只是不展示。
$('mce-headers-sec').classList.toggle('hidden', !!preset);
$('mce-del-btn').classList.toggle('hidden', add);
renderPresetFields();
renderMcpHeaders();
$('mcp-edit-modal').classList.remove('hidden');
}
function closeMcpEditor() { $('mcp-edit-modal').classList.add('hidden'); }
// header 行:id 由 JS 运行时下标 i 拼接,避免与服务端 path 冲突
function mcpHeaderRowHtml(r, i) {
// 已有行:输入框置空,placeholder 提示当前脱敏值;留空=保持原值,输入新值=替换
const ph = r.masked != null ? '当前: ' + r.masked + '(留空保持不变)' : '值';
return '<div class="mpe-row">' +
'<input class="mpe-grow" type="text" placeholder="Header 字段" value="' + esc(r.key) + '" oninput="mcpUI.setHeader(' + i + ',\'key\',this.value)">' +
'<input class="mpe-grow" type="text" placeholder="' + esc(ph) + '" 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: '', masked: null });
renderMcpHeaders();
}
function delMcpHeader(i) {
if (!mcpEdit) return;
mcpEdit.headers.splice(i, 1);
renderMcpHeaders();
}
function setMcpHeader(i, f, v) { if (mcpEdit && mcpEdit.headers[i]) mcpEdit.headers[i][f] = v; }
// 预设字段表单:label + 输入框 + 提示。密钥项只提示「已配置」,不回填真值(前端拿到的本来就是掩码)。
function renderPresetFields() {
if (!mcpEdit) return;
const box = $('mce-preset-fields');
if (!box) return;
const p = mcpEdit.preset;
if (!p) { box.innerHTML = ''; return; }
const curH = ((mcpEdit.idx >= 0 && SET.cfgMcp[mcpEdit.idx]) || {}).headers || {};
box.innerHTML = (p.fields || []).map(f => {
const isSet = !!curH[f.header];
const ph = f.secret && isSet ? '已配置,留空保持不变' : (f.placeholder || '');
const val = mcpEdit.values[f.header] || '';
// 左标签 / 右输入,与下方「单次调用超时 / 工具暴露」同一种单行排版。
// 必填不加 * 标记(会破坏对齐)——空着保存时按 label 点名报错。
return '<div class="mpe-item"><label class="mpe-line"><span>' + esc(f.label || f.header) + '</span>' +
'<input type="' + (f.secret ? 'password' : 'text') + '"' +
' value="' + att(val) + '"' +
' placeholder="' + att(ph) + '"' +
' autocomplete="off" spellcheck="false"' +
' oninput="mcpUI.setField(\'' + att(f.header) + '\',this.value)">' +
'</label>' + (f.hint ? '<div class="cfg-note">' + esc(f.hint) + '</div>' : '') + '</div>';
}).join('');
}
function setPresetField(header, v) {
if (mcpEdit && mcpEdit.values) mcpEdit.values[header] = v;
}
// 预设里的 prefix(如 Bearer )只在用户没带过时才补,避开「Bearer Bearer sk-x」
function withPrefix(f, v) {
const p = String(f.prefix || '');
if (!p) return v;
const re = new RegExp('^' + p.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s', 'i');
return re.test(v) ? v : p + v;
}
// 与配置里的 headers 比较:key 顺序不同不算改动(避免无意义重写丢掉节点里的注释)
function sameHeaders(a, b) {
const ka = Object.keys(a).sort(), kb = Object.keys(b).sort();
if (ka.length !== kb.length) return false;
return ka.every((k, i) => k === kb[i] && a[k] === b[kb[i]]);
}
// 自定义服务的 headers:空 key 行丢弃,已有行留空 = 发回掩码占位由后端按键名还原
function plainHeaders() {
const out = {};
for (const r of mcpEdit.headers) {
const k = String(r.key || '').trim();
if (!k) continue;
const v = String(r.value || '').trim();
out[k] = v || (r.masked != null ? r.masked : '');
}
return out;
}
// 预设模式的 headers:字段按声明顺序取 values,空的可选项不写(不给上游塞空 header),
// 必填项空着直接报错并点名 label;手加的 header 原样跟上(整体替换语义下不带就丢)。
function presetHeaders() {
const p = mcpEdit.preset;
const curH = ((mcpEdit.idx >= 0 && SET.cfgMcp[mcpEdit.idx]) || {}).headers || {};
const out = {};
for (const f of p.fields || []) {
const raw = String(mcpEdit.values[f.header] || '').trim();
if (raw) { out[f.header] = withPrefix(f, raw); continue; }
if (f.secret && curH[f.header]) { out[f.header] = MCP_HEADER_MASK; continue; }
if (f.required) throw new Error('请填写「' + (f.label || f.header) + '」');
}
for (const r of mcpEdit.headers) {
const k = String(r.key || '').trim();
if (!k || out[k] !== undefined) continue;
const v = String(r.value || '').trim();
out[k] = v || (r.masked != null ? r.masked : '');
}
return out;
}
// 收集弹窗内的修改为批量 PATCH:服务端一次读文/写回/校验,原子生效。
// headers 整体替换(简单可靠;键值对场景下增量 diff 收益小):空 key 行不写入。
function buildMcpEdits() {
if (!mcpEdit) return [];
const edits = [];
const preset = mcpEdit.preset;
const mode = $('mce-mode').value;
// 超时:留空 = 不写入该项(沿用缺省 60s)。区间在 UI 先把一道,
// 比写进 YAML 再被 config.js 静默夹掉好排查(两边上限保持 600000 一致)。
const tmoRaw = $('mce-timeout').value.trim();
let tmo = null;
if (tmoRaw !== '') {
tmo = Number(tmoRaw);
if (!Number.isFinite(tmo) || tmo < 1000 || tmo > 600000) throw new Error('超时要填 1000 ~ 600000 毫秒(留空 = 默认 60s)');
tmo = Math.round(tmo);
}
// name 是契约(预设的服务名固定);url 不再是契约——展示与写盘均以 config 为准,
// 输入框里默认的就是预设值,改了就存。
const add = mcpEdit.idx < 0;
const cur = add ? {} : (SET.cfgMcp[mcpEdit.idx] || {});
const name = preset ? preset.key : $('mce-name').value.trim();
const url = $('mce-url').value.trim();
const headers = preset ? presetHeaders() : plainHeaders();
if (add) {
if (!url) throw new Error('请填写 url');
const obj = { url };
if (name) obj.name = name;
if (mode !== 'advertise') obj.mode = mode;
if (tmo != null) obj.timeout_ms = tmo;
if (Object.keys(headers).length) obj.headers = headers;
edits.push({ op: 'append', path: ['mcp_servers'], value: obj });
} else {
// 自定义服务:name/url 都能改;内置服务只允许改 url(name/mode 是契约)
if (!url) throw new Error('请填写 url');
if (!preset && 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 });
// mode:默认值不写进文件(选 advertise 就删键)
if ((cur.mode || 'advertise') !== mode) edits.push(mode === 'advertise'
? { path: ['mcp_servers', mcpEdit.idx, 'mode'], op: 'delete' }
: { path: ['mcp_servers', mcpEdit.idx, 'mode'], value: mode });
// 超时:清空 = 删掉该键(回落到缺省);后端 deleteIn 支持嵌套键,无键时是空操作。
const curTmo = cur.timeout_ms == null ? null : Number(cur.timeout_ms);
if (tmo !== curTmo) edits.push(tmo == null
? { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], op: 'delete' }
: { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], value: tmo });
// headers 仅在内容变更时整体 setIn;避免无意义重写(顺序或 key 顺序不同不算变更)
if (!sameHeaders(headers, cur.headers || {})) {
edits.push({ path: ['mcp_servers', mcpEdit.idx, 'headers'], value: headers });
}
}
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); },
addPreset: function (key) { openMcpEditor(null, key); },
editPreset: function (key) {
const p = presetMcpList().find(x => x.key === key);
const i = p ? presetIdx(p) : -1;
if (i >= 0) openMcpEditor(i, key);
},
setField: setPresetField,
edit: openMcpEditor,
close: closeMcpEditor,
save: saveMcpEditor,
del: delMcpEditor,
addHeader: addMcpHeader,
delHeader: delMcpHeader,
setHeader: setMcpHeader,
};
// ---------- 设置区对外接口(动态卡片里的 onclick 均指向这里) ----------
window.sUI = {
// 账户
changePassword: changePassword,
saveProfile: saveProfile,
// 用户管理(仅管理员)
openUserAdd: openUserAdd,
openUserEdit: openUserEditor,
closeUserModal: closeUserModal,
saveUser: saveUser,
userDelFromModal: userDelFromModal,
// 微信绑定
wxBind: wxBind,
wxRefresh: wxRefresh,
wxUnbind: wxUnbind,
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); },
mModField: function (i, f, v) { setPfModel(i, f, v); },
mModVision: function (i, v) { setPfModel(i, 'vision', v); },
mModEnable: function (i, v) { setPfModel(i, 'enable', v); },
mAdvToggle: function (i) {
if (!pfEdit || !pfEdit.models[i]) return;
pfEdit.models[i].adv = !pfEdit.models[i].adv;
renderPfRows();
},
mPreset: applyPfPreset,
mDelPlat: delPlatformFromModal,
restartNow: restartNow,
toggleGroup: toggleModelGroup,
refreshBalance: refreshBalance,
mToggleEnable: toggleModelEnable,
};
// ---------- 初始化 ----------
bindChatScroll(); // 聊天区滚动跟随/右下角回底按钮(只绑一次)
setView('welcome');
openDrawer(drawerMQ.matches); // 桌面端:侧边栏默认展开;跨断点缩放窗口时同步切换开合态
drawerMQ.addEventListener('change', e => openDrawer(e.matches));
// 页面加载时校验 cookie 身份:防止 localStorage 旧 token 通过 autoRestore 恢复错误用户
(async () => {
try {
const res = await fetch('/api/me', { credentials: 'include' });
if (res.ok) {
const j = await res.json();
if (j.auth === false) {
// 未启用多用户认证(单用户自用,本地模式即此形态):没有登录态可校验,全部设置可见
SET.role = 'admin';
SET.authEnabled = false;
} else if (!j.user) {
// cookie 无效或用户已从配置中移除 → 彻底清理所有前端凭据并跳登录
localStorage.removeItem('agent_token');
sessionStorage.removeItem('agent_creds'); // 旧版本遗留的 Basic 凭据,顺带清理
location.href = '/logout';
return;
} else {
SET.role = j.role === 'admin' ? 'admin' : 'user';
SET.authEnabled = true;
}
} else {
// 兜底:改契约之前的旧后端在未启用认证时该路由不存在(404),按未启用处理
SET.role = 'admin';
SET.authEnabled = false;
}
} catch (_) { /* 网络错误放过,让后续请求正常走 */ }
loadSessionList();
// 侧栏底部已是纯图标操作栏(不展示用户信息),不再需要 loadDrawerUser
// 会话深链 /?s=<session_id>:数据页面(/app/{task_id}/...)的「返回会话」FAB 用——
// task_id 即会话 id(engine 里 1:1)。地址栏常驻 ?s= 不抹掉,刷新/收藏/分享都能回到同一会话;
// 会话已删时 openSession 会自己回落到 welcome 并把 URL 清回 /。
const params = new URLSearchParams(location.search);
const deep = params.get('s');
if (deep) {
openSession(deep).then(() => {
// 从侧栏「在新窗口打开」进来(带 files=1):开局直接把侧栏切到文件树;
// 窄屏/无会话/文件树未加载时 setDrawerPane 内部会自行忽略
if (params.get('files') === '1' && typeof setDrawerPane === 'function') setDrawerPane(true);
});
}
})();