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

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

@@ -0,0 +1,888 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalEngineClient = void 0;
+/**
+ * IPC Client for managing child process communication
+ */
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const local_engine_utils_1 = require("./local-engine-utils");
+const LogManager_1 = require("../logging/LogManager");
+function getLogCategoryFromMessageType(context) {
+    switch (context.type) {
+        case 'function':
+            return LogManager_1.LogCategory.Function;
+        case 'lifecycle':
+            return LogManager_1.LogCategory.Lifecycle;
+        case 'destination':
+            return LogManager_1.LogCategory.Destination;
+        case 'source':
+            return LogManager_1.LogCategory.Source;
+        case 'jobs':
+            return LogManager_1.LogCategory.Jobs;
+        default:
+            return LogManager_1.LogCategory.AppRunner;
+    }
+}
+/**
+ * Process buffered output and log complete lines
+ */
+function processBufferedOutput(buffer, newData, isError, context) {
+    const logManager = LogManager_1.LogManager.getInstance();
+    const combined = buffer + newData;
+    const lines = combined.split('\n');
+    // Keep the last incomplete line in the buffer
+    const remainingBuffer = lines.pop() || '';
+    // Log only valid JSON lines (filters out pretty-printed output)
+    lines.forEach(line => {
+        const trimmed = line.trim();
+        if (trimmed) {
+            try {
+                // Try to parse as JSON
+                const parsed = JSON.parse(trimmed);
+                // Only log if it's a valid JSON object (structured log)
+                if (typeof parsed === 'object' && parsed !== null) {
+                    // Log with execution context
+                    if (context) {
+                        // Map execution context type to log category enum
+                        let category = getLogCategoryFromMessageType(context);
+                        logManager.log({
+                            source: LogManager_1.LogSource.App,
+                            category,
+                            level: isError ? 'error' : 'info',
+                            message: trimmed,
+                            context: { id: context.id }
+                        });
+                    }
+                    else {
+                        // Fallback for app output without context
+                        logManager.log({
+                            source: LogManager_1.LogSource.App,
+                            category: LogManager_1.LogCategory.AppRunner,
+                            level: isError ? 'error' : 'info',
+                            message: trimmed,
+                            context: { id: '' }
+                        });
+                    }
+                }
+                else {
+                    console.error(trimmed, context);
+                }
+                // Silently ignore non-JSON lines (pretty-printed output)
+            }
+            catch (error) {
+                // Not valid JSON - silently ignore
+            }
+        }
+    });
+    return remainingBuffer;
+}
+class LocalEngineClient {
+    constructor() {
+        this.connections = new Map();
+        this.logManager = LogManager_1.LogManager.getInstance();
+    }
+    /**
+     * Get the singleton instance of LocalEngineClient
+     * This ensures all IPC handlers share the same instance and JobExecutor
+     */
+    static getInstance() {
+        if (!LocalEngineClient.instance) {
+            LocalEngineClient.instance = new LocalEngineClient();
+        }
+        return LocalEngineClient.instance;
+    }
+    /**
+     * Set the JobExecutor instance for handling job trigger requests
+     */
+    setJobExecutor(jobExecutor) {
+        this.jobExecutor = jobExecutor;
+    }
+    /**
+     * Get or create a connection for the specified app
+     */
+    async getConnection(appConfig, appDir) {
+        const connectionKey = appConfig.manifest.meta?.app_id || 'unknown';
+        let connection = this.connections.get(connectionKey);
+        // Check if existing connection is healthy
+        if (connection && (0, local_engine_utils_1.isConnectionHealthy)(connection)) {
+            connection.lastActivity = Date.now();
+            return connection;
+        }
+        // Clean up old connection if it exists
+        if (connection) {
+            await this.closeConnection(connectionKey);
+        }
+        // Create new connection
+        connection = await this.createConnection(appConfig, appDir);
+        this.connections.set(connectionKey, connection);
+        return connection;
+    }
+    /**
+     * Create a new IPC connection using the unified wrapper
+     */
+    async createConnection(appConfig, appDir) {
+        const wrapperScript = path_1.default.join(__dirname, 'local-engine-unified.js');
+        this.logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Starting unified wrapper for app', {
+            id: '',
+            operation: 'spawn',
+            appId: appConfig.manifest.meta?.app_id
+        });
+        const childProcess = (0, child_process_1.spawn)('node', [wrapperScript], {
+            cwd: appDir,
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            env: {
+                ...process.env,
+                DISABLE_LOGMANAGER_CONSOLE: 'true' // Prevent double logging from child process
+            }
+        });
+        const connection = {
+            process: childProcess,
+            ready: false,
+            pendingRequests: new Map(),
+            lastActivity: Date.now(),
+            stdoutBuffer: '',
+            stderrBuffer: ''
+        };
+        // Set up message handling
+        this.setupMessageHandlers(connection);
+        // Set up error handling
+        this.setupErrorHandlers(connection);
+        // Initialize the child process
+        await this.initializeChild(connection, appConfig, appDir);
+        return connection;
+    }
+    /**
+     * Set up message handlers for a connection
+     */
+    setupMessageHandlers(connection) {
+        connection.process.on('message', (message) => {
+            try {
+                (0, local_engine_utils_1.logIPCMessage)('RECV', message, '[IPC Client]');
+                if (!(0, local_engine_utils_1.validateMessage)(message)) {
+                    this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Received invalid message', {
+                        id: connection.process.pid.toString(),
+                        messageType: message?.type
+                    });
+                    return;
+                }
+                this.handleChildMessage(connection, message);
+            }
+            catch (error) {
+                this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Error handling child message', {
+                    id: 'unknown',
+                    error
+                });
+            }
+        });
+        // Handle stdout/stderr - processBufferedOutput logs to LogManager
+        connection.process.stdout?.on('data', (data) => {
+            const output = data.toString();
+            connection.stdoutBuffer = processBufferedOutput(connection.stdoutBuffer || '', output, false, connection.currentContext // Pass execution context
+            );
+        });
+        connection.process.stderr?.on('data', (data) => {
+            const error = data.toString();
+            connection.stderrBuffer = processBufferedOutput(connection.stderrBuffer || '', error, true, connection.currentContext // Pass execution context
+            );
+        });
+    }
+    /**
+     * Set up error handlers for a connection
+     */
+    setupErrorHandlers(connection) {
+        connection.process.on('error', (error) => {
+            this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Child process error', {
+                id: connection.process.pid?.toString() || 'unknown',
+                operation: 'error',
+                error
+            });
+            this.handleConnectionError(connection, error);
+        });
+        connection.process.on('exit', (code, signal) => {
+            this.logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Child process exited', {
+                id: connection.process.pid?.toString() || 'unknown',
+                operation: 'exit',
+                exitCode: code ?? undefined,
+                signal: signal ?? undefined
+            });
+            this.handleConnectionExit(connection, code, signal);
+        });
+        connection.process.on('close', () => {
+            this.logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Child process closed', {
+                id: connection.process.pid?.toString() || 'unknown',
+                operation: 'close'
+            });
+            connection.ready = false;
+        });
+    }
+    /**
+     * Handle messages from child process
+     */
+    handleChildMessage(connection, message) {
+        connection.lastActivity = Date.now();
+        switch (message.type) {
+            case 'ready':
+                this.handleReadyMessage(connection);
+                break;
+            case 'progress':
+                this.handleProgressMessage(connection, message);
+                break;
+            case 'log':
+                this.handleLogMessage(connection, message);
+                break;
+            case 'success':
+                this.handleSuccessMessage(connection, message);
+                break;
+            case 'error':
+                this.handleErrorMessage(connection, message);
+                break;
+            case 'trigger_job':
+                this.handleTriggerJobMessage(connection, message);
+                break;
+            case 'get_job_detail':
+                this.handleGetJobDetailMessage(connection, message);
+                break;
+            case 'get_job_status':
+                this.handleGetJobStatusMessage(connection, message);
+                break;
+            default:
+                this.logManager.warn(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Unknown message type', {
+                    id: 'unknown',
+                    messageType: message.type
+                });
+        }
+    }
+    /**
+     * Handle ready message from child
+     */
+    handleReadyMessage(connection) {
+        this.logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Child process is ready', {
+            id: connection.process.pid?.toString() || 'unknown'
+        });
+        connection.ready = true;
+    }
+    /**
+     * Handle progress message from child
+     */
+    handleProgressMessage(connection, message) {
+        const { requestId, message: progressMsg, progress } = message.data;
+        this.logManager.debug(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, `Progress: ${progressMsg}`, {
+            id: requestId || 'unknown',
+            messageType: 'progress'
+        });
+    }
+    /**
+     * Handle log message from child
+     */
+    handleLogMessage(connection, message) {
+        const { level, message: logMsg, requestId } = message.data;
+        this.logManager.debug(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, logMsg, {
+            id: requestId || connection.process.pid.toString() || 'unknown',
+            messageType: 'log'
+        });
+    }
+    /**
+     * Handle success message from child
+     */
+    handleSuccessMessage(connection, message) {
+        const { requestId, result } = message.data;
+        const pendingRequest = connection.pendingRequests.get(requestId);
+        if (pendingRequest) {
+            (0, local_engine_utils_1.cleanupPendingRequest)(pendingRequest);
+            connection.pendingRequests.delete(requestId);
+            pendingRequest.resolve(result);
+            // Clear execution context
+            if (connection.currentContext?.requestId === requestId) {
+                connection.currentContext = undefined;
+            }
+        }
+        else {
+            this.logManager.warn(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Received success for unknown request', {
+                id: requestId || 'unknown',
+                messageType: 'success'
+            });
+        }
+    }
+    /**
+     * Handle error message from child
+     */
+    handleErrorMessage(connection, message) {
+        const { requestId, error: errorMsg, stack } = message.data;
+        const pendingRequest = connection.pendingRequests.get(requestId);
+        if (pendingRequest) {
+            (0, local_engine_utils_1.cleanupPendingRequest)(pendingRequest);
+            connection.pendingRequests.delete(requestId);
+            const error = (0, local_engine_utils_1.deserializeError)({ message: errorMsg, stack });
+            pendingRequest.reject(error);
+            // Clear execution context
+            if (connection.currentContext?.requestId === requestId) {
+                connection.currentContext = undefined;
+            }
+        }
+        else {
+            this.logManager.warn(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Received error for unknown request', {
+                id: requestId || 'unknown',
+                messageType: 'error',
+                errorMessage: errorMsg
+            });
+        }
+    }
+    /**
+     * Handle job trigger request from child
+     */
+    async handleTriggerJobMessage(connection, message) {
+        const { jobName, parameters } = message.data;
+        const requestId = message.id;
+        if (!this.jobExecutor) {
+            this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Jobs, 'JobExecutor not available', {
+                id: requestId,
+                jobName
+            });
+            // Send error response
+            const errorResponse = {
+                ...(0, local_engine_utils_1.createBaseMessage)('error'),
+                type: 'error',
+                data: {
+                    requestId,
+                    error: 'JobExecutor not initialized',
+                    executionTime: 0
+                }
+            };
+            (0, local_engine_utils_1.sendIPCMessage)(connection.process, errorResponse);
+            return;
+        }
+        this.logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.Jobs, 'Processing job trigger request from child', {
+            id: requestId,
+            jobName
+        });
+        // Execute the job - this returns a response object with success/error info
+        const response = await this.jobExecutor.executeJob({
+            jobId: jobName,
+            parameters: parameters || {}
+        });
+        // Check if execution failed
+        if (!response.success) {
+            this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Jobs, 'Job trigger request failed', {
+                id: requestId,
+                jobName,
+                error: response.error
+            });
+            // Send error response back to child
+            const errorResponse = {
+                ...(0, local_engine_utils_1.createBaseMessage)('error'),
+                type: 'error',
+                data: {
+                    requestId,
+                    error: response.error || 'Failed to trigger job',
+                    executionTime: 0
+                }
+            };
+            (0, local_engine_utils_1.sendIPCMessage)(connection.process, errorResponse);
+            return;
+        }
+        // Get the execution details
+        const execution = this.jobExecutor.getExecution(response.executionId);
+        if (!execution) {
+            this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Jobs, 'Execution not found after trigger', {
+                id: requestId,
+                jobName,
+                executionId: response.executionId
+            });
+            const errorResponse = {
+                ...(0, local_engine_utils_1.createBaseMessage)('error'),
+                type: 'error',
+                data: {
+                    requestId,
+                    error: `Execution not found after trigger: ${response.executionId}`,
+                    executionTime: 0
+                }
+            };
+            (0, local_engine_utils_1.sendIPCMessage)(connection.process, errorResponse);
+            return;
+        }
+        this.logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.Jobs, 'Job triggered successfully from child', {
+            id: requestId,
+            jobName,
+            executionId: response.executionId
+        });
+        // Send success response with execution details
+        const successResponse = {
+            ...(0, local_engine_utils_1.createBaseMessage)('success'),
+            type: 'success',
+            data: {
+                requestId,
+                result: {
+                    jobId: execution.id,
+                    jobName: execution.jobId,
+                    status: execution.status,
+                    parameters: execution.parameters,
+                    startedAt: execution.startedAt,
+                    completedAt: execution.completedAt
+                },
+                executionTime: 0
+            }
+        };
+        (0, local_engine_utils_1.sendIPCMessage)(connection.process, successResponse);
+    }
+    /**
+     * Handle job detail request from child
+     */
+    async handleGetJobDetailMessage(connection, message) {
+        const { requestId, executionId } = message.data;
+        const execution = this.jobExecutor?.getExecution(executionId);
+        if (!execution) {
+            const errorResponse = {
+                ...(0, local_engine_utils_1.createBaseMessage)('error'),
+                type: 'error',
+                data: {
+                    requestId,
+                    error: `Execution ${executionId} not found`,
+                    executionTime: 0
+                }
+            };
+            (0, local_engine_utils_1.sendIPCMessage)(connection.process, errorResponse);
+            return;
+        }
+        // Send success response with execution details
+        const successResponse = {
+            ...(0, local_engine_utils_1.createBaseMessage)('success'),
+            type: 'success',
+            data: {
+                requestId,
+                result: {
+                    jobId: execution.id,
+                    jobName: execution.jobId,
+                    status: execution.status,
+                    parameters: execution.parameters,
+                    startedAt: execution.startedAt,
+                    completedAt: execution.completedAt
+                },
+                executionTime: 0
+            }
+        };
+        (0, local_engine_utils_1.sendIPCMessage)(connection.process, successResponse);
+    }
+    /**
+     * Handle job status request from child
+     */
+    async handleGetJobStatusMessage(connection, message) {
+        const { requestId, executionId } = message.data;
+        const execution = this.jobExecutor?.getExecution(executionId);
+        if (!execution) {
+            const errorResponse = {
+                ...(0, local_engine_utils_1.createBaseMessage)('error'),
+                type: 'error',
+                data: {
+                    requestId,
+                    error: `Execution ${executionId} not found`,
+                    executionTime: 0
+                }
+            };
+            (0, local_engine_utils_1.sendIPCMessage)(connection.process, errorResponse);
+            return;
+        }
+        // Send success response with just the status
+        const successResponse = {
+            ...(0, local_engine_utils_1.createBaseMessage)('success'),
+            type: 'success',
+            data: {
+                requestId,
+                result: {
+                    status: execution.status
+                },
+                executionTime: 0
+            }
+        };
+        (0, local_engine_utils_1.sendIPCMessage)(connection.process, successResponse);
+    }
+    /**
+     * Handle connection errors
+     */
+    handleConnectionError(connection, error) {
+        this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Connection error', {
+            id: connection.process.pid?.toString() || 'unknown',
+            operation: 'error',
+            error
+        });
+        // Reject all pending requests
+        for (const [requestId, pendingRequest] of connection.pendingRequests) {
+            (0, local_engine_utils_1.cleanupPendingRequest)(pendingRequest);
+            pendingRequest.reject(new Error(`Connection error: ${error.message}`));
+        }
+        connection.pendingRequests.clear();
+        connection.ready = false;
+    }
+    /**
+     * Flush remaining buffered output before connection closes
+     */
+    flushRemainingBuffers(connection) {
+        const logManager = LogManager_1.LogManager.getInstance();
+        // Flush stdout buffer if it has content
+        if (connection.stdoutBuffer?.trim()) {
+            try {
+                logManager.log({
+                    source: LogManager_1.LogSource.App,
+                    category: LogManager_1.LogCategory.AppRunner,
+                    level: 'info',
+                    message: connection.stdoutBuffer.trim(),
+                    context: { id: 'unknown' }
+                });
+                connection.stdoutBuffer = '';
+            }
+            catch (error) {
+                this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Error flushing stdout buffer', {
+                    id: 'buffer',
+                    operation: 'flush',
+                    error
+                });
+            }
+        }
+        // Flush stderr buffer if it has content
+        if (connection.stderrBuffer?.trim()) {
+            try {
+                logManager.log({
+                    source: LogManager_1.LogSource.App,
+                    category: LogManager_1.LogCategory.AppRunner,
+                    level: 'error',
+                    message: connection.stderrBuffer.trim(),
+                    context: { id: 'unknown' }
+                });
+                connection.stderrBuffer = '';
+            }
+            catch (error) {
+                this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Error flushing stderr buffer', {
+                    id: 'buffer',
+                    operation: 'flush',
+                    error
+                });
+            }
+        }
+    }
+    /**
+     * Handle connection exit
+     */
+    handleConnectionExit(connection, code, signal) {
+        // Flush any remaining buffered output before handling exit
+        this.flushRemainingBuffers(connection);
+        // Reject all pending requests
+        for (const [requestId, pendingRequest] of connection.pendingRequests) {
+            (0, local_engine_utils_1.cleanupPendingRequest)(pendingRequest);
+            pendingRequest.reject(new Error(`Child process exited with code ${code}, signal ${signal}`));
+        }
+        connection.pendingRequests.clear();
+        connection.ready = false;
+    }
+    /**
+     * Initialize child process
+     */
+    async initializeChild(connection, appConfig, appDir) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Child process initialization timeout'));
+            }, local_engine_utils_1.IPC_CONFIG.DEFAULT_TIMEOUT);
+            const checkReady = () => {
+                if (connection.ready) {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+                else {
+                    setTimeout(checkReady, 100);
+                }
+            };
+            // Send initialization message
+            const initMessage = {
+                ...(0, local_engine_utils_1.createBaseMessage)('initialize'),
+                type: 'initialize',
+                data: { appConfig, appDir }
+            };
+            (0, local_engine_utils_1.sendIPCMessage)(connection.process, initMessage);
+            (0, local_engine_utils_1.logIPCMessage)('SEND', initMessage, '[IPC Client]');
+            checkReady();
+        });
+    }
+    /**
+     * Get execution type from message type
+     */
+    getExecutionType(messageType) {
+        if (messageType === 'execute_function')
+            return 'function';
+        if (messageType === 'execute_lifecycle')
+            return 'lifecycle';
+        if (messageType.startsWith('execute_destination_'))
+            return 'destination';
+        if (messageType.startsWith('execute_source_'))
+            return 'source';
+        if (messageType === 'execute_job')
+            return 'jobs';
+        return 'function'; // fallback
+    }
+    /**
+     * Get execution ID from message
+     */
+    getExecutionId(message) {
+        switch (message.type) {
+            case 'execute_function':
+                return message.data.functionId;
+            case 'execute_lifecycle':
+                return message.data.method;
+            case 'execute_destination_ready':
+            case 'execute_destination_deliver':
+            case 'execute_destination_schema':
+                return message.data.destinationId;
+            case 'execute_source_webhook':
+            case 'execute_source_create':
+            case 'execute_source_update':
+            case 'execute_source_delete':
+            case 'execute_source_enable':
+            case 'execute_source_pause':
+            case 'execute_source_job':
+            case 'execute_source_schema':
+                return message.data.sourceId;
+            case 'execute_job':
+                return message.data.jobId;
+            default:
+                return 'unknown';
+        }
+    }
+    /**
+     * Send a request and wait for response
+     */
+    async sendRequest(connection, message, timeoutMs = local_engine_utils_1.IPC_CONFIG.DEFAULT_TIMEOUT) {
+        return new Promise((resolve, reject) => {
+            const pendingRequest = (0, local_engine_utils_1.createPendingRequest)(message.id, message.type === 'execute_function' ? 'function' : 'lifecycle', resolve, reject, timeoutMs);
+            // Set up timeout
+            pendingRequest.timeout = (0, local_engine_utils_1.createRequestTimeout)(message.id, timeoutMs, reject, () => connection.pendingRequests.delete(message.id));
+            // Set execution context for stdout/stderr capture
+            connection.currentContext = {
+                type: this.getExecutionType(message.type),
+                id: this.getExecutionId(message),
+                requestId: message.id,
+                startTime: Date.now()
+            };
+            // Track the request
+            connection.pendingRequests.set(message.id, pendingRequest);
+            // Send the message
+            (0, local_engine_utils_1.logIPCMessage)('SEND', message, '[IPC Client]');
+            if (!(0, local_engine_utils_1.sendIPCMessage)(connection.process, message)) {
+                (0, local_engine_utils_1.cleanupPendingRequest)(pendingRequest);
+                connection.pendingRequests.delete(message.id);
+                reject(new Error('Failed to send IPC message'));
+            }
+        });
+    }
+    /**
+     * Execute a function using IPC
+     */
+    async executeFunction(request, appConfig, appDir) {
+        const connection = await this.getConnection(appConfig, appDir);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_function'),
+            type: 'execute_function',
+            data: request
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute a lifecycle method using IPC
+     */
+    async executeLifecycle(request, appConfig, appDir) {
+        const connection = await this.getConnection(appConfig, appDir);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_lifecycle'),
+            type: 'execute_lifecycle',
+            data: request
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute a job using IPC
+     */
+    async executeJob(request, appConfig, appDir) {
+        const connection = await this.getConnection(appConfig, appDir);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_job'),
+            type: 'execute_job',
+            data: request
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute destination ready() method
+     */
+    async executeDestinationReady(destinationId, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_destination_ready'),
+            type: 'execute_destination_ready',
+            data: { destinationId } // entryPoint removed
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute destination deliver() method
+     */
+    async executeDestinationDeliver(destinationId, batch, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_destination_deliver'),
+            type: 'execute_destination_deliver',
+            data: { destinationId, batch } // entryPoint removed
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute destination schema function
+     */
+    async executeDestinationSchema(destinationId, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_destination_schema'),
+            type: 'execute_destination_schema',
+            data: { destinationId } // entryPoint removed - local-engine looks it up from manifest
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source webhook
+     */
+    async executeSourceWebhook(request, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_webhook'),
+            type: 'execute_source_webhook',
+            data: request
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source create lifecycle
+     */
+    async executeSourceCreate(sourceId, guid, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_create'),
+            type: 'execute_source_create',
+            data: { sourceId, guid, action: 'create' }
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source update lifecycle
+     */
+    async executeSourceUpdate(sourceId, guid, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_update'),
+            type: 'execute_source_update',
+            data: { sourceId, guid, action: 'update' }
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source delete lifecycle
+     */
+    async executeSourceDelete(sourceId, guid, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_delete'),
+            type: 'execute_source_delete',
+            data: { sourceId, guid, action: 'delete' }
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source enable lifecycle
+     */
+    async executeSourceEnable(sourceId, guid, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_enable'),
+            type: 'execute_source_enable',
+            data: { sourceId, guid, action: 'enable' }
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source pause lifecycle
+     */
+    async executeSourcePause(sourceId, guid, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_pause'),
+            type: 'execute_source_pause',
+            data: { sourceId, guid, action: 'pause' }
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source job
+     */
+    async executeSourceJob(request, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_job'),
+            type: 'execute_source_job',
+            data: request
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Execute source schema
+     */
+    async executeSourceSchema(sourceId, appConfig) {
+        const connection = await this.getConnection(appConfig, appConfig.path);
+        const message = {
+            ...(0, local_engine_utils_1.createBaseMessage)('execute_source_schema'),
+            type: 'execute_source_schema',
+            data: { sourceId }
+        };
+        return this.sendRequest(connection, message);
+    }
+    /**
+     * Close a specific connection
+     */
+    async closeConnection(connectionKey) {
+        const connection = this.connections.get(connectionKey);
+        if (!connection)
+            return;
+        try {
+            // Flush any remaining buffered output before shutdown
+            this.flushRemainingBuffers(connection);
+            // Send shutdown message
+            const shutdownMessage = {
+                ...(0, local_engine_utils_1.createBaseMessage)('shutdown'),
+                type: 'shutdown'
+            };
+            (0, local_engine_utils_1.sendIPCMessage)(connection.process, shutdownMessage);
+            // Wait a bit for graceful shutdown
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Force kill if still running
+            if (!connection.process.killed) {
+                connection.process.kill('SIGTERM');
+            }
+        }
+        catch (error) {
+            this.logManager.warn(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Error during connection shutdown', {
+                id: connection.process.pid?.toString() || 'unknown',
+                operation: 'shutdown',
+                error
+            });
+        }
+        finally {
+            this.connections.delete(connectionKey);
+        }
+    }
+    /**
+     * Close all connections
+     */
+    async closeAllConnections() {
+        const closePromises = Array.from(this.connections.keys()).map(key => this.closeConnection(key));
+        await Promise.all(closePromises);
+    }
+}
+exports.LocalEngineClient = LocalEngineClient;
+//# sourceMappingURL=local-engine-client.js.map