@optimizely/ocp-local-env 1.0.0-beta.10

package/dist/src/local_engine/local-engine-unified.js

@@ -0,0 +1,723 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Local Engine Unified
+ *
+ * This script runs in the app's Node.js process context and executes both OCP functions
+ * and lifecycle methods using IPC communication with the parent process.
+ * This is a single, persistent process that handles all app execution requests.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalEngineUnified = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const local_engine_child_base_1 = require("./local-engine-child-base");
+const utils_1 = require("./utils");
+const SourceDataStore_1 = require("./storage/SourceDataStore");
+const SourceJobExecutionStore_1 = require("./storage/SourceJobExecutionStore");
+class LocalEngineUnified extends local_engine_child_base_1.LocalEngineChildBase {
+    constructor() {
+        super(...arguments);
+        this.runtime = null;
+        this.isInitialized = false;
+    }
+    /**
+     * Initialize the wrapper with app configuration
+     * This happens once when the process starts
+     */
+    async initialize(appConfig, appDir) {
+        if (this.isInitialized) {
+            this.sendLog('info', 'Wrapper already initialized, skipping initialization');
+            return;
+        }
+        this.sendLog('info', `Initializing unified wrapper for app: ${appConfig.manifest.meta?.app_id || 'unknown'}`);
+        try {
+            // Load the SDK from app's node_modules
+            this.sdkComponents = (0, utils_1.loadAppSDK)(appDir);
+            this.sendLog('info', 'SDK loaded successfully');
+            // Initialize Runtime
+            this.sendLog('info', 'Initializing Runtime...');
+            // Try initializing with dist directory first (where built files are)
+            try {
+                const distDir = path_1.default.join(appDir, 'dist');
+                this.runtime = await this.sdkComponents.Runtime.initialize(distDir);
+                this.sendLog('info', 'Runtime initialized successfully with dist directory');
+            }
+            catch (error) {
+                // Fallback: try with base directory
+                this.sendLog('warn', `Runtime initialization with dist dir failed: ${error}, trying base directory`);
+                this.runtime = await this.sdkComponents.Runtime.initialize(appDir);
+                this.sendLog('info', 'Runtime initialized successfully with base directory');
+            }
+            // Import local engine components using dynamic require
+            const localEngineDir = __dirname;
+            const storageDir = path_1.default.join(__dirname, 'storage');
+            const localSDKConfig = require(path_1.default.join(localEngineDir, 'localSDKConfig'));
+            this.configureLocalSDKs = localSDKConfig.configureLocalSDKs;
+            this.cleanUpLocalSDKs = localSDKConfig.cleanUpLocalSDKs;
+            this.LocalSettingsStore = require(path_1.default.join(storageDir, 'LocalSettingsStore')).LocalSettingsStore;
+            this.LocalConfigStore = require(path_1.default.join(storageDir, 'LocalConfigStore')).LocalConfigStore;
+            this.sendLog('info', 'Local engine components loaded');
+            // Configure SDKs for the app
+            const settingsStore = this.LocalSettingsStore.getInstance(appDir);
+            const configStore = new this.LocalConfigStore(appDir);
+            this.sendLog('info', 'Configuring SDKs for local testing...');
+            this.configureLocalSDKs(appConfig, settingsStore, appDir, 1, configStore, appConfig.account, appConfig.baseUrl);
+            // Initialize source stores
+            this.sourceDataStore = new SourceDataStore_1.SourceDataStore(appDir);
+            this.sourceJobExecutionStore = new SourceJobExecutionStore_1.SourceJobExecutionStore(appDir);
+            this.isInitialized = true;
+            this.sendLog('info', 'Unified wrapper initialized successfully - ready to handle function and lifecycle requests');
+        }
+        catch (error) {
+            this.sendLog('error', `Initialization failed: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Execute a function with the given request
+     */
+    async executeFunction(request) {
+        if (!this.appConfig || !this.appDir) {
+            throw new Error('Wrapper not properly initialized');
+        }
+        if (!this.isInitialized) {
+            throw new Error('SDK not initialized');
+        }
+        this.sendLog('info', `Executing function: ${request.functionId}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Finding function file', 20);
+        // Find the built function file
+        const functionPath = (0, utils_1.findFunctionFile)(this.appDir, request.functionId, this.appConfig.manifest);
+        this.sendLog('info', `Using function file: ${functionPath}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Loading function module', 40);
+        // Load the function module
+        const FunctionModule = require(functionPath);
+        const FunctionClass = (0, utils_1.findFunctionClass)(FunctionModule);
+        this.sendLog('info', 'Function class found, creating request object...', this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Creating request object', 60);
+        // Convert headers array to the format expected by InternalRequest
+        const headers = request.headers || [];
+        // Convert body to Uint8Array if present
+        let bodyArray = null;
+        if (request.body !== null && request.body !== undefined) {
+            const bodyString = typeof request.body === 'string' ?
+                request.body : JSON.stringify(request.body);
+            bodyArray = new Uint8Array(Buffer.from(bodyString, 'utf8'));
+        }
+        const internalRequest = new this.sdkComponents.App.InternalRequest(request.method, request.fullpath, request.path, request.params || {}, headers, bodyArray);
+        this.sendLog('debug', `Created InternalRequest - method: ${request.method}, path: ${request.path}`, this.currentRequestId);
+        // Create function instance and call perform
+        const functionInstance = new FunctionClass(internalRequest);
+        if (typeof functionInstance.perform !== 'function') {
+            throw new Error('Function class does not implement perform method');
+        }
+        this.sendLog('info', 'Executing function perform method...', this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Executing function', 80);
+        // Call the function's perform method
+        const response = await functionInstance.perform();
+        this.sendLog('info', `Function execution completed - status: ${response.status}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Function execution completed', 100);
+        // Convert response to serializable format
+        const result = {
+            success: true,
+            status: response.status || 200,
+            headers: response.headers ? response.headers.toArray() : [],
+            body: response.bodyAsU8Array ? Array.from(response.bodyAsU8Array) : null
+        };
+        return result;
+    }
+    /**
+     * Execute a lifecycle method with the given request
+     */
+    async executeLifecycle(request) {
+        if (!this.appConfig || !this.appDir) {
+            throw new Error('Wrapper not properly initialized');
+        }
+        if (!this.isInitialized) {
+            throw new Error('SDK not initialized');
+        }
+        this.sendLog('info', `Executing lifecycle method: ${request.method}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Checking lifecycle file', 20);
+        // Check if built file exists
+        if (!fs_1.default.existsSync(request.scriptPath)) {
+            throw new Error(`Lifecycle file not built or not found at ${request.scriptPath}`);
+        }
+        this.sendLog('info', `Using lifecycle file: ${request.scriptPath}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Loading lifecycle module', 40);
+        // Load the lifecycle module
+        const LifecycleModule = require(request.scriptPath);
+        const LifecycleClass = (0, utils_1.findLifecycleClass)(LifecycleModule);
+        // Create instance and call the method
+        const lifecycle = new LifecycleClass();
+        if (typeof lifecycle[request.method] !== 'function') {
+            throw new Error(`Method ${request.method} not found on Lifecycle class`);
+        }
+        this.sendLog('info', `Executing ${request.method} with params: ${JSON.stringify(request.params)}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Executing lifecycle method', 60);
+        // Call the lifecycle method with appropriate parameters
+        let result;
+        if (request.method === 'onUpgrade') {
+            result = await lifecycle[request.method](request.params?.fromVersion || '0.0.0');
+        }
+        else if (request.method === 'onSettingsForm') {
+            const params = request.params || {};
+            result = await lifecycle[request.method](params.page, params.action, params.formData);
+        }
+        else {
+            result = await lifecycle[request.method]();
+        }
+        this.sendLog('info', `Lifecycle method result: ${JSON.stringify(result)}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Processing result', 80);
+        // Handle different lifecycle method return types
+        let processedResult;
+        if (request.method === 'onSettingsForm') {
+            // The result should be a LifecycleSettingsResult with getResponse method
+            let settingsResponse = {};
+            if (result && typeof result.getResponse === 'function') {
+                this.sendLog('debug', 'Getting response from LifecycleSettingsResult', this.currentRequestId);
+                const params = request.params || {};
+                settingsResponse = result.getResponse(params.page);
+                this.sendLog('debug', `Settings response: ${JSON.stringify(settingsResponse)}`, this.currentRequestId);
+            }
+            else if (result) {
+                this.sendLog('debug', 'Using result as fallback', this.currentRequestId);
+                // Fallback - use result as is
+                settingsResponse = result;
+            }
+            // Mock the storage.settings.getAllSections() call since we don't have the full SDK context
+            // In real implementation, this would fetch from the app's settings store
+            const mockFormData = {}; // This will be populated by the REST endpoint
+            processedResult = {
+                result: settingsResponse,
+                data: mockFormData
+            };
+        }
+        else if (request.method === 'onInstall' || request.method === 'onUninstall' || request.method === 'onUpgrade') {
+            // These methods return LifecycleResult with success property
+            if (result && typeof result === 'object' && 'success' in result) {
+                processedResult = result;
+            }
+            else {
+                // If the result doesn't have success property, assume success if no error was thrown
+                this.sendLog('warn', `Lifecycle method ${request.method} did not return a proper LifecycleResult object. Assuming success.`, this.currentRequestId);
+                processedResult = {
+                    success: true,
+                    message: result?.message || 'Operation completed without explicit success status'
+                };
+            }
+        }
+        else if (request.method === 'canUninstall') {
+            // canUninstall returns CanUninstallResult with uninstallable property
+            if (result && typeof result === 'object' && 'uninstallable' in result) {
+                processedResult = result;
+            }
+            else {
+                // If the result doesn't have uninstallable property, this is an error
+                throw new Error(`Lifecycle method canUninstall did not return a proper CanUninstallResult object with uninstallable property. Result: ${JSON.stringify(result)}`);
+            }
+        }
+        else {
+            // Default fallback for other methods
+            processedResult = result;
+        }
+        this.sendProgress(this.currentRequestId, 'Lifecycle execution completed', 100);
+        return {
+            success: request.method === 'onSettingsForm' ? true : (processedResult?.success !== false),
+            result: processedResult
+        };
+    }
+    /**
+     * Execute a job with the given request
+     */
+    async executeJob(request) {
+        if (!this.appConfig || !this.appDir) {
+            throw new Error('Local engine not properly initialized');
+        }
+        if (!this.isInitialized) {
+            throw new Error('SDK not initialized');
+        }
+        this.sendLog('info', `Executing job: ${request.jobId}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Finding job file', 20);
+        // Find job definition in manifest
+        const manifest = this.appConfig.manifest;
+        let jobDef = null;
+        let isSourceJob = false;
+        // Check regular jobs
+        if (manifest.jobs && manifest.jobs[request.jobId]) {
+            jobDef = manifest.jobs[request.jobId];
+            isSourceJob = false;
+        }
+        // Check source jobs (nested under sources)
+        else if (manifest.sources) {
+            for (const [sourceId, source] of Object.entries(manifest.sources)) {
+                const sourceAny = source;
+                if (sourceAny.jobs) {
+                    const compositeJobId = `${sourceId}_${Object.keys(sourceAny.jobs)[0]}`;
+                    if (compositeJobId === request.jobId || Object.keys(sourceAny.jobs).includes(request.jobId)) {
+                        const actualJobId = request.jobId.includes('_') ? request.jobId.split('_')[1] : request.jobId;
+                        jobDef = sourceAny.jobs[actualJobId];
+                        isSourceJob = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!jobDef) {
+            throw new Error(`Job not found in manifest: ${request.jobId}`);
+        }
+        // Find the built job file
+        const jobPath = path_1.default.join(this.appDir, 'dist', 'jobs', `${jobDef.entry_point}.js`);
+        if (!fs_1.default.existsSync(jobPath)) {
+            throw new Error(`Job file not built or not found: dist/jobs/${jobDef.entry_point}.js`);
+        }
+        this.sendLog('info', `Using job file: ${jobPath}`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Loading job module', 40);
+        // Import job module
+        const JobModule = require(jobPath);
+        // Find job class (look for default export or named export matching entry point)
+        let JobClass = JobModule.default || JobModule[jobDef.entry_point] || JobModule;
+        if (typeof JobClass !== 'function') {
+            // Look for any class in the module
+            const exports = Object.keys(JobModule);
+            for (const key of exports) {
+                if (typeof JobModule[key] === 'function' && JobModule[key].prototype) {
+                    JobClass = JobModule[key];
+                    break;
+                }
+            }
+        }
+        if (typeof JobClass !== 'function') {
+            throw new Error(`No job class found in ${jobPath}`);
+        }
+        this.sendLog('info', 'Job class found, creating invocation...', this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Creating job invocation', 60);
+        // Create job invocation
+        const invocation = {
+            jobId: `${request.jobId}_${Date.now()}`, // Unique run ID
+            scheduledAt: new Date(),
+            parameters: request.parameters || {}
+        };
+        // Add dataSyncId for source jobs
+        if (isSourceJob && request.dataSyncId) {
+            invocation.dataSyncId = request.dataSyncId;
+        }
+        this.sendLog('info', 'Creating job instance...', this.currentRequestId);
+        // Create job instance
+        let jobInstance;
+        if (isSourceJob && request.dataSyncId) {
+            // Source job requires source parameter
+            const mockSource = { id: request.sourceKey || 'local-source' };
+            jobInstance = new JobClass(invocation, mockSource);
+        }
+        else {
+            jobInstance = new JobClass(invocation);
+        }
+        // Validate job instance has required methods
+        if (typeof jobInstance.prepare !== 'function') {
+            throw new Error('Job class does not implement prepare method');
+        }
+        if (typeof jobInstance.perform !== 'function') {
+            throw new Error('Job class does not implement perform method');
+        }
+        this.sendLog('info', 'Executing job prepare method...', this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Preparing job', 70);
+        // Import LocalJobStore to track state
+        const { LocalJobStore } = require('./storage/LocalJobStore');
+        const jobStore = LocalJobStore.getInstance(request.appDir);
+        const { createHash } = require('crypto');
+        let status;
+        let statusHash;
+        try {
+            // Execute prepare phase
+            this.sendLog('info', 'Executing job prepare method...', this.currentRequestId);
+            status = await jobInstance.prepare(request.parameters || {});
+            statusHash = createHash('sha256').update(JSON.stringify(status)).digest('hex');
+            // Save initial state from prepare
+            jobStore.saveState(request.executionId, status, status.complete || false, statusHash, 'prepare');
+            this.sendLog('info', 'Job prepared successfully', this.currentRequestId);
+        }
+        catch (error) {
+            this.sendLog('error', `Job prepare failed: ${error.message}`, this.currentRequestId);
+            // Mark job as failed in store
+            const { LocalJobStore, JobExecutionStatus } = require('./storage/LocalJobStore');
+            const failedJobStore = LocalJobStore.getInstance(request.appDir);
+            failedJobStore.updateExecutionStatus(request.executionId, JobExecutionStatus.FAILED, {
+                message: error.message,
+                stack: error.stack
+            });
+            throw new Error(`Job prepare method failed: ${error.message}`);
+        }
+        this.sendLog('info', 'Job prepared, starting perform loop...', this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Executing job', 80);
+        // Execute perform loop
+        let loopCount = 0;
+        const maxLoops = 1000; // Safety limit
+        while (!status.complete && loopCount < maxLoops) {
+            this.sendLog('debug', `Job perform loop ${loopCount + 1}`, this.currentRequestId);
+            try {
+                status = await jobInstance.perform(status);
+                loopCount++;
+                // Check if state changed and save if so
+                const newStatusHash = createHash('sha256').update(JSON.stringify(status)).digest('hex');
+                if (statusHash !== newStatusHash) {
+                    jobStore.saveState(request.executionId, status, status.complete || false, newStatusHash, 'perform');
+                    statusHash = newStatusHash;
+                }
+                // Update progress
+                this.sendProgress(this.currentRequestId, `Job perform loop ${loopCount}`, 80 + (loopCount / maxLoops) * 15);
+            }
+            catch (error) {
+                this.sendLog('error', `Job perform failed at loop ${loopCount + 1}: ${error.message}`, this.currentRequestId);
+                // Mark job as failed in store
+                const { LocalJobStore, JobExecutionStatus } = require('./storage/LocalJobStore');
+                const failedJobStore = LocalJobStore.getInstance(request.appDir);
+                failedJobStore.updateExecutionStatus(request.executionId, JobExecutionStatus.FAILED, {
+                    message: error.message,
+                    stack: error.stack
+                });
+                throw new Error(`Job perform method failed at loop ${loopCount + 1}: ${error.message}`);
+            }
+        }
+        if (loopCount >= maxLoops && !status.complete) {
+            // Mark job as failed due to excessive loops
+            const { LocalJobStore, JobExecutionStatus } = require('./storage/LocalJobStore');
+            const failedJobStore = LocalJobStore.getInstance(request.appDir);
+            failedJobStore.updateExecutionStatus(request.executionId, JobExecutionStatus.FAILED, {
+                message: `Job exceeded maximum loop count (${maxLoops})`,
+                stack: new Error().stack
+            });
+            throw new Error(`Job exceeded maximum loop count (${maxLoops})`);
+        }
+        this.sendLog('info', `Job completed after ${loopCount} perform loops`, this.currentRequestId);
+        this.sendProgress(this.currentRequestId, 'Job execution completed', 100);
+        return {
+            success: true,
+            result: status,
+            loopCount
+        };
+    }
+    /**
+     * Execute destination ready() method
+     */
+    async executeDestinationReady(data) {
+        const { destinationId } = data; // entryPoint no longer needed
+        if (!this.runtime) {
+            throw new Error('Runtime not initialized');
+        }
+        this.sendLog('info', `Executing ready() for destination: ${destinationId}`, this.currentRequestId);
+        // Use Runtime to get destination class
+        const DestinationClass = await this.runtime.getDestinationClass(destinationId);
+        const destination = new DestinationClass();
+        const result = await destination.ready();
+        this.sendLog('info', `Destination ready() result: ${JSON.stringify(result)}`, this.currentRequestId);
+        return result;
+    }
+    /**
+     * Execute destination deliver() method
+     */
+    async executeDestinationDeliver(data) {
+        const { destinationId, batch } = data; // entryPoint no longer needed
+        if (!this.runtime) {
+            throw new Error('Runtime not initialized');
+        }
+        this.sendLog('debug', `Batch: ${JSON.stringify(batch)}`, this.currentRequestId);
+        // Use Runtime to get destination class
+        const DestinationClass = await this.runtime.getDestinationClass(destinationId);
+        const destination = new DestinationClass();
+        const result = await destination.deliver(batch);
+        this.sendLog('info', `Destination deliver() result: ${JSON.stringify(result)}`, this.currentRequestId);
+        return result;
+    }
+    /**
+     * Execute destination schema function
+     */
+    async executeDestinationSchema(data) {
+        const { destinationId } = data;
+        if (!this.runtime) {
+            throw new Error('Runtime not initialized');
+        }
+        this.sendLog('info', `Loading schema for destination: ${destinationId}`, this.currentRequestId);
+        // Get destination definition from manifest via Runtime
+        const destination = this.runtime.manifest.destinations?.[destinationId];
+        if (!destination) {
+            // Use Runtime's error message format for consistency with production
+            throw new Error(`No destination '${destinationId}' defined in manifest`);
+        }
+        let schema;
+        // Check if schema is static (YAML) or dynamic (function)
+        if (typeof destination.schema === 'string') {
+            // Load static YAML schema using Runtime
+            this.sendLog('info', `Loading static YAML schema: ${destination.schema}`, this.currentRequestId);
+            const allSchemas = this.runtime.getDestinationSchema();
+            // Runtime returns schemas keyed by file path, e.g., "destinations/schema/myschema.yml"
+            const schemaKey = `destinations/schema/${destination.schema}.yml`;
+            const schemaKeyYaml = `destinations/schema/${destination.schema}.yaml`;
+            schema = allSchemas[schemaKey] || allSchemas[schemaKeyYaml];
+            if (!schema) {
+                throw new Error(`Schema file not found: ${destination.schema}.yml or .yaml`);
+            }
+            this.sendLog('info', `Static schema loaded: ${destination.schema}`, this.currentRequestId);
+        }
+        else if (destination.schema?.entry_point) {
+            // Load dynamic schema function using Runtime
+            this.sendLog('info', `Loading dynamic schema function for: ${destinationId}`, this.currentRequestId);
+            const SchemaFunctionClass = await this.runtime.getDestinationSchemaFunctionClass(destinationId);
+            const schemaFunction = new SchemaFunctionClass({ destinationKey: destinationId });
+            schema = await schemaFunction.getDestinationsSchema();
+            this.sendLog('info', `Dynamic schema loaded for ${destinationId}: ${schema.name}`, this.currentRequestId);
+        }
+        else {
+            throw new Error(`Destination '${destinationId}' has invalid schema configuration`);
+        }
+        return schema;
+    }
+    /**
+     * Handle source webhook
+     */
+    async handleSourceWebhook(message) {
+        const { sourceId, guid, method, fullpath, path, params, headers, body } = message.data;
+        if (!this.appConfig) {
+            throw new Error('App configuration not initialized');
+        }
+        // Create configuration
+        const sources = this.appConfig.manifest.sources || {};
+        const sourceManifest = sources[sourceId];
+        if (!sourceManifest) {
+            throw new Error(`Source ${sourceId} not found in manifest`);
+        }
+        const config = {
+            dataSyncId: 'mock-data-sync-id',
+            sourceKey: sourceId,
+            schema: sourceManifest.schema,
+            webhookUrl: `http://localhost:${process.env.PORT || 8080}/sources/${this.appConfig.manifest.meta?.app_id}/${sourceId}/${guid}`
+        };
+        // Load SourceFunction class using runtime - pass sourceId, runtime looks up entry_point
+        const SourceFunctionClass = await this.runtime.getSourceFunctionClass(sourceId);
+        // Create Request instance using dynamically loaded class
+        // Convert body to Buffer format (SDK expects raw body as Uint8Array, not parsed object)
+        const bodyBuffer = body ? Buffer.from(JSON.stringify(body)) : Buffer.from('');
+        const request = new this.sdkComponents.Request(method, path, params, headers, bodyBuffer);
+        // Create mocked Source instance
+        const mockedSource = {
+            emit: async (data) => {
+                this.sourceDataStore.push(sourceId, data, 'webhook');
+                return { success: true };
+            }
+        };
+        // Instantiate and execute
+        const sourceFunction = new SourceFunctionClass(config, request, mockedSource);
+        const response = await sourceFunction.perform();
+        // Return response (convert to serializable format like function execution)
+        return {
+            status: response.status,
+            headers: response.headers ? response.headers.toArray() : [],
+            body: response.bodyAsU8Array ? Array.from(response.bodyAsU8Array) : null
+        };
+    }
+    /**
+     * Handle source lifecycle
+     */
+    async handleSourceLifecycle(message, action) {
+        const { sourceId, guid } = message.data;
+        if (!this.appConfig) {
+            throw new Error('App configuration not initialized');
+        }
+        // Create configuration
+        const sources = this.appConfig.manifest.sources || {};
+        const sourceManifest = sources[sourceId];
+        if (!sourceManifest) {
+            throw new Error(`Source ${sourceId} not found in manifest`);
+        }
+        const config = {
+            dataSyncId: 'mock-data-sync-id',
+            sourceKey: sourceId,
+            schema: sourceManifest.schema,
+            webhookUrl: `http://localhost:${process.env.PORT || 8080}/sources/${this.appConfig.manifest.meta?.app_id}/${sourceId}/${guid}`
+        };
+        // Load SourceLifecycle class using runtime - pass sourceId, runtime looks up entry_point
+        // Returns null if no lifecycle handler defined
+        const SourceLifecycleClass = await this.runtime.getSourceLifecycleClass(sourceId);
+        if (!SourceLifecycleClass) {
+            return {
+                success: true,
+                message: 'No lifecycle handler defined for this source'
+            };
+        }
+        // Instantiate lifecycle handler
+        const lifecycle = new SourceLifecycleClass(config);
+        // Call appropriate method
+        let result;
+        switch (action) {
+            case 'create':
+                result = await lifecycle.onSourceCreate();
+                break;
+            case 'update':
+                result = await lifecycle.onSourceUpdate();
+                break;
+            case 'delete':
+                result = await lifecycle.onSourceDelete();
+                break;
+            case 'enable':
+                result = await lifecycle.onSourceEnable();
+                break;
+            case 'pause':
+                result = await lifecycle.onSourcePause();
+                break;
+            default:
+                throw new Error(`Unknown lifecycle action: ${action}`);
+        }
+        return result;
+    }
+    /**
+     * Handle source job
+     */
+    async handleSourceJob(message) {
+        const { sourceId, jobId, parameters } = message.data;
+        const startTime = Date.now();
+        const logs = [];
+        try {
+            if (!this.appConfig) {
+                throw new Error('App configuration not initialized');
+            }
+            // Load SourceJob class using runtime - pass sourceId and jobId, runtime looks up entry_point
+            const SourceJobClass = await this.runtime.getSourceJobClass(sourceId, jobId);
+            // Create mocked Source instance
+            const mockedSource = {
+                emit: async (data) => {
+                    this.sourceDataStore.push(sourceId, data, 'job');
+                    logs.push(`Pushed data: ${JSON.stringify(data)}`);
+                    return { success: true };
+                }
+            };
+            // Create invocation
+            const invocation = {
+                jobId,
+                scheduledAt: new Date(),
+                parameters: parameters || {},
+                dataSyncId: 'mock-data-sync-id'
+            };
+            // Instantiate job
+            const job = new SourceJobClass(invocation, mockedSource);
+            // Execute prepare
+            logs.push('Preparing job...');
+            let status = await job.prepare(parameters || {});
+            logs.push('Job prepared');
+            // Execute perform loop
+            let iterations = 0;
+            const maxIterations = 100;
+            while (!status.complete && iterations < maxIterations) {
+                logs.push(`Performing iteration ${iterations + 1}...`);
+                status = await job.perform(status);
+                iterations++;
+            }
+            if (!status.complete) {
+                logs.push(`Warning: Job did not complete after ${maxIterations} iterations`);
+            }
+            else {
+                logs.push('Job completed successfully');
+            }
+            const executionTime = Date.now() - startTime;
+            // Store execution
+            this.sourceJobExecutionStore.addExecution(sourceId, {
+                jobId,
+                timestamp: Date.now(),
+                success: true,
+                logs,
+                executionTime,
+                result: status
+            });
+            return {
+                success: true,
+                logs,
+                executionTime,
+                result: status
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            logs.push(`Error: ${error.message}`);
+            // Store failed execution
+            this.sourceJobExecutionStore.addExecution(sourceId, {
+                jobId,
+                timestamp: Date.now(),
+                success: false,
+                logs,
+                executionTime,
+                error: error.message
+            });
+            throw error; // Let the base class handler catch and send the error
+        }
+    }
+    /**
+     * Handle source schema
+     */
+    async handleSourceSchema(message) {
+        const { sourceId } = message.data;
+        if (!this.appConfig) {
+            throw new Error('App configuration not initialized');
+        }
+        if (!this.runtime) {
+            throw new Error('Runtime not initialized');
+        }
+        const sources = this.appConfig.manifest.sources || {};
+        const sourceManifest = sources[sourceId];
+        if (!sourceManifest) {
+            throw new Error(`Source ${sourceId} not found in manifest`);
+        }
+        const schema = sourceManifest.schema;
+        // Static schema - load from YAML file using Runtime
+        if (typeof schema === 'string') {
+            this.sendLog('info', `Loading static YAML schema: ${schema}`, this.currentRequestId);
+            const allSchemas = this.runtime.getSourceSchema();
+            // Runtime returns schemas keyed by file path, e.g., "sources/schema/myschema.yml"
+            const schemaKey = `sources/schema/${schema}.yml`;
+            const schemaKeyYaml = `sources/schema/${schema}.yaml`;
+            const loadedSchema = allSchemas[schemaKey] || allSchemas[schemaKeyYaml];
+            if (!loadedSchema) {
+                throw new Error(`Schema file not found: ${schema}.yml or .yaml`);
+            }
+            this.sendLog('info', `Static schema loaded: ${schema}`, this.currentRequestId);
+            return loadedSchema;
+        }
+        // Dynamic schema - call the schema function
+        if (typeof schema === 'object' && schema.entry_point) {
+            this.sendLog('info', `Loading dynamic schema function for: ${sourceId}`, this.currentRequestId);
+            const SchemaFunctionClass = await this.runtime.getSourceSchemaFunctionClass(sourceId);
+            const config = {
+                sourceKey: sourceId
+            };
+            const schemaFunction = new SchemaFunctionClass(config);
+            const result = await schemaFunction.getSourcesSchema();
+            this.sendLog('info', `Dynamic schema loaded for ${sourceId}`, this.currentRequestId);
+            return result;
+        }
+        throw new Error('Invalid schema configuration');
+    }
+    /**
+     * Clean up SDK configuration
+     * This only happens when the process is shutting down
+     */
+    async cleanup() {
+        this.sendLog('info', 'Cleaning up unified wrapper');
+        if (this.cleanUpLocalSDKs && this.appDir && this.isInitialized) {
+            try {
+                this.cleanUpLocalSDKs(this.appDir);
+                this.sendLog('info', 'SDK cleanup completed');
+                this.isInitialized = false;
+            }
+            catch (error) {
+                this.sendLog('warn', `SDK cleanup error: ${error}`);
+            }
+        }
+    }
+}
+exports.LocalEngineUnified = LocalEngineUnified;
+// Only execute if this script is run directly (not imported)
+if (require.main === module) {
+    const localEngine = new LocalEngineUnified();
+    localEngine.start();
+}
+//# sourceMappingURL=local-engine-unified.js.map