@synergenius/flow-weaver 0.2.0

package/dist/deployment/core/adapters.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Request adapters for normalizing input from different sources
+ *
+ * Each adapter transforms source-specific input into a unified WorkflowRequest.
+ */
+import type { WorkflowRequest, ExecutionContext, ValidationResult, CliInput, HttpInput, LambdaInput, VercelInput, CloudflareInput, Environment } from '../types.js';
+/**
+ * Request adapter interface
+ */
+export interface RequestAdapter<TInput> {
+    /**
+     * Parse source input into a unified WorkflowRequest
+     */
+    parseRequest(input: TInput): WorkflowRequest;
+    /**
+     * Validate the parsed request
+     */
+    validate(request: WorkflowRequest): ValidationResult;
+}
+/**
+ * Base adapter with shared validation logic
+ */
+declare abstract class BaseRequestAdapter<TInput> implements RequestAdapter<TInput> {
+    abstract parseRequest(input: TInput): WorkflowRequest;
+    validate(request: WorkflowRequest): ValidationResult;
+    /**
+     * Create a default execution context
+     */
+    protected createContext(source: WorkflowRequest['context']['source'], options?: {
+        requestId?: string;
+        includeTrace?: boolean;
+        timeout?: number;
+        environment?: Environment;
+    }): ExecutionContext;
+    /**
+     * Detect runtime environment
+     */
+    protected detectEnvironment(): Environment;
+}
+/**
+ * CLI request adapter
+ *
+ * Parses CLI command input into a WorkflowRequest
+ */
+export declare class CliRequestAdapter extends BaseRequestAdapter<CliInput> {
+    parseRequest(input: CliInput): WorkflowRequest;
+    /**
+     * Extract workflow ID from file path (uses filename without extension)
+     */
+    private extractWorkflowId;
+}
+/**
+ * HTTP request adapter (for Fastify/Express-like servers)
+ *
+ * Parses HTTP request into a WorkflowRequest
+ */
+export declare class HttpRequestAdapter extends BaseRequestAdapter<HttpInput> {
+    parseRequest(input: HttpInput): WorkflowRequest;
+}
+/**
+ * AWS Lambda request adapter
+ *
+ * Parses API Gateway event into a WorkflowRequest
+ */
+export declare class LambdaRequestAdapter extends BaseRequestAdapter<LambdaInput> {
+    parseRequest(input: LambdaInput): WorkflowRequest;
+}
+/**
+ * Vercel serverless function request adapter
+ */
+export declare class VercelRequestAdapter extends BaseRequestAdapter<VercelInput> {
+    parseRequest(input: VercelInput): WorkflowRequest;
+}
+/**
+ * Cloudflare Workers request adapter
+ */
+export declare class CloudflareRequestAdapter extends BaseRequestAdapter<CloudflareInput> {
+    parseRequestAsync(input: CloudflareInput): Promise<WorkflowRequest>;
+    parseRequest(_input: CloudflareInput): WorkflowRequest;
+}
+/**
+ * Create the appropriate adapter for a given source
+ */
+export declare function createAdapter(source: 'cli'): CliRequestAdapter;
+export declare function createAdapter(source: 'http'): HttpRequestAdapter;
+export declare function createAdapter(source: 'lambda'): LambdaRequestAdapter;
+export declare function createAdapter(source: 'vercel'): VercelRequestAdapter;
+export declare function createAdapter(source: 'cloudflare'): CloudflareRequestAdapter;
+export {};
+//# sourceMappingURL=adapters.d.ts.map

package/dist/deployment/core/adapters.js

@@ -0,0 +1,251 @@
+/**
+ * Request adapters for normalizing input from different sources
+ *
+ * Each adapter transforms source-specific input into a unified WorkflowRequest.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+/**
+ * Base adapter with shared validation logic
+ */
+class BaseRequestAdapter {
+    validate(request) {
+        const errors = [];
+        // Validate workflowId
+        if (!request.workflowId || typeof request.workflowId !== 'string') {
+            errors.push({
+                path: 'workflowId',
+                message: 'Workflow ID is required and must be a string',
+                expected: 'string',
+                actual: typeof request.workflowId,
+            });
+        }
+        // Validate params is an object
+        if (request.params !== null && typeof request.params !== 'object') {
+            errors.push({
+                path: 'params',
+                message: 'Params must be an object',
+                expected: 'object',
+                actual: typeof request.params,
+            });
+        }
+        // Validate context
+        if (!request.context) {
+            errors.push({
+                path: 'context',
+                message: 'Execution context is required',
+            });
+        }
+        else {
+            if (!request.context.requestId) {
+                errors.push({
+                    path: 'context.requestId',
+                    message: 'Request ID is required',
+                });
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+    }
+    /**
+     * Create a default execution context
+     */
+    createContext(source, options = {}) {
+        return {
+            source,
+            environment: options.environment ?? this.detectEnvironment(),
+            requestId: options.requestId ?? randomUUID(),
+            includeTrace: options.includeTrace ?? true,
+            timeout: options.timeout,
+        };
+    }
+    /**
+     * Detect runtime environment
+     */
+    detectEnvironment() {
+        const nodeEnv = process.env.NODE_ENV?.toLowerCase();
+        if (nodeEnv === 'production' || nodeEnv === 'prod') {
+            return 'production';
+        }
+        if (nodeEnv === 'staging' || nodeEnv === 'stage') {
+            return 'staging';
+        }
+        return 'development';
+    }
+}
+/**
+ * CLI request adapter
+ *
+ * Parses CLI command input into a WorkflowRequest
+ */
+export class CliRequestAdapter extends BaseRequestAdapter {
+    parseRequest(input) {
+        // Parse params from JSON string or file
+        let params = {};
+        if (input.params) {
+            try {
+                params = JSON.parse(input.params);
+            }
+            catch {
+                throw new Error(`Invalid JSON in params: ${input.params}`);
+            }
+        }
+        else if (input.paramsFile) {
+            const paramsFilePath = path.resolve(input.paramsFile);
+            if (!fs.existsSync(paramsFilePath)) {
+                throw new Error(`Params file not found: ${paramsFilePath}`);
+            }
+            try {
+                const content = fs.readFileSync(paramsFilePath, 'utf8');
+                params = JSON.parse(content);
+            }
+            catch {
+                throw new Error(`Failed to parse params file: ${input.paramsFile}`);
+            }
+        }
+        // Determine trace inclusion
+        const includeTrace = input.trace ?? !input.production;
+        return {
+            workflowId: input.workflowName || this.extractWorkflowId(input.filePath),
+            params,
+            context: this.createContext('cli', {
+                includeTrace,
+                timeout: input.timeout,
+                environment: input.production ? 'production' : 'development',
+            }),
+        };
+    }
+    /**
+     * Extract workflow ID from file path (uses filename without extension)
+     */
+    extractWorkflowId(filePath) {
+        const basename = path.basename(filePath, path.extname(filePath));
+        return basename;
+    }
+}
+/**
+ * HTTP request adapter (for Fastify/Express-like servers)
+ *
+ * Parses HTTP request into a WorkflowRequest
+ */
+export class HttpRequestAdapter extends BaseRequestAdapter {
+    parseRequest(input) {
+        const workflowId = input.params.name || input.params.workflow || '';
+        const includeTrace = input.query.trace === 'true';
+        return {
+            workflowId,
+            params: input.body || {},
+            context: this.createContext('http', {
+                requestId: input.headers['x-request-id'],
+                includeTrace,
+            }),
+        };
+    }
+}
+/**
+ * AWS Lambda request adapter
+ *
+ * Parses API Gateway event into a WorkflowRequest
+ */
+export class LambdaRequestAdapter extends BaseRequestAdapter {
+    parseRequest(input) {
+        // Parse body
+        let params = {};
+        if (typeof input.body === 'string') {
+            try {
+                params = JSON.parse(input.body || '{}');
+            }
+            catch {
+                params = {};
+            }
+        }
+        else if (input.body && typeof input.body === 'object') {
+            params = input.body;
+        }
+        // Get workflow ID from path parameters
+        const workflowId = input.pathParameters?.name ||
+            input.pathParameters?.workflow ||
+            input.pathParameters?.id ||
+            '';
+        const includeTrace = input.queryStringParameters?.trace === 'true';
+        const isProduction = input.requestContext?.stage === 'prod' || input.requestContext?.stage === 'production';
+        return {
+            workflowId,
+            params,
+            context: this.createContext('lambda', {
+                requestId: input.requestContext?.requestId,
+                includeTrace,
+                environment: isProduction ? 'production' : 'development',
+            }),
+        };
+    }
+}
+/**
+ * Vercel serverless function request adapter
+ */
+export class VercelRequestAdapter extends BaseRequestAdapter {
+    parseRequest(input) {
+        // Workflow ID comes from the file-based routing in Vercel
+        // The caller should provide it, or we extract from query
+        const workflowId = input.query.workflow || input.query.name || '';
+        const includeTrace = input.query.trace === 'true';
+        return {
+            workflowId,
+            params: input.body || {},
+            context: this.createContext('vercel', {
+                requestId: input.headers['x-vercel-id'],
+                includeTrace,
+            }),
+        };
+    }
+}
+/**
+ * Cloudflare Workers request adapter
+ */
+export class CloudflareRequestAdapter extends BaseRequestAdapter {
+    async parseRequestAsync(input) {
+        // Parse body
+        let params = {};
+        try {
+            params = await input.request.json();
+        }
+        catch {
+            params = {};
+        }
+        // Extract workflow ID from URL path
+        const url = new URL(input.request.url);
+        const pathParts = url.pathname.split('/').filter(Boolean);
+        const workflowId = pathParts[pathParts.length - 1] || '';
+        const includeTrace = url.searchParams.get('trace') === 'true';
+        return {
+            workflowId,
+            params,
+            context: this.createContext('cloudflare', {
+                requestId: input.request.headers.get('cf-ray') || undefined,
+                includeTrace,
+            }),
+        };
+    }
+    // Sync version throws - use parseRequestAsync for Cloudflare
+    parseRequest(_input) {
+        throw new Error('Use parseRequestAsync for Cloudflare Workers');
+    }
+}
+export function createAdapter(source) {
+    switch (source) {
+        case 'cli':
+            return new CliRequestAdapter();
+        case 'http':
+            return new HttpRequestAdapter();
+        case 'lambda':
+            return new LambdaRequestAdapter();
+        case 'vercel':
+            return new VercelRequestAdapter();
+        case 'cloudflare':
+            return new CloudflareRequestAdapter();
+    }
+}
+//# sourceMappingURL=adapters.js.map

package/dist/deployment/core/executor.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Unified workflow executor
+ *
+ * Provides a single entry point for executing workflows across all contexts.
+ */
+import { WorkflowRegistry } from '../../server/workflow-registry.js';
+import type { WorkflowRequest, WorkflowResponse, ValidationResult, ExecutionContext } from '../types.js';
+/**
+ * Options for the unified executor
+ */
+export interface ExecutorOptions {
+    /** Workflow registry for resolving workflows */
+    registry?: WorkflowRegistry;
+    /** Default timeout in milliseconds */
+    defaultTimeout?: number;
+    /** Production mode - disables trace by default */
+    production?: boolean;
+}
+/**
+ * Unified workflow executor
+ *
+ * Provides consistent execution behavior across CLI, HTTP, and serverless contexts.
+ */
+export declare class UnifiedWorkflowExecutor {
+    private registry?;
+    private defaultTimeout;
+    private production;
+    constructor(options?: ExecutorOptions);
+    /**
+     * Execute a workflow with the given request
+     */
+    execute<T = unknown>(request: WorkflowRequest): Promise<WorkflowResponse<T>>;
+    /**
+     * Execute a workflow directly from a file path
+     */
+    executeFromFile<T = unknown>(filePath: string, params: Record<string, unknown>, context?: Partial<ExecutionContext>): Promise<WorkflowResponse<T>>;
+    /**
+     * Execute a file directly without registry lookup
+     */
+    private executeFileDirectly;
+    /**
+     * Resolve a workflow from the registry
+     */
+    private resolveWorkflow;
+    /**
+     * Execute workflow with timeout support
+     */
+    private executeWithTimeout;
+    /**
+     * Create a standardized error response
+     */
+    private createErrorResponse;
+    /**
+     * Validate a workflow request
+     */
+    validateRequest(request: WorkflowRequest): ValidationResult;
+}
+/**
+ * Create a new executor instance
+ */
+export declare function createExecutor(options?: ExecutorOptions): UnifiedWorkflowExecutor;
+//# sourceMappingURL=executor.d.ts.map

package/dist/deployment/core/executor.js

@@ -0,0 +1,197 @@
+/**
+ * Unified workflow executor
+ *
+ * Provides a single entry point for executing workflows across all contexts.
+ */
+import { randomUUID } from 'crypto';
+import { executeWorkflowFromFile } from '../../mcp/workflow-executor.js';
+/**
+ * Unified workflow executor
+ *
+ * Provides consistent execution behavior across CLI, HTTP, and serverless contexts.
+ */
+export class UnifiedWorkflowExecutor {
+    registry;
+    defaultTimeout;
+    production;
+    constructor(options = {}) {
+        this.registry = options.registry;
+        this.defaultTimeout = options.defaultTimeout ?? 30000;
+        this.production = options.production ?? false;
+    }
+    /**
+     * Execute a workflow with the given request
+     */
+    async execute(request) {
+        const startTime = Date.now();
+        const requestId = request.context.requestId || randomUUID();
+        try {
+            // Resolve the workflow
+            const workflow = await this.resolveWorkflow(request.workflowId);
+            if (!workflow) {
+                return this.createErrorResponse(request.workflowId, requestId, 'WORKFLOW_NOT_FOUND', `Workflow "${request.workflowId}" not found`, startTime);
+            }
+            // Execute with timeout if specified
+            const timeout = request.context.timeout ?? this.defaultTimeout;
+            const includeTrace = request.context.includeTrace && !this.production;
+            const result = await this.executeWithTimeout(workflow.filePath, request.params, {
+                workflowName: workflow.functionName,
+                production: this.production || request.context.environment === 'production',
+                includeTrace,
+            }, timeout, request.abortSignal);
+            return {
+                success: true,
+                workflowId: request.workflowId,
+                result: result.result,
+                executionTime: Date.now() - startTime,
+                trace: includeTrace ? result.trace : undefined,
+                requestId,
+            };
+        }
+        catch (error) {
+            // Check for specific error types
+            if (error instanceof Error) {
+                if (error.name === 'AbortError' || error.message.includes('abort')) {
+                    return this.createErrorResponse(request.workflowId, requestId, 'CANCELLED', 'Workflow execution was cancelled', startTime);
+                }
+                if (error.message.includes('timeout') || error.message.includes('timed out')) {
+                    return this.createErrorResponse(request.workflowId, requestId, 'TIMEOUT', `Workflow execution timed out after ${request.context.timeout ?? this.defaultTimeout}ms`, startTime);
+                }
+                // Check if it's a validation error
+                if (error.message.includes('validation') || error.message.includes('invalid')) {
+                    return this.createErrorResponse(request.workflowId, requestId, 'VALIDATION_ERROR', error.message, startTime, error.stack);
+                }
+                // General execution error
+                return this.createErrorResponse(request.workflowId, requestId, 'EXECUTION_ERROR', error.message, startTime, error.stack);
+            }
+            // Unknown error
+            return this.createErrorResponse(request.workflowId, requestId, 'INTERNAL_ERROR', String(error), startTime);
+        }
+    }
+    /**
+     * Execute a workflow directly from a file path
+     */
+    async executeFromFile(filePath, params, context = {}) {
+        const fullContext = {
+            source: context.source ?? 'cli',
+            environment: context.environment ?? 'development',
+            requestId: context.requestId ?? randomUUID(),
+            includeTrace: context.includeTrace ?? true,
+            timeout: context.timeout,
+        };
+        const request = {
+            workflowId: filePath,
+            params,
+            context: fullContext,
+        };
+        return this.executeFileDirectly(filePath, request);
+    }
+    /**
+     * Execute a file directly without registry lookup
+     */
+    async executeFileDirectly(filePath, request) {
+        const startTime = Date.now();
+        const requestId = request.context.requestId;
+        try {
+            const timeout = request.context.timeout ?? this.defaultTimeout;
+            const includeTrace = request.context.includeTrace && !this.production;
+            const result = await this.executeWithTimeout(filePath, request.params, {
+                production: this.production || request.context.environment === 'production',
+                includeTrace,
+            }, timeout, request.abortSignal);
+            return {
+                success: true,
+                workflowId: result.functionName,
+                result: result.result,
+                executionTime: Date.now() - startTime,
+                trace: includeTrace ? result.trace : undefined,
+                requestId,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            return this.createErrorResponse(request.workflowId, requestId, 'EXECUTION_ERROR', errorMessage, startTime, errorStack);
+        }
+    }
+    /**
+     * Resolve a workflow from the registry
+     */
+    async resolveWorkflow(workflowId) {
+        if (!this.registry) {
+            return null;
+        }
+        return this.registry.getEndpoint(workflowId);
+    }
+    /**
+     * Execute workflow with timeout support
+     */
+    async executeWithTimeout(filePath, params, options, timeout, abortSignal) {
+        // Create a promise that rejects on timeout
+        const timeoutPromise = new Promise((_, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Workflow execution timed out after ${timeout}ms`));
+            }, timeout);
+            // Clear timeout if abort signal fires
+            if (abortSignal) {
+                abortSignal.addEventListener('abort', () => {
+                    clearTimeout(timer);
+                    reject(new Error('Workflow execution was cancelled'));
+                });
+            }
+        });
+        // Race between execution and timeout
+        return Promise.race([executeWorkflowFromFile(filePath, params, options), timeoutPromise]);
+    }
+    /**
+     * Create a standardized error response
+     */
+    createErrorResponse(workflowId, requestId, code, message, startTime, stack) {
+        const error = {
+            code,
+            message,
+        };
+        // Only include stack in non-production environments
+        if (stack && !this.production) {
+            error.stack = stack;
+        }
+        return {
+            success: false,
+            workflowId,
+            error,
+            executionTime: Date.now() - startTime,
+            requestId,
+        };
+    }
+    /**
+     * Validate a workflow request
+     */
+    validateRequest(request) {
+        const errors = [];
+        if (!request.workflowId) {
+            errors.push({
+                path: 'workflowId',
+                message: 'Workflow ID is required',
+            });
+        }
+        if (request.params && typeof request.params !== 'object') {
+            errors.push({
+                path: 'params',
+                message: 'Params must be an object',
+                expected: 'object',
+                actual: typeof request.params,
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+    }
+}
+/**
+ * Create a new executor instance
+ */
+export function createExecutor(options) {
+    return new UnifiedWorkflowExecutor(options);
+}
+//# sourceMappingURL=executor.js.map

package/dist/deployment/core/formatters.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Response formatters for different output contexts
+ *
+ * Transforms unified WorkflowResponse into format-specific outputs.
+ */
+import type { WorkflowResponse } from '../types.js';
+/**
+ * Format response for CLI output
+ */
+export interface CliOutputOptions {
+    /** Output as JSON */
+    json?: boolean;
+    /** Include trace summary */
+    includeTrace?: boolean;
+    /** Color output */
+    color?: boolean;
+}
+/**
+ * Format response for CLI consumption
+ */
+export declare function formatCliResponse<T>(response: WorkflowResponse<T>, options?: CliOutputOptions): string;
+/**
+ * Format response for HTTP (returns object suitable for JSON response)
+ */
+export declare function formatHttpResponse<T>(response: WorkflowResponse<T>): {
+    statusCode: number;
+    body: Record<string, unknown>;
+    headers: Record<string, string>;
+};
+/**
+ * Format response for AWS Lambda (API Gateway response format)
+ */
+export declare function formatLambdaResponse<T>(response: WorkflowResponse<T>): {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+};
+/**
+ * Format response for Cloudflare Workers (returns Response object constructor args)
+ */
+export declare function formatCloudflareResponse<T>(response: WorkflowResponse<T>): {
+    body: string;
+    init: ResponseInit;
+};
+/**
+ * Format error for consistent error responses
+ */
+export declare function formatError(error: unknown, context?: {
+    workflowId?: string;
+    requestId?: string;
+    production?: boolean;
+}): {
+    message: string;
+    code: string;
+    stack?: string;
+};
+//# sourceMappingURL=formatters.d.ts.map