@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/deployment/config/types.js

@@ -1,5 +0,0 @@
-/**
- * Configuration types for the deployment system
- */
-export {};
-//# sourceMappingURL=types.js.map

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

@@ -1,66 +0,0 @@
-/**
- * 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, 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;
-}
-/**
- * Create the appropriate adapter for a given source
- */
-export declare function createAdapter(source: 'cli'): CliRequestAdapter;
-export declare function createAdapter(source: 'http'): HttpRequestAdapter;
-export {};
-//# sourceMappingURL=adapters.d.ts.map

package/dist/deployment/core/adapters.js

@@ -1,156 +0,0 @@
-/**
- * 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,
-            }),
-        };
-    }
-}
-export function createAdapter(source) {
-    switch (source) {
-        case 'cli':
-            return new CliRequestAdapter();
-        case 'http':
-            return new HttpRequestAdapter();
-    }
-}
-//# sourceMappingURL=adapters.js.map

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

@@ -1,62 +0,0 @@
-/**
- * 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

@@ -1,197 +0,0 @@
-/**
- * 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

@@ -1,42 +0,0 @@
-/**
- * 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 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

package/dist/deployment/core/formatters.js

@@ -1,146 +0,0 @@
-/**
- * Response formatters for different output contexts
- *
- * Transforms unified WorkflowResponse into format-specific outputs.
- */
-/**
- * Format response for CLI consumption
- */
-export function formatCliResponse(response, options = {}) {
-    if (options.json) {
-        return formatJsonResponse(response, options.includeTrace);
-    }
-    return formatHumanReadableResponse(response, options);
-}
-/**
- * Format response as JSON string
- */
-function formatJsonResponse(response, includeTrace) {
-    const output = {
-        success: response.success,
-        workflow: response.workflowId,
-        executionTime: response.executionTime,
-        requestId: response.requestId,
-    };
-    if (response.success) {
-        output.result = response.result;
-        if (includeTrace && response.trace) {
-            output.traceCount = response.trace.length;
-        }
-    }
-    else {
-        output.error = response.error;
-    }
-    return JSON.stringify(output, null, 2);
-}
-/**
- * Format response for human-readable CLI output
- */
-function formatHumanReadableResponse(response, options) {
-    const lines = [];
-    if (response.success) {
-        lines.push(`Workflow "${response.workflowId}" completed in ${response.executionTime}ms`);
-        lines.push('');
-        lines.push('Result:');
-        lines.push(JSON.stringify(response.result, null, 2));
-        if (options.includeTrace && response.trace && response.trace.length > 0) {
-            lines.push('');
-            lines.push('Trace:');
-            lines.push(`${response.trace.length} events captured`);
-            // Show first few trace events as summary
-            const preview = response.trace.slice(0, 5);
-            for (const event of preview) {
-                const nodeId = event.data?.nodeId || '';
-                lines.push(`  [${event.type}] ${nodeId}`);
-            }
-            if (response.trace.length > 5) {
-                lines.push(`  ... and ${response.trace.length - 5} more events`);
-            }
-        }
-    }
-    else {
-        lines.push(`Workflow "${response.workflowId}" failed`);
-        lines.push('');
-        lines.push(`Error: ${response.error?.message || 'Unknown error'}`);
-        if (response.error?.code) {
-            lines.push(`Code: ${response.error.code}`);
-        }
-        if (response.error?.stack) {
-            lines.push('');
-            lines.push('Stack trace:');
-            lines.push(response.error.stack);
-        }
-    }
-    return lines.join('\n');
-}
-/**
- * Format response for HTTP (returns object suitable for JSON response)
- */
-export function formatHttpResponse(response) {
-    const headers = {
-        'Content-Type': 'application/json',
-        'X-Request-Id': response.requestId,
-        'X-Execution-Time': `${response.executionTime}ms`,
-    };
-    if (response.success) {
-        return {
-            statusCode: 200,
-            body: {
-                success: true,
-                workflow: response.workflowId,
-                result: response.result,
-                executionTime: response.executionTime,
-                ...(response.trace && { trace: response.trace }),
-            },
-            headers,
-        };
-    }
-    // Determine status code based on error
-    let statusCode = 500;
-    if (response.error?.code === 'WORKFLOW_NOT_FOUND') {
-        statusCode = 404;
-    }
-    else if (response.error?.code === 'VALIDATION_ERROR') {
-        statusCode = 400;
-    }
-    else if (response.error?.code === 'TIMEOUT') {
-        statusCode = 504;
-    }
-    return {
-        statusCode,
-        body: {
-            success: false,
-            workflow: response.workflowId,
-            error: response.error,
-            executionTime: response.executionTime,
-        },
-        headers,
-    };
-}
-/**
- * Format error for consistent error responses
- */
-export function formatError(error, context = {}) {
-    const message = error instanceof Error ? error.message : String(error);
-    const stack = !context.production && error instanceof Error ? error.stack : undefined;
-    // Try to determine error code from message
-    let code = 'INTERNAL_ERROR';
-    if (message.includes('not found')) {
-        code = 'WORKFLOW_NOT_FOUND';
-    }
-    else if (message.includes('timeout')) {
-        code = 'TIMEOUT';
-    }
-    else if (message.includes('validation') || message.includes('invalid')) {
-        code = 'VALIDATION_ERROR';
-    }
-    else if (message.includes('cancelled') || message.includes('abort')) {
-        code = 'CANCELLED';
-    }
-    return {
-        message,
-        code,
-        stack,
-    };
-}
-//# sourceMappingURL=formatters.js.map