@headless-lms/core 0.1.0 → 0.3.0

package/dist/automations/service.js

@@ -1,8 +1,13 @@
+import { deliverWebhookInputSchema } from "../types/schemas/automations.js";
+import { ConflictError, NotFoundError } from "../shared/errors.js";
 import { noopLogger } from "../shared/logger.js";
-import { catalogActions, catalogTriggers } from "./catalog.js";
+import { ActionFailedError, AutomationKindMismatchError, InvalidTriggerError, ReservedActionError } from "./model.js";
+import { DELIVER_WEBHOOK_ACTION, catalogActions, catalogTriggers, publicDataSchema } from "./catalog.js";
+import { generateWebhookSecret } from "./webhook-signing.js";
 import { executeAction } from "./actions.js";
 import { automationEvents } from "./events.js";
-import { InvalidTriggerError } from "./model.js";
+import { communitySeeds, orgSeeds } from "./seeds.js";
+import { cronSupported } from "./schedule.js";
 //#region src/automations/service.ts
 /** True only when `input` sets `enabled` and nothing else — emits automation.enabled|disabled instead of automation.updated. */
 function isEnabledOnlyUpdate(input) {
@@ -10,6 +15,107 @@ function isEnabledOnlyUpdate(input) {
 	const { enabled: _enabled, ...rest } = input;
 	return Object.values(rest).every((v) => v === void 0);
 }
+function floorMinute(at) {
+	const copy = new Date(at);
+	copy.setUTCSeconds(0, 0);
+	return copy.getTime();
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function recordString(value, key) {
+	if (typeof value !== "object" || value === null || !(key in value)) return null;
+	const found = value[key];
+	return typeof found === "string" ? found : null;
+}
+function filterMatches(filter, data) {
+	if (filter == null) return true;
+	if (typeof data !== "object" || data === null || Array.isArray(data)) return false;
+	const record = data;
+	return Object.entries(filter).every(([key, expected]) => {
+		if (!Object.prototype.hasOwnProperty.call(record, key)) return false;
+		return JSON.stringify(record[key]) === JSON.stringify(expected);
+	});
+}
+function assertAuthorableTriggers(triggers) {
+	for (const trigger of triggers) {
+		if (trigger.startsWith("automation.")) throw new InvalidTriggerError(trigger);
+		if (trigger.startsWith("schedule:") && !cronSupported(trigger.slice(9))) throw new InvalidTriggerError(trigger, "schedule");
+	}
+}
+function assertCatalogTriggers(triggers, schedules) {
+	assertAuthorableTriggers(triggers);
+	const known = new Set(catalogTriggers().map((t) => t.type));
+	for (const trigger of triggers) if (!(schedules && trigger.startsWith("schedule:")) && !known.has(trigger)) throw new InvalidTriggerError(trigger, "unknown");
+}
+function assertAuthorableActions(actions) {
+	for (const action of actions) if (action.type === "deliverWebhook") throw new ReservedActionError(action.type);
+}
+const SCHEDULE_FIRED = "automation.schedule.fired";
+function publicEventData(event) {
+	const parsed = event.type === SCHEDULE_FIRED ? {
+		success: true,
+		data: event.data
+	} : publicDataSchema(event.type)?.safeParse(event.data);
+	return parsed?.success ? JSON.parse(JSON.stringify(parsed.data)) : null;
+}
+/** A run as callers see it: its event carries only what a webhook of that event would. */
+function toRunView(run) {
+	const { type, version, id, orgId, occurredAt } = run.event;
+	return {
+		...run,
+		event: {
+			type,
+			version,
+			id,
+			orgId,
+			occurredAt,
+			data: publicEventData(run.event)
+		}
+	};
+}
+/** An automation as callers see it: a webhook's credential reference stays internal. */
+function toAutomationView(automation) {
+	return {
+		...automation,
+		actions: automation.actions.map((action) => {
+			if (action.type !== "deliverWebhook") return action;
+			const { secretRef: _secretRef, ...input } = action.input;
+			return {
+				...action,
+				input
+			};
+		})
+	};
+}
+function webhookTarget(automation) {
+	return deliverWebhookInputSchema.parse(automation.actions[0]?.input);
+}
+function toWebhook(automation) {
+	return {
+		orgId: automation.orgId,
+		id: automation.id,
+		url: webhookTarget(automation).url,
+		events: automation.triggers,
+		description: automation.description,
+		enabled: automation.enabled,
+		createdAt: automation.createdAt,
+		updatedAt: automation.updatedAt
+	};
+}
+function updateEvent(orgId, input, updated) {
+	if (isEnabledOnlyUpdate(input)) return input.enabled ? automationEvents.automationEnabled.make({
+		orgId,
+		data: updated
+	}) : automationEvents.automationDisabled.make({
+		orgId,
+		data: updated
+	});
+	return automationEvents.automationUpdated.make({
+		orgId,
+		data: updated
+	});
+}
 var AutomationsServiceImpl = class {
 	repo;
 	runsRepo;
@@ -18,6 +124,12 @@ var AutomationsServiceImpl = class {
 	mailer;
 	lookups;
 	integrations;
+	credentials;
+	webhooks;
+	mail;
+	grants;
+	desk;
+	scheduledWork;
 	logger;
 	constructor(params) {
 		this.repo = params.repo;
@@ -27,12 +139,87 @@ var AutomationsServiceImpl = class {
 		this.mailer = params.mailer;
 		this.lookups = params.lookups;
 		this.integrations = params.integrations;
+		this.credentials = params.credentials;
+		this.webhooks = params.webhooks;
+		this.mail = {
+			...params.mail,
+			recentMessageRecipients: (orgId, automationId, chatId, since) => this.runsRepo.recentRecipients(orgId, automationId, chatId, since)
+		};
+		this.grants = params.grants;
+		this.desk = params.desk;
+		this.scheduledWork = params.scheduledWork;
 		this.logger = params.logger ?? noopLogger;
 	}
 	async handle(event) {
 		if (event.type.startsWith("automation.")) return;
+		await this.seedFor(event);
 		const automations = await this.safeListByTrigger(event);
-		for (const automation of automations.filter((a) => a.enabled)) await this.dispatchOne(automation, event);
+		for (const automation of automations) {
+			const matches = filterMatches(automation.filter, event.data);
+			if (!automation.enabled || !matches) {
+				if (automation.enabled && !matches) this.logger.debug("automation filter skipped", {
+					orgId: event.orgId,
+					automationId: automation.id,
+					trigger: event.type
+				});
+				continue;
+			}
+			await this.dispatchOne(automation, event);
+		}
+	}
+	seedsFor(event) {
+		if (event.type === "organization.created") return orgSeeds();
+		if (event.type !== "content.community.created") return null;
+		const communityId = recordString(event.data, "id");
+		if (!communityId) {
+			this.logger.error("community seed missing id", {
+				orgId: event.orgId,
+				eventId: event.id
+			});
+			return null;
+		}
+		return communitySeeds(communityId);
+	}
+	async seedFor(event) {
+		const rows = this.seedsFor(event);
+		if (!rows) return;
+		if (await this.uow.run(async ({ automations, outbox }) => {
+			const created = [];
+			for (const row of rows) {
+				const inserted = await automations.insertSeed(event.orgId, {
+					name: row.name,
+					description: row.description,
+					triggers: row.triggers,
+					actions: row.actions,
+					filter: row.filter,
+					kind: "workflow",
+					source: "system"
+				});
+				if (inserted) created.push(automationEvents.automationCreated.make({
+					orgId: event.orgId,
+					data: inserted
+				}));
+			}
+			if (created.length > 0) {
+				await outbox.append(created);
+				this.logger.info("system automations seeded", {
+					orgId: event.orgId,
+					trigger: event.type,
+					count: created.length
+				});
+			}
+			return created.length;
+		}) > 0) await this.reconcileSchedules(event.orgId);
+	}
+	async reconcileSchedules(orgId) {
+		try {
+			await this.engine.syncSchedules?.();
+		} catch (err) {
+			this.logger.error("automation schedules not reconciled", {
+				orgId,
+				err
+			});
+		}
 	}
 	async safeListByTrigger(event) {
 		try {
@@ -41,55 +228,65 @@ var AutomationsServiceImpl = class {
 			this.logger.error("automations: failed to load trigger matches", {
 				orgId: event.orgId,
 				trigger: event.type,
-				error: err instanceof Error ? err.message : String(err)
+				err
 			});
 			return [];
 		}
 	}
 	async dispatchOne(automation, event) {
-		let run;
+		let run = null;
 		try {
-			run = await this.uow.run(async ({ runs, outbox }) => {
-				const inserted = await runs.insert(event.orgId, {
-					orgId: event.orgId,
-					automationId: automation.id,
-					trigger: automation.trigger,
-					event,
-					status: "running",
-					actionResults: [],
-					startedAt: /* @__PURE__ */ new Date(),
-					finishedAt: null
-				});
-				if (!inserted) return null;
-				await outbox.append([automationEvents.runStarted.make({
-					orgId: event.orgId,
-					data: inserted
-				})]);
-				return inserted;
-			});
+			run = await this.openRun(automation, event);
 			if (!run) return;
-			await this.engine.dispatch({
-				runId: run.id,
-				orgId: event.orgId,
-				automationId: automation.id,
-				actions: automation.actions,
-				event
-			});
+			await this.engine.dispatch(this.dispatchFor(automation, run, event));
 		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
 			this.logger.error("automation run failed", {
 				orgId: event.orgId,
 				automationId: automation.id,
 				runId: run?.id,
-				error: message
+				trigger: event.type,
+				eventId: event.id,
+				err
 			});
-			if (run) await this.recordFailure(run, message);
+			if (run) await this.recordFailure(run, err instanceof Error ? err.message : String(err));
 		}
 	}
+	openRun(automation, event) {
+		const now = /* @__PURE__ */ new Date();
+		return this.uow.run(async ({ runs, outbox }) => {
+			const inserted = await runs.insert(event.orgId, {
+				orgId: event.orgId,
+				automationId: automation.id,
+				trigger: event.type,
+				event,
+				status: "running",
+				actionResults: [],
+				startedAt: now,
+				finishedAt: null,
+				createdAt: now,
+				updatedAt: now
+			});
+			if (!inserted) return null;
+			await outbox.append([automationEvents.runStarted.make({
+				orgId: event.orgId,
+				data: inserted
+			})]);
+			return inserted;
+		});
+	}
+	dispatchFor(automation, run, event) {
+		return {
+			runId: run.id,
+			orgId: event.orgId,
+			automationId: automation.id,
+			actions: automation.actions,
+			event
+		};
+	}
 	/** Best-effort: logs and never rethrows — `handle` must never throw. */
 	async recordFailure(run, error) {
 		try {
-			await this.uow.run(async ({ runs, outbox }) => {
+			return await this.uow.run(async ({ runs, outbox }) => {
 				const failed = await runs.recordOutcome(run.orgId, run.id, {
 					status: "failed",
 					actionResults: run.actionResults,
@@ -99,25 +296,113 @@ var AutomationsServiceImpl = class {
 					orgId: run.orgId,
 					data: failed
 				})]);
+				return failed;
 			});
 		} catch (err) {
 			this.logger.error("failed to record automation run failure", {
 				orgId: run.orgId,
+				automationId: run.automationId,
 				runId: run.id,
-				error: err instanceof Error ? err.message : String(err),
+				err,
 				originalError: error
 			});
+			return null;
 		}
 	}
 	async runAction(d, index) {
 		const action = d.actions[index];
 		if (!action) throw new Error(`automation ${d.automationId} run ${d.runId}: no action at index ${index}`);
-		await executeAction(action, d.event, this.mailer, this.lookups);
+		let outcome;
+		try {
+			outcome = await executeAction(action, d.event, {
+				mailer: this.mailer,
+				lookups: this.lookups,
+				credentials: this.credentials,
+				webhooks: this.webhooks,
+				mail: this.mail,
+				grants: this.grants,
+				desk: this.desk,
+				scheduledWork: this.scheduledWork,
+				automationId: d.automationId,
+				actionInput: action.input,
+				logger: this.logger
+			});
+		} catch (err) {
+			this.logger.error("automation action failed", {
+				orgId: d.orgId,
+				automationId: d.automationId,
+				runId: d.runId,
+				trigger: d.event.type,
+				index,
+				type: action.type,
+				err
+			});
+			throw err instanceof ActionFailedError ? err : new ActionFailedError();
+		}
+		const { recipients, failed } = outcome;
+		this.logger.info("automation action completed", {
+			orgId: d.orgId,
+			automationId: d.automationId,
+			runId: d.runId,
+			type: action.type,
+			recipients: recipients.length,
+			failed: failed.length
+		});
 		return {
 			index,
 			type: action.type,
-			status: "completed"
+			status: "completed",
+			...recipients.length > 0 ? { recipients } : {},
+			...failed.length > 0 ? { error: `delivery failed for ${failed.length} recipients: ${failed.join(", ")}` } : {}
+		};
+	}
+	async listSchedules() {
+		return this.repo.listSchedules();
+	}
+	async fireSchedule(orgId, automationId, at) {
+		const firedAt = new Date(floorMinute(at));
+		const automation = await this.repo.findById(orgId, automationId);
+		if (!automation?.enabled || firedAt.getTime() < floorMinute(automation.createdAt)) {
+			this.logger.debug("schedule skipped", {
+				orgId,
+				automationId
+			});
+			return;
+		}
+		if (!await this.scheduleHasWork(orgId, automation, firedAt)) {
+			this.logger.debug("schedule idle", {
+				orgId,
+				automationId
+			});
+			return;
+		}
+		const event = {
+			type: SCHEDULE_FIRED,
+			id: `schedule_${automationId}_${firedAt.toISOString()}`,
+			orgId,
+			version: 1,
+			occurredAt: firedAt.toISOString(),
+			data: {
+				automationId,
+				firedAt: firedAt.toISOString()
+			}
 		};
+		await this.dispatchOne(automation, event);
+	}
+	async scheduleHasWork(orgId, automation, firedAt) {
+		const checks = automation.actions.map((action) => this.pendingWork(action.type));
+		const known = checks.filter((check) => check !== null);
+		if (checks.length === 0 || known.length < checks.length) return true;
+		for (const check of known) if (await check(orgId, firedAt)) return true;
+		return false;
+	}
+	pendingWork(type) {
+		switch (type) {
+			case "publishDuePosts": return (orgId, now) => this.scheduledWork.hasDuePosts(orgId, now);
+			case "expireDueGrants": return (orgId, now) => this.scheduledWork.hasDueGrants(orgId, now);
+			case "removeUnattachedUploads": return (orgId, now) => this.scheduledWork.hasUnattachedUploads(orgId, now);
+			default: return null;
+		}
 	}
 	async finalize(d, results) {
 		const status = results.length === d.actions.length && results.every((r) => r.status === "completed") ? "completed" : "failed";
@@ -141,11 +426,46 @@ var AutomationsServiceImpl = class {
 			}) }));
 			await outbox.append([runEvent, ...actionFailedEvents]);
 		});
+		this.logOutcome(d, status, results);
+	}
+	logOutcome(d, status, results) {
+		const run = {
+			orgId: d.orgId,
+			automationId: d.automationId,
+			runId: d.runId,
+			trigger: d.event.type,
+			eventId: d.event.id
+		};
+		if (status === "failed") {
+			const failed = results.find((r) => r.status === "failed");
+			const index = failed?.index ?? results.length;
+			this.logger.error("automation run failed", {
+				...run,
+				index,
+				action: failed?.type ?? d.actions[index]?.type,
+				error: failed?.error ?? "not every action ran"
+			});
+			return;
+		}
+		const partial = results.filter((r) => r.error !== void 0);
+		if (partial.length > 0) this.logger.warn("automation run completed with failed deliveries", {
+			...run,
+			actions: partial.map(({ index, type, error }) => ({
+				index,
+				type,
+				error
+			}))
+		});
 	}
 	async create(orgId, input) {
-		if (input.trigger.startsWith("automation.")) throw new InvalidTriggerError(input.trigger);
+		assertCatalogTriggers(input.triggers, true);
+		assertAuthorableActions(input.actions);
 		const automation = await this.uow.run(async ({ automations, outbox }) => {
-			const created = await automations.insert(orgId, input);
+			const created = await automations.insert(orgId, {
+				...input,
+				triggers: unique(input.triggers),
+				kind: "workflow"
+			});
 			await outbox.append([automationEvents.automationCreated.make({
 				orgId,
 				data: created
@@ -156,56 +476,219 @@ var AutomationsServiceImpl = class {
 			orgId,
 			automationId: automation.id
 		});
+		await this.reconcileSchedules(orgId);
 		return automation;
 	}
 	async update(orgId, id, input) {
-		if (input.trigger !== void 0 && input.trigger.startsWith("automation.")) throw new InvalidTriggerError(input.trigger);
+		if (input.triggers !== void 0) assertCatalogTriggers(input.triggers, true);
+		if (input.actions !== void 0) assertAuthorableActions(input.actions);
+		const existing = await this.repo.findById(orgId, id);
+		if (!existing) return null;
+		if (existing.kind !== "workflow") throw new AutomationKindMismatchError(id, existing.kind);
+		const patch = input.triggers === void 0 ? input : {
+			...input,
+			triggers: unique(input.triggers)
+		};
 		const automation = await this.uow.run(async ({ automations, outbox }) => {
-			const updated = await automations.update(orgId, id, input);
+			const updated = await automations.update(orgId, id, patch);
 			if (!updated) return null;
-			if (isEnabledOnlyUpdate(input)) await outbox.append([input.enabled ? automationEvents.automationEnabled.make({
+			await outbox.append([updateEvent(orgId, input, updated)]);
+			return updated;
+		});
+		if (automation) {
+			this.logger.info("automation updated", {
 				orgId,
-				data: updated
-			}) : automationEvents.automationDisabled.make({
+				automationId: id
+			});
+			await this.reconcileSchedules(orgId);
+		}
+		return automation;
+	}
+	async delete(orgId, id) {
+		const existing = await this.repo.findById(orgId, id);
+		if (!existing) return false;
+		if (existing.kind !== "workflow") throw new AutomationKindMismatchError(id, existing.kind);
+		if (existing.source === "system") throw new ConflictError("A system automation cannot be deleted");
+		const deleted = await this.uow.run(async ({ automations, outbox }) => {
+			const removed = await automations.delete(orgId, id);
+			if (!removed) return null;
+			await outbox.append([automationEvents.automationDeleted.make({
 				orgId,
-				data: updated
+				data: removed
 			})]);
-			else await outbox.append([automationEvents.automationUpdated.make({
+			return removed;
+		});
+		if (deleted) {
+			this.logger.info("automation deleted", {
 				orgId,
-				data: updated
+				automationId: id
+			});
+			await this.reconcileSchedules(orgId);
+		}
+		return deleted !== null;
+	}
+	async list(orgId, query) {
+		return (await this.repo.listByOrg(orgId, query?.kind)).map(toAutomationView);
+	}
+	async get(orgId, id) {
+		const automation = await this.repo.findById(orgId, id);
+		return automation ? toAutomationView(automation) : null;
+	}
+	async listRuns(orgId, automationId, query) {
+		const page = await this.runsRepo.list(orgId, automationId, query);
+		return {
+			...page,
+			rows: page.rows.map(toRunView)
+		};
+	}
+	async rerun(orgId, automationId, runId) {
+		const existing = await this.runsRepo.findById(orgId, runId);
+		if (!existing || existing.automationId !== automationId) throw new NotFoundError("Automation run", runId);
+		const automation = await this.repo.findById(orgId, automationId);
+		if (!automation) throw new NotFoundError("Automation", automationId);
+		const run = await this.uow.run(async ({ runs, outbox }) => {
+			const restarted = await runs.restart(orgId, runId, /* @__PURE__ */ new Date());
+			if (!restarted) return null;
+			await outbox.append([automationEvents.runStarted.make({
+				orgId,
+				data: restarted
 			})]);
-			return updated;
+			return restarted;
+		});
+		if (!run) throw new ConflictError(`automation run ${runId} is still running`);
+		try {
+			await this.engine.dispatch(this.dispatchFor(automation, run, run.event));
+		} catch (err) {
+			this.logger.error("automation rerun failed", {
+				orgId,
+				automationId,
+				runId: run.id,
+				trigger: run.trigger,
+				err
+			});
+			return toRunView(await this.recordFailure(run, err instanceof Error ? err.message : String(err)) ?? run);
+		}
+		this.logger.info("automation rerun started", {
+			orgId,
+			automationId,
+			runId: run.id
+		});
+		return toRunView(run);
+	}
+	async listWebhooks(orgId) {
+		return (await this.repo.listByOrg(orgId, "webhook")).map(toWebhook);
+	}
+	async getWebhook(orgId, id) {
+		const automation = await this.findWebhook(orgId, id);
+		return automation ? toWebhook(automation) : null;
+	}
+	async createWebhook(orgId, input) {
+		const events = unique(input.events);
+		assertCatalogTriggers(events, false);
+		const secret = generateWebhookSecret();
+		const automation = await this.uow.run(async ({ automations, credentials, outbox }) => {
+			const secretRef = await credentials.store(orgId, { secret });
+			const created = await automations.insert(orgId, {
+				kind: "webhook",
+				name: input.url,
+				description: input.description,
+				triggers: events,
+				actions: [{
+					type: DELIVER_WEBHOOK_ACTION,
+					input: {
+						url: input.url,
+						secretRef
+					}
+				}]
+			});
+			await outbox.append([automationEvents.automationCreated.make({
+				orgId,
+				data: created
+			})]);
+			return created;
+		});
+		this.logger.info("webhook created", {
+			orgId,
+			automationId: automation.id
+		});
+		return {
+			...toWebhook(automation),
+			secret
+		};
+	}
+	async updateWebhook(orgId, id, input) {
+		const existing = await this.findWebhook(orgId, id);
+		if (!existing) return null;
+		const events = input.events === void 0 ? void 0 : unique(input.events);
+		if (events) assertCatalogTriggers(events, false);
+		const { secretRef } = webhookTarget(existing);
+		const patch = {
+			name: input.url,
+			description: input.description,
+			triggers: events,
+			actions: input.url === void 0 ? void 0 : [{
+				type: DELIVER_WEBHOOK_ACTION,
+				input: {
+					url: input.url,
+					secretRef
+				}
+			}],
+			enabled: input.enabled
+		};
+		const updated = await this.uow.run(async ({ automations, outbox }) => {
+			const row = await automations.update(orgId, id, patch);
+			if (!row) return null;
+			await outbox.append([updateEvent(orgId, input, row)]);
+			return row;
 		});
-		if (automation) this.logger.info("automation updated", {
+		if (!updated) return null;
+		this.logger.info("webhook updated", {
 			orgId,
 			automationId: id
 		});
-		return automation;
+		return toWebhook(updated);
 	}
-	async delete(orgId, id) {
-		const deleted = await this.uow.run(async ({ automations, outbox }) => {
+	async deleteWebhook(orgId, id) {
+		const existing = await this.findWebhook(orgId, id);
+		if (!existing) return false;
+		const { secretRef } = webhookTarget(existing);
+		const deleted = await this.uow.run(async ({ automations, credentials, outbox }) => {
 			const removed = await automations.delete(orgId, id);
 			if (!removed) return null;
+			await credentials.destroy(orgId, secretRef);
 			await outbox.append([automationEvents.automationDeleted.make({
 				orgId,
 				data: removed
 			})]);
 			return removed;
 		});
-		if (deleted) this.logger.info("automation deleted", {
+		if (deleted) this.logger.info("webhook deleted", {
 			orgId,
 			automationId: id
 		});
 		return deleted !== null;
 	}
-	list(orgId) {
-		return this.repo.listByOrg(orgId);
+	async revealWebhookSecret(orgId, id) {
+		const existing = await this.findWebhook(orgId, id);
+		if (!existing) return null;
+		const secret = (await this.credentials.reveal(orgId, webhookTarget(existing).secretRef))?.["secret"];
+		if (typeof secret !== "string") throw new Error(`webhook ${id}: signing secret is missing`);
+		return { secret };
 	}
-	get(orgId, id) {
-		return this.repo.findById(orgId, id);
+	async rotateWebhookSecret(orgId, id) {
+		const existing = await this.findWebhook(orgId, id);
+		if (!existing) return null;
+		const secret = generateWebhookSecret();
+		await this.credentials.update(orgId, webhookTarget(existing).secretRef, { secret });
+		this.logger.info("webhook secret rotated", {
+			orgId,
+			automationId: id
+		});
+		return { secret };
 	}
-	listRuns(orgId, automationId, query) {
-		return this.runsRepo.list(orgId, automationId, query);
+	async findWebhook(orgId, id) {
+		const automation = await this.repo.findById(orgId, id);
+		return automation?.kind === "webhook" ? automation : null;
 	}
 	availableActions() {
 		return [...catalogActions(), ...this.integrations.available().flatMap((integration) => integration.actions.map((action) => ({