@amalgm/automations 0.1.1 → 0.2.0

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

@@ -0,0 +1,19 @@
+import { Automations } from './automations.js';
+import type { AutomationTarget } from './types.js';
+export interface AutomationEventReceipt {
+    receivedAt: string;
+    targetId: string;
+    source: string;
+    event: string;
+    runIds: string[];
+    status: 'pending' | 'unmatched';
+}
+export interface AutomationEventsApiConfig {
+    delivery: Pick<Automations, 'receiveEvent'>;
+    target(request: Request): Promise<AutomationTarget>;
+    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

@@ -0,0 +1,107 @@
+import { Automations, EventRejectedError } from './automations.js';
+import { eventReference } 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.
+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')
+            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 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,
+                headers,
+                body,
+                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',
+            };
+            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 EventRejectedError)
+                return json(401, { error: error.message });
+            if (error instanceof EventHttpError)
+                return json(error.status, { error: error.message });
+            return json(500, { error: error instanceof Error ? error.message : String(error) });
+        }
+    };
+}
+class EventHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'EventHttpError';
+    }
+}
+async function readLimitedBody(request, limit) {
+    if (!request.body)
+        return Buffer.alloc(0);
+    const reader = request.body.getReader();
+    const chunks = [];
+    let size = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const chunk = Buffer.from(value);
+        size += chunk.length;
+        if (size > limit) {
+            await reader.cancel();
+            throw new EventHttpError(413, `Event body exceeds ${limit} bytes`);
+        }
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+function parsePayload(body) {
+    if (body.length === 0)
+        return {};
+    try {
+        return JSON.parse(body.toString('utf8'));
+    }
+    catch {
+        throw new EventHttpError(400, 'Event body must be valid JSON');
+    }
+}
+function positiveInteger(value, fallback) {
+    return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function json(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json' },
+    });
+}

package/dist/src/executor.d.ts

@@ -0,0 +1,16 @@
+import type { AutomationPlan, Json } from './contract.js';
+import type { ClaimedAutomationRun, MachineRuns } from './machine.js';
+export interface AutomationActionPort {
+    call(input: Readonly<{
+        actionId: string;
+        payload: Json;
+        idempotencyKey: string;
+    }>): Promise<Json>;
+}
+export declare class AutomationRunExecutor {
+    private readonly runs;
+    private readonly actions;
+    constructor(runs: MachineRuns, actions: AutomationActionPort);
+    execute(run: ClaimedAutomationRun): Promise<void>;
+}
+export declare function automationPlan(snapshot: Json): AutomationPlan;

package/dist/src/executor.js

@@ -0,0 +1,76 @@
+export class AutomationRunExecutor {
+    runs;
+    actions;
+    constructor(runs, actions) {
+        this.runs = runs;
+        this.actions = actions;
+    }
+    async execute(run) {
+        await this.runs.update(run.id, { leaseToken: run.leaseToken, status: 'running' });
+        try {
+            const plan = automationPlan(run.automation);
+            const steps = [];
+            for (const step of plan.steps) {
+                const output = await this.actions.call({
+                    actionId: step.actionId,
+                    payload: step.input,
+                    idempotencyKey: `${run.id}:${step.id}`,
+                });
+                steps.push({ id: step.id, output });
+            }
+            await this.runs.update(run.id, {
+                leaseToken: run.leaseToken,
+                status: 'completed',
+                output: { steps },
+            });
+        }
+        catch (error) {
+            await this.runs.update(run.id, {
+                leaseToken: run.leaseToken,
+                status: 'failed',
+                error: safeError(error),
+            });
+        }
+    }
+}
+export function automationPlan(snapshot) {
+    const root = record(snapshot, 'Automation snapshot');
+    const workflow = record(root.workflow, 'Workflow snapshot');
+    const compiled = record(workflow.compiled, 'Compiled workflow');
+    if (compiled.version !== 1 || !Array.isArray(compiled.steps) || compiled.steps.length > 100) {
+        throw new Error('Compiled workflow must be a version 1 plan with at most 100 steps');
+    }
+    return {
+        version: 1,
+        steps: compiled.steps.map((value, index) => step(value, index)),
+    };
+}
+function step(value, index) {
+    const item = record(value, `Workflow step ${index + 1}`);
+    if (typeof item.id !== 'string' || !item.id.trim())
+        throw new Error(`Workflow step ${index + 1} needs an id`);
+    if (typeof item.actionId !== 'string' || !item.actionId.includes('.')) {
+        throw new Error(`Workflow step ${index + 1} needs a qualified actionId`);
+    }
+    assertJson(item.input);
+    return { id: item.id, actionId: item.actionId, input: item.input };
+}
+function record(value, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${name} is missing`);
+    return value;
+}
+function assertJson(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return;
+    if (Array.isArray(value))
+        return void value.forEach(assertJson);
+    if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+        return void Object.values(value).forEach(assertJson);
+    }
+    throw new Error('Workflow step input must be JSON');
+}
+const safeError = (error) => (error instanceof Error ? error.message : String(error))
+    .replace(/[\r\n]+/g, ' ').slice(0, 1_000);

package/dist/src/index.d.ts

@@ -1,14 +1,21 @@
-export { createAutomationClient, type AutomationAuthorization } from './client.js';
+export { createAutomationClient, type AutomationAuthorization, type AutomationHeaders } from './client.js';
 export { AutomationCrudService, type AutomationCrudRepository } from './crud.js';
 export { AutomationError, ConflictError, ForbiddenError, NotFoundError, ValidationError, type AutomationErrorCode, } from './errors.js';
 export { createAutomationApi, type AuthenticateAutomationRequest, type AutomationApi } from './http.js';
 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, AutomationRun, AutomationScope, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, Page, PageQuery, RunStatus, ScheduleTrigger, Trigger, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow, } from './contract.js';
+export type { Automation, AutomationCrud, AutomationCrudService as AutomationCrudServiceContract, AutomationPrincipal, AutomationPlan, 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 { 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 { SupabaseStore } from './supabase-store.js';
+export { SupabaseMachineRunRepository, type MachineRpcClient } from './supabase-machine.js';
+export { createMachineRuns } from './machine.js';
+export type { AutomationMachinePrincipal, ClaimedAutomationRun, MachineRunRepository, MachineRuns, MachineRunUpdate, } from './machine.js';
+export { createMachineRunsApi } from './machine-http.js';
+export { createMachineRunsClient, type AutomationRequestHeaders } from './machine-client.js';
+export { AutomationRunExecutor, automationPlan, type AutomationActionPort } from './executor.js';
 export type { SupabaseRpcClient as SupabaseStoreRpcClient } from './supabase-store.js';
 export type { AutomationLog, AutomationRun as AutomationRunRecord, AutomationStore, AutomationTarget, AutomationTransport, DueCronTrigger, RunInput, RunUpdate, StoredEventTrigger, } from './types.js';

package/dist/src/index.js

@@ -13,6 +13,12 @@ export { runAutomationCli } from './cli.js';
 export { createAutomationMcpServer } from './mcp.js';
 export { SupabaseAutomationCrudRepository } from './supabase-crud.js';
 export { Automations, 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 { SupabaseStore } from './supabase-store.js';
+export { SupabaseMachineRunRepository } from './supabase-machine.js';
+export { createMachineRuns } from './machine.js';
+export { createMachineRunsApi } from './machine-http.js';
+export { createMachineRunsClient } from './machine-client.js';
+export { AutomationRunExecutor, automationPlan } from './executor.js';

package/dist/src/machine-client.d.ts

@@ -0,0 +1,7 @@
+import type { MachineRuns } from './machine.js';
+export type AutomationRequestHeaders = (method: string, url: string) => Promise<Readonly<Record<string, string>>> | Readonly<Record<string, string>>;
+export declare function createMachineRunsClient(options: {
+    readonly baseUrl: string;
+    readonly headers: AutomationRequestHeaders;
+    readonly fetch?: typeof globalThis.fetch;
+}): MachineRuns;

package/dist/src/machine-client.js

@@ -0,0 +1,30 @@
+import { AutomationError } from './errors.js';
+export function createMachineRunsClient(options) {
+    const baseUrl = options.baseUrl.replace(/\/$/, '');
+    const fetch = options.fetch ?? globalThis.fetch;
+    const request = async (path, method, body) => {
+        const url = `${baseUrl}${path}`;
+        const response = await fetch(url, {
+            method,
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                ...await options.headers(method, url),
+            },
+            body: JSON.stringify(body),
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok)
+            throw new AutomationError(response.status === 403 ? 'forbidden' : response.status >= 500 ? 'internal' : 'validation', payload.error ?? `Automations API returned ${response.status}`);
+        return payload;
+    };
+    return Object.freeze({
+        async claim(input = {}) {
+            const result = await request('/v1/machine/runs/claim', 'POST', input);
+            return result.runs;
+        },
+        update(runId, update) {
+            return request(`/v1/machine/runs/${encodeURIComponent(runId)}`, 'PATCH', update);
+        },
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { AutomationMachinePrincipal, MachineRuns } from './machine.js';
+export declare function createMachineRunsApi(options: {
+    readonly authenticate: (request: Request) => Promise<AutomationMachinePrincipal>;
+    readonly runsFor: (principal: AutomationMachinePrincipal) => MachineRuns;
+}): (request: Request) => Promise<Response>;

package/dist/src/machine-http.js

@@ -0,0 +1,40 @@
+import { AutomationError, ValidationError } from './errors.js';
+export function createMachineRunsApi(options) {
+    return async (request) => {
+        try {
+            const url = new URL(request.url);
+            const parts = url.pathname.split('/').filter(Boolean).map(decodeURIComponent);
+            if (parts[0] !== 'v1' || parts[1] !== 'machine' || parts[2] !== 'runs') {
+                return json(404, { error: 'Not found' });
+            }
+            const runs = options.runsFor(await options.authenticate(request));
+            if (parts[3] === 'claim' && parts.length === 4 && request.method === 'POST') {
+                return json(200, { runs: await runs.claim(await body(request)) });
+            }
+            if (parts[3] && parts.length === 4 && request.method === 'PATCH') {
+                return json(200, await runs.update(parts[3], await body(request)));
+            }
+            return json(405, { error: 'Method not allowed' });
+        }
+        catch (error) {
+            if (error instanceof AutomationError)
+                return json(error.code === 'validation' ? 400 : 403, {
+                    error: error.message, code: error.code,
+                });
+            const code = error instanceof Error && 'code' in error ? String(error.code) : 'internal';
+            return json(code.startsWith('dpop_') || code.includes('access') ? 401 : 500, {
+                error: code === 'internal' ? 'Automations service failed' : 'Authorization denied', code,
+            });
+        }
+    };
+}
+async function body(request) {
+    const value = await request.json().catch(() => null);
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new ValidationError('Request body must be a JSON object');
+    }
+    return value;
+}
+function json(status, value) {
+    return Response.json(value, { status, headers: { 'cache-control': 'no-store' } });
+}

package/dist/src/machine.d.ts

@@ -0,0 +1,41 @@
+import type { AutomationScope, Json, RunStatus } from './contract.js';
+import type { AutomationRun } from './types.js';
+export interface AutomationMachinePrincipal {
+    readonly userId: string;
+    readonly computerId: string;
+    readonly scopes: readonly AutomationScope[];
+}
+export interface ClaimedAutomationRun extends AutomationRun {
+    readonly leaseToken: string;
+    readonly leaseExpiresAt: string;
+    readonly attempts: number;
+}
+export interface MachineRunUpdate {
+    readonly leaseToken: string;
+    readonly status: Extract<RunStatus, 'running' | 'completed' | 'failed'>;
+    readonly output?: Json;
+    readonly error?: string;
+}
+export interface MachineRuns {
+    claim(input?: {
+        readonly limit?: number;
+        readonly leaseSeconds?: number;
+    }): Promise<readonly ClaimedAutomationRun[]>;
+    update(runId: string, update: MachineRunUpdate): Promise<ClaimedAutomationRun | null>;
+}
+export interface MachineRunRepository {
+    claim(input: Readonly<{
+        userId: string;
+        targetId: string;
+        limit: number;
+        leaseSeconds: number;
+    }>): Promise<readonly ClaimedAutomationRun[]>;
+    update(input: Readonly<{
+        userId: string;
+        targetId: string;
+        runId: string;
+        update: MachineRunUpdate;
+        now: Date;
+    }>): Promise<ClaimedAutomationRun | null>;
+}
+export declare function createMachineRuns(repository: MachineRunRepository, principal: AutomationMachinePrincipal, now?: () => Date): MachineRuns;

package/dist/src/machine.js

@@ -0,0 +1,43 @@
+import { ForbiddenError, ValidationError } from './errors.js';
+export function createMachineRuns(repository, principal, now = () => new Date()) {
+    requireScope(principal, 'runs:execute');
+    return Object.freeze({
+        async claim(input = {}) {
+            const limit = input.limit ?? 5;
+            const leaseSeconds = input.leaseSeconds ?? 300;
+            integer(limit, 1, 20, 'limit');
+            integer(leaseSeconds, 30, 900, 'leaseSeconds');
+            return repository.claim({
+                userId: principal.userId,
+                targetId: principal.computerId,
+                limit,
+                leaseSeconds,
+            });
+        },
+        async update(runId, update) {
+            if (!runId.trim() || !update.leaseToken.trim()) {
+                throw new ValidationError('Run id and lease token are required');
+            }
+            if (!['running', 'completed', 'failed'].includes(update.status)) {
+                throw new ValidationError('Run status is invalid');
+            }
+            return repository.update({
+                userId: principal.userId,
+                targetId: principal.computerId,
+                runId,
+                update,
+                now: now(),
+            });
+        },
+    });
+}
+function requireScope(principal, scope) {
+    if (!principal.scopes.includes('*') && !principal.scopes.includes(scope)) {
+        throw new ForbiddenError(`Missing scope: ${scope}`);
+    }
+}
+function integer(value, minimum, maximum, name) {
+    if (!Number.isInteger(value) || value < minimum || value > maximum) {
+        throw new ValidationError(`${name} must be an integer from ${minimum} to ${maximum}`);
+    }
+}

package/dist/src/mcp.js

@@ -16,7 +16,7 @@ export function createAutomationMcpServer(sdk) {
         return { deleted: automation_id };
     });
     register(server, 'amalgm_automation_triggers_list', 'List automation triggers', 'List all schedule and webhook triggers belonging to one automation.', automationIdInput, read(), ({ automation_id }) => sdk.triggers.list(automation_id));
-    register(server, 'amalgm_schedule_triggers_create', 'Create schedule trigger', 'Create a cron schedule trigger for one automation.', { automation_id: identifierSchema, input: createScheduleTriggerSchema }, write(false), ({ automation_id, input }) => sdk.triggers.schedule.create(automation_id, input));
+    register(server, 'amalgm_schedule_triggers_create', 'Create schedule trigger', 'Create a cron schedule trigger for one automation. Set maxOccurrences for a bounded request such as “every minute for ten minutes”; the service disables it after exactly that many admitted runs.', { automation_id: identifierSchema, input: createScheduleTriggerSchema }, write(false), ({ automation_id, input }) => sdk.triggers.schedule.create(automation_id, input));
     register(server, 'amalgm_schedule_triggers_list', 'List schedule triggers', 'List schedule triggers for one automation.', { automation_id: identifierSchema, query: pageQuerySchema.optional() }, read(), ({ automation_id, query }) => sdk.triggers.schedule.list(automation_id, query));
     register(server, 'amalgm_schedule_triggers_get', 'Get schedule trigger', 'Get one schedule trigger by automation and trigger id.', triggerIdInput, read(), ({ automation_id, trigger_id }) => sdk.triggers.schedule.get(automation_id, trigger_id));
     register(server, 'amalgm_schedule_triggers_update', 'Update schedule trigger', 'Update a cron schedule trigger without changing its type.', { automation_id: identifierSchema, trigger_id: identifierSchema, patch: updateScheduleTriggerSchema }, write(true), ({ automation_id, trigger_id, patch }) => sdk.triggers.schedule.update(automation_id, trigger_id, patch));
@@ -32,7 +32,7 @@ export function createAutomationMcpServer(sdk) {
         await sdk.triggers.webhook.delete(automation_id, trigger_id);
         return { deleted: trigger_id };
     });
-    register(server, 'amalgm_workflow_create', 'Create automation workflow', 'Create the one workflow script owned by an automation.', { automation_id: identifierSchema, input: createWorkflowSchema }, write(false), ({ automation_id, input }) => sdk.workflow.create(automation_id, input));
+    register(server, 'amalgm_workflow_create', 'Create automation workflow', 'Create the one workflow owned by an automation. For tool execution, compiled must be {version:1,steps:[{id,actionId,input}]}; for a reminder use actionId “channels.notify_user” and input {message,title?}.', { automation_id: identifierSchema, input: createWorkflowSchema }, write(false), ({ automation_id, input }) => sdk.workflow.create(automation_id, input));
     register(server, 'amalgm_workflow_get', 'Get automation workflow', 'Get the workflow script owned by an automation.', automationIdInput, read(), ({ automation_id }) => sdk.workflow.get(automation_id));
     register(server, 'amalgm_workflow_update', 'Update automation workflow', 'Update the workflow script or its configuration.', { automation_id: identifierSchema, patch: updateWorkflowSchema }, write(true), ({ automation_id, patch }) => sdk.workflow.update(automation_id, patch));
     register(server, 'amalgm_workflow_delete', 'Delete automation workflow', 'Delete the workflow script. The automation and its triggers remain.', automationIdInput, destructive(), async ({ automation_id }) => {

package/dist/src/schema.d.ts

@@ -78,37 +78,45 @@ export declare const createScheduleTriggerSchema: z.ZodObject<{
     cron: z.ZodEffects<z.ZodString, string, string>;
     timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    maxOccurrences: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     id?: string | undefined;
     cron: string;
     timezone?: string | undefined;
     enabled?: boolean | undefined;
+    maxOccurrences?: number | undefined;
 }, {
     id?: string | undefined;
     cron: string;
     timezone?: string | undefined;
     enabled?: boolean | undefined;
+    maxOccurrences?: number | undefined;
 }>;
 export declare const updateScheduleTriggerSchema: z.ZodEffects<z.ZodObject<{
     cron: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    maxOccurrences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, "strict", z.ZodTypeAny, {
     cron?: string | undefined;
     timezone?: string | undefined;
     enabled?: boolean | undefined;
+    maxOccurrences?: number | null | undefined;
 }, {
     cron?: string | undefined;
     timezone?: string | undefined;
     enabled?: boolean | undefined;
+    maxOccurrences?: number | null | undefined;
 }>, {
     cron?: string | undefined;
     timezone?: string | undefined;
     enabled?: boolean | undefined;
+    maxOccurrences?: number | null | undefined;
 }, {
     cron?: string | undefined;
     timezone?: string | undefined;
     enabled?: boolean | undefined;
+    maxOccurrences?: number | null | undefined;
 }>;
 export declare const createWebhookTriggerSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;

package/dist/src/schema.js

@@ -41,11 +41,13 @@ export const createScheduleTriggerSchema = z.object({
     cron: text(200, 'Schedule cron'),
     timezone: text(200, 'Schedule timezone').optional(),
     enabled: z.boolean().optional(),
+    maxOccurrences: z.number().int().min(1).max(100_000).optional(),
 }).strict();
 export const updateScheduleTriggerSchema = z.object({
     cron: text(200, 'Schedule cron').optional(),
     timezone: text(200, 'Schedule timezone').optional(),
     enabled: z.boolean().optional(),
+    maxOccurrences: z.number().int().min(1).max(100_000).nullable().optional(),
 }).strict().refine((patch) => Object.keys(patch).length > 0, 'Schedule trigger update must include a change');
 export const createWebhookTriggerSchema = z.object({
     id: identifierSchema.optional(),

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

@@ -0,0 +1,5 @@
+import type { AutomationCrudRepository } from '../crud.js';
+import { type SupabaseRpcClient } from './rpc.js';
+type Operations = Pick<AutomationCrudRepository, 'createAutomation' | 'listAutomations' | 'getAutomation' | 'updateAutomation' | 'deleteAutomation'>;
+export declare function automationRepository(client: SupabaseRpcClient): Operations;
+export {};

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

@@ -0,0 +1,36 @@
+import { automation, paged } from './mappers.js';
+import { call } from './rpc.js';
+export function automationRepository(client) {
+    return {
+        createAutomation: async (userId, input) => automation(await call(client, 'create_amalgm_automation', {
+            p_user_id: userId,
+            p_automation: input,
+        })),
+        listAutomations: async (userId, query) => paged(await call(client, 'list_amalgm_automations', {
+            p_user_id: userId,
+            p_target_id: query.targetId || null,
+            p_enabled: query.enabled ?? null,
+            p_limit: query.limit,
+            p_offset: query.offset,
+        }), automation, query),
+        getAutomation: async (userId, automationId) => {
+            const row = await call(client, 'get_amalgm_automation', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+            });
+            return row ? automation(row) : null;
+        },
+        updateAutomation: async (userId, automationId, patch) => {
+            const row = await call(client, 'update_amalgm_automation', {
+                p_user_id: userId,
+                p_automation_id: automationId,
+                p_patch: patch,
+            });
+            return row ? automation(row) : null;
+        },
+        deleteAutomation: (userId, automationId) => call(client, 'delete_amalgm_automation', {
+            p_user_id: userId,
+            p_automation_id: automationId,
+        }),
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { Automation, AutomationRun, Page, PageQuery, ScheduleTrigger, WebhookTrigger, Workflow } from '../contract.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 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

@@ -0,0 +1,81 @@
+export function automation(row) {
+    return {
+        id: row.id,
+        targetId: row.target_id,
+        ...(row.name ? { name: row.name } : {}),
+        ...(row.description ? { description: row.description } : {}),
+        enabled: row.enabled,
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+export function schedule(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        kind: 'schedule',
+        enabled: row.enabled,
+        cron: row.cron,
+        timezone: row.timezone,
+        nextRunAt: timestamp(row.next_run_at),
+        ...(row.max_occurrences === null ? {} : { maxOccurrences: row.max_occurrences }),
+        ...(row.remaining_occurrences === null ? {} : { remainingOccurrences: row.remaining_occurrences }),
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+export function webhook(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        kind: 'webhook',
+        enabled: row.enabled,
+        source: row.source,
+        event: row.event,
+        secretConfigured: row.secret_configured,
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+export function workflow(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        ...(row.name ? { name: row.name } : {}),
+        script: row.script,
+        ...(row.compiled !== null ? { compiled: row.compiled } : {}),
+        ...(row.allowlist !== null ? { allowlist: row.allowlist } : {}),
+        ...(row.limits !== null ? { limits: row.limits } : {}),
+        createdAt: timestamp(row.created_at),
+        updatedAt: timestamp(row.updated_at),
+    };
+}
+export function run(row) {
+    return {
+        id: row.id,
+        automationId: row.automation_id,
+        triggerId: row.trigger_id,
+        workflowId: row.workflow_id,
+        targetId: row.target_id,
+        status: row.status,
+        input: row.input,
+        createdAt: timestamp(row.created_at),
+        ...(row.sent_at ? { sentAt: timestamp(row.sent_at) } : {}),
+        ...(row.started_at ? { startedAt: timestamp(row.started_at) } : {}),
+        ...(row.finished_at ? { finishedAt: timestamp(row.finished_at) } : {}),
+        ...(row.output !== null ? { output: row.output } : {}),
+        ...(row.error !== null ? { error: row.error } : {}),
+    };
+}
+export function paged(result, mapper, query) {
+    return {
+        items: result.items.map(mapper),
+        total: result.total,
+        limit: query.limit,
+        offset: query.offset,
+        hasMore: query.offset + result.items.length < result.total,
+    };
+}
+function timestamp(value) {
+    return new Date(value).toISOString();
+}