@xopcai/xopc 0.0.111 → 0.0.113

package/dist/src/cron/service.js

@@ -1,356 +1,419 @@
+import { init_agent_scope, normalizeAgentId } from "../agent/agent-scope.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { init_paths, resolveCronJobsPath } from "../config/paths.js";
+import { buildSessionKey, init_session_key } from "../routing/session-key.js";
+import { AddJobRequestSchema, JobDataSchema, UpdateJobRequestSchema } from "./validation.js";
+import { deleteCronJob, getCronJob, listCronJobs, saveCronJob, saveCronJobs } from "../storage/sqlite/cron-job-repository.js";
+import "../storage/sqlite/index.js";
+import { computeNextRunAtMs, describeSchedule, timerDelayUntil } from "./schedule.js";
 import { DefaultJobExecutor } from "./executor.js";
-import { AddJobRequestSchema, UpdateJobRequestSchema } from "./validation.js";
-import { CronPersistence } from "./persistence.js";
 import { CronRunLogStore } from "./run-log-store.js";
-import nodeCron from "node-cron";
-import { CronExpressionParser } from "cron-parser";
-import { v4 } from "uuid";
+import { randomUUID } from "node:crypto";
 //#region src/cron/service.ts
-init_paths();
 init_logger();
+init_agent_scope();
+init_session_key();
 const log = createLogger("CronService");
+const DEFAULT_MAX_CONCURRENT_JOBS = 5;
+const DEFAULT_MISSED_JOB_STAGGER_MS = 5e3;
+var CronJobAlreadyRunningError = class extends Error {
+	jobId;
+	runningSessionKey;
+	constructor(jobId, runningSessionKey) {
+		super(`Job is already running: ${jobId}`);
+		this.name = "CronJobAlreadyRunningError";
+		this.jobId = jobId;
+		this.runningSessionKey = runningSessionKey;
+	}
+};
+function nowMs() {
+	return Date.now();
+}
+function runStatusFromExecution(status) {
+	if (status === "success") return "ok";
+	if (status === "cancelled" || status === "skipped") return "skipped";
+	return "error";
+}
+async function postFailureWebhook(url, payload) {
+	const res = await fetch(url, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(payload)
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(`Cron failure webhook failed: HTTP ${res.status}${text ? ` ${text.slice(0, 200)}` : ""}`);
+	}
+}
+function inferJobName(input) {
+	if (input.name?.trim()) return input.name.trim();
+	if (input.payload.kind === "agentTurn") return input.payload.message.slice(0, 60) || "Agent task";
+	if (input.payload.kind === "systemEvent") return input.payload.text.slice(0, 60) || "System event";
+	if (input.payload.kind === "workflowRun") return `Workflow ${input.payload.definitionId}`;
+	if (input.payload.kind === "goalContinue") return `Goal ${input.payload.goalId}`;
+	return describeSchedule(input.schedule);
+}
+function resolveRunningSessionKey(job, deps) {
+	if (job.payload.kind !== "agentTurn") return void 0;
+	if (job.sessionTarget.startsWith("session:")) return job.sessionTarget.slice(8).trim() || void 0;
+	if (job.sessionTarget === "current") return job.sessionKey?.trim() || void 0;
+	if (job.sessionTarget !== "isolated") return;
+	const aid = job.agentId?.trim();
+	const fallbackAgentId = deps.getDefaultCronAgentId?.() ?? "main";
+	return buildSessionKey({
+		agentId: normalizeAgentId(aid || fallbackAgentId),
+		source: "cron",
+		accountId: "default",
+		peerKind: "dm",
+		peerId: `${job.id}-${randomUUID().slice(0, 8)}`
+	});
+}
 var CronService = class {
-	persistence;
-	executor;
+	executor = new DefaultJobExecutor();
 	runLogStore;
-	tasks = /* @__PURE__ */ new Map();
 	initialized = false;
-	agentService = null;
-	messageBus = null;
+	stopped = false;
+	running = false;
+	timer = null;
+	deps = {};
+	maxConcurrentJobs;
+	missedJobStaggerMs;
 	constructor(config) {
-		const filePath = config?.filePath || resolveCronJobsPath();
-		this.persistence = new CronPersistence(filePath);
-		this.executor = new DefaultJobExecutor();
 		this.runLogStore = new CronRunLogStore(config?.dbPath);
 		this.executor.setRunLogStore(this.runLogStore);
+		this.maxConcurrentJobs = Math.max(1, Math.floor(config?.maxConcurrentJobs ?? DEFAULT_MAX_CONCURRENT_JOBS));
+		this.missedJobStaggerMs = Math.max(0, Math.floor(config?.missedJobStaggerMs ?? DEFAULT_MISSED_JOB_STAGGER_MS));
 		if (config?.agentService || config?.messageBus) this.setDeps({
 			agentService: config.agentService,
 			messageBus: config.messageBus
 		});
 	}
-	/**
-	* Set dependencies for the executor
-	*/
 	setDeps(deps) {
-		this.agentService = deps.agentService;
-		this.messageBus = deps.messageBus;
-		this.executor.setDeps(deps);
+		this.deps = {
+			...this.deps,
+			...deps
+		};
+		this.executor.setDeps(this.deps);
 		log.debug("CronService dependencies set");
 	}
-	/**
-	* Initialize the service and load all jobs
-	*/
 	async initialize() {
 		if (this.initialized) return;
-		await this.persistence.initialize();
-		await this.loadAllJobs();
+		this.stopped = false;
+		await this.recomputeAllNextRuns({ catchUp: true });
 		this.initialized = true;
-		log.debug("CronService initialized");
+		this.armTimer();
+		log.info("CronService initialized");
 	}
-	/**
-	* Add a new job
-	*/
-	async addJob(schedule, options) {
-		const validationResult = AddJobRequestSchema.safeParse({
-			schedule,
-			...options
-		});
-		if (!validationResult.success) {
-			const errorMsg = validationResult.error?.errors.map((e) => e.message).join(", ") || "Unknown validation error";
-			throw new Error(`Validation failed: ${errorMsg}`);
-		}
-		const data = validationResult.data;
-		const id = v4().slice(0, 8);
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const sessionTarget = data.sessionTarget ?? "main";
-		const job = {
+	async addJob(scheduleOrInput, options) {
+		const raw = options ? {
+			...options,
+			schedule: scheduleOrInput
+		} : scheduleOrInput;
+		const parsed = AddJobRequestSchema.parse(raw);
+		const ts = nowMs();
+		const id = parsed.id?.trim() || randomUUID().slice(0, 12);
+		const job = JobDataSchema.parse({
+			...parsed,
 			id,
-			name: data.name,
-			schedule: data.schedule,
-			enabled: true,
-			timezone: data.timezone,
-			maxRetries: data.maxRetries ?? 3,
-			timeout: data.timeout ?? 6e4,
-			created_at: now,
-			updated_at: now,
-			sessionTarget,
-			...data.agentId ? { agentId: data.agentId } : {},
-			...data.workingDirectory ? { workingDirectory: data.workingDirectory } : {},
-			payload: data.payload,
-			delivery: data.delivery,
-			model: data.model
-		};
-		await this.persistence.addJob(job);
-		this.scheduleJob(job);
+			name: inferJobName(parsed),
+			enabled: parsed.enabled ?? true,
+			deleteAfterRun: parsed.deleteAfterRun ?? parsed.schedule.kind === "at",
+			createdAtMs: ts,
+			updatedAtMs: ts,
+			sessionTarget: parsed.sessionTarget ?? (parsed.payload.kind === "systemEvent" ? "main" : "isolated"),
+			wakeMode: parsed.wakeMode ?? "now",
+			state: { ...parsed.state ?? {} }
+		});
+		job.state.nextRunAtMs = computeNextRunAtMs(job, ts);
+		saveCronJob(job);
+		this.armTimer();
 		log.info({
-			jobId: id,
-			name: data.name,
-			sessionTarget
-		}, "Job added");
+			jobId: job.id,
+			name: job.name,
+			schedule: job.schedule
+		}, "Cron job added");
 		return {
-			id,
-			schedule: data.schedule
+			id: job.id,
+			schedule: job.schedule
 		};
 	}
-	/**
-	* List all jobs with next run time
-	*/
 	async listJobs() {
-		return (await this.persistence.getJobs()).map((job) => {
-			let nextRun;
-			if (job.enabled) try {
-				const options = job.timezone ? { tz: job.timezone } : void 0;
-				nextRun = CronExpressionParser.parse(job.schedule, options).next().toISOString();
-			} catch (err) {
-				log.debug({
-					jobId: job.id,
-					err
-				}, "Failed to parse cron for next run");
-			}
-			return {
-				id: job.id,
-				name: job.name,
-				schedule: job.schedule,
-				enabled: job.enabled,
-				timezone: job.timezone,
-				maxRetries: job.maxRetries,
-				timeout: job.timeout,
-				sessionTarget: job.sessionTarget,
-				...job.agentId ? { agentId: job.agentId } : {},
-				...job.workingDirectory ? { workingDirectory: job.workingDirectory } : {},
-				payload: job.payload,
-				delivery: job.delivery,
-				model: job.model,
-				next_run: nextRun
-			};
-		});
+		return listCronJobs();
 	}
-	/**
-	* Get a single job
-	*/
 	async getJob(id) {
-		return this.persistence.getJob(id);
+		return getCronJob(id);
 	}
-	/**
-	* Update a job
-	*/
 	async updateJob(id, updates) {
-		const validationResult = UpdateJobRequestSchema.safeParse(updates);
-		if (!validationResult.success) {
-			const errorMsg = validationResult.error?.errors.map((e) => e.message).join(", ") || "Unknown validation error";
-			throw new Error(`Validation failed: ${errorMsg}`);
-		}
-		const job = await this.persistence.getJob(id);
-		if (!job) return false;
-		const { agentId: agentIdPatch, workingDirectory: workingDirectoryPatch, ...rest } = validationResult.data;
-		const patch = { ...rest };
-		let clearAgentId = false;
-		if (agentIdPatch === null) clearAgentId = true;
-		else if (agentIdPatch !== void 0) patch.agentId = agentIdPatch;
-		let clearWorkingDirectory = false;
-		if (workingDirectoryPatch === null) clearWorkingDirectory = true;
-		else if (workingDirectoryPatch !== void 0) patch.workingDirectory = workingDirectoryPatch;
-		if (patch.schedule && patch.schedule !== job.schedule) this.cancelTask(id);
-		await this.persistence.updateJob(id, patch, {
-			clearAgentId,
-			clearWorkingDirectory
+		const parsed = UpdateJobRequestSchema.parse(updates);
+		const current = getCronJob(id);
+		if (!current) return false;
+		const ts = nowMs();
+		const next = JobDataSchema.parse({
+			...current,
+			...parsed,
+			id: current.id,
+			createdAtMs: current.createdAtMs,
+			updatedAtMs: ts,
+			state: {
+				...current.state,
+				...parsed.state ?? {}
+			}
 		});
-		const updated = await this.persistence.getJob(id);
-		if (updated && updated.enabled) this.scheduleJob(updated);
-		log.info({ jobId: id }, "Job updated");
+		if ("schedule" in parsed || "enabled" in parsed) {
+			next.state.nextRunAtMs = computeNextRunAtMs(next, ts);
+			delete next.state.runningAtMs;
+		}
+		if ("agentId" in updates && updates.agentId?.trim() === "") delete next.agentId;
+		if ("workingDirectory" in updates && updates.workingDirectory?.trim() === "") delete next.workingDirectory;
+		saveCronJob(next);
+		this.armTimer();
+		log.info({ jobId: id }, "Cron job updated");
 		return true;
 	}
-	/**
-	* Remove a job
-	*/
 	async removeJob(id) {
-		this.cancelTask(id);
-		const removed = await this.persistence.removeJob(id);
+		const removed = deleteCronJob(id);
 		if (removed) {
+			this.executor.cancelJob(id);
 			await this.runLogStore.deleteJobRuns(id);
-			log.info({ jobId: id }, "Job removed");
+			this.armTimer();
+			log.info({ jobId: id }, "Cron job removed");
 		}
 		return removed;
 	}
-	/**
-	* Toggle job enabled state
-	*/
 	async toggleJob(id, enabled) {
-		if (!await this.persistence.getJob(id)) return false;
-		await this.persistence.updateJob(id, { enabled });
-		if (enabled) {
-			const updated = await this.persistence.getJob(id);
-			if (updated) this.scheduleJob(updated);
-		} else this.cancelTask(id);
-		log.info({
-			jobId: id,
-			enabled
-		}, "Job toggled");
-		return true;
+		return this.updateJob(id, { enabled });
 	}
-	/**
-	* Execution history for one job: merged in-memory (incl. running) + persisted SQLite rows.
-	*/
 	async getJobHistory(jobId, limit) {
-		const cap = Math.min(Math.max(limit ?? 10, 1), 500);
-		const [disk, memory] = await Promise.all([this.runLogStore.readJobHistory(jobId, cap * 2), Promise.resolve(this.executor.getHistory(jobId, cap * 2))]);
-		const byId = /* @__PURE__ */ new Map();
-		for (const e of memory) byId.set(e.id, e);
-		for (const e of disk) if (!byId.has(e.id)) byId.set(e.id, e);
-		return [...byId.values()].sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()).slice(0, cap);
+		return this.runLogStore.readJobHistory(jobId, Math.min(Math.max(limit ?? 10, 1), 500));
 	}
-	/**
-	* Latest runs across all jobs (persisted rows + optional job name).
-	*/
 	async getAllRunsHistory(limit) {
 		const cap = Math.min(Math.max(limit ?? 50, 1), 500);
-		const jobs = await this.persistence.getJobs();
-		const jobNames = new Map(jobs.map((j) => [j.id, j.name]));
-		return this.runLogStore.readAllRuns(cap, jobNames);
+		const jobs = listCronJobs();
+		const names = new Map(jobs.map((job) => [job.id, job.name]));
+		return this.runLogStore.readAllRuns(cap, names);
 	}
-	/**
-	* Get service metrics
-	*/
 	async getMetrics() {
-		const jobs = await this.persistence.getJobs();
-		const enabled = jobs.filter((j) => j.enabled);
-		let nextScheduledJob;
-		for (const job of enabled) try {
-			const options = job.timezone ? { tz: job.timezone } : void 0;
-			const next = CronExpressionParser.parse(job.schedule, options).next();
-			if (!nextScheduledJob || next.getTime() < nextScheduledJob.runAt.getTime()) nextScheduledJob = {
-				id: job.id,
-				name: job.name,
-				runAt: next.toDate()
-			};
-		} catch {}
+		const jobs = listCronJobs();
+		const enabled = jobs.filter((job) => job.enabled);
+		const next = enabled.filter((job) => job.state.nextRunAtMs != null).toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0))[0];
 		return {
 			totalJobs: jobs.length,
-			runningJobs: this.tasks.size,
+			runningJobs: jobs.filter((job) => job.state.runningAtMs != null).length,
 			enabledJobs: enabled.length,
-			failedLastHour: 0,
+			failedLastHour: jobs.filter((job) => job.state.lastRunStatus === "error" && (job.state.lastRunAtMs ?? 0) >= nowMs() - 60 * 6e4).length,
 			avgExecutionTime: 0,
-			nextScheduledJob
+			nextScheduledJob: next?.state.nextRunAtMs ? {
+				id: next.id,
+				name: next.name,
+				runAt: new Date(next.state.nextRunAtMs)
+			} : void 0
 		};
 	}
-	/**
-	* Update config (hot reload)
-	*/
-	updateConfig(_config) {
-		log.debug("Cron config updated (jobs managed separately via addJob/removeJob)");
+	updateConfig(config) {
+		this.maxConcurrentJobs = Math.max(1, Math.floor(config.cron?.maxConcurrentJobs ?? DEFAULT_MAX_CONCURRENT_JOBS));
+		this.armTimer();
 	}
-	/**
-	* Health check
-	*/
 	async healthCheck() {
 		const issues = [];
 		if (!this.initialized) issues.push("Service not initialized");
-		const jobs = await this.persistence.getJobs();
-		for (const job of jobs) if (!nodeCron.validate(job.schedule)) issues.push(`Job ${job.id} has invalid schedule`);
-		for (const job of jobs) if (job.enabled && job.sessionTarget === "isolated" && !this.agentService) {
-			issues.push(`Job ${job.id} requires agent service but none configured`);
-			break;
+		for (const job of listCronJobs()) {
+			if (!JobDataSchema.safeParse(job).success) issues.push(`Job ${job.id} is invalid`);
+			if (job.enabled && job.state.nextRunAtMs == null && job.schedule.kind !== "at") issues.push(`Job ${job.id} has no next run`);
 		}
-		let status = "healthy";
-		if (issues.length > 0) status = issues.length > 5 ? "unhealthy" : "degraded";
 		return {
-			status,
+			status: issues.length === 0 ? "healthy" : issues.length > 5 ? "unhealthy" : "degraded",
 			issues
 		};
 	}
-	/**
-	* Run a job immediately (manual trigger)
-	*/
 	async runJobNow(id) {
-		const job = await this.persistence.getJob(id);
+		const job = getCronJob(id);
 		if (!job) throw new Error(`Job not found: ${id}`);
-		if (!job.enabled) throw new Error(`Job is disabled: ${id}`);
-		await this.executeJob(job);
+		if (job.state.runningAtMs != null) throw new CronJobAlreadyRunningError(id, job.state.runningSessionKey);
+		return {
+			job: this.startSingleJob(job, { manual: true }),
+			history: await this.getJobHistory(id, 20)
+		};
 	}
-	/**
-	* Stop all jobs and cleanup
-	*/
 	async stop(options) {
-		const timeout = options?.timeout ?? 3e4;
-		for (const [id, task] of this.tasks) {
-			task.stop();
-			this.executor.cancelJob(id);
+		this.stopped = true;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
 		}
-		this.tasks.clear();
+		for (const job of listCronJobs()) this.executor.cancelJob(job.id);
 		if (options?.waitForRunning) {
-			const start = Date.now();
-			while (Date.now() - start < timeout) {
-				if (this.executor.getRunningExecutions().length === 0) break;
-				await new Promise((r) => setTimeout(r, 100));
+			const started = nowMs();
+			const timeout = options.timeout ?? 3e4;
+			while (nowMs() - started < timeout) {
+				if (listCronJobs().every((job) => job.state.runningAtMs == null)) break;
+				await new Promise((resolve) => setTimeout(resolve, 100));
 			}
 		}
-		await this.persistence.flush();
 		log.info("CronService stopped");
 	}
-	/**
-	* Load and schedule all enabled jobs
-	*/
-	async loadAllJobs() {
-		const jobs = await this.persistence.getJobs();
-		for (const job of jobs) if (job.enabled) this.scheduleJob(job);
-		log.debug({ count: this.tasks.size }, "Jobs loaded");
+	async recomputeAllNextRuns(opts) {
+		const ts = nowMs();
+		saveCronJobs(listCronJobs().map((job, index) => {
+			const next = {
+				...job,
+				state: { ...job.state }
+			};
+			if (next.state.runningAtMs != null) {
+				next.state.lastRunStatus = "error";
+				next.state.lastError = "Interrupted by gateway restart";
+				next.state.consecutiveErrors = (next.state.consecutiveErrors ?? 0) + 1;
+				delete next.state.runningAtMs;
+			}
+			if (next.enabled) {
+				const existingNext = next.state.nextRunAtMs;
+				if (opts?.catchUp && existingNext != null && existingNext <= ts) next.state.nextRunAtMs = ts + index * this.missedJobStaggerMs;
+				else next.state.nextRunAtMs = computeNextRunAtMs(next, ts);
+			} else next.state.nextRunAtMs = void 0;
+			return next;
+		}));
 	}
-	/**
-	* Schedule a job with node-cron
-	*/
-	scheduleJob(job) {
-		this.cancelTask(job.id);
-		if (!nodeCron.validate(job.schedule)) {
-			log.error({
-				jobId: job.id,
-				schedule: job.schedule
-			}, "Invalid cron expression");
-			return;
+	armTimer() {
+		if (this.stopped) return;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
 		}
-		const options = job.timezone ? { timezone: job.timezone } : void 0;
-		const task = nodeCron.schedule(job.schedule, async () => {
-			await this.executeJob(job);
-		}, options);
-		this.tasks.set(job.id, task);
-		log.debug({
-			jobId: job.id,
-			schedule: job.schedule
-		}, "Job scheduled");
+		const next = listCronJobs().filter((job) => job.enabled && job.state.nextRunAtMs != null).toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0))[0];
+		if (!next?.state.nextRunAtMs) return;
+		this.timer = setTimeout(() => {
+			this.onTimer();
+		}, timerDelayUntil(next.state.nextRunAtMs));
+		this.timer.unref?.();
 	}
-	/**
-	* Execute a job with retry logic
-	*/
-	async executeJob(job) {
-		if (this.executor.isRunning(job.id)) {
-			log.warn({ jobId: job.id }, "Job already running, skipping");
+	async onTimer() {
+		if (this.stopped) return;
+		if (this.running) {
+			this.armTimer();
 			return;
 		}
-		const controller = new AbortController();
+		this.running = true;
 		try {
-			await this.executor.execute(job, controller.signal);
-		} catch (error) {
+			const ts = nowMs();
+			const due = listCronJobs().filter((job) => job.enabled && job.state.nextRunAtMs != null && job.state.nextRunAtMs <= ts && job.state.runningAtMs == null).slice(0, this.maxConcurrentJobs);
+			if (due.length === 0) return;
+			const reserved = due.map((job) => ({
+				...job,
+				state: {
+					...job.state,
+					runningAtMs: ts
+				}
+			}));
+			saveCronJobs(reserved);
+			await Promise.all(reserved.map((job) => this.runSingleJob(job)));
+		} finally {
+			this.running = false;
+			this.armTimer();
+		}
+	}
+	startSingleJob(job, opts) {
+		const started = nowMs();
+		const runningSessionKey = resolveRunningSessionKey(job, this.deps);
+		const reserved = {
+			...job,
+			state: {
+				...job.state,
+				runningAtMs: started,
+				...runningSessionKey ? { runningSessionKey } : {}
+			}
+		};
+		saveCronJob(reserved);
+		this.runReservedJob(reserved, started, runningSessionKey, opts).catch((err) => {
 			log.error({
-				jobId: job.id,
-				err: error
-			}, "Job execution failed");
+				err,
+				jobId: job.id
+			}, `Background cron job failed: ${err instanceof Error ? err.message : String(err)}`);
+		});
+		return reserved;
+	}
+	async runSingleJob(job, opts) {
+		const started = nowMs();
+		const runningSessionKey = resolveRunningSessionKey(job, this.deps);
+		const reserved = {
+			...job,
+			state: {
+				...job.state,
+				runningAtMs: started,
+				...runningSessionKey ? { runningSessionKey } : {}
+			}
+		};
+		saveCronJob(reserved);
+		await this.runReservedJob(reserved, started, runningSessionKey, opts);
+	}
+	async runReservedJob(reserved, started, runningSessionKey, opts) {
+		const controller = new AbortController();
+		await this.executor.execute(runningSessionKey ? {
+			...reserved,
+			sessionKey: runningSessionKey
+		} : reserved, controller.signal, this.deps);
+		const latestRun = (await this.getJobHistory(reserved.id, 1))[0];
+		const finished = nowMs();
+		const status = latestRun ? runStatusFromExecution(latestRun.status) : "error";
+		const latest = getCronJob(reserved.id);
+		if (!latest) return;
+		const next = {
+			...latest,
+			state: {
+				...latest.state,
+				lastRunAtMs: finished,
+				lastRunStatus: status,
+				lastError: latestRun?.error,
+				lastDurationMs: finished - started,
+				consecutiveErrors: status === "error" ? (latest.state.consecutiveErrors ?? 0) + 1 : 0,
+				consecutiveSkipped: status === "skipped" ? (latest.state.consecutiveSkipped ?? 0) + 1 : 0,
+				lastDeliveryStatus: latest.delivery?.mode && latest.delivery.mode !== "none" ? "unknown" : "not-requested"
+			}
+		};
+		delete next.state.runningAtMs;
+		delete next.state.runningSessionKey;
+		if (!opts?.manual && next.deleteAfterRun && status === "ok") {
+			await this.removeJob(next.id);
+			return;
 		}
+		next.state.nextRunAtMs = computeNextRunAtMs(next, finished);
+		saveCronJob(next);
+		await this.maybeEmitFailureAlert(next);
 	}
-	/**
-	* Cancel a scheduled task
-	*/
-	cancelTask(id) {
-		const task = this.tasks.get(id);
-		if (task) {
-			task.stop();
-			this.tasks.delete(id);
-			log.debug({ jobId: id }, "Task cancelled");
+	async maybeEmitFailureAlert(job) {
+		if (!job.failureAlert) return;
+		if (job.state.lastRunStatus !== "error") return;
+		const threshold = job.failureAlert.after ?? 1;
+		if ((job.state.consecutiveErrors ?? 0) < threshold) return;
+		const ts = nowMs();
+		const cooldownMs = job.failureAlert.cooldownMs ?? 60 * 6e4;
+		if (job.state.lastFailureAlertAtMs && ts - job.state.lastFailureAlertAtMs < cooldownMs) return;
+		const channel = job.failureAlert.channel || job.delivery?.channel;
+		const to = job.failureAlert.to || job.delivery?.to;
+		if (!to) return;
+		if (job.failureAlert.mode === "webhook") {
+			await postFailureWebhook(to, {
+				jobId: job.id,
+				jobName: job.name,
+				status: job.state.lastRunStatus,
+				error: job.state.lastError ?? "Unknown error",
+				consecutiveErrors: job.state.consecutiveErrors ?? 0,
+				lastRunAtMs: job.state.lastRunAtMs
+			});
+			job.state.lastFailureAlertAtMs = ts;
+			saveCronJob(job);
+			return;
 		}
+		if (!this.deps.messageBus || !channel) return;
+		await this.deps.messageBus.publishOutbound({
+			channel,
+			chat_id: to,
+			type: "message",
+			content: `Cron job failed: ${job.name}\n${job.state.lastError ?? "Unknown error"}`
+		});
+		job.state.lastFailureAlertAtMs = ts;
+		saveCronJob(job);
 	}
 };
 //#endregion
-export { CronService };
+export { CronJobAlreadyRunningError, CronService };
 
 //# sourceMappingURL=service.js.map