@xopcai/xopc 0.0.332 → 0.0.334

package/dist/src/automations/events/event-dispatcher.js

@@ -0,0 +1,140 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getAutomation } from "../storage/automation-repository.js";
+import "../storage/index.js";
+import { claimAutomationEventDeliveries, claimAutomationEventsForProjection, completeAutomationEventDelivery, completeAutomationEventProjection, deferAutomationEventDelivery, expireAutomationEventProjectionLeases, failAutomationEventProjection, markAutomationEventDeliveryQueued, reconcileAutomationEventDeliveries, releaseAutomationEventDelivery, releaseAutomationEventProjection, skipAutomationEventDelivery } from "./event-repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/automations/events/event-dispatcher.ts
+init_transaction();
+init_logger();
+const log = createLogger("AutomationEventDispatcher");
+const DELIVERY_SCAN_BUDGET = 500;
+var AutomationEventDispatcher = class {
+	timer;
+	active;
+	stopping = false;
+	owner = `automation-event:${process.pid}:${randomUUID()}`;
+	abortController = new AbortController();
+	constructor(automationService, options = {}) {
+		this.automationService = automationService;
+		this.options = options;
+	}
+	start() {
+		if (this.timer) return;
+		this.stopping = false;
+		reconcileAutomationEventDeliveries();
+		this.dispatch();
+		this.timer = setInterval(() => void this.dispatch(), this.options.intervalMs ?? 1e3);
+		this.timer.unref?.();
+	}
+	async stop() {
+		this.stopping = true;
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+		this.abortController.abort(/* @__PURE__ */ new Error("Automation event dispatcher stopped"));
+		await this.active?.catch(() => void 0);
+	}
+	dispatch() {
+		if (this.stopping) return Promise.resolve(0);
+		this.active ??= this.runDispatch().finally(() => {
+			this.active = void 0;
+		});
+		return this.active;
+	}
+	runCompleted(run) {
+		completeAutomationEventDelivery(run.id, run.status);
+		if (!this.stopping) this.dispatch();
+	}
+	async runDispatch() {
+		await this.projectEvents();
+		const availableSlots = this.automationService.availableRunSlots();
+		if (availableSlots <= 0 || this.stopping) return 0;
+		let queued = 0;
+		const deliveries = claimAutomationEventDeliveries(this.owner, DELIVERY_SCAN_BUDGET);
+		for (const [index, delivery] of deliveries.entries()) {
+			if (queued >= availableSlots || this.stopping) {
+				for (const remaining of deliveries.slice(index)) releaseAutomationEventDelivery(remaining.event.id, remaining.automationId, this.owner, 0);
+				break;
+			}
+			const automation = getAutomation(delivery.automationId);
+			if (!automation || !automation.enabled) {
+				skipAutomationEventDelivery(delivery.event.id, delivery.automationId, "Automation is unavailable", this.owner);
+				continue;
+			}
+			if (automation.state.runningRunId) {
+				releaseAutomationEventDelivery(delivery.event.id, automation.id, this.owner);
+				continue;
+			}
+			try {
+				const run = runSqliteWriteTransaction(() => {
+					const next = this.automationService.queueRunAtomically(automation.id, {
+						manual: false,
+						event: delivery.event
+					});
+					markAutomationEventDeliveryQueued(delivery.event.id, automation.id, next.id, this.owner);
+					return next;
+				});
+				this.automationService.dispatchQueuedRun(run.id);
+				queued += 1;
+			} catch (error) {
+				if (error instanceof Error && error.name === "AutomationAlreadyRunningError") {
+					releaseAutomationEventDelivery(delivery.event.id, automation.id, this.owner);
+					continue;
+				}
+				const status = deferAutomationEventDelivery(delivery.event.id, automation.id, this.owner, error);
+				if (status === "dead_letter") this.options.onDeadLetter?.({
+					phase: "event_delivery",
+					eventId: delivery.event.id,
+					automationId: automation.id,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				log.warn({
+					err: error,
+					eventId: delivery.event.id,
+					automationId: automation.id,
+					status
+				}, status === "dead_letter" ? "Automation event delivery moved to dead letter" : "Automation event delivery will retry");
+			}
+		}
+		return queued;
+	}
+	async projectEvents() {
+		for (const expired of expireAutomationEventProjectionLeases()) {
+			this.options.onDeadLetter?.({
+				phase: "event_projection",
+				...expired
+			});
+			log.warn(expired, "Automation event projection moved to dead letter after lease expiry");
+		}
+		for (const event of claimAutomationEventsForProjection(this.owner)) {
+			if (this.stopping) {
+				releaseAutomationEventProjection(event.id, this.owner);
+				continue;
+			}
+			try {
+				await this.options.onEvent?.(event, this.abortController.signal);
+				completeAutomationEventProjection(event.id, this.owner);
+			} catch (error) {
+				if (this.stopping || this.abortController.signal.aborted) {
+					releaseAutomationEventProjection(event.id, this.owner);
+					continue;
+				}
+				const status = failAutomationEventProjection(event.id, this.owner, error);
+				if (status === "dead_letter") this.options.onDeadLetter?.({
+					phase: "event_projection",
+					eventId: event.id,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				log.warn({
+					err: error,
+					eventId: event.id,
+					eventType: event.type,
+					status
+				}, status === "dead_letter" ? "Automation event projection moved to dead letter" : "Automation event projection will retry");
+			}
+		}
+	}
+};
+//#endregion
+export { AutomationEventDispatcher };

package/dist/src/automations/events/event-repository.d.ts

@@ -0,0 +1,59 @@
+import type { AutomationEvent, AutomationEventDeliveryStatus, AutomationEventEnvelope, AutomationEventProjectionStatus, AutomationEventRecord, AutomationRunStatus } from '../domain/types.js';
+export interface ClaimedAutomationEventDelivery {
+    event: AutomationEventEnvelope;
+    automationId: string;
+    attempts: number;
+    owner: string;
+}
+export interface AutomationEventIngestResult {
+    event: AutomationEventEnvelope;
+    created: boolean;
+    deliveryCount: number;
+}
+export interface AutomationEventIngestOptions {
+    targetAutomationIds?: string[];
+}
+export interface AutomationEventPublisher {
+    publish(input: AutomationEvent, options?: AutomationEventIngestOptions): AutomationEventIngestResult;
+}
+export declare function ingestAutomationEvent(input: AutomationEvent, options?: AutomationEventIngestOptions): AutomationEventIngestResult;
+export declare const automationEventPublisher: AutomationEventPublisher;
+export declare function listAutomationEvents(input?: {
+    type?: string;
+    source?: string;
+    subjectKind?: string;
+    subjectId?: string;
+    limit?: number;
+    newestFirst?: boolean;
+}): AutomationEventEnvelope[];
+export declare function listAutomationEventRecords(input?: {
+    type?: string;
+    source?: string;
+    limit?: number;
+}): AutomationEventRecord[];
+export declare function claimAutomationEventsForProjection(owner: string, limit?: number, leaseMs?: number): AutomationEventEnvelope[];
+export declare function expireAutomationEventProjectionLeases(): Array<{
+    eventId: string;
+    error: string;
+}>;
+export declare function completeAutomationEventProjection(eventId: string, owner: string): void;
+export declare function releaseAutomationEventProjection(eventId: string, owner: string): void;
+export declare function failAutomationEventProjection(eventId: string, owner: string, error: unknown): AutomationEventProjectionStatus;
+export declare function claimAutomationEventDeliveries(owner: string, limit: number, leaseMs?: number): ClaimedAutomationEventDelivery[];
+export declare function releaseAutomationEventDelivery(eventId: string, automationId: string, owner: string, delayMs?: number): void;
+export declare function getAutomationEventDeliveryRunId(eventId: string, automationId: string): string | null;
+export declare function getAutomationEventForRun(runId: string): AutomationEventEnvelope | null;
+export declare function markAutomationEventDeliveryQueued(eventId: string, automationId: string, runId: string, owner?: string): void;
+export declare function deferAutomationEventDelivery(eventId: string, automationId: string, owner: string, error: unknown): AutomationEventDeliveryStatus;
+export declare function skipAutomationEventDelivery(eventId: string, automationId: string, reason: string, owner?: string): void;
+export declare function completeAutomationEventDelivery(runId: string, runStatus: AutomationRunStatus): void;
+export declare function reconcileAutomationEventDeliveries(): number;
+export declare function replayAutomationEvent(eventId: string): boolean;
+export declare function getAutomationEventQueueMetrics(): {
+    pending: number;
+    oldestPendingAgeMs: number;
+    projectionDeadLetters: number;
+    pendingDeliveries: number;
+    deliveryDeadLetters: number;
+    activeLeases: number;
+};

package/dist/src/automations/events/event-repository.js

@@ -0,0 +1,361 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getAutomation, listAutomations } from "../storage/automation-repository.js";
+import "../storage/index.js";
+import { validateCatalogedBusinessEvent } from "./event-catalog.js";
+import { randomUUID } from "node:crypto";
+//#region src/automations/events/event-repository.ts
+init_transaction();
+const MAX_PAYLOAD_BYTES = 256 * 1024;
+const MAX_ATTEMPTS = 5;
+const RETRY_DELAYS_MS = [
+	1e3,
+	5e3,
+	3e4,
+	2 * 6e4,
+	10 * 6e4
+];
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	const record = value;
+	return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function sameEventIdentity(existing, candidate, input) {
+	return existing.id === candidate.id && existing.type === candidate.type && existing.source === candidate.source && existing.schemaVersion === candidate.schemaVersion && existing.subject?.kind === candidate.subject?.kind && existing.subject?.id === candidate.subject?.id && (input.occurredAtMs === void 0 || existing.occurredAtMs === candidate.occurredAtMs) && (input.correlationId === void 0 || existing.correlationId === candidate.correlationId) && (input.causationId === void 0 || existing.causationId === candidate.causationId) && (input.rootEventId === void 0 || existing.rootEventId === candidate.rootEventId) && (input.chainDepth === void 0 || existing.chainDepth === candidate.chainDepth) && existing.dedupeKey === candidate.dedupeKey && existing.trust === candidate.trust && stableStringify(existing.payload) === stableStringify(candidate.payload);
+}
+function matchesEvent(trigger, event) {
+	if (trigger.eventType !== event.type) return false;
+	if (trigger.source && trigger.source !== event.source) return false;
+	if (!trigger.payloadMatch) return true;
+	return Object.entries(trigger.payloadMatch).every(([key, expected]) => Object.is(event.payload[key], expected));
+}
+function rowToEvent(row) {
+	return {
+		id: row.event_id,
+		type: row.event_type,
+		schemaVersion: row.schema_version,
+		source: row.source,
+		...row.subject_kind && row.subject_id ? { subject: {
+			kind: row.subject_kind,
+			id: row.subject_id
+		} } : {},
+		occurredAtMs: row.occurred_at_ms,
+		ingestedAtMs: row.ingested_at_ms,
+		correlationId: row.correlation_id,
+		...row.causation_id ? { causationId: row.causation_id } : {},
+		rootEventId: row.root_event_id,
+		chainDepth: row.chain_depth,
+		...row.dedupe_key ? { dedupeKey: row.dedupe_key } : {},
+		trust: row.trust,
+		payload: JSON.parse(row.payload_json)
+	};
+}
+function readEventByIdentity(input) {
+	const db = getSqliteDatabase();
+	const row = input.dedupeKey ? db.prepare("SELECT * FROM automation_events WHERE event_id = ? OR (source = ? AND dedupe_key = ?) LIMIT 1").get(input.id, input.source, input.dedupeKey) : db.prepare("SELECT * FROM automation_events WHERE event_id = ?").get(input.id);
+	return row ? rowToEvent(row) : null;
+}
+function ingestAutomationEvent(input, options = {}) {
+	if (!input.type.trim()) throw new Error("Automation event type is required");
+	const now = Date.now();
+	const id = input.id?.trim() || randomUUID();
+	const source = input.source?.trim() || "xopc";
+	const event = {
+		...input,
+		id,
+		type: input.type.trim(),
+		source,
+		schemaVersion: input.schemaVersion ?? 1,
+		occurredAtMs: input.occurredAtMs ?? now,
+		ingestedAtMs: now,
+		correlationId: input.correlationId?.trim() || id,
+		rootEventId: input.rootEventId?.trim() || id,
+		chainDepth: input.chainDepth ?? 0,
+		trust: input.trust ?? (source.startsWith("composio") ? "connector" : "system"),
+		payload: input.payload ?? {}
+	};
+	if (!Number.isInteger(event.schemaVersion) || event.schemaVersion < 1) throw new Error("Invalid event schema version");
+	if (!Number.isInteger(event.chainDepth) || event.chainDepth < 0 || event.chainDepth > 32) throw new Error("Invalid event chain depth");
+	const payloadJson = JSON.stringify(event.payload);
+	if (Buffer.byteLength(payloadJson) > MAX_PAYLOAD_BYTES) throw new Error(`Automation event payload exceeds ${MAX_PAYLOAD_BYTES} bytes`);
+	validateCatalogedBusinessEvent(event);
+	return runSqliteWriteTransaction((db) => {
+		if (!(db.prepare(`INSERT OR IGNORE INTO automation_events (
+      event_id, event_type, schema_version, source, subject_kind, subject_id,
+      occurred_at_ms, ingested_at_ms, correlation_id, causation_id, root_event_id,
+      chain_depth, dedupe_key, trust, payload_json, projection_next_attempt_at_ms
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(event.id, event.type, event.schemaVersion, event.source, event.subject?.kind ?? null, event.subject?.id ?? null, event.occurredAtMs, event.ingestedAtMs, event.correlationId, event.causationId ?? null, event.rootEventId, event.chainDepth, event.dedupeKey ?? null, event.trust, payloadJson, now).changes > 0)) {
+			const existing = readEventByIdentity({
+				id: event.id,
+				source: event.source,
+				dedupeKey: event.dedupeKey
+			});
+			if (!existing) throw new Error("Automation event identity conflict");
+			if (!sameEventIdentity(existing, event, input)) throw new Error("Automation event identity reused with different content");
+			return {
+				event: existing,
+				created: false,
+				deliveryCount: Number(db.prepare("SELECT count(*) AS count FROM automation_event_deliveries WHERE event_id = ?").get(existing.id)?.count ?? 0)
+			};
+		}
+		const automations = options.targetAutomationIds ? options.targetAutomationIds.map(getAutomation).filter((automation) => Boolean(automation?.enabled)) : listAutomations().filter((automation) => automation.enabled && automation.trigger.kind === "event" && matchesEvent(automation.trigger, event));
+		const insertDelivery = db.prepare(`INSERT INTO automation_event_deliveries (
+      event_id, automation_id, status, attempts, next_attempt_at_ms, created_at_ms, updated_at_ms
+    ) VALUES (?, ?, 'pending', 0, ?, ?, ?)`);
+		for (const automation of automations) insertDelivery.run(event.id, automation.id, now, now, now);
+		return {
+			event,
+			created: true,
+			deliveryCount: automations.length
+		};
+	});
+}
+const automationEventPublisher = { publish: ingestAutomationEvent };
+function listAutomationEvents(input = {}) {
+	const clauses = [];
+	const params = [];
+	if (input.type) {
+		clauses.push("event_type = ?");
+		params.push(input.type);
+	}
+	if (input.source) {
+		clauses.push("source = ?");
+		params.push(input.source);
+	}
+	if (input.subjectKind) {
+		clauses.push("subject_kind = ?");
+		params.push(input.subjectKind);
+	}
+	if (input.subjectId) {
+		clauses.push("subject_id = ?");
+		params.push(input.subjectId);
+	}
+	params.push(Math.max(1, Math.min(500, Math.floor(input.limit ?? 100))));
+	return getSqliteDatabase().prepare(`SELECT * FROM automation_events
+    ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""}
+    ORDER BY ingested_at_ms ${input.newestFirst ? "DESC" : "ASC"}, rowid ${input.newestFirst ? "DESC" : "ASC"} LIMIT ?`).all(...params).map(rowToEvent);
+}
+function listAutomationEventRecords(input = {}) {
+	const events = listAutomationEvents({
+		...input,
+		newestFirst: true
+	});
+	const db = getSqliteDatabase();
+	const readEventState = db.prepare(`SELECT projection_status, projection_attempts, projection_error
+    FROM automation_events WHERE event_id = ?`);
+	const readDeliveries = db.prepare(`SELECT automation_id, status, run_id, attempts, last_error
+    FROM automation_event_deliveries WHERE event_id = ? ORDER BY automation_id`);
+	return events.map((event) => {
+		const state = readEventState.get(event.id);
+		const deliveries = readDeliveries.all(event.id);
+		return {
+			event,
+			projectionStatus: state.projection_status,
+			projectionAttempts: state.projection_attempts,
+			projectionError: state.projection_error ?? void 0,
+			deliveries: deliveries.map((delivery) => ({
+				automationId: delivery.automation_id,
+				status: delivery.status,
+				runId: delivery.run_id ?? void 0,
+				attempts: delivery.attempts,
+				lastError: delivery.last_error ?? void 0
+			}))
+		};
+	});
+}
+function claimAutomationEventsForProjection(owner, limit = 100, leaseMs = 3e4) {
+	const now = Date.now();
+	return runSqliteWriteTransaction((db) => {
+		const candidates = db.prepare(`SELECT * FROM automation_events WHERE
+      (projection_status IN ('pending', 'retrying') AND projection_next_attempt_at_ms <= ?)
+      OR (projection_status = 'projecting' AND projection_lease_until_ms <= ?)
+      ORDER BY ingested_at_ms, event_id LIMIT ?`).all(now, now, Math.max(1, Math.min(500, limit)));
+		const claimed = [];
+		const statement = db.prepare(`UPDATE automation_events
+      SET projection_status = 'projecting', projection_attempts = projection_attempts + 1,
+          projection_owner = ?, projection_lease_until_ms = ?
+      WHERE event_id = ? AND (
+        (projection_status IN ('pending', 'retrying') AND projection_next_attempt_at_ms <= ?)
+        OR (projection_status = 'projecting' AND projection_lease_until_ms <= ?)
+      )`);
+		for (const candidate of candidates) if (statement.run(owner, now + leaseMs, candidate.event_id, now, now).changes === 1) claimed.push(rowToEvent(candidate));
+		return claimed;
+	});
+}
+function expireAutomationEventProjectionLeases() {
+	const now = Date.now();
+	return runSqliteWriteTransaction((db) => {
+		const candidates = db.prepare(`SELECT event_id FROM automation_events
+      WHERE projection_status = 'projecting' AND projection_lease_until_ms <= ? AND projection_attempts >= ?`).all(now, MAX_ATTEMPTS);
+		const expire = db.prepare(`UPDATE automation_events
+      SET projection_status = 'dead_letter', projection_error = 'Projection lease expired after maximum attempts',
+          projection_owner = NULL, projection_lease_until_ms = NULL
+      WHERE event_id = ? AND projection_status = 'projecting'
+        AND projection_lease_until_ms <= ? AND projection_attempts >= ?`);
+		const expired = [];
+		for (const candidate of candidates) if (expire.run(candidate.event_id, now, MAX_ATTEMPTS).changes === 1) expired.push({
+			eventId: candidate.event_id,
+			error: "Projection lease expired after maximum attempts"
+		});
+		return expired;
+	});
+}
+function completeAutomationEventProjection(eventId, owner) {
+	getSqliteDatabase().prepare(`UPDATE automation_events
+    SET projection_status = 'projected', projected_at_ms = ?, projection_error = NULL,
+        projection_owner = NULL, projection_lease_until_ms = NULL
+    WHERE event_id = ? AND projection_status = 'projecting' AND projection_owner = ?`).run(Date.now(), eventId, owner);
+}
+function releaseAutomationEventProjection(eventId, owner) {
+	getSqliteDatabase().prepare(`UPDATE automation_events
+    SET projection_status = 'retrying', projection_attempts = MAX(0, projection_attempts - 1),
+        projection_next_attempt_at_ms = ?, projection_owner = NULL, projection_lease_until_ms = NULL
+    WHERE event_id = ? AND projection_status = 'projecting' AND projection_owner = ?`).run(Date.now(), eventId, owner);
+}
+function failAutomationEventProjection(eventId, owner, error) {
+	const db = getSqliteDatabase();
+	const row = db.prepare("SELECT projection_attempts FROM automation_events WHERE event_id = ? AND projection_owner = ?").get(eventId, owner);
+	if (!row) return "retrying";
+	const status = row.projection_attempts >= MAX_ATTEMPTS ? "dead_letter" : "retrying";
+	const delay = RETRY_DELAYS_MS[Math.min(row.projection_attempts - 1, RETRY_DELAYS_MS.length - 1)];
+	db.prepare(`UPDATE automation_events SET projection_status = ?, projection_next_attempt_at_ms = ?,
+    projection_error = ?, projection_owner = NULL, projection_lease_until_ms = NULL
+    WHERE event_id = ? AND projection_status = 'projecting' AND projection_owner = ?`).run(status, Date.now() + delay, error instanceof Error ? error.message : String(error), eventId, owner);
+	return status;
+}
+function claimAutomationEventDeliveries(owner, limit, leaseMs = 3e4) {
+	if (limit <= 0) return [];
+	const now = Date.now();
+	return runSqliteWriteTransaction((db) => {
+		const rows = db.prepare(`SELECT e.*, d.automation_id, d.attempts
+      FROM automation_event_deliveries d
+      JOIN automation_events e ON e.event_id = d.event_id
+      LEFT JOIN automations a ON a.automation_id = d.automation_id
+      WHERE d.status IN ('pending', 'retrying') AND d.next_attempt_at_ms <= ?
+        AND (d.lease_until_ms IS NULL OR d.lease_until_ms <= ?)
+      ORDER BY CASE
+        WHEN a.enabled = 1 AND json_extract(a.state_json, '$.runningRunId') IS NULL THEN 0
+        WHEN a.automation_id IS NULL OR a.enabled = 0 THEN 1
+        ELSE 2
+      END, d.created_at_ms, d.event_id, d.automation_id LIMIT ?`).all(now, now, Math.min(500, Math.floor(limit)));
+		const claimed = [];
+		const statement = db.prepare(`UPDATE automation_event_deliveries SET lease_owner = ?, lease_until_ms = ?, updated_at_ms = ?
+      WHERE event_id = ? AND automation_id = ? AND status IN ('pending', 'retrying')
+        AND (lease_until_ms IS NULL OR lease_until_ms <= ?)`);
+		for (const row of rows) if (statement.run(owner, now + leaseMs, now, row.event_id, row.automation_id, now).changes === 1) claimed.push({
+			event: rowToEvent(row),
+			automationId: row.automation_id,
+			attempts: row.attempts,
+			owner
+		});
+		return claimed;
+	});
+}
+function releaseAutomationEventDelivery(eventId, automationId, owner, delayMs = 1e3) {
+	const now = Date.now();
+	getSqliteDatabase().prepare(`UPDATE automation_event_deliveries SET next_attempt_at_ms = ?,
+    lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+    WHERE event_id = ? AND automation_id = ? AND lease_owner = ? AND status IN ('pending', 'retrying')`).run(now + delayMs, now, eventId, automationId, owner);
+}
+function getAutomationEventDeliveryRunId(eventId, automationId) {
+	return getSqliteDatabase().prepare(`SELECT run_id FROM automation_event_deliveries
+    WHERE event_id = ? AND automation_id = ?`).get(eventId, automationId)?.run_id ?? null;
+}
+function getAutomationEventForRun(runId) {
+	const row = getSqliteDatabase().prepare(`SELECT e.* FROM automation_event_deliveries d
+    JOIN automation_events e ON e.event_id = d.event_id WHERE d.run_id = ? LIMIT 1`).get(runId);
+	return row ? rowToEvent(row) : null;
+}
+function markAutomationEventDeliveryQueued(eventId, automationId, runId, owner) {
+	const ownerClause = owner ? "AND lease_owner = ?" : "";
+	const params = owner ? [
+		runId,
+		Date.now(),
+		eventId,
+		automationId,
+		owner
+	] : [
+		runId,
+		Date.now(),
+		eventId,
+		automationId
+	];
+	if (getSqliteDatabase().prepare(`UPDATE automation_event_deliveries
+    SET status = 'queued', run_id = ?, attempts = attempts + 1, updated_at_ms = ?, last_error = NULL,
+        lease_owner = NULL, lease_until_ms = NULL
+    WHERE event_id = ? AND automation_id = ? AND status IN ('pending', 'retrying') ${ownerClause}`).run(...params).changes !== 1) throw new Error("Automation event delivery was already claimed");
+}
+function deferAutomationEventDelivery(eventId, automationId, owner, error) {
+	const db = getSqliteDatabase();
+	const row = db.prepare(`SELECT attempts FROM automation_event_deliveries
+    WHERE event_id = ? AND automation_id = ? AND lease_owner = ?`).get(eventId, automationId, owner);
+	if (!row) return "retrying";
+	const attempts = row.attempts + 1;
+	const status = attempts >= MAX_ATTEMPTS ? "dead_letter" : "retrying";
+	const delay = RETRY_DELAYS_MS[Math.min(attempts - 1, RETRY_DELAYS_MS.length - 1)];
+	db.prepare(`UPDATE automation_event_deliveries SET status = ?, attempts = ?, next_attempt_at_ms = ?,
+    last_error = ?, lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+    WHERE event_id = ? AND automation_id = ? AND lease_owner = ?`).run(status, attempts, Date.now() + delay, error instanceof Error ? error.message : String(error), Date.now(), eventId, automationId, owner);
+	return status;
+}
+function skipAutomationEventDelivery(eventId, automationId, reason, owner) {
+	const ownerClause = owner ? "AND lease_owner = ?" : "";
+	getSqliteDatabase().prepare(`UPDATE automation_event_deliveries SET status = 'skipped',
+    last_error = ?, lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+    WHERE event_id = ? AND automation_id = ? AND status IN ('pending', 'retrying') ${ownerClause}`).run(reason, Date.now(), eventId, automationId, ...owner ? [owner] : []);
+}
+function completeAutomationEventDelivery(runId, runStatus) {
+	const status = runStatus === "succeeded" ? "completed" : runStatus === "cancelled" ? "cancelled" : "failed";
+	getSqliteDatabase().prepare(`UPDATE automation_event_deliveries SET status = ?, updated_at_ms = ?
+    WHERE run_id = ? AND status = 'queued'`).run(status, Date.now(), runId);
+}
+function reconcileAutomationEventDeliveries() {
+	const result = getSqliteDatabase().prepare(`UPDATE automation_event_deliveries
+    SET status = CASE
+      WHEN (SELECT status FROM automation_runs WHERE run_id = automation_event_deliveries.run_id) = 'succeeded' THEN 'completed'
+      WHEN (SELECT status FROM automation_runs WHERE run_id = automation_event_deliveries.run_id) = 'cancelled' THEN 'cancelled'
+      ELSE 'failed'
+    END, updated_at_ms = ?
+    WHERE status = 'queued' AND run_id IN (
+      SELECT run_id FROM automation_runs WHERE status IN ('succeeded', 'failed', 'cancelled', 'timeout')
+    )`).run(Date.now());
+	return Number(result.changes);
+}
+function replayAutomationEvent(eventId) {
+	return runSqliteWriteTransaction((db) => {
+		const now = Date.now();
+		const projection = db.prepare(`UPDATE automation_events SET projection_status = 'retrying',
+      projection_attempts = 0, projection_next_attempt_at_ms = ?, projection_error = NULL,
+      projection_owner = NULL, projection_lease_until_ms = NULL
+      WHERE event_id = ? AND projection_status = 'dead_letter'`).run(now, eventId).changes;
+		const deliveries = db.prepare(`UPDATE automation_event_deliveries SET status = 'retrying', attempts = 0,
+      next_attempt_at_ms = ?, last_error = NULL, lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+      WHERE event_id = ? AND status = 'dead_letter'`).run(now, now, eventId).changes;
+		return Number(projection) + Number(deliveries) > 0;
+	});
+}
+function getAutomationEventQueueMetrics() {
+	const now = Date.now();
+	const event = getSqliteDatabase().prepare(`SELECT
+    SUM(CASE WHEN projection_status IN ('pending', 'projecting', 'retrying') THEN 1 ELSE 0 END) AS pending,
+    MIN(CASE WHEN projection_status IN ('pending', 'projecting', 'retrying') THEN ingested_at_ms END) AS oldest,
+    SUM(CASE WHEN projection_status = 'dead_letter' THEN 1 ELSE 0 END) AS dead_letters
+    FROM automation_events`).get();
+	const delivery = getSqliteDatabase().prepare(`SELECT
+    SUM(CASE WHEN status IN ('pending', 'retrying', 'queued') THEN 1 ELSE 0 END) AS pending,
+    SUM(CASE WHEN status = 'dead_letter' THEN 1 ELSE 0 END) AS dead_letters,
+    SUM(CASE WHEN lease_until_ms > ? THEN 1 ELSE 0 END) AS active_leases
+    FROM automation_event_deliveries`).get(now);
+	const projectionLeases = getSqliteDatabase().prepare(`SELECT COUNT(*) AS count FROM automation_events
+    WHERE projection_status = 'projecting' AND projection_lease_until_ms > ?`).get(now);
+	return {
+		pending: event.pending ?? 0,
+		oldestPendingAgeMs: event.oldest == null ? 0 : Math.max(0, now - event.oldest),
+		projectionDeadLetters: event.dead_letters ?? 0,
+		pendingDeliveries: delivery.pending ?? 0,
+		deliveryDeadLetters: delivery.dead_letters ?? 0,
+		activeLeases: (delivery.active_leases ?? 0) + projectionLeases.count
+	};
+}
+//#endregion
+export { automationEventPublisher, claimAutomationEventDeliveries, claimAutomationEventsForProjection, completeAutomationEventDelivery, completeAutomationEventProjection, deferAutomationEventDelivery, expireAutomationEventProjectionLeases, failAutomationEventProjection, getAutomationEventDeliveryRunId, getAutomationEventForRun, getAutomationEventQueueMetrics, ingestAutomationEvent, listAutomationEventRecords, listAutomationEvents, markAutomationEventDeliveryQueued, reconcileAutomationEventDeliveries, releaseAutomationEventDelivery, releaseAutomationEventProjection, replayAutomationEvent, skipAutomationEventDelivery };

package/dist/src/automations/events/index.d.ts

@@ -0,0 +1,3 @@
+export * from './event-dispatcher.js';
+export * from './event-repository.js';
+export * from './event-catalog.js';

package/dist/src/automations/events/index.js

@@ -0,0 +1,4 @@
+import { listBusinessEventDefinitions, registerBusinessEvent, validateCatalogedBusinessEvent } from "./event-catalog.js";
+import { automationEventPublisher, claimAutomationEventDeliveries, claimAutomationEventsForProjection, completeAutomationEventDelivery, completeAutomationEventProjection, deferAutomationEventDelivery, expireAutomationEventProjectionLeases, failAutomationEventProjection, getAutomationEventDeliveryRunId, getAutomationEventForRun, getAutomationEventQueueMetrics, ingestAutomationEvent, listAutomationEventRecords, listAutomationEvents, markAutomationEventDeliveryQueued, reconcileAutomationEventDeliveries, releaseAutomationEventDelivery, releaseAutomationEventProjection, replayAutomationEvent, skipAutomationEventDelivery } from "./event-repository.js";
+import { AutomationEventDispatcher } from "./event-dispatcher.js";
+export { AutomationEventDispatcher, automationEventPublisher, claimAutomationEventDeliveries, claimAutomationEventsForProjection, completeAutomationEventDelivery, completeAutomationEventProjection, deferAutomationEventDelivery, expireAutomationEventProjectionLeases, failAutomationEventProjection, getAutomationEventDeliveryRunId, getAutomationEventForRun, getAutomationEventQueueMetrics, ingestAutomationEvent, listAutomationEventRecords, listAutomationEvents, listBusinessEventDefinitions, markAutomationEventDeliveryQueued, reconcileAutomationEventDeliveries, registerBusinessEvent, releaseAutomationEventDelivery, releaseAutomationEventProjection, replayAutomationEvent, skipAutomationEventDelivery, validateCatalogedBusinessEvent };

package/dist/src/automations/index.d.ts

@@ -1,3 +1,5 @@
 export * from './domain/index.js';
 export * from './service/index.js';
-export * from './product-events.js';
+export * from './events/index.js';
+export * from './webhook-secrets.js';
+export * from './delivery/index.js';

package/dist/src/automations/index.js

@@ -1,9 +1,15 @@
-import { onAutomationProductEvent, publishAutomationProductEvent } from "./product-events.js";
-import { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./domain/validation.js";
+import { AutomationActionSchema, AutomationDeliveryPolicySchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./domain/validation.js";
+import { listBusinessEventDefinitions, registerBusinessEvent, validateCatalogedBusinessEvent } from "./events/event-catalog.js";
+import { automationEventPublisher, claimAutomationEventDeliveries, claimAutomationEventsForProjection, completeAutomationEventDelivery, completeAutomationEventProjection, deferAutomationEventDelivery, expireAutomationEventProjectionLeases, failAutomationEventProjection, getAutomationEventDeliveryRunId, getAutomationEventForRun, getAutomationEventQueueMetrics, ingestAutomationEvent, listAutomationEventRecords, listAutomationEvents, markAutomationEventDeliveryQueued, reconcileAutomationEventDeliveries, releaseAutomationEventDelivery, releaseAutomationEventProjection, replayAutomationEvent, skipAutomationEventDelivery } from "./events/event-repository.js";
 import { computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil } from "./domain/schedule.js";
 import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds } from "./domain/defaults.js";
 import { AutomationActionExecutor } from "./service/action-executor.js";
+import { AutomationEventDispatcher } from "./events/event-dispatcher.js";
+import "./events/index.js";
+import { resolveAutomationWebhookSecret } from "./webhook-secrets.js";
+import { AutomationDeliveryRouter, getAutomationResultDeliveryMetrics, listAutomationResultDeliveries, retryAutomationResultDelivery } from "./delivery/delivery-router.js";
+import "./delivery/index.js";
 import { AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationService } from "./service/automation-service.js";
 import "./domain/index.js";
 import "./service/index.js";
-export { AutomationActionExecutor, AutomationActionSchema, AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, onAutomationProductEvent, publishAutomationProductEvent, resolveAutomationTimeoutSeconds, timerDelayUntil };
+export { AutomationActionExecutor, AutomationActionSchema, AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationDeliveryPolicySchema, AutomationDeliveryRouter, AutomationEventDispatcher, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, automationEventPublisher, claimAutomationEventDeliveries, claimAutomationEventsForProjection, completeAutomationEventDelivery, completeAutomationEventProjection, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, deferAutomationEventDelivery, expireAutomationEventProjectionLeases, failAutomationEventProjection, getAutomationEventDeliveryRunId, getAutomationEventForRun, getAutomationEventQueueMetrics, getAutomationResultDeliveryMetrics, ingestAutomationEvent, listAutomationEventRecords, listAutomationEvents, listAutomationResultDeliveries, listBusinessEventDefinitions, markAutomationEventDeliveryQueued, reconcileAutomationEventDeliveries, registerBusinessEvent, releaseAutomationEventDelivery, releaseAutomationEventProjection, replayAutomationEvent, resolveAutomationTimeoutSeconds, resolveAutomationWebhookSecret, retryAutomationResultDelivery, skipAutomationEventDelivery, timerDelayUntil, validateCatalogedBusinessEvent };

package/dist/src/automations/service/action-executor.d.ts

@@ -1,10 +1,29 @@
-import type { Automation, AutomationActionExecutionContext, AutomationActionExecutionHooks, AutomationActionTask, AutomationDeps, AutomationRun } from '../domain/types.js';
+import type { Automation, AutomationAction, AutomationActionExecutionContext, AutomationActionExecutionHooks, AutomationActionTask, AutomationDeps, AutomationRetrySafety, AutomationRun } from '../domain/types.js';
+type AutomationActionKind = AutomationAction['kind'];
+type AutomationActionOf<K extends AutomationActionKind> = Extract<AutomationAction, {
+    kind: K;
+}>;
+interface AutomationExecutorInput {
+    automation: Automation;
+    run: AutomationRun;
+    signal: AbortSignal;
+    hooks: AutomationActionExecutionHooks;
+    deadlineAtMs: number;
+    context: AutomationActionExecutionContext;
+}
 export declare class AutomationActionExecutor {
     private deps;
+    private readonly handlers;
+    constructor();
+    register<K extends AutomationActionKind>(kind: K, retrySafety: AutomationRetrySafety, handler: (input: AutomationExecutorInput, action: AutomationActionOf<K>) => Promise<AutomationActionTask>): void;
+    canRetry(kind: AutomationActionKind, error: unknown): boolean;
     setDeps(deps: AutomationDeps): void;
     execute(automation: Automation, run: AutomationRun, signal: AbortSignal, hooks?: AutomationActionExecutionHooks, context?: AutomationActionExecutionContext): Promise<AutomationActionTask>;
     private executeWithoutTimeout;
+    private executeTaskCommand;
+    private executeSystemAction;
     private executeBrowserAutomation;
     private executeAgent;
     private executeWorkflow;
 }
+export {};