@xopcai/xopc 0.0.332 → 0.0.333

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 {};

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

@@ -70,6 +70,36 @@ async function executeWithDeadline(operation, timeoutMs, parentSignal, deadlineA
 }
 var AutomationActionExecutor = class {
 	deps = {};
+	handlers = /* @__PURE__ */ new Map();
+	constructor() {
+		this.register("agent", { mode: "never" }, (input, action) => this.executeAgent(input.automation, action, input.run, input.signal, input.hooks, input.deadlineAtMs, input.context));
+		this.register("workflow", {
+			mode: "idempotent",
+			key: "run_id"
+		}, (input, action) => this.executeWorkflow(input.automation, action, input.run, input.signal, input.hooks, input.context));
+		this.register("browser_automation", { mode: "never" }, (input, action) => this.executeBrowserAutomation(input.automation, action, input.signal, input.hooks, input.context));
+		this.register("task_command", {
+			mode: "idempotent",
+			key: "run_id"
+		}, (input, action) => this.executeTaskCommand(input, action));
+		this.register("system", {
+			mode: "transient_only",
+			classify: (error) => /temporar|timeout|timed out|unavailable|busy|rate limit|econn|network/i.test(String(error))
+		}, (input, action) => this.executeSystemAction(input, action));
+	}
+	register(kind, retrySafety, handler) {
+		if (this.handlers.has(kind)) throw new Error(`Automation executor already registered: ${kind}`);
+		this.handlers.set(kind, {
+			retrySafety,
+			handler: (input) => handler(input, input.automation.action)
+		});
+	}
+	canRetry(kind, error) {
+		const retrySafety = this.handlers.get(kind)?.retrySafety ?? { mode: "never" };
+		if (retrySafety.mode === "never") return false;
+		if (retrySafety.mode === "idempotent") return true;
+		return retrySafety.classify(error);
+	}
 	setDeps(deps) {
 		this.deps = {
 			...this.deps,
@@ -105,46 +135,56 @@ var AutomationActionExecutor = class {
 			status: "cancelled",
 			error: "Automation run was cancelled"
 		};
-		if (automation.action.kind === "workflow") return this.executeWorkflow(automation, automation.action, run, signal, hooks, context);
-		if (automation.action.kind === "browser_automation") return this.executeBrowserAutomation(automation, automation.action, signal, hooks, context);
-		if (automation.action.kind === "task_command") {
-			await hooks.onRunPatch?.({ currentPhase: "action" });
-			const execute = this.deps.executeTaskCommand;
-			if (!execute) return {
-				status: "failed",
-				error: "Task command executor is unavailable"
-			};
-			const result = execute({
-				taskId: automation.action.taskId,
-				idempotencyKey: `automation:${automation.id}:${run.id}`,
-				command: automation.action.command,
-				...context.triggerEvent ? { triggerEvent: context.triggerEvent } : {}
-			});
-			return result.ok ? {
-				status: "succeeded",
-				summary: result.runId ? `TaskRun ${result.runId} queued` : "Task command applied"
-			} : {
-				status: "failed",
-				error: result.reason ?? "Task command failed"
-			};
-		}
-		if (automation.action.kind === "system") {
-			await hooks.onRunPatch?.({ currentPhase: "action" });
-			const execute = this.deps.executeSystemAction;
-			if (!execute) return {
-				status: "failed",
-				error: "System action executor is unavailable"
-			};
-			return {
-				status: "succeeded",
-				summary: (await execute({
-					capability: automation.action.capability,
-					automationId: automation.id,
-					runId: run.id
-				})).summary ?? "System action completed"
-			};
-		}
-		return this.executeAgent(automation, automation.action, run, signal, hooks, deadlineAtMs, context);
+		const registration = this.handlers.get(automation.action.kind);
+		if (!registration) return {
+			status: "failed",
+			error: `Automation executor is unavailable: ${automation.action.kind}`
+		};
+		return registration.handler({
+			automation,
+			run,
+			signal,
+			hooks,
+			deadlineAtMs,
+			context
+		});
+	}
+	async executeTaskCommand(input, action) {
+		await input.hooks.onRunPatch?.({ currentPhase: "action" });
+		const execute = this.deps.executeTaskCommand;
+		if (!execute) return {
+			status: "failed",
+			error: "Task command executor is unavailable"
+		};
+		const result = execute({
+			taskId: action.taskId,
+			idempotencyKey: `automation:${input.automation.id}:${input.run.id}`,
+			command: action.command,
+			...input.context.triggerEvent ? { triggerEvent: input.context.triggerEvent } : {}
+		});
+		return result.ok ? {
+			status: "succeeded",
+			summary: result.runId ? `TaskRun ${result.runId} queued` : "Task command applied"
+		} : {
+			status: "failed",
+			error: result.reason ?? "Task command failed"
+		};
+	}
+	async executeSystemAction(input, action) {
+		await input.hooks.onRunPatch?.({ currentPhase: "action" });
+		const execute = this.deps.executeSystemAction;
+		if (!execute) return {
+			status: "failed",
+			error: "System action executor is unavailable"
+		};
+		return {
+			status: "succeeded",
+			summary: (await execute({
+				capability: action.capability,
+				automationId: input.automation.id,
+				runId: input.run.id
+			})).summary ?? "System action completed"
+		};
 	}
 	async executeBrowserAutomation(automation, action, signal, hooks, context) {
 		await hooks.onRunPatch?.({ currentPhase: "action" });

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

@@ -11,12 +11,15 @@ export declare class AutomationAlreadyExistsError extends Error {
 }
 export declare class AutomationService {
     private readonly executor;
+    private readonly eventDispatcher;
+    private readonly deliveryRouter;
     private timer;
     private stopped;
     private runningScheduler;
     private deps;
     private maxConcurrentRuns;
     private readonly activeRuns;
+    private readonly activeRunTasks;
     private readonly heartbeatTimers;
     private readonly leaseOwner;
     setDeps(deps: AutomationDeps): void;
@@ -49,14 +52,30 @@ export declare class AutomationService {
     resume(id: string): Promise<Automation | null>;
     runNow(id: string): Promise<AutomationRun>;
     rerunFromRun(runId: string): Promise<AutomationRun>;
-    queueRerunAtomically(runId: string): AutomationRun;
+    ingestEvent(event: AutomationEvent, targetAutomationIds?: string[]): import("../index.js").AutomationEventIngestResult;
+    dispatchEvents(): Promise<number>;
+    replayEventAtomically(eventId: string): boolean;
+    retryResultDeliveryAtomically(runId: string, destinationKey: string): boolean;
+    dispatchRecoveryWork(): void;
+    listEventRecords(input?: {
+        type?: string;
+        source?: string;
+        limit?: number;
+    }): import("../index.js").AutomationEventRecord[];
+    listResultDeliveries(input?: {
+        runId?: string;
+        status?: 'pending' | 'delivering' | 'retrying' | 'delivered' | 'dead_letter';
+        limit?: number;
+    }): import("../index.js").AutomationResultDeliveryRecord[];
+    private ingestTargetedTrigger;
+    queueTriggerAtomically(automationId: string, input: AutomationEvent, executionEvent?: AutomationEvent): AutomationRun;
     queueRunAtomically(id: string, opts?: {
         manual: boolean;
         event?: AutomationEvent;
     }): AutomationRun;
     /** Claim before invoking external work; replays never restart running or completed runs. */
     dispatchQueuedRun(runId: string): void;
-    triggerEvent(event: AutomationEvent): Promise<AutomationRun[]>;
+    availableRunSlots(): number;
     listRuns(options?: {
         automationId?: string;
         projectId?: string;
@@ -85,12 +104,10 @@ export declare class AutomationService {
     private recomputeNextRuns;
     private armTimer;
     private onTimer;
-    private startRun;
     private persistQueuedRun;
     private executeRun;
     private recoverInterruptedRuns;
     private waitForRetry;
     private appendRunEvent;
     private finishAutomationRun;
-    private postCompletionWebhook;
 }