@optimizely/ocp-local-env 1.0.0-beta.5 → 1.0.0-beta.7

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

@@ -10,9 +10,96 @@ exports.LocalEngineClient = void 0;
 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
@@ -39,17 +126,26 @@ class LocalEngineClient {
      */
     async createConnection(appConfig, appDir) {
         const wrapperScript = path_1.default.join(__dirname, 'local-engine-unified.js');
-        console.log(`[IPC Client] Starting unified wrapper for app ${appConfig.manifest.meta?.app_id}: ${wrapperScript}`);
+        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 }
+            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()
+            lastActivity: Date.now(),
+            stdoutBuffer: '',
+            stderrBuffer: ''
         };
         // Set up message handling
         this.setupMessageHandlers(connection);
@@ -67,27 +163,31 @@ class LocalEngineClient {
             try {
                 (0, local_engine_utils_1.logIPCMessage)('RECV', message, '[IPC Client]');
                 if (!(0, local_engine_utils_1.validateMessage)(message)) {
-                    console.error('[IPC Client] Received invalid message:', 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) {
-                console.error('[IPC Client] Error handling child message:', error);
+                this.logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Error handling child message', {
+                    id: 'unknown',
+                    error
+                });
             }
         });
-        // Handle stdout/stderr for debugging
+        // Handle stdout/stderr - processBufferedOutput logs to LogManager
         connection.process.stdout?.on('data', (data) => {
-            const output = data.toString().trim();
-            if (output) {
-                console.log(`[IPC Child STDOUT] ${output}`);
-            }
+            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().trim();
-            if (error) {
-                console.error(`[IPC Child STDERR] ${error}`);
-            }
+            const error = data.toString();
+            connection.stderrBuffer = processBufferedOutput(connection.stderrBuffer || '', error, true, connection.currentContext // Pass execution context
+            );
         });
     }
     /**
@@ -95,15 +195,27 @@ class LocalEngineClient {
      */
     setupErrorHandlers(connection) {
         connection.process.on('error', (error) => {
-            console.error('[IPC Client] Child process 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) => {
-            console.log(`[IPC Client] Child process exited with code ${code}, signal ${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', () => {
-            console.log('[IPC Client] Child process closed');
+            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;
         });
     }
@@ -128,15 +240,29 @@ class LocalEngineClient {
             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:
-                console.warn(`[IPC Client] Unknown message type: ${message.type}`);
+                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) {
-        console.log('[IPC Client] Child process is ready');
+        this.logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Child process is ready', {
+            id: connection.process.pid?.toString() || 'unknown'
+        });
         connection.ready = true;
     }
     /**
@@ -144,15 +270,20 @@ class LocalEngineClient {
      */
     handleProgressMessage(connection, message) {
         const { requestId, message: progressMsg, progress } = message.data;
-        console.log(`[IPC Client] Progress for ${requestId}: ${progressMsg} (${progress || 'N/A'}%)`);
+        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;
-        const prefix = requestId ? `[${requestId.slice(0, 8)}]` : '[IPC Child]';
-        console.log(`${prefix} [${level.toUpperCase()}] ${logMsg}`);
+        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
@@ -164,9 +295,16 @@ class LocalEngineClient {
             (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 {
-            console.warn(`[IPC Client] Received success for unknown request: ${requestId}`);
+            this.logManager.warn(LogManager_1.LogSource.System, LogManager_1.LogCategory.AppRunner, 'Received success for unknown request', {
+                id: requestId || 'unknown',
+                messageType: 'success'
+            });
         }
     }
     /**
@@ -180,16 +318,196 @@ class LocalEngineClient {
             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 {
-            console.warn(`[IPC Client] Received error for unknown request: ${requestId} - ${errorMsg}`);
+            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) {
-        console.error('[IPC Client] Connection error:', 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);
@@ -198,10 +516,58 @@ class LocalEngineClient {
         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);
@@ -238,6 +604,50 @@ class LocalEngineClient {
             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
      */
@@ -246,6 +656,13 @@ class LocalEngineClient {
             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
@@ -329,6 +746,102 @@ class LocalEngineClient {
         };
         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
      */
@@ -337,6 +850,8 @@ class LocalEngineClient {
         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'),
@@ -351,7 +866,11 @@ class LocalEngineClient {
             }
         }
         catch (error) {
-            console.warn(`[IPC Client] Error during connection shutdown: ${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);