@xopcai/xopc 0.0.332 → 0.0.333

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

@@ -0,0 +1,117 @@
+import { z } from "zod";
+//#region src/automations/events/event-catalog.ts
+const definitions = /* @__PURE__ */ new Map();
+function catalogKey(type, source, schemaVersion) {
+	return `${source}\0${type}\0${schemaVersion}`;
+}
+function registerBusinessEvent(definition) {
+	const key = catalogKey(definition.type, definition.source, definition.schemaVersion);
+	if (definitions.has(key)) throw new Error(`Business event is already registered: ${definition.source}/${definition.type}@${definition.schemaVersion}`);
+	definitions.set(key, definition);
+}
+function validateCatalogedBusinessEvent(event) {
+	const definition = definitions.get(catalogKey(event.type, event.source, event.schemaVersion));
+	if (!definition) return;
+	if (event.subject?.kind !== definition.subjectKind) throw new Error(`Business event subject must be ${definition.subjectKind}: ${event.type}`);
+	definition.payloadSchema.parse(event.payload);
+}
+function listBusinessEventDefinitions() {
+	return [...definitions.values()].toSorted((left, right) => `${left.source}/${left.type}`.localeCompare(`${right.source}/${right.type}`));
+}
+const objectPayload = z.record(z.string(), z.unknown());
+for (const definition of [
+	[
+		"tasks",
+		"task.changed.v2",
+		"task",
+		"A Task changed."
+	],
+	[
+		"tasks",
+		"task.deleted.v1",
+		"task",
+		"A Task was deleted."
+	],
+	[
+		"notes",
+		"note.created",
+		"note",
+		"A Note was created."
+	],
+	[
+		"notes",
+		"note.updated",
+		"note",
+		"A Note changed."
+	],
+	[
+		"notes",
+		"note.deleted",
+		"note",
+		"A Note was deleted."
+	],
+	[
+		"projects",
+		"project.created",
+		"project",
+		"A Project was created."
+	],
+	[
+		"projects",
+		"project.changed",
+		"project",
+		"A Project changed."
+	],
+	[
+		"projects",
+		"project.deleted",
+		"project",
+		"A Project was deleted."
+	],
+	[
+		"scenes",
+		"scene.created",
+		"scene",
+		"A Scene was created."
+	],
+	[
+		"scenes",
+		"scene.changed",
+		"scene",
+		"A Scene changed."
+	],
+	[
+		"scenes",
+		"scene.deleted",
+		"scene",
+		"A Scene was deleted."
+	],
+	[
+		"discussions",
+		"discussion.completed",
+		"discussion",
+		"A Discussion completed."
+	],
+	[
+		"sessions",
+		"session.transcript.updated",
+		"session",
+		"A Session transcript changed."
+	],
+	[
+		"workflows",
+		"workflow.run.completed",
+		"workflow_run",
+		"A Workflow run completed."
+	]
+]) registerBusinessEvent({
+	source: definition[0],
+	type: definition[1],
+	subjectKind: definition[2],
+	description: definition[3],
+	schemaVersion: 1,
+	payloadSchema: objectPayload,
+	defaultTrust: "system"
+});
+//#endregion
+export { listBusinessEventDefinitions, registerBusinessEvent, validateCatalogedBusinessEvent };

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

@@ -0,0 +1,27 @@
+import type { AutomationEventEnvelope, AutomationRun } from '../domain/types.js';
+import type { AutomationService } from '../service/automation-service.js';
+export declare class AutomationEventDispatcher {
+    private readonly automationService;
+    private readonly options;
+    private timer?;
+    private active?;
+    private stopping;
+    private readonly owner;
+    private readonly abortController;
+    constructor(automationService: AutomationService, options?: {
+        onEvent?: (event: AutomationEventEnvelope, signal?: AbortSignal) => void | Promise<void>;
+        onDeadLetter?: (input: {
+            phase: 'event_projection' | 'event_delivery';
+            eventId: string;
+            automationId?: string;
+            error: string;
+        }) => void;
+        intervalMs?: number;
+    });
+    start(): void;
+    stop(): Promise<void>;
+    dispatch(): Promise<number>;
+    runCompleted(run: AutomationRun): void;
+    private runDispatch;
+    private projectEvents;
+}

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