@versori/run 0.2.13 → 0.2.15

package/script/src/dsl/http/versori/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cronPort = exports.envVarLocalRun = exports.envVarInternalToken = exports.envVarTokenEndpoint = exports.envVarClientSecret = exports.envVarClientId = exports.envVarConfigFile = exports.envVarVersion = exports.envVarOtelTracesURL = exports.envVarCredsBaseURL = exports.envVarSelfRefURL = exports.envVarCronApiBaseURL = exports.envVarPlatformApiBaseURL = exports.envVarOrgSlug = exports.envVarProjectId = exports.envVarEnvironmentName = exports.envVarEnvId = exports.envVarOrgId = void 0;
+exports.cronPort = exports.envVarLocalRun = exports.envVarInternalToken = exports.envVarTokenEndpoint = exports.envVarClientSecret = exports.envVarClientId = exports.envVarConfigFile = exports.envVarVersion = exports.envVarOtelTracesURL = exports.envVarCredsBaseURL = exports.envVarSelfRefURL = exports.envVarWorkflowApiBaseURL = exports.envVarCronApiBaseURL = exports.envVarPlatformApiBaseURL = exports.envVarOrgSlug = exports.envVarProjectId = exports.envVarEnvironmentName = exports.envVarEnvId = exports.envVarOrgId = void 0;
 // This file contains constants used in the Versori DSL HTTP client.
 exports.envVarOrgId = 'RUN_ORGANISATION_ID';
 exports.envVarEnvId = 'RUN_ENVIRONMENT_ID';
@@ -9,6 +9,7 @@ exports.envVarProjectId = 'RUN_SERVICE_ID';
 exports.envVarOrgSlug = 'RUN_ORGANISATION_SLUG';
 exports.envVarPlatformApiBaseURL = 'RUN_PLATFORM_API_INTERNAL_URL';
 exports.envVarCronApiBaseURL = 'RUN_CRON_API_INTERNAL_URL';
+exports.envVarWorkflowApiBaseURL = 'RUN_SDK_API_URL';
 exports.envVarSelfRefURL = 'RUN_SELF_REF_URL';
 exports.envVarCredsBaseURL = 'RUN_CREDENTIALS_SERVICE_INTERNAL_URL';
 exports.envVarOtelTracesURL = 'RUN_OTEL_TRACES_URL';

package/script/src/dsl/triggers/DurableTrigger.d.ts

@@ -0,0 +1,17 @@
+import { Taskable } from '../mod.js';
+import { Trigger, TriggerType } from '../Trigger.js';
+import { Workflow } from '../Workflow.js';
+export type DurableWorkflowOptions = {
+    ttl?: number;
+    limit?: number;
+};
+export type DurableWorkflowData = Record<string, unknown>;
+export declare class DurableWorkflowTrigger implements Trigger<DurableWorkflowData> {
+    id: string;
+    options: DurableWorkflowOptions;
+    [TriggerType]: string;
+    constructor(id: string, options?: DurableWorkflowOptions);
+    then<OO>(task: Taskable<DurableWorkflowData, OO>): Workflow<OO>;
+}
+export declare function workflow(id: string, options?: DurableWorkflowOptions): Trigger<DurableWorkflowData>;
+//# sourceMappingURL=DurableTrigger.d.ts.map

package/script/src/dsl/triggers/DurableTrigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DurableTrigger.d.ts","sourceRoot":"","sources":["../../../../src/src/dsl/triggers/DurableTrigger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAgB,MAAM,gBAAgB,CAAC;AAExD,MAAM,MAAM,sBAAsB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1D,qBAAa,sBAAuB,YAAW,OAAO,CAAC,mBAAmB,CAAC;IACvE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,sBAAsB,CAAC;IAEhC,CAAC,WAAW,CAAC,EAAE,MAAM,CAAqB;gBAE9B,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,sBAA2B;IAK5D,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,mBAAmB,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;CAIlE;AAED,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAEnG"}

package/script/src/dsl/triggers/DurableTrigger.js

@@ -0,0 +1,41 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurableWorkflowTrigger = void 0;
+exports.workflow = workflow;
+const ensureTask_js_1 = require("../ensureTask.js");
+const Trigger_js_1 = require("../Trigger.js");
+const Workflow_js_1 = require("../Workflow.js");
+class DurableWorkflowTrigger {
+    constructor(id, options = {}) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'durableWorkflow'
+        });
+        this.id = id;
+        this.options = options;
+    }
+    then(task) {
+        return new Workflow_js_1.WorkflowImpl(this, (0, ensureTask_js_1.ensureTask)(task));
+    }
+}
+exports.DurableWorkflowTrigger = DurableWorkflowTrigger;
+_a = Trigger_js_1.TriggerType;
+;
+function workflow(id, options) {
+    return new DurableWorkflowTrigger(id, options);
+}

package/script/src/dsl/triggers/mod.d.ts

@@ -2,4 +2,5 @@ export type * from './ScheduleTrigger.js';
 export type * from './WebhookTrigger.js';
 export { schedule } from './ScheduleTrigger.js';
 export { webhook } from './WebhookTrigger.js';
+export { workflow } from './DurableTrigger.js';
 //# sourceMappingURL=mod.d.ts.map

package/script/src/dsl/triggers/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/src/dsl/triggers/mod.ts"],"names":[],"mappings":"AAAA,mBAAmB,sBAAsB,CAAC;AAC1C,mBAAmB,qBAAqB,CAAC;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/src/dsl/triggers/mod.ts"],"names":[],"mappings":"AAAA,mBAAmB,sBAAsB,CAAC;AAC1C,mBAAmB,qBAAqB,CAAC;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC"}

package/script/src/dsl/triggers/mod.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.webhook = exports.schedule = void 0;
+exports.workflow = exports.webhook = exports.schedule = void 0;
 var ScheduleTrigger_js_1 = require("./ScheduleTrigger.js");
 Object.defineProperty(exports, "schedule", { enumerable: true, get: function () { return ScheduleTrigger_js_1.schedule; } });
 var WebhookTrigger_js_1 = require("./WebhookTrigger.js");
 Object.defineProperty(exports, "webhook", { enumerable: true, get: function () { return WebhookTrigger_js_1.webhook; } });
+var DurableTrigger_js_1 = require("./DurableTrigger.js");
+Object.defineProperty(exports, "workflow", { enumerable: true, get: function () { return DurableTrigger_js_1.workflow; } });

package/script/src/interpreter/durable/DurableInterpreter.d.ts

@@ -0,0 +1,52 @@
+import { Tracer } from '@opentelemetry/api';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { Router } from 'express';
+import { Observable, Subscription } from 'rxjs';
+import { ContextProvider } from '../../context/ContextProvider.js';
+import { ConfigReader, ConnectionProvider, CronProvider, RoundTripperFactory } from '../../dsl/http/types.js';
+import { Workflow } from '../../dsl/Workflow.js';
+import { ContextImpl, ContextOperatorFunction } from '../../mod.js';
+import { Logger } from '../../observability/logging/Logger.js';
+import { ObservableCompiler } from './ObservableCompiler.js';
+import { QueueAPI } from './Queue.js';
+export type DurableInterpreterOptions = {
+    logger?: Logger;
+    compiler?: ObservableCompiler;
+    contextProvider?: ContextProvider;
+    signal?: AbortSignal;
+    skipVersoriCredentials?: boolean;
+};
+type Registration = {
+    trigger$: Observable<ContextImpl<any, void>>;
+    task$: ContextOperatorFunction<any, any, any>;
+    localAbortController: AbortController;
+    sigintListener: () => void;
+    subscription?: Subscription;
+};
+export declare class DurableInterpreter {
+    private readonly log;
+    private readonly compiler;
+    private readonly contextProvider;
+    private readonly roundTripperFactory;
+    private readonly webhookRouter;
+    private readonly cronRouter;
+    private cronRegistry;
+    private readonly connectionProvider;
+    private readonly cronProvider;
+    private readonly tracer;
+    private readonly cfgReader;
+    private readonly queueProvider;
+    private readonly otelSDK?;
+    private registeredWorkflows;
+    private webhookServer?;
+    private cronServer?;
+    private shutdownServer?;
+    private isShuttingDown;
+    constructor(log: Logger, compiler: ObservableCompiler, contextProvider: ContextProvider, roundTripperFactory: RoundTripperFactory, webhookRouter: Router, cronRouter: Router, cronRegistry: Map<string, string>, connectionProvider: ConnectionProvider, cronProvider: CronProvider, tracer: Tracer, cfgReader: ConfigReader, queueProvider: QueueAPI, otelSDK?: NodeSDK | undefined);
+    static newInstance(options?: DurableInterpreterOptions): Promise<DurableInterpreter>;
+    register<O>(workflow: Workflow<O>, options?: DurableInterpreterOptions): Registration;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=DurableInterpreter.d.ts.map

package/script/src/interpreter/durable/DurableInterpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DurableInterpreter.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/durable/DurableInterpreter.ts"],"names":[],"mappings":"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"}

package/script/src/interpreter/durable/DurableInterpreter.js

@@ -0,0 +1,440 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurableInterpreter = void 0;
+const api_1 = __importDefault(require("@opentelemetry/api"));
+const exporter_trace_otlp_proto_1 = require("@opentelemetry/exporter-trace-otlp-proto");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const express_1 = __importDefault(require("express"));
+const express_xml_bodyparser_1 = __importDefault(require("express-xml-bodyparser"));
+const rxjs_1 = require("rxjs");
+const ContextProvider_js_1 = require("../../context/ContextProvider.js");
+const default_js_1 = require("../../dsl/http/default.js");
+const constants_js_1 = require("../../dsl/http/versori/constants.js");
+const cronapi_js_1 = require("../../dsl/http/versori/cronapi.js");
+const platformapi_js_1 = require("../../dsl/http/versori/platformapi.js");
+const roundtripper_js_1 = require("../../dsl/http/versori/roundtripper.js");
+const Workflow_js_1 = require("../../dsl/Workflow.js");
+const MemoryKeyValueProvider_js_1 = require("../../kv/memory/MemoryKeyValueProvider.js");
+const NatsKeyValueProvider_js_1 = require("../../kv/nats/NatsKeyValueProvider.js");
+const ConsoleLogger_js_1 = require("../../observability/logging/ConsoleLogger.js");
+const ObservableCompiler_js_1 = require("./ObservableCompiler.js");
+const proxyroundtripper_js_1 = require("../../dsl/http/versori/proxyroundtripper.js");
+const configloader_js_1 = require("../../dsl/http/versori/configloader.js");
+const Queue_js_1 = require("./Queue.js");
+function getKVProvider(runLocal) {
+    if (runLocal) {
+        return Promise.resolve(new MemoryKeyValueProvider_js_1.MemoryKeyValueProvider());
+    }
+    return NatsKeyValueProvider_js_1.NatsKeyValueProvider.fromEnv();
+}
+function getRoundTripperFactory(log, tracer, opts) {
+    if (opts && opts.runLocal) {
+        log.info('Running in local mode, using ProxyRoundTripperFactory');
+        return proxyroundtripper_js_1.ProxyRoundTripper.fromEnv(log);
+    }
+    if (!opts || !opts.skipVersoriCredentials) {
+        return roundtripper_js_1.VersoriCredentialsFactory.fromEnv(log, tracer);
+    }
+    log.info('Running with default round tripper factory');
+    return new default_js_1.DefaultRoundTripperFactory();
+}
+class DurableInterpreter {
+    constructor(log, compiler, contextProvider, roundTripperFactory, webhookRouter, cronRouter, cronRegistry, connectionProvider, cronProvider, tracer, cfgReader, queueProvider, otelSDK) {
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: log
+        });
+        Object.defineProperty(this, "compiler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: compiler
+        });
+        Object.defineProperty(this, "contextProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: contextProvider
+        });
+        Object.defineProperty(this, "roundTripperFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: roundTripperFactory
+        });
+        Object.defineProperty(this, "webhookRouter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: webhookRouter
+        });
+        Object.defineProperty(this, "cronRouter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronRouter
+        });
+        Object.defineProperty(this, "cronRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronRegistry
+        });
+        Object.defineProperty(this, "connectionProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: connectionProvider
+        });
+        Object.defineProperty(this, "cronProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cronProvider
+        });
+        Object.defineProperty(this, "tracer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tracer
+        });
+        Object.defineProperty(this, "cfgReader", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cfgReader
+        });
+        Object.defineProperty(this, "queueProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: queueProvider
+        });
+        Object.defineProperty(this, "otelSDK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: otelSDK
+        });
+        Object.defineProperty(this, "registeredWorkflows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "webhookServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cronServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shutdownServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isShuttingDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        if (typeof this.log === 'undefined') {
+            // this captures the old way of instantiating the DurableInterpreter and provides an
+            // error message back to the user to let them know they should use the new way.
+            throw new Error('DurableInterpreter should not be instantiated directly. Use DurableInterpreter.newInstance() instead.');
+        }
+    }
+    static async newInstance(options = {}) {
+        const log = options.logger || new ConsoleLogger_js_1.ConsoleLogger('debug');
+        const compiler = options.compiler || new ObservableCompiler_js_1.ObservableCompiler();
+        const serviceName = Deno.env.get(constants_js_1.envVarProjectId) || 'example-service';
+        const environmentID = Deno.env.get(constants_js_1.envVarEnvId) || 'development';
+        const version = Deno.env.get(constants_js_1.envVarVersion) || '1.0.0';
+        const environment = Deno.env.get(constants_js_1.envVarEnvironmentName) || 'development';
+        const orgId = Deno.env.get(constants_js_1.envVarOrgId) || 'development';
+        const orgSlug = Deno.env.get(constants_js_1.envVarOrgSlug) || 'development';
+        const otelTracesURL = Deno.env.get(constants_js_1.envVarOtelTracesURL);
+        let otelSDK;
+        const configReader = configloader_js_1.VersoriConfigReader.fromEnv(log);
+        const runLocal = Deno.env.get(constants_js_1.envVarLocalRun) === 'true';
+        await waitForReady(log);
+        // Do NOT change those attributes, they are used by the API to filter on
+        const resource = (0, resources_1.resourceFromAttributes)({
+            'service.id': serviceName,
+            'service.environment': environment,
+            'service.environment_id': environmentID,
+            'service.version': version,
+            'service.organisation_id': orgId,
+            'service.organisation_slug': orgSlug,
+        });
+        if (otelTracesURL && serviceName) {
+            otelSDK = new sdk_node_1.NodeSDK({
+                traceExporter: new exporter_trace_otlp_proto_1.OTLPTraceExporter({
+                    url: otelTracesURL,
+                }),
+                serviceName: serviceName,
+                resource: resource,
+            });
+            log.info('Starting OpenTelemetry SDK');
+            otelSDK.start();
+        }
+        const tracer = api_1.default.trace.getTracer(serviceName, version);
+        const roundTripperFactory = getRoundTripperFactory(log, tracer, {
+            skipVersoriCredentials: options.skipVersoriCredentials,
+            runLocal: runLocal,
+        });
+        const queueProvider = await Queue_js_1.QueueImpl.fromEnv(log);
+        if (options.contextProvider) {
+            // no need to set up a key-value provider if options.contextProvider is already
+            // initialised.
+            return new DurableInterpreter(log, compiler, options.contextProvider, roundTripperFactory, express_1.default.Router(), express_1.default.Router(), new Map(), platformapi_js_1.PlatformAPIClient.fromEnv(), cronapi_js_1.CronAPIClient.fromEnv(), tracer, configReader, queueProvider, otelSDK);
+        }
+        const kvp = await getKVProvider(runLocal);
+        return new DurableInterpreter(log, compiler, new ContextProvider_js_1.ContextProviderImpl(log, kvp, roundTripperFactory.credentials(), queueProvider), roundTripperFactory, express_1.default.Router(), express_1.default.Router(), new Map(), platformapi_js_1.PlatformAPIClient.fromEnv(), cronapi_js_1.CronAPIClient.fromEnv(), tracer, configReader, queueProvider, otelSDK);
+    }
+    register(workflow, options) {
+        const localAbortController = new AbortController();
+        const combinedSignal = options?.signal
+            ? AbortSignal.any([localAbortController.signal, options.signal])
+            : localAbortController.signal;
+        if (!(workflow instanceof Workflow_js_1.WorkflowImpl)) {
+            throw new Error('workflow is not an instance of WorkflowImpl');
+        }
+        this.log.info('DurableInterpreter.register', { workflow });
+        const compilerContext = {
+            compiler: this.compiler,
+            log: this.log,
+            tracer: this.tracer,
+            contextProvider: this.contextProvider,
+            roundTripperFactory: this.roundTripperFactory,
+            webhookRouter: this.webhookRouter,
+            queueProvider: this.queueProvider,
+            cronRouter: this.cronRouter,
+            cronRegistry: this.cronRegistry,
+            connectionProvider: this.connectionProvider,
+            configReader: this.cfgReader,
+        };
+        const trigger$ = this.compiler.compileTrigger(compilerContext, workflow.trigger, combinedSignal);
+        const task$ = this.compiler.compileTask(compilerContext, workflow.task);
+        const registration = {
+            trigger$,
+            task$,
+            localAbortController,
+            sigintListener: () => {
+                this.log.info('Received SIGINT, shutting down workflow');
+                localAbortController.abort();
+            },
+        };
+        this.registeredWorkflows.push(registration);
+        return registration;
+    }
+    async start() {
+        const port = Deno.env.get('PORT') || 3000;
+        const cronPort = Deno.env.get('CRON_PORT') || 3001;
+        const webhookApp = (0, express_1.default)();
+        webhookApp.use(express_1.default.json({ limit: '50mb' })); // Add JSON body parser middleware
+        const cronApp = (0, express_1.default)();
+        cronApp.use(express_1.default.json());
+        const xml2jsDefaults = {
+            explicitArray: false,
+            normalize: false,
+            normalizeTags: false,
+            trim: true,
+        };
+        webhookApp.use((0, express_xml_bodyparser_1.default)(xml2jsDefaults));
+        // Add health check route
+        this.webhookRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        this.cronRouter.get('/health', (_req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        // Add router to the webhookApplication
+        webhookApp.use(this.webhookRouter);
+        cronApp.use(this.cronRouter);
+        // Start all registered workflows
+        for (const registration of this.registeredWorkflows) {
+            Deno.addSignalListener('SIGINT', registration.sigintListener);
+            registration.subscription = registration.trigger$
+                .pipe((0, rxjs_1.tap)((ctx) => {
+                ctx.log.info('DurableInterpreter.executionStarted', { data: ctx.data });
+            }), (0, rxjs_1.mergeMap)((ctx) => (0, rxjs_1.of)(ctx).pipe(registration.task$, (0, rxjs_1.catchError)((err) => {
+                ctx.log.error('DurableInterpreter.executionError', {
+                    error: err instanceof Error ? err.toString() : err,
+                });
+                try {
+                    ctx.options.onError?.(ctx.withData(err));
+                }
+                catch (err) {
+                    ctx.log.error('DurableInterpreter.onErrorError: failed to call onError handler', { error: err instanceof Error ? err.toString() : err });
+                    ctx.options.onError?.(ctx.withData({
+                        message: 'Internal server error',
+                        error: err instanceof Error ? err.toString() : err,
+                    }));
+                }
+                return rxjs_1.EMPTY;
+            }))))
+                .subscribe({
+                next: async (ctx) => {
+                    const durationMs = Date.now() - ctx.startTime.getTime();
+                    ctx.log.info('DurableInterpreter.executionCompleted', {
+                        durationMs,
+                        data: ctx.data,
+                    });
+                    try {
+                        ctx.options.onSuccess?.(ctx);
+                    }
+                    catch (err) {
+                        ctx.log.error('DurableInterpreter.onSuccessError: failed to call onSuccess handler', { error: err instanceof Error ? err.toString() : err });
+                        ctx.options.onSuccess?.(ctx.withData({
+                            message: 'Internal server error',
+                            error: err instanceof Error ? err.toString() : err,
+                        }));
+                    }
+                    if (ctx.workflowId) {
+                        this.log.info('Async workflow completed', {
+                            workflowId: ctx.workflowId,
+                        });
+                        const output = ctx.data ? btoa(JSON.stringify(ctx.data)) : undefined;
+                        await ctx.queue?.complete({
+                            id: ctx.workflowId,
+                            output,
+                            status: 'completed',
+                        });
+                    }
+                    this.contextProvider.destroy(ctx);
+                },
+                error: (err) => {
+                    this.log.error('DurableInterpreter.error', {
+                        error: err instanceof Error ? err.toString() : err,
+                    });
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+                complete: () => {
+                    this.log.info('DurableInterpreter.workflowCompleted');
+                    Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                },
+            });
+            registration.subscription.add(() => {
+                registration.subscription = undefined;
+            });
+        }
+        try {
+            this.cronProvider.updateCrons(this.cronRegistry);
+        }
+        catch (err) {
+            this.log.error('DurableInterpreter.updateCronsError', {
+                error: err instanceof Error ? err.toString() : err,
+            });
+            throw new Error('Unable to register scheduler tasks with central cron provider');
+        }
+        this.webhookServer = webhookApp.listen(port, () => {
+            this.log.info(`Express server listening on port ${port}`);
+        });
+        this.cronServer = cronApp.listen(cronPort, () => {
+            this.log.info(`Cron server listening on port ${cronPort}`);
+        });
+        this.shutdownServer = () => {
+            if (this.isShuttingDown) {
+                return;
+            }
+            this.isShuttingDown = true;
+            this.log.info('Shutting down server');
+            // Close the server
+            if (this.webhookServer) {
+                this.webhookServer.close();
+            }
+            if (this.cronServer) {
+                this.cronServer.close();
+            }
+            // Remove all signal listeners
+            for (const registration of this.registeredWorkflows) {
+                Deno.removeSignalListener('SIGINT', registration.sigintListener);
+                // Unsubscribe from all observables
+                if (registration.subscription) {
+                    registration.subscription.unsubscribe();
+                }
+                // Abort all controllers
+                registration.localAbortController.abort();
+            }
+            // Remove the server shutdown listener
+            if (this.shutdownServer) {
+                Deno.removeSignalListener('SIGINT', this.shutdownServer);
+            }
+        };
+        Deno.addSignalListener('SIGINT', this.shutdownServer);
+        return new Promise((resolve) => {
+            let serversClosed = 0;
+            const totalServers = [this.webhookServer, this.cronServer].filter(Boolean).length;
+            const checkResolve = () => {
+                serversClosed++;
+                if (serversClosed === totalServers) {
+                    this.log.info('All servers closed');
+                    resolve();
+                }
+            };
+            if (this.webhookServer) {
+                this.webhookServer.on('close', () => {
+                    this.log.info('Webhook server closed');
+                    checkResolve();
+                });
+            }
+            if (this.cronServer) {
+                this.cronServer.on('close', () => {
+                    this.log.info('Cron server closed');
+                    checkResolve();
+                });
+            }
+            if (!this.webhookServer && !this.cronServer) {
+                resolve();
+            }
+        });
+    }
+    async stop() {
+        this.otelSDK?.shutdown();
+        if (this.shutdownServer) {
+            this.shutdownServer();
+        }
+    }
+}
+exports.DurableInterpreter = DurableInterpreter;
+async function waitForReady(log) {
+    const readyCheckUrl = Deno.env.get('READY_CHECK_URL');
+    if (!readyCheckUrl) {
+        return Promise.resolve();
+    }
+    const maxAttempts = 40; // should be 20 seconds
+    const delay = 500;
+    log.info('DurableInterpreter.waitForReady: waiting for network to be ready', { readyCheckUrl });
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            const response = await fetch(readyCheckUrl);
+            if (response.ok) {
+                log.info('DurableInterpreter.waitForReady: network is ready');
+                return Promise.resolve();
+            }
+        }
+        catch (err) {
+            log.error('DurableInterpreter.waitForReadyError', {
+                error: err instanceof Error ? err.toString() : err,
+            });
+        }
+        log.info('DurableInterpreter.waitForReady: retrying...', { attempt: i });
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    throw new Error(`Network is not ready after ${maxAttempts * (delay / 1000)} seconds`);
+}

package/script/src/interpreter/durable/ExecutionError.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '../../context/Context.js';
+export declare class ExecutionError extends Error {
+    ctx: Context<any>;
+    constructor(ctx: Context<any>, message: string, opts?: ErrorOptions);
+}
+//# sourceMappingURL=ExecutionError.d.ts.map

package/script/src/interpreter/durable/ExecutionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionError.d.ts","sourceRoot":"","sources":["../../../../src/src/interpreter/durable/ExecutionError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,qBAAa,cAAe,SAAQ,KAAK;IACrC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;gBAEN,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY;CAMtE"}

package/script/src/interpreter/durable/ExecutionError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionError = void 0;
+class ExecutionError extends Error {
+    constructor(ctx, message, opts) {
+        super(message, opts);
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'ExecutionError';
+        this.ctx = ctx;
+    }
+}
+exports.ExecutionError = ExecutionError;