Hugging Face's logo

Spaces:
chanfasf
/
skill
Running

App Files Community
skill / app.js
chanfasf's picture
chanfasf
Upload app.js with huggingface_hub
03abe57 verified
Raw
History Blame Contribute Delete
68.4 kB
// Skills —— 前端逻辑
// ChatGPT 官网多账号池：access_token 存本机 localStorage，前端自管理轮询/限流/恢复
// 请求方式：优先走本地中继(localhost:8765)，回退到 Cloudflare Worker
// =====【全局配置 · 放在最前避免 TDZ 死区】=====
// 【用户预置 Key】—— 写死在代码里，跨设备自动生效，不用每台设备手动加
const BUILTIN_KEYS = [
{ name: '🎁 我的智谱', provider: 'zhipu', key: 'e923eafcbf134ac3b8249f8e1b7b8d40.6gIuxGd27Aq4fRPc', model: 'auto', _builtin: true }
];
// 【默认提供商】启动时默认选中（chatsam / zhipu / chatgpt）
const DEFAULT_PROVIDER = 'zhipu';
// ===== 商用密码门 =====
const ACCESS_PWD = 'skill2026'; // 默认密码，可改
function initLoginGate() {
const gate = document.getElementById('loginGate');
const pwdInput = document.getElementById('loginPwd');
const btn = document.getElementById('loginBtn');
const errEl = document.getElementById('loginErr');
if (!gate || !pwdInput || !btn) return;
// 已登录：加 authed class，隐藏登录页
if (sessionStorage.getItem('skill_auth') === '1') {
document.documentElement.classList.add('authed');
return;
}
// 未登录：显示登录页
document.documentElement.classList.remove('authed');
const doLogin = () => {
if (pwdInput.value === ACCESS_PWD) {
sessionStorage.setItem('skill_auth', '1');
document.documentElement.classList.add('authed');
} else {
errEl.hidden = false;
pwdInput.value = '';
pwdInput.focus();
setTimeout(() => { errEl.hidden = true; }, 2000);
}
};
btn.addEventListener('click', doLogin);
pwdInput.addEventListener('keydown', (e) => { if (e.key === 'Enter') doLogin(); });
setTimeout(() => pwdInput.focus(), 100);
}
initLoginGate();
const RELAY_URL = 'http://localhost:8765';
const WORKER_URL = 'https://jc-skill-gpt.2297153835.workers.dev';
const DEPLOY_KEY = 'jc-skill-deploy-2026-secret';
let RELAY_OK = false; // 中继是否在线
async function checkRelay() {
try {
const r = await fetch(RELAY_URL + '/healthz', { signal: AbortSignal.timeout(2000) });
RELAY_OK = r.ok;
} catch { RELAY_OK = false; }
// 更新 UI
const dot = $('relayDot');
const hint = $('relayHint');
const headerDot = $('relayStatus');
if (dot) {
dot.className = 'relay-dot ' + (RELAY_OK ? 'online' : 'offline');
}
if (hint) {
hint.textContent = RELAY_OK
? '本地中继已连接 (localhost:8765)，直连 chatgpt.com 无限制'
: '本地中继未启动，正在使用 Cloudflare Worker（可能遇到 403 限流）';
}
if (headerDot) {
headerDot.className = 'relay-status ' + (RELAY_OK ? 'online' : 'offline');
headerDot.title = RELAY_OK ? '本地中继已连接' : '本地中继离线，走 Worker';
}
return RELAY_OK;
}
// 返回当前可用的 base URL
function apiBase() { return RELAY_OK ? RELAY_URL : WORKER_URL; }
const PROVIDERS = {
chatgpt: {
name: 'ChatGPT 官网多账号池',
defaultModel: 'gpt-4o',
// chatgpt.com 网页端 8 个模型（探测时按这个优先级从最强到最弱）
models: [
'o3',
'gpt-4.1',
'gpt-4o',
'o1',
'gpt-4.1-mini',
'gpt-4o-mini',
'o3-mini',
'o1-mini'
],
usesTokenPool: true,
keyUrl: 'https://chatgpt.com',
free: true,
guide: {
access: '通过本地中继或 Cloudflare Worker 调用 chatgpt.com',
price: '免费，账号数 × ChatGPT 免费额度叠加',
pay: '用你自己的 ChatGPT 账号',
keyFormat: 'ChatGPT 官网 access_token（eyJ... 开头的 JWT）',
steps: [
'打开 chatgpt.com 登录你的账号',
'F12 打开开发者工具 → Application → Cookies',
'复制 __Secure-next-auth.session-token 的值（JWT 格式）',
'或者用 https://chatgpt.com/api/auth/session 拿 access_token',
'把 access_token 粘贴到下方「账号池」添加',
'点击账号右侧的「🔍 探测」自动测出能跑哪些模型',
'点击「📊 配额」查看账号 plan 和剩余信息'
],
note: '⚠️ access_token 会过期（一般几天到几周），过期后该 token 状态变 disabled，请重新抓。多账号加进来自动轮询，单个限流/挂掉不影响其他。每个账号可独立选模型。'
}
},
zhipu: {
name: '智谱 AI（GLM 系列模型轮调）',
defaultModel: 'auto', // auto 表示自动轮调
models: ['auto', 'glm-4-flash', 'glm-4-air', 'glm-4-plus'],
usesTokenPool: false,
keyUrl: 'https://open.bigmodel.cn/api-keys',
free: false,
guide: {
access: '国内直连，无需代理',
price: '按 tokens 计费，赠送资源用完按量付费',
pay: '在 open.bigmodel.cn 充值',
keyFormat: '智谱 API Key（apikey.xxx 格式）',
steps: [
'打开 open.bigmodel.cn 登录账号',
'进入「API Keys」页面创建新的 Key',
'复制 API Key（apikey.xxx 格式）',
'粘贴到下方输入框添加',
'系统自动跟踪模型余额，优先使用赠送资源'
],
note: '💡 支持模型轮调：自动选择余额充足的模型，低于 10% 自动切换。显示各模型剩余 tokens 和使用进度。'
}
},
chatsam: {
name: 'CHATSAM（内置号池 + 童锦程 Skill）',
baseUrl: 'https://chanfasf-chatsam.hf.space',
defaultModel: 'gpt-4o-mini',
models: ['gpt-4o-mini', 'gpt-4o', 'gpt-4.1', 'gpt-4.1-mini', 'o1', 'o1-mini', 'o3', 'o3-mini'],
usesTokenPool: false,
noKeyRequired: true,
// CHATSAM chatgpt2api 后端内置共享号池的公开 API Key
chatSamApiKey: '34555',
fallbackAuthKey: 'e923eafcbf134ac3b8249f8e1b7b8d40.6gIuxGd27Aq4fRPc',
keyUrl: '',
free: true,
guide: {
access: '直接使用 CHATSAM 内置号池，无需配置',
price: '免费',
pay: '',
keyFormat: '',
steps: [
'选择 CHATSAM 提供商即可使用',
'号池由 CHATSAM 自动管理',
'自动注入童锦程 Skill'
],
note: '💡 无需获取 access_token，CHATSAM 已内置可用号池和最新的「童锦程话术体系 + 多话术选择模式」。后端是 chatgpt2api，需登录面板创建用户 Key（未配置则自动走智谱兜底）。'
}
}
};
// 智谱模型轮调配置（赠送资源）
const ZHIPU_MODEL_QUOTAS = {
'glm-4-flash': { total: 10000000, priority: 1, name: 'GLM-4-Flash (10M tokens)' },
'glm-4-air': { total: 5000000, priority: 2, name: 'GLM-4-Air (5M tokens)' },
'glm-4-plus': { total: 3000000, priority: 3, name: 'GLM-4-Plus (3M tokens)' }
};
const MODEL_ROTATION_ORDER = ['glm-4-flash', 'glm-4-air', 'glm-4-plus'];
// 智谱模型余额存储（localStorage）
const ZHIPU_TOKENS_KEY = 'zhipu-model-tokens';
function loadZhipuTokens() {
try {
return JSON.parse(localStorage.getItem(ZHIPU_TOKENS_KEY) || '{}');
} catch {
return {};
}
}
function saveZhipuTokens(tokens) {
localStorage.setItem(ZHIPU_TOKENS_KEY, JSON.stringify(tokens));
}
// 获取模型剩余 tokens（优先从 localStorage，没有则用总额）
function getModelRemainingTokens(model) {
const tokens = loadZhipuTokens();
if (tokens[model] !== undefined) return tokens[model];
return ZHIPU_MODEL_QUOTAS[model]?.total || 0;
}
// 更新模型剩余 tokens
function updateModelTokens(model, usedTokens) {
const tokens = loadZhipuTokens();
const remaining = Math.max(0, (tokens[model] || ZHIPU_MODEL_QUOTAS[model]?.total || 0) - usedTokens);
tokens[model] = remaining;
saveZhipuTokens(tokens);
}
// 获取推荐的智谱模型（余额 > 10%）
function getRecommendedZhipuModel() {
for (const model of MODEL_ROTATION_ORDER) {
const remaining = getModelRemainingTokens(model);
const total = ZHIPU_MODEL_QUOTAS[model]?.total || 1;
if (remaining / total > 0.1) return model;
}
// 都低于 10% 了，还是返回第一个
return MODEL_ROTATION_ORDER[0];
}
// ---------- DOM ----------
const $ = (id) => document.getElementById(id);
const messagesEl = $('messages');
const inputEl = $('input');
const sendBtn = $('sendBtn');
const welcomeEl = $('welcome');
const settingsModal = $('settingsModal');
const providerSel = $('provider');
const getKeyLink = $('getKeyLink');
const providerGuideEl = $('providerGuide');
const keyListEl = $('keyList');
const newKeyNameInput = $('newKeyName');
const newKeyValInput = $('newKeyVal');
const addKeyBtn = $('addKeyBtn');
const dashBody = $('dashBody');
const refreshAllBtn = $('refreshAllBtn');
// ---------- 状态 ----------
const STORE_KEY = 'tong-jincheng-settings';
const HISTORY_KEY = 'tong-jincheng-history';
const GIRLS_KEY = 'jc-skill-girls';
let settings = loadSettings();
let history = loadHistory(); // [{role, content, girlId?, image?}]
let girls = loadGirls(); // [{id, name, color, profile, emotion, lastSeen, createdAt}]
let isStreaming = false;
let keyRotationIdx = {}; // {provider: idx} 当前轮询到第几个 key
let pendingImage = null; // data URL，待发送的截图
// 女生档案
const GIRL_COLORS = ['#ff6b8a', '#ffa94d', '#69db7c', '#4dabf7', '#cc5de8', '#fab005', '#20c997', '#f783ac'];
function loadGirls() {
try { return JSON.parse(localStorage.getItem(GIRLS_KEY) || '[]'); }
catch { return []; }
}
function saveGirls() { localStorage.setItem(GIRLS_KEY, JSON.stringify(girls)); }
function findGirlByName(name) {
if (!name) return null;
const n = name.trim();
return girls.find((g) => g.name === n) || null;
}
function addGirl(name, opts = {}) {
const g = {
id: 'g' + Date.now() + Math.random().toString(36).slice(2, 6),
name: name.trim(),
color: GIRL_COLORS[girls.length % GIRL_COLORS.length],
profile: opts.profile || '',
emotion: opts.emotion || '',
lastSeen: Date.now(),
createdAt: Date.now()
};
girls.push(g);
saveGirls();
return g;
}
function touchGirl(id, emotion) {
const g = girls.find((x) => x.id === id);
if (!g) return;
g.lastSeen = Date.now();
if (emotion) g.emotion = emotion;
saveGirls();
}
function deleteGirl(id) {
girls = girls.filter((g) => g.id !== id);
saveGirls();
}
// 自动清理：超过 5 个月没互动（没发截图、没发消息）的女生档案自动清空
const STALE_MS = 5 * 30 * 24 * 60 * 60 * 1000; // 约 5 个月
function cleanStaleGirls() {
const now = Date.now();
const before = girls.length;
girls = girls.filter((g) => g.lastSeen && (now - g.lastSeen) < STALE_MS);
if (girls.length !== before) {
saveGirls();
console.log(`[自动清理] 移除了 ${before - girls.length} 个超过 5 个月未互动的女生档案`);
}
}
// 【全局 BUILTIN_KEYS / DEFAULT_PROVIDER 已在文件顶部声明，避免 TDZ 死区】
function loadSettings() {
try {
const s = JSON.parse(localStorage.getItem(STORE_KEY) || '{}');
let keys = Array.isArray(s.keys) ? s.keys : [];
if (s.apiKey && !keys.some((k) => k.provider === (s.provider || DEFAULT_PROVIDER))) {
keys.push({ name: '默认', key: s.apiKey, provider: s.provider || DEFAULT_PROVIDER });
}
// 合并内置 Key：按 (provider,key,name) 去重，保留用户状态字段
for (const bk of BUILTIN_KEYS) {
if (!keys.some((k) => k.provider === bk.provider && k.key === bk.key)) {
keys.push({ ...bk, status: 'ok' });
} else {
// 已存在则打上 builtin 标记，防止被删后复原
const hit = keys.find((k) => k.provider === bk.provider && k.key === bk.key);
hit._builtin = true;
}
}
return {
provider: s.provider || DEFAULT_PROVIDER,
keys,
baseUrl: s.baseUrl || ''
};
} catch {
return {
provider: DEFAULT_PROVIDER,
keys: BUILTIN_KEYS.map((k) => ({ ...k, status: 'ok' })),
baseUrl: ''
};
}
}
function saveSettings() {
localStorage.setItem(STORE_KEY, JSON.stringify(settings));
}
// 按 provider 取该平台的所有 key/token
// token 池有 status 状态机：ok / limited / disabled
function keysFor(provider) {
const now = Date.now();
return settings.keys
.filter((k) => k.provider === provider)
.map((k) => {
// 自动恢复：限流已过 resetAt → 恢复 ok
if (k.status === 'limited' && k.resetAt && k.resetAt <= now) {
k.status = 'ok';
k.resetAt = 0;
}
return k;
});
}
// 取下一个可用 key/token（ok 状态；跳过 limited/disabled）
function nextKey(provider) {
const ks = keysFor(provider).filter((k) => (k.status || 'ok') === 'ok');
if (ks.length === 0) return null;
if (keyRotationIdx[provider] === undefined) keyRotationIdx[provider] = 0;
const key = ks[keyRotationIdx[provider] % ks.length];
keyRotationIdx[provider] = (keyRotationIdx[provider] + 1) % ks.length;
return key;
}
function loadHistory() {
try { return JSON.parse(localStorage.getItem(HISTORY_KEY) || '[]'); }
catch { return []; }
}
function persistHistory() {
// 只保留最近 40 条；超过 6 条之前的图片数据丢掉（转占位），避免 localStorage 爆
const trimmed = history.slice(-40).map((m, i, arr) => {
if (m.image && i < arr.length - 6) {
const copy = { ...m };
delete copy.image;
copy.content = (m.content || '') + ' [图片已省略]';
return copy;
}
return m;
});
try {
localStorage.setItem(HISTORY_KEY, JSON.stringify(trimmed));
} catch {
// 配额超了：丢掉所有图片再试
const noImg = trimmed.map((m) => { const c = { ...m }; delete c.image; return c; });
try { localStorage.setItem(HISTORY_KEY, JSON.stringify(noImg)); } catch {}
}
}
// ---------- 快速提供商切换器（顶部 Header） ----------
const quickProvSwitch = $('quickProvSwitch');
function syncQuickSwitchFromSettings() {
if (quickProvSwitch && settings.provider && quickProvSwitch.value !== settings.provider) {
quickProvSwitch.value = settings.provider;
}
}
if (quickProvSwitch) {
quickProvSwitch.addEventListener('change', () => {
const p = quickProvSwitch.value;
if (!p || p === settings.provider) return;
settings.provider = p;
saveSettings();
// 同步设置面板里的 providerSel
if (providerSel && providerSel.value !== p) providerSel.value = p;
updateProviderUI();
renderKeyList();
renderDash();
const name = quickProvSwitch.options[quickProvSwitch.selectedIndex]?.textContent?.split(' ')[1] || p;
toast(`已切换：${name}`);
});
}
// ---------- 初始化 UI ----------
function applySettingsToUI() {
providerSel.value = settings.provider;
syncQuickSwitchFromSettings();
updateProviderUI();
renderKeyList();
}
function updateProviderUI() {
const p = PROVIDERS[settings.provider];
if (!p) return;
getKeyLink.href = p.keyUrl || '#';
getKeyLink.textContent = p.keyUrl ? `→ 去${p.name}获取 Key` : `→ ${p.name}（无需配置）`;
if (!p.keyUrl) getKeyLink.style.display = 'none';
else getKeyLink.style.display = '';
// 自定义 base url 字段
const baseUrlInput = $('baseUrl');
const baseUrlField = $('baseUrlField');
if (p.requiresBaseUrl) {
baseUrlField.style.display = '';
baseUrlInput.value = settings.baseUrl || '';
} else {
baseUrlField.style.display = 'none';
}
// CHATSAM 免 key：隐藏账号池+模型选择区域
const noKeyNeeded = p.noKeyRequired;
const keyListField = $('keyField') || keyListEl.closest('.field');
const dashField = dashBody.closest('.field');
const newKeyRow = $('keyAddRow');
if (noKeyNeeded) {
if (keyListField) keyListField.style.display = 'none';
if (dashField) dashField.style.display = 'none';
if (newKeyRow) newKeyRow.style.display = 'none';
} else {
if (keyListField) keyListField.style.display = '';
if (dashField) dashField.style.display = '';
if (newKeyRow) newKeyRow.style.display = '';
// 根据 provider 切换 label / placeholder / hint
const labelEl = $('keyFieldLabel');
const valInput = newKeyValInput;
const hintTip = $('keyHintTip');
if (provider === 'zhipu') {
if (labelEl) labelEl.textContent = '智谱 API Key（支持多 Key 轮询）';
if (valInput) valInput.placeholder = '粘贴智谱 API Key（apikey.xxx 格式）';
if (hintTip) hintTip.textContent = '在 open.bigmodel.cn 创建 API Key。支持多 Key 轮询，自动跟踪模型余额。Key 存本机 localStorage，不上传服务器。';
} else if (provider === 'chatgpt') {
if (labelEl) labelEl.textContent = 'ChatGPT 账号池（多 access_token 自动轮询）';
if (valInput) valInput.placeholder = 'eyJ... 开头的 access_token';
if (hintTip) hintTip.textContent = '多账号 token 都加进来，自动轮询；单账号限流/失效不影响其他。Token 存本机 localStorage，不上传服务器。';
} else {
if (labelEl) labelEl.textContent = 'API Key';
if (valInput) valInput.placeholder = '粘贴 API Key / access_token';
if (hintTip) hintTip.textContent = '多账号轮询，单账号限流自动切换。';
}
}
// 模型下拉框根据 provider 切换
updateModelSelect(p);
renderProviderGuide(p);
renderZhipuQuotas();
}
// 切换模型下拉框选项
function updateModelSelect(p) {
const sel = $('newKeyModel');
if (!sel) return;
if (!p || !p.models) { sel.innerHTML = ''; return; }
sel.innerHTML = p.models.map((m) => `<option value="${m}">${m}</option>`).join('');
if (p.defaultModel && p.models.includes(p.defaultModel)) sel.value = p.defaultModel;
}
function renderProviderGuide(p) {
if (!p.guide) { providerGuideEl.innerHTML = ''; return; }
const g = p.guide;
const accessTag = g.access.startsWith('国内')
? `<span class="tag tag-ok">${g.access}</span>`
: `<span class="tag tag-warn">${g.access}</span>`;
const freeTag = p.free ? `<span class="tag tag-free">免费</span>` : '';
const steps = g.steps.map((s, i) => `<li><span class="step-num">${i + 1}</span><span>${s}</span></li>`).join('');
providerGuideEl.innerHTML = `
<div class="guide-head">
<span class="guide-title">${p.name} · API 获取说明</span>
${freeTag}${accessTag}
</div>
<ul class="guide-steps">${steps}</ul>
<div class="guide-meta">
<div><span class="meta-label">价格</span><span class="meta-val">${g.price}</span></div>
<div><span class="meta-label">充值</span><span class="meta-val">${g.pay}</span></div>
<div><span class="meta-label">Key 格式</span><span class="meta-val mono">${g.keyFormat}</span></div>
</div>
`;
}
// 渲染智谱模型余额显示面板
function renderZhipuQuotas() {
const quotaEl = $('zhipuQuotas');
if (!quotaEl) return;
// 只在智谱提供商时显示
if (settings.provider !== 'zhipu') {
quotaEl.style.display = 'none';
return;
}
quotaEl.style.display = '';
// 渲染各模型余额进度条
const models = MODEL_ROTATION_ORDER.map((model) => {
const total = ZHIPU_MODEL_QUOTAS[model]?.total || 1;
const remaining = getModelRemainingTokens(model);
const percentage = Math.max(0, Math.min(100, (remaining / total) * 100));
const percentageClass = percentage > 50 ? 'quota-high' : percentage > 10 ? 'quota-mid' : 'quota-low';
const recommended = getRecommendedZhipuModel() === model;
return `
<div class="quota-item">
<div class="quota-header">
<span class="quota-model">${ZHIPU_MODEL_QUOTAS[model]?.name || model}</span>
${recommended ? '<span class="tag tag-ok">推荐</span>' : ''}
</div>
<div class="quota-bar-bg">
<div class="quota-bar ${percentageClass}" style="width: ${percentage}%"></div>
</div>
<div class="quota-info">
<span>剩余 ${formatTokens(remaining)} / ${formatTokens(total)}</span>
<span>${percentage.toFixed(1)}%</span>
</div>
</div>
`;
}).join('');
quotaEl.innerHTML = `
<div class="quota-panel">
<div class="quota-title">模型余额监控</div>
<p class="quota-hint">自动轮调：优先使用余额充足的模型，低于 10% 自动切换</p>
${models}
</div>
`;
}
// 格式化 tokens 显示（带单位）
function formatTokens(num) {
if (num >= 1000000) return (num / 1000000).toFixed(1) + 'M';
if (num >= 1000) return (num / 1000).toFixed(1) + 'K';
return num.toString();
}
function renderKeyList() {
const ks = keysFor(settings.provider);
const p = PROVIDERS[settings.provider];
const isPool = p && p.usesTokenPool;
// CHATSAM 免 key 模式：不渲染列表
if (p && p.noKeyRequired) {
keyListEl.innerHTML = '<div class="empty-tip">✅ CHATSAM 内置号池已就绪，无需添加账号</div>';
renderDash();
return;
}
// 每个 token 可用模型列表（探测后存在 k.probedModels）
// 未探测时显示全模型
const modelOptions = (p && p.models) ? p.models : (p && p.defaultModel ? [p.defaultModel] : []);
const emptyTip = settings.provider === 'zhipu'
? '还没添加智谱 API Key，去 open.bigmodel.cn 创建后粘贴到下方'
: settings.provider === 'chatgpt'
? '还没添加账号，去 chatgpt.com 抓 access_token 加进来'
: '还没添加 API Key';
keyListEl.innerHTML = (ks.length === 0)
? `<div class="empty-tip">${emptyTip}</div>`
: ks.map((k, i) => {
const status = k.status || 'ok';
const statusLabel = status === 'ok' ? '<span class="tag tag-ok">正常</span>'
: status === 'limited' ? `<span class="tag tag-warn">限流${k.resetAt ? ' · ' + formatCountdown(k.resetAt) : ''}</span>`
: '<span class="tag tag-bad">失效</span>';
const errorTip = k.lastError ? ` title="${escapeHtml(k.lastError)}"` : '';
// 可用模型列表：智谱永远展示全部模型（探测只是验证，不做限制）
// ChatGPT：探测过的用 probedModels，否则全展示
let avail;
if (settings.provider === 'zhipu') {
avail = modelOptions; // 智谱所有模型都展示，不被探测结果限制
} else {
avail = Array.isArray(k.probedModels) && k.probedModels.length ? k.probedModels : modelOptions;
}
// 如果 probedModels 是空数组（旧逻辑探测失败留下的脏数据），智谱直接清掉状态
if (settings.provider === 'zhipu' && Array.isArray(k.probedModels) && k.probedModels.length === 0) {
delete k.probedModels;
if (k.status === 'disabled') { k.status = 'ok'; k.lastError = ''; }
}
const useModel = (avail.includes(k.model)) ? k.model
: (k.model || (p && p.defaultModel) || 'gpt-4o');
// 智谱/ChatGPT 都显示模型选择
const modelSelect = avail.length
? `<select class="key-model-sel" data-idx="${i}" title="选择该账号使用的模型">
${avail.map((m) => `<option value="${m}"${m === useModel ? ' selected' : ''}>${m}</option>`).join('')}
</select>`
: '';
const plan = k.sessionInfo && k.sessionInfo.planType ? `<span class="tag tag-plan">${k.sessionInfo.planType}</span>` : '';
const tabBadge = '';
const tabBtn = '';
// 探测/session 按钮仅 ChatGPT 显示
const probeBtn = isPool ? `<button class="key-probe" data-idx="${i}" title="探测此 token 能跑哪些模型">🔍</button>` : '';
const sessionBtn = isPool ? `<button class="key-session" data-idx="${i}" title="查看账号配额和 plan">📊</button>` : '';
return `
<div class="key-item${status !== 'ok' ? ' key-disabled' : ''}" data-idx="${i}"${errorTip}>
<span class="key-name">${escapeHtml(k.name || '未命名')}</span>
<span class="key-val">${escapeHtml(maskKey(k.key))}</span>
${modelSelect}
${plan}
${statusLabel}
${probeBtn}
${sessionBtn}
${status === 'limited' ? `<button class="key-reset" data-idx="${i}" title="强制重置为正常">↻</button>` : ''}
<button class="key-del" data-idx="${i}" aria-label="删除">
<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6m5 0V4a2 2 0 0 1 2-2h0a2 2 0 0 1 2 2v2"/></svg>
</button>
</div>
`;
}).join('');
keyListEl.querySelectorAll('.key-del').forEach((btn) => {
btn.addEventListener('click', () => {
const idx = parseInt(btn.dataset.idx, 10);
const ks = keysFor(settings.provider);
const target = ks[idx];
settings.keys = settings.keys.filter((k) => k !== target);
saveSettings();
renderKeyList();
});
});
keyListEl.querySelectorAll('.key-reset').forEach((btn) => {
btn.addEventListener('click', () => {
const idx = parseInt(btn.dataset.idx, 10);
const ks = keysFor(settings.provider);
const target = ks[idx];
target.status = 'ok';
target.resetAt = 0;
target.lastError = '';
saveSettings();
renderKeyList();
toast(`已重置账号「${target.name}」`);
});
});
keyListEl.querySelectorAll('.key-model-sel').forEach((sel) => {
sel.addEventListener('change', () => {
const idx = parseInt(sel.dataset.idx, 10);
const ks = keysFor(settings.provider);
const target = ks[idx];
if (!target) return;
target.model = sel.value;
saveSettings();
toast(`账号「${target.name}」→ ${sel.value}`);
});
});
keyListEl.querySelectorAll('.key-probe').forEach((btn) => {
btn.addEventListener('click', () => {
const idx = parseInt(btn.dataset.idx, 10);
const ks = keysFor(settings.provider);
const target = ks[idx];
if (target) probeOneToken(target);
});
});
keyListEl.querySelectorAll('.key-session').forEach((btn) => {
btn.addEventListener('click', () => {
const idx = parseInt(btn.dataset.idx, 10);
const ks = keysFor(settings.provider);
const target = ks[idx];
if (target) fetchSessionInfo(target);
});
});
renderDash();
}
// 探测单个 token：按优先级串行测，找到最强可用的就停
async function probeOneToken(keyObj) {
const provider = settings.provider;
const p = PROVIDERS[provider];
const idx = findIdxByKey(keyObj);
btnSpin(`.key-probe[data-idx="${idx}"]`, true);
btnSpin(`.dash-probe[data-idx="${idx}"]`, true);
// ===== 智谱：直连智谱 API 测三个 glm 模型（跳过 auto，因为它是逻辑模型）=====
if (provider === 'zhipu') {
toast(`正在验证「${keyObj.name}」...`);
const testModels = ['glm-4-plus', 'glm-4-air', 'glm-4-flash'];
const results = [];
let firstOkModel = null;
const t0 = Date.now();
for (const m of testModels) {
try {
const resp = await fetch('https://open.bigmodel.cn/api/paas/v4/chat/completions', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${keyObj.key}`
},
body: JSON.stringify({
model: m,
messages: [{ role: 'user', content: '你好' }],
stream: false,
max_tokens: 3
}),
signal: AbortSignal.timeout(12000)
});
const ok = resp.ok;
const status = resp.status;
let error = '';
if (!ok) {
try { const d = await resp.json(); error = d.error?.message || d.msg || d.error || `HTTP ${status}`; } catch { error = `HTTP ${status}`; }
} else {
firstOkModel = firstOkModel || m;
}
results.push({ model: m, ok, status, error });
} catch (e) {
results.push({ model: m, ok: false, status: 0, error: String(e.message || e) });
}
}
const okList = results.filter((r) => r.ok).map((r) => r.model);
// auto 永远加回 probedModels（因为 auto 是默认模型选择）
const probed = okList.length ? ['auto', ...okList] : [];
keyObj.probedModels = probed;
keyObj.probeSummary = {
tested: results.length,
totalModels: testModels.length,
totalMs: Date.now() - t0,
results
};
if (okList.length === 0) {
// ⚠️ 智谱：探测失败不打 disabled！探测使用的是非流式+短超时，
// 可能因网络/CORS/参数波动误判；真实发送时streamChat再决定是否禁用
keyObj.failCount = (keyObj.failCount || 0) + 1;
const lastErr = (results[0] && results[0].error) || '模型验证未通过';
keyObj.lastError = lastErr;
// 不设置 status = disabled，保持默认 ok，发送时再校验
saveSettings();
renderKeyList();
const errs = results.map((f) => `${f.model}=${f.status || 'err'}`).join(', ');
toast(`⚠️ 「${keyObj.name}」探测未完成 (${errs.slice(0,40)})，直接发送试一下`, 5500);
} else {
keyObj.model = firstOkModel;
keyObj.status = 'ok';
keyObj.successCount = (keyObj.successCount || 0) + 1;
saveSettings();
renderKeyList();
toast(`✅ 「${keyObj.name}」可用：${okList.join(' / ')}（${Date.now() - t0}ms）`, 4500);
}
btnSpin(`.key-probe[data-idx="${findIdxByKey(keyObj)}"]`, false);
btnSpin(`.dash-probe[data-idx="${findIdxByKey(keyObj)}"]`, false);
renderDash();
return;
}
// ===== ChatGPT：走本地中继或 Worker 的 /probe 端点 =====
toast(`正在探测「${keyObj.name}」最强可用模型...`);
try {
const models = (p && p.models) || [];
const base = apiBase();
const headers = { 'Content-Type': 'application/json', 'X-Account-Token': keyObj.key };
if (!RELAY_OK) headers['Authorization'] = `Bearer ${DEPLOY_KEY}`;
const resp = await fetch(base + '/probe', {
method: 'POST',
headers,
body: JSON.stringify({ models })
});
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || `HTTP ${resp.status}`);
// firstOk 是按优先级找出的第一个可用的（最强）
const firstOkModel = data.firstOk && (data.firstOk.realModel || data.firstOk.model);
// okModels 是所有跑过且成功的（实际上现在通常只有 1 个）
const okList = (data.okModels || []).filter((m) => models.includes(m));
// 但用户往往想用次强做多模型轮询——所以仍然把"理论可用"集合存下来
// 我们用 probedModels = [firstOk, ...其他已成功测过的]
// 如果全失败，probedModels = [] → 该 token 等于废
keyObj.probedModels = okList;
keyObj.lastProbedAt = Date.now();
// 探测结果摘要
keyObj.probeSummary = {
firstOk: firstOkModel || null,
tested: data.tested,
totalModels: data.totalModels,
totalMs: data.totalMs,
results: data.results
};
// 统计本次结果
const failed = (data.results || []).filter((r) => !r.ok);
if (okList.length === 0) {
keyObj.failCount = (keyObj.failCount || 0) + 1;
if (failed.length) {
keyObj.status = 'disabled';
keyObj.lastError = failed[0].error || `HTTP ${failed[0].status}`;
}
saveSettings();
renderKeyList();
const errs = failed.map((f) => `${f.model}=${f.status || 'err'}`).join(', ');
toast(`❌ 「${keyObj.name}」无可用模型 (${errs})`, 5000);
} else {
// 自动切到最强可用
keyObj.model = firstOkModel;
keyObj.successCount = (keyObj.successCount || 0) + 1;
saveSettings();
renderKeyList();
if (data.tested === 1) {
toast(`✅ 「${keyObj.name}」最强可用：${firstOkModel}（一发入魂 · ${data.totalMs}ms）`, 4000);
} else {
toast(`✅ 「${keyObj.name}」最强可用：${firstOkModel}（试了 ${data.tested} 个 · ${data.totalMs}ms）`, 5000);
}
}
} catch (e) {
keyObj.failCount = (keyObj.failCount || 0) + 1;
keyObj.lastError = String(e.message || e);
saveSettings();
renderKeyList();
toast(`❌ 探测失败：${e.message}`, 4000);
} finally {
btnSpin(`.key-probe[data-idx="${findIdxByKey(keyObj)}"]`, false);
}
}
// 拉取账号 session 信息
async function fetchSessionInfo(keyObj) {
const provider = settings.provider;
const idx = findIdxByKey(keyObj);
btnSpin(`.key-session[data-idx="${idx}"]`, true);
btnSpin(`.dash-session[data-idx="${idx}"]`, true);
// ===== 智谱：查资源信息 =====
if (provider === 'zhipu') {
toast(`正在查询「${keyObj.name}」资源信息...`);
try {
const resp = await fetch('https://open.bigmodel.cn/api/monitor/usage/quota/limit', {
method: 'GET',
headers: { 'Authorization': `Bearer ${keyObj.key}` },
signal: AbortSignal.timeout(10000)
});
const data = await resp.json();
if (data.success && data.data) {
const q = data.data;
const planTxt = q.totalQuota ? `总量${(q.totalQuota/10000).toFixed(1)}万` : '按量';
keyObj.sessionInfo = {
planType: planTxt,
email: q.userName || '',
name: q.userCode || '',
expires: q.quotaExpireTime ? new Date(q.quotaExpireTime).toISOString().slice(0,10) : '',
fetchedAt: Date.now()
};
saveSettings();
renderKeyList();
renderDash();
const remainTxt = q.remainingQuota != null ? ` · 剩余${(q.remainingQuota/10000).toFixed(1)}万tokens` : '';
toast(`💎 ${keyObj.name}：${planTxt}${remainTxt}`, 5000);
} else {
keyObj.sessionInfo = { planType: '智谱 API', email: '有效', name: keyObj.name, fetchedAt: Date.now() };
saveSettings();
renderKeyList();
renderDash();
toast(`🔑 ${keyObj.name}：Key 有效（暂无资源详情权限）`, 4500);
}
} catch (e) {
toast(`ℹ️ ${keyObj.name}：Key已添加，直接发送即可（${e.message || '资源查询需管理权限'}）`, 5000);
} finally {
const i2 = findIdxByKey(keyObj);
btnSpin(`.key-session[data-idx="${i2}"]`, false);
btnSpin(`.dash-session[data-idx="${i2}"]`, false);
}
return;
}
// ===== ChatGPT：走中继/worker /session =====
toast(`正在拉取「${keyObj.name}」账号信息...`);
try {
const base = apiBase();
const headers = { 'X-Account-Token': keyObj.key };
if (!RELAY_OK) headers['Authorization'] = `Bearer ${DEPLOY_KEY}`;
const resp = await fetch(base + '/session', { method: 'GET', headers });
const data = await resp.json();
if (!resp.ok) throw new Error(data.error || `HTTP ${resp.status}`);
if (data.error) throw new Error(data.error);
keyObj.sessionInfo = {
planType: data.planType || 'free',
email: data.email,
name: data.name,
expires: data.expires,
fetchedAt: Date.now()
};
if (data.expires) {
const expMs = Date.parse(data.expires);
if (Number.isFinite(expMs) && expMs < Date.now() + 2 * 86400_000) {
keyObj.status = 'disabled';
keyObj.lastError = 'token 即将过期（< 2 天）';
toast(`⚠️ 账号「${keyObj.name}」token 即将过期（${data.expires}）`, 5000);
}
}
saveSettings();
renderKeyList();
renderDash();
toast(`📊 ${keyObj.name}：${data.email || ''} · ${data.planType || 'free'} · 过期 ${data.expires ? data.expires.slice(0,10) : '?'}`, 5000);
} catch (e) {
toast(`❌ 拉取失败：${e.message}`, 4000);
} finally {
const i2 = findIdxByKey(keyObj);
btnSpin(`.key-session[data-idx="${i2}"]`, false);
btnSpin(`.dash-session[data-idx="${i2}"]`, false);
}
}
function findIdxByKey(keyObj) {
const ks = keysFor(settings.provider);
return ks.indexOf(keyObj);
}
// 账号仪表盘（类型 / 状态 / 账号信息 / 额度 / 恢复时间 / 成功 / 失败 / 操作）
function renderDash() {
const ks = keysFor(settings.provider);
if (ks.length === 0) {
dashBody.innerHTML = '<tr><td colspan="8" class="empty-tip">还没添加账号</td></tr>';
return;
}
dashBody.innerHTML = ks.map((k, i) => {
const status = k.status || 'ok';
const statusCell = status === 'ok'
? '<span class="tag tag-ok">正常</span>'
: status === 'limited'
? '<span class="tag tag-warn">限流</span>'
: '<span class="tag tag-bad">失效</span>';
// 类型 = 订阅 planType（未拉取过显示 ?）
const type = k.sessionInfo && k.sessionInfo.planType
? `<span class="tag tag-plan">${k.sessionInfo.planType}</span>`
: '<span class="dim">未检测</span>';
// 账号信息 = 邮箱 + 名字
const acct = k.sessionInfo
? `${escapeHtml(k.sessionInfo.email || k.sessionInfo.name || '?')}<br><span class="dim small">${escapeHtml(k.name || '')}</span>`
: `<span class="dim">未拉取</span>`;
// 额度 = 探测结果摘要（可用模型数 / 总数 + 当前模型）
const ps = k.probeSummary;
const quota = ps
? `可用 ${ps.tested === ps.totalModels ? '0' : (ps.totalModels - (ps.results.filter((r) => !r.ok).length))}/${ps.totalModels}<br><span class="dim small">当前：${escapeHtml(k.model || '?')}</span>`
: (k.probedModels && k.probedModels.length
? `可用 ${k.probedModels.length}<br><span class="dim small">当前：${escapeHtml(k.model || '?')}</span>`
: '<span class="dim">未探测</span>');
// 恢复时间
const resetCell = k.resetAt && status === 'limited'
? `<span class="dim small">${formatCountdown(k.resetAt)}</span>`
: (k.sessionInfo && k.sessionInfo.expires
? `token<br><span class="dim small">${k.sessionInfo.expires.slice(0, 10)}</span>`
: '<span class="dim">—</span>');
const ok = k.successCount || 0;
const fail = k.failCount || 0;
return `
<tr class="${status !== 'ok' ? 'row-bad' : ''}">
<td>${type}</td>
<td>${statusCell}</td>
<td>${acct}</td>
<td>${quota}</td>
<td>${resetCell}</td>
<td class="num">${ok}</td>
<td class="num">${fail}</td>
<td class="ops">
<button class="ghost-btn-mini dash-probe" data-idx="${i}" title="探测最强可用模型">🔍 探测</button>
<button class="ghost-btn-mini dash-session" data-idx="${i}" title="拉取账号信息">📊 配额</button>
<button class="ghost-btn-mini dash-reset" data-idx="${i}" title="重置状态为正常">↻ 重置</button>
<button class="ghost-btn-mini dash-del" data-idx="${i}" title="删除账号">🗑</button>
</td>
</tr>
`;
}).join('');
// 事件
dashBody.querySelectorAll('.dash-probe').forEach((b) => b.addEventListener('click', () => {
const idx = parseInt(b.dataset.idx, 10);
const k = keysFor(settings.provider)[idx];
if (k) probeOneToken(k);
}));
dashBody.querySelectorAll('.dash-session').forEach((b) => b.addEventListener('click', () => {
const idx = parseInt(b.dataset.idx, 10);
const k = keysFor(settings.provider)[idx];
if (k) fetchSessionInfo(k);
}));
dashBody.querySelectorAll('.dash-reset').forEach((b) => b.addEventListener('click', () => {
const idx = parseInt(b.dataset.idx, 10);
const k = keysFor(settings.provider)[idx];
if (!k) return;
k.status = 'ok'; k.resetAt = 0; k.lastError = '';
saveSettings(); renderKeyList(); renderDash();
toast(`已重置「${k.name}」`);
}));
dashBody.querySelectorAll('.dash-del').forEach((b) => b.addEventListener('click', () => {
const idx = parseInt(b.dataset.idx, 10);
const ks = keysFor(settings.provider);
const target = ks[idx];
if (!target) return;
if (!confirm(`删除账号「${target.name}」？`)) return;
settings.keys = settings.keys.filter((k) => k !== target);
saveSettings(); renderKeyList(); renderDash();
}));
}
function btnSpin(selector, on) {
const el = keyListEl.querySelector(selector);
if (!el) return;
if (on) { el.dataset.spin = '1'; el.style.opacity = '0.5'; }
else { delete el.dataset.spin; el.style.opacity = ''; }
}
function formatCountdown(ts) {
const sec = Math.max(0, Math.floor((ts - Date.now()) / 1000));
if (sec < 60) return sec + 's';
if (sec < 3600) return Math.floor(sec / 60) + 'm';
return Math.floor(sec / 3600) + 'h';
}
function maskKey(key) {
if (!key) return '';
if (key.length <= 10) return key.slice(0, 3) + '***';
return key.slice(0, 5) + '***' + key.slice(-4);
}
function escapeHtml(s) {
return String(s).replace(/[&<>"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
}
providerSel.addEventListener('change', () => {
settings.provider = providerSel.value;
updateProviderUI();
renderKeyList();
});
addKeyBtn.addEventListener('click', async () => {
const name = newKeyNameInput.value.trim() || `账号${keysFor(settings.provider).length + 1}`;
const key = newKeyValInput.value.trim();
if (!key) { toast('Key 不能为空'); return; }
const p = PROVIDERS[settings.provider];
const modelSel = $('newKeyModel');
const model = (modelSel && modelSel.value) || (p && p.defaultModel) || 'gpt-4o';
const newKey = { name, key, provider: settings.provider, model, addedAt: Date.now(), status: 'ok' };
settings.keys.push(newKey);
saveSettings();
newKeyNameInput.value = '';
newKeyValInput.value = '';
renderKeyList();
// ChatGPT 走探测；智谱直接可用
if (settings.provider === 'chatgpt') {
toast(`已添加「${name}」，自动探测可用模型...`);
probeOneToken(newKey);
} else if (settings.provider === 'zhipu') {
toast(`✅ 已添加「${name}」，可直接发送`);
} else {
toast(`已添加「${name}」`);
}
});
// 批量刷新所有账号：先 session 后 probe
refreshAllBtn.addEventListener('click', async () => {
const ks = keysFor(settings.provider);
if (ks.length === 0) { toast('还没添加账号'); return; }
refreshAllBtn.disabled = true;
refreshAllBtn.textContent = '⏳ 刷新中...';
try {
for (const k of ks) {
try { await fetchSessionInfo(k); } catch {}
}
for (const k of ks) {
try { await probeOneToken(k); } catch {}
}
toast(`✅ 已刷新 ${ks.length} 个账号`);
} finally {
refreshAllBtn.disabled = false;
refreshAllBtn.textContent = '🔄 全部刷新';
renderDash();
}
});
newKeyValInput.addEventListener('keydown', (e) => {
if (e.key === 'Enter') addKeyBtn.click();
});
$('settingsBtn').addEventListener('click', () => {
applySettingsToUI();
renderGirlsPanel();
settingsModal.hidden = false;
});
$('closeSettings').addEventListener('click', () => settingsModal.hidden = true);
settingsModal.querySelector('.modal-mask').addEventListener('click', () => settingsModal.hidden = true);
$('saveSettings').addEventListener('click', () => {
settings.provider = providerSel.value;
const baseUrlInput = $('baseUrl');
settings.baseUrl = baseUrlInput ? baseUrlInput.value.trim() : '';
saveSettings();
settingsModal.hidden = true;
if (keysFor(settings.provider).length === 0) {
toast('还没填 API Key，点右上角设置填一下才能用');
} else {
toast('已保存');
}
});
$('clearChat').addEventListener('click', () => {
if (!confirm('清空所有对话记录？')) return;
history = [];
persistHistory();
renderHistory();
welcomeEl.style.display = '';
settingsModal.hidden = true;
});
// 复制中继启动命令
const copyRelayBtn = $('copyRelayCmd');
if (copyRelayBtn) {
copyRelayBtn.addEventListener('click', () => {
const cmd = $('relayCmd');
if (cmd) {
navigator.clipboard.writeText(cmd.textContent).then(() => toast('已复制启动命令')).catch(() => toast('复制失败'));
}
});
}
// ---------- 渲染 ----------
function renderHistory() {
// 清掉旧消息气泡（保留 welcome）
[...messagesEl.querySelectorAll('.msg')].forEach((n) => n.remove());
if (history.length === 0) {
welcomeEl.style.display = '';
return;
}
welcomeEl.style.display = 'none';
history.forEach((m) => appendBubble(m.role, m.content, false, m.image, m.girlId));
scrollToBottom();
}
// 给某条消息节点附加女生标签（加到 bubble 内部，避免破坏横向布局）
function attachGirlTag(wrap, girlId) {
const g = girls.find((x) => x.id === girlId);
if (!g) return;
const bubble = wrap.querySelector('.bubble');
if (!bubble || bubble.querySelector('.girl-tag')) return;
const tag = document.createElement('span');
tag.className = 'girl-tag';
tag.style.color = g.color;
tag.style.borderColor = g.color;
tag.textContent = g.name;
bubble.appendChild(tag);
}
function appendBubble(role, content, animate = true, image = null, girlId = null) {
const wrap = document.createElement('div');
wrap.className = `msg ${role}`;
if (!animate) wrap.style.animation = 'none';
const av = document.createElement('div');
av.className = 'avatar-mini';
av.textContent = role === 'user' ? '你' : 'S';
const bubble = document.createElement('div');
bubble.className = 'bubble';
if (image) {
const img = document.createElement('img');
img.className = 'bubble-img';
img.src = image;
img.alt = '聊天截图';
bubble.appendChild(img);
}
if (content) {
const txt = document.createElement('div');
txt.textContent = content;
bubble.appendChild(txt);
}
// 女生头像边框色（仅 bot）
if (role === 'bot' && girlId) {
const g = girls.find((x) => x.id === girlId);
if (g) av.style.borderColor = g.color;
}
wrap.appendChild(av);
wrap.appendChild(bubble);
if (girlId) attachGirlTag(wrap, girlId);
messagesEl.appendChild(wrap);
scrollToBottom();
return bubble;
}
function scrollToBottom() {
requestAnimationFrame(() => {
messagesEl.scrollTop = messagesEl.scrollHeight;
});
}
function toast(msg, ms) {
const t = document.createElement('div');
t.textContent = msg;
t.style.cssText = 'position:fixed;left:50%;bottom:calc(env(safe-area-inset-bottom, 0px) + 80px);transform:translateX(-50%);background:#333;color:#fff;padding:10px 16px;border-radius:20px;font-size:13px;z-index:100;opacity:0;transition:opacity .2s;max-width:90vw;text-align:center;line-height:1.5;';
document.body.appendChild(t);
requestAnimationFrame(() => t.style.opacity = '1');
setTimeout(() => { t.style.opacity = '0'; setTimeout(() => t.remove(), 300); }, ms || 1800);
}
// ---------- 输入框自适应高度 ----------
inputEl.addEventListener('input', () => {
inputEl.style.height = 'auto';
inputEl.style.height = Math.min(inputEl.scrollHeight, 120) + 'px';
});
inputEl.addEventListener('keydown', (e) => {
// 桌面端 Enter 发送，移动端回车换行（默认行为）
if (e.key === 'Enter' && !e.shiftKey && window.matchMedia('(min-width: 600px)').matches) {
e.preventDefault();
send();
}
});
sendBtn.addEventListener('click', send);
// 推荐问题
document.querySelectorAll('.chip').forEach((chip) => {
chip.addEventListener('click', () => {
inputEl.value = chip.dataset.q;
inputEl.dispatchEvent(new Event('input'));
send();
});
});
// ---------- 图片上传 ----------
const imgBtn = $('imgBtn');
const imgInput = $('imgInput');
const imgPreview = $('imgPreview');
function handleImageFile(file) {
if (!file) return;
if (!file.type.startsWith('image/')) { toast('只能发图片'); return; }
if (file.size > 4 * 1024 * 1024) { toast('图片太大，请小于 4MB'); return; }
const reader = new FileReader();
reader.onload = () => {
pendingImage = reader.result;
imgPreview.innerHTML = '';
const im = document.createElement('img');
im.src = pendingImage;
const rm = document.createElement('button');
rm.className = 'img-preview-rm';
rm.innerHTML = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2.5"><path d="M18 6L6 18M6 6l12 12"/></svg>';
rm.addEventListener('click', clearImagePreview);
imgPreview.appendChild(im);
imgPreview.appendChild(rm);
imgPreview.style.display = 'flex';
};
reader.readAsDataURL(file);
}
function clearImagePreview() {
pendingImage = null;
imgPreview.innerHTML = '';
imgPreview.style.display = 'none';
imgInput.value = '';
}
if (imgBtn) {
imgBtn.addEventListener('click', () => imgInput.click());
imgInput.addEventListener('change', () => handleImageFile(imgInput.files[0]));
}
// 支持粘贴图片
document.addEventListener('paste', (e) => {
const items = e.clipboardData?.items || [];
for (const it of items) {
if (it.type.startsWith('image/')) { handleImageFile(it.getAsFile()); break; }
}
});
// ---------- 女生档案面板 ----------
const girlsListEl = $('girlsList');
function renderGirlsPanel() {
if (!girlsListEl) return;
if (girls.length === 0) {
girlsListEl.innerHTML = '<p class="hint">还没有记录任何女生。发张聊天截图或贴段资料，会自动建档。</p>';
return;
}
girlsListEl.innerHTML = girls.map((g) => {
const last = g.lastSeen ? new Date(g.lastSeen).toLocaleString('zh-CN', { month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit' }) : '无';
return `
<div class="girl-item" data-id="${g.id}">
<span class="girl-dot" style="background:${g.color}"></span>
<div class="girl-info">
<div class="girl-name">${escapeHtml(g.name)} <span class="girl-emotion">${escapeHtml(g.emotion || '')}</span></div>
<div class="girl-meta">最后互动：${last}</div>
</div>
<button class="girl-del" data-id="${g.id}" aria-label="删除档案">
<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6m5 0V4a2 2 0 0 1 2-2h0a2 2 0 0 1 2 2v2"/></svg>
</button>
</div>
`;
}).join('');
girlsListEl.querySelectorAll('.girl-del').forEach((btn) => {
btn.addEventListener('click', () => {
const id = btn.dataset.id;
deleteGirl(id);
renderGirlsPanel();
toast('已删除该女生档案');
});
});
}
// ---------- 发送 ----------
// 构造女生档案上下文（注入系统提示词）
function buildGirlsContext() {
if (girls.length === 0) {
return '\n\n## 女生档案系统\n\n当前还没有记录任何女生。用户这次发来的可能是新女生。';
}
const list = girls.map((g, i) => {
const last = g.lastSeen ? new Date(g.lastSeen).toLocaleString('zh-CN', { month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit' }) : '无';
return `${i + 1}. ${g.name} | 情绪：${g.emotion || '未知'} | 资料：${g.profile || '暂无'} | 最后互动：${last}`;
}).join('\n');
return `\n\n## 女生档案系统\n\n当前已记录的女生：\n${list}\n\n用户这次发来的可能是上面某个女生的消息/截图，也可能是新女生。你必须在回复最开头标注一行：\n[女生: 名字] [情绪: 这次消息反映的情绪]\n- 名字：能匹配到已记录的女生就用她的原名；新女生根据截图顶部名字或资料给她起个昵称\n- 情绪：根据这次消息判断她当前情绪状态（简短，如“有点累，求关注”“热情主动”“冷淡敷衍”）\n标注完这一行后再空一行，接着按正常输出格式回复。`;
}
// 从 AI 回复开头解析 [女生: x] [情绪: y] 标签
function parseGirlTags(text) {
const m = text.match(/^\s*\[女生[:：]\s*([^\]]+)\]\s*\[情绪[:：]\s*([^\]]+)\]/);
if (!m) return { name: '', emotion: '', clean: text };
const name = m[1].trim();
const emotion = m[2].trim();
const clean = text.slice(m[0].length).replace(/^\s+/, '');
return { name, emotion, clean };
}
async function send() {
const text = inputEl.value.trim();
const image = pendingImage;
if ((!text && !image) || isStreaming) return;
const p = PROVIDERS[settings.provider];
// CHATSAM 等免 key 平台直接放行
const noKeyNeeded = p && p.noKeyRequired;
if (!noKeyNeeded && keysFor(settings.provider).length === 0) {
toast('先点右上角设置，填 API Key');
settingsModal.hidden = false;
return;
}
// 有图片：确保用支持视觉的 token
if (image) {
// CHATSAM 默认 gpt-4o 支持视觉，智谱需 glm-4v
if (noKeyNeeded) {
// CHATSAM 默认 gpt-4o，支持视觉
} else {
const hasVision = keysFor(settings.provider).some((k) => {
const m = k.model || (p && p.defaultModel) || 'gpt-4o';
return /^gpt-4|^o[13]|^glm-4v/i.test(m);
});
if (!hasVision) {
toast('请至少添加一个 gpt-4o/gpt-4.1/o1/o3/glm-4v 的 token 识别图片');
return;
}
}
}
welcomeEl.style.display = 'none';
// 用户气泡（带图片预览）
appendBubble('user', text || '（截图）', true, image);
history.push({ role: 'user', content: text, image: image || undefined });
inputEl.value = '';
inputEl.style.height = 'auto';
clearImagePreview();
persistHistory();
// 创建机器人气泡用于流式填充
const bubble = appendBubble('bot', '');
bubble.classList.add('streaming');
isStreaming = true;
sendBtn.disabled = true;
// 确保 Skill 已加载
if (!SKILL_READY) { await loadSkill(); }
// 构造消息：系统提示 = SKILL + 女生档案上下文
const sysContent = (SKILL_PROMPT || '你是一个有用的助手。') + buildGirlsContext();
const msgs = [{ role: 'system', content: sysContent }];
for (const m of history) {
const role = m.role === 'bot' ? 'assistant' : 'user';
// 历史消息里的图片：只保留最近这一条带图，更早的图不带（content 里已有文字占位）
if (m.image && m === history[history.length - 1]) {
// 当前最新用户消息：构造多模态 content
const parts = [];
if (m.content) parts.push({ type: 'text', text: m.content });
parts.push({ type: 'image_url', image_url: { url: m.image } });
msgs.push({ role, content: parts });
} else {
msgs.push({ role, content: m.content || '' });
}
}
try {
const full = await streamChatWithRetry(msgs, (delta) => {
bubble.textContent += delta;
scrollToBottom();
});
// 解析女生标签
const { name, emotion, clean } = parseGirlTags(full);
let displayText = full;
let girlId = null;
if (name) {
let g = findGirlByName(name);
if (!g) g = addGirl(name, { emotion });
else touchGirl(g.id, emotion);
girlId = g.id;
displayText = clean;
renderGirlsPanel();
}
bubble.classList.remove('streaming');
bubble.textContent = displayText;
// 给气泡加女生标签
if (girlId) attachGirlTag(bubble.parentElement, girlId);
history.push({ role: 'bot', content: displayText, girlId });
persistHistory();
} catch (err) {
bubble.classList.remove('streaming');
bubble.parentElement.classList.add('error');
bubble.textContent = '出错了：' + (err.message || err);
} finally {
isStreaming = false;
sendBtn.disabled = false;
}
}
// ---------- 多 Key 轮询调用（每个 token 自带 model） ----------
// 失败（401/403/429/5xx）时换下一个 Key；所有 Key 失败后抛出
async function streamChatWithRetry(messages, onDelta) {
const provider = settings.provider;
const p = PROVIDERS[provider];
if (!p) throw new Error('未知的模型服务商');
// CHATSAM 等免 key 平台：直接调用，不走轮询
if (p.noKeyRequired) {
try {
const res = await streamChat(p, 'use-pool', messages, onDelta, p.defaultModel, provider);
return res;
} catch (err) {
throw err;
}
}
const ks = keysFor(provider);
if (ks.length === 0) {
if (provider === 'chatgpt') {
throw new Error('你还没添加 ChatGPT access_token（eyJ... 开头的 JWT）。不会抓的话，建议直接切到 🪙 CHATSAM 免Key 或 🧠 智谱 GLM，打开就能用');
}
throw new Error('该平台没有配置 API Key');
}
let lastErr = null;
for (let attempt = 0; attempt < ks.length; attempt++) {
const keyObj = nextKey(provider);
if (!keyObj) break;
let useModel = keyObj.model || (p && p.defaultModel) || 'gpt-4o';
// 智谱模型轮调：如果选择 auto，自动选择余额充足的模型
if (provider === 'zhipu' && useModel === 'auto') {
useModel = getRecommendedZhipuModel();
}
try {
const res = await streamChat(p, keyObj.key, messages, onDelta, useModel, provider);
markTokenOk(provider, keyObj);
return res;
} catch (err) {
lastErr = err;
const msg = String(err.message || err);
// 智谱：只有真实返回 401/403/429 且是 HTTP 状态码才打标；
// "Failed to fetch" / 网络错误 / CORS 问题 / 流式中断 等 不打标，让用户重试
const isNetworkErr = /failed to fetch|load failed|networkerror|abort|timeout|interrupted|chunk|stream/i.test(msg)
|| /undefined|TypeError|NetworkError/i.test(msg)
|| msg.length < 20; // 短错误一般不是 HTTP 错误
const shouldRetry = provider === 'zhipu'
? (!isNetworkErr && /(401|403|429|访问量过大|稍后再试|quota.?exceeded|insufficient|invalid.?api.?key)/i.test(msg))
: /401|403|429|rate.?limit|quota|insufficient|unauthorized|invalid.*key|1305|访问量过大|稍后再试/i.test(msg);
if (shouldRetry) {
const status = /401|403|unauthorized|invalid/i.test(msg) ? 'disabled' : 'limited';
const resetAt = status === 'limited' ? Date.now() + 60_000 : 0;
markTokenFail(provider, keyObj, status, resetAt, msg);
} else if (!isNetworkErr) {
// ChatGPT 404：旧版 Worker 缺 /v1/chat/completions 端点
if (provider === 'chatgpt' && /404/i.test(msg)) {
throw new Error(`ChatGPT 后端未就绪：${msg}。Worker 缺 /v1/chat/completions 端点，请切到 🪙 CHATSAM 免Key 或 🧠 智谱 GLM，或提供 CLOUDFLARE_API_TOKEN 重部署 Worker`);
}
// 非网络类错误，也非限流/鉴权，直接抛出给用户看（比如内容审核/参数错误）
throw err;
}
// 网络错误或可重试：最后一次尝试才抛，否则内部尝试下一个 key
if (attempt < ks.length - 1) {
const errShort = status ? `(${status})` : '(网络)';
toast(`「${keyObj.name}」${useModel} 重试中${errShort}...`);
}
}
}
// ChatGPT：/v1/chat/completions 404 → 换成友好提示
if (provider === 'chatgpt' && lastErr && /404/i.test(String(lastErr.message || lastErr))) {
throw new Error('ChatGPT 后端 Worker（jc-skill-gpt）未包含 /v1/chat/completions 端点，返回 404。请切到 🪙 CHATSAM 免Key（推荐）或 🧠 智谱 GLM 立即使用；如需启用 ChatGPT 请提供 CLOUDFLARE_API_TOKEN 重新部署。');
}
throw lastErr || new Error('所有账号都失败了');
}
function markTokenOk(provider, keyObj) {
const k = settings.keys.find((x) => x.provider === provider && x.key === keyObj.key && x.name === keyObj.name);
if (!k) return;
k.status = 'ok';
k.resetAt = 0;
k.failCount = 0;
k.lastUsedAt = Date.now();
k.lastError = '';
k.successCount = (k.successCount || 0) + 1;
saveSettings();
renderKeyList();
}
function markTokenFail(provider, keyObj, status, resetAt, errMsg) {
const k = settings.keys.find((x) => x.provider === provider && x.key === keyObj.key && x.name === keyObj.name);
if (!k) return;
k.status = status;
k.resetAt = resetAt;
k.failCount = (k.failCount || 0) + 1;
k.lastUsedAt = Date.now();
k.lastError = (errMsg || '').slice(0, 80);
saveSettings();
renderKeyList();
}
// ---------- 调用 OpenAI 兼容接口（流式） ----------
async function streamChat(p, apiKey, messages, onDelta, modelOverride, provider) {
// 智谱：真实 API 不认 "auto" / gpt-4o 等模型，必须选一个智谱真实存在的模型（glm-4-flash/air/plus）
// 兜底时防递归：第2次调用不要再兜底
const _fallbackDepth = (p && p._d) || 0;
let model = modelOverride || (p && p.defaultModel) || 'gpt-4o';
if (provider === 'zhipu') {
// 不是智谱3个真实模型就选推荐的（余额充足的）
if (!/^glm-4-(flash|air|plus)$/i.test(model)) {
model = getRecommendedZhipuModel(); // 真实模型：glm-4-flash / air / plus
}
}
// 根据提供商选择端点
let base, headers, endpoint;
if (provider === 'zhipu') {
// 智谱 AI 直连
base = 'https://open.bigmodel.cn/api/paas/v4';
headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` };
endpoint = '/chat/completions'; // 智谱端点
} else if (provider === 'chatsam') {
// CHATSAM：chatgpt2api 后端（号池内置），使用 chatSamApiKey 做 Authorization Bearer；失败才走智谱兜底
base = PROVIDERS.chatsam.baseUrl;
const authKey = (apiKey && apiKey !== 'use-pool' && apiKey !== PROVIDERS.chatsam.fallbackAuthKey)
? apiKey
: (PROVIDERS.chatsam.chatSamApiKey || PROVIDERS.chatsam.fallbackAuthKey);
headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${authKey}` };
endpoint = '/v1/chat/completions';
} else {
// ChatGPT：走本地中继或 Worker
base = apiBase();
headers = { 'Content-Type': 'application/json', 'X-Account-Token': apiKey };
if (!RELAY_OK) headers['Authorization'] = `Bearer ${DEPLOY_KEY}`;
endpoint = '/v1/chat/completions';
}
// AbortController 超时：45秒没完成就算了，避免页面假死
const ctrl = new AbortController();
const timeoutId = setTimeout(() => ctrl.abort(new Error('请求超时 (45s)，请稍后重试')), 45_000);
let lastUsage = null;
let okHeaderChecked = false;
try {
const res = await fetch(base + endpoint, {
method: 'POST',
headers,
signal: ctrl.signal,
body: JSON.stringify({
model,
messages,
stream: true,
temperature: provider === 'zhipu' ? 0.7 : 0.85
})
});
clearTimeout(timeoutId);
okHeaderChecked = true;
if (!res.ok) {
let detail = '';
try {
const jsonErr = (await res.json())?.error;
detail = jsonErr?.message || jsonErr || '';
} catch {}
// CHATSAM：任何非2xx 都降级智谱兜底（深度≥1时不再兜底，防递归）
if (provider === 'chatsam' && _fallbackDepth < 1) {
toast(`CHATSAM 暂不可用（${res.status}），自动切换到智谱兜底`, 3000);
const fbk = PROVIDERS.zhipu; fbk._d = 1;
return await streamChat(fbk, PROVIDERS.chatsam.fallbackAuthKey || BUILTIN_KEYS[0]?.key, messages, onDelta, getRecommendedZhipuModel(), 'zhipu');
}
throw new Error(`${res.status} ${res.statusText}${detail ? '：' + detail : ''}`);
}
const reader = res.body.getReader();
const decoder = new TextDecoder('utf-8');
let buffer = '';
let full = '';
while (true) {
const { done, value } = await reader.read();
if (done) break;
buffer += decoder.decode(value, { stream: true });
const lines = buffer.split('\n');
buffer = lines.pop() || '';
for (const line of lines) {
const trimmed = line.trim();
if (!trimmed || !trimmed.startsWith('data:')) continue;
const data = trimmed.slice(5).trim();
if (data === '[DONE]') {
if (provider === 'zhipu' && lastUsage) {
updateModelTokens(model, lastUsage.total_tokens || 0);
}
return full;
}
try {
const json = JSON.parse(data);
const delta = json.choices?.[0]?.delta?.content || '';
if (delta) { full += delta; onDelta(delta); }
if (json.usage) lastUsage = json.usage;
} catch { /* 忽略解析错误的中间分片 */ }
}
}
if (provider === 'zhipu' && lastUsage) {
updateModelTokens(model, lastUsage.total_tokens || 0);
}
return full;
} catch (err) {
clearTimeout(timeoutId);
// CHATSAM 任何失败都透明切智谱兜底（深度≥1时不再兜底防递归）
const msg = String(err.message || err);
if (provider === 'chatsam' && _fallbackDepth < 1) {
toast(`CHATSAM 请求失败（${msg.slice(0, 30)}），自动切智谱`, 3500);
const fbk = PROVIDERS.zhipu; fbk._d = 1;
return await streamChat(fbk, PROVIDERS.chatsam.fallbackAuthKey || BUILTIN_KEYS[0]?.key, messages, onDelta, getRecommendedZhipuModel(), 'zhipu');
}
throw err;
}
}
// ---------- Service Worker ----------
if ('serviceWorker' in navigator) {
window.addEventListener('load', () => {
navigator.serviceWorker.register('./sw.js').catch(() => {});
});
}
// ---------- 加载 Skill（ROLE.md 使用指南 + 原作者 SKILL.md 角色素材）----------
let SKILL_PROMPT = '';
let SKILL_READY = false;
// 去掉 Markdown 开头的 YAML frontmatter（--- ... --- 块）
function stripFrontmatter(text) {
return text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '').trim();
}
async function fetchMd(path) {
// 加时间戳绕过 HuggingFace CDN 缓存，确保加载最新 SKILL.md
const url = path + (path.includes('?') ? '&' : '?') + 'v=' + Date.now();
const res = await fetch(url, { cache: 'no-store' });
if (!res.ok) throw new Error(path + ' HTTP ' + res.status);
return stripFrontmatter(await res.text());
}
async function loadSkill() {
try {
// ROLE.md（用户自定义使用指南）在前，SKILL.md（原作者角色素材）在后
const [role, skill] = await Promise.all([
fetchMd('./ROLE.md').catch(() => ''),
fetchMd('./SKILL.md').catch(() => '')
]);
const parts = [];
if (role) parts.push(role);
if (skill) parts.push('---\n\n# 角色素材补充\n\n' + skill);
SKILL_PROMPT = parts.join('\n\n') || '你是一个有用的助手。';
SKILL_READY = true;
} catch (e) {
console.warn('Skill 加载失败:', e);
SKILL_PROMPT = '你是一个有用的助手。';
SKILL_READY = true;
}
}
// ---------- 启动 ----------
checkRelay().then(() => {
if (RELAY_OK) toast('本地中继已连接 (localhost:8765)', 3000);
});
setInterval(checkRelay, 15000); // 每 15 秒检测一次中继状态
loadSkill();
cleanStaleGirls(); // 启动时自动清理超过 5 个月没互动的女生档案
applySettingsToUI();
renderHistory();
renderGirlsPanel();
// 启动提示：免 key 平台直接可用，其他需配置
const _p = PROVIDERS[settings.provider];
if (_p && _p.noKeyRequired) {
setTimeout(() => toast('✅ CHATSAM 已就绪，直接发送即可'), 600);
} else if (keysFor(settings.provider).length === 0) {
setTimeout(() => toast('点右上角设置，填 API Key 开始用'), 600);
}