Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
// Bind once during browser initialization; source-only tests can load these helpers.
function bindAvatarFallbacks(){document.addEventListener('error',event=>{
const image=event.target;
if(!(image instanceof HTMLImageElement)||!image.hasAttribute('data-avatar-fallback'))return;
image.style.display='none';
const fallback=image.nextElementSibling;
if(fallback?.classList.contains('user-avatar-text'))fallback.style.display='';
},true)}
// ================= 工作台 =================
function jumpBind(host){if(!host)return;host.querySelectorAll('[data-jump],[data-issue-filter]').forEach(el=>el.onclick=()=>{
if(el.dataset.issueFilter!=null){setIssueRunFilter(el.dataset.issueFilter,false);return}
switchView(el.dataset.jump);
})}
function openRunFromId(id,opts={}){
const issueId=issueIdForRun(id);
if(!opts.forceRuns&&issueId){openIssueDetail(issueId,opts.tab||'sop');return}
switchView('runs');
showRunDetail(id);
}
function updateApprovalBadge(){
const n=approvalItems().length;
const badge=$('#approvalNavBadge');
if(!badge)return;
badge.hidden=!n;
badge.textContent=n||'';
}
// ================= 个人凭证 =================
// One table drives the list rows, the inline editors and the add wizard.
const CREDENTIAL_GROUPS=[
{id:'platform',name:'平台集成',sub:'代码仓库与统一认证',icon:'key'},
{id:'model',name:'模型与执行',sub:'AI 对话与编码 CLI',icon:'sparkles'},
];
// A CodeBuddy key only works on the edition that issued it; the CLI treats unknown values as 国际站.
// Keep in sync with chatbot/src/credentials.js and domain.NormalizeCodeBuddyInternetEnvironment.
const CODEBUDDY_ENVIRONMENTS=[
{value:'',label:'国际站',site:'codebuddy.ai',keyUrl:'https://www.codebuddy.ai/profile/keys'},
{value:'internal',label:'国内站',site:'copilot.tencent.com',keyUrl:'https://copilot.tencent.com/profile/'},
{value:'ioa',label:'iOA',site:'tencent.sso.copilot.tencent.com',keyUrl:'https://tencent.sso.copilot.tencent.com/profile/keys'},
];
const CODEBUDDY_ENVIRONMENT_ALIASES={public:'',intl:'',international:'','国际站':'',china:'internal',cn:'internal','国内站':'internal'};
// The CLI receives the stored text as-is, so only the exact values count; returns null for anything else.
function codeBuddyEnvironment(value){
const key=String(value||'').trim();
return CODEBUDDY_ENVIRONMENTS.find(env=>env.value===key)||null;
}
// What an old free-text value most likely meant (china → 国内站), used to preselect the fix.
function codeBuddyEnvironmentIntent(value){
const key=String(value||'').trim().toLowerCase();
const normalized=Object.prototype.hasOwnProperty.call(CODEBUDDY_ENVIRONMENT_ALIASES,key)?CODEBUDDY_ENVIRONMENT_ALIASES[key]:key;
return CODEBUDDY_ENVIRONMENTS.find(env=>env.value===normalized)||null;
}
// A stored value the CLI does not take as written; it connects to 国际站 until it is saved again.
function codeBuddyEnvironmentLegacy(value){const raw=String(value||'').trim();return !!raw&&!codeBuddyEnvironment(raw)}
function codeBuddyKeyURL(value){return (codeBuddyEnvironmentIntent(value)||CODEBUDDY_ENVIRONMENTS[0]).keyUrl}
function codeBuddyKeyLinkLabel(value){return `前往${(codeBuddyEnvironmentIntent(value)||CODEBUDDY_ENVIRONMENTS[0]).label}获取 API Key`}
const CREDENTIAL_KINDS=[
{key:'gitToken',group:'platform',name:'GitHub',short:'仓库授权',logo:'github',monochrome:true,
use:'克隆私有仓库、创建任务分支、推送交付产物',
description:'用于克隆私有仓库、创建任务分支及推送交付产物。',
guide:[['打开 GitHub「Settings → Developer settings → Personal access tokens」','https://github.com/settings/tokens','前往 GitHub 申请个人访问令牌'],['新建令牌,为目标仓库授予 <code>Contents</code> 和 <code>Pull requests</code> 的读写权限'],['复制令牌粘贴到下方,保存前会自动校验权限']],
placeholder:'请输入个人访问令牌(PAT)',hint:'保存前会先校验令牌有效性与权限',
impact:'依赖私有仓库的 SOP 将无法克隆或推送仓库。'},
{key:'gitSshKey',group:'platform',name:'Git SSH',short:'Git SSH 密钥',icon:'key',
use:'SSH 密钥用于克隆和推送;创建 PR/MR 需要访问令牌',dialog:()=>openGitSSHKeys(),action:'管理密钥'},
{key:'gitHttpCredentials',group:'platform',name:'Git HTTPS',short:'Git 访问令牌',icon:'lock',
use:'按主机管理 HTTPS 访问令牌,工作区的 git、gh、glab 自动认证',dialog:()=>openGitHTTPCredentials(),action:'管理令牌'},
{key:'codeBuddyApiKey',group:'model',name:'CodeBuddy',short:'CodeBuddy API Key',logo:'codebuddy',
use:'AI 对话与 SOP 的 CodeBuddy 执行器',
description:'AI 对话(含 Claude、GPT 等模型)和 SOP 的 CodeBuddy 执行器都使用它;网络环境按账号所在环境配置。',
guide:[['先在下方选择 CodeBuddy 账号所在的网络环境:国际站、国内站或 iOA'],['登录该站点的 API Key 页面,新建 API Key',codeBuddyKeyURL,codeBuddyKeyLinkLabel],['复制以 <code>ck_</code> 开头的密钥粘贴到下方;DeepSeek、OpenAI 等第三方模型的 Key 不能填在这里']],
placeholder:'请输入个人 ck_ key',
extra:{name:'codeBuddyInternetEnvironment',label:'网络环境',options:CODEBUDDY_ENVIRONMENTS},
models:{name:'codeBuddyModels',engine:'codebuddy'},
impact:'AI 对话将只能使用默认模型,CodeBuddy 执行器节点会失败。'},
{key:'codexApiKey',group:'model',name:'Codex',short:'Codex API Key',logo:'codex',monochrome:true,
use:'AI 对话选择 Codex 执行器,以及以 Codex 运行的 SOP 节点',
description:'AI 对话切换到 Codex 后可选用模型目录里的模型,SOP 在执行机器上以 Codex 运行的节点也使用它。目录为空时,未填 Base URL 使用 Codex 自带模型,填写后跟随服务发布的模型;也可以自己挑选、排序和命名。',
guide:[['在模型服务商控制台创建 API Key'],['如走代理或私有网关,记下服务地址'],['粘贴 Key,按需填写 Base URL;保存后可在模型目录里挑选 AI 对话的模型']],
placeholder:'请输入 Codex API Key',
extra:{name:'codexBaseUrl',label:'Base URL',placeholder:'https://api.openai.com/v1',url:true,clearWithKey:true},
models:{name:'codexModels',engine:'codex',endpoint:'/models'},
impact:'以 Codex 运行的 SOP 节点将无法执行,Base URL 与模型目录一并清空。'},
{key:'claudeCodeApiKey',group:'model',name:'Claude Code',short:'Claude Code API Key',logo:'claude',monochrome:true,
use:'AI 对话选择 Claude 执行器,以及以 Claude Code 运行的 SOP 节点',
description:'AI 对话切换到 Claude Code 后可选用模型目录里的模型,SOP 在执行机器上以 Claude Code 运行的节点也使用它。目录为空时,未填 Base URL 使用 Claude Code 自带模型,填写后跟随服务发布的模型;也可以自己挑选、排序和命名。',
guide:[['在模型服务商控制台创建 API Key'],['如走代理或私有网关,记下服务地址'],['粘贴 Key,按需填写 Base URL;保存后可在模型目录里挑选 AI 对话的模型']],
placeholder:'请输入 Claude Code API Key',
extra:{name:'claudeCodeBaseUrl',label:'Base URL',placeholder:'https://api.anthropic.com',url:true,clearWithKey:true},
models:{name:'claudeCodeModels',engine:'claude-code',endpoint:'/v1/models'},
impact:'以 Claude Code 运行的 SOP 节点将无法执行,Base URL 与模型目录一并清空。'},
agentCliCredentialKind('opencode',{name:'OpenCode',logo:'opencode',baseUrl:'https://api.example.com/v1',required:()=>true,
note:'OpenCode 没有自己的模型服务,需要填写 Base URL。',protocols:[['chat','Chat Completions'],['responses','Responses'],['messages','Messages(Anthropic)']]}),
agentCliCredentialKind('cursor',{name:'Cursor CLI',logo:'cursor',monochrome:true,
note:'Cursor CLI 连接 Cursor 官方服务,可按账号获取模型。',
guide:[['登录 Cursor 控制台,在「Integrations → User API Keys」新建 Key','https://cursor.com/dashboard?tab=integrations','前往 Cursor 创建 API Key'],['复制以 <code>crsr_</code> 开头的 Key'],['粘贴到下方保存']]}),
agentCliCredentialKind('agy',{name:'Antigravity',logo:'antigravity',baseUrl:'https://gateway.example.com/v1',required:protocol=>protocol==='chat',
note:'默认连接 Gemini 官方服务;选择 OpenAI 兼容网关时需要填写 Base URL。',extraNote:'OpenAI 兼容网关必填',
guide:[['在 Google AI Studio 创建 Gemini API Key,或准备 OpenAI 兼容网关的 Key','https://aistudio.google.com/apikey','前往 Google AI Studio'],['走网关时记下网关地址'],['粘贴 Key,选择协议;保存后可在模型目录里挑选 AI 对话的模型']],
protocols:[['gemini','Gemini 官方 API'],['chat','OpenAI 兼容网关(Chat Completions)']]}),
agentCliCredentialKind('kimi',{name:'Kimi Code',logo:'kimi-code.png',baseUrl:'https://api.kimi.com/coding/v1',
note:'未填写 Base URL 时连接 Kimi Code 官方服务。',protocols:[['chat','Chat Completions'],['responses','Responses'],['messages','Messages(Anthropic)']]}),
agentCliCredentialKind('pi',{name:'Pi',logo:'pi',baseUrl:'https://api.example.com/v1',required:()=>true,
note:'Pi 没有自己的模型服务,需要填写 Base URL。',protocols:[['chat','Chat Completions'],['responses','Responses'],['messages','Messages(Anthropic)']]}),
agentCliCredentialKind('dsh',{name:'DeepSeek Harness',logo:'deepseek',baseUrl:'https://api.deepseek.com',
note:'未填写 Base URL 时连接 DeepSeek 官方服务。',protocols:[['chat','Chat Completions'],['responses','Responses'],['messages','Messages(Anthropic)']]}),
agentCliCredentialKind('zcode',{name:'ZCode',logo:'glm',baseUrl:'https://open.bigmodel.cn/api/anthropic',
note:'未填写 Base URL 时连接智谱 BigModel 的 Anthropic 兼容服务(Messages)。',protocols:[['messages','Messages(Anthropic)'],['chat','Chat Completions'],['responses','Responses']]}),
];
function agentCliCredentialKind(cli,o){
const field=`agentCli.${cli}.`,configurable=!!o.protocols;
return {key:`agentCli.${cli}`,agentCli:cli,group:'model',name:o.name,short:`${o.name} API Key`,logo:o.logo,monochrome:!!o.monochrome,
use:`AI 对话的 ${o.name} 模型与以 ${o.name} 运行的 SOP 节点`,
description:`AI 对话切换到 ${o.name} 后可选用它的模型,SOP 在执行机器上以 ${o.name} 运行的节点也使用它。${o.note||''}`,
guide:o.guide||[['在模型服务商控制台创建 API Key'],['记下服务地址和它提供的接口协议'],['粘贴 Key,按需填写 Base URL 并选择协议;保存后可在模型目录里挑选 AI 对话的模型']],
placeholder:`请输入 ${o.name} API Key`,
...(configurable?{
extra:{name:field+'baseUrl',label:'Base URL',placeholder:o.baseUrl,url:true,clearWithKey:true,required:o.required,note:o.extraNote||(o.required?'必填':'')},
protocol:{name:field+'protocol',options:o.protocols},
}:{}),
models:{name:field+'models',engine:cli},
impact:`AI 对话将不能再切换到 ${o.name},以 ${o.name} 运行的 SOP 节点将无法执行${configurable?',Base URL、协议与模型目录一并清空':''}。`};
}
function credentialValue(user,name){
const [scope,cli,field]=String(name).split('.');
return scope==='agentCli'&&field?user?.agentCliCredentials?.[cli]?.[field]:user?.[name];
}
function credentialProtocol(kind,user){
const options=kind.protocol?.options||[],value=credentialValue(user,kind.protocol?.name||'');
return options.some(([id])=>id===value)?value:(options[0]?.[0]||'');
}
function credentialProtocolHTML(kind,value){
return `<label class="credential-field"><span>接口协议<em>Base URL 提供的 API</em></span><div class="credential-input is-plain is-select"><select name="protocol" aria-label="接口协议">${kind.protocol.options.map(([id,label])=>`<option value="${id}"${id===value?' selected':''}>${escapeHTML(label)}</option>`).join('')}</select></div></label>`;
}
// The model list behind an Anthropic-style Base URL sits under /v1.
function credentialModelsEndpoint(kind,protocol){
return kind.models.endpoint||({messages:'/v1/models',gemini:'/v1beta/models'}[protocol]||'/models');
}
// ---- 模型目录(Codex / Claude Code / 可配置 Agent CLI) ----
// A saved catalog is the chat list on the official endpoint and behind a Base URL.
// An empty catalog follows the CLI's built-in models when there is no Base URL
// and the Base URL's published models otherwise.
// Edits stay in the DOM until 保存.
const CREDENTIAL_CATALOG_MAX=100;
let credentialEffortCatalogs,credentialEffortCatalogRequest;
async function loadCredentialEffortCatalogs(){
if(credentialEffortCatalogs)return;
if(!credentialEffortCatalogRequest)credentialEffortCatalogRequest=api('/api/executor-models?builtin=1',{silent:true}).then(data=>{credentialEffortCatalogs=data}).catch(()=>{}).finally(()=>{credentialEffortCatalogRequest=null});
await credentialEffortCatalogRequest;
}
function credentialCatalogModels(value){
return (Array.isArray(value)?value:[]).map(model=>{
const id=String(model?.id||'').trim(),name=String(model?.name||'').trim();
const metadata={
...(model?.efforts?{efforts:model.efforts,defaultEffort:model.defaultEffort}:{}),
...(Array.isArray(model?.reasoningEfforts)?{reasoningEfforts:model.reasoningEfforts}:{}),
...(Array.isArray(model?.discoveredReasoningEfforts)?{discoveredReasoningEfforts:model.discoveredReasoningEfforts}:{}),
};
return {id,name:name===id?'':name,...metadata};
}).filter(model=>model.id||model.name);
}
function credentialCatalogStored(models){return credentialCatalogModels(models).map(({name,...model})=>name?{...model,name}:model)}
function credentialCatalogKey(models){
return JSON.stringify(credentialCatalogModels(models).map(model=>[
model.id,model.name,
model.reasoningEfforts?.slice().sort()??null,
model.discoveredReasoningEfforts?.slice().sort()??null,
Object.entries(model.efforts||{}).sort(([a],[b])=>a.localeCompare(b)),model.defaultEffort||'',
]));
}
function credentialCatalogError(models){
const seen=new Set();
if(models.length>CREDENTIAL_CATALOG_MAX)return {index:CREDENTIAL_CATALOG_MAX,error:`模型目录最多 ${CREDENTIAL_CATALOG_MAX} 个`};
for(const [index,{id='',name=''}] of models.entries()){
const model={id,name};
if(!model.id)return {index,field:'id',error:'模型 ID 不能为空'};
if(model.id.length>128)return {index,field:'id',error:'模型 ID 不能超过 128 个字符'};
if(/[\s"'`\\\u0000-\u001f\u007f]/.test(model.id))return {index,field:'id',error:`模型 ID「${model.id}」不能包含空格、引号或反斜杠`};
if(seen.has(model.id))return {index,field:'id',error:`模型 ID「${model.id}」重复`};
if([...model.name].length>64)return {index,field:'name',error:'显示名称不能超过 64 个字符'};
seen.add(model.id);
}
return null;
}
function credentialCatalogEffortSummary(model){
if(model.reasoningEfforts)return model.reasoningEfforts.join(' / ')||'仅使用默认';
if(!model.discoveredReasoningEfforts)return '自动';
return '自动 · '+(model.discoveredReasoningEfforts.join(' / ')||'仅使用默认');
}
function credentialCatalogEffortHTML(model,engine){
const available=credentialEffortCatalogs?.[engine==='claude-code'?'claude':engine]?.efforts||[];
const knownLevels=new Set([...(model.reasoningEfforts||[]),...(model.discoveredReasoningEfforts||[])]);
const additional=[...knownLevels].filter(value=>!available.some(option=>option.value===value));
const options=available.concat(additional.map(value=>({value,label:value})));
if(!options.length&&!model.discoveredReasoningEfforts)return '';
const custom=Array.isArray(model.reasoningEfforts),selected=model.reasoningEfforts??model.discoveredReasoningEfforts??[];
return `<details class="credential-catalog-effort"><summary>思考强度<span data-catalog-effort-summary>${escapeHTML(credentialCatalogEffortSummary(model))}</span></summary><label class="credential-catalog-effort-mode">可选强度<select data-catalog-effort-mode aria-label="思考强度配置"><option value="auto"${custom?'':' selected'}>自动</option><option value="custom"${custom?' selected':''}>自定义</option></select></label><div class="credential-catalog-effort-levels" data-catalog-effort-levels${custom?'':' hidden'}>${options.map(({value,label})=>`<label><input type="checkbox" data-catalog-effort="${escapeHTML(value)}"${selected.includes(value)?' checked':''}>${escapeHTML(label)}</label>`).join('')}<small>勾选此模型支持的强度;全部取消时仅使用模型默认强度。</small></div></details>`;
}
function syncCredentialCatalogEfforts(row){
if(!row)return;
const mode=row.querySelector('[data-catalog-effort-mode]');if(!mode)return;
row.querySelector('[data-catalog-effort-levels]').hidden=mode.value!=='custom';
row.querySelector('[data-catalog-effort-summary]').textContent=credentialCatalogEffortSummary(credentialCatalogRowModel(row));
}
function refreshCredentialCatalogEfforts(catalog){
if(!catalog?.isConnected)return;
credentialCatalogRows(catalog).forEach(row=>{
const html=credentialCatalogEffortHTML(credentialCatalogRowModel(row),catalog.dataset.catalogEngine),levels=row.querySelector('[data-catalog-effort-levels]');
if(!levels){row.insertAdjacentHTML('beforeend',html);return}
// Capabilities may arrive after a row was expanded. Add missing choices
// without replacing focused controls or the user's unsaved selections.
const holder=document.createElement('div');holder.innerHTML=html;
const options=[...holder.querySelectorAll('[data-catalog-effort]')];
const labels=new Map([...levels.querySelectorAll('[data-catalog-effort]')].map(input=>[input.dataset.catalogEffort,input.closest('label')]));
options.forEach((input,index)=>{
if(labels.has(input.dataset.catalogEffort))return;
const next=options.slice(index+1).map(option=>labels.get(option.dataset.catalogEffort)).find(Boolean)||levels.querySelector('small');
const label=input.closest('label');levels.insertBefore(label,next);labels.set(input.dataset.catalogEffort,label);
});
});
}
function credentialCatalogRowHTML(model={},engine=''){
const metadata=` data-catalog-metadata="${escapeHTML(JSON.stringify(credentialCatalogModels([model])[0]||{}))}"`;
return `<li class="credential-catalog-row" data-catalog-row${metadata}><button type="button" class="credential-catalog-grip" data-catalog-grip aria-label="拖动排序,也可以按 ↑ ↓ 移动">${credentialGlyph('grip',14)}</button><span class="credential-input is-plain"><input class="credential-mono" data-catalog-field="id" value="${escapeHTML(model.id||'')}" placeholder="模型 ID,如 gpt-5.5" aria-label="模型 ID" autocomplete="off" spellcheck="false"></span><span class="credential-input is-plain"><input data-catalog-field="name" value="${escapeHTML(model.name||'')}" placeholder="显示名称(可选)" aria-label="显示名称" autocomplete="off"></span><button type="button" class="credential-btn ghost icon danger credential-ink" data-catalog-act="remove" aria-label="移除模型">${credentialGlyph('trash',14)}</button>${credentialCatalogEffortHTML(model,engine)}</li>`;
}
function credentialCatalogCopy(mode,kind){
const name=kind?.name||'该 CLI';
if(mode==='runner')return {title:'使用执行机器的账号模型',detail:'获取这台机器的账号模型,或手动添加。',reset:'清空自定义列表',restored:'已清空目录,保存后生效'};
return mode==='official'
?{title:`使用 ${name} 自带的模型`,detail:`目录为空时,AI 对话列出 ${name} 支持的模型。获取可用模型可以改成自己的目录,也可以手动添加。`,reset:'清空目录,改回使用自带的模型',restored:'已恢复默认,保存后使用自带的模型'}
:{title:'跟随服务发布的模型',reset:'清空目录,改回跟随服务发布的模型',restored:'已恢复默认,保存后跟随服务发布的模型'};
}
function credentialCatalogDetailHTML(mode,kind,protocol){
const copy=credentialCatalogCopy(mode,kind);
return mode!=='remote'?escapeHTML(copy.detail):`目录为空时,AI 对话列出 Base URL 的 <code data-catalog-endpoint>${escapeHTML(credentialModelsEndpoint(kind,protocol))}</code> 返回的模型。`;
}
function credentialCatalogHTML(kind,user,{runnerLogin=false,label='模型目录'}={}){
const baseUrl=kind.extra?.url?credentialValue(user,kind.extra.name):'',protocol=credentialProtocol(kind,user);
const cursorAutomatic=kind.agentCli==='cursor'&&!user?.agentCliCredentials?.cursor?.modelsCustomized;
const models=credentialCatalogModels(cursorAutomatic?[]:credentialValue(user,kind.models.name)),empty=!models.length;
const mode=runnerLogin?'runner':!String(baseUrl||'').trim()?'official':'remote';
const copy=credentialCatalogCopy(mode,kind);
return `<section class="credential-catalog" data-credential-catalog data-catalog-engine="${escapeHTML(kind.models.engine)}" data-catalog-mode="${mode}" data-catalog-protocol="${escapeHTML(protocol)}" data-original-key="${escapeHTML(credentialCatalogKey(models))}" data-catalog-source="${escapeHTML(credentialCatalogSource(baseUrl))}" aria-label="模型目录">
<div class="credential-catalog-body" data-catalog-body>
<div class="credential-catalog-head"><div>${label?`<b>${escapeHTML(label)}</b>`:''}<small data-catalog-count>${credentialCatalogCountText(models.length)}</small></div><div><button type="button" class="credential-btn secondary credential-ink" data-catalog-act="probe">${credentialGlyph('download',14)}<span>获取可用模型</span></button><button type="button" class="credential-btn secondary credential-ink" data-catalog-act="add"><span class="credential-turn">${credentialGlyph('plus',14)}</span><span>添加模型</span></button></div></div>
<div class="credential-catalog-probe" data-catalog-probe hidden></div>
<ol class="credential-catalog-list" data-catalog-list${empty?' hidden':''}>${models.map(model=>credentialCatalogRowHTML(model,kind.models.engine)).join('')}</ol>
<div class="credential-catalog-empty" data-catalog-empty${empty?'':' hidden'}>${credentialGlyph('layers',16)}<div><b data-catalog-empty-title>${escapeHTML(copy.title)}</b><small data-catalog-empty-detail>${credentialCatalogDetailHTML(mode,kind,protocol)}</small></div></div>
<div class="credential-catalog-foot" data-catalog-foot${empty?' hidden':''}><button type="button" class="credential-btn link credential-ink" data-catalog-act="reset">${credentialGlyph('undo',13)}<span>恢复默认</span></button><small data-catalog-reset-note>${escapeHTML(copy.reset)}</small></div>
</div>
<span class="credential-sr" data-catalog-live role="status" aria-live="polite"></span>
</section>`;
}
function credentialCatalogSource(baseUrl){return String(baseUrl||'').trim().replace(/\/+$/,'')}
function credentialCatalogCountText(count){return count?`${count} 个模型`:'未自定义'}
function credentialCatalogRows(catalog){return [...catalog.querySelectorAll('[data-catalog-row]')]}
function credentialCatalogRowModel(row){
const id=row.querySelector('[data-catalog-field="id"]').value,name=row.querySelector('[data-catalog-field="name"]').value;
const metadata=row.dataset.catalogMetadata?JSON.parse(row.dataset.catalogMetadata):null;
const model=metadata?.id===id.trim()?{...metadata,id,name}:{id,name},mode=row.querySelector('[data-catalog-effort-mode]');
if(mode){
delete model.reasoningEfforts;
if(mode.value==='custom')model.reasoningEfforts=[...row.querySelectorAll('[data-catalog-effort]:checked')].map(input=>input.dataset.catalogEffort);
}
return model;
}
function credentialCatalogFilledRows(catalog){return credentialCatalogRows(catalog).filter(row=>credentialCatalogModels([credentialCatalogRowModel(row)]).length)}
function readCredentialCatalog(catalog){return credentialCatalogModels(credentialCatalogRows(catalog).map(credentialCatalogRowModel))}
function credentialCatalogMode(catalog){
const form=catalog?.closest('.credential-editor-form'),extra=form?.querySelector('input[name="extra"]');
if(!extra||catalog.dataset.catalogMode==='runner')return catalog.dataset.catalogMode;
return extra.value.trim()?'remote':'official';
}
function credentialCatalogDirty(catalog){return !!catalog&&credentialCatalogKey(readCredentialCatalog(catalog))!==catalog.dataset.originalKey}
function credentialCatalogPayload(catalog){
if(!catalog)return undefined;
return credentialCatalogDirty(catalog)?readCredentialCatalog(catalog):undefined;
}
function syncCredentialCatalog(catalog){
const mode=credentialCatalogMode(catalog),kind=credentialKind(catalog.closest('[data-credential-row]')?.dataset.credentialRow),protocol=catalog.closest('.credential-editor-form')?.querySelector('select[name="protocol"]')?.value||catalog.dataset.catalogProtocol;
const copy=credentialCatalogCopy(mode,kind);
const title=catalog.querySelector('[data-catalog-empty-title]'),detail=catalog.querySelector('[data-catalog-empty-detail]'),note=catalog.querySelector('[data-catalog-reset-note]');
if(title)title.textContent=copy.title;
if(detail)detail.innerHTML=credentialCatalogDetailHTML(mode,kind,protocol);
if(note)note.textContent=copy.reset;
if(catalog.dataset.catalogMode&&catalog.dataset.catalogMode!==mode&&!catalog.querySelector('[data-catalog-probe]').hidden)closeCredentialCatalogProbe(catalog);
catalog.dataset.catalogMode=mode;
const rows=credentialCatalogRows(catalog).length,empty=!rows;
catalog.querySelector('[data-catalog-count]').textContent=credentialCatalogCountText(rows);
catalog.querySelector('[data-catalog-list]').hidden=empty;
catalog.querySelector('[data-catalog-empty]').hidden=!empty;
catalog.querySelector('[data-catalog-foot]').hidden=empty;
catalog.querySelector('[data-catalog-act="add"]').disabled=rows>=CREDENTIAL_CATALOG_MAX;
}
function announceCredentialCatalog(catalog,text){const live=catalog.querySelector('[data-catalog-live]');if(live)live.textContent=text}
function credentialCatalogChanged(catalog){
syncCredentialCatalog(catalog);
const form=catalog.closest('.credential-editor-form');if(form)updateCredentialEditorDirty(form);
catalog.onCatalogChange?.();
}
function resetCredentialCatalog(row){
const catalog=row.querySelector('[data-credential-catalog]'),kind=credentialKind(row.dataset.credentialRow);if(!catalog||!kind)return;
const holder=document.createElement('div');
holder.innerHTML=credentialCatalogHTML(kind,credentialUser());
catalog.replaceWith(holder.firstElementChild);
const fresh=row.querySelector('[data-credential-catalog]');
syncCredentialCatalog(fresh);
hydrateCredentialIcons(fresh);
}
function addCredentialCatalogRow(catalog,model={}){
const list=catalog.querySelector('[data-catalog-list]');
list.insertAdjacentHTML('beforeend',credentialCatalogRowHTML(model,catalog.dataset.catalogEngine));
const row=list.lastElementChild;
hydrateCredentialIcons(row);
credentialCatalogChanged(catalog);
return row;
}
function removeCredentialCatalogRow(catalog,row){
const next=row.nextElementSibling||row.previousElementSibling;
row.remove();
credentialCatalogChanged(catalog);
announceCredentialCatalog(catalog,'已移除模型,保存后生效');
(next?.querySelector('[data-catalog-grip]')||catalog.querySelector('[data-catalog-act="add"]'))?.focus({preventScroll:true});
}
function moveCredentialCatalogRow(catalog,row,step){
const target=step<0?row.previousElementSibling:row.nextElementSibling;if(!target)return;
if(step<0)target.before(row);else target.after(row);
row.querySelector('[data-catalog-grip]')?.focus({preventScroll:true});
credentialCatalogChanged(catalog);
announceCredentialCatalog(catalog,`已移到第 ${credentialCatalogRows(catalog).indexOf(row)+1} 位`);
}
function startCredentialCatalogDrag(event,grip){
if(event.button!==0)return;
const row=grip.closest('[data-catalog-row]'),catalog=grip.closest('[data-credential-catalog]'),list=row?.parentElement;if(!row||!catalog)return;
event.preventDefault();
row.classList.add('is-dragging');list.classList.add('is-sorting');
const move=moveEvent=>{
if(moveEvent.pointerId!==event.pointerId)return;
const y=moveEvent.clientY;
let prev=row.previousElementSibling,next=row.nextElementSibling;
while(prev&&y<prev.getBoundingClientRect().top+prev.getBoundingClientRect().height/2){prev.before(row);prev=row.previousElementSibling}
while(next&&y>next.getBoundingClientRect().top+next.getBoundingClientRect().height/2){next.after(row);next=row.nextElementSibling}
};
const end=endEvent=>{
if(endEvent.pointerId!==event.pointerId)return;
window.removeEventListener('pointermove',move);window.removeEventListener('pointerup',end);window.removeEventListener('pointercancel',end);
row.classList.remove('is-dragging');list.classList.remove('is-sorting');
grip.focus({preventScroll:true});
credentialCatalogChanged(catalog);
};
window.addEventListener('pointermove',move);window.addEventListener('pointerup',end);window.addEventListener('pointercancel',end);
}
function credentialCatalogProbeHTML(catalog,kind){
const probe=catalog.probe,current=new Set(readCredentialCatalog(catalog).map(model=>model.id)),followAll=!current.size;
const items=probe.models.map(model=>{
const listed=current.has(model.id),checked=followAll||listed;
return `<label class="credential-catalog-pick" data-pick="${escapeHTML((model.id+' '+(model.name||'')).toLowerCase())}"><input type="checkbox" value="${escapeHTML(model.id)}"${checked?' checked':''}><code>${escapeHTML(model.id)}</code>${model.name&&model.name!==model.id?`<small>${escapeHTML(model.name)}</small>`:''}${listed?'<em>已在目录</em>':''}</label>`;
}).join('');
const protocol=catalog.closest('.credential-editor-form')?.querySelector('select[name="protocol"]')?.value||catalog.dataset.catalogProtocol;
const sources={builtin:'CLI 内置模型',official:'来自官方服务',runner:'来自这台机器的账号登录'};
const source=sources[probe.source]||`来自 Base URL 的 ${escapeHTML(credentialModelsEndpoint(kind,protocol))}`;
return `<div class="credential-catalog-probe-top"><span class="credential-input is-plain is-search">${credentialGlyph('search',14)}<input data-catalog-search placeholder="搜索模型" aria-label="搜索模型" autocomplete="off" spellcheck="false"></span><span class="credential-catalog-picked" data-catalog-picked></span><button type="button" class="credential-btn link credential-ink" data-catalog-act="toggle-all">全选</button></div>
<div class="credential-catalog-probe-list" role="group" aria-label="可用模型">${items}</div>
<div class="credential-catalog-probe-foot"><small>${source} · 勾选的模型会加入目录,取消勾选会移出</small><div><button type="button" class="credential-btn ghost credential-ink" data-catalog-act="probe-close">取消</button><button type="button" class="credential-btn primary credential-ink" data-catalog-act="probe-apply">更新列表</button></div></div>`;
}
function syncCredentialCatalogProbe(catalog){
const panel=catalog.querySelector('[data-catalog-probe]'),query=String(panel.querySelector('[data-catalog-search]')?.value||'').trim().toLowerCase();
const picks=[...panel.querySelectorAll('.credential-catalog-pick')];
picks.forEach(pick=>{pick.hidden=!!query&&!pick.dataset.pick.includes(query)});
const visible=picks.filter(pick=>!pick.hidden),checked=picks.filter(pick=>pick.querySelector('input').checked).length;
const counter=panel.querySelector('[data-catalog-picked]');if(counter)counter.textContent=`已选 ${checked} / ${picks.length}`;
const toggle=panel.querySelector('[data-catalog-act="toggle-all"]');
if(toggle){toggle.textContent=visible.length&&visible.every(pick=>pick.querySelector('input').checked)?'全不选':'全选';toggle.disabled=!visible.length}
}
function closeCredentialCatalogProbe(catalog){
const panel=catalog.querySelector('[data-catalog-probe]');
catalog.probeToken=(catalog.probeToken||0)+1;catalog.probe=null;
panel.hidden=true;panel.innerHTML='';
}
async function probeCredentialCatalog(row,catalog,button){
const kind=credentialKind(row.dataset.credentialRow),form=row.querySelector('.credential-editor-form'),panel=catalog.querySelector('[data-catalog-probe]');
const extra=form?.querySelector('input[name="extra"]'),secret=form?.querySelector('[name="secret"]')?.value.trim()||'',protocol=form?.querySelector('select[name="protocol"]')?.value,environment=form?.querySelector('select[name="extra"]')?.value;
const extraError=extra?credentialExtraError(kind,extra.value,protocol):'';
if(extraError){toast(extraError,'err');extra.focus();return}
const token=(catalog.probeToken||0)+1;catalog.probeToken=token;catalog.probe=null;
panel.hidden=false;
panel.innerHTML=`<p class="credential-vline is-info" role="status">${credentialSpinner(13)}正在获取可用模型…</p>`;
hydrateCredentialIcons(panel);
setCredentialButtonBusy(button,'获取中');
let result;
try{
result=catalog.probeModels?await catalog.probeModels():await api(`/api/users/${state.currentUser.id}/cli-models/probe`,{method:'POST',body:JSON.stringify({
engine:kind.models.engine,apiKey:secret,baseUrl:extra?.value.trim(),protocol,environment
}),silent:true});
}
catch(err){result={error:err.message}}
finally{setCredentialButtonBusy(button,'')}
if(catalog.probeToken!==token||!catalog.isConnected)return;
if(result?.error||!result?.models?.length){
panel.innerHTML=`<div class="credential-catalog-probe-fail"><p class="credential-vline is-err" role="alert">${credentialGlyph('alert',13)}${escapeHTML(result?.error||'服务没有返回可用模型')}</p><div><button type="button" class="credential-btn ghost credential-ink" data-catalog-act="probe-close">关闭</button><button type="button" class="credential-btn secondary credential-ink" data-catalog-act="probe">${credentialGlyph('refresh',13)}<span>重试</span></button></div></div>`;
hydrateCredentialIcons(panel);
return;
}
const source=credentialCatalogSource(extra?.value);
if(extra&&source!==catalog.dataset.catalogSource){
const cleared=credentialCatalogRows(catalog);
cleared.forEach(item=>item.remove());
catalog.dataset.catalogSource=source;
credentialCatalogChanged(catalog);
if(cleared.length)announceCredentialCatalog(catalog,'Base URL 已更换,原模型目录已清空,保存后生效');
}
catalog.probe=result;
panel.innerHTML=credentialCatalogProbeHTML(catalog,kind);
hydrateCredentialIcons(panel);
syncCredentialCatalogProbe(catalog);
panel.querySelector('[data-catalog-search]')?.focus({preventScroll:true});
}
function toggleCredentialCatalogProbe(catalog){
const panel=catalog.querySelector('[data-catalog-probe]'),visible=[...panel.querySelectorAll('.credential-catalog-pick:not([hidden]) input')];
const on=!visible.every(input=>input.checked);
visible.forEach(input=>{input.checked=on});
syncCredentialCatalogProbe(catalog);
}
function applyCredentialCatalogProbe(catalog){
const probe=catalog.probe;if(!probe)return;
const picked=new Set([...catalog.querySelectorAll('[data-catalog-probe] input[type="checkbox"]:checked')].map(input=>input.value));
const offered=new Set(probe.models.map(model=>model.id)),kept=new Set();
const discovered=new Map(probe.models.map(model=>[model.id,model]));
let removed=0;
credentialCatalogRows(catalog).forEach(row=>{
const id=row.querySelector('[data-catalog-field="id"]').value.trim();
if(offered.has(id)&&!picked.has(id)){row.remove();removed++}else{
kept.add(id);
if(picked.has(id)&&discovered.has(id)){
const current=credentialCatalogRowModel(row),fresh=discovered.get(id);
row.outerHTML=credentialCatalogRowHTML({...current,...fresh,name:current.name,reasoningEfforts:current.reasoningEfforts},catalog.dataset.catalogEngine);
}
}
});
const added=probe.models.filter(model=>picked.has(model.id)&&!kept.has(model.id));
const room=Math.max(0,CREDENTIAL_CATALOG_MAX-kept.size),list=catalog.querySelector('[data-catalog-list]');
list.insertAdjacentHTML('beforeend',credentialCatalogModels(added.slice(0,room)).map(model=>credentialCatalogRowHTML(model,catalog.dataset.catalogEngine)).join(''));
hydrateCredentialIcons(list);
closeCredentialCatalogProbe(catalog);
credentialCatalogChanged(catalog);
const skipped=added.length-Math.min(added.length,room);
const message=`模型目录已更新:新增 ${Math.min(added.length,room)} 个,移除 ${removed} 个${skipped?`,超出上限未加入 ${skipped} 个`:''},保存后生效`;
announceCredentialCatalog(catalog,message);
toast(message,skipped?'err':'ok');
catalog.querySelector('[data-catalog-act="probe"]')?.focus({preventScroll:true});
}
function credentialCatalogAction(action,row,catalog,button){
if(action==='add'){addCredentialCatalogRow(catalog).querySelector('[data-catalog-field="id"]').focus({preventScroll:true});return}
if(action==='remove')return removeCredentialCatalogRow(catalog,button.closest('[data-catalog-row]'));
if(action==='reset'){
credentialCatalogRows(catalog).forEach(item=>item.remove());
credentialCatalogChanged(catalog);
announceCredentialCatalog(catalog,credentialCatalogCopy(credentialCatalogMode(catalog),credentialKind(row?.dataset.credentialRow)).restored);
catalog.querySelector('[data-catalog-act="add"]')?.focus({preventScroll:true});
return;
}
if(action==='probe')return probeCredentialCatalog(row,catalog,catalog.querySelector('[data-catalog-act="probe"]'));
if(action==='probe-close'){closeCredentialCatalogProbe(catalog);catalog.querySelector('[data-catalog-act="probe"]')?.focus({preventScroll:true});return}
if(action==='toggle-all')return toggleCredentialCatalogProbe(catalog);
if(action==='probe-apply')return applyCredentialCatalogProbe(catalog);
}
function credentialCatalogKeydown(event){
const grip=event.target.closest?.('[data-catalog-grip]');
if(!grip||!['ArrowUp','ArrowDown'].includes(event.key))return;
event.preventDefault();
moveCredentialCatalogRow(grip.closest('[data-credential-catalog]'),grip.closest('[data-catalog-row]'),event.key==='ArrowUp'?-1:1);
}
function validateCredentialCatalog(catalog,models){
const error=models&&credentialCatalogError(models);
if(!error)return true;
toast(error.error,'err');
const input=credentialCatalogFilledRows(catalog)[error.index]?.querySelector(`[data-catalog-field="${error.field||'id'}"]`);
if(input){
const box=input.closest('.credential-input');
box.classList.add('is-bad');
box.classList.remove('is-shake');
void box.offsetWidth;
box.classList.add('is-shake');
input.focus();
}
return false;
}
// Platform features depend on these, in the order people should configure them.
const CREDENTIAL_RECOMMENDED=['gitToken','codeBuddyApiKey'];
const CREDENTIAL_PAT_WARNING='请填写 GitHub <b>个人访问令牌(PAT)</b>,为目标仓库授予 <b>Contents</b> 和 <b>Pull requests</b> 的读写权限;少勾权限会导致克隆 / 推送仓库失败。';
function credentialKind(key){return CREDENTIAL_KINDS.find(kind=>kind.key===key)||null}
// Kinds with a dialog manage several entries there instead of the inline editor.
function credentialDialog(key){return credentialKind(key)?.dialog||null}
function credentialConfigured(kind,user){if(kind.key==='gitToken')return !!user.gitHubCredentialConfigured;return !!credentialValue(user,kind.agentCli?kind.key+'.apiKeyConfigured':kind.key+'Configured')}
function credentialUser(){return userById(state.currentUser?.id)||{}}
function credentialUI(){return state.credentialUI||(state.credentialUI={open:null,filter:'all',closed:{}})}
function credentialGlyph(name,size=16,cls=''){return `<svg class="agent-icon harness-icon${cls?' '+cls:''}" data-icon="${name}" width="${size}" height="${size}" aria-hidden="true" focusable="false"></svg>`}
function credentialSpinner(size=14){return credentialGlyph('arc-spinner',size,'credential-spin')}
function credentialLogo(kind,cls=''){
const file=kind.logo?.endsWith('.png')?kind.logo:kind.logo+'.svg';
return `<span class="credential-logo${kind.monochrome?' monochrome':''}${cls?' '+cls:''}">${kind.icon?credentialGlyph(kind.icon,18):`<img src="/images/credentials/${file}" alt="">`}</span>`;
}
function hydrateCredentialIcons(root){if(root)window.AgentFlowHarnessIcons?.hydrate?.(root)}
function credentialNextKind(user){return CREDENTIAL_RECOMMENDED.map(credentialKind).find(kind=>!credentialConfigured(kind,user))||null}
function credentialSecretError(kind,value){
return '';
}
// Advisory only: a third-party model key is accepted here but CodeBuddy answers it with 401.
function credentialSecretWarning(kind,value){
const text=String(value||'').trim();
if(kind?.key!=='codeBuddyApiKey'||!text||text.startsWith('ck_'))return '';
return /^sk-/i.test(text)
?'这像是 DeepSeek、OpenAI 等第三方模型的 Key,CodeBuddy 会拒绝;第三方 Key 请改填到 Claude Code 或 Codex 凭证并设置 Base URL'
:'CodeBuddy API Key 通常以 ck_ 开头,请确认复制的是 CodeBuddy 的 Key';
}
// The value an extra field starts from. An old network environment preselects what it meant (china → 国内站),
// and one that cannot be guessed shows as 国际站, which is what the CLI uses.
function credentialExtraValue(kind,value){
if(kind?.extra?.options)return codeBuddyEnvironmentIntent(value)?.value??'';
return value||kind?.extra?.fallback||'';
}
function credentialExtraLabel(kind,value){
if(kind.extra.options){const env=codeBuddyEnvironment(value)||CODEBUDDY_ENVIRONMENTS[0];return `${env.label} · ${env.site}`}
return String(value||'').trim()||(kind.extra.url?'官方地址':kind.extra.fallback||'');
}
function codeBuddyEnvironmentHintHTML(selected,stored=''){
const raw=String(stored||'').trim(),legacy=codeBuddyEnvironmentLegacy(raw)?`原来填写的「${raw}」无法识别,CodeBuddy 实际按国际站连接,点保存改为上面选择的环境。`:'';
return `${escapeHTML(legacy)}Key 只能在创建它的站点使用 · <a href="${escapeHTML(codeBuddyKeyURL(selected))}" target="_blank" rel="noopener noreferrer" data-credential-key-link>${escapeHTML(codeBuddyKeyLinkLabel(selected))} ↗</a>`;
}
function credentialSelectFieldHTML(kind,stored,note=''){
const selected=credentialExtraValue(kind,stored);
const options=kind.extra.options.map(option=>`<option value="${escapeHTML(option.value)}"${option.value===selected?' selected':''}>${escapeHTML(option.label)} · ${escapeHTML(option.site)}</option>`).join('');
return `<label class="credential-field"><span>${escapeHTML(kind.extra.label)}${note?`<em>${escapeHTML(note)}</em>`:''}</span><div class="credential-input is-plain is-select"><select name="extra">${options}</select></div><small class="credential-env-hint" data-credential-env-hint>${codeBuddyEnvironmentHintHTML(selected,stored)}</small></label>`;
}
// Keeps the 获取 API Key links pointed at the edition that is selected now.
function refreshCredentialEnvironmentLinks(scope,value){
const hint=scope?.querySelector('[data-credential-env-hint]');if(hint)hint.innerHTML=codeBuddyEnvironmentHintHTML(value);
scope?.querySelectorAll('[data-wizard-link][data-environment-link]').forEach(link=>{link.href=codeBuddyKeyURL(value);link.textContent=`${codeBuddyKeyLinkLabel(value)} ↗`});
}
function credentialExtraError(kind,value,protocol){
const text=String(value||'').trim();
if(!text&&kind.extra?.required?.(protocol))return '请填写 Base URL';
if(!kind.extra?.url||!text)return '';
try{const url=new URL(text);if(url.protocol==='http:'||url.protocol==='https:')return ''}catch{}
return '请填写以 http:// 或 https:// 开头的地址';
}
// Only the fields of one credential are sent; the server leaves the rest alone.
function credentialSavePayload(kind,values={}){
if(kind.agentCli){
const entry={},secret=String(values.secret||'').trim();
if(secret)entry.apiKey=secret;
if(kind.extra&&values.extra!==undefined)entry.baseUrl=String(values.extra||'').trim();
if(kind.protocol&&values.protocol!==undefined)entry.protocol=values.protocol;
if(kind.models&&values.models!==undefined)entry.models=credentialCatalogStored(values.models);
return {agentCliCredentials:{[kind.agentCli]:entry}};
}
const payload={[kind.key]:String(values.secret||'').trim()};
if(kind.extra&&values.extra!==undefined)payload[kind.extra.name]=String(values.extra||'').trim()||(kind.extra.fallback||'');
if(kind.models&&values.models!==undefined)payload[kind.models.name]=credentialCatalogStored(values.models);
return payload;
}
function credentialClearPayload(kind){
if(kind.agentCli){
const entry={apiKeyClear:true,baseUrl:'',protocol:''};
if(kind.models)entry.models=[];
return {agentCliCredentials:{[kind.agentCli]:entry}};
}
const payload={[kind.key+'Clear']:true};
if(kind.extra?.clearWithKey)payload[kind.extra.name]='';
if(kind.models)payload[kind.models.name]=[];
return payload;
}
function gitTokenVerifyFor(user){return state.gitTokenVerify&&Number(state.gitTokenVerify.userId)===Number(user?.id)?state.gitTokenVerify:null}
function gitTokenFailure(result){
if(!result)return '';
if(result.error)return result.error;
if(!result.valid)return `令牌有效但缺少权限:${(result.missing||[]).join('、')},请在代码托管平台补充授权`;
return '';
}
function credentialStatus(kind,user){
if(!credentialConfigured(kind,user))return 'empty';
if(kind.key!=='gitToken')return 'ok';
const verify=gitTokenVerifyFor({id:state.currentUser?.id});
if(verify?.busy)return 'busy';
return gitTokenFailure(verify?.result)?'err':'ok';
}
function credentialBadgeHTML(status){
const lamp={empty:'<span class="hui-lamp is-hollow" aria-hidden="true"><i></i></span>',ok:'<span class="hui-lamp" aria-hidden="true"><i></i></span>',busy:credentialSpinner(12),err:credentialGlyph('alert',12)}[status];
const label={empty:'未配置',ok:'已配置',busy:'校验中',err:'有错误'}[status];
const tone={empty:'muted',ok:'success',busy:'info',err:'error'}[status];
return `<span class="hui-badge credential-status" data-size="sm" data-tone="${tone}" data-status="${status}" role="status">${lamp}<span class="hui-badge-label">${label}</span></span>`;
}
function credentialSubline(kind,user){
const dot='<i class="credential-dot"></i>',use=`<span>${escapeHTML(kind.use)}</span>`;
if(!credentialConfigured(kind,user))return use;
if(kind.key==='gitToken'){
const verify=gitTokenVerifyFor({id:state.currentUser?.id}),result=verify?.result,source=`<span>${user.gitTokenOAuth?'工蜂授权':'个人访问令牌'}</span>`;
if(verify?.busy)return source+dot+'<span class="is-info">正在校验…</span>';
if(!result)return source+dot+use;
if(result.error)return source+dot+`<span class="is-err">${escapeHTML(result.error)}</span>`;
if(!result.valid)return source+dot+`<span class="is-err">缺少权限 ${escapeHTML((result.missing||[]).join('、'))}</span>`;
return source+dot+'<span class="is-ok">令牌有效</span>'+(result.scopes?.length?dot+`<span class="credential-mono">${escapeHTML(result.scopes.join(' · '))}</span>`:'');
}
if(kind.key==='codeBuddyApiKey'){
const raw=String(user.codeBuddyInternetEnvironment||'').trim(),env=codeBuddyEnvironment(raw);
return `<span>网络环境</span>${env?`<span class="credential-mono">${escapeHTML(env.label)}</span>`:`<span class="is-err">「${escapeHTML(raw)}」无法识别,按国际站连接</span>`}${dot}${use}`;
}
if(kind.extra){
const models=kind.models&&credentialCatalogModels(credentialValue(user,kind.models.name)).length,baseUrl=credentialValue(user,kind.extra.name);
const protocol=kind.protocol?kind.protocol.options.find(([id])=>id===credentialProtocol(kind,user))?.[1]:'';
return (baseUrl?`<span class="credential-mono">${escapeHTML(baseUrl)}</span>`:'<span>官方地址</span>')+(protocol?dot+`<span>${escapeHTML(protocol)}</span>`:'')+(models?dot+`<span>${models} 个自定义模型</span>`:'')+dot+use;
}
return use;
}
function credentialFieldHTML({label,note='',name,type='password',value='',placeholder='',hint='',hintTone='',id='',multiline=false}){
if(multiline)return `<label class="credential-field"><span>${escapeHTML(label)}${note?`<em>${escapeHTML(note)}</em>`:''}</span><div class="credential-input"><textarea${id?` id="${id}"`:''} name="${name}" rows="5" maxlength="16384" spellcheck="false" autocomplete="off" placeholder="${escapeHTML(placeholder)}"></textarea></div><small data-credential-hint="${name}" class="${hintTone?'is-'+hintTone:''}">${escapeHTML(hint)}</small></label>`;
const secret=type==='password';
// Secrets are never serialized into markup; callers assign input.value after rendering.
return `<label class="credential-field"><span>${escapeHTML(label)}${note?`<em>${escapeHTML(note)}</em>`:''}</span><div class="credential-input${secret?'':' is-plain'}${hintTone?' is-'+(hintTone==='err'?'bad':hintTone==='ok'?'good':hintTone):''}"><input${id?` id="${id}"`:''} name="${name}" type="${type}" ${secret?'autocomplete="new-password"':'autocomplete="off" spellcheck="false"'}${secret?'':` value="${escapeHTML(value)}"`} placeholder="${escapeHTML(placeholder)}">${secret?`<button type="button" class="credential-eye" data-credential-eye aria-label="显示">${credentialGlyph('eye',15)}</button>`:''}</div>${hint!==null?`<small data-credential-hint="${name}"${hintTone?` class="is-${hintTone}"`:''}>${escapeHTML(hint)}</small>`:''}</label>`;
}
function credentialOAuthHTML(label,note){
return (typeof githubConnectHTML==='function'?githubConnectHTML():'')+`<div class="credential-oauth" data-gongfeng-oauth${state.gongfengOAuthEnabled?'':' hidden'}><a class="credential-btn secondary credential-ink" href="/api/auth/gongfeng/start" target="_blank" rel="noopener noreferrer">${credentialLogo(credentialKind('gitToken'),'is-mini')}<span>${label}</span></a><small>${note}</small></div>`;
}
function credentialPatWarningHTML(show){return `<div class="credential-note is-warn git-token-pat-warning"${show?'':' hidden'}>${credentialGlyph('alert',14)}<span>${CREDENTIAL_PAT_WARNING}</span></div>`}
const GIT_TOKEN_REPLACE_HINT='保存后替换当前的令牌,对下一次任务生效';
function credentialAgo(at){
const seconds=Math.max(0,Math.round((Date.now()-at)/1000));
if(seconds<60)return '刚刚';
if(seconds<3600)return `${Math.floor(seconds/60)} 分钟前`;
if(seconds<86400)return `${Math.floor(seconds/3600)} 小时前`;
return `${Math.floor(seconds/86400)} 天前`;
}
function gitTokenDetailHTML(kind,user){
const verify=gitTokenVerifyFor({id:state.currentUser?.id}),result=verify?.result,missing=result?.missing||[];
const scopes=(result?.scopes||[]).filter(scope=>!missing.includes(scope)).map(scope=>`<code class="credential-scope">${escapeHTML(scope)}</code>`)
.concat(missing.map(scope=>`<code class="credential-scope is-miss" title="缺少此权限">${escapeHTML(scope)}</code>`)).join('');
const ago=verify?.checkedAt?` · ${credentialAgo(verify.checkedAt)}`:'';
const checked=verify?.busy?`<span class="is-info">${credentialSpinner(13)}校验中…</span>`
:!result?'<span class="is-muted">尚未校验</span>'
:result.error?`<span class="is-err">${escapeHTML(result.error)}</span>${ago}`
:!result.valid?`<span class="is-err">令牌有效但缺少权限 ${escapeHTML(missing.join('、'))}</span>${ago}`
:`<span class="is-ok">令牌有效</span>${ago}`;
return `<dl class="credential-kv" data-git-detail><dt>来源</dt><dd>${user.gitTokenOAuth?'工蜂授权 · 到期自动续期':'GitHub 授权 / 个人访问令牌'}</dd><dt>权限</dt><dd>${scopes||'<span class="is-muted">校验后显示</span>'}</dd><dt>最近校验</dt><dd>${checked}</dd><dt>用于</dt><dd>${escapeHTML(kind.description)}</dd></dl>`;
}
function gitTokenEditorHTML(kind,user){
const failure=gitTokenFailure(gitTokenVerifyFor({id:state.currentUser?.id})?.result);
return `<div class="credential-editor-form is-detail">
${credentialPatWarningHTML(!!failure)}
${gitTokenDetailHTML(kind,user)}
<div class="credential-swap">
<div class="credential-bar" data-credential-pane="bar">${credentialOAuthHTML('重新授权','')}<button type="button" class="credential-btn ${failure?'primary':'secondary'} credential-ink" data-credential-act="replace">${credentialGlyph('key',14)}<span>手动更换令牌</span></button><button type="button" class="credential-btn ghost danger credential-ink" data-credential-act="delete">${credentialGlyph('trash',14)}<span>删除凭证</span></button></div>
<div class="credential-replace is-off" data-credential-pane="form" inert>
${credentialFieldHTML({label:'新的个人访问令牌',note:'保存前会校验有效性与权限',name:'secret',placeholder:'粘贴 GitHub 个人访问令牌(PAT)',hint:GIT_TOKEN_REPLACE_HINT})}
<div class="credential-replace-acts"><button type="button" class="credential-btn ghost credential-ink" data-credential-act="cancel">取消</button><button type="button" class="credential-btn primary credential-ink" data-credential-act="save" disabled>校验并保存</button></div>
<p class="credential-vline git-token-verify-status" data-git-verify-line role="status"></p>
</div>
<div class="credential-confirm is-off" data-credential-pane="confirm" role="alert" inert><div>删除 <b>${escapeHTML(kind.short)}</b>?${escapeHTML(kind.impact)}</div><button type="button" class="credential-btn ghost credential-ink" data-credential-act="undelete">取消</button><button type="button" class="credential-btn danger-solid credential-ink" data-credential-act="confirm-delete">删除</button></div>
</div>
</div>`;
}
function credentialEditorHTML(kind,user){
if(kind.key==='gitToken')return gitTokenEditorHTML(kind,user);
const extraStored=kind.extra?credentialValue(user,kind.extra.name):'';
const extraValue=kind.extra?credentialExtraValue(kind,extraStored):'';
const extraField=!kind.extra?''
:kind.extra.options?credentialSelectFieldHTML(kind,extraStored,'与 Key 所在站点一致')
:credentialFieldHTML({label:kind.extra.label,note:kind.extra.note||(kind.extra.url?'留空使用官方地址':''),name:'extra',type:kind.extra.url?'url':'text',value:extraValue,placeholder:kind.extra.placeholder,hint:null});
const protocolValue=kind.protocol?credentialProtocol(kind,user):'';
const protocolField=kind.protocol?credentialProtocolHTML(kind,protocolValue):'';
const legacy=!!(kind.extra?.options&&codeBuddyEnvironmentLegacy(user[kind.extra.name]));
return `<div class="credential-editor-form${kind.models?' has-catalog':''}"${kind.extra?` data-original="${escapeHTML(extraValue)}"`:''}${kind.protocol?` data-original-protocol="${escapeHTML(protocolValue)}"`:''}${legacy?' data-legacy="true"':''}>
${credentialFieldHTML({label:kind.short,note:'已配置 · 留空则不改',name:'secret',placeholder:'输入新值以替换',hint:kind.hint||''})}
${extraField}
${protocolField}
${kind.models?credentialCatalogHTML(kind,user):''}
<div class="credential-swap">
<div class="credential-editor-foot" data-credential-pane="foot"><button type="button" class="credential-btn ghost danger credential-ink" data-credential-act="delete">${credentialGlyph('trash',14)}<span>删除</span></button><div><button type="button" class="credential-btn ghost credential-ink" data-credential-act="cancel">取消</button><button type="button" class="credential-btn primary credential-ink" data-credential-act="save"${legacy?'':' disabled'}>保存</button></div></div>
<div class="credential-confirm is-off" data-credential-pane="confirm" role="alert"><div>删除 <b>${escapeHTML(kind.short)}</b>?${escapeHTML(kind.impact)}</div><button type="button" class="credential-btn ghost credential-ink" data-credential-act="undelete">取消</button><button type="button" class="credential-btn danger-solid credential-ink" data-credential-act="confirm-delete">删除</button></div>
</div>
</div>`;
}
function credentialRowMainHTML(kind,user){
const managed=!!kind.dialog,on=credentialConfigured(kind,user),open=on&&credentialUI().open===kind.key,status=credentialStatus(kind,user);
const end=on&&!managed
?`${credentialBadgeHTML(status)}${kind.key==='gitToken'?`<span class="credential-tip" data-tip="重新校验"><button type="button" class="credential-btn ghost icon credential-ink git-token-verify" data-credential-act="verify" aria-label="重新校验"${status==='busy'?' disabled':''}>${credentialGlyph('refresh',15)}</button></span>`:''}<span class="credential-chevron">${credentialGlyph('chevron-down',16)}</span>`
:`${credentialBadgeHTML(status)}<button type="button" class="credential-btn secondary credential-ink" data-credential-act="setup"${managed?' aria-haspopup="dialog"':''}>${managed?kind.action:'去配置'}<span class="credential-nudge">${credentialGlyph('chevron-right',13)}</span></button>`;
const interaction=managed?'':` role="button" tabindex="0"${on?` aria-expanded="${open}"`:''}`;
return `<div class="credential-row-main credential-ink"${interaction}>${credentialLogo(kind,on?'':'is-dim')}<div class="credential-row-who"><b>${escapeHTML(kind.name)}<span>${escapeHTML(kind.short)}</span></b><small>${credentialSubline(kind,user)}</small></div><div class="credential-row-end">${end}</div></div>`;
}
function credentialRowHTML(kind,user){
const on=credentialConfigured(kind,user),open=on&&credentialUI().open===kind.key;
const editor=on&&!kind.dialog?credentialEditorHTML(kind,user):'';
return `<div class="credential-row${on?' is-configured':''}${open?' is-open':''}" data-credential-row="${kind.key}">${credentialRowMainHTML(kind,user)}<div class="credential-editor"><div><div class="credential-editor-inner">${editor}</div></div></div></div>`;
}
function credentialGroupHTML(group,user){
const kinds=CREDENTIAL_KINDS.filter(kind=>kind.group===group.id),done=kinds.filter(kind=>credentialConfigured(kind,user)).length,closed=!!credentialUI().closed[group.id];
return `<section class="credential-group" data-credential-group="${group.id}"><button type="button" class="credential-group-head credential-ink" aria-expanded="${!closed}">${credentialGlyph(group.icon,16)}<strong>${escapeHTML(group.name)}</strong><span class="credential-group-sub">${escapeHTML(group.sub)}</span><span class="credential-group-meta">${done} / ${kinds.length}</span><span class="credential-group-chevron">${credentialGlyph('chevron-down',15)}</span></button><div class="credential-fold${closed?' is-closed':''}"><div><div class="credential-rows">${kinds.map(kind=>credentialRowHTML(kind,user)).join('')}<p class="credential-empty" hidden></p></div></div></div></section>`;
}
function credentialProgressHTML(user){
const done=CREDENTIAL_KINDS.filter(kind=>credentialConfigured(kind,user)).length,next=credentialNextKind(user);
return `<div class="credential-segs" aria-hidden="true">${CREDENTIAL_KINDS.map((_,index)=>`<i${index<done?' class="is-on"':''}></i>`).join('')}</div><span class="credential-count"><b>${done}</b> / ${CREDENTIAL_KINDS.length} 已配置</span>`
+(next?`<span class="credential-next">下一步<button type="button" class="credential-btn link credential-ink" data-credential-setup="${next.key}">配置 ${escapeHTML(next.short)}<span class="credential-nudge">${credentialGlyph('arrow-right',13)}</span></button></span>`:`<span class="credential-ready">${credentialGlyph('check',15)}推荐凭证已全部就绪</span>`);
}
function credentialFilterHTML(user){
const done=CREDENTIAL_KINDS.filter(kind=>credentialConfigured(kind,user)).length,filter=credentialUI().filter;
return [['all','全部',CREDENTIAL_KINDS.length],['configured','已配置',done],['missing','未配置',CREDENTIAL_KINDS.length-done]].map(([id,label,count])=>`<button type="button" role="tab" data-credential-filter="${id}" class="${filter===id?'active':''}" aria-selected="${filter===id}">${label}<span>${count}</span></button>`).join('');
}
function credentialPanelHTML(user){
return `<header class="credential-section-head"><div><h2>个人凭证</h2><p>SOP 使用需求责任人(未指定时为项目 Owner)的个人凭证,保存后对下一次任务生效。</p></div><button type="button" class="credential-btn primary credential-ink" id="credentialAddButton" data-credential-add><span class="credential-turn">${credentialGlyph('plus',15)}</span><span>添加凭证</span></button></header>
<div class="credential-note credential-subscription-note">
${credentialGlyph('monitor',16)}
<div><strong>使用已有订阅</strong>
<p>绑定已登录 Claude Code、Codex 或 Antigravity 的机器,选「账号登录」即可用订阅额度运行对话和 SOP,无需 API Key。</p></div>
<a class="button ghost small" href="#/runners"><span>配置执行机器</span>${credentialGlyph('arrow-right',14)}</a>
</div>
<div class="credential-progress">${credentialProgressHTML(user)}</div>
<div class="credential-toolbar"><div class="credential-filter" role="tablist" aria-label="筛选凭证">${credentialFilterHTML(user)}</div></div>
<div class="credential-list">${CREDENTIAL_GROUPS.map(group=>credentialGroupHTML(group,user)).join('')}</div>`;
}
function applyCredentialFilter(panel,user){
const filter=credentialUI().filter;
panel.querySelectorAll('[data-credential-row]').forEach(row=>{
const on=credentialConfigured(credentialKind(row.dataset.credentialRow),user);
row.classList.toggle('is-filtered',(filter==='configured'&&!on)||(filter==='missing'&&on));
});
panel.querySelectorAll('[data-credential-group]').forEach(group=>{
const empty=group.querySelector('.credential-empty'),visible=group.querySelectorAll('[data-credential-row]:not(.is-filtered)').length;
empty.hidden=!!visible;
empty.textContent=filter==='configured'?'这一组还没有配置凭证':'这一组已全部配置';
});
}
function renderCredentialPanel(){
const panel=$('#credentialPanel');if(!panel)return;
const user=credentialUser();
panel.innerHTML=credentialPanelHTML(user);
if(typeof hydrateGitHubConnections==='function')hydrateGitHubConnections(panel);
applyCredentialFilter(panel,user);
hydrateCredentialIcons(panel);
}
function repaintCredentialRow(key){
const row=$(`#credentialPanel [data-credential-row="${key}"]`),kind=credentialKind(key);if(!row||!kind)return;
const user=credentialUser(),holder=document.createElement('div');
holder.innerHTML=credentialRowMainHTML(kind,user);
row.querySelector('.credential-row-main').replaceWith(holder.firstElementChild);
if(key==='gitToken'){
// Only the read-only parts are replaced: an open replace form keeps what was typed.
const failure=gitTokenFailure(gitTokenVerifyFor({id:state.currentUser?.id})?.result),detail=row.querySelector('[data-git-detail]'),warning=row.querySelector('.git-token-pat-warning'),replace=row.querySelector('[data-credential-act="replace"]');
if(detail){holder.innerHTML=gitTokenDetailHTML(kind,user);detail.replaceWith(holder.firstElementChild)}
if(warning)warning.hidden=!failure;
if(replace){replace.classList.toggle('primary',!!failure);replace.classList.toggle('secondary',!failure)}
}
row.querySelector('.credential-status')?.classList.add('is-swap');
hydrateCredentialIcons(row);
}
function flashCredentialRow(key){
const row=$(`#credentialPanel [data-credential-row="${key}"]`);if(!row)return;
row.classList.remove('is-flash');void row.offsetWidth;row.classList.add('is-flash');
row.querySelector('.credential-status')?.classList.add('is-swap');
}
function setCredentialRowOpen(key,open){
const row=$(`#credentialPanel [data-credential-row="${key}"]`);if(!row)return;
row.classList.toggle('is-open',open);
row.querySelector('.credential-row-main')?.setAttribute('aria-expanded',String(open));
if(!open){
resetCredentialEditor(row);
showCredentialPane(row,'bar');
}
}
function resetCredentialEditor(row){
row.querySelectorAll('[name="secret"]').forEach(input=>{input.value='';if(input.tagName==='INPUT')input.type='password'});
const form=row.querySelector('.credential-editor-form');if(!form)return;
const extra=form.querySelector('[name="extra"]');if(extra)extra.value=form.dataset.original||'';
if(extra?.tagName==='SELECT')refreshCredentialEnvironmentLinks(form,extra.value);
const protocol=form.querySelector('select[name="protocol"]');if(protocol)protocol.value=form.dataset.originalProtocol||'';
resetCredentialCatalog(row);
if(row.dataset.credentialRow==='gitToken'){
const line=form.querySelector('[data-git-verify-line]');if(line){line.classList.remove('is-err');line.innerHTML=''}
setCredentialHint(form,'secret',GIT_TOKEN_REPLACE_HINT);
}else setCredentialHint(form,'secret',credentialKind(row.dataset.credentialRow)?.hint||'');
updateCredentialEditorDirty(form);
}
function toggleCredentialRow(key,open){
const ui=credentialUI(),next=open??ui.open!==key;
if(ui.open&&ui.open!==key)setCredentialRowOpen(ui.open,false);
ui.open=next?key:null;
setCredentialRowOpen(key,next);
// 代码仓库 opens on its read-only detail; the token input only appears after 手动更换令牌.
if(next&&key!=='gitToken')setTimeout(()=>$(`#credentialPanel [data-credential-row="${key}"] [name="secret"]`)?.focus({preventScroll:true}),200);
}
const CREDENTIAL_PANE_FOCUS={form:'[name="secret"]',confirm:'[data-credential-act="undelete"]'};
// 代码仓库 swaps bar / form / confirm; the other kinds swap foot / confirm. Unknown names fall back to the first pane.
function showCredentialPane(row,name,focus=CREDENTIAL_PANE_FOCUS[name]){
const panes=['bar','foot','form','confirm'].map(pane=>row.querySelector(`[data-credential-pane="${pane}"]`)).filter(Boolean);if(!panes.length)return;
const target=panes.find(pane=>pane===row.querySelector(`[data-credential-pane="${name}"]`))||panes[0];
panes.forEach(pane=>{const on=pane===target;pane.classList.toggle('is-off',!on);pane.inert=!on});
if(focus)setTimeout(()=>target.querySelector(focus)?.focus({preventScroll:true}),60);
}
function updateCredentialEditorDirty(form){
const secret=form.querySelector('[name="secret"]')?.value.trim()||'',extra=form.querySelector('[name="extra"]'),protocol=form.querySelector('select[name="protocol"]'),save=form.querySelector('[data-credential-act="save"]');
if(save&&!save.dataset.busy)save.disabled=!secret&&!form.dataset.legacy&&!(extra&&extra.value.trim()!==(form.dataset.original||''))&&!(protocol&&protocol.value!==(form.dataset.originalProtocol||''))&&!credentialCatalogDirty(form.querySelector('[data-credential-catalog]'));
}
function setCredentialHint(scope,name,text,tone=''){
const hint=scope.querySelector(`[data-credential-hint="${name}"]`),box=scope.querySelector(`[name="${name}"]`)?.closest('.credential-input');
if(hint){hint.textContent=text;hint.className=tone?'is-'+tone:''}
if(box){box.classList.toggle('is-bad',tone==='err');box.classList.toggle('is-good',tone==='ok');box.classList.toggle('is-warn',tone==='warn');if(tone==='err'){box.classList.remove('is-shake');void box.offsetWidth;box.classList.add('is-shake')}}
}
function setCredentialButtonBusy(button,label){
if(!button)return;
if(label){button.dataset.busy='true';button.dataset.label=button.innerHTML;button.disabled=true;button.innerHTML=`${credentialSpinner(14)}<span>${escapeHTML(label)}</span>`;hydrateCredentialIcons(button);return}
delete button.dataset.busy;button.disabled=false;if(button.dataset.label!=null)button.innerHTML=button.dataset.label;
}
function storeCredentialUser(saved){
const users=state.data.users||(state.data.users=[]),index=users.findIndex(u=>Number(u.id)===Number(saved.id));
if(index>=0)users[index]=saved;else users.push(saved);
}
function notifyCredentialsChanged(){$('#chatNextFrame')?.contentWindow?.postMessage({type:'agentflow-credentials-changed'},location.origin)}
async function saveCredential(key,values={},options={}){
const user=state.currentUser,kind=credentialKind(key);
let saved;
if(key==='gitToken'){
const endpoint=`/api/users/${user.id}/git-http-credentials`,credentials=await api(endpoint),existing=credentials.find(credential=>credential.host==='github.com');
const listed=await api(endpoint,{method:'PUT',body:JSON.stringify({...(existing?{id:existing.id}:{}),name:'GitHub',platform:'github',host:'github.com',username:'x-access-token',token:values.secret})});
saved={...credentialUser(),id:user.id,gitHubCredentialConfigured:listed.some(item=>item.host==='github.com'),gitHttpCredentialsConfigured:listed.length>0};
}else saved=await api(`/api/users/${user.id}/credentials`,{method:'PUT',body:JSON.stringify(credentialSavePayload(kind,values))});
if(key==='gitToken'&&!options.verified)state.gitTokenVerify=null;
storeCredentialUser(saved);
notifyCredentialsChanged();
return saved;
}
async function deleteCredential(key){
const user=state.currentUser,kind=credentialKind(key);
let saved;
if(key==='gitToken'){
const endpoint=`/api/users/${user.id}/git-http-credentials`,credentials=await api(endpoint),existing=credentials.find(credential=>credential.host==='github.com');
const listed=existing?await api(`${endpoint}/${encodeURIComponent(existing.id)}`,{method:'DELETE'}):credentials;
saved={...credentialUser(),id:user.id,gitHubCredentialConfigured:listed.some(item=>item.host==='github.com'),gitHttpCredentialsConfigured:listed.length>0};
}else saved=await api(`/api/users/${user.id}/credentials`,{method:'PUT',body:JSON.stringify(credentialClearPayload(kind))});
if(key==='gitToken')state.gitTokenVerify=null;
storeCredentialUser(saved);
notifyCredentialsChanged();
return saved;
}
// Git 令牌必须先校验通过才保存,校验失败时什么都不写入。
async function verifyAndSaveGitToken(token){
const user=state.currentUser;
const result=await api(`/api/users/${user.id}/git-token/verify`,{method:'POST',body:JSON.stringify({token}),silent:true});
if(!result?.valid)return {saved:false,result};
const saved=await saveCredential('gitToken',{secret:token},{verified:true});
state.gitTokenVerify={userId:user.id,result,checkedAt:Date.now()};
return {saved:true,result,user:saved};
}
async function refreshGitTokenStatus(options={}){
const user=state.currentUser;if(!user||user.isGuest)return null;
// The previous answer stays alongside busy so the detail keeps its scopes while re-checking.
const previous=gitTokenVerifyFor(user);
state.gitTokenVerify={userId:user.id,busy:true,result:previous?.result,checkedAt:previous?.checkedAt};
repaintCredentialRow('gitToken');
let result;
try{result=await api(`/api/users/${user.id}/git-token/verify`,{silent:true})}
catch(err){result={valid:false,error:err.message}}
if(Number(state.currentUser?.id)!==Number(user.id))return result;
state.gitTokenVerify={userId:user.id,result,checkedAt:Date.now()};
repaintCredentialRow('gitToken');
const announce=options.announce||state.gitTokenAnnounceVerify;
state.gitTokenAnnounceVerify=false;
if(announce){const failure=gitTokenFailure(result);toast(failure||'Git 令牌校验通过',failure?'err':'ok')}
return result;
}
function credentialSaved(key,message){
credentialUI().open=null;
renderCredentialPanel();
flashCredentialRow(key);
toast(message,'ok');
}
async function submitCredentialEditor(row,button){
const key=row.dataset.credentialRow,kind=credentialKind(key),form=row.querySelector('.credential-editor-form');
const secret=form.querySelector('[name="secret"]').value.trim(),extra=form.querySelector('[name="extra"]'),protocol=form.querySelector('[name="protocol"]');
const secretError=credentialSecretError(kind,secret),extraError=extra?credentialExtraError(kind,extra.value,protocol?.value):'';
if(secretError){setCredentialHint(form,'secret',secretError,'err');return}
if(extraError){toast(extraError,'err');extra.focus();return}
const catalog=form.querySelector('[data-credential-catalog]'),models=credentialCatalogPayload(catalog);
if(!validateCredentialCatalog(catalog,models))return;
setCredentialButtonBusy(button,key==='gitToken'?'校验中':'保存中');
try{
if(key==='gitToken'){
const outcome=await verifyAndSaveGitToken(secret);
if(!outcome.saved){
setCredentialButtonBusy(button,'');
const line=row.querySelector('[data-git-verify-line]'),warning=row.querySelector('.git-token-pat-warning');
if(line){line.classList.add('is-err');line.innerHTML=credentialGlyph('alert',13)+escapeHTML(`${gitTokenFailure(outcome.result)||'Git Token 校验未通过'}(未保存)`);hydrateCredentialIcons(line)}
if(warning)warning.hidden=false;
return;
}
credentialSaved(key,'Git Token 校验通过,已保存');
return;
}
await saveCredential(key,{secret,...(extra?{extra:extra.value}:{}),...(protocol?{protocol:protocol.value}:{}),...(models?{models}:{})});
credentialSaved(key,`${kind.short} 已保存`);
}catch(err){toast(err.message,'err');setCredentialButtonBusy(button,'')}
}
async function confirmDeleteCredential(row,button){
const key=row.dataset.credentialRow,kind=credentialKind(key);
setCredentialButtonBusy(button,'删除中');
try{await deleteCredential(key);credentialSaved(key,`${kind.short} 已删除`)}
catch(err){toast(err.message,'err');setCredentialButtonBusy(button,'')}
}
function toggleCredentialSecret(button){
const input=button.previousElementSibling,show=input.type==='password';
input.type=show?'text':'password';
button.setAttribute('aria-label',show?'隐藏':'显示');
button.innerHTML=credentialGlyph(show?'eye-off':'eye',15);
hydrateCredentialIcons(button);
}
function credentialRowAction(action,row,button){
const key=row.dataset.credentialRow;
if(action==='setup')return openCredentialWizard(key);
if(action==='verify')return refreshGitTokenStatus({announce:true});
const gongfeng=key==='gitToken';
if(action==='replace')return showCredentialPane(row,'form');
if(action==='cancel'){
if(!gongfeng)return toggleCredentialRow(key,false);
resetCredentialEditor(row);
return showCredentialPane(row,'bar','[data-credential-act="replace"]');
}
if(action==='delete')return showCredentialPane(row,'confirm');
if(action==='undelete')return showCredentialPane(row,'bar',gongfeng?'[data-credential-act="delete"]':'');
if(action==='confirm-delete')return confirmDeleteCredential(row,button);
if(action==='save')return submitCredentialEditor(row,button);
}
function setCredentialFilter(panel,filter){
credentialUI().filter=filter;
panel.querySelectorAll('[data-credential-filter]').forEach(tab=>{const on=tab.dataset.credentialFilter===filter;tab.classList.toggle('active',on);tab.setAttribute('aria-selected',String(on))});
applyCredentialFilter(panel,credentialUser());
}
function toggleCredentialGroup(head){
const id=head.closest('[data-credential-group]').dataset.credentialGroup,ui=credentialUI();
ui.closed[id]=!ui.closed[id];
head.setAttribute('aria-expanded',String(!ui.closed[id]));
head.nextElementSibling.classList.toggle('is-closed',!!ui.closed[id]);
}
function activateCredentialRow(row){
const key=row.dataset.credentialRow;
const dialog=credentialDialog(key);if(dialog)return dialog();
return row.classList.contains('is-configured')?toggleCredentialRow(key):openCredentialWizard(key);
}
function bindCredentialPanel(panel){
panel.onclick=event=>{
const target=event.target;
if(target.closest('[data-credential-add]'))return openCredentialWizard();
const setup=target.closest('[data-credential-setup]');if(setup)return openCredentialWizard(setup.dataset.credentialSetup);
const filter=target.closest('[data-credential-filter]');if(filter)return setCredentialFilter(panel,filter.dataset.credentialFilter);
const head=target.closest('.credential-group-head');if(head)return toggleCredentialGroup(head);
const eye=target.closest('[data-credential-eye]');if(eye)return toggleCredentialSecret(eye);
const row=target.closest('[data-credential-row]');if(!row)return;
const catalogAction=target.closest('[data-catalog-act]');
if(catalogAction){event.stopPropagation();if(!catalogAction.disabled)credentialCatalogAction(catalogAction.dataset.catalogAct,row,catalogAction.closest('[data-credential-catalog]'),catalogAction);return}
const action=target.closest('[data-credential-act]');
if(action){event.stopPropagation();if(!action.disabled)credentialRowAction(action.dataset.credentialAct,row,action);return}
if(target.closest('.credential-editor'))return;
if(target.closest('.credential-row-main'))activateCredentialRow(row);
};
panel.onkeydown=event=>{
const main=event.target.closest?.('.credential-row-main[role="button"]');
if(main&&event.target===main&&(event.key==='Enter'||event.key===' ')){event.preventDefault();activateCredentialRow(main.closest('[data-credential-row]'))}
credentialCatalogKeydown(event);
if(event.defaultPrevented)return;
const probe=event.target.closest?.('[data-catalog-probe]');
if(probe&&event.key==='Escape'){event.preventDefault();event.stopPropagation();credentialCatalogAction('probe-close',null,probe.closest('[data-credential-catalog]'));return}
const input=event.target.closest?.('.credential-editor-form input, .credential-editor-form select');
if(input&&event.key==='Enter'&&!probe){event.preventDefault();const save=input.closest('.credential-editor-form').querySelector('[data-credential-act="save"]');if(!save.disabled)save.click()}
};
panel.onpointerdown=event=>{
const grip=event.target.closest?.('[data-catalog-grip]');if(grip)startCredentialCatalogDrag(event,grip);
};
panel.oninput=event=>{
const form=event.target.closest?.('.credential-editor-form');if(!form)return;
const catalog=event.target.closest('[data-credential-catalog]');
if(catalog){
if(event.target.closest('[data-catalog-probe]'))return syncCredentialCatalogProbe(catalog);
event.target.closest('.credential-input')?.classList.remove('is-bad');
syncCredentialCatalogEfforts(event.target.closest('[data-catalog-row]'));
}
if(event.target.name==='extra'||event.target.name==='protocol'){const catalogBox=form.querySelector('[data-credential-catalog]');if(catalogBox)syncCredentialCatalog(catalogBox)}
if(event.target.name==='secret'){
const kind=credentialKind(form.closest('[data-credential-row]').dataset.credentialRow),error=credentialSecretError(kind,event.target.value),warning=credentialSecretWarning(kind,event.target.value);
setCredentialHint(form,'secret',error||warning||(kind.key==='gitToken'?GIT_TOKEN_REPLACE_HINT:kind.hint||''),error?'err':warning?'warn':'');
}
if(event.target.name==='extra'&&event.target.tagName==='SELECT')refreshCredentialEnvironmentLinks(form,event.target.value);
updateCredentialEditorDirty(form);
};
}
// gotoCredential lands here for configured credentials.
function revealCredentialRow(key){
const panel=$('#credentialPanel'),row=panel?.querySelector(`[data-credential-row="${key}"]`);if(!row)return;
if(row.classList.contains('is-filtered'))setCredentialFilter(panel,'all');
const group=row.closest('[data-credential-group]'),head=group?.querySelector('.credential-group-head');
if(head&&credentialUI().closed[group.dataset.credentialGroup])toggleCredentialGroup(head);
if(credentialUI().open!==key)toggleCredentialRow(key,true);
else if(key!=='gitToken')setTimeout(()=>row.querySelector('[name="secret"]')?.focus({preventScroll:true}),200);
row.scrollIntoView({block:'center',behavior:'smooth'});
row.classList.add('credential-highlight');
setTimeout(()=>row.classList.remove('credential-highlight'),2400);
}
// ---- 添加凭证向导 ----
let credentialWizard=null;
function credentialWizardDefaults(kind,user){return kind?.extra?credentialExtraValue(kind,credentialValue(user,kind.extra.name)):''}
function openCredentialWizard(key){
const user=credentialUser();
if(!state.currentUser||state.currentUser.isGuest||!$('#credentialPanel'))return;
const dialog=credentialDialog(key);if(dialog)return dialog();
const preset=key?credentialKind(key):null;
if(preset&&credentialConfigured(preset,user))return revealCredentialRow(key);
const kind=preset||CREDENTIAL_RECOMMENDED.map(credentialKind).find(k=>!credentialConfigured(k,user))||CREDENTIAL_KINDS.find(k=>!credentialConfigured(k,user))||null;
if(credentialWizard)closeCredentialWizard(true);
credentialUI().open&&toggleCredentialRow(credentialUI().open,false);
credentialWizard={step:preset?2:1,kind:kind?.key||null,direct:!!preset,secret:'',extra:credentialWizardDefaults(kind,user),protocol:credentialProtocol(kind||{},user),saving:false,error:'',done:false,guide:{},returnFocus:document.activeElement};
let scrim=$('#credentialWizard');
if(scrim?.closeTimer){clearTimeout(scrim.closeTimer);scrim.closeTimer=0}
if(!scrim){
scrim=document.createElement('div');
scrim.id='credentialWizard';
scrim.className='credential-scrim';
scrim.innerHTML=`<section class="credential-dialog" role="dialog" aria-modal="true" aria-label="添加凭证" tabindex="-1"><div class="credential-dialog-top"><div class="credential-dots" aria-hidden="true"><span></span><span></span><span></span></div><div><span data-wizard-step role="status"></span><button type="button" class="credential-btn ghost icon credential-ink" data-wizard-close aria-label="关闭">${credentialGlyph('close',15)}</button></div></div><div class="credential-dialog-body"></div><div class="credential-dialog-foot"></div></section>`;
document.body.append(scrim);
scrim.addEventListener('pointerdown',event=>{if(event.target===scrim)closeCredentialWizard()});
scrim.addEventListener('click',credentialWizardClick);
scrim.addEventListener('input',credentialWizardInput);
}
document.removeEventListener('keydown',credentialWizardKeydown,true);
document.addEventListener('keydown',credentialWizardKeydown,true);
$('#personalSettingsContent')?.classList.add('credential-wizard-open');
paintCredentialWizard(0);
scrim.querySelector('.credential-dialog').focus({preventScroll:true});
requestAnimationFrame(()=>scrim.classList.add('is-open'));
setTimeout(focusCredentialWizard,260);
}
function closeCredentialWizard(immediate=false){
const wizard=credentialWizard,scrim=$('#credentialWizard');
if(!wizard||(wizard.saving&&!immediate))return;
credentialWizard=null;
document.removeEventListener?.('keydown',credentialWizardKeydown,true);
$('#personalSettingsContent')?.classList.remove('credential-wizard-open');
if(!scrim)return;
const remove=()=>{scrim.closeTimer=0;scrim.remove()};
scrim.classList.remove('is-open');
// The secret input is removed with the dialog so nothing typed stays in the DOM.
scrim.querySelectorAll('input').forEach(input=>{input.value=''});
if(immediate)remove();else scrim.closeTimer=setTimeout(remove,260);
if(wizard.done)flashCredentialRow(wizard.kind);
if(wizard.returnFocus?.isConnected)wizard.returnFocus.focus({preventScroll:true});
}
function credentialWizardValid(wizard=credentialWizard){
const kind=credentialKind(wizard.kind);if(!kind)return {ok:false};
const secret=String(wizard.secret||'').trim(),error=credentialSecretError(kind,secret)||(kind.extra?credentialExtraError(kind,wizard.extra,wizard.protocol):'');
return {ok:!!secret&&!error,error};
}
function credentialWizardSecretHint(kind,wizard,validity=credentialWizardValid(wizard)){
const error=credentialSecretError(kind,wizard.secret);if(error)return {text:error,tone:'err'};
const warning=credentialSecretWarning(kind,wizard.secret);if(warning)return {text:warning,tone:'warn'};
return validity.ok?{text:'格式正确',tone:'ok'}:{text:kind.hint||'只在你负责的任务运行时注入,保存后不再明文展示',tone:''};
}
function credentialWizardStepOneHTML(user){
const wizard=credentialWizard,all=CREDENTIAL_KINDS.every(kind=>credentialConfigured(kind,user));
const groups=CREDENTIAL_GROUPS.map(group=>`<p class="credential-opt-label">${escapeHTML(group.name)}</p><div class="credential-opts" role="radiogroup" aria-label="${escapeHTML(group.name)}">${CREDENTIAL_KINDS.filter(kind=>kind.group===group.id).map((kind,index)=>{
const on=credentialConfigured(kind,user),selected=wizard.kind===kind.key;
return `<button type="button" class="credential-opt${selected?' is-selected':''}" style="--i:${index}" role="radio" aria-checked="${selected}" data-wizard-kind="${kind.key}"${on&&!kind.dialog?' disabled':''}><span class="credential-radio">${credentialGlyph('check',10)}</span>${credentialLogo(kind)}<span class="credential-opt-text"><b>${escapeHTML(kind.name)}</b><small>${escapeHTML(kind.short)}</small></span>${on?'<span class="credential-pill is-ok">已配置</span>':CREDENTIAL_RECOMMENDED.includes(kind.key)?'<span class="credential-pill">推荐</span>':''}</button>`;
}).join('')}</div>`).join('');
return `<div class="credential-question">${credentialGlyph('key',16)}<span>要添加哪一项凭证?</span><small>选择一项 · 已配置的可在列表中编辑</small></div>${groups}${all?`<div class="credential-note">${credentialGlyph('check',14)}<span>已全部配置,可在列表中编辑。</span></div>`:''}`;
}
function credentialWizardStepTwoHTML(kind){
const wizard=credentialWizard;
// A guide link given as functions follows the selected network environment.
const guide=kind.guide.map(([text,href,label],index)=>{
const dynamic=typeof href==='function',url=dynamic?href(wizard.extra):href,name=typeof label==='function'?label(wizard.extra):label;
return `<li class="${wizard.guide[index]?'is-done':''}" data-wizard-guide="${index}"><span class="credential-guide-no">${wizard.guide[index]?credentialGlyph('check-draw',10):index+1}</span><span>${text}${url?`<a href="${escapeHTML(url)}" target="_blank" rel="noopener noreferrer" data-wizard-link="${index}"${dynamic?' data-environment-link':''}>${escapeHTML(name)} ↗</a>`:''}</span></li>`;
}).join('');
const github=kind.key==='gitToken';
const manual=wizard.githubMethod==='manual';
const methods=github?`<div class="github-methods" role="tablist" aria-label="GitHub 连接方式"><button type="button" role="tab" data-github-method="oauth" aria-selected="${!manual}">GitHub 授权</button><button type="button" role="tab" data-github-method="manual" aria-selected="${manual}">访问令牌</button></div>`:'';
if(github&&!manual)return `<div class="credential-question">${credentialLogo(kind,'is-mini')}<span>连接 GitHub</span><small class="credential-description">连接后可选择仓库,用于克隆代码、创建分支和推送交付产物。</small></div>${methods}${credentialOAuthHTML('用工蜂授权','')}`;
const validity=credentialWizardValid();
const {text:secretHint,tone:secretTone}=credentialWizardSecretHint(kind,wizard,validity);
const secretField=credentialFieldHTML({label:github?'个人访问令牌(PAT)':kind.short,name:'secret',id:'credentialWizardSecret',placeholder:kind.placeholder,hint:secretHint,hintTone:secretTone});
const extraField=!kind.extra?''
:kind.extra.options?credentialSelectFieldHTML(kind,wizard.extra)
:credentialFieldHTML({label:kind.extra.label,note:kind.extra.note||(kind.extra.url?'可选 · 留空使用官方地址':''),name:'extra',type:kind.extra.url?'url':'text',value:wizard.extra,placeholder:kind.extra.placeholder,hint:''});
const protocolField=kind.protocol?credentialProtocolHTML(kind,wizard.protocol||credentialProtocol(kind,{})):'';
// The network environment decides where the key comes from, so it is chosen first.
return `<div class="credential-question">${credentialLogo(kind,'is-mini')}<span>${github?'使用访问令牌':'配置 '+escapeHTML(kind.short)}</span><small class="credential-description">${escapeHTML(kind.description)}</small></div>${methods}<ol class="credential-guide">${guide}</ol><div class="credential-fields">
${kind.extra?.options?extraField+secretField:secretField+extraField+protocolField}
</div>`;
}
function credentialWizardStepThreeHTML(kind){
const wizard=credentialWizard;
if(wizard.done)return `<div class="credential-saved"><span class="credential-check-big"><svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12.5l4.2 4.2L19 7"/></svg></span><h4>${escapeHTML(kind.short)} 已保存</h4><p>下一次运行你负责的任务时生效,可随时在列表中展开编辑。</p></div>`;
const extra=kind.extra?`<dt>${escapeHTML(kind.extra.label)}</dt><dd${kind.extra.url?' class="credential-mono"':''}>${escapeHTML(credentialExtraLabel(kind,wizard.extra))}</dd>`:'';
const warning=credentialSecretWarning(kind,wizard.secret);
const line=wizard.error?`<p class="credential-vline is-err" role="alert">${credentialGlyph('alert',13)}${escapeHTML(wizard.error)}</p>`
:wizard.saving&&kind.key==='gitToken'?`<p class="credential-vline is-info" role="status">${credentialSpinner(13)}正在校验令牌有效性与权限…</p>`
:kind.key==='gitToken'?`<p class="credential-vline git-token-verify-status">${credentialGlyph('lock',13)}保存前会先校验令牌有效性与权限</p>`
:warning?`<p class="credential-vline is-warn" role="status">${credentialGlyph('alert',13)}${escapeHTML(warning)}</p>`:'';
return `<div class="credential-question">${credentialGlyph('check',16)}<span>确认并保存</span><small>密钥只在任务运行时注入,不写入 Agent 资产</small></div><div class="credential-summary"><div>${credentialGlyph('key',14)}${escapeHTML(kind.name)}</div><dl><dt>凭证</dt><dd>${escapeHTML(kind.short)}</dd><dt>密钥</dt><dd class="credential-mask">已填写 ••••••••</dd>${extra}<dt>生效</dt><dd>下一次任务</dd></dl></div>${line}`;
}
function credentialWizardFootHTML(){
const wizard=credentialWizard;
if(wizard.step===2&&wizard.kind==='gitToken'&&wizard.githubMethod!=='manual')return '<span class="credential-kbd"><kbd>Esc</kbd> 关闭</span><span class="github-private-note">仅为当前账号授权</span>';
if(wizard.done)return `<span></span><button type="button" class="credential-btn primary credential-ink" data-wizard-done>完成</button>`;
const back=wizard.step===1||(wizard.direct&&wizard.step===2)
?'<span class="credential-kbd"><kbd>Esc</kbd> 关闭</span>'
:`<button type="button" class="credential-btn ghost credential-ink" data-wizard-back${wizard.saving?' disabled':''}><span class="credential-nudge is-left">${credentialGlyph('arrow-left',13)}</span>上一步</button>`;
if(wizard.step<3){
const ok=wizard.step===1?!!wizard.kind&&(!!credentialDialog(wizard.kind)||!credentialConfigured(credentialKind(wizard.kind),credentialUser())):credentialWizardValid().ok;
return `${back}<button type="button" class="credential-btn secondary credential-ink" data-wizard-next${ok?'':' disabled'}>下一步<span class="credential-nudge">${credentialGlyph('chevron-right',13)}</span></button>`;
}
const gongfeng=wizard.kind==='gitToken';
return `${back}<button type="button" class="credential-btn primary credential-ink" data-wizard-next${wizard.saving?' disabled data-busy="true"':''}>${wizard.saving?credentialSpinner(14)+`<span>${gongfeng?'校验中':'保存中'}</span>`:credentialGlyph('check',14)+`<span>${gongfeng?'校验并保存':'保存凭证'}</span>`}</button>`;
}
function credentialWizardPaneHTML(){
const wizard=credentialWizard,kind=credentialKind(wizard.kind);
if(wizard.step===1)return credentialWizardStepOneHTML(credentialUser());
if(wizard.step===2)return credentialWizardStepTwoHTML(kind);
return credentialWizardStepThreeHTML(kind);
}
function paintCredentialWizard(direction){
const scrim=$('#credentialWizard'),wizard=credentialWizard;if(!scrim||!wizard)return;
const body=scrim.querySelector('.credential-dialog-body'),before=body.offsetHeight,old=body.querySelector('.credential-pane:not(.is-leaving)');
const pane=document.createElement('div');
pane.className='credential-pane'+(direction>0?' is-forward':direction<0?' is-back':'');
pane.innerHTML=credentialWizardPaneHTML();
if(old&&direction){old.className=`credential-pane is-leaving ${direction>0?'is-forward':'is-back'}`;old.querySelectorAll('input,textarea').forEach(input=>{input.value=''});setTimeout(()=>old.remove(),180)}
else old?.remove();
body.append(pane);
const secretInput=pane.querySelector('[name="secret"]');if(secretInput)secretInput.value=wizard.secret||'';
if(before&&direction){body.style.height=before+'px';requestAnimationFrame(()=>{body.style.height=pane.offsetHeight+'px';setTimeout(()=>{body.style.height=''},300)})}
scrim.querySelectorAll('.credential-dots span').forEach((dot,index)=>{dot.className=wizard.done||index+1<wizard.step?'is-done':index+1===wizard.step?'is-current':''});
scrim.querySelector('[data-wizard-step]').textContent=wizard.done?'已完成':`${wizard.step} / 3`;
scrim.querySelector('[data-wizard-close]').disabled=wizard.saving;
scrim.querySelector('.credential-dialog-foot').innerHTML=credentialWizardFootHTML();
hydrateCredentialIcons(scrim);
if(typeof hydrateGitHubConnections==='function')hydrateGitHubConnections(pane);
pane.querySelectorAll('[data-github-method]').forEach(button=>{button.onclick=()=>{wizard.githubMethod=button.dataset.githubMethod;paintCredentialWizard(0);focusCredentialWizard()}});
}
function refreshCredentialWizardFoot(){
const scrim=$('#credentialWizard');if(!scrim||!credentialWizard)return;
scrim.querySelector('.credential-dialog-foot').innerHTML=credentialWizardFootHTML();
hydrateCredentialIcons(scrim.querySelector('.credential-dialog-foot'));
}
function focusCredentialWizard(){
const pane=$('#credentialWizard .credential-pane:not(.is-leaving)');
// Deferred calls must not pull focus back once the user is already in this pane, or typing lands in the wrong field.
if(pane?.contains(document.activeElement))return;
(pane?.querySelector('input, textarea, .credential-opt.is-selected:not(:disabled), .credential-opt:not(:disabled)')
||$('#credentialWizard [data-wizard-next]:not(:disabled), #credentialWizard [data-wizard-done]')
||$('#credentialWizard [data-wizard-close]:not(:disabled)')
||$('#credentialWizard .credential-dialog'))?.focus({preventScroll:true});
}
function credentialWizardFocusables(){
const dialog=$('#credentialWizard .credential-dialog');if(!dialog)return [];
return [...dialog.querySelectorAll('button, a[href], input, select')].filter(el=>!el.disabled&&!el.closest('.credential-pane.is-leaving, [hidden]')&&el.getClientRects().length);
}
function markCredentialGuide(index){
const wizard=credentialWizard;if(!wizard||wizard.guide[index])return;
wizard.guide[index]=true;
const item=$(`#credentialWizard .credential-pane:not(.is-leaving) [data-wizard-guide="${index}"]`);if(!item)return;
item.classList.add('is-done');
item.querySelector('.credential-guide-no').innerHTML=credentialGlyph('check-draw',10);
hydrateCredentialIcons(item);
}
function credentialWizardInput(event){
const wizard=credentialWizard,input=event.target;if(!wizard||!input.name)return;
const kind=credentialKind(wizard.kind),pane=input.closest('.credential-pane');
if(input.name==='extra')wizard.extra=input.value;
if(input.name==='protocol')wizard.protocol=input.value;
if(input.name==='secret')wizard.secret=input.value;
const valid=credentialWizardValid(),hint=credentialWizardSecretHint(kind,wizard,valid);
setCredentialHint(pane,'secret',hint.text,hint.tone);
if(kind.extra?.options){if(input.name==='extra')refreshCredentialEnvironmentLinks(pane,wizard.extra)}
else if(kind.extra){const extraError=credentialExtraError(kind,wizard.extra,wizard.protocol);setCredentialHint(pane,'extra',extraError,extraError?'err':'')}
if(valid.ok)kind.guide.forEach((_,index)=>markCredentialGuide(index));
const next=$('#credentialWizard [data-wizard-next]');if(next)next.disabled=!valid.ok;
}
function credentialWizardKeydown(event){
if(!credentialWizard)return;
if(event.key==='Escape'){event.preventDefault();event.stopPropagation();closeCredentialWizard();return}
if(event.key==='Tab'){
const items=credentialWizardFocusables(),dialog=$('#credentialWizard .credential-dialog');if(!dialog)return;
if(!items.length){event.preventDefault();dialog.focus({preventScroll:true});return}
const index=items.indexOf(document.activeElement);
if(index<0||(event.shiftKey&&index===0)||(!event.shiftKey&&index===items.length-1)){event.preventDefault();items[event.shiftKey?items.length-1:0].focus({preventScroll:true})}
return;
}
if(event.key==='Enter'&&event.target.matches?.('#credentialWizard .credential-pane input')){event.preventDefault();advanceCredentialWizard()}
}
function selectCredentialWizardKind(key){
const wizard=credentialWizard;if(!wizard||wizard.kind===key)return;
// A secret typed for one kind must never be submitted as another kind's credential.
wizard.kind=key;wizard.secret='';wizard.guide={};wizard.error='';
wizard.extra=credentialWizardDefaults(credentialKind(key),credentialUser());
wizard.protocol=credentialProtocol(credentialKind(key),credentialUser());
}
function credentialWizardClick(event){
const wizard=credentialWizard,target=event.target;if(!wizard)return;
if(target.closest('[data-wizard-close]'))return closeCredentialWizard();
if(target.closest('[data-wizard-done]'))return closeCredentialWizard();
const eye=target.closest('[data-credential-eye]');if(eye)return toggleCredentialSecret(eye);
const link=target.closest('[data-wizard-link]');if(link)return markCredentialGuide(Number(link.dataset.wizardLink));
const option=target.closest('[data-wizard-kind]');
if(option&&!option.disabled){
selectCredentialWizardKind(option.dataset.wizardKind);
option.parentElement.closest('.credential-pane').querySelectorAll('[data-wizard-kind]').forEach(item=>{const on=item===option;item.classList.toggle('is-selected',on);item.setAttribute('aria-checked',String(on))});
refreshCredentialWizardFoot();
return;
}
const back=target.closest('[data-wizard-back]');
if(back&&!back.disabled){wizard.step--;wizard.error='';paintCredentialWizard(-1);setTimeout(focusCredentialWizard,220);return}
const next=target.closest('[data-wizard-next]');if(next&&!next.disabled)advanceCredentialWizard();
}
async function advanceCredentialWizard(){
const wizard=credentialWizard;if(!wizard||wizard.saving||wizard.done)return;
if(wizard.step===1){
const dialog=credentialDialog(wizard.kind);
if(!wizard.kind||(!dialog&&credentialConfigured(credentialKind(wizard.kind),credentialUser())))return;
if(dialog){
closeCredentialWizard(true);
return dialog();
}
wizard.step=2;paintCredentialWizard(1);setTimeout(focusCredentialWizard,220);return;
}
if(wizard.step===2){
if(!credentialWizardValid().ok){const pane=$('#credentialWizard .credential-pane:not(.is-leaving)');if(pane)setCredentialHint(pane,'secret',credentialWizardValid().error||'请先填写密钥','err');return}
wizard.step=3;wizard.error='';paintCredentialWizard(1);setTimeout(focusCredentialWizard,220);return;
}
const kind=credentialKind(wizard.kind),secret=String(wizard.secret).trim();
wizard.saving=true;wizard.error='';paintCredentialWizard(0);focusCredentialWizard();
try{
if(kind.key==='gitToken'){
const outcome=await verifyAndSaveGitToken(secret);
if(!outcome.saved){wizard.error=`${gitTokenFailure(outcome.result)||'Git Token 校验未通过'}(未保存)`;return}
}else await saveCredential(kind.key,{secret,...(kind.extra?{extra:wizard.extra}:{}),...(kind.protocol?{protocol:wizard.protocol}:{})});
wizard.done=true;wizard.secret='';
renderCredentialPanel();
toast(kind.key==='gitToken'?'Git Token 校验通过,已保存':`${kind.short} 已保存`,'ok');
}catch(err){wizard.error=err.message}
finally{
if(credentialWizard===wizard){wizard.saving=false;paintCredentialWizard(0);focusCredentialWizard()}
}
}
// Gongfeng OAuth completes in its own tab, which broadcasts from gongfeng-oauth-done.js.
// Called once at startup; other views ignore the signal and pick up the grant on their next render.
function listenForGongfengOAuth(){
if(typeof BroadcastChannel!=='function')return null;
const channel=new BroadcastChannel('agentflow-gongfeng-oauth');
channel.onmessage=event=>{
if(event.data?.type!=='gongfeng-oauth-completed'||activeViewName()!=='settings')return;
refreshGongfengGrant().catch(()=>{});
};
return channel;
}
// Patch only the Gongfeng row: re-rendering the panel would drop inputs typed into other rows.
async function refreshGongfengGrant(){
const user=state.currentUser;if(!user||user.isGuest||!$('#credentialPanel'))return;
const users=await api('/api/users',{silent:true});
const fresh=(Array.isArray(users)?users:[]).find(u=>Number(u.id)===Number(user.id));
const panel=$('#credentialPanel'),row=panel?.querySelector('[data-credential-row="gitToken"]');
if(!fresh||!row||Number(state.currentUser?.id)!==Number(user.id))return;
storeCredentialUser(fresh);
state.gitTokenVerify=null;
if(credentialWizard?.kind==='gitToken'&&fresh.gitHubCredentialConfigured)closeCredentialWizard(true);
if(row.classList.contains('is-configured')!==!!fresh.gitHubCredentialConfigured){
const holder=document.createElement('div');
holder.innerHTML=credentialRowHTML(credentialKind('gitToken'),fresh);
row.replaceWith(holder.firstElementChild);
panel.querySelector('.credential-progress').innerHTML=credentialProgressHTML(fresh);
panel.querySelector('.credential-filter').innerHTML=credentialFilterHTML(fresh);
applyCredentialFilter(panel,fresh);
hydrateCredentialIcons(panel);
}
if(!fresh.gitHubCredentialConfigured){repaintCredentialRow('gitToken');return}
state.gitTokenAnnounceVerify=true;
toast('工蜂授权已保存,正在校验授权有效性…');
await refreshGitTokenStatus();
}
async function renderPersonalSettings(){
const host=$('#personalSettingsContent');if(!host)return;
const user=state.currentUser;
if(!user||user.isGuest){
host.innerHTML='<section class="personal-settings-card"><h2>登录账号</h2><p>登录后即可管理自己的 Git Token 和 API Key。</p><button class="button primary" id="settingsLogin">账号登录</button><button class="button ghost" id="localAcceptanceLogin" hidden>本地验收登录</button></section>';
host.querySelector('#settingsLogin').onclick=()=>{window.location.href=state.loginUrl||'/login.html'};
try{const capability=await api('/api/auth/local',{silent:true}),button=host.querySelector('#localAcceptanceLogin');if(button&&capability.enabled){button.hidden=false;button.onclick=async()=>{try{const result=await api('/api/auth/local',{method:'POST',body:'{}'});state.currentUser=result.user;state.data.users=await api('/api/users');window.AgentFlowExecutorModels=null;window.AgentFlowAssistantModels?.load?.();renderUserBadge();renderPersonalSettings();toast('已登录本地验收账号')}catch(err){toast(err.message)}}}}catch{}
return;
}
const storedUser=userById(user.id)||{};
const gongfengInURL=new URLSearchParams(location.search).get('gongfeng')==='ok';
if(state.gongfengReturned||gongfengInURL){
state.gongfengReturned=false;
if(gongfengInURL)history.replaceState(null,'',location.pathname+location.hash);
state.gitTokenVerify=null;
state.gitTokenAnnounceVerify=true;
toast('工蜂授权已保存,正在校验授权有效性…');
}
if(credentialWizard)closeCredentialWizard(true);
host.innerHTML=`<section class="credential-account credential-enter" style="--i:0"><span class="credential-avatar">${userAvatarHTML(user, 150)}</span><div><b>${escapeHTML(userDisplay(user))}</b><small>凭证按用户隔离,仅在你负责的任务运行时注入。</small></div><span class="credential-account-note">${credentialGlyph('lock',14)}任务级注入,不写入 Agent 资产</span></section><section class="credential-panel credential-enter is-entering" id="credentialPanel" style="--i:1"></section>`;
const panel=host.querySelector('#credentialPanel');
bindCredentialPanel(panel);
renderCredentialPanel();
loadCredentialEffortCatalogs().then(()=>panel.querySelectorAll('[data-credential-catalog]').forEach(refreshCredentialCatalogEfforts));
hydrateCredentialIcons(host);
setTimeout(()=>panel.classList.remove('is-entering'),900);
// Offer the OAuth shortcut only when the server has a Gongfeng application.
api('/api/auth/gongfeng',{silent:true}).then(capability=>{state.gongfengOAuthEnabled=!!capability?.enabled;document.querySelectorAll('[data-gongfeng-oauth]').forEach(el=>{el.hidden=!state.gongfengOAuthEnabled})}).catch(()=>{});
if(storedUser.gitHubCredentialConfigured){
const cached=gitTokenVerifyFor(user);
if(!cached||(cached.busy&&!state.gitTokenVerifyInFlight)){state.gitTokenVerifyInFlight=true;refreshGitTokenStatus().finally(()=>{state.gitTokenVerifyInFlight=false})}
}
}
// 谁能改通用模板是平台级权限,不属于任何一个项目,也不属于个人凭据;
// 只有平台管理员能看到「平台管理」入口。
function renderPlatformNav(){
const group=$('#platformNavGroup');if(!group)return;
group.hidden=!isPlatformAdmin();
}
// 平台管理分成三个 tab:成员账号、平台管理员、共享 CodeBuddy Key。
const PLATFORM_TABS=[
{id:'accounts',zh:'成员账号',en:'Accounts'},
{id:'admins',zh:'平台管理员',en:'Admins'},
{id:'sharedKey',zh:'共享 CodeBuddy Key',en:'Shared CodeBuddy Key'},
];
function platformTabsHTML(active){
return `<div class="pa-tabs-wrap platform-tabs-wrap"><div class="pa-tabs platform-tabs" id="platformTabs" role="tablist" aria-label="平台管理分区">${PLATFORM_TABS.map(t=>{
const on=t.id===active;
const extra=t.id==='sharedKey'?'<span class="platform-tab-state" data-platform-tab-state hidden></span>':'<span class="pa-tab-n" data-platform-tab-count hidden></span>';
return `<button type="button" role="tab" class="pa-tab${on?' on':''}" id="platformTab-${t.id}" data-platform-tab="${t.id}" aria-controls="platformPanel-${t.id}" aria-selected="${on}" tabindex="${on?0:-1}">${lfT(t.zh,t.en)}${extra}</button>`;
}).join('')}</div></div>`;
}
function platformTabPanel(id,active,body){
return `<section class="platform-tab-panel" id="platformPanel-${id}" role="tabpanel" aria-labelledby="platformTab-${id}" data-platform-panel="${id}"${id===active?'':' hidden'}>${body}</section>`;
}
function setPlatformTab(host,tab){
if(!PLATFORM_TABS.some(t=>t.id===tab))tab=PLATFORM_TABS[0].id;
state.platformTab=tab;
host.querySelectorAll('[data-platform-tab]').forEach(b=>{const on=b.dataset.platformTab===tab;b.classList.toggle('on',on);b.setAttribute('aria-selected',String(on));b.tabIndex=on?0:-1});
host.querySelectorAll('[data-platform-panel]').forEach(p=>{p.hidden=p.dataset.platformPanel!==tab});
}
function bindPlatformTabs(host){
const bar=host.querySelector('#platformTabs');if(!bar)return;
bar.querySelectorAll('[data-platform-tab]').forEach(b=>b.onclick=()=>setPlatformTab(host,b.dataset.platformTab));
bar.onkeydown=e=>{
if(!['ArrowLeft','ArrowRight'].includes(e.key))return;
const ids=PLATFORM_TABS.map(t=>t.id),i=ids.indexOf(state.platformTab),next=ids[(i+(e.key==='ArrowRight'?1:ids.length-1))%ids.length];
setPlatformTab(host,next);bar.querySelector(`[data-platform-tab="${next}"]`)?.focus();
};
}
function setPlatformTabCount(host,tab,n){
const el=host.querySelector(`[data-platform-tab="${tab}"] [data-platform-tab-count]`);
if(el){el.textContent=String(n);el.hidden=false}
}
function renderPlatformAdminPanel(){
const host=$('#platformAdminPanel');if(!host)return;
if(!isPlatformAdmin()){host.innerHTML='';return}
const tab=PLATFORM_TABS.some(t=>t.id===state.platformTab)?state.platformTab:PLATFORM_TABS[0].id;
state.platformTab=tab;
host.innerHTML=`
${platformTabsHTML(tab)}
${platformTabPanel('accounts',tab,platformAccountsHTML())}
${platformTabPanel('admins',tab,`
<div class="platform-metric-grid">
<div class="platform-metric-card">
<div class="platform-metric-icon blue">
<svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="2"><path d="M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="8.5" cy="7" r="4"/><polyline points="17 11 19 13 23 9"/></svg>
</div>
<div class="platform-metric-info">
<span class="platform-metric-label">平台管理员</span>
<b class="platform-metric-num" id="platformMetricTotal">--</b>
<small>具有跨项目通用模板与角色编辑权</small>
</div>
</div>
<div class="platform-metric-card">
<div class="platform-metric-icon amber">
<svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"/><path d="M7 11V7a5 5 0 0 1 10 0v4"/></svg>
</div>
<div class="platform-metric-info">
<span class="platform-metric-label">系统内置</span>
<b class="platform-metric-num" id="platformMetricLocked">--</b>
<small>系统初始预设名单,不可撤销</small>
</div>
</div>
<div class="platform-metric-card">
<div class="platform-metric-icon purple">
<svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="2"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>
</div>
<div class="platform-metric-info">
<span class="platform-metric-label">界面授权</span>
<b class="platform-metric-num" id="platformMetricGranted">--</b>
<small>控制台动态授予,可随时撤销</small>
</div>
</div>
<div class="platform-metric-card">
<div class="platform-metric-icon green">
<svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="2" y1="12" x2="22" y2="12"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/></svg>
</div>
<div class="platform-metric-info">
<span class="platform-metric-label">生效范围</span>
<b class="platform-metric-num">全平台通用</b>
<small>通用模板 · 共享角色 · 门禁规范</small>
</div>
</div>
</div>
<div class="platform-admin-layout">
<div class="platform-admin-main-card">
<div class="platform-admin-head">
<div class="platform-admin-head-meta">
<h2>谁可以改通用模板</h2>
<p>平台管理员能直接编辑通用模板和它打包的角色,改完所有项目下次运行生效。系统内置名单不能在这里撤销。</p>
</div>
<span class="platform-admin-count-pill" id="platformAdminCountBadge">-- 位管理员</span>
</div>
<div class="platform-add-box">
<form id="platformAdminForm" class="platform-admin-form">
<div class="platform-input-wrap">
<span class="platform-input-icon">
<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg>
</span>
<input name="loginName" placeholder="输入用户名,如 alice" autocomplete="off">
</div>
<button class="button primary platform-add-btn" type="submit">添加管理员</button>
</form>
<div class="platform-add-hint">
<svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
<span>授权后用户将获得全平台通用 SOP 模板及公共角色的修改与发布权限,请谨慎授予。</span>
</div>
</div>
<div class="platform-list-toolbar">
<div class="platform-search-wrap">
<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/></svg>
<input id="platformAdminSearch" placeholder="搜索姓名或用户名..." autocomplete="off">
</div>
<div class="platform-filter-tabs" id="platformFilterTabs">
<button type="button" class="platform-filter-btn active" data-source-filter="all">全部</button>
<button type="button" class="platform-filter-btn" data-source-filter="builtin">内置</button>
<button type="button" class="platform-filter-btn" data-source-filter="granted">已授权</button>
</div>
</div>
<div id="platformAdminList" class="platform-admin-list"></div>
</div>
<div class="platform-admin-side">
<div class="platform-side-card">
<div class="platform-side-head">
<span class="platform-side-icon blue">
<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/></svg>
</span>
<h3>权限与安全规则</h3>
</div>
<ul class="platform-side-list">
<li>
<b>通用 SOP 模板全局编辑</b>
<p>通用模板面向全平台所有项目共享,由平台管理员统一定义并维护,修改后各项目下次运行即刻生效。</p>
</li>
<li>
<b>公共角色与通用门禁下发</b>
<p>通用模板中引用的 Agent 角色、执行门禁由平台统一调优升级,项目内默认只读,保障基准质量。</p>
</li>
<li>
<b>系统固化名单安全保护</b>
<p>系统内置名单具备最高防锁死安全防护,无法通过页面撤销,确保生产管理连续性。</p>
</li>
</ul>
</div>
<div class="platform-side-card">
<div class="platform-side-head">
<span class="platform-side-icon green">
<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2"><polygon points="12 2 2 7 12 12 22 7 12 2"/><polyline points="2 17 12 22 22 17"/><polyline points="2 12 12 17 22 12"/></svg>
</span>
<h3>通用模板与资产管理</h3>
</div>
<p class="platform-side-desc">平台管理员在流程设计或角色定义中维护通用模板后,所有关联项目将在下次运行自动应用最新版本。</p>
<div class="platform-side-quick-links">
<button type="button" class="button ghost small platform-quick-link-btn" data-platform-nav="sops">查看 SOP 流程 ↗</button>
<button type="button" class="button ghost small platform-quick-link-btn" data-platform-nav="agents">查看角色定义 ↗</button>
</div>
<div class="platform-audit-note">
<svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>
<span>管理员授予与撤销操作均实时生效,变更将记录平台审计。</span>
</div>
</div>
</div>
</div>
`)}
${platformTabPanel('sharedKey',tab,platformSharedKeyHTML())}
`;
bindPlatformTabs(host);
loadPlatformAccounts(host);
loadPlatformSharedKey(host);
loadPlatformAdmins(host);
}
// 平台管理 → 成员账号 / 平台共享 CodeBuddy Key.
const PLATFORM_ACCOUNT_PASSWORD_MIN=6;
function platformRandomPassword(){
const alphabet='ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789';
const bytes=new Uint32Array(14);window.crypto.getRandomValues(bytes);
return Array.from(bytes,b=>alphabet[b%alphabet.length]).join('');
}
function sharedModelLabel(id){return id==='deepseek-v4.1-flash'?'Deepseek-V4.1-Flash':String(id||'')}
// The models users without their own CodeBuddy key may use, as announced by bootstrap.
function sharedModelSummary(){
const models=Array.isArray(state.data?.sponsoredModels)&&state.data.sponsoredModels.length?state.data.sponsoredModels:(state.data?.sponsoredModel?[state.data.sponsoredModel]:[]);
return models.map(sharedModelLabel).join('、');
}
const PLATFORM_ICON_USER='<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg>';
const PLATFORM_ICON_LOCK='<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"/><path d="M7 11V7a5 5 0 0 1 10 0v4"/></svg>';
const PLATFORM_ICON_SEARCH='<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/></svg>';
function platformAccountsHTML(){
return `
<section class="platform-admin-main-card" id="platformAccountsCard">
<div class="platform-admin-head">
<div class="platform-admin-head-meta">
<h2>给同事开账号</h2>
<p data-account-intro>填好用户名和初始密码,点创建,再把登录信息发给同事。同事忘记密码时可以在下面重置。</p>
</div>
<span class="platform-admin-count-pill" id="platformAccountCountBadge">${lfT('-- 个账号','-- accounts')}</span>
</div>
<div class="platform-account-create">
<form id="platformAccountForm" class="platform-account-form" autocomplete="off">
<div class="platform-input-wrap"><span class="platform-input-icon">${PLATFORM_ICON_USER}</span><input name="loginName" placeholder="用户名,如 alice" aria-label="用户名" maxlength="64" autocomplete="off" spellcheck="false"></div>
<div class="platform-input-wrap"><span class="platform-input-icon">${PLATFORM_ICON_LOCK}</span><input name="password" placeholder="初始密码,至少 6 位" aria-label="初始密码" maxlength="72" autocomplete="new-password" spellcheck="false"><button type="button" class="button ghost small" data-account-generate>随机生成</button></div>
<label class="platform-check"><input type="checkbox" name="admin"><span>同时设为平台管理员</span></label>
<button class="button primary platform-add-btn" type="submit">创建账号</button>
</form>
<div class="platform-account-created" data-account-created hidden></div>
</div>
<div class="platform-list-toolbar">
<div class="platform-search-wrap platform-account-search">${PLATFORM_ICON_SEARCH}<input data-account-search placeholder="搜索用户名..." autocomplete="off"></div>
</div>
<div id="platformAccountList" class="platform-admin-list platform-account-list"></div>
</section>`;
}
function platformSharedKeyHTML(){
const envOptions=CODEBUDDY_ENVIRONMENTS.map(env=>`<option value="${escapeHTML(env.value)}">${escapeHTML(env.label)} · ${escapeHTML(env.site)}</option>`).join('');
return `
<section class="platform-admin-main-card" id="platformSharedKeyCard">
<div class="platform-admin-head">
<div class="platform-admin-head-meta">
<h2>给没配 Key 的成员用</h2>
<p>成员没配自己的 CodeBuddy API Key 时,对话和 SOP 会用这里的 Key,并且只能用下面勾选的模型。成员配了自己的 Key 就用自己的,不受限制。</p>
</div>
<span class="platform-admin-count-pill platform-status-pill" data-shared-key-badge>${lfT('加载中','Loading')}</span>
</div>
<form id="platformSharedKeyForm" class="platform-shared-key-form" autocomplete="off">
<div class="platform-shared-key-grid">
<div class="platform-shared-key-col">
<label class="platform-field"><span>网络环境</span><select name="internetEnvironment">${envOptions}</select></label>
<div class="platform-field-group">
<label class="platform-field"><span>API Key</span><input name="apiKey" type="password" autocomplete="new-password" spellcheck="false" placeholder="ck_ 开头的 CodeBuddy API Key"></label>
<a class="platform-shared-key-link" data-shared-key-link target="_blank" rel="noopener noreferrer"></a>
</div>
<div class="platform-note is-warn" data-shared-key-warning hidden></div>
<label class="platform-field"><span>默认模型</span><select name="defaultModel"></select><small class="platform-field-hint">没指定模型时用它;SOP 角色的模型不在允许范围内时也改用它。</small></label>
</div>
<div class="platform-shared-key-col">
<div class="platform-field">
<div class="platform-field-head"><span>允许使用的模型</span><small data-shared-models-count></small></div>
<div class="platform-model-list" data-shared-models><p class="prop-hint">正在读取可用模型…</p></div>
</div>
<label class="platform-field"><span>列表里没有的模型</span><input name="extraModels" placeholder="模型 ID,多个用逗号分隔" autocomplete="off" spellcheck="false"></label>
</div>
</div>
<div class="platform-shared-key-footer">
<p class="platform-add-hint" data-shared-key-meta></p>
<div class="platform-shared-key-actions">
<button class="button ghost danger" type="button" data-shared-key-clear hidden>停用共享 Key</button>
<button class="button primary" type="submit">保存</button>
</div>
</div>
</form>
</section>`;
}
function platformAccountCreatedHTML(action,login,password){
const who=`<b data-i18n-skip>${escapeHTML(login)}</b>`,secret=`<code>${escapeHTML(password)}</code>`;
const text=action==='reset'
?lfT(`已重置账号 ${who},新密码 ${secret}。密码只显示这一次,请现在发给对方。`,`Password of ${who} reset to ${secret}. It is shown only once; send it now.`)
:lfT(`已创建账号 ${who},初始密码 ${secret}。密码只显示这一次,请现在发给对方。`,`Created ${who} with the initial password ${secret}. It is shown only once; send it now.`);
return `<div class="platform-note is-ok"><span>${text}</span><button type="button" class="button ghost small" data-copy-login>复制登录信息</button></div>`;
}
const platformPasswordTooShort=()=>lfT(`密码至少 ${PLATFORM_ACCOUNT_PASSWORD_MIN} 位`,`The password needs at least ${PLATFORM_ACCOUNT_PASSWORD_MIN} characters`);
async function loadPlatformAccounts(host){
const card=host.querySelector('#platformAccountsCard');if(!card)return;
const list=card.querySelector('#platformAccountList'),form=card.querySelector('#platformAccountForm'),created=card.querySelector('[data-account-created]'),search=card.querySelector('[data-account-search]');
let accounts=[],query='',resetting=null;
const showCreated=(action,login,password)=>{
created.innerHTML=platformAccountCreatedHTML(action,login,password);created.hidden=false;
created.querySelector('[data-copy-login]').onclick=()=>copyText(lfT(`登录地址:${location.origin}\n用户名:${login}\n密码:${password}`,`Sign in at: ${location.origin}\nLogin: ${login}\nPassword: ${password}`),'已复制登录信息');
};
const render=()=>{
const n=accounts.length,badge=card.querySelector('#platformAccountCountBadge');if(badge)badge.textContent=lfT(`共 ${n} 个账号`,`${n} account${n===1?'':'s'}`);
setPlatformTabCount(host,'accounts',n);
const q=query.toLowerCase();
const rows=accounts.filter(a=>!q||String(a.loginName||'').toLowerCase().includes(q)||String(a.chineseName||'').toLowerCase().includes(q));
if(!rows.length){list.innerHTML=`<div class="platform-empty-state"><b>${accounts.length?'没有匹配的账号':'还没有账号'}</b></div>`;return}
list.innerHTML=rows.map(a=>{
const name=a.chineseName&&a.chineseName.toLowerCase()!==String(a.loginName).toLowerCase()?`${a.loginName}(${a.chineseName})`:a.loginName;
const badges=[a.admin?'<span class="platform-source-badge source-builtin">平台管理员</span>':'',a.password?'<span class="platform-source-badge source-default">用户名密码</span>':'<span class="platform-source-badge source-default">GitHub / 网关登录</span>',a.codeBuddyApiKeyConfigured?'<span class="platform-source-badge source-env">已配 CodeBuddy Key</span>':'<span class="platform-source-badge source-default">未配 CodeBuddy Key</span>'].join('');
const editing=resetting===a.userId;
return `<div class="platform-admin-row platform-account-row" data-account-row="${Number(a.userId)}">
<div class="platform-admin-user">
<div class="platform-admin-avatar">${userAvatarHTML(a.loginName,100)}</div>
<div class="platform-admin-info"><span class="platform-admin-name" data-i18n-skip>${escapeHTML(name)}</span><div class="platform-admin-meta">${badges}</div></div>
</div>
<div class="platform-admin-actions">${a.password?(editing?`<form class="platform-account-reset" data-reset-form="${Number(a.userId)}"><input name="password" placeholder="新密码,至少 6 位" aria-label="新密码" maxlength="72" autocomplete="new-password" spellcheck="false"><button type="button" class="button ghost small" data-reset-generate>随机</button><button type="submit" class="button primary small">确认重置</button><button type="button" class="button ghost small" data-reset-cancel>取消</button></form>`:`<button type="button" class="button ghost small" data-reset-account="${Number(a.userId)}">重置密码</button>`):'<span class="platform-locked-tag" title="通过 GitHub 或网关登录的账号没有平台密码">无平台密码</span>'}</div>
</div>`;
}).join('');
list.querySelectorAll('[data-reset-account]').forEach(btn=>btn.onclick=()=>{resetting=Number(btn.dataset.resetAccount);render();list.querySelector('[data-reset-form] input')?.focus()});
const resetForm=list.querySelector('[data-reset-form]');
if(resetForm){
resetForm.querySelector('[data-reset-cancel]').onclick=()=>{resetting=null;render()};
resetForm.querySelector('[data-reset-generate]').onclick=()=>{resetForm.elements.password.value=platformRandomPassword()};
resetForm.onsubmit=async e=>{
e.preventDefault();
const password=resetForm.elements.password.value;
if(password.length<PLATFORM_ACCOUNT_PASSWORD_MIN)return toast(platformPasswordTooShort(),'err');
const account=accounts.find(a=>a.userId===resetting);
resetForm.querySelectorAll('button').forEach(b=>b.disabled=true);
try{
await api(`/api/platform/accounts/${encodeURIComponent(resetting)}/password`,{method:'PUT',body:JSON.stringify({password})});
resetting=null;render();showCreated('reset',account?.loginName||'',password);toast('密码已重置','ok');
}catch(err){toast(err.message,'err');resetForm.querySelectorAll('button').forEach(b=>b.disabled=false)}
};
}
};
const load=async()=>{
try{
const result=await api('/api/platform/accounts');
accounts=Array.isArray(result?.accounts)?result.accounts:[];
const intro=card.querySelector('[data-account-intro]');
if(intro)intro.textContent=result?.signupEnabled
?'登录页目前允许自助注册。也可以在这里直接创建账号,再把登录信息发给同事;同事忘记密码时可以在下面重置。'
:'登录页的自助注册已关闭,同事的账号要在这里创建:填好用户名和初始密码,点创建,再把登录信息发给对方。忘记密码时可以在下面重置。';
render();
}catch(e){list.innerHTML=`<p class="prop-hint">${escapeHTML(e.message||'加载账号失败')}</p>`}
};
if(search)search.oninput=()=>{query=search.value.trim();render()};
form.querySelector('[data-account-generate]').onclick=()=>{form.elements.password.value=platformRandomPassword()};
form.onsubmit=async e=>{
e.preventDefault();
const loginName=form.elements.loginName.value.trim(),password=form.elements.password.value,admin=form.elements.admin.checked;
if(!/^[A-Za-z0-9][A-Za-z0-9_.-]{1,63}$/.test(loginName))return toast('用户名需 2–64 位,以字母或数字开头,只能包含字母、数字、_ . -','err');
if(password.length<PLATFORM_ACCOUNT_PASSWORD_MIN)return toast(platformPasswordTooShort(),'err');
const submit=form.querySelector('button[type="submit"]');if(submit)submit.disabled=true;
try{
const account=await api('/api/platform/accounts',{method:'POST',body:JSON.stringify({loginName,password,admin})});
form.reset();
accounts=[...accounts.filter(a=>a.userId!==account?.userId),account].filter(Boolean);
render();showCreated('create',loginName,password);toast('账号已创建','ok');
if(admin)loadPlatformAdmins(host);
}catch(err){toast(err.message,'err')}
finally{if(submit)submit.disabled=false}
};
await load();
}
async function loadPlatformSharedKey(host){
const card=host.querySelector('#platformSharedKeyCard');if(!card)return;
const form=card.querySelector('#platformSharedKeyForm');
const env=form.elements.internetEnvironment,key=form.elements.apiKey,extra=form.elements.extraModels,defaultSelect=form.elements.defaultModel;
const modelsHost=card.querySelector('[data-shared-models]'),badge=card.querySelector('[data-shared-key-badge]'),meta=card.querySelector('[data-shared-key-meta]');
const link=card.querySelector('[data-shared-key-link]'),warning=card.querySelector('[data-shared-key-warning]'),clear=card.querySelector('[data-shared-key-clear]');
let status=null,catalog=[],selected=[];
const extraIDs=()=>String(extra.value||'').split(/[,,\s]+/).map(s=>s.trim()).filter(Boolean);
const chosen=()=>{const all=[...selected];for(const id of extraIDs())if(!all.includes(id))all.push(id);return all};
const modelCount=card.querySelector('[data-shared-models-count]'),tabState=host.querySelector('[data-platform-tab-state]');
const renderDefault=()=>{
const models=chosen(),current=defaultSelect.value;
if(modelCount)modelCount.textContent=models.length?lfT(`已选 ${models.length} 个`,`${models.length} selected`):'';
defaultSelect.innerHTML=models.length?models.map(id=>`<option value="${escapeHTML(id)}">${escapeHTML(sharedModelLabel(id))}</option>`).join(''):'<option value="">请先勾选模型</option>';
defaultSelect.value=models.includes(current)?current:(models[0]||'');
};
const renderModels=()=>{
const listed=catalog.filter(m=>m&&m.id&&m.id!=='default');
const ids=new Set(listed.map(m=>m.id));
for(const id of selected)if(!ids.has(id)){listed.push({id,name:id});ids.add(id)}
modelsHost.innerHTML=listed.length?listed.map(m=>`<label class="platform-check platform-model-option"><input type="checkbox" value="${escapeHTML(m.id)}"${selected.includes(m.id)?' checked':''}><span>${escapeHTML(m.name&&m.name!==m.id?`${m.name}(${m.id})`:sharedModelLabel(m.id))}</span>${m.credits?`<small>${escapeHTML(m.credits)}</small>`:''}</label>`).join(''):'<p class="prop-hint">这个网络环境暂时没有读到模型列表,可以在下面直接填模型 ID。</p>';
modelsHost.querySelectorAll('input[type="checkbox"]').forEach(box=>box.onchange=()=>{
selected=box.checked?[...selected.filter(id=>id!==box.value),box.value]:selected.filter(id=>id!==box.value);
renderDefault();
});
renderDefault();
};
const renderLink=()=>{link.href=codeBuddyKeyURL(env.value);link.textContent=`${codeBuddyKeyLinkLabel(env.value)} ↗`};
const renderStatus=()=>{
const on=!!status?.configured,envInfo=CODEBUDDY_ENVIRONMENTS.find(e=>e.value===(status?.internetEnvironment||''))||CODEBUDDY_ENVIRONMENTS[0];
const tone=on?'on':status?.legacySponsor?'legacy':'off';
badge.textContent=on?'已启用':status?.legacySponsor?'使用旧配置':'未启用';
badge.classList.remove('is-on','is-legacy','is-off');badge.classList.add(`is-${tone}`);
if(tabState){tabState.className=`platform-tab-state is-${tone}`;tabState.title=badge.textContent;tabState.hidden=false}
key.placeholder=on?'已配置,留空保持不变':'ck_ 开头的 CodeBuddy API Key';
clear.hidden=!on;
const parts=[];
if(on){
const n=(status.models||[]).length,first=sharedModelLabel(status.models?.[0]),by=status.updatedBy||'';
parts.push(lfT(`当前:${envInfo.label},${n} 个模型,默认 ${first}${by?`,${by} 最后修改`:''}。`,`Current: ${envInfo.label}, ${n} model${n===1?'':'s'}, default ${first}${by?`, last changed by ${by}`:''}.`));
}
else parts.push(lfT('还没有配置共享 Key,没配 Key 的成员需要先配自己的 Key 才能对话和跑 SOP。','No shared key yet; members without their own key must add one before chatting or running SOPs.'));
const sponsor=status?.legacySponsor;
if(sponsor)parts.push(on
?lfT(`配置后不再使用环境变量 AGENTFLOW_ASSISTANT_SPONSOR_LOGIN 指定的账号 ${sponsor} 的 Key。`,`The key of ${sponsor} (AGENTFLOW_ASSISTANT_SPONSOR_LOGIN) is no longer used.`)
:lfT(`现在沿用环境变量 AGENTFLOW_ASSISTANT_SPONSOR_LOGIN 指定的账号 ${sponsor} 的 Key,只能用 ${sharedModelLabel(status.legacySponsorModel)}。`,`For now the key of ${sponsor} (AGENTFLOW_ASSISTANT_SPONSOR_LOGIN) is shared, limited to ${sharedModelLabel(status.legacySponsorModel)}.`));
meta.textContent=parts.join(lfT('',' '));
};
const syncBootstrap=()=>{
if(!state.data)return;
const models=status?.configured?(status.models||[]):(status?.legacySponsor?[status.legacySponsorModel]:[]);
state.data.sponsoredModels=models;state.data.sponsoredModel=models[0]||'';
};
const fetchStatus=async environment=>{
const query=environment===undefined?'':`?environment=${encodeURIComponent(environment)}`;
const result=await api('/api/platform/codebuddy-key'+query);
catalog=Array.isArray(result?.catalog)?result.catalog:[];
return result;
};
try{
status=await fetchStatus();
env.value=status?.internetEnvironment||'';
selected=status?.configured?[...(status.models||[])]:(status?.legacySponsorModel?[status.legacySponsorModel]:[]);
renderStatus();renderLink();renderModels();
}catch(e){
badge.textContent='加载失败';modelsHost.innerHTML=`<p class="prop-hint">${escapeHTML(e.message||'加载共享 Key 失败')}</p>`;
return;
}
env.onchange=async()=>{
renderLink();
modelsHost.innerHTML='<p class="prop-hint">正在读取可用模型…</p>';
try{await fetchStatus(env.value)}catch(e){catalog=[]}
renderModels();
};
extra.oninput=renderDefault;
key.oninput=()=>{const text=credentialSecretWarning(credentialKind('codeBuddyApiKey'),key.value);warning.textContent=text;warning.hidden=!text};
form.onsubmit=async e=>{
e.preventDefault();
const models=chosen();
if(!models.length)return toast('请至少勾选一个允许使用的模型','err');
if(!status?.configured&&!key.value.trim())return toast('请填写 CodeBuddy API Key','err');
const first=defaultSelect.value&&models.includes(defaultSelect.value)?defaultSelect.value:models[0];
const ordered=[first,...models.filter(id=>id!==first)];
const submit=form.querySelector('button[type="submit"]');if(submit)submit.disabled=true;
try{
status=await api('/api/platform/codebuddy-key',{method:'PUT',body:JSON.stringify({apiKey:key.value.trim(),internetEnvironment:env.value,models:ordered})});
key.value='';warning.hidden=true;extra.value='';selected=[...(status.models||ordered)];
renderStatus();renderModels();syncBootstrap();toast('共享 Key 已保存','ok');
}catch(err){toast(err.message,'err')}
finally{if(submit)submit.disabled=false}
};
clear.onclick=async()=>{
if(!await afConfirm({title:'停用共享 Key',message:'停用后,没配自己 Key 的成员将不能再用共享 Key 对话和跑 SOP。确定停用?',danger:true,confirmText:'停用'}))return;
try{status=await api('/api/platform/codebuddy-key',{method:'DELETE'});renderStatus();syncBootstrap();toast('共享 Key 已停用','ok')}
catch(err){toast(err.message,'err')}
};
}
async function loadPlatformAdmins(host){
const list=host.querySelector('#platformAdminList');
const form=host.querySelector('#platformAdminForm');
const searchInput=host.querySelector('#platformAdminSearch');
const filterTabs=host.querySelectorAll('#platformFilterTabs button');
if(!list||!form)return;
host.querySelectorAll('[data-platform-nav]').forEach(btn=>{
btn.onclick=()=>{
const target=btn.dataset.platformNav;
if(target&&typeof switchView==='function'){
switchView(target);
}
};
});
const sourceMeta={
builtin:{label:'内置',className:'source-builtin',icon:'<svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/></svg>'},
granted:{label:'已授权',className:'source-granted',icon:'<svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="2"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg>'}
};
let allRows=[];
let activeFilter='all';
let searchQuery='';
const updateMetrics=rows=>{
const listArr=rows||[];
const total=listArr.length;
const locked=listArr.filter(r=>!r.revocable).length;
const granted=listArr.filter(r=>r.revocable).length;
const elTotal=host.querySelector('#platformMetricTotal');
const elLocked=host.querySelector('#platformMetricLocked');
const elGranted=host.querySelector('#platformMetricGranted');
const elBadge=host.querySelector('#platformAdminCountBadge');
if(elTotal)elTotal.textContent=total;
if(elLocked)elLocked.textContent=locked;
if(elGranted)elGranted.textContent=granted;
if(elBadge)elBadge.textContent=`共 ${total} 位管理员`;
setPlatformTabCount(host,'admins',total);
};
const render=()=>{
let filtered=allRows||[];
if(activeFilter==='builtin'){
filtered=filtered.filter(r=>!r.revocable||r.source==='builtin'||r.source==='env');
}else if(activeFilter==='granted'){
filtered=filtered.filter(r=>r.revocable||r.source==='granted');
}
if(searchQuery){
const q=searchQuery.toLowerCase();
const knownChineseNames = {};
filtered=filtered.filter(r=>
(r.chineseName&&String(r.chineseName).toLowerCase().includes(q))||
(r.loginName&&String(r.loginName).toLowerCase().includes(q))||
(knownChineseNames[String(r.loginName).toLowerCase()]&&knownChineseNames[String(r.loginName).toLowerCase()].toLowerCase().includes(q))
);
}
if(!filtered.length){
list.innerHTML=`
<div class="platform-empty-state">
<div class="platform-empty-icon">🔍</div>
<b>未找到符合条件的管理员</b>
<p>${(allRows&&allRows.length)?'请尝试更换搜索关键字或重置筛选条件。':'还没有配置平台管理员。'}</p>
</div>
`;
return;
}
list.innerHTML=filtered.map(row=>{
const isBuiltin=!row.revocable||row.source==='builtin'||row.source==='env';
const meta=isBuiltin?sourceMeta.builtin:sourceMeta.granted;
const userObj=(state.data?.users||[]).find(u=>u.loginName===row.loginName||(row.userId&&Number(u.id)===Number(row.userId)));
const knownChineseNames = {};
const lName=row.loginName||'';
let cName=row.chineseName||userObj?.chineseName||'';
if(!cName||cName.toLowerCase()===lName.toLowerCase()){
if(knownChineseNames[lName.toLowerCase()]){
cName=knownChineseNames[lName.toLowerCase()];
}
}
const displayName=(cName&&cName.toLowerCase()!==lName.toLowerCase())
? `${lName}(${cName})`
: lName;
return `
<div class="platform-admin-row ${row.revocable?'is-granted':'is-locked'}">
<div class="platform-admin-user">
<div class="platform-admin-avatar">
${userAvatarHTML(row.loginName, 100)}
</div>
<div class="platform-admin-info">
<div class="platform-admin-name-row">
<span class="platform-admin-name">${escapeHTML(displayName)}</span>
</div>
<div class="platform-admin-meta">
<span class="platform-source-badge ${meta.className}">
${meta.icon}<span>${escapeHTML(meta.label)}</span>
</span>
</div>
</div>
</div>
<div class="platform-admin-actions">
${row.revocable?`
<button type="button" class="button ghost small platform-revoke-btn" data-revoke-admin="${escapeHTML(row.loginName)}" title="撤销该账号的平台管理员权限">
<svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
<span>撤销</span>
</button>
`:`
<span class="platform-locked-tag" title="系统内置名单无法通过界面撤销,保障平台管理连续性">
<svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"/><path d="M7 11V7a5 5 0 0 1 10 0v4"/></svg>
<span>不可撤销</span>
</span>
`}
</div>
</div>
`;
}).join('');
list.querySelectorAll('[data-revoke-admin]').forEach(btn=>btn.onclick=async()=>{
const target=btn.dataset.revokeAdmin;
if(!await afConfirm({
title:'撤销平台管理员',
message:`确定撤销 ${target} 的平台管理员权限?撤销后该账号将不再具备通用模板与角色编辑能力。`,
danger:true,
confirmText:'撤销权限'
}))return;
try{
const rows=await api('/api/platform/admins',{method:'PUT',body:JSON.stringify({loginName:target,role:''})});
allRows=rows||[];
updateMetrics(allRows);
render();
toast('已撤销管理员权限','ok');
}catch(e){toast(e.message,'err')}
});
};
if(searchInput){
searchInput.oninput=()=>{
searchQuery=searchInput.value.trim();
render();
};
}
filterTabs.forEach(btn=>{
btn.onclick=()=>{
filterTabs.forEach(b=>b.classList.remove('active'));
btn.classList.add('active');
activeFilter=btn.dataset.sourceFilter||'all';
render();
};
});
try{
allRows=await api('/api/platform/admins')||[];
updateMetrics(allRows);
render();
}catch(e){
list.innerHTML=`<p class="prop-hint">${escapeHTML(e.message||'加载管理员列表失败')}</p>`;
}
form.onsubmit=async e=>{
e.preventDefault();
const login=form.elements.loginName.value.trim();
if(!login)return toast('请填写用户名');
const submitBtn=form.querySelector('button[type="submit"]');
if(submitBtn)submitBtn.disabled=true;
try{
const rows=await api('/api/platform/admins',{method:'PUT',body:JSON.stringify({loginName:login,role:'admin'})});
form.reset();
allRows=rows||[];
updateMetrics(allRows);
render();
toast('已成功添加平台管理员','ok');
}catch(err){
toast(err.message,'err');
}finally{
if(submitBtn)submitBtn.disabled=false;
}
};
}
function renderUserProfilePopover() {
const popover = $('#userProfilePopover');
if (!popover) return;
const user = state.currentUser;
const isGuest = !user || user.isGuest;
const displayName = user?.chineseName || user?.loginName || '访客';
const initial = (displayName[0] || '访').toUpperCase();
let authErr = null;
try { authErr = sessionStorage.getItem('agentflow_auth_err'); } catch (_) {}
if (isGuest) {
popover.innerHTML = `
<div class="upp-header">
<div class="upp-avatar-lg is-guest">${escapeHTML(initial)}</div>
<div class="upp-user-meta">
<div class="upp-name-row">
<span class="upp-name">访客身份</span>
<span class="upp-badge-tag is-guest">未认证</span>
</div>
<div class="upp-login-sub">Guest Session</div>
</div>
</div>
<div class="upp-divider"></div>
<div class="upp-guest-body">
${authErr ? `
<div class="upp-alert-warn">
<b>⚠️ 认证换票未通过</b><br>此前统一认证票据已失效,请点击下方按钮重新登录。
</div>
` : `
<p class="upp-guest-desc">当前以访客身份访问平台。登录后可在左侧「个人配置」配置 GitHub Git Token 和 CodeBuddy API Key。</p>
`}
</div>
<div class="upp-divider"></div>
${themeSegmentHTML()}
<div class="upp-footer">
<button id="uppLoginBtn" class="button small primary upp-full-btn" type="button">通过账号登录</button>
</div>
`;
const loginBtn = popover.querySelector('#uppLoginBtn');
if (loginBtn) {
loginBtn.onclick = () => {
try { sessionStorage.removeItem('agentflow_auth_err'); } catch (_) {}
const target = state.loginUrl || '/login.html';
window.location.href = target;
};
}
} else {
const storedUser=(state.data?.users||[]).find(u=>Number(u.id)===Number(user.id))||{};
popover.innerHTML = `
<div class="upp-header">
<div class="upp-avatar-lg">${userAvatarHTML(user, 150)}</div>
<div class="upp-user-meta">
<div class="upp-name-row">
<span class="upp-name">${escapeHTML(displayName)}</span>
<span class="upp-badge-tag">已登录</span>
</div>
<div class="upp-login-sub">${escapeHTML(user.loginName || '')}</div>
</div>
</div>
<div class="upp-divider"></div>
<div class="upp-info-list">
<div class="upp-info-item">
<span class="upp-label">显示名称</span>
<span class="upp-value">${escapeHTML(user.chineseName || displayName)}</span>
</div>
<div class="upp-info-item">
<span class="upp-label">登录账号</span>
<span class="upp-value">${escapeHTML(user.loginName || '-')}</span>
</div>
<div class="upp-info-item">
<span class="upp-label">用户 ID</span>
<span class="upp-value">${escapeHTML(user.id ? String(user.id) : '-')}</span>
</div>
<div class="upp-info-item">
<span class="upp-label">所属部门</span>
<span class="upp-value" title="${escapeHTML(user.deptName || '-')}">${escapeHTML(user.deptName || '-')}</span>
</div>
<div class="upp-info-item">
<span class="upp-label">认证方式</span>
<span class="upp-value">LoopForge 本地账号</span>
</div>
</div>
<div class="upp-divider"></div>
${themeSegmentHTML()}
<div class="upp-footer">
<button id="uppLogoutBtn" class="button small ghost upp-btn-danger upp-full-btn" type="button" title="退出当前登录">退出登录</button>
</div>
`;
const logoutBtn = popover.querySelector('#uppLogoutBtn');
if (logoutBtn) {
logoutBtn.onclick = async () => {
try {
await api('/api/auth/logout', {method: 'POST'});
location.replace('/login.html');
} catch (err) {
toast('退出登录失败: ' + err.message, 'err');
}
};
}
}
bindThemeSegment(popover);
}
const THEME_SEGMENT_OPTIONS = [['light', 'sun', '浅色'], ['dark', 'moon', '深色'], ['system', 'monitor', '跟随系统']];
function themeSegmentHTML() {
return `
<div class="upp-theme">
<span class="upp-label" id="uppThemeLabel">外观</span>
<div class="upp-theme-seg" role="radiogroup" aria-labelledby="uppThemeLabel">
${THEME_SEGMENT_OPTIONS.map(([value, icon, label]) => `<button type="button" role="radio" data-theme-pref="${value}" aria-checked="false" tabindex="-1"><svg class="agent-icon harness-icon" data-icon="${icon}" width="14" height="14" aria-hidden="true" focusable="false"></svg>${label}</button>`).join('')}
</div>
</div>`;
}
function bindThemeSegment(popover) {
window.AgentFlowHarnessIcons?.hydrate(popover);
const buttons = [...popover.querySelectorAll('[data-theme-pref]')];
buttons.forEach((button, index) => {
button.onclick = () => { if (typeof setThemePreference === 'function') setThemePreference(button.dataset.themePref); };
button.onkeydown = event => {
const step = { ArrowRight: 1, ArrowDown: 1, ArrowLeft: -1, ArrowUp: -1 }[event.key];
if (!step) return;
event.preventDefault();
const next = buttons[(index + step + buttons.length) % buttons.length];
next.click();
next.focus();
};
});
if (typeof renderThemeSegment === 'function') renderThemeSegment();
}
if (typeof window !== 'undefined' && typeof window.addEventListener === 'function' && !window.__avatarErrBound) {
window.__avatarErrBound = true;
window.addEventListener('error', e => {
if (e.target && e.target.tagName === 'IMG' && e.target.classList?.contains('user-avatar-img')) {
e.target.remove();
}
}, true);
}
function userAvatarHTML(userOrId, spec=100, extraClass=''){
let user = null;
if(userOrId && typeof userOrId === 'object'){
user = userOrId;
} else if(userOrId != null && userOrId !== '') {
if(typeof userById === 'function'){
user = userById(userOrId);
}
if(!user){
user = {loginName: String(userOrId)};
}
}
const isGuest = !user || user.isGuest || user.loginName === 'guest' || !user.loginName;
const initial = (user?.chineseName || user?.loginName || '用')[0]?.toUpperCase() || '访';
if(isGuest){
return `<span class="user-avatar-text">${escapeHTML(initial)}</span>`;
}
const specNum = Number(spec) || 100;
const photoUrl = `/api/auth/photo/${specNum}/${encodeURIComponent(user.loginName)}.png`;
return `<img class="user-avatar-img ${extraClass}" src="${photoUrl}" alt="" loading="lazy"><span class="user-avatar-text">${escapeHTML(initial)}</span>`;
}
function renderUserBadge(){
window.AgentFlowPageFeedback?.sync();
const badge=$('#userBadge'), nameEl=$('#userName'), avatarEl=$('#userAvatarText');
if(!badge) return;
const user=state.currentUser;
const isGuest = !user || user.isGuest;
const displayName=user?.chineseName||user?.loginName||'访客';
if(nameEl) nameEl.textContent=displayName;
if(avatarEl) avatarEl.innerHTML=userAvatarHTML(user, 100);
let authErr = null;
try { authErr = sessionStorage.getItem('agentflow_auth_err'); } catch (_) {}
if(isGuest){
badge.classList.add('is-guest');
}else{
badge.classList.remove('is-guest');
}
const tipText = isGuest
? (authErr ? '认证换票未通过 · 点击查看个人信息' : '当前为访客身份 · 点击查看个人信息')
: `${displayName} (${user.loginName||user.staffId||''}) · 点击查看个人信息`;
badge.title = tipText;
if(typeof badge.setAttribute === 'function'){
badge.setAttribute('data-tooltip', tipText);
badge.setAttribute('aria-label', tipText);
}
renderUserProfilePopover();
}
function renderDashboard(){
const issues=state.data.issues||[];
const projectIssues=issues.filter(i=>!state.projectFilter||i.projectId===state.projectFilter);
const attention=projectIssues.filter(i=>issueRunHealth(i)==='attention');
const waiting=projectIssues.filter(i=>issueCurrentStage(i).key==='waiting');
const confirm=projectIssues.filter(i=>issueCurrentStage(i).key==='confirm');
const active=projectIssues.filter(i=>issueRunHealth(i)==='active'&&issueCurrentStage(i).key!=='waiting');
const closed=projectIssues.filter(i=>issueRunHealth(i)==='closed');
updateApprovalBadge();
const needMe=[...waiting,...confirm,...attention.filter(i=>!waiting.includes(i)&&!confirm.includes(i))];
const statCards=[
{label:'需要介入',value:attention.length,foot:'待确认结论、失败或已中断',color:'#c63c4b',filter:'attention'},
{label:'待我确认',value:approvalItems().length,foot:'批准后才会继续跑',color:'#fbbf24',to:'approvals'},
{label:'正在推进',value:active.length,foot:'Agent 正在执行',color:'#5b8cff',filter:'active'},
{label:'已经完成',value:closed.length,foot:'本项目已闭环',color:'#34d399',filter:'closed'},
];
const statsHost=$('#dashStats');
statsHost.innerHTML=statCards.map(c=>`<div class="stat-card" ${c.filter!=null?`data-issue-filter="${c.filter}"`:`data-jump="${c.to}"`} style="--accent:${c.color}"><div class="label">${c.label}</div><div class="value">${c.value}</div><div class="foot">${c.foot}</div></div>`).join('');
jumpBind(statsHost);jumpBind($('#dashboardView'));
const row=(i)=>{
const p=(state.data.projects||[]).find(x=>x.id===i.projectId),out=issueOutcome(i),stage=issueCurrentStage(i);
return `<div class="row-item ${out.key}" data-issue="${escapeHTML(i.id)}"><span class="dot ${out.key}"></span><div style="flex:1;min-width:0"><div class="strong ellipsis">${escapeHTML(i.title)}</div><div class="muted">${escapeHTML(issueKeyLabel(i))} · ${escapeHTML(stage.label)}</div></div><span class="status ${out.key}">${escapeHTML(out.short)}</span></div>`;
};
const bindIssueRows=host=>{host.querySelectorAll('[data-issue]').forEach(el=>el.onclick=()=>openIssueDetail(el.dataset.issue))};
$('#dashAttention').innerHTML=needMe.length?needMe.slice(0,8).map(row).join(''):'<div class="empty-box">没有需要你处理的需求</div>';
$('#dashActive').innerHTML=active.length?active.slice(0,8).map(row).join(''):'<div class="empty-box">当前没有进行中的需求</div>';
const results=closed.filter(i=>!issueManuallyClosed(i)&&!issueTrackerClosed(i)).sort((a,b)=>new Date(b.updatedAt||0)-new Date(a.updatedAt||0)).slice(0,8);
$('#dashResults').innerHTML=results.length?results.map(row).join(''):'<div class="empty-box">还没有跑完的需求</div>';
bindIssueRows($('#dashAttention'));bindIssueRows($('#dashActive'));bindIssueRows($('#dashResults'));
const cfg=state.data.syncConfig||{},logs=state.data.syncLogs||[];
const synced=knownTime(cfg.lastSyncAt),syncResult=logs[0]?.status==='success'?'成功':logs[0]?.status==='failed'?'失败':'';
$('#dashFeedHint').textContent=synced?`最近同步 ${synced.toLocaleString()}${syncResult?` · ${syncResult}`:''}`:'从未同步';
const feed=logs.slice(0,8).map(l=>`<div class="tl-item"><div><b>${l.direction==='pull'?'拉取':'推送'} · ${l.source==='github'?'GitHub':l.source==='gongfeng'?'工蜂':l.source==='tapd'?'TAPD':escapeHTML(l.source||'')}</b> <span class="muted">${escapeHTML(l.message||l.action)}</span></div><div class="muted" style="font-size:10.5px;margin-top:2px">${new Date(l.startedAt).toLocaleString()} · ${l.status==='success'?'成功':`失败 ${escapeHTML(l.message||'')}`}</div></div>`).join('');
$('#dashFeed').innerHTML=feed||'<div class="tl-item"><div class="muted">尚未同步。绑定 GitHub 仓库后,可在「需求列表」里点击「同步 GitHub」。</div></div>';
}