@amalgm/automations 0.2.1 → 0.2.3

package/AXIOMS.md

@@ -24,33 +24,55 @@
 9. Supabase is authoritative for automations, triggers, workflow source, and
    permanent run history. A definition edit or deletion never rewrites prior
    runs.
-10. Webhook secrets are persisted but write-only: normal reads reveal only that
-   a secret is configured.
-11. Run history is read-only in the control plane and always scoped to its
+10. A webhook URL is a rotatable bearer capability for exactly one trigger. Its
+    random locator is not sufficient without the hosted service's HMAC, and
+    caller input never supplies an owner or target.
+11. Optional provider signing secrets are persisted but write-only: normal
+    reads reveal only that a secret is configured.
+12. Run history is read-only in the control plane and always scoped to its
     automation's owner.
-12. Storage records, Supabase RPCs, HTTP details, and MCP protocol details are
+13. Storage records, Supabase RPCs, HTTP details, and MCP protocol details are
     implementation concerns, not SDK concepts.
-13. The control-plane SDK is the only configuration write path. The delivery
+14. The control-plane SDK is the only configuration write path. The delivery
     rail reads that configuration and writes only schedule clocks and run
     state; it never owns a second automation-definition API.
-14. Admitting a run atomically verifies the current enabled configuration,
+15. Admitting a run atomically verifies the current enabled configuration,
     stores a secret-free snapshot, and, for a schedule, advances exactly the
     firing instant that was claimed.
-15. Legacy local automation storage is not a compatibility authority. Engine
-    cutover migrates callers to this SDK and then deletes the old store.
-16. Event ingress returns success only after every admitted run is durable in
-    Supabase. Its recent-event list is a bounded, secret-free operational view,
-    never a second event or run authority.
-17. A finite schedule decrements its durable remaining occurrence count in the
+16. Legacy local automation storage is not a compatibility authority. Engine
+    is deprecated read-only evidence; active callers use this SDK and its
+    standalone service, and no old store may run beside them.
+17. Event ingress returns success only after its admitted run is durable in
+    Supabase. A repeated explicit delivery id resolves to the same run.
+18. A finite schedule decrements its durable remaining occurrence count in the
     same transaction that admits a run; zero disables the trigger.
-18. A machine receives work only by exclusively leasing runs whose persisted
+19. A machine receives work only by exclusively leasing runs whose persisted
     target equals the `computer_id` in its DPoP-bound access token.
-19. The configured public origin, never forwarding headers, reconstructs the
+20. The configured public origin, never forwarding headers, reconstructs the
     DPoP request URL behind the Fly proxy.
-20. Machine execution consumes the immutable workflow snapshot stored on the
+21. Machine execution consumes the immutable workflow snapshot stored on the
     run. It never rediscovers or silently updates the automation definition.
-21. A compiled workflow is a small declarative sequence of tool actions. The
+22. A compiled workflow is a small declarative sequence of one or more tool actions. The
     executor receives tool calling as a host capability and never embeds a
     Channels, Shell, CLI, or provider special case.
-22. Automations is a standalone hosted service. Gateway owns none of its API,
+23. Automations is a standalone hosted service. Gateway owns none of its API,
     scheduling, claim, execution, or persistence path.
+24. The durable run ledger is the offline queue. The platform never keeps a
+    second online-machine delivery buffer and never drops an unclaimed run.
+25. A run advances through its immutable plan in order. Every step transition
+    commits under the run's current lease before execution advances, and a
+    completed step is never intentionally invoked again.
+26. A machine may begin an action only after the service confirms its current
+    lease. It renews that lease while the action is running and stops advancing
+    when renewal fails.
+27. One run-step pair has one stable idempotency key. Step ids are unique in a
+    plan, and every action host receives that key and a cancellation signal.
+28. Only transient transport failures retry. They release the same run with a
+    bounded future retry time and retain completed step output; invalid plans,
+    missing actions, authorization failures, and other deterministic errors
+    are terminal.
+29. The selected target executes every action effect. The hosted service owns
+    only configuration, admission, leases, the step journal, and run history.
+30. Run Now is triggerless manual admission. It atomically snapshots the
+    current enabled automation and compiled workflow into the pending ledger;
+    it never executes inline or changes a trigger's schedule state.

package/PURPOSE.md

@@ -3,7 +3,7 @@
 ## Purpose
 
 Automations is the sole owner of Amalgm automation behavior and data. It lets an
-authenticated user create, inspect, change, and delete automation
+authenticated user create, inspect, change, delete, and manually run automation
 configuration — an automation belongs to one user and one target, may own any
 number of scheduled and webhook triggers, and may own one workflow script — and
 have each trigger occurrence run on the selected existing Amalgm machine.
@@ -13,7 +13,7 @@ complete workflow, and permanent run history.
 The product has two composable halves over that one state:
 
 - **The configuration control plane** — one ergonomic, auth-bound SDK contract
-  for automation CRUD and run-history reads. The HTTP API, CLI, MCP server, and
+  for automation CRUD, manual run admission, and run-history reads. The HTTP API, CLI, MCP server, and
   skill are adapters over that contract; they do not access Supabase directly
   or implement lifecycle rules.
 - **The delivery rail** — trigger admission, scheduling, and run state: the
@@ -23,7 +23,17 @@ The product has two composable halves over that one state:
   write path. When a machine is offline, new runs remain pending; when it
   reconnects, Shell claims pending runs directly from the Automations service
   with its machine-bound DPoP identity and executes the persisted tool-action
-  plan. Execution itself stays on the selected machine.
+  plan. Execution itself stays on the selected machine. The platform never
+  needs to know whether a machine is online: an unclaimed run is the complete
+  offline queue.
+
+One run is one immutable plan plus one durable ordered step journal. The
+machine records a step as running before invoking its action and records its
+output before advancing. Reconnect resumes at the first step that is not
+already complete. A transient network failure releases the same run back to
+the queue with a bounded future retry time; a configuration, authorization, or
+action error fails it. Stable per-step idempotency keys make an uncertain
+network acknowledgement safe to repeat.
 
 Automations is its own hosted service and Fly machine. Its API and scheduler
 share the same SDK and Supabase authority; neither is composed into, proxied by,
@@ -32,10 +42,14 @@ occurrence count in durable state, so “every minute for ten minutes” means t
 admitted runs and then an automatically disabled trigger — not a timer that a
 machine must remember.
 
-The event HTTP adapter is one thin door over that delivery rail. It bounds and
-parses the webhook body, resolves the authenticated target supplied by the
-host, and returns only after matching runs have been stored in Supabase. Its
-recent-event response is an ephemeral, secret-free operational projection.
+The event HTTP adapter is one thin door over that delivery rail. Every webhook
+trigger owns one opaque URL under `automations.amalgm.ai`; the URL resolves the
+trigger, owner, and target, so a caller never supplies routing identity. The
+adapter bounds and parses the body, optionally verifies the provider's signing
+secret, deduplicates explicit provider delivery ids, and returns only after the
+run has been stored in Supabase. The signed URL can be rotated without changing
+the automation, and its usable bearer token cannot be reconstructed from the
+database alone.
 
 Amalgm supplies a resolved authenticated principal from its user session or
 HMAC-refresh flow; future API keys resolve to the same principal capability.
@@ -47,7 +61,8 @@ connectivity, and narrow host capabilities. The product receives identity and
 scopes — never raw credentials or Core storage — and neither side reaches into
 the other's storage or reimplements the other's decisions.
 
-This extraction is complete only when every Automations surface in Engine calls
-this product service, product state has one writer, migrated behavior has parity
-tests, and the local `amalgm-mcp` automation implementation and storage are
-deleted rather than retained as a compatibility layer.
+This repository and its standalone Fly host are the active Automations
+authority. Shell calls the published machine-claim and execution contracts
+directly; the UI calls the hosted control plane through the published client.
+Any remaining Engine automation code is deprecated migration/parity evidence,
+not a cutover dependency or compatibility authority.

package/README.md

@@ -25,12 +25,19 @@ await sdk.triggers.schedule.create(automation.id, {
   timezone: 'America/Los_Angeles',
   maxOccurrences: 10,
 });
+
+const run = await sdk.runs.runNow(automation.id, {
+  input: { requestedFrom: 'automation-page' },
+  idempotencyKey: crypto.randomUUID(),
+});
 ```
 
 That schedule admits exactly ten durable runs, then disables itself. If the
 machine is offline, the runs remain pending. Shell later claims only work whose
 target matches its DPoP `computer_id`, executes the immutable tool-action plan,
-and commits the result.
+and commits the result. Run Now returns the newly admitted `pending` run; it
+uses that same machine execution path and never executes workflow effects in
+the API request.
 
 ## Surfaces
 
@@ -49,14 +56,18 @@ or depend on Amalgm Gateway.
 An automation belongs to one user and target. It owns any number of schedule
 or webhook triggers and zero or one workflow. Supabase owns definitions,
 schedule clocks, immutable run snapshots, machine leases, and permanent run
-history. Webhook secrets are write-only.
+history. Every webhook trigger has one rotatable URL; an optional provider
+signing secret is write-only.
 
-Compiled workflows use one small format:
+Executable workflows use one small, non-empty format:
 
 ```ts
 type AutomationPlan = {
   version: 1;
-  steps: Array<{ id: string; actionId: string; input: Json }>;
+  steps: [
+    { id: string; actionId: string; input: Json },
+    ...Array<{ id: string; actionId: string; input: Json }>,
+  ];
 };
 ```
 
@@ -68,11 +79,29 @@ one action-calling capability, and each step receives the stable idempotency key
 
 The control API lives under `/v1/automations`. The machine execution API is:
 
+```text
+POST /v1/automations/:automationId/runs
+```
+
+The optional JSON body contains `input` and an `idempotencyKey`. Reusing the
+key for the same automation returns the same admitted run.
+
+The machine execution API is:
+
 ```text
 POST  /v1/machine/runs/claim
 PATCH /v1/machine/runs/:runId
 ```
 
+Public webhook admission uses the URL returned on each webhook trigger:
+
+```text
+POST https://automations.amalgm.ai/e/<opaque-capability>
+```
+
+`Idempotency-Key` and common provider delivery-id headers deduplicate retries
+against the same trigger. The caller never supplies a user or target id.
+
 The target is never accepted in a machine request. It comes from the verified
 access token. Run leases expire and are safely reclaimable; terminal updates
 must present the active lease token.

package/dist/host/config.d.ts

@@ -1,6 +1,8 @@
 export interface AutomationsHostConfig {
     readonly port: number;
     readonly publicOrigin: string;
+    readonly webhookOrigin: string;
+    readonly webhookTokenKey: string;
     readonly supabaseUrl: string;
     readonly supabaseServiceRoleKey: string;
     readonly authorizationIssuer: string;

package/dist/host/config.js

@@ -2,6 +2,8 @@ export function automationsHostConfig(env = process.env) {
     return Object.freeze({
         port: integer(env.PORT, 8080, 1, 65_535),
         publicOrigin: url(env.AMALGAM_PUBLIC_ORIGIN, 'AMALGAM_PUBLIC_ORIGIN'),
+        webhookOrigin: url(env.AUTOMATIONS_WEBHOOK_ORIGIN, 'AUTOMATIONS_WEBHOOK_ORIGIN'),
+        webhookTokenKey: secret(env.AUTOMATIONS_WEBHOOK_TOKEN_KEY, 'AUTOMATIONS_WEBHOOK_TOKEN_KEY'),
         supabaseUrl: url(env.SUPABASE_URL ?? env.NEXT_PUBLIC_SUPABASE_URL, 'SUPABASE_URL'),
         supabaseServiceRoleKey: required(env.SUPABASE_SERVICE_ROLE_KEY, 'SUPABASE_SERVICE_ROLE_KEY'),
         authorizationIssuer: url(env.AMALGM_AUTHORIZATION_ISSUER, 'AMALGM_AUTHORIZATION_ISSUER'),
@@ -13,6 +15,12 @@ function required(value, name) {
         throw new Error(`${name} is required`);
     return value.trim();
 }
+function secret(value, name) {
+    const result = required(value, name);
+    if (Buffer.byteLength(result) < 32)
+        throw new Error(`${name} must contain at least 32 bytes`);
+    return result;
+}
 function url(value, name) {
     const parsed = new URL(required(value, name));
     const local = parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1';

package/dist/host/main.js

@@ -2,11 +2,13 @@ import { createClient } from '@supabase/supabase-js';
 import { Automations } from '../src/automations.js';
 import { AutomationCrudService } from '../src/crud.js';
 import { createAutomationApi } from '../src/http.js';
+import { createAutomationEventsApi } from '../src/events-http.js';
 import { createMachineRuns } from '../src/machine.js';
 import { createMachineRunsApi } from '../src/machine-http.js';
 import { SupabaseAutomationCrudRepository } from '../src/supabase-crud.js';
 import { SupabaseMachineRunRepository } from '../src/supabase-machine.js';
 import { SupabaseStore } from '../src/supabase-store.js';
+import { WebhookEndpoints } from '../src/webhook.js';
 import { createAutomationsAuthenticators } from './auth.js';
 import { automationsHostConfig } from './config.js';
 import { createAutomationsHost } from './server.js';
@@ -18,12 +20,10 @@ const authentication = createAutomationsAuthenticators({
     issuer: config.authorizationIssuer,
     supabase,
 });
-const delivery = new Automations(new SupabaseStore(supabase), {
-    isOnline: () => false,
-    send: async () => false,
-}, (event, details) => log(event, details));
+const webhooks = new WebhookEndpoints(config.webhookOrigin, config.webhookTokenKey);
+const delivery = new Automations(new SupabaseStore(supabase), (event, details) => log(event, details));
 const controlApi = createAutomationApi({
-    service: new AutomationCrudService(new SupabaseAutomationCrudRepository(supabase)),
+    service: new AutomationCrudService(new SupabaseAutomationCrudRepository(supabase), () => new Date(), webhooks),
     authenticate: authentication.control,
 });
 const machineRepository = new SupabaseMachineRunRepository(supabase);
@@ -31,10 +31,15 @@ const machineApi = createMachineRunsApi({
     authenticate: authentication.machine,
     runsFor: (principal) => createMachineRuns(machineRepository, principal),
 });
+const eventsApi = createAutomationEventsApi({
+    delivery,
+    endpoints: webhooks,
+});
 const host = createAutomationsHost({
     publicOrigin: config.publicOrigin,
     controlApi,
     machineApi,
+    eventsApi,
     fireSchedules: () => delivery.fireDueCrons(),
     schedulerIntervalMs: config.schedulerIntervalMs,
     log,

package/dist/host/server.d.ts

@@ -3,8 +3,10 @@ export declare function createAutomationsHost(options: {
     readonly publicOrigin: string;
     readonly controlApi: (request: Request) => Promise<Response>;
     readonly machineApi: (request: Request) => Promise<Response>;
+    readonly eventsApi?: (request: Request) => Promise<Response>;
     readonly fireSchedules: () => Promise<unknown>;
     readonly schedulerIntervalMs: number;
+    readonly maxRequestBodyBytes?: number;
     readonly log?: (event: string, details?: Readonly<Record<string, unknown>>) => void;
 }): {
     server: import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/dist/host/server.js

@@ -17,14 +17,19 @@ export function createAutomationsHost(options) {
         try {
             if (incoming.url === '/healthz')
                 return send(outgoing, Response.json({ ok: true }));
-            const request = await webRequest(incoming, options.publicOrigin);
-            const api = new URL(request.url).pathname.startsWith('/v1/machine/')
-                ? options.machineApi : options.controlApi;
+            const request = await webRequest(incoming, options.publicOrigin, options.maxRequestBodyBytes ?? 2 * 1024 * 1024);
+            const pathname = new URL(request.url).pathname;
+            const api = pathname.startsWith('/e/') && options.eventsApi
+                ? options.eventsApi
+                : pathname.startsWith('/v1/machine/') ? options.machineApi : options.controlApi;
             await send(outgoing, await api(request));
         }
         catch (error) {
             log('request.failed', { error: safe(error) });
-            await send(outgoing, Response.json({ error: 'Automations service failed' }, { status: 500 }));
+            const status = error instanceof HostRequestError ? error.status : 500;
+            await send(outgoing, Response.json({
+                error: status === 500 ? 'Automations service failed' : error instanceof Error ? error.message : String(error),
+            }, { status }));
         }
     });
     return {
@@ -36,10 +41,16 @@ export function createAutomationsHost(options) {
         },
     };
 }
-async function webRequest(request, publicOrigin) {
+async function webRequest(request, publicOrigin, maximumBodyBytes) {
     const chunks = [];
-    for await (const chunk of request)
-        chunks.push(Buffer.from(chunk));
+    let size = 0;
+    for await (const value of request) {
+        const chunk = Buffer.from(value);
+        size += chunk.length;
+        if (size > maximumBodyBytes)
+            throw new HostRequestError(413, 'Request body is too large');
+        chunks.push(chunk);
+    }
     const body = Buffer.concat(chunks);
     return new Request(publicResourceRequestUrl(publicOrigin, request.url ?? '/'), {
         method: request.method ?? 'GET',
@@ -47,6 +58,13 @@ async function webRequest(request, publicOrigin) {
         ...(body.length ? { body } : {}),
     });
 }
+class HostRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
 async function send(response, source) {
     response.writeHead(source.status, Object.fromEntries(source.headers));
     response.end(Buffer.from(await source.arrayBuffer()));

package/dist/src/automations.d.ts

@@ -1,24 +1,30 @@
-import type { AutomationLog, AutomationRun, AutomationStore, AutomationTarget, AutomationTransport, Json, RunUpdate } from './types.js';
+import type { AutomationLog, AutomationRun, AutomationStore, Json } from './types.js';
 export declare class EventRejectedError extends Error {
     constructor();
 }
+export declare class EventEndpointNotFoundError extends Error {
+    constructor();
+}
+export interface EventAdmission {
+    run: AutomationRun | null;
+    source: string;
+    event: string;
+}
+/** Admits trigger occurrences to the durable run ledger. It never delivers them. */
 export declare class Automations {
     #private;
     readonly store: AutomationStore;
-    readonly transport: AutomationTransport;
     readonly log: AutomationLog;
-    constructor(store: AutomationStore, transport: AutomationTransport, log?: AutomationLog);
+    constructor(store: AutomationStore, log?: AutomationLog);
     receiveEvent(input: {
-        target: AutomationTarget;
+        endpointId: string;
         headers: Record<string, string>;
         body: Buffer;
         payload: Json;
+        deliveryKey: string | null;
         source?: string;
         event?: string;
         now?: Date;
-    }): Promise<AutomationRun[]>;
-    fireDueCrons(now?: Date): Promise<AutomationRun[]>;
-    targetOnline(target: AutomationTarget): Promise<number>;
-    updateRun(target: AutomationTarget, runId: string, update: RunUpdate): Promise<AutomationRun | null>;
-    drain(target: AutomationTarget): Promise<number>;
+    }): Promise<EventAdmission>;
+    fireDueCrons(now?: Date, maximumRuns?: number): Promise<AutomationRun[]>;
 }

package/dist/src/automations.js

@@ -7,47 +7,58 @@ export class EventRejectedError extends Error {
         this.name = 'EventRejectedError';
     }
 }
+export class EventEndpointNotFoundError extends Error {
+    constructor() {
+        super('Webhook endpoint was not found');
+        this.name = 'EventEndpointNotFoundError';
+    }
+}
+/** Admits trigger occurrences to the durable run ledger. It never delivers them. */
 export class Automations {
     store;
-    transport;
     log;
-    #drains = new Map();
-    constructor(store, transport, log = noop) {
+    constructor(store, log = noop) {
         this.store = store;
-        this.transport = transport;
         this.log = log;
     }
     async receiveEvent(input) {
         assertJson(input.payload, 'Event payload');
-        const candidates = await this.store.eventTriggers(input.target);
-        const authenticated = candidates.filter((trigger) => (verifyEventSecret(trigger.secret, input.headers, input.body)));
-        if (authenticated.length === 0) {
-            this.log('event.rejected', { targetId: input.target.targetId });
+        const trigger = await this.store.eventTrigger(input.endpointId);
+        if (!trigger)
+            throw new EventEndpointNotFoundError();
+        if (!verifyEventSecret(trigger.secret, input.headers, input.body)) {
+            this.log('event.rejected', { triggerId: trigger.triggerId });
             throw new EventRejectedError();
         }
         const references = input.source && input.event
             ? { primary: { source: input.source, event: input.event } }
             : eventReferences(input.headers, input.payload);
         let reference = references.primary;
-        let triggers = authenticated.filter((trigger) => matchesEvent(trigger, reference.source, reference.event));
-        if (triggers.length === 0 && references.fallback) {
+        let matches = matchesEvent(trigger, reference.source, reference.event);
+        if (!matches && references.fallback) {
             reference = references.fallback;
-            triggers = authenticated.filter((trigger) => matchesEvent(trigger, reference.source, reference.event));
+            matches = matchesEvent(trigger, reference.source, reference.event);
         }
-        if (triggers.length === 0)
-            return [];
+        if (!matches)
+            return { run: null, ...reference };
         const now = input.now || new Date();
         const runInput = { kind: 'event', ...reference, payload: input.payload };
-        const runs = (await Promise.all(triggers.map((trigger) => (this.store.enqueueEvent(trigger, runInput, now))))).filter((run) => run !== null);
-        await this.#drainCreated(runs);
-        return runs;
+        const run = await this.store.enqueueEvent(trigger, runInput, now, input.deliveryKey);
+        if (!run)
+            return { run: null, ...reference };
+        this.#logPending([run]);
+        return { run, ...reference };
     }
-    async fireDueCrons(now = new Date()) {
+    async fireDueCrons(now = new Date(), maximumRuns = 1_000) {
+        if (!Number.isInteger(maximumRuns) || maximumRuns < 1)
+            throw new Error('maximumRuns must be a positive integer');
         const created = [];
         for (const trigger of await this.store.dueCronTriggers(now)) {
             let scheduledFor = trigger.nextRunAt;
             let remaining = trigger.remainingOccurrences;
-            while (new Date(scheduledFor) <= now && (remaining === undefined || remaining > 0)) {
+            while (created.length < maximumRuns
+                && new Date(scheduledFor) <= now
+                && (remaining === undefined || remaining > 0)) {
                 const nextRunAt = nextCronAt(trigger.cron, trigger.timezone, scheduledFor);
                 const run = await this.store.enqueueCron({ ...trigger, nextRunAt: scheduledFor }, nextRunAt, now);
                 if (!run)
@@ -57,31 +68,13 @@ export class Automations {
                 if (remaining !== undefined)
                     remaining -= 1;
             }
+            if (created.length === maximumRuns)
+                break;
         }
-        await this.#drainCreated(created);
+        this.#logPending(created);
         return created;
     }
-    targetOnline(target) {
-        return this.drain(target);
-    }
-    updateRun(target, runId, update) {
-        if (update.output !== undefined)
-            assertJson(update.output, 'Run output');
-        return this.store.updateRun(target, runId, update);
-    }
-    drain(target) {
-        const key = `${target.userId}:${target.targetId}`;
-        const active = this.#drains.get(key);
-        if (active)
-            return active;
-        const drain = this.#drain(target).finally(() => {
-            if (this.#drains.get(key) === drain)
-                this.#drains.delete(key);
-        });
-        this.#drains.set(key, drain);
-        return drain;
-    }
-    async #drainCreated(runs) {
+    #logPending(runs) {
         for (const run of runs) {
             this.log('run.pending', {
                 runId: run.id,
@@ -89,42 +82,6 @@ export class Automations {
                 automationId: run.automationId,
             });
         }
-        const targets = new Map(runs.map((run) => [
-            `${run.userId}:${run.targetId}`,
-            { userId: run.userId, targetId: run.targetId },
-        ]));
-        await Promise.all([...targets.values()].map((target) => this.drain(target)));
-    }
-    async #drain(target) {
-        if (!this.transport.isOnline(target))
-            return 0;
-        this.log('drain.started', { targetId: target.targetId });
-        let sent = 0;
-        const failed = new Set();
-        while (this.transport.isOnline(target)) {
-            const runs = (await this.store.pendingRuns(target)).filter(({ id }) => !failed.has(id));
-            if (runs.length === 0)
-                return sent;
-            for (const run of runs) {
-                if (!this.transport.isOnline(target))
-                    return sent;
-                try {
-                    if (!await this.transport.send(run)) {
-                        this.log('run.failed', { runId: run.id, targetId: target.targetId });
-                        failed.add(run.id);
-                        continue;
-                    }
-                    if (await this.store.markSent(run.id, target, new Date()))
-                        sent += 1;
-                    this.log('run.sent', { runId: run.id, targetId: target.targetId });
-                }
-                catch {
-                    this.log('run.failed', { runId: run.id, targetId: target.targetId });
-                    failed.add(run.id);
-                }
-            }
-        }
-        return sent;
     }
 }
 function assertJson(value, label) {

package/dist/src/cli.d.ts

@@ -2,7 +2,7 @@ import type { AutomationCrud } from './contract.js';
 interface Output {
     write(chunk: string): unknown;
 }
-export declare const automationCliHelp = "Usage: amalgm-automations <resource> <action>\n\nautomations  create|list|get|update|delete\ntriggers     list | schedule <create|list|get|update|delete> | webhook <create|list|get|update|delete>\nworkflow     create|get|update|delete\nruns         list|get\n\nList filters:\n  automations list [--target-id ID] [--enabled true|false] [--limit N] [--offset N]\n  triggers schedule|webhook list AUTOMATION_ID [--limit N] [--offset N]\n  runs list AUTOMATION_ID [--status STATUS] [--limit N] [--offset N]\n";
+export declare const automationCliHelp = "Usage: amalgm-automations <resource> <action>\n\nautomations  create|list|get|update|delete\ntriggers     list | schedule <create|list|get|update|delete> | webhook <create|list|get|update|delete>\nworkflow     create|get|update|delete\nruns         run-now|list|get\n\nList filters:\n  automations list [--target-id ID] [--enabled true|false] [--limit N] [--offset N]\n  triggers schedule|webhook list AUTOMATION_ID [--limit N] [--offset N]\n  runs list AUTOMATION_ID [--status STATUS] [--limit N] [--offset N]\n";
 export declare function runAutomationCli(argv: string[], sdk: AutomationCrud, output?: {
     stdout?: Output;
     stderr?: Output;

package/dist/src/cli.js

@@ -4,7 +4,7 @@ export const automationCliHelp = `Usage: amalgm-automations <resource> <action>
 automations  create|list|get|update|delete
 triggers     list | schedule <create|list|get|update|delete> | webhook <create|list|get|update|delete>
 workflow     create|get|update|delete
-runs         list|get
+runs         run-now|list|get
 
 List filters:
   automations list [--target-id ID] [--enabled true|false] [--limit N] [--offset N]
@@ -109,11 +109,14 @@ async function workflowCommand(action, args, sdk) {
 }
 async function runsCommand(action, args, sdk) {
     const automationId = required(args, 0, 'automation id');
+    if (action === 'run-now') {
+        return sdk.runs.runNow(automationId, args[1] ? await jsonFile(args[1]) : {});
+    }
     if (action === 'list')
         return sdk.runs.list(automationId, runListOptions(args.slice(1)));
     if (action === 'get')
         return sdk.runs.get(automationId, required(args, 1, 'run id'));
-    throw new Error('Usage: runs <list|get>');
+    throw new Error('Usage: runs <run-now|list|get>');
 }
 function automationListOptions(args) {
     const options = readOptions(args, new Set(['--target-id', '--enabled', '--limit', '--offset']));

package/dist/src/client.d.ts

@@ -6,4 +6,5 @@ export declare function createAutomationClient(options: {
     authorization?: AutomationAuthorization;
     headers?: AutomationHeaders;
     fetch?: typeof globalThis.fetch;
+    requestTimeoutMs?: number;
 }): AutomationCrud;

package/dist/src/client.js

@@ -1,7 +1,7 @@
 import { AutomationError } from './errors.js';
 export function createAutomationClient(options) {
     const baseUrl = options.baseUrl.replace(/\/$/, '');
-    const request = createRequester(baseUrl, options.authorization, options.headers, options.fetch || globalThis.fetch);
+    const request = createRequester(baseUrl, options.authorization, options.headers, options.fetch || globalThis.fetch, options.requestTimeoutMs ?? 15_000);
     return {
         automations: {
             create: (input) => request('/v1/automations', 'POST', input),
@@ -34,12 +34,13 @@ export function createAutomationClient(options) {
             delete: (automationId) => request(workflowPath(automationId), 'DELETE'),
         },
         runs: {
+            runNow: (automationId, input = {}) => request(runsPath(automationId), 'POST', input),
             list: (automationId, query = {}) => request(`${runsPath(automationId)}${queryString(query)}`, 'GET'),
             get: (automationId, runId) => request(`${runsPath(automationId)}/${part(runId)}`, 'GET', undefined, true),
         },
     };
 }
-function createRequester(baseUrl, authorization, additionalHeaders, fetch) {
+function createRequester(baseUrl, authorization, additionalHeaders, fetch, requestTimeoutMs) {
     return async (path, method, body, nullable = false) => {
         const url = `${baseUrl}${path}`;
         const token = await authorization?.();
@@ -52,6 +53,7 @@ function createRequester(baseUrl, authorization, additionalHeaders, fetch) {
                 ...await additionalHeaders?.(method, url),
             },
             ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            signal: AbortSignal.timeout(requestTimeoutMs),
         });
         if (response.status === 204)
             return undefined;