@amalgm/automations 0.2.2 → 0.2.4

package/dist/src/crud/triggers.js

@@ -3,7 +3,7 @@ import { parseCreateScheduleTrigger, parseCreateWebhookTrigger, parsePageQuery,
 import { nextCronAt } from '../schedule.js';
 import { id, newId, page, schedule } from '../validation.js';
 export function triggerOperations(context) {
-    const { principal, repository } = context;
+    const { principal, repository, webhooks } = context;
     const unique = async (automationId, triggerId) => {
         const exists = (await repository.listTriggers(principal.userId, automationId))
             .some((trigger) => trigger.id === triggerId);
@@ -14,7 +14,7 @@ export function triggerOperations(context) {
         list: async (automationId) => {
             context.read();
             await context.exists(automationId);
-            return repository.listTriggers(principal.userId, automationId);
+            return (await repository.listTriggers(principal.userId, automationId)).map((trigger) => (trigger.kind === 'webhook' ? publicWebhook(trigger, webhooks) : trigger));
         },
         schedule: {
             create: async (automationId, input) => {
@@ -80,31 +80,36 @@ export function triggerOperations(context) {
                 const parsed = parseCreateWebhookTrigger(input);
                 if (parsed.id)
                     await unique(automationId, parsed.id);
-                return repository.createWebhookTrigger(principal.userId, automationId, {
+                return publicWebhook(await repository.createWebhookTrigger(principal.userId, automationId, {
                     id: parsed.id ? id(parsed.id, 'Webhook trigger id') : newId('webhook'),
                     source: parsed.source || '*',
                     event: parsed.event || '*',
-                    secret: parsed.secret,
+                    secret: parsed.secret ?? null,
                     enabled: parsed.enabled !== false,
-                });
+                    endpointId: webhooks.createId(),
+                }), webhooks);
             },
             list: async (automationId, query = {}) => {
                 context.read();
                 await context.exists(automationId);
-                return repository.listWebhookTriggers(principal.userId, automationId, page(parsePageQuery(query)));
+                const result = await repository.listWebhookTriggers(principal.userId, automationId, page(parsePageQuery(query)));
+                return { ...result, items: result.items.map((trigger) => publicWebhook(trigger, webhooks)) };
             },
             get: async (automationId, triggerId) => {
                 context.read();
                 await context.exists(automationId);
-                return repository.getWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
+                const trigger = await repository.getWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
+                return trigger ? publicWebhook(trigger, webhooks) : null;
             },
             update: async (automationId, triggerId, patch) => {
                 context.write();
                 await context.exists(automationId);
-                const updated = await repository.updateWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'), parseUpdateWebhookTrigger(patch));
+                const parsed = parseUpdateWebhookTrigger(patch);
+                const { rotateUrl, ...changes } = parsed;
+                const updated = await repository.updateWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'), { ...changes, ...(rotateUrl ? { endpointId: webhooks.createId() } : {}) });
                 if (!updated)
                     throw new NotFoundError('Webhook trigger');
-                return updated;
+                return publicWebhook(updated, webhooks);
             },
             delete: async (automationId, triggerId) => {
                 context.write();
@@ -116,3 +121,7 @@ export function triggerOperations(context) {
         },
     };
 }
+function publicWebhook(trigger, webhooks) {
+    const { endpointId, ...publicTrigger } = trigger;
+    return { ...publicTrigger, webhookUrl: webhooks.url(endpointId) };
+}

package/dist/src/crud.d.ts

@@ -1,9 +1,11 @@
 import type { AutomationCrud, AutomationCrudService as AutomationCrudServiceContract, AutomationPrincipal } from './contract.js';
 import type { AutomationCrudRepository } from './crud/repository.js';
-export type { AutomationCrudRepository, NormalizedListAutomations, NormalizedListRuns, StoredScheduleCreate, StoredScheduleUpdate, } from './crud/repository.js';
+import { WebhookEndpoints } from './webhook.js';
+export type { AutomationCrudRepository, NormalizedListAutomations, NormalizedListRuns, StoredScheduleCreate, StoredScheduleUpdate, StoredWebhookCreate, StoredWebhookUpdate, WebhookTriggerRecord, } from './crud/repository.js';
 export declare class AutomationCrudService implements AutomationCrudServiceContract {
+    #private;
     private readonly repository;
     private readonly clock;
-    constructor(repository: AutomationCrudRepository, clock?: () => Date);
+    constructor(repository: AutomationCrudRepository, clock?: () => Date, webhooks?: WebhookEndpoints);
     for(principal: AutomationPrincipal): AutomationCrud;
 }

package/dist/src/crud.js

@@ -3,15 +3,18 @@ import { createContext } from './crud/context.js';
 import { runOperations } from './crud/runs.js';
 import { triggerOperations } from './crud/triggers.js';
 import { workflowOperations } from './crud/workflow.js';
+import { WebhookEndpoints } from './webhook.js';
 export class AutomationCrudService {
     repository;
     clock;
-    constructor(repository, clock = () => new Date()) {
+    #webhooks;
+    constructor(repository, clock = () => new Date(), webhooks) {
         this.repository = repository;
         this.clock = clock;
+        this.#webhooks = webhooks ?? new WebhookEndpoints('http://automations.local', Buffer.from('local-automations-webhook-key-32-bytes-minimum'));
     }
     for(principal) {
-        const context = createContext(this.repository, principal, this.clock);
+        const context = createContext(this.repository, principal, this.clock, this.#webhooks);
         return {
             automations: automationOperations(context),
             triggers: triggerOperations(context),

package/dist/src/events-http.d.ts

@@ -1,19 +1,17 @@
 import { Automations } from './automations.js';
-import type { AutomationTarget } from './types.js';
+import { type WebhookEndpoints } from './webhook.js';
 export interface AutomationEventReceipt {
     receivedAt: string;
-    targetId: string;
     source: string;
     event: string;
-    runIds: string[];
+    runId?: string;
     status: 'pending' | 'unmatched';
 }
 export interface AutomationEventsApiConfig {
     delivery: Pick<Automations, 'receiveEvent'>;
-    target(request: Request): Promise<AutomationTarget>;
+    endpoints: Pick<WebhookEndpoints, 'resolve'>;
     now?: () => Date;
     maxBodyBytes?: number;
-    recentLimit?: number;
 }
 export type AutomationEventsApi = (request: Request) => Promise<Response>;
 export declare function createAutomationEventsApi(config: AutomationEventsApiConfig): AutomationEventsApi;

package/dist/src/events-http.js

@@ -1,55 +1,47 @@
-import { Automations, EventRejectedError } from './automations.js';
-import { eventReference } from './webhook.js';
+import { Automations, EventEndpointNotFoundError, EventRejectedError } from './automations.js';
+import { webhookDeliveryKey } from './webhook.js';
 // Engine reference: amalgm-engine/runtime/scripts/amalgm-mcp/events/ingress.js.
-// The 2 MiB transport bound and safe recent-events door are preserved. The
-// authority changes deliberately: success now means matching runs are durable
-// in Supabase, never that an envelope was written to a local SQLite inbox.
+// The 2 MiB transport bound is preserved. Success means the matching run is
+// durable in Supabase, never that an envelope was written to a local inbox.
 const DEFAULT_MAX_BODY_BYTES = 2 * 1024 * 1024;
-const DEFAULT_RECENT_LIMIT = 200;
 export function createAutomationEventsApi(config) {
-    const recent = [];
     const now = config.now ?? (() => new Date());
     const maxBodyBytes = positiveInteger(config.maxBodyBytes, DEFAULT_MAX_BODY_BYTES);
-    const recentLimit = positiveInteger(config.recentLimit, DEFAULT_RECENT_LIMIT);
     return async (request) => {
         const pathname = new URL(request.url).pathname;
-        if (pathname !== '/events')
+        const token = pathname.match(/^\/e\/([^/]+)$/)?.[1];
+        if (!token)
             return json(404, { error: 'not found' });
-        if (request.method === 'GET')
-            return json(200, { events: recent.slice(-50) });
         if (request.method !== 'POST')
             return json(405, { error: 'method not allowed' });
         try {
+            const endpointId = config.endpoints.resolve(token);
+            if (!endpointId)
+                throw new EventEndpointNotFoundError();
             const body = await readLimitedBody(request, maxBodyBytes);
             const payload = parsePayload(body);
             const headers = Object.fromEntries(request.headers.entries());
-            const target = await config.target(request);
             const receivedAt = now();
-            const runs = await config.delivery.receiveEvent({
-                target,
+            const admission = await config.delivery.receiveEvent({
+                endpointId,
                 headers,
                 body,
                 payload,
+                deliveryKey: webhookDeliveryKey(headers, payload),
                 now: receivedAt,
             });
-            const firstInput = runs[0]?.input;
-            const reference = firstInput?.kind === 'event'
-                ? { source: firstInput.source, event: firstInput.event }
-                : eventReference(headers, payload);
             const receipt = {
                 receivedAt: receivedAt.toISOString(),
-                targetId: target.targetId,
-                source: reference.source,
-                event: reference.event,
-                runIds: runs.map(({ id }) => id),
-                status: runs.length ? 'pending' : 'unmatched',
+                source: admission.source,
+                event: admission.event,
+                ...(admission.run ? { runId: admission.run.id } : {}),
+                status: admission.run ? 'pending' : 'unmatched',
             };
-            recent.push(receipt);
-            if (recent.length > recentLimit)
-                recent.splice(0, recent.length - recentLimit);
             return json(202, { ok: true, accepted: true, ...receipt });
         }
         catch (error) {
+            if (error instanceof EventEndpointNotFoundError)
+                return json(404, { error: error.message });
             if (error instanceof EventRejectedError)
                 return json(401, { error: error.message });
             if (error instanceof EventHttpError)

package/dist/src/http.js

@@ -1,5 +1,5 @@
 import { AutomationError } from './errors.js';
-import { parseCreateAutomation, parseCreateScheduleTrigger, parseCreateWebhookTrigger, parseCreateWorkflow, parseListAutomations, parseListRuns, parsePageQuery, parseUpdateAutomation, parseUpdateScheduleTrigger, parseUpdateWebhookTrigger, parseUpdateWorkflow, } from './schema.js';
+import { parseCreateAutomation, parseCreateScheduleTrigger, parseCreateWebhookTrigger, parseCreateWorkflow, parseListAutomations, parseListRuns, parseRunAutomationNow, parsePageQuery, parseUpdateAutomation, parseUpdateScheduleTrigger, parseUpdateWebhookTrigger, parseUpdateWorkflow, } from './schema.js';
 export function createAutomationApi(options) {
     return async (request) => {
         try {
@@ -85,6 +85,9 @@ export function createAutomationApi(options) {
                 }
             }
             if (parts[3] === 'runs') {
+                if (parts.length === 4 && method === 'POST') {
+                    return response(202, await sdk.runs.runNow(automationId, parseRunAutomationNow(await body(request))));
+                }
                 if (parts.length === 4 && method === 'GET') {
                     return response(200, await sdk.runs.list(automationId, parseListRuns({
                         ...query,

package/dist/src/index.d.ts

@@ -5,11 +5,11 @@ export { createAutomationApi, type AuthenticateAutomationRequest, type Automatio
 export { runAutomationCli } from './cli.js';
 export { createAutomationMcpServer } from './mcp.js';
 export { SupabaseAutomationCrudRepository, type SupabaseRpcClient } from './supabase-crud.js';
-export type { Automation, AutomationCrud, AutomationCrudService as AutomationCrudServiceContract, AutomationPrincipal, AutomationPlan, AutomationRunJournal, AutomationStepRun, AutomationStepStatus, AutomationRun, AutomationScope, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, Page, PageQuery, RunStatus, ScheduleTrigger, Trigger, ToolActionStep, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow, } from './contract.js';
-export { Automations, EventRejectedError } from './automations.js';
+export type { Automation, AutomationCrud, AutomationCrudService as AutomationCrudServiceContract, AutomationPrincipal, AutomationPlan, AutomationRunJournal, AutomationStepRun, AutomationStepStatus, AutomationRun, AutomationScope, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, Page, PageQuery, RunStatus, RunAutomationNow, ScheduleTrigger, Trigger, ToolActionStep, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow, } from './contract.js';
+export { Automations, EventEndpointNotFoundError, EventRejectedError } from './automations.js';
 export { createAutomationEventsApi, type AutomationEventReceipt, type AutomationEventsApi, type AutomationEventsApiConfig, } from './events-http.js';
 export { nextCronAt, validateCron } from './schedule.js';
-export { eventReference, eventReferences, matchesEvent, normalizeHeaders, verifyEventSecret, } from './webhook.js';
+export { eventReference, eventReferences, matchesEvent, normalizeHeaders, verifyEventSecret, webhookDeliveryKey, WebhookEndpoints, } from './webhook.js';
 export { SupabaseStore } from './supabase-store.js';
 export { SupabaseMachineRunRepository, type MachineRpcClient } from './supabase-machine.js';
 export { createMachineRuns } from './machine.js';
@@ -20,4 +20,4 @@ export { AutomationRunExecutor, automationPlan, type AutomationActionPort } from
 export { createAutomationMachineRunner, type AutomationMachineRunnerOptions, } from './runner.js';
 export { compiledAutomationPlan } from './plan.js';
 export type { SupabaseRpcClient as SupabaseStoreRpcClient } from './supabase-store.js';
-export type { AutomationLog, AutomationRun as AutomationRunRecord, AutomationStore, AutomationTarget, DueCronTrigger, RunInput, StoredEventTrigger, } from './types.js';
+export type { AutomationLog, AutomationRun as AutomationRunRecord, AutomationStore, DueCronTrigger, RunInput, StoredEventTrigger, } from './types.js';

package/dist/src/index.js

@@ -12,10 +12,10 @@ export { createAutomationApi } from './http.js';
 export { runAutomationCli } from './cli.js';
 export { createAutomationMcpServer } from './mcp.js';
 export { SupabaseAutomationCrudRepository } from './supabase-crud.js';
-export { Automations, EventRejectedError } from './automations.js';
+export { Automations, EventEndpointNotFoundError, EventRejectedError } from './automations.js';
 export { createAutomationEventsApi, } from './events-http.js';
 export { nextCronAt, validateCron } from './schedule.js';
-export { eventReference, eventReferences, matchesEvent, normalizeHeaders, verifyEventSecret, } from './webhook.js';
+export { eventReference, eventReferences, matchesEvent, normalizeHeaders, verifyEventSecret, webhookDeliveryKey, WebhookEndpoints, } from './webhook.js';
 export { SupabaseStore } from './supabase-store.js';
 export { SupabaseMachineRunRepository } from './supabase-machine.js';
 export { createMachineRuns } from './machine.js';

package/dist/src/mcp.js

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod/v3';
-import { createAutomationSchema, createScheduleTriggerSchema, createWebhookTriggerSchema, createWorkflowSchema, identifierSchema, listAutomationsSchema, listRunsSchema, updateAutomationSchema, updateScheduleTriggerSchema, updateWebhookTriggerSchema, updateWorkflowSchema, } from './schema.js';
+import { createAutomationSchema, createScheduleTriggerSchema, createWebhookTriggerSchema, createWorkflowSchema, identifierSchema, listAutomationsSchema, listRunsSchema, runAutomationNowSchema, updateAutomationSchema, updateScheduleTriggerSchema, updateWebhookTriggerSchema, updateWorkflowSchema, } from './schema.js';
 import { createAutomationToolSurface } from './tool-surface.js';
 export { createAutomationToolSurface };
 const resultSchema = { result: z.unknown() };
@@ -46,6 +46,14 @@ export function createAutomationMcpServer(sdk) {
     register(server, 'amalgm_automations_delete', 'Delete automation', 'Delete an automation and its current triggers and workflow. Historical runs remain.', {
         automation_id: identifierSchema,
     }, destructive(), ({ automation_id }) => tools.delete(automation_id));
+    register(server, 'amalgm_automations_run_now', 'Run automation now', 'Durably admit one manual run using the automation\'s current enabled configuration and compiled workflow. The selected machine executes it through the normal pending-run queue; this call never executes the workflow inline.', {
+        automation_id: identifierSchema,
+        input: runAutomationNowSchema.shape.input,
+        idempotency_key: runAutomationNowSchema.shape.idempotencyKey,
+    }, write(false), ({ automation_id, input, idempotency_key }) => tools.runNow(automation_id, {
+        ...(input === undefined ? {} : { input }),
+        ...(idempotency_key === undefined ? {} : { idempotencyKey: idempotency_key }),
+    }));
     return server;
 }
 function register(server, name, title, description, inputSchema, annotations, handler) {

package/dist/src/run-contract.d.ts

@@ -44,3 +44,9 @@ export interface AutomationRun {
 export interface ListRuns extends PageQuery {
     status?: RunStatus;
 }
+export interface RunAutomationNow {
+    /** Trigger payload recorded with the immutable run snapshot. */
+    input?: Json;
+    /** Reusing this key for the same automation returns the same admitted run. */
+    idempotencyKey?: string;
+}

package/dist/src/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod/v3';
-import type { CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, PageQuery, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow } from './contract.js';
+import type { CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, PageQuery, RunAutomationNow, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow } from './contract.js';
 export declare const identifierSchema: z.ZodString;
 export declare const pageQuerySchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
@@ -122,46 +122,51 @@ export declare const createWebhookTriggerSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     event: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    secret: z.ZodString;
+    secret: z.ZodOptional<z.ZodString>;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    secret: string;
     enabled?: boolean | undefined;
     event?: string | undefined;
-    source?: string | undefined;
+    secret?: string | undefined;
     id?: string | undefined;
+    source?: string | undefined;
 }, {
-    secret: string;
     enabled?: boolean | undefined;
     event?: string | undefined;
-    source?: string | undefined;
+    secret?: string | undefined;
     id?: string | undefined;
+    source?: string | undefined;
 }>;
 export declare const updateWebhookTriggerSchema: z.ZodEffects<z.ZodObject<{
     source: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     event: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    secret: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    rotateUrl: z.ZodOptional<z.ZodBoolean>;
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }>, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }, {
     enabled?: boolean | undefined;
     event?: string | undefined;
-    secret?: string | undefined;
+    secret?: string | null | undefined;
     source?: string | undefined;
+    rotateUrl?: boolean | undefined;
 }>;
 export declare const createWorkflowSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -173,15 +178,15 @@ export declare const createWorkflowSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     script: string;
     name?: string | undefined;
-    compiled?: Json | undefined;
     id?: string | undefined;
+    compiled?: Json | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }, {
     script: string;
     name?: string | undefined;
-    compiled?: Json | undefined;
     id?: string | undefined;
+    compiled?: Json | undefined;
     allowlist?: Json | undefined;
     limits?: Json | undefined;
 }>;
@@ -230,6 +235,16 @@ export declare const listRunsSchema: z.ZodObject<{
     limit?: number | undefined;
     offset?: number | undefined;
 }>;
+export declare const runAutomationNowSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    input?: Json | undefined;
+    idempotencyKey?: string | undefined;
+}, {
+    input?: Json | undefined;
+    idempotencyKey?: string | undefined;
+}>;
 export declare function parseCreateAutomation(value: unknown): CreateAutomation;
 export declare function parseUpdateAutomation(value: unknown): UpdateAutomation;
 export declare function parseListAutomations(value: unknown): ListAutomations;
@@ -241,4 +256,5 @@ export declare function parseCreateWorkflow(value: unknown): CreateWorkflow;
 export declare function parseUpdateWorkflow(value: unknown): UpdateWorkflow;
 export declare function parsePageQuery(value: unknown): PageQuery;
 export declare function parseListRuns(value: unknown): ListRuns;
+export declare function parseRunAutomationNow(value: unknown): RunAutomationNow;
 export declare function parse<T>(schema: z.ZodType<T>, value: unknown): T;

package/dist/src/schema.js

@@ -54,13 +54,14 @@ export const createWebhookTriggerSchema = z.object({
     id: identifierSchema.optional(),
     source: text(200, 'Webhook source').optional(),
     event: text(200, 'Webhook event').optional(),
-    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long'),
+    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long').optional(),
     enabled: z.boolean().optional(),
 }).strict();
 export const updateWebhookTriggerSchema = z.object({
     source: text(200, 'Webhook source').optional(),
     event: text(200, 'Webhook event').optional(),
-    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long').optional(),
+    secret: z.string().min(16, 'Webhook secret must be at least 16 characters').max(10_000, 'Webhook secret is too long').nullable().optional(),
+    rotateUrl: z.boolean().optional(),
     enabled: z.boolean().optional(),
 }).strict().refine((patch) => Object.keys(patch).length > 0, 'Webhook trigger update must include a change');
 export const createWorkflowSchema = z.object({
@@ -81,6 +82,10 @@ export const updateWorkflowSchema = z.object({
 export const listRunsSchema = pageQuerySchema.extend({
     status: z.enum(['pending', 'sent', 'running', 'completed', 'failed']).optional(),
 }).strict();
+export const runAutomationNowSchema = z.object({
+    input: jsonSchema.optional(),
+    idempotencyKey: z.string().min(1).max(500).optional(),
+}).strict();
 export function parseCreateAutomation(value) {
     return parse(createAutomationSchema, value);
 }
@@ -120,6 +125,9 @@ export function parsePageQuery(value) {
 export function parseListRuns(value) {
     return parse(listRunsSchema, value);
 }
+export function parseRunAutomationNow(value) {
+    return parse(runAutomationNowSchema, value);
+}
 export function parse(schema, value) {
     const result = schema.safeParse(value);
     if (result.success)

package/dist/src/supabase-crud/mappers.d.ts

@@ -1,8 +1,9 @@
-import type { Automation, AutomationRun, Page, PageQuery, ScheduleTrigger, WebhookTrigger, Workflow } from '../contract.js';
+import type { Automation, AutomationRun, Page, PageQuery, ScheduleTrigger, Workflow } from '../contract.js';
+import type { WebhookTriggerRecord } from '../crud/repository.js';
 import type { AutomationRow, PageResult, RunRow, TriggerRow, WorkflowRow } from './rows.js';
 export declare function automation(row: AutomationRow): Automation;
 export declare function schedule(row: TriggerRow): ScheduleTrigger;
-export declare function webhook(row: TriggerRow): WebhookTrigger;
+export declare function webhook(row: TriggerRow): WebhookTriggerRecord;
 export declare function workflow(row: WorkflowRow): Workflow;
 export declare function run(row: RunRow): AutomationRun;
 export declare function paged<T, U>(result: PageResult<T>, mapper: (row: T) => U, query: Required<PageQuery>): Page<U>;

package/dist/src/supabase-crud/mappers.js

@@ -25,6 +25,8 @@ export function schedule(row) {
     };
 }
 export function webhook(row) {
+    if (!row.endpoint_id)
+        throw new Error('Webhook trigger is missing its endpoint id');
     return {
         id: row.id,
         automationId: row.automation_id,
@@ -32,6 +34,7 @@ export function webhook(row) {
         enabled: row.enabled,
         source: row.source,
         event: row.event,
+        endpointId: row.endpoint_id,
         secretConfigured: row.secret_configured,
         createdAt: timestamp(row.created_at),
         updatedAt: timestamp(row.updated_at),

package/dist/src/supabase-crud/rows.d.ts

@@ -20,6 +20,7 @@ export type TriggerRow = {
     remaining_occurrences: number | null;
     source: string | null;
     event: string | null;
+    endpoint_id: string | null;
     secret_configured: boolean;
     created_at: Date | string;
     updated_at: Date | string;

package/dist/src/supabase-crud/workflow-runs.d.ts

@@ -1,5 +1,5 @@
 import type { AutomationCrudRepository } from '../crud.js';
 import { type SupabaseRpcClient } from './rpc.js';
-type Operations = Pick<AutomationCrudRepository, 'createWorkflow' | 'getWorkflow' | 'updateWorkflow' | 'deleteWorkflow' | 'listRuns' | 'getRun'>;
+type Operations = Pick<AutomationCrudRepository, 'createWorkflow' | 'getWorkflow' | 'updateWorkflow' | 'deleteWorkflow' | 'listRuns' | 'getRun' | 'runAutomationNow'>;
 export declare function workflowRunRepository(client: SupabaseRpcClient): Operations;
 export {};

package/dist/src/supabase-crud/workflow-runs.js

@@ -37,5 +37,15 @@ export function workflowRunRepository(client) {
             });
             return row ? run(row) : null;
         },
+        runAutomationNow: async (userId, automationId, input, idempotencyKey, now) => {
+            const rows = await call(client, 'enqueue_amalgm_manual_run', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+                p_input: input,
+                p_idempotency_key: idempotencyKey,
+                p_now: now.toISOString(),
+            });
+            return rows[0] ? run(rows[0]) : null;
+        },
     };
 }

package/dist/src/supabase-store.d.ts

@@ -1,4 +1,4 @@
-import type { AutomationStore, AutomationTarget, AutomationRun, DueCronTrigger, RunInput, StoredEventTrigger } from './types.js';
+import type { AutomationStore, AutomationRun, DueCronTrigger, RunInput, StoredEventTrigger } from './types.js';
 export interface SupabaseRpcClient {
     rpc(functionName: string, arguments_: Record<string, unknown>): PromiseLike<{
         data: unknown;
@@ -11,10 +11,10 @@ export declare class SupabaseStore implements AutomationStore {
     #private;
     readonly client: SupabaseRpcClient;
     constructor(client: SupabaseRpcClient);
-    eventTriggers(target: AutomationTarget): Promise<StoredEventTrigger[]>;
+    eventTrigger(endpointId: string): Promise<StoredEventTrigger | null>;
     dueCronTriggers(now: Date): Promise<DueCronTrigger[]>;
     enqueueEvent(trigger: StoredEventTrigger, input: Extract<RunInput, {
         kind: 'event';
-    }>, now: Date): Promise<AutomationRun | null>;
+    }>, now: Date, deliveryKey: string | null): Promise<AutomationRun | null>;
     enqueueCron(trigger: DueCronTrigger, nextRunAt: string, now: Date): Promise<AutomationRun | null>;
 }

package/dist/src/supabase-store.js

@@ -22,13 +22,14 @@ export class SupabaseStore {
     constructor(client) {
         this.client = client;
     }
-    async eventTriggers(target) {
-        const rows = await this.#call('list_amalgm_event_triggers', {
-            p_user_id: target.userId,
-            p_target_id: target.targetId,
+    async eventTrigger(endpointId) {
+        const rows = await this.#call('resolve_amalgm_webhook', {
+            p_endpoint_id: endpointId,
         });
-        return rows.map((row) => ({
+        const row = rows[0];
+        return row ? {
             kind: 'event',
+            endpointId: row.endpoint_id,
             userId: row.user_id,
             automationId: row.automation_id,
             triggerId: row.trigger_id,
@@ -36,7 +37,7 @@ export class SupabaseStore {
             source: row.source,
             event: row.event,
             secret: row.secret,
-        }));
+        } : null;
     }
     async dueCronTriggers(now) {
         const rows = await this.#call('list_due_amalgm_crons', { p_now: now.toISOString() });
@@ -52,22 +53,24 @@ export class SupabaseStore {
             ...(row.remaining_occurrences === null ? {} : { remainingOccurrences: row.remaining_occurrences }),
         }));
     }
-    enqueueEvent(trigger, input, now) {
-        return this.#enqueue(trigger, input, now, null);
+    enqueueEvent(trigger, input, now, deliveryKey) {
+        return this.#enqueue(trigger, input, now, null, deliveryKey);
     }
     enqueueCron(trigger, nextRunAt, now) {
         return this.#enqueue(trigger, {
             kind: 'cron',
             scheduledFor: trigger.nextRunAt,
-        }, now, nextRunAt);
+        }, now, nextRunAt, null);
     }
-    async #enqueue(trigger, input, now, nextRunAt) {
+    async #enqueue(trigger, input, now, nextRunAt, deliveryKey) {
         const rows = await this.#call('enqueue_amalgm_run', {
             p_kind: trigger.kind,
             p_user_id: trigger.userId,
             p_automation_id: trigger.automationId,
             p_trigger_id: trigger.triggerId,
             p_target_id: trigger.targetId,
+            p_endpoint_id: trigger.kind === 'event' ? trigger.endpointId : null,
+            p_delivery_key: deliveryKey,
             p_expected_next_run_at: trigger.kind === 'cron' ? trigger.nextRunAt : null,
             p_next_run_at: nextRunAt,
             p_input: input,

package/dist/src/tool-surface.d.ts

@@ -41,6 +41,7 @@ export interface AutomationToolSurface {
     delete(automationId: string): Promise<{
         deleted: string;
     }>;
+    runNow(automationId: string, input?: Parameters<AutomationCrud['runs']['runNow']>[1]): Promise<AutomationRun>;
 }
 export declare function createAutomationToolSurface(sdk: AutomationCrud): AutomationToolSurface;
 export {};

package/dist/src/tool-surface.js

@@ -69,6 +69,7 @@ export function createAutomationToolSurface(sdk) {
             await sdk.automations.delete(automationId);
             return { deleted: automationId };
         },
+        runNow: (automationId, input = {}) => sdk.runs.runNow(automationId, input),
     };
     return Object.freeze(surface);
 }