@forestadmin/workflow-executor 1.0.0

package/dist/adapters/server-types.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Local mirror of the orchestrator's contract.
+ * See forestadmin-server/packages/private-api/src/domain/workflow-orchestrator/types.ts
+ *
+ * Contains both step-level types (workflow step variants) and the run envelope
+ * (HydratedWorkflowRun + user profile + step history).
+ */
+export interface ServerWorkflowTransition {
+    stepId: string;
+    buttonText: string | null;
+    buttonColor?: string | null;
+    answer?: string;
+}
+export declare enum ServerStepTypeEnum {
+    Task = "task",
+    Condition = "condition",
+    End = "end",
+    Escalation = "escalation",
+    StartSubWorkflow = "start-sub-workflow",
+    CloseSubWorkflow = "close-sub-workflow"
+}
+export declare enum ServerTaskTypeEnum {
+    Guideline = "guideline",
+    TriggerAction = "trigger-action",
+    GetData = "get-data",
+    UpdateData = "update-data",
+    LoadRelatedRecord = "load-related-record",
+    McpServer = "mcp-server"
+}
+export declare enum ServerStepExecutionTypeEnum {
+    Manual = "manual",
+    AutomatedWithConfirmation = "automated-with-confirmation",
+    FullyAutomated = "fully-automated"
+}
+interface ServerWorkflowStepBase {
+    type: ServerStepTypeEnum;
+    title: string;
+    prompt?: string;
+    executionType: ServerStepExecutionTypeEnum;
+    automaticCompletion: boolean;
+    outgoing: ServerWorkflowTransition[];
+}
+export interface ServerWorkflowTaskBase extends ServerWorkflowStepBase {
+    type: ServerStepTypeEnum.Task;
+    taskType: ServerTaskTypeEnum;
+    isSubTask?: boolean;
+    prompt: string;
+    outgoing: [ServerWorkflowTransition];
+}
+export interface ServerWorkflowTaskGuideline extends ServerWorkflowTaskBase {
+    taskType: ServerTaskTypeEnum.Guideline;
+    executionType: ServerStepExecutionTypeEnum.Manual;
+    completionType: 'simple' | 'user-input';
+    inputType?: 'free-text';
+    automaticCompletion: false;
+}
+interface ServerWorkflowTaskGetData extends ServerWorkflowTaskBase {
+    taskType: ServerTaskTypeEnum.GetData;
+    executionType: ServerStepExecutionTypeEnum.FullyAutomated;
+}
+interface ServerWorkflowTaskUpdateData extends ServerWorkflowTaskBase {
+    taskType: ServerTaskTypeEnum.UpdateData;
+    executionType: ServerStepExecutionTypeEnum.FullyAutomated | ServerStepExecutionTypeEnum.AutomatedWithConfirmation;
+}
+interface ServerWorkflowTaskTriggerAction extends ServerWorkflowTaskBase {
+    taskType: ServerTaskTypeEnum.TriggerAction;
+    executionType: ServerStepExecutionTypeEnum.FullyAutomated | ServerStepExecutionTypeEnum.AutomatedWithConfirmation;
+}
+interface ServerWorkflowTaskLoadRelatedRecord extends ServerWorkflowTaskBase {
+    taskType: ServerTaskTypeEnum.LoadRelatedRecord;
+    executionType: ServerStepExecutionTypeEnum.FullyAutomated | ServerStepExecutionTypeEnum.AutomatedWithConfirmation;
+}
+export interface ServerWorkflowTaskMcpServer extends ServerWorkflowTaskBase {
+    taskType: ServerTaskTypeEnum.McpServer;
+    executionType: ServerStepExecutionTypeEnum.FullyAutomated | ServerStepExecutionTypeEnum.AutomatedWithConfirmation;
+    mcpServerId: string;
+}
+export type ServerWorkflowTask = ServerWorkflowTaskGuideline | ServerWorkflowTaskGetData | ServerWorkflowTaskUpdateData | ServerWorkflowTaskTriggerAction | ServerWorkflowTaskLoadRelatedRecord | ServerWorkflowTaskMcpServer;
+export interface ServerWorkflowEnd extends ServerWorkflowStepBase {
+    type: ServerStepTypeEnum.End;
+    executionType: ServerStepExecutionTypeEnum.Manual;
+    automaticCompletion: false;
+    outgoing: [];
+}
+export interface ServerWorkflowCondition extends ServerWorkflowStepBase {
+    type: ServerStepTypeEnum.Condition;
+    executionType: ServerStepExecutionTypeEnum.Manual | ServerStepExecutionTypeEnum.FullyAutomated;
+    prompt: string;
+    automaticCompletion: false;
+}
+export interface ServerWorkflowEscalation extends ServerWorkflowStepBase {
+    type: ServerStepTypeEnum.Escalation;
+    prompt: string;
+    outgoing: [ServerWorkflowTransition];
+    inboxId: string | null;
+}
+export interface ServerStartSubWorkflow extends ServerWorkflowStepBase {
+    type: ServerStepTypeEnum.StartSubWorkflow;
+    executionType: ServerStepExecutionTypeEnum.Manual;
+    outgoing: [ServerWorkflowTransition];
+    workflowId: string;
+}
+export interface ServerCloseSubWorkflow extends ServerWorkflowStepBase {
+    type: ServerStepTypeEnum.CloseSubWorkflow;
+    executionType: ServerStepExecutionTypeEnum.Manual;
+    outgoing: [ServerWorkflowTransition];
+    parentWorkflowId: string | null;
+}
+export type ServerWorkflowStep = ServerWorkflowTask | ServerWorkflowCondition | ServerWorkflowEnd | ServerWorkflowEscalation | ServerStartSubWorkflow | ServerCloseSubWorkflow;
+export interface ServerUserProfile {
+    id: number;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    team: string | null;
+    renderingId: number;
+    role: string | null;
+    permissionLevel: string | null;
+    tags: Record<string, string>;
+    serverToken: string;
+}
+export interface ServerStepHistory {
+    stepName: string;
+    stepIndex: number;
+    done: boolean;
+    revised?: boolean;
+    cancelled?: boolean;
+    originalStepIndex?: number;
+    context?: Record<string, unknown>;
+    childrenWorkflowId?: string;
+    stepDefinition: ServerWorkflowStep;
+}
+/** Mirror of the server's `WorkflowRunState` enum (workflow-run-model.ts). */
+export type ServerWorkflowRunState = 'started' | 'pending' | 'loading' | 'aborted' | 'finished';
+export interface ServerHydratedWorkflowRun {
+    id: number;
+    workflowId: string;
+    collectionId: string;
+    collectionName: string | null;
+    selectedRecordId: string;
+    bpmnVersion: string;
+    runState: ServerWorkflowRunState;
+    workflowHistory: ServerStepHistory[];
+    /** Server types declare `Date`; Express serializes to ISO 8601 string on the wire. */
+    createdAt: string;
+    updatedAt: string;
+    userId: number;
+    renderingId: number;
+    lockedAt?: string | null;
+    userProfile: ServerUserProfile;
+}
+export interface ServerStepHistoryUpdate {
+    /** Accepted by the server Joi schema; missing from the server TS type (server-side gap). */
+    isLoading?: boolean;
+    done?: boolean;
+    revised?: boolean;
+    cancelled?: boolean;
+    context?: Record<string, unknown>;
+}
+export interface ServerStepUpdate {
+    stepIndex: number;
+    attributes: ServerStepHistoryUpdate;
+}
+export type ServerExecutionStatus = 
+/** `nextStepId` is accepted by the server Joi schema; missing from the server TS type. */
+{
+    type: 'success';
+    nextStepId?: string;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'awaiting-input';
+};
+export interface ServerUpdateStepRequest {
+    runId: number;
+    stepUpdate: ServerStepUpdate;
+    executionStatus: ServerExecutionStatus;
+}
+export {};
+//# sourceMappingURL=server-types.d.ts.map

package/dist/adapters/server-types.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Local mirror of the orchestrator's contract.
+ * See forestadmin-server/packages/private-api/src/domain/workflow-orchestrator/types.ts
+ *
+ * Contains both step-level types (workflow step variants) and the run envelope
+ * (HydratedWorkflowRun + user profile + step history).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerStepExecutionTypeEnum = exports.ServerTaskTypeEnum = exports.ServerStepTypeEnum = void 0;
+var ServerStepTypeEnum;
+(function (ServerStepTypeEnum) {
+    ServerStepTypeEnum["Task"] = "task";
+    ServerStepTypeEnum["Condition"] = "condition";
+    ServerStepTypeEnum["End"] = "end";
+    ServerStepTypeEnum["Escalation"] = "escalation";
+    ServerStepTypeEnum["StartSubWorkflow"] = "start-sub-workflow";
+    ServerStepTypeEnum["CloseSubWorkflow"] = "close-sub-workflow";
+})(ServerStepTypeEnum || (exports.ServerStepTypeEnum = ServerStepTypeEnum = {}));
+var ServerTaskTypeEnum;
+(function (ServerTaskTypeEnum) {
+    ServerTaskTypeEnum["Guideline"] = "guideline";
+    ServerTaskTypeEnum["TriggerAction"] = "trigger-action";
+    ServerTaskTypeEnum["GetData"] = "get-data";
+    ServerTaskTypeEnum["UpdateData"] = "update-data";
+    ServerTaskTypeEnum["LoadRelatedRecord"] = "load-related-record";
+    ServerTaskTypeEnum["McpServer"] = "mcp-server";
+})(ServerTaskTypeEnum || (exports.ServerTaskTypeEnum = ServerTaskTypeEnum = {}));
+var ServerStepExecutionTypeEnum;
+(function (ServerStepExecutionTypeEnum) {
+    ServerStepExecutionTypeEnum["Manual"] = "manual";
+    ServerStepExecutionTypeEnum["AutomatedWithConfirmation"] = "automated-with-confirmation";
+    ServerStepExecutionTypeEnum["FullyAutomated"] = "fully-automated";
+})(ServerStepExecutionTypeEnum || (exports.ServerStepExecutionTypeEnum = ServerStepExecutionTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLXR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FkYXB0ZXJzL3NlcnZlci10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFTSCxJQUFZLGtCQU9YO0FBUEQsV0FBWSxrQkFBa0I7SUFDNUIsbUNBQWEsQ0FBQTtJQUNiLDZDQUF1QixDQUFBO0lBQ3ZCLGlDQUFXLENBQUE7SUFDWCwrQ0FBeUIsQ0FBQTtJQUN6Qiw2REFBdUMsQ0FBQTtJQUN2Qyw2REFBdUMsQ0FBQTtBQUN6QyxDQUFDLEVBUFcsa0JBQWtCLGtDQUFsQixrQkFBa0IsUUFPN0I7QUFFRCxJQUFZLGtCQU9YO0FBUEQsV0FBWSxrQkFBa0I7SUFDNUIsNkNBQXVCLENBQUE7SUFDdkIsc0RBQWdDLENBQUE7SUFDaEMsMENBQW9CLENBQUE7SUFDcEIsZ0RBQTBCLENBQUE7SUFDMUIsK0RBQXlDLENBQUE7SUFDekMsOENBQXdCLENBQUE7QUFDMUIsQ0FBQyxFQVBXLGtCQUFrQixrQ0FBbEIsa0JBQWtCLFFBTzdCO0FBRUQsSUFBWSwyQkFJWDtBQUpELFdBQVksMkJBQTJCO0lBQ3JDLGdEQUFpQixDQUFBO0lBQ2pCLHdGQUF5RCxDQUFBO0lBQ3pELGlFQUFrQyxDQUFBO0FBQ3BDLENBQUMsRUFKVywyQkFBMkIsMkNBQTNCLDJCQUEyQixRQUl0QyJ9

package/dist/adapters/step-definition-mapper.d.ts

@@ -0,0 +1,4 @@
+import type { ServerWorkflowStep } from './server-types';
+import type { StepDefinition } from '../types/validated/step-definition';
+export default function toStepDefinition(serverStep: ServerWorkflowStep): StepDefinition;
+//# sourceMappingURL=step-definition-mapper.d.ts.map

package/dist/adapters/step-definition-mapper.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = toStepDefinition;
+const server_types_1 = require("./server-types");
+const errors_1 = require("../errors");
+const step_definition_1 = require("../types/validated/step-definition");
+function mapTask(task) {
+    // executionType is passed through as-is; each schema's .default().catch() handles
+    // missing or unsupported values without requiring an explicit mapping here.
+    const base = { prompt: task.prompt, executionType: task.executionType, title: task.title };
+    switch (task.taskType) {
+        case server_types_1.ServerTaskTypeEnum.McpServer:
+            return step_definition_1.McpStepDefinitionSchema.parse({
+                ...base,
+                type: step_definition_1.StepType.Mcp,
+                mcpServerId: task.mcpServerId,
+            });
+        case server_types_1.ServerTaskTypeEnum.Guideline:
+            return step_definition_1.GuidanceStepDefinitionSchema.parse({ ...base, type: step_definition_1.StepType.Guidance });
+        case server_types_1.ServerTaskTypeEnum.GetData:
+            return step_definition_1.ReadRecordStepDefinitionSchema.parse({ ...base, type: step_definition_1.StepType.ReadRecord });
+        case server_types_1.ServerTaskTypeEnum.UpdateData:
+            return step_definition_1.UpdateRecordStepDefinitionSchema.parse({ ...base, type: step_definition_1.StepType.UpdateRecord });
+        case server_types_1.ServerTaskTypeEnum.TriggerAction:
+            return step_definition_1.TriggerActionStepDefinitionSchema.parse({ ...base, type: step_definition_1.StepType.TriggerAction });
+        case server_types_1.ServerTaskTypeEnum.LoadRelatedRecord:
+            return step_definition_1.LoadRelatedRecordStepDefinitionSchema.parse({
+                ...base,
+                type: step_definition_1.StepType.LoadRelatedRecord,
+            });
+        default:
+            throw new errors_1.InvalidStepDefinitionError(`Unknown taskType: "${task.taskType}"`);
+    }
+}
+function mapCondition(condition) {
+    const options = condition.outgoing
+        .map(t => t.answer ?? t.buttonText)
+        .filter((v) => typeof v === 'string' && v.length > 0);
+    if (options.length < 2) {
+        throw new errors_1.InvalidStepDefinitionError(`Condition step requires at least 2 options, got ${options.length}`);
+    }
+    return step_definition_1.ConditionStepDefinitionSchema.parse({
+        type: step_definition_1.StepType.Condition,
+        prompt: condition.prompt,
+        executionType: condition.executionType,
+        title: condition.title,
+        options,
+    });
+}
+// Server uses `type:'task' + taskType` for non-condition steps and `outgoing[]` for conditions;
+// executor uses flat StepDefinition with `options[]`. Unsupported server types
+// (end/escalation/sub-workflow) throw UnsupportedStepTypeError.
+function toStepDefinition(serverStep) {
+    switch (serverStep.type) {
+        case 'task':
+            return mapTask(serverStep);
+        case 'condition':
+            return mapCondition(serverStep);
+        case 'end':
+        case 'escalation':
+        case 'start-sub-workflow':
+        case 'close-sub-workflow':
+            throw new errors_1.UnsupportedStepTypeError(serverStep.type);
+        default:
+            throw new errors_1.InvalidStepDefinitionError(`Unknown server step type: "${serverStep.type}"`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/step-outcome-to-update-step-mapper.d.ts

@@ -0,0 +1,4 @@
+import type { ServerUpdateStepRequest } from './server-types';
+import type { StepOutcome } from '../types/validated/step-outcome';
+export default function toUpdateStepRequest(runId: string, outcome: StepOutcome): ServerUpdateStepRequest;
+//# sourceMappingURL=step-outcome-to-update-step-mapper.d.ts.map

package/dist/adapters/step-outcome-to-update-step-mapper.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = toUpdateStepRequest;
+function toExecutionStatus(outcome) {
+    if (outcome.status === 'error') {
+        // Joi.string().required() on the server rejects empty strings — fall back
+        // so an executor that produces error='' doesn't trigger an infinite re-dispatch.
+        return { type: 'error', message: outcome.error || 'Unknown error' };
+    }
+    if (outcome.status === 'awaiting-input') {
+        return { type: 'awaiting-input' };
+    }
+    return { type: 'success' };
+}
+// Write to `context` so the round-trip with run-to-available-step-mapper stays ISO (reverse mapper
+// reads status/error/selectedOption from ServerStepHistory.context).
+function toUpdateStepRequest(runId, outcome) {
+    const context = { status: outcome.status };
+    if (outcome.error !== undefined)
+        context.error = outcome.error;
+    if (outcome.type === 'condition' && outcome.selectedOption !== undefined) {
+        context.selectedOption = outcome.selectedOption;
+    }
+    const attributes = {
+        done: outcome.status !== 'awaiting-input',
+        context,
+    };
+    return {
+        runId: Number(runId),
+        stepUpdate: { stepIndex: outcome.stepIndex, attributes },
+        executionStatus: toExecutionStatus(outcome),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcC1vdXRjb21lLXRvLXVwZGF0ZS1zdGVwLW1hcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hZGFwdGVycy9zdGVwLW91dGNvbWUtdG8tdXBkYXRlLXN0ZXAtbWFwcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBdUJBLHNDQXFCQztBQXJDRCxTQUFTLGlCQUFpQixDQUFDLE9BQW9CO0lBQzdDLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxPQUFPLEVBQUUsQ0FBQztRQUMvQiwwRUFBMEU7UUFDMUUsaUZBQWlGO1FBQ2pGLE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxPQUFPLENBQUMsS0FBSyxJQUFJLGVBQWUsRUFBRSxDQUFDO0lBQ3RFLENBQUM7SUFFRCxJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssZ0JBQWdCLEVBQUUsQ0FBQztRQUN4QyxPQUFPLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLENBQUM7SUFDcEMsQ0FBQztJQUVELE9BQU8sRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLENBQUM7QUFDN0IsQ0FBQztBQUVELG1HQUFtRztBQUNuRyxxRUFBcUU7QUFDckUsU0FBd0IsbUJBQW1CLENBQ3pDLEtBQWEsRUFDYixPQUFvQjtJQUVwQixNQUFNLE9BQU8sR0FBNEIsRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQ3BFLElBQUksT0FBTyxDQUFDLEtBQUssS0FBSyxTQUFTO1FBQUUsT0FBTyxDQUFDLEtBQUssR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDO0lBRS9ELElBQUksT0FBTyxDQUFDLElBQUksS0FBSyxXQUFXLElBQUksT0FBTyxDQUFDLGNBQWMsS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUN6RSxPQUFPLENBQUMsY0FBYyxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUM7SUFDbEQsQ0FBQztJQUVELE1BQU0sVUFBVSxHQUE0QjtRQUMxQyxJQUFJLEVBQUUsT0FBTyxDQUFDLE1BQU0sS0FBSyxnQkFBZ0I7UUFDekMsT0FBTztLQUNSLENBQUM7SUFFRixPQUFPO1FBQ0wsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUM7UUFDcEIsVUFBVSxFQUFFLEVBQUUsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTLEVBQUUsVUFBVSxFQUFFO1FBQ3hELGVBQWUsRUFBRSxpQkFBaUIsQ0FBQyxPQUFPLENBQUM7S0FDNUMsQ0FBQztBQUNKLENBQUMifQ==

package/dist/adapters/with-retry.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from '../ports/logger-port';
+export default function withRetry<T>(label: string, fn: () => Promise<T>, { logger, extraRetryStatuses }: {
+    logger: Logger;
+    extraRetryStatuses?: number[];
+}): Promise<T>;
+//# sourceMappingURL=with-retry.d.ts.map

package/dist/adapters/with-retry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = withRetry;
+const errors_1 = require("../errors");
+const RETRY_DELAYS_MS = [100, 500, 2000];
+const RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
+function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+function isRetryable(err, extra) {
+    const { status } = err;
+    if (typeof status !== 'number')
+        return false;
+    return RETRYABLE_STATUS.has(status) || extra.includes(status);
+}
+async function withRetry(label, fn, { logger, extraRetryStatuses = [] }) {
+    let lastError;
+    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt += 1) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            if (!isRetryable(err, extraRetryStatuses) || attempt === RETRY_DELAYS_MS.length)
+                throw err;
+            logger.warn(`"${label}" failed, retrying`, {
+                attempt: attempt + 1,
+                status: err.status,
+                error: (0, errors_1.extractErrorMessage)(err),
+            });
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(RETRY_DELAYS_MS[attempt]);
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1yZXRyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hZGFwdGVycy93aXRoLXJldHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBb0JBLDRCQXlCQztBQTNDRCxzQ0FBZ0Q7QUFFaEQsTUFBTSxlQUFlLEdBQUcsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLElBQUssQ0FBQyxDQUFDO0FBQzFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxHQUFHLENBQUMsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFFakUsU0FBUyxLQUFLLENBQUMsRUFBVTtJQUN2QixPQUFPLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFO1FBQzNCLFVBQVUsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDMUIsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsU0FBUyxXQUFXLENBQUMsR0FBWSxFQUFFLEtBQWU7SUFDaEQsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLEdBQTBCLENBQUM7SUFDOUMsSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFFN0MsT0FBTyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksS0FBSyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUNoRSxDQUFDO0FBRWMsS0FBSyxVQUFVLFNBQVMsQ0FDckMsS0FBYSxFQUNiLEVBQW9CLEVBQ3BCLEVBQUUsTUFBTSxFQUFFLGtCQUFrQixHQUFHLEVBQUUsRUFBcUQ7SUFFdEYsSUFBSSxTQUFrQixDQUFDO0lBRXZCLEtBQUssSUFBSSxPQUFPLEdBQUcsQ0FBQyxFQUFFLE9BQU8sSUFBSSxlQUFlLENBQUMsTUFBTSxFQUFFLE9BQU8sSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUN0RSxJQUFJLENBQUM7WUFDSCw0Q0FBNEM7WUFDNUMsT0FBTyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3BCLENBQUM7UUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2IsU0FBUyxHQUFHLEdBQUcsQ0FBQztZQUNoQixJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsRUFBRSxrQkFBa0IsQ0FBQyxJQUFJLE9BQU8sS0FBSyxlQUFlLENBQUMsTUFBTTtnQkFBRSxNQUFNLEdBQUcsQ0FBQztZQUMzRixNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksS0FBSyxvQkFBb0IsRUFBRTtnQkFDekMsT0FBTyxFQUFFLE9BQU8sR0FBRyxDQUFDO2dCQUNwQixNQUFNLEVBQUcsR0FBMkIsQ0FBQyxNQUFNO2dCQUMzQyxLQUFLLEVBQUUsSUFBQSw0QkFBbUIsRUFBQyxHQUFHLENBQUM7YUFDaEMsQ0FBQyxDQUFDO1lBQ0gsNENBQTRDO1lBQzVDLE1BQU0sS0FBSyxDQUFDLGVBQWUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1FBQ3hDLENBQUM7SUFDSCxDQUFDO0lBRUQsTUFBTSxTQUFTLENBQUM7QUFDbEIsQ0FBQyJ9

package/dist/build-workflow-executor.d.ts

@@ -0,0 +1,35 @@
+import type { Logger } from './ports/logger-port';
+import type { RunnerState } from './runner';
+import type { AiConfiguration } from '@forestadmin/ai-proxy';
+import type { Options as SequelizeOptions } from 'sequelize';
+export interface WorkflowExecutor {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    readonly state: RunnerState;
+}
+export interface ExecutorOptions {
+    envSecret: string;
+    authSecret: string;
+    agentUrl: string;
+    httpPort: number;
+    forestServerUrl?: string;
+    aiConfigurations?: AiConfiguration[];
+    pollingIntervalMs?: number;
+    logger?: Logger;
+    stopTimeoutMs?: number;
+    stepTimeoutMs?: number;
+    aiInvokeTimeoutMs?: number;
+    maxChainDepth?: number;
+    schemaCacheTtlMs?: number;
+    forceAiError?: boolean;
+}
+export type DatabaseExecutorOptions = ExecutorOptions & ({
+    database: SequelizeOptions & {
+        uri: string;
+    };
+} | {
+    database: SequelizeOptions;
+});
+export declare function buildInMemoryExecutor(options: ExecutorOptions): WorkflowExecutor;
+export declare function buildDatabaseExecutor(options: DatabaseExecutorOptions): WorkflowExecutor;
+//# sourceMappingURL=build-workflow-executor.d.ts.map

package/dist/build-workflow-executor.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInMemoryExecutor = buildInMemoryExecutor;
+exports.buildDatabaseExecutor = buildDatabaseExecutor;
+const forestadmin_client_1 = require("@forestadmin/forestadmin-client");
+const sequelize_1 = require("sequelize");
+const agent_client_agent_port_1 = __importDefault(require("./adapters/agent-client-agent-port"));
+const ai_client_adapter_1 = __importDefault(require("./adapters/ai-client-adapter"));
+const always_error_ai_model_port_1 = __importDefault(require("./adapters/always-error-ai-model-port"));
+const console_logger_1 = __importDefault(require("./adapters/console-logger"));
+const forest_server_workflow_port_1 = __importDefault(require("./adapters/forest-server-workflow-port"));
+const forestadmin_client_activity_log_port_factory_1 = __importDefault(require("./adapters/forestadmin-client-activity-log-port-factory"));
+const server_ai_adapter_1 = __importDefault(require("./adapters/server-ai-adapter"));
+const defaults_1 = require("./defaults");
+const executor_http_server_1 = __importDefault(require("./http/executor-http-server"));
+const runner_1 = __importDefault(require("./runner"));
+const schema_cache_1 = __importDefault(require("./schema-cache"));
+const database_store_1 = __importDefault(require("./stores/database-store"));
+const in_memory_store_1 = __importDefault(require("./stores/in-memory-store"));
+const FORCE_EXIT_DELAY_MS = 5000;
+// A bad timeout config (0, negative, non-finite) must fall back to the default rather than
+// silently disabling the timeout — `?? default` only catches null/undefined, not 0/negative.
+function positiveOrDefault(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function buildCommonDependencies(options) {
+    const forestServerUrl = options.forestServerUrl ?? defaults_1.DEFAULT_FOREST_SERVER_URL;
+    const logger = options.logger ?? new console_logger_1.default();
+    const workflowPort = new forest_server_workflow_port_1.default({
+        envSecret: options.envSecret,
+        forestServerUrl,
+        logger,
+    });
+    const forceAiError = options.forceAiError && process.env.NODE_ENV !== 'production';
+    if (forceAiError) {
+        logger.info('FORCE_AI_ERROR is enabled — AI calls will always fail. Do not use in production.', {});
+    }
+    else if (options.forceAiError && process.env.NODE_ENV === 'production') {
+        logger.info('FORCE_AI_ERROR is set but ignored in production.', {});
+    }
+    let aiModelPort;
+    if (forceAiError) {
+        aiModelPort = new always_error_ai_model_port_1.default();
+    }
+    else if (options.aiConfigurations?.length) {
+        aiModelPort = new ai_client_adapter_1.default(options.aiConfigurations);
+    }
+    else {
+        aiModelPort = new server_ai_adapter_1.default({ forestServerUrl, envSecret: options.envSecret });
+    }
+    // A TTL of 0/negative/non-finite would silently make the cache always-stale, so fall back.
+    const schemaCache = new schema_cache_1.default(positiveOrDefault(options.schemaCacheTtlMs, defaults_1.DEFAULT_SCHEMA_CACHE_TTL_MS));
+    const agentPort = new agent_client_agent_port_1.default({
+        agentUrl: options.agentUrl,
+        authSecret: options.authSecret,
+        schemaCache,
+    });
+    const activityLogsService = new forestadmin_client_1.ActivityLogsService(new forestadmin_client_1.ForestHttpApi(), {
+        forestServerUrl,
+        headers: { 'Forest-Application-Source': 'WorkflowExecutor' },
+    });
+    const activityLogPortFactory = new forestadmin_client_activity_log_port_factory_1.default(activityLogsService, logger);
+    return {
+        agentPort,
+        schemaCache,
+        workflowPort,
+        aiModelPort,
+        activityLogPortFactory,
+        logger,
+        pollingIntervalMs: options.pollingIntervalMs ?? defaults_1.DEFAULT_POLLING_INTERVAL_MS,
+        envSecret: options.envSecret,
+        authSecret: options.authSecret,
+        stopTimeoutMs: options.stopTimeoutMs,
+        stepTimeoutMs: positiveOrDefault(options.stepTimeoutMs, defaults_1.DEFAULT_STEP_TIMEOUT_MS),
+        aiInvokeTimeoutMs: positiveOrDefault(options.aiInvokeTimeoutMs, defaults_1.DEFAULT_AI_INVOKE_TIMEOUT_MS),
+        maxChainDepth: options.maxChainDepth,
+    };
+}
+function createWorkflowExecutor(runner, server, logger) {
+    let shutdownPromise = null;
+    const shutdown = async () => {
+        try {
+            await server.stop();
+        }
+        catch (err) {
+            logger.error('HTTP server close failed during shutdown', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        await runner.stop();
+    };
+    const onSignal = async () => {
+        logger.info?.('Received shutdown signal, stopping gracefully...', {});
+        try {
+            if (!shutdownPromise)
+                shutdownPromise = shutdown();
+            await shutdownPromise;
+            process.exitCode = 0;
+        }
+        catch (error) {
+            logger.error('Graceful shutdown failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            process.exitCode = 1;
+        }
+        // Safety net: force exit if the event loop doesn't drain
+        // eslint-disable-next-line no-console
+        setTimeout(() => {
+            logger.error('Process did not exit after shutdown — forcing exit', {});
+            process.exit(process.exitCode ?? 1);
+        }, FORCE_EXIT_DELAY_MS).unref();
+    };
+    return {
+        get state() {
+            return runner.state;
+        },
+        async start() {
+            await runner.start();
+            await server.start();
+            process.on('SIGTERM', onSignal);
+            process.on('SIGINT', onSignal);
+        },
+        async stop() {
+            process.removeListener('SIGTERM', onSignal);
+            process.removeListener('SIGINT', onSignal);
+            if (!shutdownPromise)
+                shutdownPromise = shutdown();
+            await shutdownPromise;
+        },
+    };
+}
+function buildInMemoryExecutor(options) {
+    const deps = buildCommonDependencies(options);
+    const runner = new runner_1.default({
+        ...deps,
+        runStore: new in_memory_store_1.default(),
+    });
+    const server = new executor_http_server_1.default({
+        port: options.httpPort,
+        runner,
+        authSecret: options.authSecret,
+        workflowPort: deps.workflowPort,
+        logger: deps.logger,
+    });
+    return createWorkflowExecutor(runner, server, deps.logger);
+}
+function buildDatabaseExecutor(options) {
+    const deps = buildCommonDependencies(options);
+    const { uri, ...sequelizeOptions } = options.database;
+    // Silence Sequelize's verbose SQL logger by default so our structured logs
+    // stay readable. Caller can still opt in via options.database.logging.
+    // An explicit `logging: undefined` in the caller overrides our default via
+    // spread, so we re-apply the default when the merged value ends up undefined.
+    const sequelizeDefaults = { logging: false };
+    const mergedOptions = { ...sequelizeDefaults, ...sequelizeOptions };
+    if (mergedOptions.logging === undefined)
+        mergedOptions.logging = false;
+    const sequelize = uri ? new sequelize_1.Sequelize(uri, mergedOptions) : new sequelize_1.Sequelize(mergedOptions);
+    const runner = new runner_1.default({
+        ...deps,
+        runStore: new database_store_1.default({ sequelize }),
+    });
+    const server = new executor_http_server_1.default({
+        port: options.httpPort,
+        runner,
+        authSecret: options.authSecret,
+        workflowPort: deps.workflowPort,
+        logger: deps.logger,
+    });
+    return createWorkflowExecutor(runner, server, deps.logger);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli-core.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from './ports/logger-port';
+import { type DatabaseExecutorOptions, type ExecutorOptions, type WorkflowExecutor } from './build-workflow-executor';
+export interface CliArgs {
+    help: boolean;
+    version: boolean;
+    inMemory: boolean;
+    pretty: boolean;
+    json: boolean;
+}
+export interface CliConfig {
+    executorOptions: ExecutorOptions;
+    databaseUrl?: string;
+    mode: 'in-memory' | 'database';
+}
+export interface CliFactories {
+    buildInMemory: (options: ExecutorOptions) => WorkflowExecutor;
+    buildDatabase: (options: DatabaseExecutorOptions) => WorkflowExecutor;
+}
+export declare function parseArgs(argv: string[]): CliArgs;
+export declare function pickLogger(args: CliArgs, stdout?: NodeJS.WriteStream): Logger;
+export declare function readEnvConfig(env: NodeJS.ProcessEnv, args: CliArgs): CliConfig;
+export declare function printHelp(): void;
+export declare function printVersion(): void;
+export declare function logStartup(logger: Logger, config: CliConfig): void;
+export declare function runCli(argv: string[], env: NodeJS.ProcessEnv, factories: CliFactories): Promise<WorkflowExecutor | null>;
+//# sourceMappingURL=cli-core.d.ts.map