2171 lines
99 KiB
JavaScript
2171 lines
99 KiB
JavaScript
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 导入
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
import { extension_settings, getContext, writeExtensionField } from "../../../../../extensions.js";
|
||
import { saveSettingsDebounced, characters, this_chid, chat, callPopup } from "../../../../../../script.js";
|
||
import { getPresetManager } from "../../../../../preset-manager.js";
|
||
import { oai_settings } from "../../../../../openai.js";
|
||
import { SlashCommandParser } from "../../../../../slash-commands/SlashCommandParser.js";
|
||
import { SlashCommand } from "../../../../../slash-commands/SlashCommand.js";
|
||
import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from "../../../../../slash-commands/SlashCommandArgument.js";
|
||
import { callGenericPopup, POPUP_TYPE } from "../../../../../popup.js";
|
||
import { accountStorage } from "../../../../../util/AccountStorage.js";
|
||
import { download, getFileText, uuidv4, debounce, getSortableDelay } from "../../../../../utils.js";
|
||
import { executeSlashCommand } from "../../core/slash-command.js";
|
||
import { EXT_ID } from "../../core/constants.js";
|
||
import { createModuleEvents, event_types } from "../../core/event-manager.js";
|
||
import { xbLog, CacheRegistry } from "../../core/debug-core.js";
|
||
import { TasksStorage } from "../../core/server-storage.js";
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 常量和默认值
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const TASKS_MODULE_NAME = "xiaobaix-tasks";
|
||
const defaultSettings = { enabled: true, globalTasks: [], processedMessages: [], character_allowed_tasks: [] };
|
||
const CONFIG = { MAX_PROCESSED: 20, MAX_COOLDOWN: 10, CLEANUP_INTERVAL: 30000, TASK_COOLDOWN: 50 };
|
||
const events = createModuleEvents('scheduledTasks');
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 数据迁移
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function migrateToServerStorage() {
|
||
const FLAG = 'LWB_tasks_migrated_server_v1';
|
||
if (localStorage.getItem(FLAG)) return;
|
||
|
||
let count = 0;
|
||
|
||
const settings = getSettings();
|
||
for (const task of (settings.globalTasks || [])) {
|
||
if (!task) continue;
|
||
if (!task.id) task.id = uuidv4();
|
||
if (task.commands) {
|
||
await TasksStorage.set(task.id, task.commands);
|
||
delete task.commands;
|
||
count++;
|
||
}
|
||
}
|
||
if (count > 0) saveSettingsDebounced();
|
||
|
||
await new Promise((resolve) => {
|
||
const req = indexedDB.open('LittleWhiteBox_TaskScripts');
|
||
req.onerror = () => resolve();
|
||
req.onsuccess = async (e) => {
|
||
const db = e.target.result;
|
||
if (!db.objectStoreNames.contains('scripts')) {
|
||
db.close();
|
||
resolve();
|
||
return;
|
||
}
|
||
try {
|
||
const tx = db.transaction('scripts', 'readonly');
|
||
const store = tx.objectStore('scripts');
|
||
const keys = await new Promise(r => {
|
||
const req = store.getAllKeys();
|
||
req.onsuccess = () => r(req.result || []);
|
||
req.onerror = () => r([]);
|
||
});
|
||
const vals = await new Promise(r => {
|
||
const req = store.getAll();
|
||
req.onsuccess = () => r(req.result || []);
|
||
req.onerror = () => r([]);
|
||
});
|
||
for (let i = 0; i < keys.length; i++) {
|
||
if (keys[i] && vals[i]) {
|
||
await TasksStorage.set(keys[i], vals[i]);
|
||
count++;
|
||
}
|
||
}
|
||
} catch (err) {
|
||
console.warn('[Tasks] IndexedDB 迁移出错:', err);
|
||
}
|
||
db.close();
|
||
indexedDB.deleteDatabase('LittleWhiteBox_TaskScripts');
|
||
resolve();
|
||
};
|
||
});
|
||
|
||
if (count > 0) {
|
||
await TasksStorage.saveNow();
|
||
console.log(`[Tasks] 已迁移 ${count} 个脚本到服务器`);
|
||
}
|
||
|
||
localStorage.setItem(FLAG, 'true');
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 状态
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
let state = {
|
||
currentEditingTask: null, currentEditingIndex: -1, currentEditingId: null, currentEditingScope: 'global',
|
||
lastChatId: null, chatJustChanged: false,
|
||
isNewChat: false, lastTurnCount: 0, executingCount: 0, isCommandGenerated: false,
|
||
taskLastExecutionTime: new Map(), cleanupTimer: null, lastTasksHash: '', taskBarVisible: true,
|
||
processedMessagesSet: new Set(),
|
||
taskBarSignature: '',
|
||
floorCounts: { all: 0, user: 0, llm: 0 },
|
||
dynamicCallbacks: new Map(),
|
||
qrObserver: null,
|
||
isUpdatingTaskBar: false,
|
||
lastPresetName: ''
|
||
};
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 工具函数
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const isAnyTaskExecuting = () => (state.executingCount || 0) > 0;
|
||
const isGloballyEnabled = () => (window.isXiaobaixEnabled !== undefined ? window.isXiaobaixEnabled : true) && getSettings().enabled;
|
||
const clampInt = (v, min, max, d = 0) => (Number.isFinite(+v) ? Math.max(min, Math.min(max, +v)) : d);
|
||
const nowMs = () => Date.now();
|
||
|
||
const normalizeTiming = (t) => (String(t || '').toLowerCase() === 'initialization' ? 'character_init' : t);
|
||
const mapTiming = (task) => ({ ...task, triggerTiming: normalizeTiming(task.triggerTiming) });
|
||
|
||
const allTasksMeta = () => [
|
||
...getSettings().globalTasks.map(mapTiming),
|
||
...getCharacterTasks().map(mapTiming),
|
||
...getPresetTasks().map(mapTiming)
|
||
];
|
||
|
||
const allTasks = allTasksMeta;
|
||
|
||
async function allTasksFull() {
|
||
const globalMeta = getSettings().globalTasks || [];
|
||
const globalTasks = await Promise.all(globalMeta.map(async (task) => ({
|
||
...task,
|
||
commands: await TasksStorage.get(task.id)
|
||
})));
|
||
return [
|
||
...globalTasks.map(mapTiming),
|
||
...getCharacterTasks().map(mapTiming),
|
||
...getPresetTasks().map(mapTiming)
|
||
];
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 设置管理
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function getSettings() {
|
||
const ext = extension_settings[EXT_ID] || (extension_settings[EXT_ID] = {});
|
||
if (!ext.tasks) ext.tasks = structuredClone(defaultSettings);
|
||
const t = ext.tasks;
|
||
if (typeof t.enabled !== 'boolean') t.enabled = defaultSettings.enabled;
|
||
if (!Array.isArray(t.globalTasks)) t.globalTasks = [];
|
||
if (!Array.isArray(t.processedMessages)) t.processedMessages = [];
|
||
if (!Array.isArray(t.character_allowed_tasks)) t.character_allowed_tasks = [];
|
||
return t;
|
||
}
|
||
|
||
function hydrateProcessedSetFromSettings() {
|
||
try {
|
||
state.processedMessagesSet = new Set(getSettings().processedMessages || []);
|
||
} catch {}
|
||
}
|
||
|
||
function scheduleCleanup() {
|
||
if (state.cleanupTimer) return;
|
||
state.cleanupTimer = setInterval(() => {
|
||
const n = nowMs();
|
||
for (const [taskName, lastTime] of state.taskLastExecutionTime.entries()) {
|
||
if (n - lastTime > CONFIG.TASK_COOLDOWN * 2) state.taskLastExecutionTime.delete(taskName);
|
||
}
|
||
if (state.taskLastExecutionTime.size > CONFIG.MAX_COOLDOWN) {
|
||
const entries = [...state.taskLastExecutionTime.entries()].sort((a, b) => b[1] - a[1]).slice(0, CONFIG.MAX_COOLDOWN);
|
||
state.taskLastExecutionTime.clear();
|
||
entries.forEach(([k, v]) => state.taskLastExecutionTime.set(k, v));
|
||
}
|
||
const settings = getSettings();
|
||
if (settings.processedMessages.length > CONFIG.MAX_PROCESSED) {
|
||
settings.processedMessages = settings.processedMessages.slice(-CONFIG.MAX_PROCESSED);
|
||
state.processedMessagesSet = new Set(settings.processedMessages);
|
||
saveSettingsDebounced();
|
||
}
|
||
}, CONFIG.CLEANUP_INTERVAL);
|
||
}
|
||
|
||
const isTaskInCooldown = (name, t = nowMs()) => {
|
||
const last = state.taskLastExecutionTime.get(name);
|
||
return last && (t - last) < CONFIG.TASK_COOLDOWN;
|
||
};
|
||
|
||
const setTaskCooldown = (name) => state.taskLastExecutionTime.set(name, nowMs());
|
||
|
||
const isMessageProcessed = (key) => state.processedMessagesSet.has(key);
|
||
|
||
function markMessageAsProcessed(key) {
|
||
if (state.processedMessagesSet.has(key)) return;
|
||
state.processedMessagesSet.add(key);
|
||
const settings = getSettings();
|
||
settings.processedMessages.push(key);
|
||
if (settings.processedMessages.length > CONFIG.MAX_PROCESSED) {
|
||
settings.processedMessages = settings.processedMessages.slice(-Math.floor(CONFIG.MAX_PROCESSED / 2));
|
||
state.processedMessagesSet = new Set(settings.processedMessages);
|
||
}
|
||
saveSettingsDebounced();
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 角色任务
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function getCharacterTasks() {
|
||
if (!this_chid || !characters[this_chid]) return [];
|
||
const c = characters[this_chid];
|
||
if (!c.data) c.data = {};
|
||
if (!c.data.extensions) c.data.extensions = {};
|
||
if (!c.data.extensions[TASKS_MODULE_NAME]) c.data.extensions[TASKS_MODULE_NAME] = { tasks: [] };
|
||
const list = c.data.extensions[TASKS_MODULE_NAME].tasks;
|
||
if (!Array.isArray(list)) c.data.extensions[TASKS_MODULE_NAME].tasks = [];
|
||
return c.data.extensions[TASKS_MODULE_NAME].tasks;
|
||
}
|
||
|
||
async function saveCharacterTasks(tasks) {
|
||
if (!this_chid || !characters[this_chid]) return;
|
||
await writeExtensionField(Number(this_chid), TASKS_MODULE_NAME, { tasks });
|
||
try {
|
||
if (!characters[this_chid].data) characters[this_chid].data = {};
|
||
if (!characters[this_chid].data.extensions) characters[this_chid].data.extensions = {};
|
||
if (!characters[this_chid].data.extensions[TASKS_MODULE_NAME]) characters[this_chid].data.extensions[TASKS_MODULE_NAME] = { tasks: [] };
|
||
characters[this_chid].data.extensions[TASKS_MODULE_NAME].tasks = tasks;
|
||
} catch {}
|
||
const settings = getSettings();
|
||
const avatar = characters[this_chid].avatar;
|
||
if (avatar && !settings.character_allowed_tasks?.includes(avatar)) {
|
||
settings.character_allowed_tasks ??= [];
|
||
settings.character_allowed_tasks.push(avatar);
|
||
saveSettingsDebounced();
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 预设任务
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const PRESET_TASK_FIELD = 'scheduledTasks';
|
||
const PRESET_PROMPT_ORDER_CHARACTER_ID = 100000;
|
||
const presetTasksState = { name: '', tasks: [] };
|
||
|
||
const PresetTasksStore = (() => {
|
||
const isPlainObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
|
||
const deepClone = (value) => {
|
||
if (value === undefined) return undefined;
|
||
if (typeof structuredClone === 'function') {
|
||
try { return structuredClone(value); } catch {}
|
||
}
|
||
try { return JSON.parse(JSON.stringify(value)); } catch { return value; }
|
||
};
|
||
|
||
const getPresetManagerSafe = () => {
|
||
try { return getPresetManager('openai'); } catch { return null; }
|
||
};
|
||
|
||
const getPresetSnapshot = (manager, name) => {
|
||
if (!manager || !name) return { source: null, clone: null };
|
||
let source = null;
|
||
try {
|
||
if (typeof manager.getCompletionPresetByName === 'function') {
|
||
source = manager.getCompletionPresetByName(name) || null;
|
||
}
|
||
} catch {}
|
||
if (!source) {
|
||
try { source = manager.getPresetSettings?.(name) || null; } catch { source = null; }
|
||
}
|
||
if (!source) return { source: null, clone: null };
|
||
return { source, clone: deepClone(source) };
|
||
};
|
||
|
||
const syncTarget = (target, source) => {
|
||
if (!target || !source) return;
|
||
Object.keys(target).forEach((key) => {
|
||
if (!Object.prototype.hasOwnProperty.call(source, key)) delete target[key];
|
||
});
|
||
Object.assign(target, source);
|
||
};
|
||
|
||
const ensurePromptOrderEntry = (preset, create = false) => {
|
||
if (!preset) return null;
|
||
if (!Array.isArray(preset.prompt_order)) {
|
||
if (!create) return null;
|
||
preset.prompt_order = [];
|
||
}
|
||
let entry = preset.prompt_order.find(item => Number(item?.character_id) === PRESET_PROMPT_ORDER_CHARACTER_ID);
|
||
if (!entry && create) {
|
||
entry = { character_id: PRESET_PROMPT_ORDER_CHARACTER_ID, order: [] };
|
||
preset.prompt_order.push(entry);
|
||
}
|
||
return entry || null;
|
||
};
|
||
|
||
const currentName = () => {
|
||
try { return getPresetManagerSafe()?.getSelectedPresetName?.() || ''; } catch { return ''; }
|
||
};
|
||
|
||
const read = (name) => {
|
||
if (!name) return [];
|
||
const manager = getPresetManagerSafe();
|
||
if (!manager) return [];
|
||
const { clone } = getPresetSnapshot(manager, name);
|
||
if (!clone) return [];
|
||
const entry = ensurePromptOrderEntry(clone, false);
|
||
if (!entry || !isPlainObject(entry.xiaobai_ext)) return [];
|
||
const tasks = entry.xiaobai_ext[PRESET_TASK_FIELD];
|
||
return Array.isArray(tasks) ? deepClone(tasks) : [];
|
||
};
|
||
|
||
const write = async (name, tasks) => {
|
||
if (!name) return;
|
||
const manager = getPresetManagerSafe();
|
||
if (!manager) return;
|
||
const { source, clone } = getPresetSnapshot(manager, name);
|
||
if (!clone) return;
|
||
const shouldCreate = Array.isArray(tasks) && tasks.length > 0;
|
||
const entry = ensurePromptOrderEntry(clone, shouldCreate);
|
||
if (entry) {
|
||
entry.xiaobai_ext = isPlainObject(entry.xiaobai_ext) ? entry.xiaobai_ext : {};
|
||
if (shouldCreate) {
|
||
entry.xiaobai_ext[PRESET_TASK_FIELD] = deepClone(tasks);
|
||
} else {
|
||
if (entry.xiaobai_ext) delete entry.xiaobai_ext[PRESET_TASK_FIELD];
|
||
if (entry.xiaobai_ext && Object.keys(entry.xiaobai_ext).length === 0) delete entry.xiaobai_ext;
|
||
}
|
||
}
|
||
await manager.savePreset(name, clone, { skipUpdate: true });
|
||
syncTarget(source, clone);
|
||
const activeName = manager.getSelectedPresetName?.();
|
||
if (activeName && activeName === name && Object.prototype.hasOwnProperty.call(clone, 'prompt_order')) {
|
||
try { oai_settings.prompt_order = structuredClone(clone.prompt_order); } catch { oai_settings.prompt_order = clone.prompt_order; }
|
||
}
|
||
};
|
||
|
||
return { currentName, read, write };
|
||
})();
|
||
|
||
const ensurePresetTaskIds = (tasks) => {
|
||
let mutated = false;
|
||
tasks?.forEach(task => {
|
||
if (task && !task.id) {
|
||
task.id = uuidv4();
|
||
mutated = true;
|
||
}
|
||
});
|
||
return mutated;
|
||
};
|
||
|
||
function resetPresetTasksCache() {
|
||
presetTasksState.name = '';
|
||
presetTasksState.tasks = [];
|
||
}
|
||
|
||
function getPresetTasks() {
|
||
const name = PresetTasksStore.currentName();
|
||
if (!name) {
|
||
resetPresetTasksCache();
|
||
return presetTasksState.tasks;
|
||
}
|
||
if (presetTasksState.name !== name || !presetTasksState.tasks.length) {
|
||
const loaded = PresetTasksStore.read(name) || [];
|
||
ensurePresetTaskIds(loaded);
|
||
presetTasksState.name = name;
|
||
presetTasksState.tasks = Array.isArray(loaded) ? loaded : [];
|
||
}
|
||
return presetTasksState.tasks;
|
||
}
|
||
|
||
async function savePresetTasks(tasks) {
|
||
const name = PresetTasksStore.currentName();
|
||
if (!name) return;
|
||
const list = Array.isArray(tasks) ? tasks : [];
|
||
ensurePresetTaskIds(list);
|
||
presetTasksState.name = name;
|
||
presetTasksState.tasks = list;
|
||
await PresetTasksStore.write(name, list);
|
||
state.lastTasksHash = '';
|
||
updatePresetTaskHint();
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 任务列表操作
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const getTaskListByScope = (scope) => {
|
||
if (scope === 'character') return getCharacterTasks();
|
||
if (scope === 'preset') return getPresetTasks();
|
||
return getSettings().globalTasks;
|
||
};
|
||
|
||
async function persistTaskListByScope(scope, tasks) {
|
||
if (scope === 'character') return await saveCharacterTasks(tasks);
|
||
if (scope === 'preset') return await savePresetTasks(tasks);
|
||
|
||
const metaOnly = [];
|
||
for (const task of tasks) {
|
||
if (!task) continue;
|
||
if (!task.id) task.id = uuidv4();
|
||
|
||
if (Object.prototype.hasOwnProperty.call(task, 'commands')) {
|
||
await TasksStorage.set(task.id, String(task.commands ?? ''));
|
||
}
|
||
|
||
const meta = { ...task };
|
||
delete meta.commands;
|
||
metaOnly.push(meta);
|
||
}
|
||
|
||
getSettings().globalTasks = metaOnly;
|
||
saveSettingsDebounced();
|
||
}
|
||
|
||
async function removeTaskByScope(scope, taskId, fallbackIndex = -1) {
|
||
const list = getTaskListByScope(scope);
|
||
const idx = taskId ? list.findIndex(t => t?.id === taskId) : fallbackIndex;
|
||
if (idx < 0 || idx >= list.length) return;
|
||
|
||
const task = list[idx];
|
||
if (scope === 'global' && task?.id) {
|
||
await TasksStorage.delete(task.id);
|
||
}
|
||
|
||
list.splice(idx, 1);
|
||
await persistTaskListByScope(scope, [...list]);
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 任务运行管理
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const __taskRunMap = new Map();
|
||
|
||
CacheRegistry.register('scheduledTasks', {
|
||
name: '循环任务状态',
|
||
getSize: () => {
|
||
try {
|
||
const a = state.processedMessagesSet?.size || 0;
|
||
const b = state.taskLastExecutionTime?.size || 0;
|
||
const c = state.dynamicCallbacks?.size || 0;
|
||
const d = __taskRunMap.size || 0;
|
||
const e = TasksStorage.getCacheSize() || 0;
|
||
return a + b + c + d + e;
|
||
} catch { return 0; }
|
||
},
|
||
getBytes: () => {
|
||
try {
|
||
let total = 0;
|
||
const addStr = (v) => { total += String(v ?? '').length * 2; };
|
||
const addSet = (s) => { if (!s?.forEach) return; s.forEach(v => addStr(v)); };
|
||
const addMap = (m, addValue = null) => {
|
||
if (!m?.forEach) return;
|
||
m.forEach((v, k) => { addStr(k); if (typeof addValue === 'function') addValue(v); });
|
||
};
|
||
addSet(state.processedMessagesSet);
|
||
addMap(state.taskLastExecutionTime, (v) => addStr(v));
|
||
addMap(state.dynamicCallbacks, (entry) => {
|
||
addStr(entry?.options?.timing);
|
||
addStr(entry?.options?.floorType);
|
||
addStr(entry?.options?.interval);
|
||
try { addStr(entry?.callback?.toString?.()); } catch {}
|
||
});
|
||
addMap(__taskRunMap, (entry) => {
|
||
addStr(entry?.signature);
|
||
total += (entry?.timers?.size || 0) * 8;
|
||
total += (entry?.intervals?.size || 0) * 8;
|
||
});
|
||
total += TasksStorage.getCacheBytes();
|
||
return total;
|
||
} catch { return 0; }
|
||
},
|
||
clear: () => {
|
||
try {
|
||
state.processedMessagesSet?.clear?.();
|
||
state.taskLastExecutionTime?.clear?.();
|
||
TasksStorage.clearCache();
|
||
const s = getSettings();
|
||
if (s?.processedMessages) s.processedMessages = [];
|
||
saveSettingsDebounced();
|
||
} catch {}
|
||
try {
|
||
for (const [id, entry] of state.dynamicCallbacks.entries()) {
|
||
try { entry?.abortController?.abort?.(); } catch {}
|
||
state.dynamicCallbacks.delete(id);
|
||
}
|
||
} catch {}
|
||
},
|
||
getDetail: () => {
|
||
try {
|
||
return {
|
||
processedMessages: state.processedMessagesSet?.size || 0,
|
||
cooldown: state.taskLastExecutionTime?.size || 0,
|
||
dynamicCallbacks: state.dynamicCallbacks?.size || 0,
|
||
runningSingleInstances: __taskRunMap.size || 0,
|
||
scriptCache: TasksStorage.getCacheSize() || 0,
|
||
};
|
||
} catch { return {}; }
|
||
},
|
||
});
|
||
|
||
async function __runTaskSingleInstance(taskName, jsRunner, signature = null) {
|
||
const existing = __taskRunMap.get(taskName);
|
||
if (existing) {
|
||
try { existing.abort?.abort?.(); } catch {}
|
||
try { await Promise.resolve(existing.completion).catch(() => {}); } catch {}
|
||
__taskRunMap.delete(taskName);
|
||
}
|
||
|
||
const abort = new AbortController();
|
||
const timers = new Set();
|
||
const intervals = new Set();
|
||
const entry = { abort, timers, intervals, signature, completion: null };
|
||
__taskRunMap.set(taskName, entry);
|
||
|
||
const addListener = (target, type, handler, opts = {}) => {
|
||
if (!target?.addEventListener) return;
|
||
target.addEventListener(type, handler, { ...opts, signal: abort.signal });
|
||
};
|
||
const setTimeoutSafe = (fn, t, ...a) => {
|
||
const id = setTimeout(() => {
|
||
timers.delete(id);
|
||
try { fn(...a); } catch (e) { console.error(e); }
|
||
}, t);
|
||
timers.add(id);
|
||
return id;
|
||
};
|
||
const clearTimeoutSafe = (id) => { clearTimeout(id); timers.delete(id); };
|
||
const setIntervalSafe = (fn, t, ...a) => {
|
||
const id = setInterval(fn, t, ...a);
|
||
intervals.add(id);
|
||
return id;
|
||
};
|
||
const clearIntervalSafe = (id) => { clearInterval(id); intervals.delete(id); };
|
||
|
||
entry.completion = (async () => {
|
||
try {
|
||
await jsRunner({ addListener, setTimeoutSafe, clearTimeoutSafe, setIntervalSafe, clearIntervalSafe, abortSignal: abort.signal });
|
||
} finally {
|
||
try { abort.abort(); } catch {}
|
||
try {
|
||
timers.forEach((id) => clearTimeout(id));
|
||
intervals.forEach((id) => clearInterval(id));
|
||
} catch {}
|
||
try { window?.dispatchEvent?.(new CustomEvent('xiaobaix-task-cleaned', { detail: { taskName, signature } })); } catch {}
|
||
__taskRunMap.delete(taskName);
|
||
}
|
||
})();
|
||
|
||
return entry.completion;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 命令执行
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function executeCommands(commands, taskName) {
|
||
if (!String(commands || '').trim()) return null;
|
||
state.isCommandGenerated = true;
|
||
state.executingCount = Math.max(0, (state.executingCount || 0) + 1);
|
||
try {
|
||
return await processTaskCommands(commands, taskName);
|
||
} finally {
|
||
setTimeout(() => {
|
||
state.executingCount = Math.max(0, (state.executingCount || 0) - 1);
|
||
if (!isAnyTaskExecuting()) state.isCommandGenerated = false;
|
||
}, 500);
|
||
}
|
||
}
|
||
|
||
async function processTaskCommands(commands, taskName) {
|
||
const jsTagRegex = /<<taskjs>>([\s\S]*?)<<\/taskjs>>/g;
|
||
let lastIndex = 0, result = null, match;
|
||
|
||
while ((match = jsTagRegex.exec(commands)) !== null) {
|
||
const beforeJs = commands.slice(lastIndex, match.index).trim();
|
||
if (beforeJs) result = await executeSlashCommand(beforeJs);
|
||
const jsCode = match[1].trim();
|
||
if (jsCode) {
|
||
try { await executeTaskJS(jsCode, taskName || 'AnonymousTask'); }
|
||
catch (error) {
|
||
console.error(`[任务JS执行错误] ${error.message}`);
|
||
try { xbLog.error('scheduledTasks', `taskjs error task=${String(taskName || 'AnonymousTask')}`, error); } catch {}
|
||
}
|
||
}
|
||
lastIndex = match.index + match[0].length;
|
||
}
|
||
|
||
if (lastIndex === 0) {
|
||
result = await executeSlashCommand(commands);
|
||
} else {
|
||
const remaining = commands.slice(lastIndex).trim();
|
||
if (remaining) result = await executeSlashCommand(remaining);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function __hashStringForKey(str) {
|
||
try {
|
||
let hash = 5381;
|
||
for (let i = 0; i < str.length; i++) {
|
||
hash = ((hash << 5) + hash) ^ str.charCodeAt(i);
|
||
}
|
||
return (hash >>> 0).toString(36);
|
||
} catch { return Math.random().toString(36).slice(2); }
|
||
}
|
||
|
||
async function executeTaskJS(jsCode, taskName = 'AnonymousTask') {
|
||
const STscript = async (command) => {
|
||
if (!command) return { error: "命令为空" };
|
||
if (!command.startsWith('/')) command = '/' + command;
|
||
return await executeSlashCommand(command);
|
||
};
|
||
|
||
const codeSig = __hashStringForKey(String(jsCode || ''));
|
||
const stableKey = (String(taskName || '').trim()) || `js-${codeSig}`;
|
||
const isLightTask = stableKey.startsWith('[x]');
|
||
|
||
const taskContext = {
|
||
taskName: String(taskName || 'AnonymousTask'),
|
||
stableKey,
|
||
codeSig,
|
||
log: (msg, extra) => { try { xbLog.info('scheduledTasks', { task: stableKey, msg: String(msg ?? ''), extra }); } catch {} },
|
||
warn: (msg, extra) => { try { xbLog.warn('scheduledTasks', { task: stableKey, msg: String(msg ?? ''), extra }); } catch {} },
|
||
error: (msg, err, extra) => { try { xbLog.error('scheduledTasks', { task: stableKey, msg: String(msg ?? ''), extra }, err || null); } catch {} }
|
||
};
|
||
|
||
const old = __taskRunMap.get(stableKey);
|
||
if (old) {
|
||
try { old.abort?.abort?.(); } catch {}
|
||
if (!isLightTask) {
|
||
try { await Promise.resolve(old.completion).catch(() => {}); } catch {}
|
||
}
|
||
__taskRunMap.delete(stableKey);
|
||
}
|
||
|
||
const callbackPrefix = `${stableKey}_fl_`;
|
||
for (const [id, entry] of state.dynamicCallbacks.entries()) {
|
||
if (id.startsWith(callbackPrefix)) {
|
||
try { entry?.abortController?.abort(); } catch {}
|
||
state.dynamicCallbacks.delete(id);
|
||
}
|
||
}
|
||
|
||
const jsRunner = async (utils) => {
|
||
const { addListener, setTimeoutSafe, clearTimeoutSafe, setIntervalSafe, clearIntervalSafe, abortSignal } = utils;
|
||
|
||
const originalWindowFns = {
|
||
setTimeout: window.setTimeout,
|
||
clearTimeout: window.clearTimeout,
|
||
setInterval: window.setInterval,
|
||
clearInterval: window.clearInterval,
|
||
};
|
||
|
||
const originals = {
|
||
setTimeout: originalWindowFns.setTimeout.bind(window),
|
||
clearTimeout: originalWindowFns.clearTimeout.bind(window),
|
||
setInterval: originalWindowFns.setInterval.bind(window),
|
||
clearInterval: originalWindowFns.clearInterval.bind(window),
|
||
addEventListener: EventTarget.prototype.addEventListener,
|
||
removeEventListener: EventTarget.prototype.removeEventListener,
|
||
appendChild: Node.prototype.appendChild,
|
||
insertBefore: Node.prototype.insertBefore,
|
||
replaceChild: Node.prototype.replaceChild,
|
||
};
|
||
|
||
const timeouts = new Set();
|
||
const intervals = new Set();
|
||
const listeners = new Set();
|
||
const createdNodes = new Set();
|
||
const waiters = new Set();
|
||
|
||
const notifyActivityChange = () => {
|
||
if (waiters.size === 0) return;
|
||
for (const cb of Array.from(waiters)) { try { cb(); } catch {} }
|
||
};
|
||
|
||
const normalizeListenerOptions = (options) => (typeof options === 'boolean' ? options : !!options?.capture);
|
||
|
||
window.setTimeout = function(fn, t, ...args) {
|
||
const id = originals.setTimeout(function(...inner) {
|
||
try { fn?.(...inner); } finally { timeouts.delete(id); notifyActivityChange(); }
|
||
}, t, ...args);
|
||
timeouts.add(id);
|
||
notifyActivityChange();
|
||
return id;
|
||
};
|
||
window.clearTimeout = function(id) { originals.clearTimeout(id); timeouts.delete(id); notifyActivityChange(); };
|
||
window.setInterval = function(fn, t, ...args) { const id = originals.setInterval(fn, t, ...args); intervals.add(id); notifyActivityChange(); return id; };
|
||
window.clearInterval = function(id) { originals.clearInterval(id); intervals.delete(id); notifyActivityChange(); };
|
||
|
||
const addListenerEntry = (entry) => { listeners.add(entry); notifyActivityChange(); };
|
||
const removeListenerEntry = (target, type, listener, options) => {
|
||
let removed = false;
|
||
for (const entry of listeners) {
|
||
if (entry.target === target && entry.type === type && entry.listener === listener && entry.capture === normalizeListenerOptions(options)) {
|
||
listeners.delete(entry);
|
||
removed = true;
|
||
break;
|
||
}
|
||
}
|
||
if (removed) notifyActivityChange();
|
||
};
|
||
|
||
EventTarget.prototype.addEventListener = function(type, listener, options) {
|
||
addListenerEntry({ target: this, type, listener, capture: normalizeListenerOptions(options) });
|
||
return originals.addEventListener.call(this, type, listener, options);
|
||
};
|
||
EventTarget.prototype.removeEventListener = function(type, listener, options) {
|
||
removeListenerEntry(this, type, listener, options);
|
||
return originals.removeEventListener.call(this, type, listener, options);
|
||
};
|
||
|
||
const trackNode = (node) => { try { if (node && node.nodeType === 1) createdNodes.add(node); } catch {} };
|
||
Node.prototype.appendChild = function(child) { trackNode(child); return originals.appendChild.call(this, child); };
|
||
Node.prototype.insertBefore = function(newNode, refNode) { trackNode(newNode); return originals.insertBefore.call(this, newNode, refNode); };
|
||
Node.prototype.replaceChild = function(newNode, oldNode) { trackNode(newNode); return originals.replaceChild.call(this, newNode, oldNode); };
|
||
|
||
const restoreGlobals = () => {
|
||
window.setTimeout = originalWindowFns.setTimeout;
|
||
window.clearTimeout = originalWindowFns.clearTimeout;
|
||
window.setInterval = originalWindowFns.setInterval;
|
||
window.clearInterval = originalWindowFns.clearInterval;
|
||
EventTarget.prototype.addEventListener = originals.addEventListener;
|
||
EventTarget.prototype.removeEventListener = originals.removeEventListener;
|
||
Node.prototype.appendChild = originals.appendChild;
|
||
Node.prototype.insertBefore = originals.insertBefore;
|
||
Node.prototype.replaceChild = originals.replaceChild;
|
||
};
|
||
|
||
const hardCleanup = () => {
|
||
try { timeouts.forEach(id => originals.clearTimeout(id)); } catch {}
|
||
try { intervals.forEach(id => originals.clearInterval(id)); } catch {}
|
||
try {
|
||
for (const entry of listeners) {
|
||
const { target, type, listener, capture } = entry;
|
||
originals.removeEventListener.call(target, type, listener, capture);
|
||
}
|
||
} catch {}
|
||
try {
|
||
createdNodes.forEach(node => {
|
||
if (!node?.parentNode) return;
|
||
if (node.id?.startsWith('xiaobaix_') || node.tagName === 'SCRIPT' || node.tagName === 'STYLE') {
|
||
try { node.parentNode.removeChild(node); } catch {}
|
||
}
|
||
});
|
||
} catch {}
|
||
listeners.clear();
|
||
waiters.clear();
|
||
};
|
||
|
||
const addFloorListener = (callback, options = {}) => {
|
||
if (typeof callback !== 'function') throw new Error('callback 必须是函数');
|
||
const callbackId = `${stableKey}_fl_${uuidv4()}`;
|
||
const entryAbort = new AbortController();
|
||
try { abortSignal.addEventListener('abort', () => { try { entryAbort.abort(); } catch {} state.dynamicCallbacks.delete(callbackId); }); } catch {}
|
||
state.dynamicCallbacks.set(callbackId, {
|
||
callback,
|
||
options: {
|
||
interval: Number.isFinite(parseInt(options.interval)) ? parseInt(options.interval) : 0,
|
||
timing: options.timing || 'after_ai',
|
||
floorType: options.floorType || 'all'
|
||
},
|
||
abortController: entryAbort
|
||
});
|
||
return () => { try { entryAbort.abort(); } catch {} state.dynamicCallbacks.delete(callbackId); };
|
||
};
|
||
|
||
const runInScope = async (code) => {
|
||
// eslint-disable-next-line no-new-func -- intentional: user-defined task expression
|
||
const fn = new Function(
|
||
'taskContext', 'ctx', 'STscript', 'addFloorListener',
|
||
'addListener', 'setTimeoutSafe', 'clearTimeoutSafe', 'setIntervalSafe', 'clearIntervalSafe', 'abortSignal',
|
||
`return (async () => { ${code} })();`
|
||
);
|
||
return await fn(taskContext, taskContext, STscript, addFloorListener, addListener, setTimeoutSafe, clearTimeoutSafe, setIntervalSafe, clearIntervalSafe, abortSignal);
|
||
};
|
||
|
||
const hasActiveResources = () => (timeouts.size > 0 || intervals.size > 0 || listeners.size > 0);
|
||
|
||
const waitForAsyncSettled = () => new Promise((resolve) => {
|
||
if (abortSignal?.aborted) return resolve();
|
||
if (!hasActiveResources()) return resolve();
|
||
let finished = false;
|
||
const finalize = () => { if (finished) return; finished = true; waiters.delete(checkStatus); try { abortSignal?.removeEventListener?.('abort', finalize); } catch {} resolve(); };
|
||
const checkStatus = () => { if (finished) return; if (abortSignal?.aborted) return finalize(); if (!hasActiveResources()) finalize(); };
|
||
waiters.add(checkStatus);
|
||
try { abortSignal?.addEventListener?.('abort', finalize, { once: true }); } catch {}
|
||
checkStatus();
|
||
});
|
||
|
||
try {
|
||
await runInScope(jsCode);
|
||
await waitForAsyncSettled();
|
||
} finally {
|
||
try { hardCleanup(); } finally { restoreGlobals(); }
|
||
}
|
||
};
|
||
|
||
if (isLightTask) {
|
||
__runTaskSingleInstance(stableKey, jsRunner, codeSig);
|
||
return;
|
||
}
|
||
|
||
await __runTaskSingleInstance(stableKey, jsRunner, codeSig);
|
||
}
|
||
|
||
function handleTaskMessage(event) {
|
||
if (!event.data || event.data.source !== 'xiaobaix-iframe' || event.data.type !== 'executeTaskJS') return;
|
||
try {
|
||
const script = document.createElement('script');
|
||
script.textContent = event.data.code;
|
||
event.source.document.head.appendChild(script);
|
||
event.source.document.head.removeChild(script);
|
||
} catch (error) { console.error('执行任务JS失败:', error); }
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 楼层计数
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function getFloorCounts() {
|
||
return state.floorCounts || { all: 0, user: 0, llm: 0 };
|
||
}
|
||
|
||
function pickFloorByType(floorType, counts) {
|
||
switch (floorType) {
|
||
case 'user': return Math.max(0, counts.user - 1);
|
||
case 'llm': return Math.max(0, counts.llm - 1);
|
||
default: return Math.max(0, counts.all - 1);
|
||
}
|
||
}
|
||
|
||
function calculateTurnCount() {
|
||
if (!Array.isArray(chat) || chat.length === 0) return 0;
|
||
const userMessages = chat.filter(msg => msg.is_user && !msg.is_system).length;
|
||
const aiMessages = chat.filter(msg => !msg.is_user && !msg.is_system).length;
|
||
return Math.min(userMessages, aiMessages);
|
||
}
|
||
|
||
function recountFloors() {
|
||
let user = 0, llm = 0, all = 0;
|
||
if (Array.isArray(chat)) {
|
||
for (const m of chat) {
|
||
all++;
|
||
if (m.is_system) continue;
|
||
if (m.is_user) user++; else llm++;
|
||
}
|
||
}
|
||
state.floorCounts = { all, user, llm };
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 任务触发
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function shouldSkipByContext(taskTriggerTiming, triggerContext) {
|
||
if (taskTriggerTiming === 'character_init') return triggerContext !== 'chat_created';
|
||
if (taskTriggerTiming === 'plugin_init') return triggerContext !== 'plugin_initialized';
|
||
if (taskTriggerTiming === 'chat_changed') return triggerContext !== 'chat_changed';
|
||
if (taskTriggerTiming === 'only_this_floor' || taskTriggerTiming === 'any_message') {
|
||
return triggerContext !== 'before_user' && triggerContext !== 'after_ai';
|
||
}
|
||
return taskTriggerTiming !== triggerContext;
|
||
}
|
||
|
||
function matchInterval(task, counts, triggerContext) {
|
||
const currentFloor = pickFloorByType(task.floorType || 'all', counts);
|
||
if (currentFloor <= 0) return false;
|
||
if (task.triggerTiming === 'only_this_floor') return currentFloor === task.interval;
|
||
if (task.triggerTiming === 'any_message') return currentFloor % task.interval === 0;
|
||
return currentFloor % task.interval === 0;
|
||
}
|
||
|
||
async function checkAndExecuteTasks(triggerContext = 'after_ai', overrideChatChanged = null, overrideNewChat = null) {
|
||
if (!isGloballyEnabled() || isAnyTaskExecuting()) return;
|
||
|
||
const tasks = await allTasksFull();
|
||
const n = nowMs();
|
||
const counts = getFloorCounts();
|
||
|
||
const dynamicTaskList = [];
|
||
if (state.dynamicCallbacks?.size > 0) {
|
||
for (const [callbackId, entry] of state.dynamicCallbacks.entries()) {
|
||
const { callback, options, abortController } = entry || {};
|
||
if (!callback) { state.dynamicCallbacks.delete(callbackId); continue; }
|
||
if (abortController?.signal?.aborted) { state.dynamicCallbacks.delete(callbackId); continue; }
|
||
const interval = Number.isFinite(parseInt(options?.interval)) ? parseInt(options.interval) : 0;
|
||
dynamicTaskList.push({
|
||
name: callbackId,
|
||
disabled: false,
|
||
interval,
|
||
floorType: options?.floorType || 'all',
|
||
triggerTiming: options?.timing || 'after_ai',
|
||
__dynamic: true,
|
||
__callback: callback
|
||
});
|
||
}
|
||
}
|
||
|
||
const combined = [...tasks, ...dynamicTaskList];
|
||
if (combined.length === 0) return;
|
||
|
||
const tasksToExecute = combined.filter(task => {
|
||
if (task.disabled) return false;
|
||
if (isTaskInCooldown(task.name, n)) return false;
|
||
const tt = task.triggerTiming || 'after_ai';
|
||
if (tt === 'chat_changed') {
|
||
if (shouldSkipByContext(tt, triggerContext)) return false;
|
||
return true;
|
||
}
|
||
if (tt === 'character_init') return triggerContext === 'chat_created';
|
||
if (tt === 'plugin_init') return triggerContext === 'plugin_initialized';
|
||
if ((overrideChatChanged ?? state.chatJustChanged) || (overrideNewChat ?? state.isNewChat)) return false;
|
||
if (task.interval <= 0) return false;
|
||
if (shouldSkipByContext(tt, triggerContext)) return false;
|
||
return matchInterval(task, counts, triggerContext);
|
||
});
|
||
|
||
if (tasksToExecute.length === 0) return;
|
||
|
||
state.executingCount = Math.max(0, (state.executingCount || 0) + 1);
|
||
try {
|
||
for (const task of tasksToExecute) {
|
||
state.taskLastExecutionTime.set(task.name, n);
|
||
if (task.__dynamic) {
|
||
try {
|
||
const currentFloor = pickFloorByType(task.floorType || 'all', counts);
|
||
await Promise.resolve().then(() => task.__callback({
|
||
timing: triggerContext,
|
||
floors: counts,
|
||
currentFloor,
|
||
interval: task.interval,
|
||
floorType: task.floorType || 'all'
|
||
}));
|
||
} catch (e) { console.error('[动态回调错误]', task.name, e); }
|
||
} else {
|
||
await executeCommands(task.commands, task.name);
|
||
}
|
||
}
|
||
} finally {
|
||
state.executingCount = Math.max(0, (state.executingCount || 0) - 1);
|
||
}
|
||
|
||
if (triggerContext === 'after_ai') state.lastTurnCount = calculateTurnCount();
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 事件处理
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function onMessageReceived(messageId) {
|
||
if (typeof messageId !== 'number' || messageId < 0 || !chat[messageId]) return;
|
||
const message = chat[messageId];
|
||
if (message.is_user || message.is_system || message.mes === '...' ||
|
||
state.isCommandGenerated || isAnyTaskExecuting() ||
|
||
(message.swipe_id !== undefined && message.swipe_id > 0)) return;
|
||
if (!isGloballyEnabled()) return;
|
||
const messageKey = `${getContext().chatId}_${messageId}_${message.send_date || nowMs()}`;
|
||
if (isMessageProcessed(messageKey)) return;
|
||
markMessageAsProcessed(messageKey);
|
||
try { state.floorCounts.all = Math.max(0, (state.floorCounts.all || 0) + 1); state.floorCounts.llm = Math.max(0, (state.floorCounts.llm || 0) + 1); } catch {}
|
||
await checkAndExecuteTasks('after_ai');
|
||
state.chatJustChanged = state.isNewChat = false;
|
||
}
|
||
|
||
async function onGenerationEnded(chatLen) {
|
||
const len = Number(chatLen);
|
||
if (!Number.isFinite(len) || len <= 0) return;
|
||
await onMessageReceived(len - 1);
|
||
}
|
||
|
||
async function onUserMessage() {
|
||
if (!isGloballyEnabled()) return;
|
||
const messageKey = `${getContext().chatId}_user_${chat.length}`;
|
||
if (isMessageProcessed(messageKey)) return;
|
||
markMessageAsProcessed(messageKey);
|
||
try { state.floorCounts.all = Math.max(0, (state.floorCounts.all || 0) + 1); state.floorCounts.user = Math.max(0, (state.floorCounts.user || 0) + 1); } catch {}
|
||
await checkAndExecuteTasks('before_user');
|
||
state.chatJustChanged = state.isNewChat = false;
|
||
}
|
||
|
||
function onMessageDeleted() {
|
||
const settings = getSettings();
|
||
const chatId = getContext().chatId;
|
||
settings.processedMessages = settings.processedMessages.filter(key => !key.startsWith(`${chatId}_`));
|
||
state.processedMessagesSet = new Set(settings.processedMessages);
|
||
state.executingCount = 0;
|
||
state.isCommandGenerated = false;
|
||
recountFloors();
|
||
saveSettingsDebounced();
|
||
}
|
||
|
||
async function onChatChanged(chatId) {
|
||
Object.assign(state, {
|
||
chatJustChanged: true,
|
||
isNewChat: state.lastChatId !== chatId && chat.length <= 1,
|
||
lastChatId: chatId,
|
||
lastTurnCount: 0,
|
||
executingCount: 0,
|
||
isCommandGenerated: false
|
||
});
|
||
state.taskLastExecutionTime.clear();
|
||
TasksStorage.clearCache();
|
||
|
||
requestAnimationFrame(() => {
|
||
state.processedMessagesSet.clear();
|
||
const settings = getSettings();
|
||
settings.processedMessages = [];
|
||
checkEmbeddedTasks();
|
||
refreshUI();
|
||
checkAndExecuteTasks('chat_changed', false, false);
|
||
requestAnimationFrame(() => requestAnimationFrame(() => { try { updateTaskBar(); } catch {} }));
|
||
});
|
||
|
||
recountFloors();
|
||
setTimeout(() => { state.chatJustChanged = state.isNewChat = false; }, 2000);
|
||
}
|
||
|
||
async function onChatCreated() {
|
||
Object.assign(state, { isNewChat: true, chatJustChanged: true });
|
||
recountFloors();
|
||
await checkAndExecuteTasks('chat_created', false, false);
|
||
}
|
||
|
||
function onPresetChanged(event) {
|
||
const apiId = event?.apiId;
|
||
if (apiId && apiId !== 'openai') return;
|
||
resetPresetTasksCache();
|
||
state.lastTasksHash = '';
|
||
refreshUI();
|
||
}
|
||
|
||
function onMainApiChanged() {
|
||
resetPresetTasksCache();
|
||
state.lastTasksHash = '';
|
||
refreshUI();
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// UI 列表
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function getTasksHash() {
|
||
const globalTasks = getSettings().globalTasks;
|
||
const characterTasks = getCharacterTasks();
|
||
const presetTasks = getPresetTasks();
|
||
const presetName = PresetTasksStore.currentName();
|
||
const all = [...globalTasks, ...characterTasks, ...presetTasks];
|
||
return `${presetName || ''}|${all.map(t => `${t.id}_${t.disabled}_${t.name}_${t.interval}_${t.floorType}_${t.triggerTiming || 'after_ai'}`).join('|')}`;
|
||
}
|
||
|
||
function createTaskItemSimple(task, index, scope = 'global') {
|
||
if (!task.id) task.id = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
|
||
const taskType = scope || 'global';
|
||
const floorTypeText = { user: '用户楼层', llm: 'LLM楼层' }[task.floorType] || '全部楼层';
|
||
const triggerTimingText = {
|
||
before_user: '用户前',
|
||
any_message: '任意对话',
|
||
initialization: '角色卡初始化',
|
||
character_init: '角色卡初始化',
|
||
plugin_init: '插件初始化',
|
||
only_this_floor: '仅该楼层',
|
||
chat_changed: '切换聊天后'
|
||
}[task.triggerTiming] || 'AI后';
|
||
|
||
let displayName;
|
||
if (task.interval === 0) {
|
||
displayName = `${task.name} (手动触发)`;
|
||
} else if (task.triggerTiming === 'initialization' || task.triggerTiming === 'character_init') {
|
||
displayName = `${task.name} (角色卡初始化)`;
|
||
} else if (task.triggerTiming === 'plugin_init') {
|
||
displayName = `${task.name} (插件初始化)`;
|
||
} else if (task.triggerTiming === 'chat_changed') {
|
||
displayName = `${task.name} (切换聊天后)`;
|
||
} else if (task.triggerTiming === 'only_this_floor') {
|
||
displayName = `${task.name} (仅第${task.interval}${floorTypeText})`;
|
||
} else {
|
||
displayName = `${task.name} (每${task.interval}${floorTypeText}·${triggerTimingText})`;
|
||
}
|
||
|
||
const taskElement = $('#task_item_template').children().first().clone();
|
||
taskElement.attr({ id: task.id, 'data-index': index, 'data-type': taskType });
|
||
taskElement.find('.task_name').attr('title', task.name).text(displayName);
|
||
taskElement.find('.disable_task').attr('id', `task_disable_${task.id}`).prop('checked', task.disabled);
|
||
taskElement.find('label.checkbox').attr('for', `task_disable_${task.id}`);
|
||
return taskElement;
|
||
}
|
||
|
||
function initSortable($list, onUpdate) {
|
||
const inst = (() => { try { return $list.sortable('instance'); } catch { return undefined; } })();
|
||
if (inst) return;
|
||
$list.sortable({
|
||
delay: getSortableDelay?.() || 0,
|
||
handle: '.drag-handle.menu-handle',
|
||
items: '> .task-item',
|
||
update: onUpdate
|
||
});
|
||
}
|
||
|
||
function updateTaskCounts(globalCount, characterCount, presetCount) {
|
||
const globalEl = document.getElementById('global_task_count');
|
||
const characterEl = document.getElementById('character_task_count');
|
||
const presetEl = document.getElementById('preset_task_count');
|
||
if (globalEl) globalEl.textContent = globalCount > 0 ? `(${globalCount})` : '';
|
||
if (characterEl) characterEl.textContent = characterCount > 0 ? `(${characterCount})` : '';
|
||
if (presetEl) presetEl.textContent = presetCount > 0 ? `(${presetCount})` : '';
|
||
}
|
||
|
||
function refreshTaskLists() {
|
||
updatePresetTaskHint();
|
||
const currentHash = getTasksHash();
|
||
if (currentHash === state.lastTasksHash) {
|
||
updateTaskBar();
|
||
return;
|
||
}
|
||
state.lastTasksHash = currentHash;
|
||
|
||
const $globalList = $('#global_tasks_list');
|
||
const $charList = $('#character_tasks_list');
|
||
const $presetList = $('#preset_tasks_list');
|
||
|
||
const globalTasks = getSettings().globalTasks;
|
||
const characterTasks = getCharacterTasks();
|
||
const presetTasks = getPresetTasks();
|
||
|
||
updateTaskCounts(globalTasks.length, characterTasks.length, presetTasks.length);
|
||
|
||
const globalFragment = document.createDocumentFragment();
|
||
globalTasks.forEach((task, i) => { globalFragment.appendChild(createTaskItemSimple(task, i, 'global')[0]); });
|
||
$globalList.empty().append(globalFragment);
|
||
|
||
const charFragment = document.createDocumentFragment();
|
||
characterTasks.forEach((task, i) => { charFragment.appendChild(createTaskItemSimple(task, i, 'character')[0]); });
|
||
$charList.empty().append(charFragment);
|
||
|
||
if ($presetList.length) {
|
||
const presetFragment = document.createDocumentFragment();
|
||
presetTasks.forEach((task, i) => { presetFragment.appendChild(createTaskItemSimple(task, i, 'preset')[0]); });
|
||
$presetList.empty().append(presetFragment);
|
||
}
|
||
|
||
initSortable($globalList, async function () {
|
||
const newOrderIds = $globalList.sortable('toArray');
|
||
const current = getSettings().globalTasks;
|
||
const idToTask = new Map(current.map(t => [t.id, t]));
|
||
const reordered = newOrderIds.map(id => idToTask.get(id)).filter(Boolean);
|
||
const leftovers = current.filter(t => !newOrderIds.includes(t.id));
|
||
await persistTaskListByScope('global', [...reordered, ...leftovers]);
|
||
refreshTaskLists();
|
||
});
|
||
|
||
initSortable($charList, async function () {
|
||
const newOrderIds = $charList.sortable('toArray');
|
||
const current = getCharacterTasks();
|
||
const idToTask = new Map(current.map(t => [t.id, t]));
|
||
const reordered = newOrderIds.map(id => idToTask.get(id)).filter(Boolean);
|
||
const leftovers = current.filter(t => !newOrderIds.includes(t.id));
|
||
await saveCharacterTasks([...reordered, ...leftovers]);
|
||
refreshTaskLists();
|
||
});
|
||
|
||
if ($presetList.length) {
|
||
initSortable($presetList, async function () {
|
||
const newOrderIds = $presetList.sortable('toArray');
|
||
const current = getPresetTasks();
|
||
const idToTask = new Map(current.map(t => [t.id, t]));
|
||
const reordered = newOrderIds.map(id => idToTask.get(id)).filter(Boolean);
|
||
const leftovers = current.filter(t => !newOrderIds.includes(t.id));
|
||
await savePresetTasks([...reordered, ...leftovers]);
|
||
refreshTaskLists();
|
||
});
|
||
}
|
||
|
||
updateTaskBar();
|
||
}
|
||
|
||
function updatePresetTaskHint() {
|
||
const hint = document.getElementById('preset_tasks_hint');
|
||
if (!hint) return;
|
||
const presetName = PresetTasksStore.currentName();
|
||
state.lastPresetName = presetName || '';
|
||
if (!presetName) {
|
||
hint.textContent = '未选择';
|
||
hint.classList.add('no-preset');
|
||
hint.title = '请在OpenAI设置中选择预设';
|
||
} else {
|
||
hint.textContent = `${presetName}`;
|
||
hint.classList.remove('no-preset');
|
||
hint.title = `当前OpenAI预设：${presetName}`;
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 任务栏
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const cache = { bar: null, btns: null, sig: '', ts: 0 };
|
||
|
||
const getActivatedTasks = () => isGloballyEnabled() ? allTasks().filter(t => t.buttonActivated && !t.disabled) : [];
|
||
|
||
const getBar = () => {
|
||
if (cache.bar?.isConnected) return cache.bar;
|
||
cache.bar = document.getElementById('qr--bar') || document.getElementById('qr-bar');
|
||
if (!cache.bar && !(window.quickReplyApi?.settings?.isEnabled || extension_settings?.quickReplyV2?.isEnabled)) {
|
||
const parent = document.getElementById('send_form') || document.body;
|
||
cache.bar = parent.insertBefore(
|
||
Object.assign(document.createElement('div'), {
|
||
id: 'qr-bar',
|
||
className: 'flex-container flexGap5',
|
||
innerHTML: '<div class="qr--buttons" style="display:flex;flex-wrap:wrap;justify-content:center"></div>'
|
||
}),
|
||
parent.firstChild
|
||
);
|
||
}
|
||
cache.btns = cache.bar?.querySelector('.qr--buttons');
|
||
return cache.bar;
|
||
};
|
||
|
||
function createTaskBar() {
|
||
const tasks = getActivatedTasks();
|
||
const sig = state.taskBarVisible ? tasks.map(t => t.name).join() : '';
|
||
if (sig === cache.sig && Date.now() - cache.ts < 100) return;
|
||
const bar = getBar();
|
||
if (!bar) return;
|
||
bar.style.display = state.taskBarVisible ? '' : 'none';
|
||
if (!state.taskBarVisible) return;
|
||
const btns = cache.btns || bar;
|
||
const exist = new Map([...btns.querySelectorAll('.xiaobaix-task-button')].map(el => [el.dataset.taskName, el]));
|
||
const names = new Set(tasks.map(t => t.name));
|
||
exist.forEach((el, name) => !names.has(name) && el.remove());
|
||
const frag = document.createDocumentFragment();
|
||
tasks.forEach(t => {
|
||
if (!exist.has(t.name)) {
|
||
const btn = Object.assign(document.createElement('button'), {
|
||
className: 'menu_button menu_button_icon xiaobaix-task-button interactable',
|
||
innerHTML: `<span>${t.name}</span>`
|
||
});
|
||
btn.dataset.taskName = t.name;
|
||
frag.appendChild(btn);
|
||
}
|
||
});
|
||
frag.childNodes.length && btns.appendChild(frag);
|
||
cache.sig = sig;
|
||
cache.ts = Date.now();
|
||
}
|
||
|
||
const updateTaskBar = debounce(createTaskBar, 100);
|
||
|
||
function toggleTaskBarVisibility() {
|
||
state.taskBarVisible = !state.taskBarVisible;
|
||
const bar = getBar();
|
||
bar && (bar.style.display = state.taskBarVisible ? '' : 'none');
|
||
createTaskBar();
|
||
const btn = document.getElementById('toggle_task_bar');
|
||
const txt = btn?.querySelector('small');
|
||
if (txt) {
|
||
txt.style.cssText = state.taskBarVisible ? 'opacity:1;text-decoration:none' : 'opacity:.5;text-decoration:line-through';
|
||
btn.title = state.taskBarVisible ? '隐藏任务栏' : '显示任务栏';
|
||
}
|
||
}
|
||
|
||
document.addEventListener('click', async e => {
|
||
const btn = e.target.closest('.xiaobaix-task-button');
|
||
if (!btn) return;
|
||
if (!isGloballyEnabled()) return;
|
||
window.xbqte(btn.dataset.taskName).catch(console.error);
|
||
});
|
||
|
||
new MutationObserver(updateTaskBar).observe(document.body, { childList: true, subtree: true });
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 任务编辑器
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function showTaskEditor(task = null, isEdit = false, scope = 'global') {
|
||
const initialScope = scope || 'global';
|
||
const sourceList = getTaskListByScope(initialScope);
|
||
|
||
if (task && scope === 'global' && task.id) {
|
||
task = { ...task, commands: await TasksStorage.get(task.id) };
|
||
}
|
||
|
||
state.currentEditingTask = task;
|
||
state.currentEditingScope = initialScope;
|
||
state.currentEditingIndex = isEdit ? sourceList.indexOf(task) : -1;
|
||
state.currentEditingId = task?.id || null;
|
||
|
||
const editorTemplate = $('#task_editor_template').clone().removeAttr('id').show();
|
||
editorTemplate.find('.task_name_edit').val(task?.name || '');
|
||
editorTemplate.find('.task_commands_edit').val(task?.commands || '');
|
||
editorTemplate.find('.task_interval_edit').val(task?.interval ?? 3);
|
||
editorTemplate.find('.task_floor_type_edit').val(task?.floorType || 'all');
|
||
editorTemplate.find('.task_trigger_timing_edit').val(task?.triggerTiming || 'after_ai');
|
||
editorTemplate.find('.task_type_edit').val(initialScope);
|
||
editorTemplate.find('.task_enabled_edit').prop('checked', !task?.disabled);
|
||
editorTemplate.find('.task_button_activated_edit').prop('checked', task?.buttonActivated || false);
|
||
|
||
function updateWarningDisplay() {
|
||
const interval = parseInt(editorTemplate.find('.task_interval_edit').val()) || 0;
|
||
const triggerTiming = editorTemplate.find('.task_trigger_timing_edit').val();
|
||
const floorType = editorTemplate.find('.task_floor_type_edit').val();
|
||
let warningElement = editorTemplate.find('.trigger-timing-warning');
|
||
if (warningElement.length === 0) {
|
||
warningElement = $('<div class="trigger-timing-warning" style="color:#ff6b6b;font-size:.8em;margin-top:4px;"></div>');
|
||
editorTemplate.find('.task_trigger_timing_edit').parent().append(warningElement);
|
||
}
|
||
const shouldShowWarning = interval > 0 && floorType === 'all' && (triggerTiming === 'after_ai' || triggerTiming === 'before_user');
|
||
if (shouldShowWarning) {
|
||
warningElement.html('⚠️ 警告：选择"全部楼层"配合"AI消息后"或"用户消息前"可能因楼层编号不匹配而不触发').show();
|
||
} else {
|
||
warningElement.hide();
|
||
}
|
||
}
|
||
|
||
function updateControlStates() {
|
||
const interval = parseInt(editorTemplate.find('.task_interval_edit').val()) || 0;
|
||
const triggerTiming = editorTemplate.find('.task_trigger_timing_edit').val();
|
||
const intervalControl = editorTemplate.find('.task_interval_edit');
|
||
const floorTypeControl = editorTemplate.find('.task_floor_type_edit');
|
||
const triggerTimingControl = editorTemplate.find('.task_trigger_timing_edit');
|
||
|
||
if (interval === 0) {
|
||
floorTypeControl.prop('disabled', true).css('opacity', '0.5');
|
||
triggerTimingControl.prop('disabled', true).css('opacity', '0.5');
|
||
let manualTriggerHint = editorTemplate.find('.manual-trigger-hint');
|
||
if (manualTriggerHint.length === 0) {
|
||
manualTriggerHint = $('<small class="manual-trigger-hint" style="color:#888;">手动触发</small>');
|
||
triggerTimingControl.parent().append(manualTriggerHint);
|
||
}
|
||
manualTriggerHint.show();
|
||
} else {
|
||
floorTypeControl.prop('disabled', false).css('opacity', '1');
|
||
triggerTimingControl.prop('disabled', false).css('opacity', '1');
|
||
editorTemplate.find('.manual-trigger-hint').hide();
|
||
if (triggerTiming === 'initialization' || triggerTiming === 'plugin_init' || triggerTiming === 'chat_changed') {
|
||
intervalControl.prop('disabled', true).css('opacity', '0.5');
|
||
floorTypeControl.prop('disabled', true).css('opacity', '0.5');
|
||
} else {
|
||
intervalControl.prop('disabled', false).css('opacity', '1');
|
||
floorTypeControl.prop('disabled', false).css('opacity', '1');
|
||
}
|
||
}
|
||
updateWarningDisplay();
|
||
}
|
||
|
||
editorTemplate.find('.task_interval_edit').on('input', updateControlStates);
|
||
editorTemplate.find('.task_trigger_timing_edit').on('change', updateControlStates);
|
||
editorTemplate.find('.task_floor_type_edit').on('change', updateControlStates);
|
||
updateControlStates();
|
||
|
||
callGenericPopup(editorTemplate, POPUP_TYPE.CONFIRM, '', { okButton: '保存' }).then(async (result) => {
|
||
if (result) {
|
||
const desiredName = String(editorTemplate.find('.task_name_edit').val() || '').trim();
|
||
const existingNames = new Set(allTasks().map(t => (t?.name || '').trim().toLowerCase()));
|
||
let uniqueName = desiredName;
|
||
if (desiredName && (!isEdit || (isEdit && task?.name?.toLowerCase() !== desiredName.toLowerCase()))) {
|
||
if (existingNames.has(desiredName.toLowerCase())) {
|
||
let idx = 1;
|
||
while (existingNames.has(`${desiredName}${idx}`.toLowerCase())) idx++;
|
||
uniqueName = `${desiredName}${idx}`;
|
||
}
|
||
}
|
||
|
||
const base = task ? structuredClone(task) : {};
|
||
const newTask = {
|
||
...base,
|
||
id: base.id || `task_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
|
||
name: uniqueName,
|
||
commands: String(editorTemplate.find('.task_commands_edit').val() || '').trim(),
|
||
interval: parseInt(String(editorTemplate.find('.task_interval_edit').val() || '0'), 10) || 0,
|
||
floorType: editorTemplate.find('.task_floor_type_edit').val() || 'all',
|
||
triggerTiming: editorTemplate.find('.task_trigger_timing_edit').val() || 'after_ai',
|
||
disabled: !editorTemplate.find('.task_enabled_edit').prop('checked'),
|
||
buttonActivated: editorTemplate.find('.task_button_activated_edit').prop('checked'),
|
||
createdAt: base.createdAt || new Date().toISOString(),
|
||
};
|
||
const targetScope = String(editorTemplate.find('.task_type_edit').val() || initialScope);
|
||
await saveTaskFromEditor(newTask, targetScope);
|
||
}
|
||
});
|
||
}
|
||
|
||
async function saveTaskFromEditor(task, scope) {
|
||
const targetScope = scope === 'character' || scope === 'preset' ? scope : 'global';
|
||
const isManual = (task?.interval === 0);
|
||
if (!task.name || (!isManual && !task.commands)) return;
|
||
|
||
const isEditingExistingTask = state.currentEditingIndex >= 0 || !!state.currentEditingId;
|
||
const previousScope = state.currentEditingScope || 'global';
|
||
const taskTypeChanged = isEditingExistingTask && previousScope !== targetScope;
|
||
|
||
if (targetScope === 'preset' && !PresetTasksStore.currentName()) {
|
||
toastr?.warning?.('请先选择一个OpenAI预设。');
|
||
return;
|
||
}
|
||
|
||
if (taskTypeChanged) {
|
||
await removeTaskByScope(previousScope, state.currentEditingId, state.currentEditingIndex);
|
||
state.lastTasksHash = '';
|
||
state.currentEditingIndex = -1;
|
||
state.currentEditingId = null;
|
||
}
|
||
|
||
const list = getTaskListByScope(targetScope);
|
||
let idx = state.currentEditingId ? list.findIndex(t => t?.id === state.currentEditingId) : state.currentEditingIndex;
|
||
|
||
if (idx >= 0 && idx < list.length) {
|
||
list[idx] = task;
|
||
} else {
|
||
list.push(task);
|
||
}
|
||
|
||
await persistTaskListByScope(targetScope, [...list]);
|
||
|
||
state.currentEditingScope = targetScope;
|
||
state.lastTasksHash = '';
|
||
refreshUI();
|
||
}
|
||
|
||
|
||
async function editTask(index, scope) {
|
||
const list = getTaskListByScope(scope);
|
||
const task = list[index];
|
||
if (task) showTaskEditor(task, true, scope);
|
||
}
|
||
|
||
async function deleteTask(index, scope) {
|
||
const list = getTaskListByScope(scope);
|
||
const task = list[index];
|
||
if (!task) return;
|
||
|
||
try {
|
||
const styleId = 'temp-dialog-style';
|
||
if (!document.getElementById(styleId)) {
|
||
const style = document.createElement('style');
|
||
style.id = styleId;
|
||
style.textContent = '#dialogue_popup_ok, #dialogue_popup_cancel { width: auto !important; }';
|
||
document.head.appendChild(style);
|
||
}
|
||
const result = await callPopup(`确定要删除任务 "${task.name}" 吗？`, 'confirm');
|
||
document.getElementById(styleId)?.remove();
|
||
if (result) {
|
||
await removeTaskByScope(scope, task.id, index);
|
||
refreshUI();
|
||
}
|
||
} catch (error) {
|
||
console.error('删除任务时出错:', error);
|
||
document.getElementById('temp-dialog-style')?.remove();
|
||
}
|
||
}
|
||
|
||
const getAllTaskNames = () => allTasks().filter(t => !t.disabled).map(t => t.name);
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 嵌入式任务
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function checkEmbeddedTasks() {
|
||
if (!this_chid) return;
|
||
const avatar = characters[this_chid]?.avatar;
|
||
const tasks = characters[this_chid]?.data?.extensions?.[TASKS_MODULE_NAME]?.tasks;
|
||
|
||
if (Array.isArray(tasks) && tasks.length > 0 && avatar) {
|
||
const settings = getSettings();
|
||
settings.character_allowed_tasks ??= [];
|
||
|
||
if (!settings.character_allowed_tasks.includes(avatar)) {
|
||
const checkKey = `AlertTasks_${avatar}`;
|
||
if (!accountStorage.getItem(checkKey)) {
|
||
accountStorage.setItem(checkKey, 'true');
|
||
let result;
|
||
try {
|
||
const templateFilePath = `scripts/extensions/third-party/LittleWhiteBox/modules/scheduled-tasks/embedded-tasks.html`;
|
||
const templateContent = await fetch(templateFilePath).then(r => r.text());
|
||
const templateElement = $(templateContent);
|
||
const taskListContainer = templateElement.find('#embedded-tasks-list');
|
||
tasks.forEach(task => {
|
||
const taskPreview = $('#task_preview_template').children().first().clone();
|
||
taskPreview.find('.task-preview-name').text(task.name);
|
||
taskPreview.find('.task-preview-interval').text(`(每${task.interval}回合)`);
|
||
taskPreview.find('.task-preview-commands').text(task.commands);
|
||
taskListContainer.append(taskPreview);
|
||
});
|
||
result = await callGenericPopup(templateElement, POPUP_TYPE.CONFIRM, '', { okButton: '允许' });
|
||
} catch {
|
||
result = await callGenericPopup(`此角色包含 ${tasks.length} 个定时任务。是否允许使用？`, POPUP_TYPE.CONFIRM, '', { okButton: '允许' });
|
||
}
|
||
if (result) {
|
||
settings.character_allowed_tasks.push(avatar);
|
||
saveSettingsDebounced();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
refreshTaskLists();
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 云端任务
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const CLOUD_TASKS_API = 'https://task.whitelittlebox.qzz.io/';
|
||
|
||
async function fetchCloudTasks() {
|
||
try {
|
||
const response = await fetch(CLOUD_TASKS_API, {
|
||
method: 'GET',
|
||
headers: { 'Accept': 'application/json', 'X-Plugin-Key': 'xbaix', 'Cache-Control': 'no-cache', 'Pragma': 'no-cache' },
|
||
cache: 'no-store'
|
||
});
|
||
if (!response.ok) throw new Error(`HTTP错误: ${response.status}`);
|
||
const data = await response.json();
|
||
return data.items || [];
|
||
} catch (error) {
|
||
console.error('获取云端任务失败:', error);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
async function downloadAndImportCloudTask(taskUrl, taskType) {
|
||
try {
|
||
const response = await fetch(taskUrl);
|
||
if (!response.ok) throw new Error(`下载失败: ${response.status}`);
|
||
const taskData = await response.json();
|
||
const jsonString = JSON.stringify(taskData);
|
||
const blob = new Blob([jsonString], { type: 'application/json' });
|
||
const file = new File([blob], 'cloud_task.json', { type: 'application/json' });
|
||
await importGlobalTasks(file);
|
||
} catch (error) {
|
||
console.error('下载并导入云端任务失败:', error);
|
||
await callGenericPopup(`导入失败: ${error.message}`, POPUP_TYPE.TEXT, '', { okButton: '确定' });
|
||
}
|
||
}
|
||
|
||
async function showCloudTasksModal() {
|
||
const modalTemplate = $('#cloud_tasks_modal_template').children().first().clone();
|
||
const loadingEl = modalTemplate.find('.cloud-tasks-loading');
|
||
const contentEl = modalTemplate.find('.cloud-tasks-content');
|
||
const errorEl = modalTemplate.find('.cloud-tasks-error');
|
||
|
||
callGenericPopup(modalTemplate, POPUP_TYPE.TEXT, '', { okButton: '关闭' });
|
||
|
||
try {
|
||
const cloudTasks = await fetchCloudTasks();
|
||
if (!cloudTasks || cloudTasks.length === 0) throw new Error('云端没有可用的任务');
|
||
const globalTasks = cloudTasks.filter(t => t.type === 'global');
|
||
const characterTasks = cloudTasks.filter(t => t.type === 'character');
|
||
|
||
const globalList = modalTemplate.find('.cloud-global-tasks');
|
||
if (globalTasks.length === 0) {
|
||
globalList.html('<div style="color: #888; padding: 10px;">暂无全局任务</div>');
|
||
} else {
|
||
globalTasks.forEach(task => { globalList.append(createCloudTaskItem(task)); });
|
||
}
|
||
|
||
const characterList = modalTemplate.find('.cloud-character-tasks');
|
||
if (characterTasks.length === 0) {
|
||
characterList.html('<div style="color: #888; padding: 10px;">暂无角色任务</div>');
|
||
} else {
|
||
characterTasks.forEach(task => { characterList.append(createCloudTaskItem(task)); });
|
||
}
|
||
|
||
loadingEl.hide();
|
||
contentEl.show();
|
||
} catch (error) {
|
||
loadingEl.hide();
|
||
errorEl.text(`加载失败: ${error.message}`).show();
|
||
}
|
||
}
|
||
|
||
function createCloudTaskItem(taskInfo) {
|
||
const item = $('#cloud_task_item_template').children().first().clone();
|
||
item.find('.cloud-task-name').text(taskInfo.name || '未命名任务');
|
||
item.find('.cloud-task-intro').text(taskInfo.简介 || taskInfo.intro || '无简介');
|
||
item.find('.cloud-task-download').on('click', async function () {
|
||
$(this).prop('disabled', true).find('i').removeClass('fa-download').addClass('fa-spinner fa-spin');
|
||
try {
|
||
await downloadAndImportCloudTask(taskInfo.url, taskInfo.type);
|
||
$(this).find('i').removeClass('fa-spinner fa-spin').addClass('fa-check');
|
||
$(this).find('small').text('已导入');
|
||
setTimeout(() => {
|
||
$(this).find('i').removeClass('fa-check').addClass('fa-download');
|
||
$(this).find('small').text('导入');
|
||
$(this).prop('disabled', false);
|
||
}, 2000);
|
||
} catch (error) {
|
||
$(this).find('i').removeClass('fa-spinner fa-spin').addClass('fa-download');
|
||
$(this).prop('disabled', false);
|
||
}
|
||
});
|
||
return item;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 导入导出
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
|
||
async function exportSingleTask(index, scope) {
|
||
const list = getTaskListByScope(scope);
|
||
if (index < 0 || index >= list.length) return;
|
||
|
||
let task = list[index];
|
||
if (scope === 'global' && task.id) {
|
||
task = { ...task, commands: await TasksStorage.get(task.id) };
|
||
}
|
||
|
||
const fileName = `${scope}_task_${task?.name || 'unnamed'}_${new Date().toISOString().split('T')[0]}.json`;
|
||
const fileData = JSON.stringify({ type: scope, exportDate: new Date().toISOString(), tasks: [task] }, null, 4);
|
||
download(fileData, fileName, 'application/json');
|
||
}
|
||
|
||
async function importGlobalTasks(file) {
|
||
if (!file) return;
|
||
try {
|
||
const fileText = await getFileText(file);
|
||
const raw = JSON.parse(fileText);
|
||
let incomingTasks = [];
|
||
let fileType = 'global';
|
||
|
||
if (Array.isArray(raw)) {
|
||
incomingTasks = raw;
|
||
fileType = 'global';
|
||
} else if (raw && Array.isArray(raw.tasks)) {
|
||
incomingTasks = raw.tasks;
|
||
if (raw.type === 'character' || raw.type === 'global' || raw.type === 'preset') fileType = raw.type;
|
||
} else if (raw && typeof raw === 'object' && raw.name && (raw.commands || raw.interval !== undefined)) {
|
||
incomingTasks = [raw];
|
||
if (raw.type === 'character' || raw.type === 'global' || raw.type === 'preset') fileType = raw.type;
|
||
} else {
|
||
throw new Error('无效的任务文件格式');
|
||
}
|
||
|
||
const VALID_FLOOR = ['all', 'user', 'llm'];
|
||
const VALID_TIMING = ['after_ai', 'before_user', 'any_message', 'initialization', 'character_init', 'plugin_init', 'only_this_floor', 'chat_changed'];
|
||
const deepClone = (o) => JSON.parse(JSON.stringify(o || {}));
|
||
|
||
const tasksToImport = incomingTasks
|
||
.filter(t => (t?.name || '').trim() && (String(t?.commands || '').trim() || t.interval === 0))
|
||
.map(src => ({
|
||
id: uuidv4(),
|
||
name: String(src.name || '').trim(),
|
||
commands: String(src.commands || '').trim(),
|
||
interval: clampInt(src.interval, 0, 99999, 0),
|
||
floorType: VALID_FLOOR.includes(src.floorType) ? src.floorType : 'all',
|
||
triggerTiming: VALID_TIMING.includes(src.triggerTiming) ? src.triggerTiming : 'after_ai',
|
||
disabled: !!src.disabled,
|
||
buttonActivated: !!src.buttonActivated,
|
||
createdAt: src.createdAt || new Date().toISOString(),
|
||
importedAt: new Date().toISOString(),
|
||
x: (src.x && typeof src.x === 'object') ? deepClone(src.x) : {}
|
||
}));
|
||
|
||
if (!tasksToImport.length) throw new Error('没有可导入的任务');
|
||
|
||
if (fileType === 'character') {
|
||
if (!this_chid || !characters[this_chid]) {
|
||
toastr?.warning?.('角色任务请先在角色聊天界面导入。');
|
||
return;
|
||
}
|
||
const current = getCharacterTasks();
|
||
await saveCharacterTasks([...current, ...tasksToImport]);
|
||
} else if (fileType === 'preset') {
|
||
const presetName = PresetTasksStore.currentName();
|
||
if (!presetName) {
|
||
toastr?.warning?.('请先选择一个OpenAI预设后再导入预设任务。');
|
||
return;
|
||
}
|
||
const current = getPresetTasks();
|
||
await savePresetTasks([...current, ...tasksToImport]);
|
||
} else {
|
||
const currentMeta = getSettings().globalTasks;
|
||
const merged = [...currentMeta, ...tasksToImport];
|
||
await persistTaskListByScope('global', merged);
|
||
}
|
||
|
||
refreshTaskLists();
|
||
toastr?.success?.(`已导入 ${tasksToImport.length} 个任务`);
|
||
} catch (error) {
|
||
console.error('任务导入失败:', error);
|
||
toastr?.error?.(`导入失败：${error.message}`);
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 调试工具
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function clearProcessedMessages() {
|
||
getSettings().processedMessages = [];
|
||
state.processedMessagesSet.clear();
|
||
saveSettingsDebounced();
|
||
}
|
||
|
||
function clearTaskCooldown(taskName = null) {
|
||
taskName ? state.taskLastExecutionTime.delete(taskName) : state.taskLastExecutionTime.clear();
|
||
}
|
||
|
||
function getTaskCooldownStatus() {
|
||
const status = {};
|
||
for (const [taskName, lastTime] of state.taskLastExecutionTime.entries()) {
|
||
const remaining = Math.max(0, CONFIG.TASK_COOLDOWN - (nowMs() - lastTime));
|
||
status[taskName] = { lastExecutionTime: lastTime, remainingCooldown: remaining, isInCooldown: remaining > 0 };
|
||
}
|
||
return status;
|
||
}
|
||
|
||
function getMemoryUsage() {
|
||
return {
|
||
processedMessages: getSettings().processedMessages.length,
|
||
taskCooldowns: state.taskLastExecutionTime.size,
|
||
globalTasks: getSettings().globalTasks.length,
|
||
characterTasks: getCharacterTasks().length,
|
||
scriptCache: TasksStorage.getCacheSize(),
|
||
maxProcessedMessages: CONFIG.MAX_PROCESSED,
|
||
maxCooldownEntries: CONFIG.MAX_COOLDOWN
|
||
};
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// UI 刷新和清理
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function refreshUI() {
|
||
refreshTaskLists();
|
||
updateTaskBar();
|
||
}
|
||
|
||
function onMessageSwiped() {
|
||
state.executingCount = 0;
|
||
state.isCommandGenerated = false;
|
||
}
|
||
|
||
function onCharacterDeleted({ character }) {
|
||
const avatar = character?.avatar;
|
||
const settings = getSettings();
|
||
if (avatar && settings.character_allowed_tasks?.includes(avatar)) {
|
||
const index = settings.character_allowed_tasks.indexOf(avatar);
|
||
if (index !== -1) {
|
||
settings.character_allowed_tasks.splice(index, 1);
|
||
saveSettingsDebounced();
|
||
}
|
||
}
|
||
}
|
||
|
||
function cleanup() {
|
||
if (state.cleanupTimer) {
|
||
clearInterval(state.cleanupTimer);
|
||
state.cleanupTimer = null;
|
||
}
|
||
state.taskLastExecutionTime.clear();
|
||
TasksStorage.clearCache();
|
||
|
||
try {
|
||
if (state.dynamicCallbacks && state.dynamicCallbacks.size > 0) {
|
||
for (const entry of state.dynamicCallbacks.values()) {
|
||
try { entry?.abortController?.abort(); } catch {}
|
||
}
|
||
state.dynamicCallbacks.clear();
|
||
}
|
||
} catch {}
|
||
|
||
events.cleanup();
|
||
window.removeEventListener('message', handleTaskMessage);
|
||
$(window).off('beforeunload', cleanup);
|
||
|
||
try {
|
||
const $qrButtons = $('#qr--bar .qr--buttons, #qr--bar, #qr-bar');
|
||
$qrButtons.off('click.xb');
|
||
$qrButtons.find('.xiaobaix-task-button').remove();
|
||
} catch {}
|
||
|
||
try { state.qrObserver?.disconnect(); } catch {}
|
||
state.qrObserver = null;
|
||
resetPresetTasksCache();
|
||
delete window.__XB_TASKS_INITIALIZED__;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 公共 API
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
(function () {
|
||
if (window.__XB_TASKS_FACADE__) return;
|
||
|
||
const norm = s => String(s ?? '').normalize('NFKC').replace(/[\u200B-\u200D\uFEFF]/g, '').trim().toLowerCase();
|
||
|
||
function list(scope = 'all') {
|
||
const g = getSettings().globalTasks || [];
|
||
const c = getCharacterTasks() || [];
|
||
const p = getPresetTasks() || [];
|
||
const map = t => ({
|
||
id: t.id, name: t.name, interval: t.interval,
|
||
floorType: t.floorType, timing: t.triggerTiming, disabled: !!t.disabled
|
||
});
|
||
if (scope === 'global') return g.map(map);
|
||
if (scope === 'character') return c.map(map);
|
||
if (scope === 'preset') return p.map(map);
|
||
return { global: g.map(map), character: c.map(map), preset: p.map(map) };
|
||
}
|
||
|
||
function find(name, scope = 'all') {
|
||
const n = norm(name);
|
||
if (scope !== 'character' && scope !== 'preset') {
|
||
const g = getSettings().globalTasks || [];
|
||
const gi = g.findIndex(t => norm(t?.name) === n);
|
||
if (gi !== -1) return { scope: 'global', list: g, index: gi, task: g[gi] };
|
||
}
|
||
if (scope !== 'global' && scope !== 'preset') {
|
||
const c = getCharacterTasks() || [];
|
||
const ci = c.findIndex(t => norm(t?.name) === n);
|
||
if (ci !== -1) return { scope: 'character', list: c, index: ci, task: c[ci] };
|
||
}
|
||
if (scope !== 'global' && scope !== 'character') {
|
||
const p = getPresetTasks() || [];
|
||
const pi = p.findIndex(t => norm(t?.name) === n);
|
||
if (pi !== -1) return { scope: 'preset', list: p, index: pi, task: p[pi] };
|
||
}
|
||
return null;
|
||
}
|
||
|
||
async function setCommands(name, commands, opts = {}) {
|
||
const { mode = 'replace', scope = 'all' } = opts;
|
||
const hit = find(name, scope);
|
||
if (!hit) throw new Error(`找不到任务: ${name}`);
|
||
|
||
let old = hit.task.commands || '';
|
||
if (hit.scope === 'global' && hit.task.id) {
|
||
old = await TasksStorage.get(hit.task.id);
|
||
}
|
||
|
||
const body = String(commands ?? '');
|
||
let newCommands;
|
||
if (mode === 'append') newCommands = old ? (old + '\n' + body) : body;
|
||
else if (mode === 'prepend') newCommands = old ? (body + '\n' + old) : body;
|
||
else newCommands = body;
|
||
|
||
hit.task.commands = newCommands;
|
||
await persistTaskListByScope(hit.scope, hit.list);
|
||
refreshTaskLists();
|
||
return { ok: true, scope: hit.scope, name: hit.task.name };
|
||
}
|
||
|
||
async function setJS(name, jsCode, opts = {}) {
|
||
const commands = `<<taskjs>>${jsCode}<</taskjs>>`;
|
||
return await setCommands(name, commands, opts);
|
||
}
|
||
|
||
async function setProps(name, props, scope = 'all') {
|
||
const hit = find(name, scope);
|
||
if (!hit) throw new Error(`找不到任务: ${name}`);
|
||
Object.assign(hit.task, props || {});
|
||
await persistTaskListByScope(hit.scope, hit.list);
|
||
refreshTaskLists();
|
||
return { ok: true, scope: hit.scope, name: hit.task.name };
|
||
}
|
||
|
||
async function exec(name) {
|
||
const hit = find(name, 'all');
|
||
if (!hit) throw new Error(`找不到任务: ${name}`);
|
||
let commands = hit.task.commands || '';
|
||
if (hit.scope === 'global' && hit.task.id) {
|
||
commands = await TasksStorage.get(hit.task.id);
|
||
}
|
||
return await executeCommands(commands, hit.task.name);
|
||
}
|
||
|
||
async function dump(scope = 'all') {
|
||
const g = await Promise.all((getSettings().globalTasks || []).map(async t => ({
|
||
...structuredClone(t),
|
||
commands: await TasksStorage.get(t.id)
|
||
})));
|
||
const c = structuredClone(getCharacterTasks() || []);
|
||
const p = structuredClone(getPresetTasks() || []);
|
||
if (scope === 'global') return g;
|
||
if (scope === 'character') return c;
|
||
if (scope === 'preset') return p;
|
||
return { global: g, character: c, preset: p };
|
||
}
|
||
|
||
window.XBTasks = {
|
||
list, dump, find, setCommands, setJS, setProps, exec,
|
||
get global() { return getSettings().globalTasks; },
|
||
get character() { return getCharacterTasks(); },
|
||
get preset() { return getPresetTasks(); },
|
||
};
|
||
|
||
try { if (window.top && window.top !== window) window.top.XBTasks = window.XBTasks; } catch {}
|
||
window.__XB_TASKS_FACADE__ = true;
|
||
})();
|
||
|
||
window.xbqte = async (name) => {
|
||
try {
|
||
if (!name?.trim()) throw new Error('请提供任务名称');
|
||
const tasks = await allTasksFull();
|
||
const task = tasks.find(t => t.name.toLowerCase() === name.toLowerCase());
|
||
if (!task) throw new Error(`找不到名为 "${name}" 的任务`);
|
||
if (task.disabled) throw new Error(`任务 "${name}" 已被禁用`);
|
||
if (isTaskInCooldown(task.name)) {
|
||
const cd = getTaskCooldownStatus()[task.name];
|
||
throw new Error(`任务 "${name}" 仍在冷却中，剩余 ${cd.remainingCooldown}ms`);
|
||
}
|
||
setTaskCooldown(task.name);
|
||
const result = await executeCommands(task.commands, task.name);
|
||
return result || `已执行任务: ${task.name}`;
|
||
} catch (error) {
|
||
console.error(`执行任务失败: ${error.message}`);
|
||
throw error;
|
||
}
|
||
};
|
||
|
||
window.setScheduledTaskInterval = async (name, interval) => {
|
||
if (!name?.trim()) throw new Error('请提供任务名称');
|
||
const intervalNum = parseInt(interval);
|
||
if (isNaN(intervalNum) || intervalNum < 0 || intervalNum > 99999) {
|
||
throw new Error('间隔必须是 0-99999 之间的数字');
|
||
}
|
||
|
||
const settings = getSettings();
|
||
const gi = settings.globalTasks.findIndex(t => t.name.toLowerCase() === name.toLowerCase());
|
||
if (gi !== -1) {
|
||
settings.globalTasks[gi].interval = intervalNum;
|
||
saveSettingsDebounced();
|
||
refreshTaskLists();
|
||
return `已设置全局任务 "${name}" 的间隔为 ${intervalNum === 0 ? '手动激活' : `每${intervalNum}楼层`}`;
|
||
}
|
||
|
||
const cts = getCharacterTasks();
|
||
const ci = cts.findIndex(t => t.name.toLowerCase() === name.toLowerCase());
|
||
if (ci !== -1) {
|
||
cts[ci].interval = intervalNum;
|
||
await saveCharacterTasks(cts);
|
||
refreshTaskLists();
|
||
return `已设置角色任务 "${name}" 的间隔为 ${intervalNum === 0 ? '手动激活' : `每${intervalNum}楼层`}`;
|
||
}
|
||
throw new Error(`找不到名为 "${name}" 的任务`);
|
||
};
|
||
|
||
Object.assign(window, {
|
||
clearTasksProcessedMessages: clearProcessedMessages,
|
||
clearTaskCooldown,
|
||
getTaskCooldownStatus,
|
||
getTasksMemoryUsage: getMemoryUsage
|
||
});
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 斜杠命令
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
function registerSlashCommands() {
|
||
try {
|
||
SlashCommandParser.addCommandObject(SlashCommand.fromProps({
|
||
name: 'xbqte',
|
||
callback: async (args, value) => {
|
||
if (!value) return '请提供任务名称。用法: /xbqte 任务名称';
|
||
try { return await window.xbqte(value); } catch (error) { return `错误: ${error.message}`; }
|
||
},
|
||
unnamedArgumentList: [SlashCommandArgument.fromProps({
|
||
description: '要执行的任务名称',
|
||
typeList: [ARGUMENT_TYPE.STRING],
|
||
isRequired: true,
|
||
enumProvider: getAllTaskNames
|
||
})],
|
||
helpString: '执行指定名称的定时任务。例如: /xbqte 我的任务名称'
|
||
}));
|
||
|
||
SlashCommandParser.addCommandObject(SlashCommand.fromProps({
|
||
name: 'xbset',
|
||
callback: async (namedArgs, taskName) => {
|
||
const name = String(taskName || '').trim();
|
||
if (!name) throw new Error('请提供任务名称');
|
||
|
||
const settings = getSettings();
|
||
let task = null, isCharacter = false, taskIndex = -1;
|
||
|
||
taskIndex = settings.globalTasks.findIndex(t => t.name.toLowerCase() === name.toLowerCase());
|
||
if (taskIndex !== -1) {
|
||
task = settings.globalTasks[taskIndex];
|
||
} else {
|
||
const cts = getCharacterTasks();
|
||
taskIndex = cts.findIndex(t => t.name.toLowerCase() === name.toLowerCase());
|
||
if (taskIndex !== -1) {
|
||
task = cts[taskIndex];
|
||
isCharacter = true;
|
||
}
|
||
}
|
||
if (!task) throw new Error(`找不到任务 "${name}"`);
|
||
|
||
const changed = [];
|
||
|
||
if (namedArgs.status !== undefined) {
|
||
const val = String(namedArgs.status).toLowerCase();
|
||
if (val === 'on' || val === 'true') { task.disabled = false; changed.push('状态=启用'); }
|
||
else if (val === 'off' || val === 'false') { task.disabled = true; changed.push('状态=禁用'); }
|
||
else throw new Error('status 仅支持 on/off');
|
||
}
|
||
|
||
if (namedArgs.interval !== undefined) {
|
||
const num = parseInt(namedArgs.interval);
|
||
if (isNaN(num) || num < 0 || num > 99999) throw new Error('interval 必须为 0-99999');
|
||
task.interval = num;
|
||
changed.push(`间隔=${num}`);
|
||
}
|
||
|
||
if (namedArgs.timing !== undefined) {
|
||
const val = String(namedArgs.timing).toLowerCase();
|
||
const valid = ['after_ai', 'before_user', 'any_message', 'initialization', 'character_init', 'plugin_init', 'only_this_floor', 'chat_changed'];
|
||
if (!valid.includes(val)) throw new Error(`timing 必须为: ${valid.join(', ')}`);
|
||
task.triggerTiming = val;
|
||
changed.push(`时机=${val}`);
|
||
}
|
||
|
||
if (namedArgs.floorType !== undefined) {
|
||
const val = String(namedArgs.floorType).toLowerCase();
|
||
if (!['all', 'user', 'llm'].includes(val)) throw new Error('floorType 必须为: all, user, llm');
|
||
task.floorType = val;
|
||
changed.push(`楼层=${val}`);
|
||
}
|
||
|
||
if (changed.length === 0) throw new Error('未提供要修改的参数');
|
||
|
||
if (isCharacter) await saveCharacterTasks(getCharacterTasks());
|
||
else saveSettingsDebounced();
|
||
refreshTaskLists();
|
||
|
||
return `已更新任务 "${name}": ${changed.join(', ')}`;
|
||
},
|
||
namedArgumentList: [
|
||
SlashCommandNamedArgument.fromProps({ name: 'status', description: '启用/禁用', typeList: [ARGUMENT_TYPE.STRING], enumList: ['on', 'off'] }),
|
||
SlashCommandNamedArgument.fromProps({ name: 'interval', description: '楼层间隔(0=手动)', typeList: [ARGUMENT_TYPE.NUMBER] }),
|
||
SlashCommandNamedArgument.fromProps({ name: 'timing', description: '触发时机', typeList: [ARGUMENT_TYPE.STRING], enumList: ['after_ai', 'before_user', 'any_message', 'initialization', 'character_init', 'plugin_init', 'only_this_floor', 'chat_changed'] }),
|
||
SlashCommandNamedArgument.fromProps({ name: 'floorType', description: '楼层类型', typeList: [ARGUMENT_TYPE.STRING], enumList: ['all', 'user', 'llm'] }),
|
||
],
|
||
unnamedArgumentList: [SlashCommandArgument.fromProps({ description: '任务名称', typeList: [ARGUMENT_TYPE.STRING], isRequired: true, enumProvider: getAllTaskNames })],
|
||
helpString: `设置任务属性。用法: /xbset status=on/off interval=数字 timing=时机 floorType=类型 任务名`
|
||
}));
|
||
} catch (error) {
|
||
console.error("注册斜杠命令时出错:", error);
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 初始化
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function initTasks() {
|
||
if (window.__XB_TASKS_INITIALIZED__) {
|
||
console.log('[小白X任务] 已经初始化，跳过重复注册');
|
||
return;
|
||
}
|
||
window.__XB_TASKS_INITIALIZED__ = true;
|
||
|
||
await migrateToServerStorage();
|
||
hydrateProcessedSetFromSettings();
|
||
scheduleCleanup();
|
||
|
||
if (!extension_settings[EXT_ID].tasks) {
|
||
extension_settings[EXT_ID].tasks = structuredClone(defaultSettings);
|
||
}
|
||
|
||
if (window.registerModuleCleanup) {
|
||
window.registerModuleCleanup('scheduledTasks', cleanup);
|
||
}
|
||
|
||
// eslint-disable-next-line no-restricted-syntax -- legacy task bridge; keep behavior unchanged.
|
||
window.addEventListener('message', handleTaskMessage);
|
||
|
||
$('#scheduled_tasks_enabled').on('input', e => {
|
||
const enabled = $(e.target).prop('checked');
|
||
getSettings().enabled = enabled;
|
||
saveSettingsDebounced();
|
||
try { createTaskBar(); } catch {}
|
||
});
|
||
|
||
$('#add_global_task').on('click', () => showTaskEditor(null, false, 'global'));
|
||
$('#add_character_task').on('click', () => showTaskEditor(null, false, 'character'));
|
||
$('#add_preset_task').on('click', () => showTaskEditor(null, false, 'preset'));
|
||
$('#toggle_task_bar').on('click', toggleTaskBarVisibility);
|
||
$('#import_global_tasks').on('click', () => $('#import_tasks_file').trigger('click'));
|
||
$('#cloud_tasks_button').on('click', () => showCloudTasksModal());
|
||
$('#import_tasks_file').on('change', function (e) {
|
||
const file = e.target.files[0];
|
||
if (file) { importGlobalTasks(file); $(this).val(''); }
|
||
});
|
||
|
||
$('#global_tasks_list')
|
||
.on('input', '.disable_task', function () {
|
||
const $item = $(this).closest('.task-item');
|
||
const idx = parseInt($item.attr('data-index'), 10);
|
||
const list = getSettings().globalTasks;
|
||
if (list[idx]) {
|
||
list[idx].disabled = $(this).prop('checked');
|
||
saveSettingsDebounced();
|
||
state.lastTasksHash = '';
|
||
refreshTaskLists();
|
||
}
|
||
})
|
||
.on('click', '.edit_task', function () { editTask(parseInt($(this).closest('.task-item').attr('data-index')), 'global'); })
|
||
.on('click', '.export_task', function () { exportSingleTask(parseInt($(this).closest('.task-item').attr('data-index')), 'global'); })
|
||
.on('click', '.delete_task', function () { deleteTask(parseInt($(this).closest('.task-item').attr('data-index')), 'global'); });
|
||
|
||
$('#character_tasks_list')
|
||
.on('input', '.disable_task', function () {
|
||
const $item = $(this).closest('.task-item');
|
||
const idx = parseInt($item.attr('data-index'), 10);
|
||
const tasks = getCharacterTasks();
|
||
if (tasks[idx]) {
|
||
tasks[idx].disabled = $(this).prop('checked');
|
||
saveCharacterTasks(tasks);
|
||
state.lastTasksHash = '';
|
||
refreshTaskLists();
|
||
}
|
||
})
|
||
.on('click', '.edit_task', function () { editTask(parseInt($(this).closest('.task-item').attr('data-index')), 'character'); })
|
||
.on('click', '.export_task', function () { exportSingleTask(parseInt($(this).closest('.task-item').attr('data-index')), 'character'); })
|
||
.on('click', '.delete_task', function () { deleteTask(parseInt($(this).closest('.task-item').attr('data-index')), 'character'); });
|
||
|
||
$('#preset_tasks_list')
|
||
.on('input', '.disable_task', async function () {
|
||
const $item = $(this).closest('.task-item');
|
||
const idx = parseInt($item.attr('data-index'), 10);
|
||
const tasks = getPresetTasks();
|
||
if (tasks[idx]) {
|
||
tasks[idx].disabled = $(this).prop('checked');
|
||
await savePresetTasks([...tasks]);
|
||
state.lastTasksHash = '';
|
||
refreshTaskLists();
|
||
}
|
||
})
|
||
.on('click', '.edit_task', function () { editTask(parseInt($(this).closest('.task-item').attr('data-index')), 'preset'); })
|
||
.on('click', '.export_task', function () { exportSingleTask(parseInt($(this).closest('.task-item').attr('data-index')), 'preset'); })
|
||
.on('click', '.delete_task', function () { deleteTask(parseInt($(this).closest('.task-item').attr('data-index')), 'preset'); });
|
||
|
||
$('#scheduled_tasks_enabled').prop('checked', getSettings().enabled);
|
||
refreshTaskLists();
|
||
|
||
if (event_types.GENERATION_ENDED) {
|
||
events.on(event_types.GENERATION_ENDED, onGenerationEnded);
|
||
} else {
|
||
events.on(event_types.CHARACTER_MESSAGE_RENDERED, onMessageReceived);
|
||
}
|
||
events.on(event_types.USER_MESSAGE_RENDERED, onUserMessage);
|
||
events.on(event_types.CHAT_CHANGED, onChatChanged);
|
||
events.on(event_types.CHAT_CREATED, onChatCreated);
|
||
events.on(event_types.MESSAGE_DELETED, onMessageDeleted);
|
||
events.on(event_types.MESSAGE_SWIPED, onMessageSwiped);
|
||
events.on(event_types.CHARACTER_DELETED, onCharacterDeleted);
|
||
events.on(event_types.PRESET_CHANGED, onPresetChanged);
|
||
events.on(event_types.OAI_PRESET_CHANGED_AFTER, onPresetChanged);
|
||
events.on(event_types.MAIN_API_CHANGED, onMainApiChanged);
|
||
|
||
$(window).on('beforeunload', cleanup);
|
||
registerSlashCommands();
|
||
setTimeout(() => checkEmbeddedTasks(), 1000);
|
||
|
||
setTimeout(() => {
|
||
try { checkAndExecuteTasks('plugin_initialized', false, false); } catch (e) { console.debug(e); }
|
||
}, 0);
|
||
}
|
||
|
||
export { initTasks };
|