@amalgm/automations 0.1.2 → 0.2.1

package/dist/src/crud.js

@@ -1,7 +1,8 @@
-import { ConflictError, ForbiddenError, NotFoundError } from './errors.js';
-import { parseCreateAutomation, parseCreateScheduleTrigger, parseCreateWebhookTrigger, parseCreateWorkflow, parseListAutomations, parseListRuns, parsePageQuery, parseUpdateAutomation, parseUpdateScheduleTrigger, parseUpdateWebhookTrigger, parseUpdateWorkflow, } from './schema.js';
-import { id, newId, page, requiredText, schedule, } from './validation.js';
-import { nextCronAt } from './schedule.js';
+import { automationOperations } from './crud/automations.js';
+import { createContext } from './crud/context.js';
+import { runOperations } from './crud/runs.js';
+import { triggerOperations } from './crud/triggers.js';
+import { workflowOperations } from './crud/workflow.js';
 export class AutomationCrudService {
     repository;
     clock;
@@ -10,240 +11,12 @@ export class AutomationCrudService {
         this.clock = clock;
     }
     for(principal) {
-        assertPrincipal(principal);
-        const read = () => assertScope(principal, 'automations:read');
-        const write = () => assertScope(principal, 'automations:write');
-        const runsRead = () => assertScope(principal, 'runs:read');
-        const exists = async (automationId) => {
-            const automation = await this.repository.getAutomation(principal.userId, id(automationId, 'Automation id'));
-            if (!automation)
-                throw new NotFoundError('Automation');
-        };
+        const context = createContext(this.repository, principal, this.clock);
         return {
-            automations: {
-                create: async (input) => {
-                    write();
-                    const parsed = parseCreateAutomation(input);
-                    const targetId = parsed.targetId;
-                    assertTarget(principal, targetId);
-                    if (parsed.id && await this.repository.getAutomation(principal.userId, id(parsed.id, 'Automation id'))) {
-                        throw new ConflictError('Automation');
-                    }
-                    return this.repository.createAutomation(principal.userId, {
-                        id: parsed.id ? id(parsed.id, 'Automation id') : newId('automation'),
-                        targetId,
-                        name: parsed.name || '',
-                        description: parsed.description || '',
-                        enabled: parsed.enabled !== false,
-                    });
-                },
-                list: async (query = {}) => {
-                    read();
-                    const parsed = parseListAutomations(query);
-                    if (parsed.targetId)
-                        assertTarget(principal, parsed.targetId);
-                    return this.repository.listAutomations(principal.userId, {
-                        ...page(parsed),
-                        ...(parsed.targetId ? { targetId: id(parsed.targetId, 'targetId') } : {}),
-                        ...(parsed.enabled === undefined ? {} : { enabled: parsed.enabled }),
-                    });
-                },
-                get: async (automationId) => {
-                    read();
-                    return this.repository.getAutomation(principal.userId, id(automationId, 'Automation id'));
-                },
-                update: async (automationId, patch) => {
-                    write();
-                    const parsed = parseUpdateAutomation(patch);
-                    if (parsed.targetId !== undefined) {
-                        assertTarget(principal, parsed.targetId);
-                    }
-                    const updated = await this.repository.updateAutomation(principal.userId, id(automationId, 'Automation id'), parsed);
-                    if (!updated)
-                        throw new NotFoundError('Automation');
-                    return updated;
-                },
-                delete: async (automationId) => {
-                    write();
-                    const deleted = await this.repository.deleteAutomation(principal.userId, id(automationId, 'Automation id'));
-                    if (!deleted)
-                        throw new NotFoundError('Automation');
-                },
-            },
-            triggers: {
-                list: async (automationId) => {
-                    read();
-                    await exists(automationId);
-                    return this.repository.listTriggers(principal.userId, automationId);
-                },
-                schedule: {
-                    create: async (automationId, input) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseCreateScheduleTrigger(input);
-                        const timezone = parsed.timezone || 'UTC';
-                        schedule(parsed.cron, timezone);
-                        if (parsed.id && (await this.repository.listTriggers(principal.userId, automationId))
-                            .some((trigger) => trigger.id === parsed.id))
-                            throw new ConflictError('Trigger');
-                        return this.repository.createScheduleTrigger(principal.userId, automationId, {
-                            id: parsed.id ? id(parsed.id, 'Schedule trigger id') : newId('schedule'),
-                            cron: parsed.cron,
-                            timezone,
-                            enabled: parsed.enabled !== false,
-                            nextRunAt: nextCronAt(parsed.cron, timezone, this.clock()),
-                        });
-                    },
-                    list: async (automationId, query = {}) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.listScheduleTriggers(principal.userId, automationId, page(parsePageQuery(query)));
-                    },
-                    get: async (automationId, triggerId) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.getScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'));
-                    },
-                    update: async (automationId, triggerId, patch) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseUpdateScheduleTrigger(patch);
-                        let storedPatch = parsed;
-                        if (parsed.cron !== undefined || parsed.timezone !== undefined) {
-                            const existing = await this.repository.getScheduleTrigger(principal.userId, automationId, triggerId);
-                            if (!existing)
-                                throw new NotFoundError('Schedule trigger');
-                            const cron = parsed.cron ?? existing.cron;
-                            const timezone = parsed.timezone ?? existing.timezone;
-                            schedule(cron, timezone);
-                            storedPatch = { ...parsed, nextRunAt: nextCronAt(cron, timezone, this.clock()) };
-                        }
-                        const updated = await this.repository.updateScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'), storedPatch);
-                        if (!updated)
-                            throw new NotFoundError('Schedule trigger');
-                        return updated;
-                    },
-                    delete: async (automationId, triggerId) => {
-                        write();
-                        await exists(automationId);
-                        const deleted = await this.repository.deleteScheduleTrigger(principal.userId, automationId, id(triggerId, 'Schedule trigger id'));
-                        if (!deleted)
-                            throw new NotFoundError('Schedule trigger');
-                    },
-                },
-                webhook: {
-                    create: async (automationId, input) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseCreateWebhookTrigger(input);
-                        if (parsed.id && (await this.repository.listTriggers(principal.userId, automationId))
-                            .some((trigger) => trigger.id === parsed.id))
-                            throw new ConflictError('Trigger');
-                        return this.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,
-                            enabled: parsed.enabled !== false,
-                        });
-                    },
-                    list: async (automationId, query = {}) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.listWebhookTriggers(principal.userId, automationId, page(parsePageQuery(query)));
-                    },
-                    get: async (automationId, triggerId) => {
-                        read();
-                        await exists(automationId);
-                        return this.repository.getWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
-                    },
-                    update: async (automationId, triggerId, patch) => {
-                        write();
-                        await exists(automationId);
-                        const parsed = parseUpdateWebhookTrigger(patch);
-                        const updated = await this.repository.updateWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'), parsed);
-                        if (!updated)
-                            throw new NotFoundError('Webhook trigger');
-                        return updated;
-                    },
-                    delete: async (automationId, triggerId) => {
-                        write();
-                        await exists(automationId);
-                        const deleted = await this.repository.deleteWebhookTrigger(principal.userId, automationId, id(triggerId, 'Webhook trigger id'));
-                        if (!deleted)
-                            throw new NotFoundError('Webhook trigger');
-                    },
-                },
-            },
-            workflow: {
-                create: async (automationId, input) => {
-                    write();
-                    await exists(automationId);
-                    if (await this.repository.getWorkflow(principal.userId, automationId)) {
-                        throw new ConflictError('Workflow');
-                    }
-                    const parsed = parseCreateWorkflow(input);
-                    return this.repository.createWorkflow(principal.userId, automationId, {
-                        id: parsed.id ? id(parsed.id, 'Workflow id') : newId('workflow'),
-                        name: parsed.name || '',
-                        script: parsed.script,
-                        compiled: parsed.compiled ?? null,
-                        allowlist: parsed.allowlist ?? null,
-                        limits: parsed.limits ?? null,
-                    });
-                },
-                get: async (automationId) => {
-                    read();
-                    await exists(automationId);
-                    return this.repository.getWorkflow(principal.userId, automationId);
-                },
-                update: async (automationId, patch) => {
-                    write();
-                    await exists(automationId);
-                    const parsed = parseUpdateWorkflow(patch);
-                    const updated = await this.repository.updateWorkflow(principal.userId, automationId, parsed);
-                    if (!updated)
-                        throw new NotFoundError('Workflow');
-                    return updated;
-                },
-                delete: async (automationId) => {
-                    write();
-                    await exists(automationId);
-                    if (!await this.repository.deleteWorkflow(principal.userId, automationId)) {
-                        throw new NotFoundError('Workflow');
-                    }
-                },
-            },
-            runs: {
-                list: async (automationId, query = {}) => {
-                    runsRead();
-                    const parsed = parseListRuns(query);
-                    return this.repository.listRuns(principal.userId, id(automationId, 'Automation id'), {
-                        ...page(parsed),
-                        ...(parsed.status ? { status: parsed.status } : {}),
-                    });
-                },
-                get: async (automationId, runId) => {
-                    runsRead();
-                    return this.repository.getRun(principal.userId, id(automationId, 'Automation id'), id(runId, 'Run id'));
-                },
-            },
+            automations: automationOperations(context),
+            triggers: triggerOperations(context),
+            workflow: workflowOperations(context),
+            runs: runOperations(context),
         };
     }
 }
-function assertPrincipal(principal) {
-    requiredText(principal.userId, 'Authenticated user id');
-    if (!Array.isArray(principal.scopes))
-        throw new ForbiddenError();
-    principal.targetIds?.forEach((targetId) => id(targetId, 'Authorized target id'));
-}
-function assertScope(principal, scope) {
-    if (!principal.scopes.includes('*') && !principal.scopes.includes(scope)) {
-        throw new ForbiddenError(`This credential requires ${scope}`);
-    }
-}
-function assertTarget(principal, targetId) {
-    if (principal.targetIds && !principal.targetIds.includes(targetId)) {
-        throw new ForbiddenError('This credential cannot access that target');
-    }
-}

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,15 +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

@@ -17,3 +17,8 @@ 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

@@ -7,7 +7,7 @@ const triggerIdInput = { ...automationIdInput, trigger_id: identifierSchema };
 const runIdInput = { ...automationIdInput, run_id: identifierSchema };
 export function createAutomationMcpServer(sdk) {
     const server = new McpServer({ name: 'amalgm-automations-mcp-server', version: '0.1.0' });
-    register(server, 'amalgm_automations_create', 'Create automation', 'Create an automation configuration without triggers or workflow.', { input: createAutomationSchema }, write(false), ({ input }) => sdk.automations.create(input));
+    register(server, 'amalgm_automations_create', 'Create automation', 'Create an automation configuration without triggers or workflow. In an authenticated machine session, omit input.targetId so the service uses that machine; never guess a target id.', { input: createAutomationSchema }, write(false), ({ input }) => sdk.automations.create(input));
     register(server, 'amalgm_automations_list', 'List automations', 'List the caller\'s automations with optional target and enabled filters.', { query: listAutomationsSchema.optional() }, read(), ({ query }) => sdk.automations.list(query));
     register(server, 'amalgm_automations_get', 'Get automation', 'Get one automation by id.', automationIdInput, read(), ({ automation_id }) => sdk.automations.get(automation_id));
     register(server, 'amalgm_automations_update', 'Update automation', 'Update automation metadata, target, or enabled state.', { automation_id: identifierSchema, patch: updateAutomationSchema }, write(true), ({ automation_id, patch }) => sdk.automations.update(automation_id, patch));
@@ -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 }) => {