@amalgm/automations 0.2.6 → 0.3.0

package/dist/src/cli-main.js

@@ -1,21 +1,3 @@
 #!/usr/bin/env node
-import { createAutomationClient } from './client.js';
-import { automationCliHelp, runAutomationCli } from './cli.js';
-const baseUrl = process.env.AMALGM_AUTOMATIONS_API_URL;
-const authorization = process.env.AMALGM_AUTOMATIONS_AUTHORIZATION;
-const argv = process.argv.slice(2);
-const help = argv.length === 0 || argv[0] === 'help' || argv[0] === '--help' || argv[0] === '-h';
-if (help) {
-    process.stdout.write(automationCliHelp);
-}
-else if (!baseUrl || !authorization) {
-    process.stderr.write('AMALGM_AUTOMATIONS_API_URL and AMALGM_AUTOMATIONS_AUTHORIZATION are required.\n');
-    process.exitCode = 1;
-}
-else {
-    const code = await runAutomationCli(argv, createAutomationClient({
-        baseUrl,
-        authorization: () => authorization,
-    }));
-    process.exitCode = code;
-}
+import { runAutomationCliMain } from './cli/main.js';
+process.exitCode = await runAutomationCliMain();

package/dist/src/cli.d.ts

@@ -1,10 +1,3 @@
-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         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;
-}): Promise<number>;
-export {};
+export { automationCliHelp, runAutomationCli, type AutomationCliIo, } from './cli/run.js';
+export { createShellAutomationCommands, shellAutomationEndpoint, type ShellAutomationCommandOptions, } from './cli/shell-runtime.js';
+export { runAutomationCliMain, type AutomationCliMainOptions } from './cli/main.js';

package/dist/src/cli.js

@@ -1,186 +1,3 @@
-import fs from 'node:fs/promises';
-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         run-now|list|get
-
-List filters:
-  automations list [--target-id ID] [--enabled true|false] [--limit N] [--offset N]
-  triggers schedule|webhook list AUTOMATION_ID [--limit N] [--offset N]
-  runs list AUTOMATION_ID [--status STATUS] [--limit N] [--offset N]
-`;
-export async function runAutomationCli(argv, sdk, output = {}) {
-    const stdout = output.stdout || process.stdout;
-    const stderr = output.stderr || process.stderr;
-    try {
-        const [resource, action, ...rest] = argv;
-        if (!resource || resource === 'help' || resource === '--help' || resource === '-h') {
-            stdout.write(automationCliHelp);
-            return 0;
-        }
-        const result = await command(resource, action, rest, sdk);
-        stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        return 0;
-    }
-    catch (error) {
-        stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 1;
-    }
-}
-async function command(resource, action, args, sdk) {
-    if (resource === 'automations')
-        return automationCommand(action, args, sdk);
-    if (resource === 'triggers')
-        return triggerCommand(action, args, sdk);
-    if (resource === 'workflow')
-        return workflowCommand(action, args, sdk);
-    if (resource === 'runs')
-        return runsCommand(action, args, sdk);
-    throw new Error(`Unknown resource: ${resource}`);
-}
-async function automationCommand(action, args, sdk) {
-    if (action === 'create')
-        return sdk.automations.create(await jsonFile(required(args, 0, 'automation JSON file')));
-    if (action === 'list')
-        return sdk.automations.list(automationListOptions(args));
-    if (action === 'get')
-        return sdk.automations.get(required(args, 0, 'automation id'));
-    if (action === 'update')
-        return sdk.automations.update(required(args, 0, 'automation id'), await jsonFile(required(args, 1, 'automation patch JSON file')));
-    if (action === 'delete') {
-        const automationId = required(args, 0, 'automation id');
-        await sdk.automations.delete(automationId);
-        return { deleted: automationId };
-    }
-    throw new Error('Usage: automations <create|list|get|update|delete>');
-}
-async function triggerCommand(action, args, sdk) {
-    if (action === 'list')
-        return sdk.triggers.list(required(args, 0, 'automation id'));
-    const [operation, automationId, ...rest] = args;
-    const automation = requiredValue(automationId, 'automation id');
-    if (action === 'schedule') {
-        if (operation === 'create')
-            return sdk.triggers.schedule.create(automation, await jsonFile(required(rest, 0, 'schedule JSON file')));
-        if (operation === 'list')
-            return sdk.triggers.schedule.list(automation, pageOptions(rest));
-        if (operation === 'get')
-            return sdk.triggers.schedule.get(automation, required(rest, 0, 'schedule trigger id'));
-        if (operation === 'update')
-            return sdk.triggers.schedule.update(automation, required(rest, 0, 'schedule trigger id'), await jsonFile(required(rest, 1, 'schedule patch JSON file')));
-        if (operation === 'delete') {
-            const id = required(rest, 0, 'schedule trigger id');
-            await sdk.triggers.schedule.delete(automation, id);
-            return { deleted: id };
-        }
-    }
-    if (action === 'webhook') {
-        if (operation === 'create')
-            return sdk.triggers.webhook.create(automation, await jsonFile(required(rest, 0, 'webhook JSON file')));
-        if (operation === 'list')
-            return sdk.triggers.webhook.list(automation, pageOptions(rest));
-        if (operation === 'get')
-            return sdk.triggers.webhook.get(automation, required(rest, 0, 'webhook trigger id'));
-        if (operation === 'update')
-            return sdk.triggers.webhook.update(automation, required(rest, 0, 'webhook trigger id'), await jsonFile(required(rest, 1, 'webhook patch JSON file')));
-        if (operation === 'delete') {
-            const id = required(rest, 0, 'webhook trigger id');
-            await sdk.triggers.webhook.delete(automation, id);
-            return { deleted: id };
-        }
-    }
-    throw new Error('Usage: triggers <list|schedule|webhook>');
-}
-async function workflowCommand(action, args, sdk) {
-    const automationId = required(args, 0, 'automation id');
-    if (action === 'create')
-        return sdk.workflow.create(automationId, await jsonFile(required(args, 1, 'workflow JSON file')));
-    if (action === 'get')
-        return sdk.workflow.get(automationId);
-    if (action === 'update')
-        return sdk.workflow.update(automationId, await jsonFile(required(args, 1, 'workflow patch JSON file')));
-    if (action === 'delete') {
-        await sdk.workflow.delete(automationId);
-        return { deleted: automationId };
-    }
-    throw new Error('Usage: workflow <create|get|update|delete>');
-}
-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 <run-now|list|get>');
-}
-function automationListOptions(args) {
-    const options = readOptions(args, new Set(['--target-id', '--enabled', '--limit', '--offset']));
-    return {
-        ...pageOptionsFrom(options),
-        ...(options['--target-id'] ? { targetId: options['--target-id'] } : {}),
-        ...(options['--enabled'] === undefined ? {} : { enabled: booleanOption(options['--enabled'], '--enabled') }),
-    };
-}
-function runListOptions(args) {
-    const options = readOptions(args, new Set(['--status', '--limit', '--offset']));
-    return {
-        ...pageOptionsFrom(options),
-        ...(options['--status'] ? { status: options['--status'] } : {}),
-    };
-}
-function pageOptions(args) {
-    return pageOptionsFrom(readOptions(args, new Set(['--limit', '--offset'])));
-}
-function pageOptionsFrom(options) {
-    return {
-        ...(options['--limit'] === undefined ? {} : { limit: numberOption(options['--limit'], '--limit') }),
-        ...(options['--offset'] === undefined ? {} : { offset: numberOption(options['--offset'], '--offset') }),
-    };
-}
-function readOptions(args, allowed) {
-    const result = {};
-    for (let index = 0; index < args.length; index += 2) {
-        const flag = args[index];
-        const value = args[index + 1];
-        if (!flag || !allowed.has(flag) || value === undefined)
-            throw new Error(`Unknown or incomplete list option: ${flag || ''}`);
-        if (result[flag] !== undefined)
-            throw new Error(`List option may be provided once: ${flag}`);
-        result[flag] = value;
-    }
-    return result;
-}
-function numberOption(value, name) {
-    const number = Number(value);
-    if (!Number.isInteger(number))
-        throw new Error(`${name} must be an integer`);
-    return number;
-}
-function booleanOption(value, name) {
-    if (value === 'true')
-        return true;
-    if (value === 'false')
-        return false;
-    throw new Error(`${name} must be true or false`);
-}
-async function jsonFile(filename) {
-    try {
-        return JSON.parse(await fs.readFile(filename, 'utf8'));
-    }
-    catch (error) {
-        throw new Error(`Cannot read JSON file ${filename}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function required(values, index, label) {
-    return requiredValue(values[index], label);
-}
-function requiredValue(value, label) {
-    if (!value)
-        throw new Error(`${label} is required`);
-    return value;
-}
+export { automationCliHelp, runAutomationCli, } from './cli/run.js';
+export { createShellAutomationCommands, shellAutomationEndpoint, } from './cli/shell-runtime.js';
+export { runAutomationCliMain } from './cli/main.js';

package/dist/src/command-result.d.ts

@@ -0,0 +1,8 @@
+export interface AutomationFailureEnvelope {
+    error: {
+        code: string;
+        message: string;
+        status?: number;
+    };
+}
+export declare function automationFailure(error: unknown): AutomationFailureEnvelope;

package/dist/src/command-result.js

@@ -0,0 +1,13 @@
+import { AutomationError } from './errors.js';
+export function automationFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof AutomationError ? error.code : 'internal';
+    const status = error instanceof AutomationError ? error.status : undefined;
+    return {
+        error: {
+            code,
+            message,
+            ...(status === undefined ? {} : { status }),
+        },
+    };
+}

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

@@ -0,0 +1,25 @@
+import { z } from 'zod/v3';
+import type { AutomationCrud } from './contract.js';
+import { type AutomationToolSurface } from './tool-surface.js';
+export type AutomationCommandName = 'create' | 'list' | 'get' | 'update' | 'delete' | 'run-now';
+export interface AutomationCommandAnnotations {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    idempotentHint: boolean;
+    openWorldHint: boolean;
+}
+export interface AutomationCommandDefinition {
+    name: AutomationCommandName;
+    mcpName: `amalgm_automations_${string}`;
+    title: string;
+    description: string;
+    inputShape: z.ZodRawShape;
+    annotations: AutomationCommandAnnotations;
+    invoke(tools: AutomationToolSurface, input: unknown): Promise<unknown>;
+}
+export interface AutomationCommands {
+    execute(name: AutomationCommandName, input?: unknown): Promise<unknown>;
+}
+export declare const automationCommandDefinitions: readonly AutomationCommandDefinition[];
+export declare function createAutomationCommands(sdk: AutomationCrud): AutomationCommands;
+export declare function automationCommandDefinition(name: string): AutomationCommandDefinition;

package/dist/src/command-surface.js

@@ -0,0 +1,125 @@
+import { z } from 'zod/v3';
+import { ValidationError } from './errors.js';
+import { createAutomationSchema, createScheduleTriggerSchema, createWebhookTriggerSchema, createWorkflowSchema, identifierSchema, listAutomationsSchema, listRunsSchema, parse, runAutomationNowSchema, updateAutomationSchema, updateScheduleTriggerSchema, updateWebhookTriggerSchema, updateWorkflowSchema, } from './schema.js';
+import { createAutomationToolSurface, } from './tool-surface.js';
+const scheduleChangesSchema = z.object({
+    create: z.array(createScheduleTriggerSchema).max(100).optional(),
+    update: z.array(z.object({ id: identifierSchema, patch: updateScheduleTriggerSchema }).strict()).max(100).optional(),
+    delete: z.array(identifierSchema).max(100).optional(),
+}).strict();
+const webhookChangesSchema = z.object({
+    create: z.array(createWebhookTriggerSchema).max(100).optional(),
+    update: z.array(z.object({ id: identifierSchema, patch: updateWebhookTriggerSchema }).strict()).max(100).optional(),
+    delete: z.array(identifierSchema).max(100).optional(),
+}).strict();
+const workflowChangeSchema = z.union([
+    z.object({ create: createWorkflowSchema }).strict(),
+    z.object({ update: updateWorkflowSchema }).strict(),
+    z.object({ delete: z.literal(true) }).strict(),
+]);
+const definitions = [
+    define({
+        name: 'create',
+        title: 'Create automation',
+        description: 'Create one complete automation definition, including its schedules, webhooks, and optional workflow. Compiled version 1 remains action-only ({id, actionId, input}); use version 2 to mix Amalgm action steps with direct argv command steps ({id, kind:"command", command, args?, cwd?, env?, stdin?, timeoutMs?, maxOutputBytes?}) and explicit code steps ({id, kind:"script", runtime:"shell"|"node"|"python", source, args?, cwd?, env?, stdin?, timeoutMs?, maxOutputBytes?}). The service stages configuration disabled and enables it only after setup succeeds. Omit targetId in a machine-bound session; never guess a target id.',
+        schema: createAutomationSchema.extend({
+            schedules: z.array(createScheduleTriggerSchema).max(100).optional(),
+            webhooks: z.array(createWebhookTriggerSchema).max(100).optional(),
+            workflow: createWorkflowSchema.optional(),
+        }).strict(),
+        annotations: write(false),
+        run: (tools, input) => tools.create(input),
+    }),
+    define({
+        name: 'list',
+        title: 'List automations',
+        description: 'List the caller\'s automations with optional target, enabled-state, and pagination filters.',
+        schema: listAutomationsSchema,
+        annotations: read(),
+        run: (tools, input) => tools.list(input),
+    }),
+    define({
+        name: 'get',
+        title: 'Get automation',
+        description: 'Get one complete automation definition with its typed triggers and workflow. Recent run history is optional.',
+        schema: z.object({
+            automation_id: identifierSchema,
+            include_runs: z.boolean().optional(),
+            run_query: listRunsSchema.optional(),
+        }).strict(),
+        annotations: read(),
+        run: (tools, { automation_id, include_runs, run_query }) => (tools.get(automation_id, include_runs || run_query ? (run_query ?? { limit: 20 }) : false)),
+    }),
+    define({
+        name: 'update',
+        title: 'Update automation',
+        description: 'Update an automation and grouped trigger or workflow changes in one task-level call. Workflow plans use the same action, command, and script step forms accepted by create. Resource changes are staged while the automation is disabled; a failed change leaves a safe disabled draft.',
+        schema: z.object({
+            automation_id: identifierSchema,
+            patch: updateAutomationSchema.optional(),
+            schedules: scheduleChangesSchema.optional(),
+            webhooks: webhookChangesSchema.optional(),
+            workflow: workflowChangeSchema.optional(),
+        }).strict(),
+        annotations: write(false),
+        run: (tools, { automation_id, ...input }) => tools.update(automation_id, input),
+    }),
+    define({
+        name: 'delete',
+        title: 'Delete automation',
+        description: 'Delete an automation and its current triggers and workflow. Historical runs remain.',
+        schema: z.object({ automation_id: identifierSchema }).strict(),
+        annotations: destructive(),
+        run: (tools, { automation_id }) => tools.delete(automation_id),
+    }),
+    define({
+        name: 'run-now',
+        title: 'Run automation now',
+        description: 'Durably admit one manual run using the automation\'s current enabled configuration and compiled workflow. The selected machine executes it through the normal pending-run queue; this call never executes the workflow inline.',
+        schema: z.object({
+            automation_id: identifierSchema,
+            input: runAutomationNowSchema.shape.input,
+            idempotency_key: runAutomationNowSchema.shape.idempotencyKey,
+        }).strict(),
+        annotations: write(false),
+        run: (tools, { automation_id, input, idempotency_key }) => tools.runNow(automation_id, {
+            ...(input === undefined ? {} : { input }),
+            ...(idempotency_key === undefined ? {} : { idempotencyKey: idempotency_key }),
+        }),
+    }),
+];
+export const automationCommandDefinitions = Object.freeze(definitions);
+export function createAutomationCommands(sdk) {
+    const tools = createAutomationToolSurface(sdk);
+    return Object.freeze({
+        execute(name, input = {}) {
+            return automationCommandDefinition(name).invoke(tools, input);
+        },
+    });
+}
+export function automationCommandDefinition(name) {
+    const definition = automationCommandDefinitions.find((candidate) => candidate.name === name);
+    if (!definition)
+        throw new ValidationError(`Unknown Automations command: ${name}`);
+    return definition;
+}
+function define(input) {
+    return Object.freeze({
+        name: input.name,
+        mcpName: `amalgm_automations_${input.name.replace('-', '_')}`,
+        title: input.title,
+        description: input.description,
+        inputShape: input.schema.shape,
+        annotations: input.annotations,
+        invoke: (tools, value) => input.run(tools, parse(input.schema, value)),
+    });
+}
+function read() {
+    return Object.freeze({ readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false });
+}
+function write(idempotentHint) {
+    return Object.freeze({ readOnlyHint: false, destructiveHint: false, idempotentHint, openWorldHint: false });
+}
+function destructive() {
+    return Object.freeze({ readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false });
+}

package/dist/src/contract.d.ts

@@ -2,7 +2,7 @@ export type Json = null | boolean | number | string | Json[] | {
     [key: string]: Json;
 };
 import type { AutomationRun, ListRuns, RunAutomationNow } from './run-contract.js';
-export type { AutomationPlan, AutomationRun, AutomationRunJournal, AutomationStepRun, AutomationStepStatus, ListRuns, RunAutomationNow, RunStatus, ToolActionStep, } from './run-contract.js';
+export type { AutomationActionPlan, AutomationPlan, AutomationRun, AutomationRunJournal, AutomationScriptRuntime, AutomationStep, AutomationStepRun, AutomationStepStatus, AutomationTypedPlan, CodeScriptStep, DirectCommandStep, ListRuns, RunAutomationNow, RunStatus, ToolActionStep, } from './run-contract.js';
 export type AutomationScope = 'automations:read' | 'automations:write' | 'runs:read' | 'runs:execute' | '*';
 /** Identity resolved by Amalgm before the SDK is bound to a caller. */
 export interface AutomationPrincipal {

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

@@ -0,0 +1,28 @@
+import type { CodeScriptStep, DirectCommandStep, Json } from './contract.js';
+export interface AutomationActionPort {
+    call(input: Readonly<{
+        actionId: string;
+        payload: Json;
+        idempotencyKey: string;
+        signal: AbortSignal;
+    }>): Promise<Json>;
+}
+export type AutomationProcessExecution = Readonly<Omit<DirectCommandStep, 'id' | 'stdin'> & {
+    stdin?: string;
+    idempotencyKey: string;
+    signal: AbortSignal;
+} | Omit<CodeScriptStep, 'id' | 'stdin'> & {
+    stdin?: string;
+    idempotencyKey: string;
+    signal: AbortSignal;
+}>;
+export interface AutomationProcessPort {
+    execute(input: AutomationProcessExecution): Promise<Json>;
+}
+export interface AutomationRunExecutorOptions {
+    readonly now?: () => Date;
+    readonly heartbeatMs?: number;
+    readonly maxAttempts?: number;
+    readonly retryDelayMs?: (attempt: number) => number;
+    readonly processes?: AutomationProcessPort;
+}

package/dist/src/execution-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/src/execution-errors.d.ts

@@ -0,0 +1,6 @@
+import type { Json } from './contract.js';
+export declare function transientFailure(error: unknown): boolean;
+export declare function safeError(error: unknown): string;
+export declare function errorOutput(error: unknown): {
+    output?: Json;
+};

package/dist/src/execution-errors.js

@@ -0,0 +1,48 @@
+export function transientFailure(error) {
+    for (let current = error, depth = 0; current && depth < 4; depth += 1) {
+        if (typeof current !== 'object')
+            break;
+        const item = current;
+        const status = Number(item.status);
+        if (status === 408 || status === 429 || status >= 500)
+            return true;
+        const code = String(item.code ?? '');
+        if (TRANSIENT_CODES.has(code))
+            return true;
+        current = item.cause;
+    }
+    const message = safeError(error).toLowerCase();
+    return message.includes('fetch failed') || message.includes('network error');
+}
+export function safeError(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, ' ').slice(0, 1_000);
+}
+export function errorOutput(error) {
+    if (!error || typeof error !== 'object')
+        return {};
+    const output = error.output;
+    return isJson(output) ? { output } : {};
+}
+const TRANSIENT_CODES = new Set([
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EAI_AGAIN',
+    'ENETDOWN',
+    'ENETUNREACH',
+    'ETIMEDOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_SOCKET',
+    'internal',
+]);
+function isJson(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJson);
+    return Boolean(value) && typeof value === 'object'
+        && Object.getPrototypeOf(value) === Object.prototype
+        && Object.values(value).every(isJson);
+}

package/dist/src/executor.d.ts

@@ -1,20 +1,8 @@
-import type { Json } from './contract.js';
+import type { AutomationActionPort, AutomationRunExecutorOptions } from './execution-contract.js';
 import type { ClaimedAutomationRun, MachineRuns } from './machine.js';
 export { automationPlan } from './plan.js';
-export interface AutomationActionPort {
-    call(input: Readonly<{
-        actionId: string;
-        payload: Json;
-        idempotencyKey: string;
-        signal: AbortSignal;
-    }>): Promise<Json>;
-}
-export interface AutomationRunExecutorOptions {
-    readonly now?: () => Date;
-    readonly heartbeatMs?: number;
-    readonly maxAttempts?: number;
-    readonly retryDelayMs?: (attempt: number) => number;
-}
+export { transientFailure } from './execution-errors.js';
+export type { AutomationActionPort, AutomationProcessExecution, AutomationProcessPort, AutomationRunExecutorOptions, } from './execution-contract.js';
 export declare class AutomationRunExecutor {
     #private;
     private readonly runs;
@@ -22,4 +10,3 @@ export declare class AutomationRunExecutor {
     constructor(runs: MachineRuns, actions: AutomationActionPort, options?: AutomationRunExecutorOptions);
     execute(run: ClaimedAutomationRun): Promise<void>;
 }
-export declare function transientFailure(error: unknown): boolean;

package/dist/src/executor.js

@@ -1,7 +1,9 @@
-import { resolveActionInput } from './input-template.js';
+import { resolveInputTemplate } from './input-template.js';
 import { automationPlan } from './plan.js';
+import { errorOutput, safeError, transientFailure } from './execution-errors.js';
 import { completed, emptyJournal, journalJson, putStep, runJournal, stepAttempt, } from './run-journal.js';
 export { automationPlan } from './plan.js';
+export { transientFailure } from './execution-errors.js';
 export class AutomationRunExecutor {
     runs;
     actions;
@@ -9,6 +11,7 @@ export class AutomationRunExecutor {
     #heartbeatMs;
     #maxAttempts;
     #retryDelayMs;
+    #processes;
     constructor(runs, actions, options = {}) {
         this.runs = runs;
         this.actions = actions;
@@ -16,6 +19,7 @@ export class AutomationRunExecutor {
         this.#heartbeatMs = integer(options.heartbeatMs ?? 20_000, 1, 'heartbeatMs');
         this.#maxAttempts = integer(options.maxAttempts ?? 5, 1, 'maxAttempts');
         this.#retryDelayMs = options.retryDelayMs ?? defaultRetryDelayMs;
+        this.#processes = options.processes;
     }
     async execute(run) {
         const confirmed = await this.runs.update(run.id, {
@@ -60,6 +64,7 @@ export class AutomationRunExecutor {
                         finishedAt: this.#now().toISOString(),
                         error,
                         failureKind,
+                        ...errorOutput(action.error),
                     });
                     if (failureKind === 'transient' && run.attempts < this.#maxAttempts) {
                         await this.runs.update(run.id, {
@@ -137,12 +142,7 @@ export class AutomationRunExecutor {
         const timer = setInterval(renew, this.#heartbeatMs);
         timer.unref?.();
         try {
-            const output = await this.actions.call({
-                actionId: step.actionId,
-                payload: resolveActionInput(step.input, run.input),
-                idempotencyKey: `${run.id}:${step.id}`,
-                signal: controller.signal,
-            });
+            const output = await this.#executeStep(run, step, controller.signal);
             return leaseLost ? { leaseLost: true } : { leaseLost: false, output };
         }
         catch (error) {
@@ -154,35 +154,30 @@ export class AutomationRunExecutor {
             await heartbeat;
         }
     }
-}
-export function transientFailure(error) {
-    for (let current = error, depth = 0; current && depth < 4; depth += 1) {
-        if (typeof current !== 'object')
-            break;
-        const item = current;
-        const status = Number(item.status);
-        if (status === 408 || status === 429 || status >= 500)
-            return true;
-        const code = String(item.code ?? '');
-        if (TRANSIENT_CODES.has(code))
-            return true;
-        current = item.cause;
+    #executeStep(run, step, signal) {
+        const idempotencyKey = `${run.id}:${step.id}`;
+        if ('kind' in step) {
+            if (!this.#processes) {
+                throw Object.assign(new Error('Automation process execution is not installed on this machine'), {
+                    code: 'process_execution_unavailable',
+                });
+            }
+            const { id: _id, stdin, ...execution } = step;
+            return this.#processes.execute({
+                ...execution,
+                ...(stdin === undefined ? {} : { stdin: processStdin(resolveInputTemplate(stdin, run.input)) }),
+                idempotencyKey,
+                signal,
+            });
+        }
+        return this.actions.call({
+            actionId: step.actionId,
+            payload: resolveInputTemplate(step.input, run.input),
+            idempotencyKey,
+            signal,
+        });
     }
-    const message = safeError(error).toLowerCase();
-    return message.includes('fetch failed') || message.includes('network error');
 }
-const TRANSIENT_CODES = new Set([
-    'ECONNREFUSED',
-    'ECONNRESET',
-    'EAI_AGAIN',
-    'ENETDOWN',
-    'ENETUNREACH',
-    'ETIMEDOUT',
-    'UND_ERR_CONNECT_TIMEOUT',
-    'UND_ERR_HEADERS_TIMEOUT',
-    'UND_ERR_SOCKET',
-    'internal',
-]);
 function defaultRetryDelayMs(attempt) {
     return Math.min(5 * 60_000, 2_000 * (2 ** Math.max(0, attempt - 1)));
 }
@@ -191,6 +186,6 @@ function integer(value, minimum, name) {
         throw new Error(`${name} must be an integer of at least ${minimum}`);
     return value;
 }
-function safeError(error) {
-    return (error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/g, ' ').slice(0, 1_000);
+function processStdin(value) {
+    return typeof value === 'string' ? value : `${JSON.stringify(value)}\n`;
 }