@xopcai/xopc 0.0.118 → 0.0.120

package/dist/src/automations/service/action-executor.js

@@ -0,0 +1,157 @@
+import { init_agent_scope, normalizeAgentId } from "../../agent/agent-scope.js";
+import { buildSessionKey, init_session_key } from "../../routing/session-key.js";
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import crypto from "node:crypto";
+//#region src/automations/service/action-executor.ts
+init_agent_scope();
+init_session_key();
+init_logger();
+const log = createLogger("Automation:ActionExecutor");
+const DEFAULT_TIMEOUT_MS = 18e4;
+function withTimeout(promise, timeoutMs, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(/* @__PURE__ */ new Error("Automation run was cancelled"));
+			return;
+		}
+		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Automation timed out after ${timeoutMs}ms`)), timeoutMs);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("Automation run was cancelled"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (err) => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(err);
+		});
+	});
+}
+var AutomationActionExecutor = class {
+	deps = {};
+	setDeps(deps) {
+		this.deps = {
+			...this.deps,
+			...deps
+		};
+	}
+	async execute(automation, run, signal) {
+		const timeoutMs = (automation.action.timeoutSeconds ?? automation.reliability?.timeoutSeconds ?? 0) > 0 ? (automation.action.timeoutSeconds ?? automation.reliability?.timeoutSeconds) * 1e3 : DEFAULT_TIMEOUT_MS;
+		return withTimeout(this.executeWithoutTimeout(automation, run, signal), timeoutMs, signal).catch((err) => {
+			const message = err instanceof Error ? err.message : String(err);
+			return {
+				status: message.toLowerCase().includes("cancelled") ? "cancelled" : message.toLowerCase().includes("timed out") ? "timeout" : "failed",
+				error: message
+			};
+		});
+	}
+	async executeWithoutTimeout(automation, run, signal) {
+		if (signal.aborted) return {
+			status: "cancelled",
+			error: "Automation run was cancelled"
+		};
+		if (automation.action.kind === "workflow") return this.executeWorkflow(automation, automation.action, run);
+		return this.executeAgent(automation, automation.action);
+	}
+	async executeAgent(automation, action) {
+		const agentService = this.deps.agentService;
+		if (!agentService?.turnDispatcher?.processDirect) return {
+			status: "failed",
+			error: "Agent service is not available"
+		};
+		const sessionKey = buildSessionKey({
+			agentId: normalizeAgentId(action.agentId || this.deps.getDefaultAgentId?.() || "main"),
+			source: "automation",
+			accountId: "default",
+			peerKind: "dm",
+			peerId: `${automation.id}-${crypto.randomUUID().slice(0, 8)}`
+		});
+		await agentService.sessionConfig?.applyAutomationWorkingDirectory?.(sessionKey, action.workingDirectory);
+		if (agentService.sessionConfig?.applyAutomationModelOverride) {
+			if (!await agentService.sessionConfig.applyAutomationModelOverride(sessionKey, action.model) && action.model) log.warn({
+				automationId: automation.id,
+				sessionKey,
+				model: action.model
+			}, "Automation model override invalid; using agent default");
+		}
+		const response = await agentService.turnDispatcher.processDirect(buildSafetyInstruction(automation, action.instruction), sessionKey);
+		const model = agentService.getModelForSession?.(sessionKey);
+		return {
+			status: "succeeded",
+			summary: response.slice(0, 500),
+			sessionKey,
+			model
+		};
+	}
+	async executeWorkflow(automation, action, run) {
+		const safetyMode = automation.safety?.mode ?? "auto_apply";
+		if (safetyMode === "suggest_only") return {
+			status: "succeeded",
+			summary: `Suggest only: workflow ${action.workflowId} was not started. Review the automation and upgrade safety mode to run it automatically.`
+		};
+		if (safetyMode === "ask_before_apply") return {
+			status: "succeeded",
+			summary: `Ask before applying: workflow ${action.workflowId} is ready, but was not started automatically. Upgrade to Auto apply when you trust this automation.`
+		};
+		const workflowRunService = this.deps.workflowRunService;
+		if (!workflowRunService) return {
+			status: "failed",
+			error: "Workflow service is not available"
+		};
+		const agentId = normalizeAgentId(action.agentId || this.deps.getDefaultAgentId?.() || "main");
+		const idempotencyKey = `automation:${automation.id}:${run.id}`;
+		const result = await workflowRunService.startWorkflowRun({
+			agentId,
+			definitionId: action.workflowId,
+			input: action.input,
+			inputEnvelope: action.inputEnvelope,
+			goal: action.goal,
+			concurrency: action.concurrency,
+			maxSubagents: action.maxSubagents,
+			source: {
+				kind: "automation",
+				automationId: automation.id,
+				runId: run.id
+			},
+			idempotencyKey
+		});
+		if (result.ok === false) return {
+			status: "failed",
+			error: result.message
+		};
+		return {
+			status: "succeeded",
+			summary: `Started workflow run ${result.runId}`,
+			sessionKey: result.sessionKey,
+			workflowRunId: result.runId
+		};
+	}
+};
+function buildSafetyInstruction(automation, instruction) {
+	const mode = automation.safety?.mode ?? "auto_apply";
+	if (mode === "suggest_only") return [
+		"Automation safety mode: Suggest only.",
+		"Only analyze the situation and produce a concise recommendation.",
+		"Do not modify files, notes, goals, workflows, external systems, or persistent state.",
+		"If a change seems useful, describe the exact change for the user to review.",
+		"",
+		instruction
+	].join("\n");
+	if (mode === "ask_before_apply") return [
+		"Automation safety mode: Ask before applying.",
+		"Draft the proposed change or action and clearly ask for user confirmation before applying anything.",
+		"Do not perform irreversible or external side effects unless the user has explicitly approved them in this run.",
+		"",
+		instruction
+	].join("\n");
+	return instruction;
+}
+//#endregion
+export { AutomationActionExecutor };
+
+//# sourceMappingURL=action-executor.js.map

package/dist/src/automations/service/action-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-executor.js","names":[],"sources":["../../../../src/automations/service/action-executor.ts"],"sourcesContent":["import crypto from 'node:crypto';\n\nimport { DEFAULT_AGENT_ID, normalizeAgentId } from '../../agent/agent-scope.js';\nimport { buildSessionKey } from '../../routing/session-key.js';\nimport { createLogger } from '../../utils/logger.js';\nimport type {\n  Automation,\n  AutomationAction,\n  AutomationActionOutcome,\n  AutomationDeps,\n  AutomationRun,\n} from '../domain/types.js';\n\nconst log = createLogger('Automation:ActionExecutor');\n\nconst DEFAULT_TIMEOUT_MS = 180_000;\n\nfunction withTimeout<T>(promise: Promise<T>, timeoutMs: number, signal: AbortSignal): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    if (signal.aborted) {\n      reject(new Error('Automation run was cancelled'));\n      return;\n    }\n    const timer = setTimeout(() => reject(new Error(`Automation timed out after ${timeoutMs}ms`)), timeoutMs);\n    const onAbort = () => {\n      clearTimeout(timer);\n      reject(new Error('Automation run was cancelled'));\n    };\n    signal.addEventListener('abort', onAbort, { once: true });\n    promise.then(\n      (value) => {\n        clearTimeout(timer);\n        signal.removeEventListener('abort', onAbort);\n        resolve(value);\n      },\n      (err) => {\n        clearTimeout(timer);\n        signal.removeEventListener('abort', onAbort);\n        reject(err);\n      },\n    );\n  });\n}\n\nexport class AutomationActionExecutor {\n  private deps: AutomationDeps = {};\n\n  setDeps(deps: AutomationDeps): void {\n    this.deps = { ...this.deps, ...deps };\n  }\n\n  async execute(\n    automation: Automation,\n    run: AutomationRun,\n    signal: AbortSignal,\n  ): Promise<AutomationActionOutcome> {\n    const timeoutMs =\n      (automation.action.timeoutSeconds ?? automation.reliability?.timeoutSeconds ?? 0) > 0\n        ? (automation.action.timeoutSeconds ?? automation.reliability?.timeoutSeconds)! * 1000\n        : DEFAULT_TIMEOUT_MS;\n\n    return withTimeout(this.executeWithoutTimeout(automation, run, signal), timeoutMs, signal).catch((err) => {\n      const message = err instanceof Error ? err.message : String(err);\n      return {\n        status: message.toLowerCase().includes('cancelled')\n          ? 'cancelled'\n          : message.toLowerCase().includes('timed out')\n            ? 'timeout'\n            : 'failed',\n        error: message,\n      };\n    });\n  }\n\n  private async executeWithoutTimeout(\n    automation: Automation,\n    run: AutomationRun,\n    signal: AbortSignal,\n  ): Promise<AutomationActionOutcome> {\n    if (signal.aborted) {\n      return { status: 'cancelled', error: 'Automation run was cancelled' };\n    }\n    if (automation.action.kind === 'workflow') {\n      return this.executeWorkflow(automation, automation.action, run);\n    }\n    return this.executeAgent(automation, automation.action);\n  }\n\n  private async executeAgent(\n    automation: Automation,\n    action: Extract<AutomationAction, { kind: 'agent' }>,\n  ): Promise<AutomationActionOutcome> {\n    const agentService = this.deps.agentService;\n    if (!agentService?.turnDispatcher?.processDirect) {\n      return { status: 'failed', error: 'Agent service is not available' };\n    }\n    const agentId = normalizeAgentId(\n      action.agentId || this.deps.getDefaultAgentId?.() || DEFAULT_AGENT_ID,\n    );\n    const sessionKey = buildSessionKey({\n      agentId,\n      source: 'automation',\n      accountId: 'default',\n      peerKind: 'dm',\n      peerId: `${automation.id}-${crypto.randomUUID().slice(0, 8)}`,\n    });\n\n    await agentService.sessionConfig?.applyAutomationWorkingDirectory?.(\n      sessionKey,\n      action.workingDirectory,\n    );\n    if (agentService.sessionConfig?.applyAutomationModelOverride) {\n      const ok = await agentService.sessionConfig.applyAutomationModelOverride(sessionKey, action.model);\n      if (!ok && action.model) {\n        log.warn(\n          { automationId: automation.id, sessionKey, model: action.model },\n          'Automation model override invalid; using agent default',\n        );\n      }\n    }\n\n    const response = await agentService.turnDispatcher.processDirect(\n      buildSafetyInstruction(automation, action.instruction),\n      sessionKey,\n    );\n    const model = agentService.getModelForSession?.(sessionKey);\n    return {\n      status: 'succeeded',\n      summary: response.slice(0, 500),\n      sessionKey,\n      model,\n    };\n  }\n\n  private async executeWorkflow(\n    automation: Automation,\n    action: Extract<AutomationAction, { kind: 'workflow' }>,\n    run: AutomationRun,\n  ): Promise<AutomationActionOutcome> {\n    const safetyMode = automation.safety?.mode ?? 'auto_apply';\n    if (safetyMode === 'suggest_only') {\n      return {\n        status: 'succeeded',\n        summary: `Suggest only: workflow ${action.workflowId} was not started. Review the automation and upgrade safety mode to run it automatically.`,\n      };\n    }\n    if (safetyMode === 'ask_before_apply') {\n      return {\n        status: 'succeeded',\n        summary: `Ask before applying: workflow ${action.workflowId} is ready, but was not started automatically. Upgrade to Auto apply when you trust this automation.`,\n      };\n    }\n    const workflowRunService = this.deps.workflowRunService;\n    if (!workflowRunService) {\n      return { status: 'failed', error: 'Workflow service is not available' };\n    }\n    const agentId = normalizeAgentId(\n      action.agentId || this.deps.getDefaultAgentId?.() || DEFAULT_AGENT_ID,\n    );\n    const idempotencyKey = `automation:${automation.id}:${run.id}`;\n    const result = await workflowRunService.startWorkflowRun({\n      agentId,\n      definitionId: action.workflowId,\n      input: action.input,\n      inputEnvelope: action.inputEnvelope,\n      goal: action.goal,\n      concurrency: action.concurrency,\n      maxSubagents: action.maxSubagents,\n      source: { kind: 'automation', automationId: automation.id, runId: run.id },\n      idempotencyKey,\n    });\n    if (result.ok === false) {\n      return { status: 'failed', error: result.message };\n    }\n    return {\n      status: 'succeeded',\n      summary: `Started workflow run ${result.runId}`,\n      sessionKey: result.sessionKey,\n      workflowRunId: result.runId,\n    };\n  }\n}\n\nfunction buildSafetyInstruction(automation: Automation, instruction: string): string {\n  const mode = automation.safety?.mode ?? 'auto_apply';\n  if (mode === 'suggest_only') {\n    return [\n      'Automation safety mode: Suggest only.',\n      'Only analyze the situation and produce a concise recommendation.',\n      'Do not modify files, notes, goals, workflows, external systems, or persistent state.',\n      'If a change seems useful, describe the exact change for the user to review.',\n      '',\n      instruction,\n    ].join('\\n');\n  }\n  if (mode === 'ask_before_apply') {\n    return [\n      'Automation safety mode: Ask before applying.',\n      'Draft the proposed change or action and clearly ask for user confirmation before applying anything.',\n      'Do not perform irreversible or external side effects unless the user has explicitly approved them in this run.',\n      '',\n      instruction,\n    ].join('\\n');\n  }\n  return instruction;\n}\n"],"mappings":"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"}

package/dist/src/automations/service/automation-service.d.ts

@@ -0,0 +1,54 @@
+import type { Automation, AutomationDeps, AutomationEvent, AutomationMetrics, AutomationProductEventRun, AutomationRun, AutomationRunEvent } from '../domain/types.js';
+import { type CreateAutomationInput, type UpdateAutomationInput } from '../domain/validation.js';
+export declare class AutomationAlreadyRunningError extends Error {
+    readonly automationId: string;
+    readonly runningRunId?: string;
+    constructor(automationId: string, runningRunId?: string);
+}
+export declare class AutomationService {
+    private readonly executor;
+    private timer;
+    private stopped;
+    private runningScheduler;
+    private deps;
+    private maxConcurrentRuns;
+    private readonly activeRuns;
+    setDeps(deps: AutomationDeps): void;
+    initialize(options?: {
+        maxConcurrentRuns?: number;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    create(input: CreateAutomationInput): Promise<Automation>;
+    list(): Promise<Automation[]>;
+    get(id: string): Promise<Automation | null>;
+    update(id: string, patch: UpdateAutomationInput): Promise<Automation | null>;
+    remove(id: string): Promise<boolean>;
+    pause(id: string): Promise<Automation | null>;
+    resume(id: string): Promise<Automation | null>;
+    runNow(id: string): Promise<AutomationRun>;
+    rerunFromRun(runId: string): Promise<AutomationRun>;
+    triggerEvent(event: AutomationEvent): Promise<AutomationRun[]>;
+    listRuns(options?: {
+        automationId?: string;
+        limit?: number;
+    }): Promise<AutomationRun[]>;
+    listRunsForProductEvent(options: {
+        eventType: string;
+        source?: string;
+        payloadKey?: string;
+        payloadValue?: string;
+        limit?: number;
+    }): Promise<AutomationProductEventRun[]>;
+    getRun(runId: string): Promise<AutomationRun | null>;
+    listRunEvents(runId: string): Promise<AutomationRunEvent[]>;
+    cancelRun(runId: string): Promise<boolean>;
+    getMetrics(): Promise<AutomationMetrics>;
+    private recomputeNextRuns;
+    private armTimer;
+    private onTimer;
+    private startRun;
+    private executeRun;
+    private appendRunEvent;
+    private finishAutomationRun;
+    private postAfterRunWebhook;
+}

package/dist/src/automations/service/automation-service.js

@@ -0,0 +1,404 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { computeNextAutomationRunAtMs, timerDelayUntil } from "../domain/schedule.js";
+import { AutomationSchema, CreateAutomationSchema, UpdateAutomationSchema } from "../domain/validation.js";
+import { AutomationActionExecutor } from "./action-executor.js";
+import { deleteAutomation, getAutomation, listAutomations, saveAutomation, saveAutomations } from "../storage/automation-repository.js";
+import { appendAutomationRunEvent, getAutomationRun, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, saveAutomationRun } from "../storage/automation-run-repository.js";
+import "../storage/index.js";
+import { randomUUID } from "node:crypto";
+//#region src/automations/service/automation-service.ts
+init_logger();
+const log = createLogger("AutomationService");
+const DEFAULT_MAX_CONCURRENT_RUNS = 5;
+const MISSED_RUN_STAGGER_MS = 5e3;
+var AutomationAlreadyRunningError = class extends Error {
+	constructor(automationId, runningRunId) {
+		super(`Automation is already running: ${automationId}`);
+		this.automationId = automationId;
+		this.runningRunId = runningRunId;
+		this.name = "AutomationAlreadyRunningError";
+	}
+};
+var AutomationService = class {
+	executor = new AutomationActionExecutor();
+	timer = null;
+	stopped = true;
+	runningScheduler = false;
+	deps = {};
+	maxConcurrentRuns = DEFAULT_MAX_CONCURRENT_RUNS;
+	activeRuns = /* @__PURE__ */ new Map();
+	setDeps(deps) {
+		this.deps = {
+			...this.deps,
+			...deps
+		};
+		this.executor.setDeps(this.deps);
+	}
+	async initialize(options) {
+		this.maxConcurrentRuns = Math.max(1, Math.floor(options?.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS));
+		this.stopped = false;
+		await this.recomputeNextRuns({ catchUp: true });
+		this.armTimer();
+		log.info("Automation service initialized");
+	}
+	async stop() {
+		this.stopped = true;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		for (const controller of this.activeRuns.values()) controller.abort();
+		log.info("Automation service stopped");
+	}
+	async create(input) {
+		const parsed = CreateAutomationSchema.parse(input);
+		const now = Date.now();
+		const automation = AutomationSchema.parse({
+			...parsed,
+			id: parsed.id?.trim() || randomUUID().slice(0, 12),
+			enabled: parsed.enabled ?? true,
+			safety: parsed.safety ?? { mode: "auto_apply" },
+			afterRun: parsed.afterRun ?? { kind: "none" },
+			state: parsed.state ?? {},
+			createdAtMs: now,
+			updatedAtMs: now
+		});
+		automation.state.nextRunAtMs = computeNextAutomationRunAtMs(automation, now);
+		saveAutomation(automation);
+		this.armTimer();
+		return automation;
+	}
+	async list() {
+		return listAutomations();
+	}
+	async get(id) {
+		return getAutomation(id);
+	}
+	async update(id, patch) {
+		const parsed = UpdateAutomationSchema.parse(patch);
+		const current = getAutomation(id);
+		if (!current) return null;
+		const now = Date.now();
+		const next = AutomationSchema.parse({
+			...current,
+			...parsed,
+			id: current.id,
+			createdAtMs: current.createdAtMs,
+			updatedAtMs: now,
+			state: {
+				...current.state,
+				...parsed.state ?? {}
+			}
+		});
+		if ("enabled" in parsed || "trigger" in parsed) next.state.nextRunAtMs = computeNextAutomationRunAtMs(next, now);
+		saveAutomation(next);
+		this.armTimer();
+		return next;
+	}
+	async remove(id) {
+		const automation = getAutomation(id);
+		if (automation?.state.runningRunId) this.activeRuns.get(automation.state.runningRunId)?.abort();
+		const removed = deleteAutomation(id);
+		if (removed) this.armTimer();
+		return removed;
+	}
+	async pause(id) {
+		return this.update(id, { enabled: false });
+	}
+	async resume(id) {
+		return this.update(id, { enabled: true });
+	}
+	async runNow(id) {
+		const automation = getAutomation(id);
+		if (!automation) throw new Error(`Automation not found: ${id}`);
+		if (automation.state.runningRunId) throw new AutomationAlreadyRunningError(id, automation.state.runningRunId);
+		return this.startRun(automation, { manual: true });
+	}
+	async rerunFromRun(runId) {
+		const previous = getAutomationRun(runId);
+		if (!previous) throw new Error(`Automation run not found: ${runId}`);
+		const automation = getAutomation(previous.automationId);
+		if (!automation) throw new Error(`Automation not found: ${previous.automationId}`);
+		if (automation.state.runningRunId) throw new AutomationAlreadyRunningError(automation.id, automation.state.runningRunId);
+		const triggerEvent = listAutomationRunEvents(runId).map((event) => readAutomationEventFromRunEvent(event)).find((event) => event !== null);
+		return this.startRun(automation, triggerEvent ? {
+			manual: false,
+			event: triggerEvent
+		} : { manual: true });
+	}
+	async triggerEvent(event) {
+		const normalized = {
+			...event,
+			occurredAtMs: event.occurredAtMs ?? Date.now()
+		};
+		const automations = listAutomations().filter((automation) => automation.enabled && automation.trigger.kind === "event" && !automation.state.runningRunId && matchesAutomationEvent(automation.trigger, normalized));
+		const availableSlots = Math.max(0, this.maxConcurrentRuns - this.activeRuns.size);
+		const started = [];
+		for (const automation of automations.slice(0, availableSlots)) started.push(await this.startRun(automation, {
+			manual: false,
+			event: normalized
+		}));
+		return started;
+	}
+	async listRuns(options) {
+		return listAutomationRuns(options);
+	}
+	async listRunsForProductEvent(options) {
+		return listAutomationRunsForProductEvent(options);
+	}
+	async getRun(runId) {
+		return getAutomationRun(runId);
+	}
+	async listRunEvents(runId) {
+		return listAutomationRunEvents(runId);
+	}
+	async cancelRun(runId) {
+		const controller = this.activeRuns.get(runId);
+		if (!controller) return false;
+		controller.abort();
+		return true;
+	}
+	async getMetrics() {
+		const automations = listAutomations();
+		const enabled = automations.filter((automation) => automation.enabled);
+		const next = enabled.filter((automation) => automation.state.nextRunAtMs != null).toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0))[0];
+		const oneHourAgo = Date.now() - 60 * 6e4;
+		return {
+			totalAutomations: automations.length,
+			enabledAutomations: enabled.length,
+			runningRuns: this.activeRuns.size,
+			failedLastHour: automations.filter((automation) => (automation.state.lastRunStatus === "failed" || automation.state.lastRunStatus === "timeout") && (automation.state.lastRunAtMs ?? 0) >= oneHourAgo).length,
+			nextRun: next?.state.nextRunAtMs ? {
+				automationId: next.id,
+				name: next.name,
+				runAtMs: next.state.nextRunAtMs
+			} : void 0
+		};
+	}
+	async recomputeNextRuns(options) {
+		const now = Date.now();
+		saveAutomations(listAutomations().map((automation, index) => {
+			const next = {
+				...automation,
+				state: { ...automation.state }
+			};
+			if (next.state.runningRunId) {
+				next.state.lastRunStatus = "failed";
+				next.state.lastError = "Interrupted by gateway restart";
+				next.state.consecutiveFailures = (next.state.consecutiveFailures ?? 0) + 1;
+				delete next.state.runningRunId;
+			}
+			const computed = computeNextAutomationRunAtMs(next, now);
+			next.state.nextRunAtMs = options?.catchUp && computed != null && computed <= now ? now + index * MISSED_RUN_STAGGER_MS : computed;
+			return next;
+		}));
+	}
+	armTimer() {
+		if (this.stopped) return;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		const next = listAutomations().filter((automation) => automation.enabled && automation.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?.();
+	}
+	async onTimer() {
+		if (this.stopped) return;
+		if (this.runningScheduler) {
+			this.armTimer();
+			return;
+		}
+		this.runningScheduler = true;
+		try {
+			const now = Date.now();
+			const due = listAutomations().filter((automation) => automation.enabled && automation.trigger.kind === "schedule" && automation.state.nextRunAtMs != null && automation.state.nextRunAtMs <= now && !automation.state.runningRunId).slice(0, this.maxConcurrentRuns);
+			await Promise.all(due.map((automation) => this.startRun(automation, { manual: false })));
+		} finally {
+			this.runningScheduler = false;
+			this.armTimer();
+		}
+	}
+	async startRun(automation, opts) {
+		const now = Date.now();
+		const run = {
+			id: randomUUID(),
+			automationId: automation.id,
+			automationName: automation.name,
+			status: "queued",
+			triggerSnapshot: automation.trigger,
+			actionSnapshot: automation.action,
+			manual: opts.manual,
+			createdAtMs: now
+		};
+		saveAutomationRun(run);
+		this.appendRunEvent(run, "run.queued", opts.event ? `Event ${opts.event.type} queued automation` : opts.manual ? "Manual run queued" : "Scheduled run queued", {
+			trigger: automation.trigger,
+			actionKind: automation.action.kind,
+			safety: automation.safety ?? { mode: "auto_apply" },
+			event: opts.event
+		});
+		const nextAutomation = {
+			...automation,
+			state: {
+				...automation.state,
+				runningRunId: run.id
+			}
+		};
+		saveAutomation(nextAutomation);
+		this.executeRun(nextAutomation, run).catch((err) => {
+			log.error({
+				err,
+				automationId: automation.id,
+				runId: run.id
+			}, `Automation run failed: ${err instanceof Error ? err.message : String(err)}`);
+		});
+		return run;
+	}
+	async executeRun(automation, initialRun) {
+		const controller = new AbortController();
+		this.activeRuns.set(initialRun.id, controller);
+		const startedAtMs = Date.now();
+		let run = {
+			...initialRun,
+			status: "running",
+			startedAtMs
+		};
+		saveAutomationRun(run);
+		this.appendRunEvent(run, "run.started", "Automation run started");
+		let status = "failed";
+		let error;
+		let activePhase = "action";
+		try {
+			this.appendRunEvent(run, "action.started", `Running ${automation.action.kind} action`, {
+				actionKind: automation.action.kind,
+				safety: automation.safety ?? { mode: "auto_apply" }
+			});
+			const outcome = await this.executor.execute(automation, run, controller.signal);
+			status = outcome.status;
+			error = outcome.error;
+			this.appendRunEvent(run, status === "succeeded" ? "action.completed" : "action.failed", status === "succeeded" ? `${automation.action.kind} action completed` : `${automation.action.kind} action ${status}`, {
+				summary: outcome.summary,
+				error: outcome.error,
+				sessionKey: outcome.sessionKey,
+				workflowRunId: outcome.workflowRunId,
+				model: outcome.model
+			});
+			run = {
+				...run,
+				status,
+				summary: outcome.summary,
+				error,
+				sessionKey: outcome.sessionKey,
+				workflowRunId: outcome.workflowRunId,
+				model: outcome.model
+			};
+			if ((automation.safety?.mode ?? "auto_apply") !== "auto_apply" && automation.afterRun?.kind === "webhook") this.appendRunEvent(run, "after_run.completed", "After-run webhook skipped by safety mode", { safety: automation.safety ?? { mode: "auto_apply" } });
+			else if (automation.afterRun?.kind === "webhook") {
+				activePhase = "after_run";
+				this.appendRunEvent(run, "after_run.started", "Calling after-run webhook", { url: automation.afterRun.url });
+				await this.postAfterRunWebhook(automation.afterRun.url, run);
+				this.appendRunEvent(run, "after_run.completed", "After-run webhook completed");
+			}
+		} catch (err) {
+			error = err instanceof Error ? err.message : String(err);
+			status = controller.signal.aborted ? "cancelled" : "failed";
+			this.appendRunEvent(run, activePhase === "after_run" ? "after_run.failed" : "action.failed", `Automation run ${status}`, { error });
+			run = {
+				...run,
+				status,
+				error
+			};
+		} finally {
+			const endedAtMs = Date.now();
+			run = {
+				...run,
+				status,
+				endedAtMs,
+				durationMs: endedAtMs - startedAtMs
+			};
+			saveAutomationRun(run);
+			this.appendRunEvent(run, "run.completed", `Automation run ${status}`, {
+				status,
+				durationMs: run.durationMs,
+				error
+			});
+			this.activeRuns.delete(initialRun.id);
+			this.finishAutomationRun(automation.id, status, error, endedAtMs);
+		}
+	}
+	appendRunEvent(run, type, message, data) {
+		appendAutomationRunEvent({
+			id: randomUUID(),
+			runId: run.id,
+			automationId: run.automationId,
+			type,
+			message,
+			data,
+			createdAtMs: Date.now()
+		});
+	}
+	finishAutomationRun(automationId, status, error, finishedAtMs) {
+		const current = getAutomation(automationId);
+		if (!current) return;
+		const consecutiveFailures = status === "failed" || status === "timeout" ? (current.state.consecutiveFailures ?? 0) + 1 : 0;
+		const disableAfter = current.reliability?.disableAfterConsecutiveFailures;
+		const shouldDisable = disableAfter != null && consecutiveFailures >= disableAfter;
+		const next = {
+			...current,
+			enabled: shouldDisable ? false : current.enabled,
+			state: {
+				...current.state,
+				lastRunAtMs: finishedAtMs,
+				lastRunStatus: status,
+				lastError: error,
+				consecutiveFailures
+			},
+			updatedAtMs: shouldDisable ? finishedAtMs : current.updatedAtMs
+		};
+		delete next.state.runningRunId;
+		next.state.nextRunAtMs = computeNextAutomationRunAtMs(next, finishedAtMs);
+		saveAutomation(next);
+		this.armTimer();
+	}
+	async postAfterRunWebhook(url, run) {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ run })
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`Automation webhook failed: HTTP ${response.status}${text ? ` ${text.slice(0, 200)}` : ""}`);
+		}
+	}
+};
+function matchesAutomationEvent(trigger, event) {
+	if (trigger.eventType !== event.type) return false;
+	if (trigger.source && trigger.source !== event.source) return false;
+	const payloadMatch = trigger.payloadMatch;
+	if (!payloadMatch) return true;
+	const payload = event.payload ?? {};
+	return Object.entries(payloadMatch).every(([key, expected]) => Object.is(payload[key], expected));
+}
+function readAutomationEventFromRunEvent(event) {
+	if (!event.data || typeof event.data !== "object" || Array.isArray(event.data)) return null;
+	const raw = event.data.event;
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const candidate = raw;
+	if (typeof candidate.type !== "string" || !candidate.type.trim()) return null;
+	return {
+		type: candidate.type,
+		source: typeof candidate.source === "string" ? candidate.source : void 0,
+		payload: candidate.payload && typeof candidate.payload === "object" && !Array.isArray(candidate.payload) ? candidate.payload : void 0,
+		occurredAtMs: typeof candidate.occurredAtMs === "number" ? candidate.occurredAtMs : void 0
+	};
+}
+//#endregion
+export { AutomationAlreadyRunningError, AutomationService };
+
+//# sourceMappingURL=automation-service.js.map