@versori/run 0.2.30 → 0.3.0-beta.10

package/script/src/connection/internal/OutboundConnectionFactory.js

@@ -0,0 +1,454 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundConnectionFactory = void 0;
+const lru_cache_1 = require("lru-cache");
+const isTokenValid_js_1 = require("../../services/credentials/isTokenValid.js");
+const CredentialHolder_js_1 = require("./CredentialHolder.js");
+const FetchBuilder_js_1 = require("./FetchBuilder.js");
+const oauth_1_0a_1 = __importDefault(require("oauth-1.0a"));
+const node_crypto_1 = require("node:crypto");
+class OutboundConnectionFactory {
+    constructor(httpClientFactory, credentials, tokens, oauth1, logger) {
+        Object.defineProperty(this, "httpClientFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: httpClientFactory
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: credentials
+        });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokens
+        });
+        Object.defineProperty(this, "oauth1", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: oauth1
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: logger
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cache = new lru_cache_1.LRUCache({ max: 100 });
+    }
+    fetcher(cnx) {
+        // This function must be synchronous, do not update to be async/await!!!
+        // This implementation prevents multiple concurrent requests to trigger multiple calls to
+        // `this.buildFetcher` since the cache is populated synchronously with promises to the built fetch.
+        const cachedFetch = this.cache.get(cnx.id);
+        if (cachedFetch) {
+            return cachedFetch;
+        }
+        const fetcherPromise = this.buildFetcher(cnx);
+        // all subsequent callers to `fetcher()` will block on `fetcherPromise` if it is still pending.
+        this.cache.set(cnx.id, fetcherPromise);
+        return fetcherPromise;
+    }
+    async buildFetcher(cnx) {
+        // TODO(@teo): we have a tracing fetch as the base implementation on the old approach, this needs updating here.
+        const builder = new FetchBuilder_js_1.FetchBuilder(globalThis.fetch, cnx);
+        const middlewares = [];
+        for (const [index, cnxCredential] of cnx.credentials.entries()) {
+            middlewares.push(this.buildMiddleware(cnxCredential, index, cnx));
+        }
+        for (const middleware of await Promise.all(middlewares)) {
+            if (middleware) {
+                builder.use(middleware);
+            }
+        }
+        return builder.build();
+    }
+    buildMiddleware(cnxCredential, index, cnx) {
+        const { authSchemeConfig, credential: redactedCredential } = cnxCredential;
+        if (!authSchemeConfig || !redactedCredential) {
+            this.logger.warn('Connection credential is missing authSchemeConfig or credential', {
+                connectionId: cnx.id,
+                index,
+                authSchemeConfig,
+                redactedCredential,
+            });
+            return Promise.resolve(undefined);
+        }
+        switch (authSchemeConfig.type) {
+            case 'certificate': {
+                return this.buildCertificateMiddleware(redactedCredential);
+            }
+            case 'api-key': {
+                return this.buildApiKeyMiddleware(authSchemeConfig, redactedCredential);
+            }
+            case 'basic-auth': {
+                return this.buildBasicAuthMiddleware(redactedCredential);
+            }
+            case 'jwt-bearer': {
+                return this.buildJwtBearerMiddleware(redactedCredential);
+            }
+            case 'oauth2': {
+                return this.buildOAuth2Middleware(redactedCredential);
+            }
+            case 'oauth1': {
+                return this.buildOAuth1Middleware(redactedCredential);
+            }
+            // TODO(@teo): add support for all the other auth schemes
+            default:
+                this.logger.warn('Unsupported authSchemeConfig type', {
+                    connectionId: cnx.id,
+                    index,
+                    authSchemeConfig,
+                });
+                return Promise.resolve(undefined);
+        }
+    }
+    async buildCertificateMiddleware(redactedCredential) {
+        const response = await this.credentials.get({
+            id: redactedCredential.id,
+        });
+        if (!response || !response.credential) {
+            return undefined;
+        }
+        const client = await this.httpClientFactory.getClient(response.credential);
+        if (!client) {
+            return undefined;
+        }
+        return (fetch) => {
+            return (input, init = {}) => {
+                return fetch(input, { ...init, client });
+            };
+        };
+    }
+    async buildApiKeyMiddleware(asc, redactedCredential) {
+        if (!asc.apiKey) {
+            throw new Error('AuthSchemeConfig.apiKey is required');
+        }
+        const response = await this.tokens.getToken({
+            credentialId: redactedCredential.id,
+            forceRefresh: false,
+        });
+        if (!response || !response.token) {
+            this.logger.warn('Response from getToken is empty', {
+                credentialId: redactedCredential.id,
+                response,
+            });
+            return undefined;
+        }
+        const tokenHolder = new CredentialHolder_js_1.CredentialHolder(response.token, isTokenValid_js_1.isTokenValid, async () => {
+            const refreshed = await this.tokens.getToken({
+                credentialId: redactedCredential.id,
+                forceRefresh: false,
+            });
+            return refreshed.token;
+        });
+        let authMiddleware;
+        switch (asc.apiKey?.in) {
+            case 'header':
+                authMiddleware = this.buildApiKeyHeaderMiddleware(asc.apiKey, tokenHolder);
+                break;
+            case 'query':
+                authMiddleware = this.buildApiKeyQueryMiddleware(asc.apiKey, tokenHolder);
+                break;
+            case 'cookie':
+                authMiddleware = this.buildApiKeyCookieMiddleware(asc.apiKey, tokenHolder);
+                break;
+            default:
+                throw new Error('Unsupported apiKey.in value: ' + asc.apiKey?.in);
+        }
+        // wrap the middleware applying auth in a new middleware that handles refreshing tokens
+        // in the event of a 401 or 403 response. It's important that non of the middlewares above
+        // mutate the input or init parameters.
+        return refreshTokenMiddleware(authMiddleware, tokenHolder, this.logger);
+    }
+    buildApiKeyHeaderMiddleware(cfg, tokenHolder) {
+        return (fetch) => {
+            return async (input, init = {}) => {
+                const token = await tokenHolder.get();
+                const headers = new Headers(init?.headers);
+                headers.set(cfg.name, token.tokenType ? `${token.tokenType} ${token.accessToken}` : token.accessToken);
+                return fetch(input, {
+                    ...init,
+                    headers,
+                });
+            };
+        };
+    }
+    buildApiKeyQueryMiddleware(cfg, tokenHolder) {
+        return (fetch) => {
+            return async (input, init) => {
+                const token = await tokenHolder.get();
+                const params = new URLSearchParams({
+                    [cfg.name]: token.accessToken,
+                });
+                if (input instanceof URL) {
+                    // must clone the URL object to avoid modifying the original object in case of
+                    // refreshing tokens and retrying the request.
+                    const nextInput = new URL(input.toString());
+                    params.forEach((value, key) => {
+                        nextInput.searchParams.set(key, value);
+                    });
+                    input = nextInput;
+                }
+                else if (input instanceof Request) {
+                    const url = new URL(input.url);
+                    params.forEach((value, key) => {
+                        url.searchParams.set(key, value);
+                    });
+                    input = new Request(url.toString(), {
+                        ...init,
+                        headers: new Headers(init?.headers),
+                    });
+                }
+                else if (typeof input === 'string') {
+                    const url = new URL(input);
+                    params.forEach((value, key) => {
+                        url.searchParams.set(key, value);
+                    });
+                    input = url.toString();
+                }
+                else {
+                    throw new Error('Unsupported input parameter to fetch(): ' + typeof input);
+                }
+                return fetch(input, init);
+            };
+        };
+    }
+    buildApiKeyCookieMiddleware(cfg, tokenHolder) {
+        return (fetch) => {
+            return async (input, init = {}) => {
+                const token = await tokenHolder.get();
+                const cookie = `${cfg.name}=${token.accessToken}`;
+                const headers = new Headers(init?.headers);
+                if (headers.has('Cookie')) {
+                    headers.set('Cookie', `${headers.get('Cookie')}; ${cookie}`);
+                }
+                else {
+                    headers.set('Cookie', cookie);
+                }
+                return fetch(input, {
+                    ...init,
+                    headers,
+                });
+            };
+        };
+    }
+    async buildBasicAuthMiddleware(redactedCredential) {
+        const response = await this.tokens.getToken({
+            credentialId: redactedCredential.id,
+        });
+        if (!response || !response.token) {
+            this.logger.warn('Empty response for basic auth credential', {
+                credentialId: redactedCredential.id,
+                response,
+            });
+            return Promise.resolve(undefined);
+        }
+        const tokenHolder = new CredentialHolder_js_1.CredentialHolder(response.token, isTokenValid_js_1.isTokenValid, async () => {
+            const refreshed = await this.tokens.getToken({
+                credentialId: redactedCredential.id,
+                forceRefresh: false,
+            });
+            return refreshed.token;
+        });
+        const authMiddleware = this.buildBasicAuthHeaderMiddleware(tokenHolder);
+        return Promise.resolve(refreshTokenMiddleware(authMiddleware, tokenHolder, this.logger));
+    }
+    async buildOAuth1Middleware(redactedCredential) {
+        const oauth1Meta = await this.oauth1.getAuthorizationMetadata({
+            credentialId: redactedCredential.id,
+        });
+        if (!oauth1Meta || !oauth1Meta.authorizationMetadata) {
+            this.logger.warn('Empty response for OAuth1 metadata', {
+                credentialId: redactedCredential.id,
+                oauth1Meta,
+            });
+            return Promise.resolve(undefined);
+        }
+        const tokenHolder = new CredentialHolder_js_1.CredentialHolder(oauth1Meta.authorizationMetadata, () => true, async () => {
+            const refreshed = await this.oauth1.getAuthorizationMetadata({
+                credentialId: redactedCredential.id,
+            });
+            return refreshed.authorizationMetadata;
+        });
+        const authMiddleware = this.buildOAuth1HeaderMiddleware(tokenHolder);
+        return Promise.resolve(refreshTokenMiddleware(authMiddleware, tokenHolder, this.logger));
+    }
+    buildBasicAuthHeaderMiddleware(tokenHolder) {
+        return (fetch) => {
+            return async (input, init = {}) => {
+                const token = await tokenHolder.get();
+                const headers = new Headers(init?.headers);
+                headers.set('Authorization', `Basic ${token.accessToken}`);
+                return fetch(input, {
+                    ...init,
+                    headers,
+                });
+            };
+        };
+    }
+    buildOAuth1HeaderMiddleware(tokenHolder) {
+        return (fetch) => {
+            return async (input, init = {}) => {
+                const metadata = await tokenHolder.get();
+                const authParams = new URLSearchParams(metadata.authorizationParams);
+                if (!metadata.authorizationParams) {
+                    throw new Error('OAuth1 metadata not found');
+                }
+                const oauth = new oauth_1_0a_1.default({
+                    consumer: {
+                        key: metadata.consumerKey,
+                        secret: metadata.consumerSecret,
+                    },
+                    signature_method: 'HMAC-SHA256',
+                    hash_function: (baseString, key) => (0, node_crypto_1.createHmac)('sha256', key).update(baseString).digest('base64'),
+                    realm: authParams.get('realm') || undefined,
+                });
+                let url;
+                if (input instanceof Request) {
+                    url = input.url;
+                }
+                else if (input instanceof URL) {
+                    url = input.toString();
+                }
+                else if (typeof input === 'string') {
+                    url = input;
+                }
+                else {
+                    throw new Error('Invalid input type for OAuth1 fetcher');
+                }
+                const header = oauth.toHeader(oauth.authorize({
+                    url: url,
+                    method: init?.method || 'GET',
+                }, {
+                    key: metadata.oauthToken,
+                    secret: metadata.oauthTokenSecret,
+                }));
+                const authHeader = header.Authorization;
+                if (!init) {
+                    init = {};
+                }
+                if (!init.headers) {
+                    init.headers = new Headers();
+                }
+                if (init.headers instanceof Headers) {
+                    init.headers.set('Authorization', authHeader);
+                }
+                else if (init.headers instanceof Array) {
+                    init.headers.push(['Authorization', authHeader]);
+                }
+                else {
+                    init.headers = {
+                        ...init.headers,
+                        ['Authorization']: authHeader,
+                    };
+                }
+                return fetch(input, init);
+            };
+        };
+    }
+    async buildJwtBearerMiddleware(redactedCredential) {
+        const response = await this.tokens.getToken({
+            credentialId: redactedCredential.id,
+        });
+        if (!response || !response.token) {
+            this.logger.warn('Empty response for JWT bearer credential', {
+                credentialId: redactedCredential.id,
+                response,
+            });
+            return Promise.resolve(undefined);
+        }
+        const tokenHolder = new CredentialHolder_js_1.CredentialHolder(response.token, isTokenValid_js_1.isTokenValid, async () => {
+            const refreshed = await this.tokens.getToken({
+                credentialId: redactedCredential.id,
+                forceRefresh: false,
+            });
+            return refreshed.token;
+        });
+        const authMiddleware = this.buildAuthorizationHeaderMiddleware(tokenHolder);
+        return Promise.resolve(refreshTokenMiddleware(authMiddleware, tokenHolder, this.logger));
+    }
+    async buildOAuth2Middleware(redactedCredential) {
+        const response = await this.tokens.getToken({
+            credentialId: redactedCredential.id,
+        });
+        if (!response || !response.token) {
+            return Promise.resolve(undefined);
+        }
+        const tokenHolder = new CredentialHolder_js_1.CredentialHolder(response.token, isTokenValid_js_1.isTokenValid, async () => {
+            const refreshed = await this.tokens.getToken({
+                credentialId: redactedCredential.id,
+                forceRefresh: true,
+            });
+            return refreshed.token;
+        });
+        let tokenType = 'Bearer';
+        switch (response.token.tokenType?.toLowerCase()) {
+            case 'mac':
+                tokenType = 'MAC';
+                break;
+            case 'bearer':
+                tokenType = 'Bearer';
+                break;
+            case 'basic':
+                tokenType = 'Basic';
+                break;
+            default:
+                tokenType = 'Bearer';
+                break;
+        }
+        return this.buildAuthorizationHeaderMiddleware(tokenHolder, tokenType);
+    }
+    buildAuthorizationHeaderMiddleware(tokenHolder, tokenType = 'Bearer') {
+        return (fetch) => {
+            return async (input, init = {}) => {
+                const token = await tokenHolder.get();
+                const headers = new Headers(init?.headers);
+                headers.set('Authorization', `${tokenType} ${token.accessToken}`);
+                console.log('headers', input);
+                return fetch(input, {
+                    ...init,
+                    headers,
+                });
+            };
+        };
+    }
+}
+exports.OutboundConnectionFactory = OutboundConnectionFactory;
+function refreshTokenMiddleware(authMiddleware, tokenHolder, logger) {
+    return (fetch) => {
+        if (authMiddleware) {
+            fetch = authMiddleware(fetch);
+        }
+        return async (input, init = {}) => {
+            const response = await fetch(input, init);
+            if (response.ok) {
+                return response;
+            }
+            if (response.status !== 401 && response.status !== 403) {
+                return response;
+            }
+            // the response is a 401 or 403, try refreshing the token and retrying the request
+            tokenHolder.refresh();
+            if (init.body instanceof ReadableStream) {
+                logger.warn(`received ${response.status} but cannot refresh token requests using ReadableStream body`);
+                return response;
+            }
+            return fetch(input, init);
+        };
+    };
+}

package/script/src/connection/types.d.ts

@@ -0,0 +1,32 @@
+import type * as express from 'express';
+import { Context } from '../context/Context.js';
+import { Connection } from '../services/platform/mod.js';
+export type FetchLike = typeof fetch;
+export type OutboundMiddleware = (fetch: FetchLike) => FetchLike;
+/**
+ * ConnectionFactory is a factory class that can be used to create an instance of {@link RuntimeConnectionFactory} based
+ * on the type of connection being used by a step.
+ */
+export interface ConnectionFactory {
+    fetcher(cnx: Connection): Promise<FetchLike>;
+    handler(cnx: Connection): Promise<express.RequestHandler>;
+}
+/**
+ * RuntimeConnectionFactory is similar to {@link ConnectionFactory} but is constructed at boot-time by the interpreter
+ * and is used during execution runtime to return the associated {@link FetchLike} and {@link express.RequestHandler}
+ * for a given {@link Context}.
+ *
+ * This will either be a {@link StaticFetchFactory} or a {@link DynamicFetchFactory} depending on the type of connection
+ * being used.
+ */
+export interface RuntimeConnectionFactory {
+    fetcher(ctx: Context<unknown>): Promise<FetchLike>;
+    baseUrl(ctx: Context<unknown>): Promise<string>;
+    handler(ctx: Context<unknown>): Promise<express.RequestHandler>;
+}
+/**
+ * ExpressHandlers is the interface for returning a dynamic express handler based on the provided context.
+ */
+export interface ExpressHandlers {
+}
+//# sourceMappingURL=types.d.ts.map

package/script/src/connection/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/src/connection/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,MAAM,MAAM,SAAS,GAAG,OAAO,KAAK,CAAC;AAErC,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,SAAS,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAC9B,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAC7C,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;CAC7D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACrC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACnD,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;CACnE;AAuBD;;GAEG;AACH,MAAM,WAAW,eAAe;CAC/B"}

package/script/src/connection/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/src/context/ActivationImpl.d.ts

@@ -0,0 +1,18 @@
+import { Logger } from '../observability/mod.js';
+import { Activation, Connection, DynamicVariables, EndUser, PlatformApi, ProjectEnvironment } from '../services/platform/mod.js';
+export declare class ActivationImpl implements Activation {
+    private readonly activation;
+    private readonly platformApi;
+    private readonly organisationId;
+    private readonly environmentId;
+    private readonly log;
+    constructor(activation: Activation, platformApi: PlatformApi, organisationId: string, environmentId: string, log: Logger);
+    get id(): string;
+    get user(): EndUser;
+    get environment(): ProjectEnvironment | undefined;
+    get connections(): Array<Connection> | undefined;
+    get dynamicVariables(): DynamicVariables | undefined;
+    getVariable<T = unknown>(name: string): T | undefined;
+    setVariable(name: string, value: unknown): Promise<void>;
+}
+//# sourceMappingURL=ActivationImpl.d.ts.map

package/script/src/context/ActivationImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivationImpl.d.ts","sourceRoot":"","sources":["../../../src/src/context/ActivationImpl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEjI,qBAAa,cAAe,YAAW,UAAU;IAEzC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAJH,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,MAAM;IAGhC,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,IAAI,WAAW,IAAI,kBAAkB,GAAG,SAAS,CAEhD;IAED,IAAI,WAAW,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAE/C;IAED,IAAI,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAEnD;IAED,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAQ/C,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CA8BjE"}

package/script/src/context/ActivationImpl.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivationImpl = void 0;
+class ActivationImpl {
+    constructor(activation, platformApi, organisationId, environmentId, log) {
+        Object.defineProperty(this, "activation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: activation
+        });
+        Object.defineProperty(this, "platformApi", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: platformApi
+        });
+        Object.defineProperty(this, "organisationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: organisationId
+        });
+        Object.defineProperty(this, "environmentId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: environmentId
+        });
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: log
+        });
+    }
+    get id() {
+        return this.activation.id;
+    }
+    get user() {
+        return this.activation.user;
+    }
+    get environment() {
+        return this.activation.environment;
+    }
+    get connections() {
+        return this.activation.connections;
+    }
+    get dynamicVariables() {
+        return this.activation.dynamicVariables;
+    }
+    getVariable(name) {
+        if (!this.activation.dynamicVariables) {
+            return undefined;
+        }
+        return this.activation.dynamicVariables[name];
+    }
+    async setVariable(name, value) {
+        if (!this.activation.dynamicVariables) {
+            this.log.error(`No variables found for activation`);
+            return;
+        }
+        try {
+            await this.platformApi.setDynamicVariable({
+                path: {
+                    organisation_id: this.organisationId,
+                    environment_id: this.environmentId,
+                    activation_id: this.id,
+                    variable_name: name,
+                },
+                body: {
+                    value,
+                }
+            });
+        }
+        catch (err) {
+            this.log.error(`Failed to set variable`, {
+                error: err,
+                variableName: name,
+            });
+            return;
+        }
+        this.activation.dynamicVariables[name] = value;
+    }
+}
+exports.ActivationImpl = ActivationImpl;

package/script/src/context/AsyncWorkflow.js

@@ -63,7 +63,7 @@ class AsyncWorkflow {
                 this.isWaiting = false;
                 throw new Error('wait timed out');
             }
-            const workflow = await this.queue.poll(this.workflowId);
+            const workflow = await this.queue.getWorkflow(this.workflowId);
             if (workflow.status === 'completed') {
                 // workflow is completed, parse the output and set the data and completed to true
                 const stringData = workflow.output;

package/script/src/context/Context.d.ts

@@ -1,25 +1,21 @@
 import type * as express from 'express';
-import { Activation } from '../dsl/http/types.js';
 import { CredentialsProvider } from '../dsl/http/versori/contextcredentials.js';
 import { QueueAPI } from '../interpreter/durable/Queue.js';
 import { Issue, IssueAPI } from '../issues/Issues.js';
 import { KeyValue, KeyValueProvider, KeyValueScope } from '../kv/KeyValue.js';
 import { Logger } from '../observability/logging/Logger.js';
 import { AsyncWorkflow } from './AsyncWorkflow.js';
+import { Workflow } from '../interpreter/durable/Queue.js';
+import { ActivationImpl } from './ActivationImpl.js';
+import { WorkflowInterface, WorkflowOpts } from './WorkflowClient.js';
 export type OnSuccessFn = (ctx: Context<any>) => void;
 export type OnErrorFn = (ctx: Context<any>) => void;
 export type ContextOptions = {
-    activation?: Activation;
-    workflowId?: string;
+    workflow?: Workflow;
     request?: express.Request;
     onSuccess?: OnSuccessFn;
     onError?: OnErrorFn;
 };
-export type WorkflowOpts = {
-    maxAttempts?: number;
-    data?: unknown;
-    dataRaw?: string;
-};
 export type CreateIssue = {
     severity: 'low' | 'medium' | 'high';
     title: string;
@@ -31,7 +27,7 @@ export interface Context<D> {
     readonly executionId: string;
     readonly startTime: Date;
     readonly data: D;
-    activation?: Activation;
+    activation: ActivationImpl;
     /**
      * Opens a key value store for the given scope, defaulting to ':project:' if not provided.
      * @param scope
@@ -44,6 +40,7 @@ export interface Context<D> {
         deduplicate?: boolean;
     }): Promise<Issue | null>;
     request(): express.Request | undefined;
+    workflowClient(): WorkflowInterface;
 }
 export declare class ContextImpl<D, Index = void> implements Context<D> {
     #private;
@@ -55,14 +52,14 @@ export declare class ContextImpl<D, Index = void> implements Context<D> {
     readonly kvp: KeyValueProvider;
     readonly queue?: QueueAPI;
     readonly options: ContextOptions;
-    constructor(log: Logger, kvp: KeyValueProvider, creds: CredentialsProvider, executionId: string, startTime: Date, data: D, issues: IssueAPI, queue?: QueueAPI, options?: ContextOptions);
-    get activation(): Activation | undefined;
-    get workflowId(): string | undefined;
+    constructor(log: Logger, kvp: KeyValueProvider, creds: CredentialsProvider, executionId: string, startTime: Date, data: D, activation: ActivationImpl, issues: IssueAPI, queue?: QueueAPI, options?: ContextOptions);
+    get activation(): ActivationImpl;
+    get workflow(): Workflow | undefined;
     setIndex(idx: number): ContextImpl<D, number>;
-    withActivation(activation: Activation): ContextImpl<D, Index>;
     withData<D2>(data: D2): ContextImpl<D2, Index>;
     openKv(scope?: KeyValueScope): KeyValue;
     request(): express.Request | undefined;
+    workflowClient(): WorkflowInterface;
     start(group: string, opts: WorkflowOpts): Promise<AsyncWorkflow>;
     createIssue(issue: CreateIssue, options?: {
         deduplicate?: boolean;