Files
2026-11-02 22:54:14 +08:00

358 lines
16 KiB
JavaScript

// ==================== CommandsTab Computed ====================
window.CommandsTriggerTypeBuiltinMeta = window.CommandsTriggerTypeBuiltinMeta || {
request_count: {
label: '请求计数',
description: '当页面请求次数达到阈值时触发,适合每隔一段交互插入一次动作。'
},
error_count: {
label: '错误计数',
description: '当累计错误次数达到阈值时触发,适合自动恢复、告警或切换策略。'
},
idle_timeout: {
label: '空闲超时',
description: '当标签页持续空闲超过设定秒数时触发,适合长时间无响应后的兜底处理。'
},
page_check: {
label: '页面特征探测',
description: '通过文本检索或 JavaScript 注入自动检测页面状态(支持识别 Cloudflare 拦截、人机验证或 502 等异常)。'
},
command_check: {
label: '命令检查',
description: '先执行一条检查命令,再根据它某一步或最终返回值决定是否开始执行当前动作列表。'
},
command_triggered: {
label: '命令已触发',
description: '当指定命令刚刚被触发时联动执行,适合做后续补充动作。'
},
command_result_match: {
label: '命令返回结果',
description: '监听指定命令某一步或最终返回值,只有满足匹配条件时才触发。'
},
command_result_event: {
label: '命令结果事件',
description: '监听命令产生的结果事件,可按来源命令筛选,也可以只接收事件。'
},
network_request_error: {
label: '网络异常',
description: '按请求 URL 和状态码检查网络错误,命中后可立刻刷新、切代理或告警。'
}
};
window.CommandsTabComputed = {
triggerTypeOptions() {
const builtins = window.CommandsTriggerTypeBuiltinMeta || {};
const backendLabels = this.meta.trigger_types || {};
const orderedKeys = Array.from(new Set([
...Object.keys(builtins),
...Object.keys(backendLabels)
]));
return orderedKeys.map(key => ({
value: key,
label: backendLabels[key] || builtins[key]?.label || key,
description: builtins[key]?.description || '用于在满足指定条件后触发动作。'
}));
},
actionTypeOptions() {
return Object.entries(this.meta.action_types || {})
.filter(([k]) => k !== 'switch_preset')
.map(([k, v]) => ({ value: k, label: v }));
},
actionTypeGroups() {
const categoryOrder = ['页面操作', '自动化', '预设与流程', '通知与集成', '任务控制'];
const categoryMap = {
clear_cookies: '页面操作',
refresh_page: '页面操作',
new_chat: '页面操作',
run_js: '页面操作',
run_js_file: '页面操作',
wait: '页面操作',
navigate: '页面操作',
click_element: '页面操作',
click_coordinates: '页面操作',
// 补齐遗漏的分类映射,否则该动作会被 categoryMap[...] || '其他' 扔进“其他”分组
click_captcha_challenge: '页面操作',
write_element: '自动化',
read_element: '自动化',
http_request: '自动化',
append_file: '自动化',
execute_preset: '预设与流程',
execute_workflow: '预设与流程',
execute_command_group: '预设与流程',
switch_proxy: '通知与集成',
send_webhook: '通知与集成',
send_napcat: '通知与集成',
abort_task: '任务控制',
release_tab_lock: '任务控制'
};
const grouped = new Map();
for (const option of (this.actionTypeOptions || [])) {
const category = categoryMap[option.value] || '其他';
if (!grouped.has(category)) grouped.set(category, []);
grouped.get(category).push(option);
}
const dynamicOrder = Array.from(grouped.keys()).filter(name => !categoryOrder.includes(name));
return [...categoryOrder, ...dynamicOrder]
.filter(name => grouped.has(name))
.map(name => ({ label: name, options: grouped.get(name) }));
},
commandLogLevelOptions() {
return [
{ value: 'GLOBAL', label: '跟随全局' },
{ value: 'DEBUG', label: '调试' },
{ value: 'INFO', label: '信息' },
{ value: 'WARNING', label: '警告' },
{ value: 'ERROR', label: '错误' }
];
},
sourceCommandOptions() {
const currentId = this.editingCommand?.id;
return (this.commands || [])
.filter(cmd => cmd?.id && cmd.id !== currentId)
.map(cmd => ({
value: cmd.id,
label: cmd.name || cmd.id,
groupName: String(cmd.group_name || '').trim(),
enabled: cmd.enabled !== false,
searchText: [
cmd.name || '',
cmd.id || '',
String(cmd.group_name || '').trim()
].join(' ').toLowerCase()
}))
.sort((a, b) => {
const aGrouped = a.groupName ? 0 : 1;
const bGrouped = b.groupName ? 0 : 1;
if (aGrouped !== bGrouped) return aGrouped - bGrouped;
if (a.groupName !== b.groupName) {
return a.groupName.localeCompare(b.groupName, 'zh-CN');
}
return a.label.localeCompare(b.label, 'zh-CN');
});
},
selectedSourceCommandOptions() {
const ids = new Set(
Array.isArray(this.editingCommand?.trigger?.command_ids)
? this.editingCommand.trigger.command_ids.map(id => String(id || '').trim()).filter(Boolean)
: []
);
return (this.sourceCommandOptions || []).filter(opt => ids.has(opt.value));
},
selectedSourceCommandOption() {
const selectedId = String(this.editingCommand?.trigger?.command_id || '').trim();
if (!selectedId) return null;
return this.sourceCommandOptions.find(opt => opt.value === selectedId) || null;
},
filteredSourceCommandSections() {
const keyword = String(this.sourceCommandSearch || '').trim().toLowerCase();
const groupedMap = new Map();
const ungrouped = [];
for (const option of (this.sourceCommandOptions || [])) {
if (keyword && !option.searchText.includes(keyword)) {
continue;
}
if (option.groupName) {
if (!groupedMap.has(option.groupName)) {
groupedMap.set(option.groupName, []);
}
groupedMap.get(option.groupName).push(option);
} else {
ungrouped.push(option);
}
}
const groupedSections = Array.from(groupedMap.entries())
.sort((a, b) => a[0].localeCompare(b[0], 'zh-CN'))
.map(([name, commands]) => ({
key: 'group:' + name,
name,
commands
}));
if (ungrouped.length > 0) {
groupedSections.push({
key: 'group:__ungrouped__',
name: '未分组命令',
commands: ungrouped,
isUngrouped: true
});
}
return groupedSections;
},
resultSourceActionOptions() {
const sourceId = this.editingCommand?.trigger?.command_id;
if (!sourceId) return [];
return this.getCommandActionOptions(sourceId);
},
enabledCount() {
return (this.commands || []).filter(cmd => cmd.enabled).length;
},
disabledCount() {
return (this.commands || []).filter(cmd => !cmd.enabled).length;
},
displayRows() {
const rows = [];
const groupRowMap = {};
for (const cmd of (this.commands || [])) {
const groupName = String(cmd?.group_name || '').trim();
if (!groupName) {
rows.push({
key: 'cmd_' + cmd.id,
isGroup: false,
groupName: '',
commands: [cmd]
});
continue;
}
if (!groupRowMap[groupName]) {
const row = {
key: 'group_' + groupName,
isGroup: true,
groupName,
commands: []
};
groupRowMap[groupName] = row;
rows.push(row);
}
groupRowMap[groupName].commands.push(cmd);
}
return rows;
},
totalPages() {
return Math.max(1, Math.ceil((this.displayRows || []).length / this.pageSize));
},
pageStartIndex() {
if (!this.displayRows.length) return 0;
return (this.currentPage - 1) * this.pageSize + 1;
},
pageEndIndex() {
return Math.min(this.currentPage * this.pageSize, this.displayRows.length);
},
visiblePageNumbers() {
const total = this.totalPages;
const current = this.currentPage;
const start = Math.max(1, current - 2);
const end = Math.min(total, start + 4);
const adjustedStart = Math.max(1, end - 4);
return Array.from({ length: end - adjustedStart + 1 }, (_, idx) => adjustedStart + idx);
},
selectedCommands() {
if (!Array.isArray(this.selectedCommandIds) || this.selectedCommandIds.length === 0) return [];
const selectedSet = new Set(this.selectedCommandIds);
return (this.commands || []).filter(cmd => selectedSet.has(cmd.id));
},
hasSelection() {
return this.selectedCommands.length > 0;
},
commandGroups() {
const bucket = {};
for (const cmd of (this.commands || [])) {
const groupName = String(cmd?.group_name || '').trim();
if (!groupName) continue;
if (!bucket[groupName]) {
bucket[groupName] = {
name: groupName,
count: 0,
enabledCount: 0,
commandIds: []
};
}
bucket[groupName].count += 1;
bucket[groupName].enabledCount += cmd.enabled ? 1 : 0;
bucket[groupName].commandIds.push(cmd.id);
}
return Object.values(bucket).sort((a, b) => a.name.localeCompare(b.name, 'zh-CN'));
},
commandGroupOptions() {
return this.commandGroups.map(group => ({ value: group.name, label: group.name }));
},
paginatedDisplayRows() {
const start = (this.currentPage - 1) * this.pageSize;
return (this.displayRows || []).slice(start, start + this.pageSize);
},
visiblePageCommandIds() {
const ids = [];
for (const row of (this.paginatedDisplayRows || [])) {
if (row.isGroup && this.isGroupCollapsed(row.groupName)) continue;
for (const cmd of (row.commands || [])) {
ids.push(cmd.id);
}
}
return ids;
},
resolvedPresetDomain() {
return this.getBoundDomain(this.editingCommand);
},
advancedUiConfig() {
return this.editingCommand?.advanced_ui || {};
},
advancedUiFields() {
const fields = this.advancedUiConfig.fields;
return Array.isArray(fields) ? fields : [];
},
advancedUiRuleFields() {
return this.advancedUiFields.filter(field => field.type === 'rule_list');
},
advancedUiGlobalFieldGroups() {
const fields = this.advancedUiFields.filter(field => field.type !== 'rule_list');
const definitions = [
{ id: 'execution', label: '执行与内容', keys: ['total_runs', 'prompt_text', 'reference_image', 'random_insert_chars', 'wait_reply_timeout_sec'] },
{ id: 'page', label: '页面交互', keys: ['message_selector', 'send_selector', 'new_chat_selector', 'agree_selector', 'redirect_url'] },
{ id: 'retry', label: '重试与恢复', keys: ['new_chat_ready_timeout_sec', 'new_chat_retry_attempts', 'new_chat_retry_delay_sec'] },
{ id: 'integration', label: '外部集成', keys: ['link_drawer_path', 'controlled_browser_api_url', 'detector_url'] },
{ id: 'legacy', label: '兼容设置', keys: ['arena_detector_enabled', 'arena_detector_model_keyword'] },
];
const assigned = new Set();
const groups = definitions.map(definition => {
const groupedFields = definition.keys
.map(key => fields.find(field => field.key === key))
.filter(Boolean);
groupedFields.forEach(field => assigned.add(field.key));
return { ...definition, fields: groupedFields };
}).filter(group => group.fields.length);
const remaining = fields.filter(field => !assigned.has(field.key));
if (remaining.length) groups.push({ id: 'other', label: '其他设置', fields: remaining });
return groups;
},
hasAdvancedUiForm() {
return String(this.advancedUiConfig.kind || '').trim().toLowerCase() === 'form'
&& this.advancedUiFields.length > 0;
},
advancedUiTitle() {
return String(this.advancedUiConfig.title || '').trim() || '高级命令配置';
},
advancedUiDescription() {
if (this.advancedUiFields.some(field => field.type === 'rule_list')) {
return '同一轮回复会交给所有模板独立筛选;命中 URL 持久化到结果区,并可按模板写入链接抽屉分组。';
}
return String(this.advancedUiConfig.description || '').trim();
},
advancedUiResultsEnabled() {
return !!this.advancedUiConfig.results_enabled
|| this.advancedUiFields.some(field => field.type === 'rule_list');
},
scriptPlaceholder() {
if (!this.editingCommand) return '';
if (this.editingCommand.script_lang === 'javascript') {
return '// 在页面中执行的 JavaScript\n' +
'// 清除 cookies 并刷新页面\n' +
'document.cookie.split(";").forEach(c => {\n' +
' document.cookie = c.trim().split("=")[0] + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/";\n' +
'});\n' +
'location.reload();';
} else {
return '# Python 脚本\n' +
'# 默认使用受限沙箱;可用变量: tab, session, browser, config_engine, logger, time, json\n' +
'# 默认允许导入: json, time, datetime, math, requests, urllib.parse\n\n' +
'logger.info(f"当前 URL: {tab.url}")\n' +
'logger.info(f"请求次数: {session.request_count}")\n\n' +
'# 清除 cookies 并刷新\n' +
'tab.run_js("document.cookie.split(\\";\\").forEach(c => document.cookie = c.trim().split(\\"=\\")[0] + \\"=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/\\");")\n' +
'time.sleep(0.5)\n' +
'tab.refresh()';
}
}
};