@wanghaopeng1148/deskpet 2.0.0 → 2.0.2

package/dist/node/server/services/task-scheduler.js

@@ -0,0 +1,813 @@
+/**
+ * 任务调度器 — 任务全生命周期管理（对齐旧版 task_scheduler.py 语义）
+ *
+ * 三类任务: manual / scheduled / scene
+ * 触发方式: once / cron / delay / interval / idle / startup / network
+ * 特性: 优先级队列、失败重试、一次性任务、执行历史 SQLite、任务链(M5 完善)
+ */
+import { EventEmitter } from 'node:events';
+import schedule from 'node-schedule';
+import { TaskStatus as TS } from "../../shared/types.js";
+import { chainContextOf, evalChainCondition } from "../../shared/chain-condition.js";
+import { newTaskId } from "../db/task-repository.js";
+import { isProcessAlive } from "../utils/instance-guard.js";
+/** 重试间隔（毫秒） */
+const RETRY_DELAY_MS = 2000;
+/** 实时输出缓冲上限（每个流，保留最后 64KB） */
+const LIVE_OUTPUT_LIMIT = 64 * 1024;
+/** 写入执行记录的输出上限（与正常收尾保持一致，避免超长输出撑爆库） */
+const EXEC_OUTPUT_LIMIT = 10 * 1024;
+/**
+ * 实时输出落盘节流间隔。
+ *
+ * 为什么不能让输出只留在内存：任务被中断时（服务退出 / 进程被强杀 / 直接关机）
+ * 走不到正常收尾，而 liveOutput 是内存字段，一旦进程消失输出就全没了 ——
+ * 表现就是执行记录里 stdout 空白，用户完全无从判断脚本跑到哪一步。
+ * 定期把已产生的输出写进 executions 表，即使进程被强杀也能保住中断前的部分。
+ */
+const OUTPUT_FLUSH_MS = 3000;
+function appendTail(current, addition, limit) {
+    const next = current + addition;
+    return next.length <= limit ? next : next.slice(-limit);
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+export class TaskScheduler extends EventEmitter {
+    records = new Map();
+    /** node-schedule cron 任务 */
+    jobs = new Map();
+    /** once/delay 定时器 */
+    timers = new Map();
+    /** interval 循环 */
+    intervals = new Map();
+    /** 待执行队列（按优先级降序） */
+    queue = [];
+    /** 当前执行中的任务 */
+    executingId = null;
+    /** 连续失败计数（熔断用） */
+    failStreak = new Map();
+    /** 运行中任务的执行记录行 id */
+    execRows = new Map();
+    /** 运行中任务的实时输出缓冲（供管理台流式查看，按 taskId 保存） */
+    liveOutput = new Map();
+    /** 输出有更新、等待落盘的任务（节流用） */
+    dirtyOutputs = new Set();
+    /** 输出落盘定时器 */
+    flushTimer = null;
+    startedFlag = false;
+    repo;
+    registry;
+    actionCtx;
+    constructor(repo, registry, actionCtx) {
+        super();
+        this.repo = repo;
+        this.registry = registry;
+        this.actionCtx = actionCtx;
+    }
+    // ── 生命周期 ──────────────────────────────────────────────
+    /** 从数据库载入全部任务 */
+    load() {
+        for (const dto of this.repo.listAll()) {
+            this.records.set(dto.id, dto);
+        }
+    }
+    /**
+     * 启动调度（注册定时触发 + 开机场景）。
+     *
+     * @param options.recover 是否执行「残留任务恢复」，默认 true。
+     *   调用方在**检测到已有另一个实例正在运行**时必须传 false：
+     *   recoverInterrupted() 的判定是「库里凡是 running 的任务都是上个进程遗留的」，
+     *   但若任务其实正跑在另一个实例里，这一下就会把它误判成中断
+     *   （见 utils/instance-guard.ts 的说明）。
+     */
+    start(options = {}) {
+        if (this.startedFlag)
+            return;
+        this.startedFlag = true;
+        if (options.recover === false) {
+            console.warn('[scheduler] 检测到已有另一个实例在运行 → 跳过残留任务恢复，避免中断对方正在执行的任务');
+        }
+        else {
+            // 收拾上次进程遗留的 running/pending，否则任务会被永久卡死
+            this.recoverInterrupted();
+        }
+        for (const rec of this.records.values()) {
+            this.applySchedule(rec);
+        }
+        // 开机场景任务
+        for (const rec of this.records.values()) {
+            if (rec.config.type === 'scene' &&
+                rec.config.trigger.type === 'startup' &&
+                rec.config.enabled) {
+                this.requestRun(rec.id, 'trigger');
+            }
+        }
+        this.emit('started');
+    }
+    stop() {
+        this.startedFlag = false;
+        this.clearFlushTimer();
+        for (const job of this.jobs.values())
+            job.cancel();
+        this.jobs.clear();
+        for (const t of this.timers.values())
+            clearTimeout(t);
+        this.timers.clear();
+        for (const i of this.intervals.values())
+            clearInterval(i);
+        this.intervals.clear();
+        this.queue = [];
+    }
+    /**
+     * 进程退出前的收尾（优雅退出时由 main 调用，见 main.ts 的 shutdown）。
+     *
+     * 为什么必须单独做这件事：`stop()` 只清理定时器与队列，**不碰任务状态**。
+     * 若退出时正好有任务在执行，数据库里就会永远留下 status='running' 的任务
+     * 与执行记录；下次启动时 recoverInterrupted() 会把它判定为「上次被重启中断」
+     * 并把这条错误挂到任务上 —— 而用户只是正常按了 Ctrl+C，
+     * 看起来就像任务自己坏了。
+     *
+     * 与 recoverInterrupted() 的分工：
+     *   · 正常退出 → 这里主动收尾（文案「服务退出」）
+     *   · 进程被强杀 / 崩溃 → 来不及收尾，靠启动时 recoverInterrupted() 兜底（文案「服务重启」）
+     */
+    shutdown() {
+        const executing = this.executingId;
+        const queued = [...this.queue];
+        // 排队中但尚未开始的任务：直接复位，不记为失败
+        for (const id of queued) {
+            const rec = this.records.get(id);
+            if (!rec)
+                continue;
+            rec.status = rec.config.enabled ? TS.IDLE : TS.DISABLED;
+            this.repo.update(id, rec.config, rec.status);
+        }
+        this.stop();
+        // 正在执行的任务：标记为「被服务退出中断」并落库
+        if (executing) {
+            const rec = this.records.get(executing);
+            if (rec) {
+                rec.status = rec.config.enabled ? TS.IDLE : TS.DISABLED;
+                rec.currentRetry = 0;
+                rec.lastResult = 'interrupted';
+                rec.lastError = '服务退出，执行被中断（非任务自身错误）';
+                this.repo.update(rec.id, rec.config, rec.status);
+            }
+            const execId = this.execRows.get(executing);
+            if (execId !== undefined) {
+                // 一并落盘已产生的输出：否则这条记录会是一条没有日志的空壳，
+                // 用户根本看不出脚本跑到哪一步（这正是「看不到标准输出」的由来）
+                const live = this.liveOutput.get(executing);
+                this.repo.updateExecution(execId, {
+                    status: 'failed',
+                    finishedAt: nowIso(),
+                    error: '服务退出，执行被中断（非任务自身错误）',
+                    stdout: (live?.stdout ?? '').slice(-EXEC_OUTPUT_LIMIT),
+                    stderr: (live?.stderr ?? '').slice(-EXEC_OUTPUT_LIMIT)
+                });
+                this.execRows.delete(executing);
+            }
+            this.executingId = null;
+        }
+        this.liveOutput.clear();
+        this.runningScripts.clear();
+    }
+    get isStarted() {
+        return this.startedFlag;
+    }
+    /**
+     * 启动恢复：修正「上次进程被强杀 / 重启」留下的脏状态。
+     *
+     * 执行上下文（executingId / liveOutput / runningScripts）全在内存里，
+     * 进程一挂就没了，但数据库里任务状态和执行记录仍停在 running/pending。
+     * 不修正会有两个后果：
+     *   1. 界面自相矛盾——列表显示「运行中」，日志抽屉却显示「已结束」且没有任何输出；
+     *   2. 任务被彻底卡死——requestRun 里 `rec.status === TS.RUNNING` 会永久拦截入队，
+     *      用户再点「运行」只会得到「任务未入队」。
+     *
+     * @returns 被复位状态的任务数
+     */
+    recoverInterrupted() {
+        let recovered = 0;
+        for (const rec of this.records.values()) {
+            if (rec.status !== TS.RUNNING && rec.status !== TS.PENDING)
+                continue;
+            // 回到可再次被触发的状态：启用中→空闲，已禁用→保持禁用
+            rec.status = rec.config.enabled ? TS.IDLE : TS.DISABLED;
+            rec.currentRetry = 0;
+            rec.lastResult = 'interrupted';
+            rec.lastError = '上次执行被服务重启中断';
+            this.repo.update(rec.id, rec.config, rec.status);
+            this.emit('status', this.statusEvent(rec));
+            recovered += 1;
+        }
+        // ── 收尾执行记录：先分辨「脚本真没了」还是「脚本仍在后台跑」 ──
+        //
+        // 旧实现是一刀切：把所有 status='running' 的记录收尾成「服务重启，执行被中断」。
+        // 但父进程被强杀时子进程不一定跟着死（Windows 尤其如此），于是会出现
+        // 「任务被判失败、python 其实还在改远端状态」——用户看到失败就会重点一次，
+        // 对部署类脚本来说这才是真正危险的地方。这里按 pid 存活情况分别定性。
+        const running = this.repo.listRunningExecutions();
+        const orphanIds = [];
+        const stillAlive = [];
+        for (const r of running) {
+            if (r.pid && isProcessAlive(r.pid))
+                stillAlive.push(r);
+            else
+                orphanIds.push(r.id);
+        }
+        const closed = this.repo.markRunningExecutionsInterrupted(undefined, undefined, orphanIds);
+        // 仍在后台运行的：如实标注（不擅自 kill，交给用户判断）
+        for (const r of stillAlive) {
+            const reason = `服务重启，执行被中断，但脚本仍在后台运行（pid ${r.pid}）——` +
+                `重跑前请先确认它的状态，必要时手动结束该进程`;
+            this.repo.markRunningExecutionsInterrupted(reason, undefined, [r.id]);
+            const rec = this.records.get(r.taskId);
+            if (rec) {
+                rec.lastError = reason;
+                this.repo.update(rec.id, rec.config, rec.status);
+                this.emit('status', this.statusEvent(rec));
+            }
+        }
+        if (stillAlive.length) {
+            console.warn(`[scheduler] 有 ${stillAlive.length} 个脚本在上次服务退出后仍在后台运行（pid: ${stillAlive
+                .map((r) => r.pid)
+                .join(', ')}），已如实标注，未擅自终止`);
+        }
+        // 内存态归零（进程刚起来时本就是这个值，显式重置以保证幂等）
+        this.queue = [];
+        this.executingId = null;
+        this.liveOutput.clear();
+        this.execRows.clear();
+        this.runningScripts.clear();
+        if (recovered || closed || stillAlive.length) {
+            this.emit('changed');
+            console.log(`[scheduler] 已恢复 ${recovered} 个中断任务，收尾 ${closed} 条未结束的执行记录` +
+                (stillAlive.length ? `，另有 ${stillAlive.length} 个脚本仍在后台运行` : ''));
+        }
+        return recovered;
+    }
+    // ── CRUD ──────────────────────────────────────────────────
+    listTasks() {
+        return [...this.records.values()].map((r) => ({ ...r }));
+    }
+    getTask(id) {
+        const r = this.records.get(id);
+        return r ? { ...r } : null;
+    }
+    createTask(config) {
+        const id = newTaskId();
+        const record = {
+            id,
+            config,
+            status: config.enabled ? TS.IDLE : TS.DISABLED,
+            createdAt: nowIso(),
+            executionCount: 0,
+            lastRunAt: null,
+            lastResult: null,
+            lastError: null,
+            nextRunAt: this.calcNextRun(config.trigger),
+            currentRetry: 0
+        };
+        this.records.set(id, record);
+        this.repo.insert(record);
+        this.applySchedule(record);
+        this.emit('changed');
+        return { ...record };
+    }
+    updateTask(id, config) {
+        const rec = this.records.get(id);
+        if (!rec)
+            return false;
+        rec.config = config;
+        rec.nextRunAt = this.calcNextRun(config.trigger);
+        if (!config.enabled)
+            rec.status = TS.DISABLED;
+        else if (rec.status === TS.DISABLED)
+            rec.status = TS.IDLE;
+        this.repo.update(id, config, rec.status);
+        this.unschedule(id);
+        this.applySchedule(rec);
+        this.emit('changed');
+        return true;
+    }
+    deleteTask(id) {
+        if (!this.records.has(id))
+            return false;
+        this.unschedule(id);
+        this.queue = this.queue.filter((q) => q !== id);
+        this.repo.delete(id);
+        this.records.delete(id);
+        this.emit('changed');
+        return true;
+    }
+    setEnabled(id, enabled) {
+        const rec = this.records.get(id);
+        if (!rec)
+            return false;
+        rec.config.enabled = enabled;
+        rec.status = enabled ? TS.IDLE : TS.DISABLED;
+        this.repo.update(id, rec.config, rec.status);
+        this.unschedule(id);
+        if (enabled)
+            this.applySchedule(rec);
+        this.emit('changed');
+        return true;
+    }
+    // ── 执行队列 ──────────────────────────────────────────────
+    /** 当前执行队列快照（运行中任务 + 按先后顺序排队中的任务） */
+    getQueueState() {
+        const nameOf = (id) => this.records.get(id)?.config.name ?? id;
+        return {
+            running: this.executingId ? { id: this.executingId, name: nameOf(this.executingId) } : null,
+            queue: this.queue.map((id) => ({ id, name: nameOf(id) }))
+        };
+    }
+    /** 队列变化广播（前端实时显示运行中 / 排队中） */
+    emitQueue() {
+        this.emit('queue', this.getQueueState());
+    }
+    // ── 实时输出（运行中即可查看 stdout/stderr） ──────────────
+    /** 追加实时输出并广播（由脚本输出回调驱动） */
+    appendLiveOutput(taskId, taskName, stream, text) {
+        if (!text)
+            return;
+        const buf = this.liveOutput.get(taskId) ?? { stdout: '', stderr: '' };
+        buf[stream] = appendTail(buf[stream], text, LIVE_OUTPUT_LIMIT);
+        this.liveOutput.set(taskId, buf);
+        this.emit('output', { taskId, taskName, stream, text, ts: Date.now() });
+        this.scheduleOutputFlush(taskId);
+    }
+    /**
+     * 标记该任务的输出待落盘，并按 OUTPUT_FLUSH_MS 节流统一写入。
+     * 避免每来一小段输出就写一次库（脚本输出可能非常密集）。
+     */
+    scheduleOutputFlush(taskId) {
+        this.dirtyOutputs.add(taskId);
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setInterval(() => this.flushLiveOutputs(), OUTPUT_FLUSH_MS);
+        this.flushTimer.unref?.();
+    }
+    /**
+     * 把累积的实时输出写进对应的执行记录。
+     * 这样即使任务随后被中断（进程被杀 / 直接关机），用户仍能看到中断前已产生的日志。
+     */
+    flushLiveOutputs() {
+        for (const taskId of this.dirtyOutputs) {
+            const execId = this.execRows.get(taskId);
+            const buf = this.liveOutput.get(taskId);
+            if (execId === undefined || !buf)
+                continue;
+            try {
+                this.repo.updateExecution(execId, {
+                    stdout: buf.stdout.slice(-EXEC_OUTPUT_LIMIT),
+                    stderr: buf.stderr.slice(-EXEC_OUTPUT_LIMIT)
+                });
+            }
+            catch {
+                /* 落盘失败不能影响任务本身，下次节拍或收尾时会再试 */
+            }
+        }
+        this.dirtyOutputs.clear();
+        this.clearFlushTimer();
+    }
+    clearFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    /** 某个任务的实时输出快照（含是否正在运行） */
+    getLiveOutput(taskId) {
+        const buf = this.liveOutput.get(taskId) ?? { stdout: '', stderr: '' };
+        return { stdout: buf.stdout, stderr: buf.stderr, running: this.executingId === taskId };
+    }
+    /** 清空排队中的任务（不影响正在运行的那个），返回取消数量 */
+    clearQueue() {
+        const ids = [...this.queue];
+        this.queue = [];
+        for (const id of ids) {
+            const rec = this.records.get(id);
+            if (!rec)
+                continue;
+            rec.status = TS.CANCELLED;
+            this.repo.update(id, rec.config, TS.CANCELLED);
+            this.emit('status', this.statusEvent(rec));
+        }
+        this.emitQueue();
+        return ids.length;
+    }
+    /** 全部停止：终止运行中的脚本 + 清空排队 */
+    stopAll() {
+        const cleared = this.clearQueue();
+        let stopped = 0;
+        if (this.executingId) {
+            const handle = this.runningScripts.get(this.executingId);
+            if (handle) {
+                handle.kill();
+                stopped = 1;
+            }
+        }
+        return { stopped, cleared };
+    }
+    // ── 执行 ──────────────────────────────────────────────────
+    /**
+     * 请求执行任务（手动或触发器）
+     * @returns 是否成功入队
+     */
+    requestRun(id, source = 'manual') {
+        const rec = this.records.get(id);
+        if (!rec)
+            return false;
+        if (this.executingId === id || rec.status === TS.RUNNING)
+            return false;
+        if (this.queue.includes(id))
+            return false;
+        // 队列按请求先后入队（FIFO；优先级配置已移除）
+        this.queue.push(id);
+        if (rec.status !== TS.PENDING) {
+            rec.status = TS.PENDING;
+        }
+        void source;
+        this.emit('status', this.statusEvent(rec));
+        this.pump();
+        this.emitQueue();
+        return true;
+    }
+    /** 停止任务：取消排队 / 终止运行中的脚本 */
+    stopTask(id) {
+        const rec = this.records.get(id);
+        if (!rec)
+            return false;
+        if (this.queue.includes(id)) {
+            this.queue = this.queue.filter((q) => q !== id);
+            rec.status = TS.CANCELLED;
+            this.repo.update(id, rec.config, rec.status);
+            this.emit('status', this.statusEvent(rec));
+            this.emitQueue();
+            return true;
+        }
+        if (this.executingId === id) {
+            const running = this.runningScripts.get(id);
+            running?.kill();
+            return true;
+        }
+        return false;
+    }
+    /** 运行中脚本的句柄（由 executeRecord 注册） */
+    runningScripts = new Map();
+    /** 带参执行的原始参数暂存（taskId → 原 scriptArgs） */
+    pendingArgOverrides = new Map();
+    /**
+     * 带参执行：临时覆盖 scriptArgs，执行完自动恢复原配置（微信「带参执行」指令）
+     */
+    runTaskWithArgs(id, args) {
+        const rec = this.records.get(id);
+        if (!rec)
+            return false;
+        if (this.executingId === id || this.queue.includes(id))
+            return false;
+        this.pendingArgOverrides.set(id, rec.config.scriptArgs ?? []);
+        rec.config.scriptArgs = [...args];
+        const ok = this.requestRun(id, 'manual');
+        if (!ok)
+            this.pendingArgOverrides.delete(id);
+        return ok;
+    }
+    /** 注入运行中脚本句柄（python_script 动作启动时调用） */
+    trackRunningScript(taskId, handle) {
+        if (handle)
+            this.runningScripts.set(taskId, handle);
+        else
+            this.runningScripts.delete(taskId);
+    }
+    /** 场景触发：闲置时长变化 */
+    notifyIdle(idleMinutes) {
+        for (const rec of this.records.values()) {
+            const t = rec.config.trigger;
+            if (rec.config.type === 'scene' &&
+                t.type === 'idle' &&
+                t.idleMinutes &&
+                idleMinutes >= t.idleMinutes &&
+                rec.config.enabled &&
+                rec.status === TS.IDLE) {
+                this.requestRun(rec.id, 'trigger');
+            }
+        }
+    }
+    /** 场景触发：联网事件 */
+    notifyNetwork() {
+        this.runSceneByType('network');
+    }
+    /** 场景触发辅助 */
+    runSceneByType(type) {
+        for (const rec of this.records.values()) {
+            if (rec.config.type === 'scene' &&
+                rec.config.trigger.type === type &&
+                rec.config.enabled &&
+                rec.status === TS.IDLE) {
+                this.requestRun(rec.id, 'trigger');
+            }
+        }
+    }
+    // ── 内部：执行引擎 ────────────────────────────────────────
+    pump() {
+        if (this.executingId)
+            return;
+        const next = this.queue.shift();
+        if (!next)
+            return;
+        void this.executeRecord(next);
+    }
+    async executeRecord(id) {
+        const rec = this.records.get(id);
+        if (!rec) {
+            this.pump();
+            return;
+        }
+        this.executingId = id;
+        rec.status = TS.RUNNING;
+        rec.executionCount += 1;
+        rec.lastRunAt = nowIso();
+        this.repo.update(id, rec.config, TS.RUNNING, rec.executionCount);
+        this.emit('status', this.statusEvent(rec));
+        this.emit('busy', true);
+        this.emitQueue();
+        const startedAt = nowIso();
+        // 本次执行开始 → 重置实时输出缓冲（供管理台实时查看）
+        this.liveOutput.set(id, { stdout: '', stderr: '' });
+        const execId = this.repo.insertExecution({
+            taskId: id,
+            taskName: rec.config.name,
+            status: 'running',
+            startedAt,
+            finishedAt: null,
+            exitCode: null,
+            durationMs: null,
+            stdout: '',
+            stderr: '',
+            error: ''
+        });
+        this.execRows.set(id, execId);
+        const t0 = Date.now();
+        let result;
+        try {
+            // 每次执行注入独立的 onOutput 回调（把脚本实时输出推给管理台）
+            const runCtx = {
+                ...this.actionCtx,
+                onOutput: (stream, text) => this.appendLiveOutput(id, rec.config.name, stream, text),
+                // 落库子进程 pid：服务中途被强杀时，靠它判断脚本是否还在后台跑
+                onChildPid: (pid) => {
+                    try {
+                        this.repo.updateExecution(execId, { pid });
+                    }
+                    catch {
+                        /* 落库失败不能影响执行本身 */
+                    }
+                }
+            };
+            result = await this.registry.execute(rec, runCtx);
+        }
+        catch (err) {
+            result = { success: false, error: String(err) };
+        }
+        const durationMs = Date.now() - t0;
+        // 执行已结束，停掉输出落盘定时器（下面会一次性写入完整结果）
+        this.dirtyOutputs.delete(id);
+        this.clearFlushTimer();
+        // 带参执行结束 → 恢复原配置参数
+        if (this.pendingArgOverrides.has(id)) {
+            rec.config.scriptArgs = this.pendingArgOverrides.get(id) ?? [];
+            this.pendingArgOverrides.delete(id);
+            this.repo.update(id, rec.config);
+        }
+        // 执行记录状态
+        const execStatus = result.timedOut
+            ? 'timeout'
+            : result.success
+                ? 'completed'
+                : 'failed';
+        this.repo.updateExecution(execId, {
+            status: execStatus,
+            finishedAt: nowIso(),
+            exitCode: result.exitCode ?? null,
+            durationMs,
+            stdout: (result.stdout ?? '').slice(-EXEC_OUTPUT_LIMIT),
+            stderr: (result.stderr ?? '').slice(-EXEC_OUTPUT_LIMIT),
+            error: result.error ?? ''
+        });
+        this.execRows.delete(id);
+        this.emit('execution', { taskId: id, taskName: rec.config.name, status: execStatus, durationMs, error: result.error ?? '' });
+        if (result.success) {
+            rec.lastResult = 'success';
+            rec.lastError = null;
+            this.setStatus(rec, TS.COMPLETED);
+            this.afterCompletion(rec, result);
+        }
+        else {
+            rec.lastResult = result.timedOut ? 'timeout' : 'failed';
+            rec.lastError = result.error ?? '未知错误';
+            this.handleFailure(rec);
+        }
+        this.executingId = null;
+        this.emit('busy', false);
+        this.pump();
+        this.emitQueue();
+    }
+    /** 成功后的通知与任务链 */
+    afterCompletion(rec, result) {
+        this.failStreak.delete(rec.id);
+        const channels = rec.config.notifyChannels ?? [];
+        if (channels.includes('desktop')) {
+            this.actionCtx.notifier.notify(`任务完成: ${rec.config.name}`, `耗时正常，状态成功`);
+        }
+        if (channels.includes('wechat')) {
+            this.actionCtx.notifier.sendWechat(`✅ 任务完成: ${rec.config.name}`);
+        }
+        // 任务链（方案 §3.3.B：支持 exit==0 / output contains 条件）
+        if (rec.config.chainNext && this.records.has(rec.config.chainNext)) {
+            const ok = evalChainCondition(rec.config.chainCondition, chainContextOf(result));
+            if (ok) {
+                this.requestRun(rec.config.chainNext, 'chain');
+            }
+        }
+    }
+    /** 失败处理（含重试，对齐旧版 _handle_failure） */
+    handleFailure(rec) {
+        const maxRetries = rec.config.retryCount ?? 0;
+        if (rec.currentRetry < maxRetries) {
+            rec.currentRetry += 1;
+            rec.status = TS.PENDING;
+            this.repo.update(rec.id, rec.config, TS.PENDING);
+            this.emit('status', this.statusEvent(rec));
+            const timer = setTimeout(() => {
+                this.requestRun(rec.id, 'retry');
+            }, RETRY_DELAY_MS);
+            timer.unref?.();
+            return;
+        }
+        rec.currentRetry = 0;
+        const note = maxRetries > 0 ? `重试 ${maxRetries} 次后仍失败` : '';
+        if (note) {
+            rec.lastError = rec.lastError ? `${rec.lastError}（${note}）` : note;
+        }
+        // 失败熔断：连续失败达到阈值自动禁用并告警（方案外补充）
+        if (this.checkCircuitBreaker(rec))
+            return;
+        this.setStatus(rec, TS.FAILED);
+    }
+    /** 连续失败计数；达到阈值返回 true 并执行禁用+告警 */
+    checkCircuitBreaker(rec) {
+        let threshold = 3;
+        try {
+            const v = this.actionCtx.config.get?.('tasks.breakerThreshold');
+            if (typeof v === 'number' && v >= 0)
+                threshold = v;
+        }
+        catch {
+            /* 测试环境无配置存储时用默认值 */
+        }
+        if (threshold <= 0) {
+            this.failStreak.delete(rec.id);
+            return false;
+        }
+        const streak = (this.failStreak.get(rec.id) ?? 0) + 1;
+        this.failStreak.set(rec.id, streak);
+        if (streak < threshold)
+            return false;
+        this.failStreak.delete(rec.id);
+        rec.config.enabled = false;
+        rec.lastError = `${rec.lastError ?? '任务失败'}\n⛔ 已连续失败 ${streak} 次，任务被自动禁用（失败熔断）`;
+        this.repo.update(rec.id, rec.config, TS.FAILED);
+        this.setStatus(rec, TS.DISABLED);
+        this.actionCtx.notifier.notify(`任务已熔断: ${rec.config.name}`, `连续失败 ${streak} 次，已自动禁用。请到管理台排查后重新启用。`);
+        this.actionCtx.notifier.sendWechat(`⛔ 任务熔断: ${rec.config.name}\n连续失败 ${streak} 次，已自动禁用`);
+        this.emit('changed');
+        return true;
+    }
+    setStatus(rec, status) {
+        rec.status = status;
+        this.repo.update(rec.id, rec.config, status);
+        this.emit('status', this.statusEvent(rec));
+        // 一次性任务：终态后自动删除
+        if (rec.config.oneTime &&
+            (status === TS.COMPLETED || status === TS.FAILED)) {
+            this.deleteTask(rec.id);
+        }
+    }
+    statusEvent(rec) {
+        return {
+            taskId: rec.id,
+            taskName: rec.config.name,
+            status: rec.status,
+            result: rec.lastResult ?? undefined
+        };
+    }
+    // ── 内部：触发注册 ────────────────────────────────────────
+    applySchedule(rec) {
+        if (rec.config.type !== 'scheduled' || !rec.config.enabled)
+            return;
+        const t = rec.config.trigger;
+        switch (t.type) {
+            case 'cron':
+                if (t.cron) {
+                    try {
+                        const job = schedule.scheduleJob(t.cron, () => this.triggered(rec.id));
+                        if (job)
+                            this.jobs.set(rec.id, job);
+                    }
+                    catch (err) {
+                        console.error(`[scheduler] cron 注册失败 (${rec.config.name}):`, err);
+                    }
+                }
+                break;
+            case 'once':
+                if (t.datetime) {
+                    const delay = this.onceDelayMs(t.datetime);
+                    if (delay > 0) {
+                        const timer = setTimeout(() => this.triggered(rec.id), delay);
+                        timer.unref?.();
+                        this.timers.set(rec.id, timer);
+                    }
+                }
+                break;
+            case 'delay':
+                if (t.delaySeconds && t.delaySeconds > 0) {
+                    const timer = setTimeout(() => this.triggered(rec.id), t.delaySeconds * 1000);
+                    timer.unref?.();
+                    this.timers.set(rec.id, timer);
+                }
+                break;
+            case 'interval':
+                if (t.intervalMinutes && t.intervalMinutes > 0) {
+                    const iv = setInterval(() => this.triggered(rec.id), t.intervalMinutes * 60 * 1000);
+                    iv.unref?.();
+                    this.intervals.set(rec.id, iv);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    unschedule(id) {
+        this.jobs.get(id)?.cancel();
+        this.jobs.delete(id);
+        const t = this.timers.get(id);
+        if (t)
+            clearTimeout(t);
+        this.timers.delete(id);
+        const iv = this.intervals.get(id);
+        if (iv)
+            clearInterval(iv);
+        this.intervals.delete(id);
+    }
+    /** 定时触发回调（对齐旧版 _scheduled_trigger） */
+    triggered(id) {
+        const rec = this.records.get(id);
+        if (!rec || !rec.config.enabled)
+            return;
+        const t = rec.config.trigger;
+        if (t.maxExecutions > 0 && rec.executionCount >= t.maxExecutions) {
+            this.unschedule(id);
+            this.setStatus(rec, TS.COMPLETED);
+            return;
+        }
+        // 工作日近似检测（周末跳过；法定节假日表暂不实现）
+        if (t.holidayCheck) {
+            const day = new Date().getDay();
+            if (day === 0 || day === 6)
+                return;
+        }
+        this.requestRun(id, 'trigger');
+    }
+    /** once 时间解析："YYYY-MM-DD HH:MM" 本地时间 */
+    onceDelayMs(datetime) {
+        const m = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})$/.exec(datetime.trim());
+        if (!m)
+            return -1;
+        const [, y, mo, d, h, mi] = m;
+        const target = new Date(+y, +mo - 1, +d, +h, +mi, 0, 0);
+        return target.getTime() - Date.now();
+    }
+    calcNextRun(trigger) {
+        if (trigger.type === 'once' && trigger.datetime) {
+            const delay = this.onceDelayMs(trigger.datetime);
+            if (delay > 0)
+                return new Date(Date.now() + delay).toISOString();
+            return null;
+        }
+        if (trigger.type === 'delay' && trigger.delaySeconds) {
+            return new Date(Date.now() + trigger.delaySeconds * 1000).toISOString();
+        }
+        return null;
+    }
+    /** 供测试/调试：清空内存态 */
+    resetInMemory() {
+        this.records.clear();
+        this.queue = [];
+        this.stop();
+        this.startedFlag = false;
+    }
+}