mirror of
https://github.com/router-for-me/Cli-Proxy-API-Management-Center.git
synced 2026-02-03 11:20:50 +08:00
1605 lines
62 KiB
JavaScript
1605 lines
62 KiB
JavaScript
export const authFilesModule = {
|
|
// 加载认证文件
|
|
async loadAuthFiles(keyStats = null) {
|
|
try {
|
|
const data = await this.makeRequest('/auth-files');
|
|
if (!keyStats) {
|
|
keyStats = await this.getKeyStats();
|
|
}
|
|
await this.renderAuthFiles(data.files || [], keyStats);
|
|
} catch (error) {
|
|
console.error('加载认证文件失败:', error);
|
|
}
|
|
},
|
|
|
|
// 渲染认证文件列表
|
|
async renderAuthFiles(files, keyStats = null) {
|
|
const container = document.getElementById('auth-files-list');
|
|
if (!container) {
|
|
return;
|
|
}
|
|
|
|
const allFiles = Array.isArray(files) ? files : [];
|
|
const visibleFiles = allFiles.filter(file => {
|
|
if (!file) return false;
|
|
return this.shouldDisplayDisabledGeminiCli(file) || file.disabled !== true;
|
|
});
|
|
const stats = keyStats || await this.getKeyStats();
|
|
|
|
this.cachedAuthFiles = visibleFiles.map(file => ({ ...file }));
|
|
this.authFileStatsCache = stats || { bySource: {}, byAuthIndex: {} };
|
|
this.syncAuthFileControls();
|
|
|
|
if (this.cachedAuthFiles.length === 0) {
|
|
container.innerHTML = `
|
|
<div class="empty-state">
|
|
<i class="fas fa-file-alt"></i>
|
|
<h3>${i18n.t('auth_files.empty_title')}</h3>
|
|
<p>${i18n.t('auth_files.empty_desc')}</p>
|
|
</div>
|
|
`;
|
|
this.updateFilterButtons(new Set(['all']));
|
|
this.bindAuthFileFilterEvents();
|
|
this.applyAuthFileFilterState(false);
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.authFilesPagination.totalPages = 1;
|
|
this.updatePaginationControls(0);
|
|
return;
|
|
}
|
|
|
|
const existingTypes = new Set(['all']);
|
|
this.cachedAuthFiles.forEach(file => {
|
|
if (file.type) {
|
|
existingTypes.add(file.type);
|
|
}
|
|
});
|
|
|
|
this.updateFilterButtons(existingTypes);
|
|
this.bindAuthFileFilterEvents();
|
|
this.applyAuthFileFilterState(false);
|
|
this.renderAuthFilesPage(this.authFilesPagination.currentPage);
|
|
this.bindAuthFileActionEvents();
|
|
},
|
|
|
|
isRuntimeOnlyAuthFile(file) {
|
|
if (!file) return false;
|
|
const runtimeValue = file.runtime_only;
|
|
return runtimeValue === true || runtimeValue === 'true';
|
|
},
|
|
|
|
shouldDisplayDisabledGeminiCli(file) {
|
|
if (!file) return false;
|
|
const provider = typeof file.provider === 'string' ? file.provider.toLowerCase() : '';
|
|
const type = typeof file.type === 'string' ? file.type.toLowerCase() : '';
|
|
const isGeminiCli = provider === 'gemini-cli' || type === 'gemini-cli';
|
|
return isGeminiCli && !this.isRuntimeOnlyAuthFile(file);
|
|
},
|
|
|
|
resolveAuthFileStats(file, stats = {}) {
|
|
const statsBySource = (stats && stats.bySource) || stats || {};
|
|
const statsByAuthIndex = (stats && stats.byAuthIndex) || {};
|
|
const rawFileName = typeof file?.name === 'string' ? file.name : '';
|
|
const defaultStats = { success: 0, failure: 0 };
|
|
const authIndexKey = this.normalizeAuthIndexValue(file?.auth_index);
|
|
|
|
if (authIndexKey && statsByAuthIndex[authIndexKey]) {
|
|
return statsByAuthIndex[authIndexKey];
|
|
}
|
|
|
|
if (!rawFileName) {
|
|
return defaultStats;
|
|
}
|
|
|
|
const fromName = statsBySource[rawFileName];
|
|
if (fromName && (fromName.success > 0 || fromName.failure > 0)) {
|
|
return fromName;
|
|
}
|
|
|
|
let fileStats = fromName || defaultStats;
|
|
if (fileStats.success === 0 && fileStats.failure === 0) {
|
|
const nameWithoutExt = rawFileName.replace(/\.[^/.]+$/, "");
|
|
|
|
if (nameWithoutExt && nameWithoutExt !== rawFileName) {
|
|
const candidateNames = new Set([nameWithoutExt]);
|
|
const normalizedName = nameWithoutExt.toLowerCase();
|
|
const typePrefix = typeof file?.type === 'string' ? file.type.trim().toLowerCase() : '';
|
|
const providerPrefix = typeof file?.provider === 'string' ? file.provider.trim().toLowerCase() : '';
|
|
const prefixList = [];
|
|
|
|
if (typePrefix) {
|
|
prefixList.push(`${typePrefix}-`);
|
|
}
|
|
if (providerPrefix && providerPrefix !== typePrefix) {
|
|
prefixList.push(`${providerPrefix}-`);
|
|
}
|
|
|
|
prefixList.forEach(prefix => {
|
|
if (prefix && normalizedName.startsWith(prefix)) {
|
|
const trimmed = nameWithoutExt.substring(prefix.length);
|
|
if (trimmed) {
|
|
candidateNames.add(trimmed);
|
|
}
|
|
}
|
|
});
|
|
|
|
for (const candidate of candidateNames) {
|
|
const candidateStats = statsBySource[candidate];
|
|
if (candidateStats && (candidateStats.success > 0 || candidateStats.failure > 0)) {
|
|
fileStats = candidateStats;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return fileStats || defaultStats;
|
|
},
|
|
|
|
normalizeAuthIndexValue(value) {
|
|
if (typeof value === 'number' && Number.isFinite(value)) {
|
|
return value.toString();
|
|
}
|
|
if (typeof value === 'string') {
|
|
const trimmed = value.trim();
|
|
return trimmed ? trimmed : null;
|
|
}
|
|
return null;
|
|
},
|
|
|
|
buildAuthFileItemHtml(file) {
|
|
const rawFileName = typeof file?.name === 'string' ? file.name : '';
|
|
const safeFileName = this.escapeHtml(rawFileName);
|
|
const stats = this.authFileStatsCache || {};
|
|
const fileStats = this.resolveAuthFileStats(file, stats);
|
|
const fileType = file.type || 'unknown';
|
|
let typeDisplayKey;
|
|
switch (fileType) {
|
|
case 'qwen':
|
|
typeDisplayKey = 'auth_files.type_qwen';
|
|
break;
|
|
case 'gemini':
|
|
typeDisplayKey = 'auth_files.type_gemini';
|
|
break;
|
|
case 'gemini-cli':
|
|
typeDisplayKey = 'auth_files.type_gemini-cli';
|
|
break;
|
|
case 'aistudio':
|
|
typeDisplayKey = 'auth_files.type_aistudio';
|
|
break;
|
|
case 'claude':
|
|
typeDisplayKey = 'auth_files.type_claude';
|
|
break;
|
|
case 'codex':
|
|
typeDisplayKey = 'auth_files.type_codex';
|
|
break;
|
|
case 'antigravity':
|
|
typeDisplayKey = 'auth_files.type_antigravity';
|
|
break;
|
|
case 'iflow':
|
|
typeDisplayKey = 'auth_files.type_iflow';
|
|
break;
|
|
case 'vertex':
|
|
typeDisplayKey = 'auth_files.type_vertex';
|
|
break;
|
|
case 'empty':
|
|
typeDisplayKey = 'auth_files.type_empty';
|
|
break;
|
|
default:
|
|
typeDisplayKey = 'auth_files.type_unknown';
|
|
break;
|
|
}
|
|
const typeBadge = `<span class="file-type-badge ${fileType}">${i18n.t(typeDisplayKey)}</span>`;
|
|
const isRuntimeOnly = this.isRuntimeOnlyAuthFile(file);
|
|
const shouldShowMainFlag = this.shouldDisplayDisabledGeminiCli(file);
|
|
const mainFlagButton = shouldShowMainFlag ? `
|
|
<button class="btn-small btn-warning main-flag-btn" title="主" disabled>主</button>` : '';
|
|
const actionsHtml = isRuntimeOnly ? `
|
|
<div class="item-actions">
|
|
<span class="virtual-auth-badge">虚拟认证文件</span>
|
|
</div>` : `
|
|
<div class="item-actions" data-filename="${safeFileName}">
|
|
${mainFlagButton}
|
|
<button class="btn-small btn-info" data-action="showDetails" title="详细信息">
|
|
<i class="fas fa-info-circle"></i>
|
|
</button>
|
|
<button class="btn-small btn-primary" data-action="download" title="下载">
|
|
<i class="fas fa-download"></i>
|
|
</button>
|
|
<button class="btn-small btn-danger" data-action="delete" title="删除">
|
|
<i class="fas fa-trash"></i>
|
|
</button>
|
|
</div>`;
|
|
|
|
return `
|
|
<div class="file-item" data-file-type="${fileType}" data-file-name="${safeFileName}" ${isRuntimeOnly ? 'data-runtime-only="true"' : ''}>
|
|
<div class="item-content">
|
|
<div class="item-title">${typeBadge}${safeFileName}</div>
|
|
<div class="item-meta">
|
|
<span class="item-subtitle">${i18n.t('auth_files.file_modified')}: ${new Date(file.modtime).toLocaleString(i18n.currentLanguage === 'zh-CN' ? 'zh-CN' : 'en-US')}</span>
|
|
<span class="item-subtitle">${i18n.t('auth_files.file_size')}: ${this.formatFileSize(file.size)}</span>
|
|
</div>
|
|
<div class="item-footer">
|
|
<div class="item-stats">
|
|
<span class="stat-badge stat-success">
|
|
<i class="fas fa-check-circle"></i> ${i18n.t('stats.success')}: ${fileStats.success}
|
|
</span>
|
|
<span class="stat-badge stat-failure">
|
|
<i class="fas fa-times-circle"></i> ${i18n.t('stats.failure')}: ${fileStats.failure}
|
|
</span>
|
|
</div>
|
|
${actionsHtml}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
`;
|
|
},
|
|
|
|
getFilteredAuthFiles(filterType = this.currentAuthFileFilter) {
|
|
const files = Array.isArray(this.cachedAuthFiles) ? this.cachedAuthFiles : [];
|
|
if (!files.length) {
|
|
return [];
|
|
}
|
|
|
|
const typeFilter = (filterType || 'all').toLowerCase();
|
|
const keyword = (this.authFileSearchQuery || '').trim().toLowerCase();
|
|
|
|
return files.filter(file => {
|
|
const name = String(file?.name || '').toLowerCase();
|
|
const type = String(file?.type || '').toLowerCase();
|
|
const provider = String(file?.provider || '').toLowerCase();
|
|
|
|
if (typeFilter !== 'all') {
|
|
if (!type) return false;
|
|
if (type !== typeFilter) {
|
|
if (!provider || provider !== typeFilter) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!keyword) return true;
|
|
return name.includes(keyword) || type.includes(keyword) || provider.includes(keyword);
|
|
});
|
|
},
|
|
|
|
updateAuthFileSearchQuery(value = '') {
|
|
const normalized = (value || '').trim();
|
|
if (this.authFileSearchQuery === normalized) {
|
|
return;
|
|
}
|
|
this.authFileSearchQuery = normalized;
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.renderAuthFilesPage(1);
|
|
},
|
|
|
|
updateAuthFilesPageSize(value) {
|
|
const normalized = this.normalizeAuthFilesPageSize(value);
|
|
if (this.authFilesPagination?.pageSize === normalized) {
|
|
this.syncAuthFileControls();
|
|
return;
|
|
}
|
|
this.authFilesPagination.pageSize = normalized;
|
|
this.authFilesPagination.currentPage = 1;
|
|
try {
|
|
localStorage.setItem(this.authFilesPageSizeKey, `${normalized}`);
|
|
} catch (error) {
|
|
console.warn('Failed to persist auth files page size:', error);
|
|
}
|
|
this.syncAuthFileControls();
|
|
this.renderAuthFilesPage(1);
|
|
},
|
|
|
|
syncAuthFileControls() {
|
|
const searchInput = document.getElementById('auth-files-search-input');
|
|
if (searchInput && searchInput.value !== this.authFileSearchQuery) {
|
|
searchInput.value = this.authFileSearchQuery;
|
|
}
|
|
|
|
const pageSizeInput = document.getElementById('auth-files-page-size-input');
|
|
const targetSize = this.authFilesPagination?.pageSize || 9;
|
|
if (pageSizeInput && parseInt(pageSizeInput.value, 10) !== targetSize) {
|
|
pageSizeInput.value = targetSize;
|
|
}
|
|
},
|
|
|
|
bindAuthFilesSearchControl() {
|
|
const searchInput = document.getElementById('auth-files-search-input');
|
|
if (!searchInput) return;
|
|
|
|
if (searchInput._authFileSearchListener) {
|
|
searchInput.removeEventListener('input', searchInput._authFileSearchListener);
|
|
}
|
|
|
|
const debounced = this.debounce((value) => {
|
|
this.updateAuthFileSearchQuery(value);
|
|
}, 250);
|
|
|
|
const listener = (event) => {
|
|
const value = event?.target?.value ?? '';
|
|
debounced(value);
|
|
};
|
|
|
|
searchInput._authFileSearchListener = listener;
|
|
searchInput.addEventListener('input', listener);
|
|
},
|
|
|
|
bindAuthFilesPageSizeControl() {
|
|
const pageSizeInput = document.getElementById('auth-files-page-size-input');
|
|
if (!pageSizeInput) return;
|
|
|
|
if (pageSizeInput._authFilePageSizeListener) {
|
|
pageSizeInput.removeEventListener('change', pageSizeInput._authFilePageSizeListener);
|
|
}
|
|
|
|
const listener = (event) => {
|
|
const value = parseInt(event?.target?.value, 10);
|
|
if (!Number.isFinite(value)) {
|
|
return;
|
|
}
|
|
this.updateAuthFilesPageSize(value);
|
|
};
|
|
|
|
pageSizeInput._authFilePageSizeListener = listener;
|
|
pageSizeInput.addEventListener('change', listener);
|
|
|
|
if (pageSizeInput._authFilePageSizeBlur) {
|
|
pageSizeInput.removeEventListener('blur', pageSizeInput._authFilePageSizeBlur);
|
|
}
|
|
|
|
const blurListener = () => {
|
|
if (!pageSizeInput.value) {
|
|
this.syncAuthFileControls();
|
|
}
|
|
};
|
|
|
|
pageSizeInput._authFilePageSizeBlur = blurListener;
|
|
pageSizeInput.addEventListener('blur', blurListener);
|
|
},
|
|
|
|
renderAuthFilesPage(page = null) {
|
|
const container = document.getElementById('auth-files-list');
|
|
if (!container) return;
|
|
|
|
const pageSize = this.authFilesPagination?.pageSize || 9;
|
|
const filteredFiles = this.getFilteredAuthFiles();
|
|
const totalItems = filteredFiles.length;
|
|
const hasCachedFiles = Array.isArray(this.cachedAuthFiles) && this.cachedAuthFiles.length > 0;
|
|
const filterApplied = (this.currentAuthFileFilter && this.currentAuthFileFilter !== 'all');
|
|
const searchApplied = Boolean((this.authFileSearchQuery || '').trim());
|
|
|
|
if (totalItems === 0) {
|
|
const titleKey = hasCachedFiles && (filterApplied || searchApplied)
|
|
? 'auth_files.search_empty_title'
|
|
: 'auth_files.empty_title';
|
|
const descKey = hasCachedFiles && (filterApplied || searchApplied)
|
|
? 'auth_files.search_empty_desc'
|
|
: 'auth_files.empty_desc';
|
|
container.innerHTML = `
|
|
<div class="empty-state">
|
|
<i class="fas fa-file-alt"></i>
|
|
<h3>${i18n.t(titleKey)}</h3>
|
|
<p>${i18n.t(descKey)}</p>
|
|
</div>
|
|
`;
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.updatePaginationControls(0);
|
|
return;
|
|
}
|
|
|
|
const maxPages = Math.max(1, Math.ceil(totalItems / pageSize));
|
|
let currentPage = page == null ? (this.authFilesPagination.currentPage || 1) : page;
|
|
if (currentPage > maxPages) {
|
|
currentPage = maxPages;
|
|
}
|
|
if (currentPage < 1) {
|
|
currentPage = 1;
|
|
}
|
|
this.authFilesPagination.currentPage = currentPage;
|
|
this.authFilesPagination.totalPages = maxPages;
|
|
|
|
const startIndex = (currentPage - 1) * pageSize;
|
|
const pageFiles = filteredFiles.slice(startIndex, startIndex + pageSize);
|
|
|
|
container.innerHTML = pageFiles.map(file => this.buildAuthFileItemHtml(file)).join('');
|
|
this.updatePaginationControls(totalItems);
|
|
this.bindAuthFileActionEvents();
|
|
},
|
|
|
|
bindAuthFilesPaginationEvents() {
|
|
const container = document.getElementById('auth-files-pagination');
|
|
if (!container) return;
|
|
|
|
const oldListener = container._paginationListener;
|
|
if (oldListener) {
|
|
container.removeEventListener('click', oldListener);
|
|
}
|
|
|
|
const listener = (event) => {
|
|
const button = event.target.closest('button[data-action]');
|
|
if (!button || !container.contains(button)) return;
|
|
event.preventDefault();
|
|
const action = button.dataset.action;
|
|
const currentPage = this.authFilesPagination?.currentPage || 1;
|
|
if (action === 'prev') {
|
|
this.renderAuthFilesPage(currentPage - 1);
|
|
} else if (action === 'next') {
|
|
this.renderAuthFilesPage(currentPage + 1);
|
|
}
|
|
};
|
|
|
|
container._paginationListener = listener;
|
|
container.addEventListener('click', listener);
|
|
},
|
|
|
|
updatePaginationControls(totalItems = 0) {
|
|
const paginationContainer = document.getElementById('auth-files-pagination');
|
|
const infoEl = document.getElementById('auth-files-pagination-info');
|
|
if (!paginationContainer || !infoEl) return;
|
|
|
|
const prevBtn = paginationContainer.querySelector('button[data-action=\"prev\"]');
|
|
const nextBtn = paginationContainer.querySelector('button[data-action=\"next\"]');
|
|
const pageSize = this.authFilesPagination?.pageSize || 9;
|
|
const totalPages = this.authFilesPagination?.totalPages || 1;
|
|
const currentPage = Math.min(this.authFilesPagination?.currentPage || 1, totalPages);
|
|
const shouldShow = totalItems > pageSize;
|
|
|
|
paginationContainer.style.display = shouldShow ? 'flex' : 'none';
|
|
|
|
const infoParams = totalItems === 0
|
|
? { current: 0, total: 0, count: 0 }
|
|
: { current: currentPage, total: totalPages, count: totalItems };
|
|
infoEl.textContent = i18n.t('auth_files.pagination_info', infoParams);
|
|
|
|
if (prevBtn) {
|
|
prevBtn.disabled = currentPage <= 1;
|
|
}
|
|
if (nextBtn) {
|
|
nextBtn.disabled = currentPage >= totalPages;
|
|
}
|
|
},
|
|
|
|
updateFilterButtons(existingTypes) {
|
|
const filterContainer = document.querySelector('.auth-file-filter');
|
|
if (!filterContainer) return;
|
|
|
|
const predefinedTypes = [
|
|
{ type: 'all', labelKey: 'auth_files.filter_all' },
|
|
{ type: 'qwen', labelKey: 'auth_files.filter_qwen' },
|
|
{ type: 'gemini', labelKey: 'auth_files.filter_gemini' },
|
|
{ type: 'gemini-cli', labelKey: 'auth_files.filter_gemini-cli' },
|
|
{ type: 'aistudio', labelKey: 'auth_files.filter_aistudio' },
|
|
{ type: 'claude', labelKey: 'auth_files.filter_claude' },
|
|
{ type: 'codex', labelKey: 'auth_files.filter_codex' },
|
|
{ type: 'antigravity', labelKey: 'auth_files.filter_antigravity' },
|
|
{ type: 'iflow', labelKey: 'auth_files.filter_iflow' },
|
|
{ type: 'vertex', labelKey: 'auth_files.filter_vertex' },
|
|
{ type: 'empty', labelKey: 'auth_files.filter_empty' }
|
|
];
|
|
|
|
const existingButtons = filterContainer.querySelectorAll('.filter-btn');
|
|
const existingButtonTypes = new Set();
|
|
existingButtons.forEach(btn => {
|
|
existingButtonTypes.add(btn.dataset.type);
|
|
});
|
|
|
|
existingButtons.forEach(btn => {
|
|
const btnType = btn.dataset.type;
|
|
if (existingTypes.has(btnType)) {
|
|
btn.style.display = 'inline-block';
|
|
const match = predefinedTypes.find(item => item.type === btnType);
|
|
if (match) {
|
|
btn.textContent = i18n.t(match.labelKey);
|
|
btn.setAttribute('data-i18n-text', match.labelKey);
|
|
}
|
|
} else {
|
|
btn.style.display = 'none';
|
|
}
|
|
});
|
|
|
|
const predefinedTypeSet = new Set(predefinedTypes.map(t => t.type));
|
|
existingTypes.forEach(type => {
|
|
if (type !== 'all' && !predefinedTypeSet.has(type) && !existingButtonTypes.has(type)) {
|
|
const btn = document.createElement('button');
|
|
btn.className = 'filter-btn';
|
|
btn.dataset.type = type;
|
|
|
|
const match = predefinedTypes.find(item => item.type === type);
|
|
if (match) {
|
|
btn.setAttribute('data-i18n-text', match.labelKey);
|
|
btn.textContent = i18n.t(match.labelKey);
|
|
} else {
|
|
const dynamicKey = `auth_files.filter_${type}`;
|
|
btn.setAttribute('data-i18n-text', dynamicKey);
|
|
btn.textContent = this.generateDynamicTypeLabel(type);
|
|
}
|
|
|
|
const emptyBtn = filterContainer.querySelector('[data-type=\"empty\"]');
|
|
if (emptyBtn) {
|
|
filterContainer.insertBefore(btn, emptyBtn);
|
|
} else {
|
|
filterContainer.appendChild(btn);
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
handleFilterClick(clickedBtn, options = {}) {
|
|
if (!clickedBtn) return;
|
|
const { skipRender = false } = options;
|
|
const filterBtns = document.querySelectorAll('.auth-file-filter .filter-btn');
|
|
|
|
filterBtns.forEach(b => b.classList.remove('active'));
|
|
clickedBtn.classList.add('active');
|
|
|
|
const filterType = clickedBtn.dataset.type;
|
|
this.currentAuthFileFilter = filterType || 'all';
|
|
|
|
if (!skipRender) {
|
|
this.authFilesPagination.currentPage = 1;
|
|
this.renderAuthFilesPage(1);
|
|
}
|
|
|
|
this.refreshFilterButtonTexts();
|
|
this.renderOauthExcludedModels();
|
|
},
|
|
|
|
generateDynamicTypeLabel(type) {
|
|
if (!type) return '';
|
|
const key = `auth_files.type_${type}`;
|
|
const translated = i18n.t(key);
|
|
if (translated && translated !== key) {
|
|
return translated;
|
|
}
|
|
if (type.toLowerCase() === 'iflow') return 'iFlow';
|
|
return type.charAt(0).toUpperCase() + type.slice(1);
|
|
},
|
|
|
|
bindAuthFileFilterEvents() {
|
|
const filterContainer = document.querySelector('.auth-file-filter');
|
|
if (!filterContainer) return;
|
|
|
|
if (filterContainer._filterListener) {
|
|
filterContainer.removeEventListener('click', filterContainer._filterListener);
|
|
}
|
|
|
|
const listener = (event) => {
|
|
const button = event.target.closest('.filter-btn');
|
|
if (!button || !filterContainer.contains(button)) return;
|
|
event.preventDefault();
|
|
this.handleFilterClick(button);
|
|
};
|
|
|
|
filterContainer._filterListener = listener;
|
|
filterContainer.addEventListener('click', listener);
|
|
|
|
this.refreshFilterButtonTexts();
|
|
},
|
|
|
|
applyAuthFileFilterState(shouldRender = false) {
|
|
const filterContainer = document.querySelector('.auth-file-filter');
|
|
if (!filterContainer) return;
|
|
|
|
const currentType = this.currentAuthFileFilter || 'all';
|
|
const buttons = filterContainer.querySelectorAll('.filter-btn');
|
|
if (buttons.length === 0) return;
|
|
|
|
let targetButton = null;
|
|
buttons.forEach(btn => {
|
|
if (btn.dataset.type === currentType) {
|
|
targetButton = btn;
|
|
}
|
|
});
|
|
|
|
if (!targetButton) {
|
|
targetButton = filterContainer.querySelector('.filter-btn[data-type=\"all\"]') || buttons[0];
|
|
if (targetButton) {
|
|
this.currentAuthFileFilter = targetButton.dataset.type || 'all';
|
|
}
|
|
}
|
|
|
|
if (targetButton) {
|
|
this.handleFilterClick(targetButton, { skipRender: !shouldRender });
|
|
}
|
|
},
|
|
|
|
removeAuthFileElements(filenames = []) {
|
|
if (!Array.isArray(filenames) || filenames.length === 0) {
|
|
return;
|
|
}
|
|
|
|
const removalSet = new Set(filenames);
|
|
this.cachedAuthFiles = (this.cachedAuthFiles || []).filter(file => file && !removalSet.has(file.name));
|
|
|
|
if (!this.cachedAuthFiles.length) {
|
|
this.authFilesPagination.currentPage = 1;
|
|
}
|
|
this.renderAuthFilesPage(this.authFilesPagination.currentPage);
|
|
},
|
|
|
|
refreshFilterButtonTexts() {
|
|
document.querySelectorAll('.auth-file-filter .filter-btn[data-i18n-text]').forEach(btn => {
|
|
const key = btn.getAttribute('data-i18n-text');
|
|
if (key) {
|
|
btn.textContent = i18n.t(key);
|
|
}
|
|
});
|
|
},
|
|
|
|
bindAuthFileActionEvents() {
|
|
const container = document.getElementById('auth-files-list');
|
|
if (!container) return;
|
|
|
|
const oldListener = container._authFileActionListener;
|
|
if (oldListener) {
|
|
container.removeEventListener('click', oldListener);
|
|
}
|
|
|
|
const listener = (e) => {
|
|
const button = e.target.closest('button[data-action]');
|
|
if (!button) return;
|
|
|
|
const action = button.dataset.action;
|
|
const actionsContainer = button.closest('.item-actions');
|
|
if (!actionsContainer) return;
|
|
|
|
const filename = actionsContainer.dataset.filename;
|
|
if (!filename) return;
|
|
|
|
switch (action) {
|
|
case 'showDetails':
|
|
this.showAuthFileDetails(filename);
|
|
break;
|
|
case 'download':
|
|
this.downloadAuthFile(filename);
|
|
break;
|
|
case 'delete':
|
|
this.deleteAuthFile(filename);
|
|
break;
|
|
}
|
|
};
|
|
|
|
container._authFileActionListener = listener;
|
|
container.addEventListener('click', listener);
|
|
},
|
|
|
|
formatFileSize(bytes) {
|
|
if (bytes === 0) return '0 Bytes';
|
|
const k = 1024;
|
|
const sizes = ['Bytes', 'KB', 'MB', 'GB'];
|
|
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
|
|
},
|
|
|
|
openVertexFilePicker() {
|
|
const fileInput = document.getElementById('vertex-file-input');
|
|
if (fileInput) {
|
|
fileInput.click();
|
|
}
|
|
},
|
|
|
|
handleVertexFileSelection(event) {
|
|
const fileInput = event?.target;
|
|
const file = fileInput?.files?.[0] || null;
|
|
|
|
if (fileInput) {
|
|
fileInput.value = '';
|
|
}
|
|
|
|
if (file && !file.name.toLowerCase().endsWith('.json')) {
|
|
this.showNotification(i18n.t('vertex_import.file_required'), 'error');
|
|
this.vertexImportState.file = null;
|
|
this.updateVertexFileDisplay();
|
|
this.updateVertexImportButtonState();
|
|
return;
|
|
}
|
|
|
|
this.vertexImportState.file = file;
|
|
this.updateVertexFileDisplay(file ? file.name : '');
|
|
this.updateVertexImportButtonState();
|
|
},
|
|
|
|
updateVertexFileDisplay(filename = '') {
|
|
const displayInput = document.getElementById('vertex-file-display');
|
|
if (!displayInput) return;
|
|
displayInput.value = filename || '';
|
|
},
|
|
|
|
updateVertexImportButtonState() {
|
|
const importBtn = document.getElementById('vertex-import-btn');
|
|
if (!importBtn) return;
|
|
const disabled = !this.vertexImportState.file || this.vertexImportState.loading;
|
|
importBtn.disabled = disabled;
|
|
},
|
|
|
|
async importVertexCredential() {
|
|
if (!this.vertexImportState.file) {
|
|
this.showNotification(i18n.t('vertex_import.file_required'), 'error');
|
|
return;
|
|
}
|
|
|
|
const locationInput = document.getElementById('vertex-location');
|
|
const location = locationInput ? locationInput.value.trim() : '';
|
|
const formData = new FormData();
|
|
formData.append('file', this.vertexImportState.file, this.vertexImportState.file.name);
|
|
if (location) {
|
|
formData.append('location', location);
|
|
}
|
|
|
|
try {
|
|
this.vertexImportState.loading = true;
|
|
this.updateVertexImportButtonState();
|
|
|
|
const response = await this.apiClient.requestRaw('/vertex/import', {
|
|
method: 'POST',
|
|
body: formData
|
|
});
|
|
|
|
if (!response.ok) {
|
|
let errorMessage = `HTTP ${response.status}`;
|
|
try {
|
|
const errorData = await response.json();
|
|
errorMessage = errorData?.message || errorData?.error || errorMessage;
|
|
} catch (parseError) {
|
|
const text = await response.text();
|
|
if (text) {
|
|
errorMessage = text;
|
|
}
|
|
}
|
|
throw new Error(errorMessage);
|
|
}
|
|
|
|
const result = await response.json();
|
|
this.vertexImportState.result = result;
|
|
this.renderVertexImportResult(result);
|
|
this.showNotification(i18n.t('vertex_import.success'), 'success');
|
|
this.vertexImportState.file = null;
|
|
this.updateVertexFileDisplay('');
|
|
} catch (error) {
|
|
console.error('Vertex credential import failed:', error);
|
|
this.showNotification(`${i18n.t('notification.import_failed')}: ${error.message}`, 'error');
|
|
} finally {
|
|
this.vertexImportState.loading = false;
|
|
this.updateVertexImportButtonState();
|
|
const fileInput = document.getElementById('vertex-file-input');
|
|
if (fileInput) {
|
|
fileInput.value = '';
|
|
}
|
|
}
|
|
},
|
|
|
|
renderVertexImportResult(result = null) {
|
|
const container = document.getElementById('vertex-import-result');
|
|
const projectEl = document.getElementById('vertex-result-project');
|
|
const emailEl = document.getElementById('vertex-result-email');
|
|
const locationEl = document.getElementById('vertex-result-location');
|
|
const fileEl = document.getElementById('vertex-result-file');
|
|
if (!container || !projectEl || !emailEl || !locationEl || !fileEl) return;
|
|
|
|
if (!result) {
|
|
container.style.display = 'none';
|
|
this.vertexImportState.result = null;
|
|
return;
|
|
}
|
|
|
|
this.vertexImportState.result = result;
|
|
projectEl.textContent = result.project || '-';
|
|
emailEl.textContent = result.email || '-';
|
|
locationEl.textContent = result.location || '-';
|
|
fileEl.textContent = result.file || '-';
|
|
container.style.display = 'block';
|
|
},
|
|
|
|
showAuthFileDetails(filename, content) {
|
|
const file = (this.cachedAuthFiles || []).find(f => f && f.name === filename);
|
|
if (!file) return;
|
|
|
|
const stats = this.resolveAuthFileStats(file, this.authFileStatsCache || {});
|
|
const size = typeof file.size === 'number' ? this.formatFileSize(file.size) : '-';
|
|
const provider = file.provider || '-';
|
|
const type = file.type || '-';
|
|
const createdAt = file.created_at ? new Date(file.created_at).toLocaleString('zh-CN') : '-';
|
|
|
|
const jsonContent = content || JSON.stringify(file, null, 2);
|
|
|
|
// 使用独立的 JSON 弹窗样式，避免被通用 .modal 的 display:none 覆盖
|
|
const modalHtml = `
|
|
<div class="json-modal" id="json-modal">
|
|
<div class="json-modal-content">
|
|
<div class="json-modal-header">
|
|
<h3>${this.escapeHtml(filename)}</h3>
|
|
</div>
|
|
<div class="json-modal-body">
|
|
<pre class="json-content">${this.escapeHtml(jsonContent)}</pre>
|
|
</div>
|
|
<div class="json-modal-footer">
|
|
<button class="btn btn-secondary" data-action="copy">
|
|
<i class="fas fa-copy"></i>
|
|
${i18n.t('common.copy')}
|
|
</button>
|
|
<button class="btn btn-secondary" data-action="close">
|
|
${i18n.t('common.close')}
|
|
</button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
`;
|
|
|
|
const oldModal = document.getElementById('json-modal');
|
|
if (oldModal) {
|
|
oldModal.remove();
|
|
}
|
|
|
|
document.body.insertAdjacentHTML('beforeend', modalHtml);
|
|
const modal = document.getElementById('json-modal');
|
|
|
|
modal.addEventListener('click', (e) => {
|
|
if (e.target === modal) {
|
|
this.closeJsonModal();
|
|
}
|
|
});
|
|
|
|
this.bindJsonModalEvents(modal);
|
|
},
|
|
|
|
bindJsonModalEvents(modal) {
|
|
modal.addEventListener('click', (e) => {
|
|
const button = e.target.closest('button[data-action]');
|
|
if (!button) return;
|
|
|
|
const action = button.dataset.action;
|
|
switch (action) {
|
|
case 'copy':
|
|
this.copyJsonContent();
|
|
break;
|
|
case 'close':
|
|
this.closeJsonModal();
|
|
break;
|
|
}
|
|
});
|
|
},
|
|
|
|
closeJsonModal() {
|
|
const modal = document.getElementById('json-modal');
|
|
if (modal) {
|
|
modal.remove();
|
|
}
|
|
},
|
|
|
|
copyJsonContent() {
|
|
const jsonContent = document.querySelector('.json-content');
|
|
if (jsonContent) {
|
|
const text = jsonContent.textContent;
|
|
navigator.clipboard.writeText(text).then(() => {
|
|
this.showNotification('内容已复制到剪贴板', 'success');
|
|
}).catch(() => {
|
|
this.showNotification('复制失败', 'error');
|
|
});
|
|
}
|
|
},
|
|
|
|
async downloadAuthFile(filename) {
|
|
try {
|
|
const response = await this.apiClient.requestRaw(`/auth-files/download?name=${encodeURIComponent(filename)}`);
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP ${response.status}`);
|
|
}
|
|
|
|
const blob = await response.blob();
|
|
const url = window.URL.createObjectURL(blob);
|
|
const a = document.createElement('a');
|
|
a.href = url;
|
|
a.download = filename;
|
|
a.click();
|
|
window.URL.revokeObjectURL(url);
|
|
|
|
this.showNotification(i18n.t('auth_files.download_success'), 'success');
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.download_failed')}: ${error.message}`, 'error');
|
|
}
|
|
},
|
|
|
|
async deleteAuthFile(filename) {
|
|
if (!confirm(`${i18n.t('auth_files.delete_confirm')} "${filename}" 吗？`)) return;
|
|
|
|
try {
|
|
await this.makeRequest(`/auth-files?name=${encodeURIComponent(filename)}`, { method: 'DELETE' });
|
|
this.removeAuthFileElements([filename]);
|
|
this.clearCache();
|
|
await this.loadAuthFiles();
|
|
this.showNotification(i18n.t('auth_files.delete_success'), 'success');
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.delete_failed')}: ${error.message}`, 'error');
|
|
}
|
|
},
|
|
|
|
async deleteAllAuthFiles() {
|
|
const filterType = (this.currentAuthFileFilter || 'all').toLowerCase();
|
|
const isFiltered = filterType !== 'all';
|
|
const typeLabel = this.generateDynamicTypeLabel(filterType);
|
|
const confirmMessage = isFiltered
|
|
? i18n.t('auth_files.delete_filtered_confirm').replace('{type}', typeLabel)
|
|
: i18n.t('auth_files.delete_all_confirm');
|
|
|
|
if (!confirm(confirmMessage)) return;
|
|
|
|
try {
|
|
if (!isFiltered) {
|
|
const response = await this.makeRequest('/auth-files?all=true', { method: 'DELETE' });
|
|
const currentNames = (this.cachedAuthFiles || []).map(file => file.name).filter(Boolean);
|
|
if (currentNames.length > 0) {
|
|
this.removeAuthFileElements(currentNames);
|
|
}
|
|
this.clearCache();
|
|
this.currentAuthFileFilter = 'all';
|
|
await this.loadAuthFiles();
|
|
this.showNotification(`${i18n.t('auth_files.delete_all_success')} ${response.deleted} ${i18n.t('auth_files.files_count')}`, 'success');
|
|
return;
|
|
}
|
|
|
|
const deletableFiles = (this.cachedAuthFiles || []).filter(file => {
|
|
if (!file || file.runtime_only) return false;
|
|
const fileType = (file.type || 'unknown').toLowerCase();
|
|
return fileType === filterType;
|
|
});
|
|
|
|
if (deletableFiles.length === 0) {
|
|
this.showNotification(i18n.t('auth_files.delete_filtered_none').replace('{type}', typeLabel), 'info');
|
|
return;
|
|
}
|
|
|
|
let success = 0;
|
|
let failed = 0;
|
|
const deletedNames = [];
|
|
|
|
for (const file of deletableFiles) {
|
|
try {
|
|
await this.makeRequest(`/auth-files?name=${encodeURIComponent(file.name)}`, { method: 'DELETE' });
|
|
success++;
|
|
deletedNames.push(file.name);
|
|
} catch (error) {
|
|
console.error('删除认证文件失败:', file?.name, error);
|
|
failed++;
|
|
}
|
|
}
|
|
|
|
if (deletedNames.length > 0) {
|
|
this.removeAuthFileElements(deletedNames);
|
|
}
|
|
|
|
this.clearCache();
|
|
this.currentAuthFileFilter = 'all';
|
|
await this.loadAuthFiles();
|
|
|
|
if (failed === 0) {
|
|
const successMsg = i18n.t('auth_files.delete_filtered_success')
|
|
.replace('{count}', success)
|
|
.replace('{type}', typeLabel);
|
|
this.showNotification(successMsg, 'success');
|
|
} else {
|
|
const warningMsg = i18n.t('auth_files.delete_filtered_partial')
|
|
.replace('{success}', success)
|
|
.replace('{failed}', failed)
|
|
.replace('{type}', typeLabel);
|
|
this.showNotification(warningMsg, 'warning');
|
|
}
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.delete_failed')}: ${error.message}`, 'error');
|
|
}
|
|
},
|
|
|
|
// 触发文件上传选择器
|
|
uploadAuthFile() {
|
|
const authFileInput = document.getElementById('auth-file-input');
|
|
if (authFileInput) {
|
|
authFileInput.click();
|
|
}
|
|
},
|
|
|
|
// 处理文件上传
|
|
async handleFileUpload(event) {
|
|
const file = event.target.files[0];
|
|
if (!file) return;
|
|
|
|
if (!file.name.endsWith('.json')) {
|
|
this.showNotification(i18n.t('auth_files.upload_error_json'), 'error');
|
|
event.target.value = '';
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const formData = new FormData();
|
|
formData.append('file', file, file.name);
|
|
|
|
const response = await this.apiClient.requestRaw('/auth-files', {
|
|
method: 'POST',
|
|
body: formData
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errorData = await response.json().catch(() => ({}));
|
|
throw new Error(errorData.error || `HTTP ${response.status}`);
|
|
}
|
|
|
|
this.clearCache(); // 清除缓存
|
|
await this.loadAuthFiles();
|
|
this.showNotification(i18n.t('auth_files.upload_success'), 'success');
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('notification.upload_failed')}: ${error.message}`, 'error');
|
|
} finally {
|
|
// 清空文件输入框,允许重复上传同一文件
|
|
event.target.value = '';
|
|
}
|
|
},
|
|
|
|
normalizeOauthExcludedMap(payload = {}) {
|
|
const raw = (payload && (payload['oauth-excluded-models'] || payload.items)) || payload || {};
|
|
if (!raw || typeof raw !== 'object') {
|
|
return {};
|
|
}
|
|
const normalized = {};
|
|
Object.entries(raw).forEach(([provider, models]) => {
|
|
const key = typeof provider === 'string' ? provider.trim() : '';
|
|
if (!key) return;
|
|
const list = Array.isArray(models)
|
|
? models.map(item => String(item || '').trim()).filter(Boolean)
|
|
: [];
|
|
normalized[key.toLowerCase()] = list;
|
|
});
|
|
return normalized;
|
|
},
|
|
|
|
resolveOauthExcludedFromConfig(config = null) {
|
|
const sources = [];
|
|
if (config && typeof config === 'object') {
|
|
sources.push(config);
|
|
}
|
|
if (this.configCache && typeof this.configCache === 'object') {
|
|
if (this.configCache['oauth-excluded-models'] !== undefined) {
|
|
sources.push({ 'oauth-excluded-models': this.configCache['oauth-excluded-models'] });
|
|
}
|
|
if (this.configCache['__full__']) {
|
|
sources.push(this.configCache['__full__']);
|
|
}
|
|
}
|
|
|
|
for (const source of sources) {
|
|
if (!source || typeof source !== 'object') continue;
|
|
if (Object.prototype.hasOwnProperty.call(source, 'oauth-excluded-models')) {
|
|
return {
|
|
map: this.normalizeOauthExcludedMap(source),
|
|
found: true
|
|
};
|
|
}
|
|
}
|
|
|
|
return { map: {}, found: false };
|
|
},
|
|
|
|
applyOauthExcludedFromConfig(config = null, options = {}) {
|
|
const { render = true } = options || {};
|
|
const { map, found } = this.resolveOauthExcludedFromConfig(config);
|
|
if (!found) {
|
|
return false;
|
|
}
|
|
|
|
this.oauthExcludedModels = map;
|
|
this._oauthExcludedLoading = false;
|
|
this.setOauthExcludedStatus('');
|
|
this.updateOauthExcludedButtonsState(false);
|
|
if (render) {
|
|
this.renderOauthExcludedModels();
|
|
}
|
|
return true;
|
|
},
|
|
|
|
getFilteredOauthExcludedMap(filterType = this.currentAuthFileFilter) {
|
|
const map = this.oauthExcludedModels || {};
|
|
if (!map || typeof map !== 'object') {
|
|
return {};
|
|
}
|
|
const type = (filterType || 'all').toLowerCase();
|
|
if (type === 'all') {
|
|
return map;
|
|
}
|
|
const result = {};
|
|
Object.entries(map).forEach(([provider, models]) => {
|
|
if ((provider || '').toLowerCase() === type) {
|
|
result[provider] = models;
|
|
}
|
|
});
|
|
return result;
|
|
},
|
|
|
|
findOauthExcludedEntry(provider) {
|
|
if (!provider || provider === 'all') {
|
|
return null;
|
|
}
|
|
const normalized = provider.toLowerCase();
|
|
const map = this.oauthExcludedModels || {};
|
|
for (const [key, models] of Object.entries(map)) {
|
|
if ((key || '').toLowerCase() === normalized) {
|
|
return { provider: key, models: Array.isArray(models) ? models : [] };
|
|
}
|
|
}
|
|
return null;
|
|
},
|
|
|
|
setOauthExcludedForm(provider = '', models = null) {
|
|
const providerSelect = document.getElementById('oauth-excluded-provider-select');
|
|
const modelsInput = document.getElementById('oauth-excluded-models');
|
|
|
|
const normalizedProvider = (provider || '').trim();
|
|
if (providerSelect) {
|
|
const options = Array.from(providerSelect.options || []);
|
|
let match = options.find(opt => (opt.value || '').toLowerCase() === normalizedProvider.toLowerCase());
|
|
if (!match && normalizedProvider) {
|
|
match = new Option(this.generateDynamicTypeLabel(normalizedProvider) || normalizedProvider, normalizedProvider);
|
|
providerSelect.appendChild(match);
|
|
}
|
|
if (normalizedProvider && match) {
|
|
providerSelect.value = match.value;
|
|
} else {
|
|
providerSelect.value = 'auto';
|
|
}
|
|
}
|
|
|
|
if (modelsInput && models !== null && models !== undefined) {
|
|
const list = Array.isArray(models) ? models : [];
|
|
modelsInput.value = list.map(item => item || '').join('\n');
|
|
}
|
|
},
|
|
|
|
syncOauthExcludedFormWithFilter(overrideModels = false) {
|
|
const filterType = (this.currentAuthFileFilter || 'all').toLowerCase();
|
|
const entry = this.findOauthExcludedEntry(filterType);
|
|
|
|
if (filterType === 'all') {
|
|
if (overrideModels) {
|
|
if (entry) {
|
|
this.setOauthExcludedForm(entry.provider, entry.models);
|
|
} else {
|
|
this.setOauthExcludedForm('', '');
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (overrideModels) {
|
|
this.setOauthExcludedForm(filterType, entry ? entry.models : []);
|
|
} else {
|
|
this.setOauthExcludedForm(filterType);
|
|
}
|
|
},
|
|
|
|
getOauthExcludedProviderValue() {
|
|
const providerSelect = document.getElementById('oauth-excluded-provider-select');
|
|
const filterFallback = (this.currentAuthFileFilter && this.currentAuthFileFilter !== 'all')
|
|
? this.currentAuthFileFilter
|
|
: '';
|
|
|
|
let selected = (providerSelect && providerSelect.value) ? providerSelect.value.trim() : '';
|
|
if (!selected || selected === 'auto') {
|
|
return filterFallback;
|
|
}
|
|
return selected;
|
|
},
|
|
|
|
refreshOauthProviderOptions() {
|
|
const providerSelect = document.getElementById('oauth-excluded-provider-select');
|
|
if (!providerSelect) return;
|
|
|
|
const allowedProviders = ['gemini-cli', 'vertex', 'aistudio', 'antigravity', 'claude', 'codex', 'qwen', 'iflow'];
|
|
const mapProviders = Object.keys(this.oauthExcludedModels || {});
|
|
const filterType = (this.currentAuthFileFilter || '').toLowerCase();
|
|
const providers = Array.from(new Set([...allowedProviders, ...mapProviders].filter(Boolean)));
|
|
|
|
const prevValue = providerSelect.value || 'auto';
|
|
|
|
providerSelect.innerHTML = '';
|
|
const addOption = (value, textKey, fallbackText = null) => {
|
|
const opt = document.createElement('option');
|
|
opt.value = value;
|
|
if (textKey) {
|
|
opt.setAttribute('data-i18n-text', textKey);
|
|
opt.textContent = i18n.t(textKey);
|
|
} else {
|
|
opt.textContent = fallbackText || value;
|
|
}
|
|
providerSelect.appendChild(opt);
|
|
};
|
|
|
|
addOption('auto', 'oauth_excluded.provider_auto');
|
|
providers.sort((a, b) => a.localeCompare(b)).forEach(item => addOption(item, null, this.generateDynamicTypeLabel(item) || item));
|
|
|
|
const restoreValue = (() => {
|
|
if (prevValue && Array.from(providerSelect.options).some(opt => opt.value === prevValue)) {
|
|
return prevValue;
|
|
}
|
|
if (filterType && Array.from(providerSelect.options).some(opt => opt.value === filterType)) {
|
|
return filterType;
|
|
}
|
|
return 'auto';
|
|
})();
|
|
providerSelect.value = restoreValue;
|
|
},
|
|
|
|
parseOauthExcludedModelsInput(input = '') {
|
|
const tokens = (input || '').split(/[\n,]/).map(token => token.trim()).filter(Boolean);
|
|
const unique = [];
|
|
tokens.forEach(token => {
|
|
if (!unique.includes(token)) {
|
|
unique.push(token);
|
|
}
|
|
});
|
|
return unique;
|
|
},
|
|
|
|
openOauthExcludedEditor(provider = '', models = null) {
|
|
const modal = document.getElementById('modal');
|
|
const modalBody = document.getElementById('modal-body');
|
|
if (!modal || !modalBody) return;
|
|
|
|
const normalizedProvider = (provider || '').trim();
|
|
const fallbackProvider = normalizedProvider
|
|
|| ((this.currentAuthFileFilter && this.currentAuthFileFilter !== 'all') ? this.currentAuthFileFilter : '');
|
|
let targetModels = models;
|
|
|
|
if ((targetModels === null || targetModels === undefined) && fallbackProvider) {
|
|
const existing = this.findOauthExcludedEntry(fallbackProvider);
|
|
if (existing) {
|
|
targetModels = existing.models;
|
|
}
|
|
}
|
|
|
|
modalBody.innerHTML = `
|
|
<h3>${fallbackProvider
|
|
? i18n.t('oauth_excluded.edit_title', { provider: this.generateDynamicTypeLabel(fallbackProvider) })
|
|
: i18n.t('oauth_excluded.add_title')
|
|
}</h3>
|
|
<div class="provider-item oauth-excluded-editor-card">
|
|
<div class="item-content">
|
|
<div class="form-group">
|
|
<label for="oauth-excluded-provider-select" data-i18n="oauth_excluded.provider_label">${i18n.t('oauth_excluded.provider_label')}</label>
|
|
<select id="oauth-excluded-provider-select"></select>
|
|
<p class="form-hint" data-i18n="oauth_excluded.provider_hint">${i18n.t('oauth_excluded.provider_hint')}</p>
|
|
</div>
|
|
<div class="form-group">
|
|
<label for="oauth-excluded-models" data-i18n="oauth_excluded.models_label">${i18n.t('oauth_excluded.models_label')}</label>
|
|
<textarea id="oauth-excluded-models" rows="5" data-i18n-placeholder="oauth_excluded.models_placeholder" placeholder="${i18n.t('oauth_excluded.models_placeholder')}"></textarea>
|
|
<p class="form-hint" data-i18n="oauth_excluded.models_hint">${i18n.t('oauth_excluded.models_hint')}</p>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div class="modal-actions">
|
|
<button class="btn btn-primary" id="oauth-excluded-save">
|
|
<i class="fas fa-save"></i> ${i18n.t('oauth_excluded.save')}
|
|
</button>
|
|
<button class="btn btn-danger" id="oauth-excluded-delete">
|
|
<i class="fas fa-trash"></i> ${i18n.t('oauth_excluded.delete')}
|
|
</button>
|
|
<button class="btn btn-secondary" onclick="manager.closeModal()">
|
|
${i18n.t('common.cancel')}
|
|
</button>
|
|
</div>
|
|
`;
|
|
|
|
this.refreshOauthProviderOptions();
|
|
this.setOauthExcludedForm(fallbackProvider, targetModels != null ? targetModels : []);
|
|
this.showModal();
|
|
|
|
const saveBtn = document.getElementById('oauth-excluded-save');
|
|
if (saveBtn) {
|
|
saveBtn.onclick = () => this.saveOauthExcludedEntry();
|
|
}
|
|
const deleteBtn = document.getElementById('oauth-excluded-delete');
|
|
if (deleteBtn) {
|
|
deleteBtn.onclick = () => this.deleteOauthExcludedEntry();
|
|
}
|
|
|
|
const providerSelect = document.getElementById('oauth-excluded-provider-select');
|
|
const syncDeleteState = () => {
|
|
if (deleteBtn) {
|
|
deleteBtn.disabled = !this.getOauthExcludedProviderValue();
|
|
}
|
|
};
|
|
if (providerSelect) {
|
|
providerSelect.addEventListener('change', syncDeleteState);
|
|
}
|
|
syncDeleteState();
|
|
this.updateOauthExcludedButtonsState(false);
|
|
},
|
|
|
|
buildOauthExcludedItem(provider, models = []) {
|
|
const providerLabel = this.generateDynamicTypeLabel(provider) || provider;
|
|
const normalizedModels = Array.isArray(models) ? models.filter(Boolean) : [];
|
|
const tags = normalizedModels.length
|
|
? normalizedModels.map(model => `<span class="provider-model-tag"><span class="model-name">${this.escapeHtml(String(model))}</span></span>`).join('')
|
|
: `<span class="oauth-excluded-empty">${i18n.t('oauth_excluded.no_models')}</span>`;
|
|
const modelCount = normalizedModels.length;
|
|
|
|
return `
|
|
<div class="provider-item oauth-excluded-card" data-provider="${this.escapeHtml(provider)}">
|
|
<div class="item-content">
|
|
<div class="item-title">${this.escapeHtml(providerLabel)}</div>
|
|
<div class="item-meta">
|
|
<span class="item-subtitle">
|
|
${modelCount > 0
|
|
? i18n.t('oauth_excluded.model_count', { count: modelCount })
|
|
: i18n.t('oauth_excluded.no_models')}
|
|
</span>
|
|
</div>
|
|
<div class="provider-models oauth-excluded-tags">
|
|
${tags}
|
|
</div>
|
|
</div>
|
|
<div class="item-actions">
|
|
<button class="btn btn-secondary" data-action="edit" data-provider="${this.escapeHtml(provider)}">
|
|
<i class="fas fa-pen"></i>
|
|
</button>
|
|
<button class="btn btn-danger" data-action="delete" data-provider="${this.escapeHtml(provider)}">
|
|
<i class="fas fa-trash"></i>
|
|
</button>
|
|
</div>
|
|
</div>
|
|
`;
|
|
},
|
|
|
|
renderOauthExcludedModels(filterType = this.currentAuthFileFilter) {
|
|
const container = document.getElementById('oauth-excluded-list');
|
|
const scopeEl = document.getElementById('oauth-excluded-scope');
|
|
if (!container) return;
|
|
|
|
const currentType = (filterType || 'all').toLowerCase();
|
|
const map = this.getFilteredOauthExcludedMap(currentType);
|
|
const providers = Object.keys(map || {});
|
|
|
|
if (scopeEl) {
|
|
const label = currentType === 'all'
|
|
? i18n.t('oauth_excluded.scope_all')
|
|
: i18n.t('oauth_excluded.scope_provider', { provider: this.generateDynamicTypeLabel(currentType) });
|
|
scopeEl.textContent = label;
|
|
}
|
|
|
|
if (!this.isConnected) {
|
|
container.innerHTML = `<div class="oauth-excluded-empty">${i18n.t('oauth_excluded.disconnected')}</div>`;
|
|
return;
|
|
}
|
|
|
|
if (this._oauthExcludedLoading) {
|
|
container.innerHTML = `<div class="loading-placeholder">${i18n.t('common.loading')}</div>`;
|
|
return;
|
|
}
|
|
|
|
if (!providers.length) {
|
|
const emptyKey = currentType === 'all'
|
|
? 'oauth_excluded.list_empty_all'
|
|
: 'oauth_excluded.list_empty_filtered';
|
|
container.innerHTML = `<div class="oauth-excluded-empty">${i18n.t(emptyKey)}</div>`;
|
|
return;
|
|
}
|
|
|
|
const itemsHtml = providers
|
|
.sort((a, b) => a.localeCompare(b))
|
|
.map(provider => this.buildOauthExcludedItem(provider, map[provider]))
|
|
.join('');
|
|
container.innerHTML = itemsHtml;
|
|
this.refreshOauthProviderOptions();
|
|
this.bindOauthExcludedActionEvents();
|
|
},
|
|
|
|
bindOauthExcludedActionEvents() {
|
|
const container = document.getElementById('oauth-excluded-list');
|
|
if (!container) return;
|
|
|
|
if (container._oauthExcludedListener) {
|
|
container.removeEventListener('click', container._oauthExcludedListener);
|
|
}
|
|
|
|
const listener = (event) => {
|
|
const button = event.target.closest('button[data-action]');
|
|
if (!button || !container.contains(button)) return;
|
|
const provider = button.dataset.provider;
|
|
if (!provider) return;
|
|
|
|
const entry = this.findOauthExcludedEntry(provider);
|
|
if (button.dataset.action === 'edit') {
|
|
this.openOauthExcludedEditor(provider, entry ? entry.models : []);
|
|
} else if (button.dataset.action === 'delete') {
|
|
this.deleteOauthExcludedEntry(provider);
|
|
}
|
|
};
|
|
|
|
container._oauthExcludedListener = listener;
|
|
container.addEventListener('click', listener);
|
|
},
|
|
|
|
updateOauthExcludedButtonsState(isLoading = false) {
|
|
const refreshBtn = document.getElementById('oauth-excluded-refresh');
|
|
const saveBtn = document.getElementById('oauth-excluded-save');
|
|
const deleteBtn = document.getElementById('oauth-excluded-delete');
|
|
const addBtn = document.getElementById('oauth-excluded-add');
|
|
const disabled = isLoading || !this.isConnected;
|
|
[refreshBtn, saveBtn, deleteBtn, addBtn].forEach(btn => {
|
|
if (btn) {
|
|
btn.disabled = disabled;
|
|
}
|
|
});
|
|
},
|
|
|
|
setOauthExcludedStatus(message = '') {
|
|
const statusEl = document.getElementById('oauth-excluded-status');
|
|
if (statusEl) {
|
|
statusEl.textContent = message || '';
|
|
}
|
|
},
|
|
|
|
async loadOauthExcludedModels(forceRefresh = false) {
|
|
if (!this.isConnected) {
|
|
this.renderOauthExcludedModels();
|
|
this.updateOauthExcludedButtonsState();
|
|
return;
|
|
}
|
|
|
|
if (this._oauthExcludedLoading) {
|
|
return;
|
|
}
|
|
|
|
this._oauthExcludedLoading = true;
|
|
this.updateOauthExcludedButtonsState(true);
|
|
this.setOauthExcludedStatus(i18n.t('oauth_excluded.refreshing'));
|
|
this.renderOauthExcludedModels();
|
|
|
|
try {
|
|
let targetMap = {};
|
|
let hasData = false;
|
|
|
|
if (!forceRefresh) {
|
|
const { map, found } = this.resolveOauthExcludedFromConfig();
|
|
if (found) {
|
|
targetMap = map;
|
|
hasData = true;
|
|
}
|
|
}
|
|
|
|
if (!hasData) {
|
|
try {
|
|
const configSection = await this.getConfig('oauth-excluded-models', forceRefresh);
|
|
if (configSection !== undefined) {
|
|
targetMap = this.normalizeOauthExcludedMap(configSection);
|
|
hasData = true;
|
|
}
|
|
} catch (configError) {
|
|
console.warn('从配置获取 OAuth 排除列表失败，尝试回退接口:', configError);
|
|
}
|
|
}
|
|
|
|
if (!hasData) {
|
|
const data = await this.makeRequest('/oauth-excluded-models');
|
|
targetMap = this.normalizeOauthExcludedMap(data);
|
|
hasData = true;
|
|
}
|
|
|
|
this.oauthExcludedModels = targetMap;
|
|
this.setOauthExcludedStatus('');
|
|
} catch (error) {
|
|
console.error('加载 OAuth 排除列表失败:', error);
|
|
const message = `${i18n.t('oauth_excluded.load_failed')}: ${error.message}`;
|
|
this.setOauthExcludedStatus(message);
|
|
this.showNotification(message, 'error');
|
|
} finally {
|
|
this._oauthExcludedLoading = false;
|
|
this.updateOauthExcludedButtonsState(false);
|
|
this.renderOauthExcludedModels();
|
|
}
|
|
},
|
|
|
|
async saveOauthExcludedEntry() {
|
|
if (!this.isConnected) {
|
|
this.showNotification(i18n.t('notification.connection_required'), 'error');
|
|
return;
|
|
}
|
|
const modelsInput = document.getElementById('oauth-excluded-models');
|
|
if (!modelsInput) return;
|
|
|
|
const providerValue = this.getOauthExcludedProviderValue();
|
|
if (!providerValue) {
|
|
this.showNotification(i18n.t('oauth_excluded.provider_required'), 'error');
|
|
return;
|
|
}
|
|
|
|
const models = this.parseOauthExcludedModelsInput(modelsInput.value);
|
|
this.updateOauthExcludedButtonsState(true);
|
|
this.setOauthExcludedStatus(i18n.t('oauth_excluded.saving'));
|
|
|
|
try {
|
|
await this.makeRequest('/oauth-excluded-models', {
|
|
method: 'PATCH',
|
|
body: JSON.stringify({
|
|
provider: providerValue,
|
|
models
|
|
})
|
|
});
|
|
const successKey = models.length === 0 ? 'oauth_excluded.delete_success' : 'oauth_excluded.save_success';
|
|
this.showNotification(i18n.t(successKey), 'success');
|
|
this.clearCache('oauth-excluded-models');
|
|
await this.loadOauthExcludedModels(true);
|
|
this.closeModal();
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('oauth_excluded.save_failed')}: ${error.message}`, 'error');
|
|
} finally {
|
|
this.setOauthExcludedStatus('');
|
|
this.updateOauthExcludedButtonsState(false);
|
|
}
|
|
},
|
|
|
|
async deleteOauthExcludedEntry(providerOverride = null) {
|
|
if (!this.isConnected) {
|
|
this.showNotification(i18n.t('notification.connection_required'), 'error');
|
|
return;
|
|
}
|
|
const providerValue = (providerOverride || this.getOauthExcludedProviderValue() || '').trim();
|
|
|
|
if (!providerValue) {
|
|
this.showNotification(i18n.t('oauth_excluded.provider_required'), 'error');
|
|
return;
|
|
}
|
|
|
|
if (!confirm(i18n.t('oauth_excluded.delete_confirm', { provider: providerValue }))) {
|
|
return;
|
|
}
|
|
|
|
this.updateOauthExcludedButtonsState(true);
|
|
this.setOauthExcludedStatus(i18n.t('oauth_excluded.deleting'));
|
|
|
|
try {
|
|
await this.makeRequest(`/oauth-excluded-models?provider=${encodeURIComponent(providerValue)}`, { method: 'DELETE' });
|
|
this.showNotification(i18n.t('oauth_excluded.delete_success'), 'success');
|
|
this.clearCache('oauth-excluded-models');
|
|
await this.loadOauthExcludedModels(true);
|
|
this.closeModal();
|
|
} catch (error) {
|
|
this.showNotification(`${i18n.t('oauth_excluded.delete_failed')}: ${error.message}`, 'error');
|
|
} finally {
|
|
this.setOauthExcludedStatus('');
|
|
this.updateOauthExcludedButtonsState(false);
|
|
}
|
|
},
|
|
|
|
registerAuthFilesListeners() {
|
|
if (!this.events || typeof this.events.on !== 'function') {
|
|
return;
|
|
}
|
|
this.events.on('data:config-loaded', async (event) => {
|
|
const detail = event?.detail || {};
|
|
const config = detail.config || {};
|
|
const keyStats = detail.keyStats || null;
|
|
try {
|
|
await this.loadAuthFiles(keyStats);
|
|
} catch (error) {
|
|
console.error('加载认证文件失败:', error);
|
|
}
|
|
try {
|
|
const applied = this.applyOauthExcludedFromConfig(config, { render: true });
|
|
if (!applied) {
|
|
await this.loadOauthExcludedModels(true);
|
|
}
|
|
} catch (error) {
|
|
console.error('加载 OAuth 排除列表失败:', error);
|
|
}
|
|
});
|
|
|
|
this.events.on('connection:status-changed', (event) => {
|
|
const detail = event?.detail || {};
|
|
this.updateOauthExcludedButtonsState(false);
|
|
if (detail.isConnected) {
|
|
if (!this.applyOauthExcludedFromConfig(null, { render: true })) {
|
|
this.renderOauthExcludedModels();
|
|
}
|
|
} else {
|
|
this.renderOauthExcludedModels();
|
|
}
|
|
});
|
|
}
|
|
};
|