@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/core/Codebolt.js

@@ -29,9 +29,41 @@ const memory_1 = __importDefault(require("../modules/memory"));
 const agent_1 = __importDefault(require("../modules/agent"));
 const utils_1 = __importDefault(require("../modules/utils"));
 const actionPlan_1 = __importDefault(require("../modules/actionPlan"));
+const mail_1 = __importDefault(require("../modules/mail"));
+const groupFeedback_1 = __importDefault(require("../modules/groupFeedback"));
+const agentDeliberation_1 = __importDefault(require("../modules/agentDeliberation"));
+const autoTesting_1 = __importDefault(require("../modules/autoTesting"));
 const notificationfunctions_1 = require("../notificationfunctions");
 const user_message_manager_1 = require("../modules/user-message-manager");
 const user_message_utilities_1 = require("../modules/user-message-utilities");
+const thread_1 = __importDefault(require("../modules/thread"));
+const todo_1 = __importDefault(require("../modules/todo"));
+const sideExecution_1 = __importDefault(require("../modules/sideExecution"));
+const capability_1 = __importDefault(require("../modules/capability"));
+const job_1 = __importDefault(require("../modules/job"));
+const actionBlock_1 = __importDefault(require("../modules/actionBlock"));
+const requirementPlan_1 = __importDefault(require("../modules/requirementPlan"));
+const swarm_1 = __importDefault(require("../modules/swarm"));
+const calendar_1 = __importDefault(require("../modules/calendar"));
+const episodicMemory_1 = __importDefault(require("../modules/episodicMemory"));
+const roadmap_1 = __importDefault(require("../modules/roadmap"));
+const codemap_1 = __importDefault(require("../modules/codemap"));
+const projectStructure_1 = __importDefault(require("../modules/projectStructure"));
+const codebaseSearch_1 = __importDefault(require("../modules/codebaseSearch"));
+const fileUpdateIntent_1 = __importDefault(require("../modules/fileUpdateIntent"));
+const projectStructureUpdateRequest_1 = __importDefault(require("../modules/projectStructureUpdateRequest"));
+const reviewMergeRequest_1 = __importDefault(require("../modules/reviewMergeRequest"));
+const kvStore_1 = __importDefault(require("../modules/kvStore"));
+const persistentMemory_1 = __importDefault(require("../modules/persistentMemory"));
+const eventLog_1 = __importDefault(require("../modules/eventLog"));
+const knowledgeGraph_1 = __importDefault(require("../modules/knowledgeGraph"));
+const hook_1 = __importDefault(require("../modules/hook"));
+const memoryIngestion_1 = __importDefault(require("../modules/memoryIngestion"));
+const contextAssembly_1 = __importDefault(require("../modules/contextAssembly"));
+const contextRuleEngine_1 = __importDefault(require("../modules/contextRuleEngine"));
+const agentPortfolio_1 = __importDefault(require("../modules/agentPortfolio"));
+const orchestrator_1 = __importDefault(require("../modules/orchestrator"));
+const backgroundChildThreads_1 = __importDefault(require("../modules/backgroundChildThreads"));
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
@@ -50,6 +82,9 @@ class Codebolt {
         this.fs = fs_1.default;
         this.git = git_1.default;
         this.llm = llm_1.default;
+        this.mail = mail_1.default;
+        this.groupFeedback = groupFeedback_1.default;
+        this.agentDeliberation = agentDeliberation_1.default;
         this.browser = browser_1.default;
         this.chat = chat_1.default;
         this.terminal = terminal_1.default;
@@ -63,6 +98,7 @@ class Codebolt {
         this.dbmemory = dbmemory_1.default;
         this.cbstate = state_1.default;
         this.task = task_1.default;
+        this.thread = thread_1.default;
         this.vectordb = vectordb_1.default;
         this.debug = debug_1.default;
         this.tokenizer = tokenizer_1.default;
@@ -73,6 +109,34 @@ class Codebolt {
         this.notify = notificationfunctions_1.notificationFunctions;
         this.memory = memory_1.default;
         this.actionPlan = actionPlan_1.default;
+        this.todo = todo_1.default;
+        this.sideExecution = sideExecution_1.default;
+        this.capability = capability_1.default;
+        this.job = job_1.default;
+        this.autoTesting = autoTesting_1.default;
+        this.actionBlock = actionBlock_1.default;
+        this.requirementPlan = requirementPlan_1.default;
+        this.swarm = swarm_1.default;
+        this.calendar = calendar_1.default;
+        this.episodicMemory = episodicMemory_1.default;
+        this.roadmap = roadmap_1.default;
+        this.codemap = codemap_1.default;
+        this.projectStructure = projectStructure_1.default;
+        this.codebaseSearch = codebaseSearch_1.default;
+        this.fileUpdateIntent = fileUpdateIntent_1.default;
+        this.projectStructureUpdateRequest = projectStructureUpdateRequest_1.default;
+        this.reviewMergeRequest = reviewMergeRequest_1.default;
+        this.kvStore = kvStore_1.default;
+        this.persistentMemory = persistentMemory_1.default;
+        this.eventLog = eventLog_1.default;
+        this.knowledgeGraph = knowledgeGraph_1.default;
+        this.hook = hook_1.default;
+        this.memoryIngestion = memoryIngestion_1.default;
+        this.contextAssembly = contextAssembly_1.default;
+        this.contextRuleEngine = contextRuleEngine_1.default;
+        this.agentPortfolio = agentPortfolio_1.default;
+        this.orchestrator = orchestrator_1.default;
+        this.backgroundChildThreads = backgroundChildThreads_1.default;
         /**
          * User message utilities for accessing current user message and context
          */
@@ -283,7 +347,8 @@ class Codebolt {
                             openedFiles: response.message.activeFile
                         };
                         // Call the custom handler
-                        const result = await handler(userMessage);
+                        let additionalVariable = process.env;
+                        const result = await handler(userMessage, additionalVariable);
                         // Send processStoped with optional message
                         const message = {
                             "type": "processStoped"
@@ -309,6 +374,59 @@ class Codebolt {
             console.error('Failed to set up message handler:', error);
         });
     }
+    /**
+     * Sets up a listener for ActionBlock invocation events.
+     * This is called when a Side Execution ActionBlock is invoked by a parent agent.
+     * @param {Function} handler - The handler function to call when ActionBlock is invoked.
+     *   - params: The parameters passed to the ActionBlock
+     *   - threadContext: The thread context from the parent agent
+     *   - metadata: Additional metadata (sideExecutionId, threadId, parentAgentId, etc.)
+     * @returns {void}
+     */
+    onActionBlockInvocation(handler) {
+        this.waitForReady().then(() => {
+            const handleActionBlockInvocation = async (response) => {
+                if (response.type === "actionBlockInvocation") {
+                    console.log("ActionBlock invocation received", response);
+                    try {
+                        // Merge params into threadContext so action blocks can access them
+                        // params contains the custom parameters passed via actionBlock.start()
+                        const threadContextWithParams = {
+                            ...(response.threadContext || {}),
+                            params: response.params || {}
+                        };
+                        const result = await handler(threadContextWithParams, {
+                            sideExecutionId: response.sideExecutionId,
+                            threadId: response.threadId,
+                            parentAgentId: response.parentAgentId,
+                            parentAgentInstanceId: response.parentAgentInstanceId,
+                            timestamp: response.timestamp
+                        });
+                        // Send completion response
+                        const message = {
+                            "type": "actionBlockComplete",
+                            "sideExecutionId": response.sideExecutionId
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.result = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in ActionBlock invocation handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "actionBlockComplete",
+                            "sideExecutionId": response.sideExecutionId,
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleActionBlockInvocation);
+        }).catch(error => {
+            console.error('Failed to set up ActionBlockInvocation handler:', error);
+        });
+    }
     onRawMessage(handler) {
         this.waitForReady().then(() => {
             const handleRawUserMessage = async (response) => {
@@ -461,6 +579,330 @@ class Codebolt {
             console.error('Failed to set up get diff files handler:', error);
         });
     }
+    /**
+     * Sets up a listener for read file events.
+     * @param {Function} handler - The handler function to call when read file is requested.
+     * @returns {void}
+     */
+    onReadFile(handler) {
+        this.waitForReady().then(() => {
+            const handleReadFile = async (response) => {
+                console.log("Read file event received");
+                if (response.type === "providerReadFile") {
+                    try {
+                        const result = await handler(response.path);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerReadFileResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in read file handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerReadFileResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleReadFile);
+        }).catch(error => {
+            console.error('Failed to set up read file handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for write file events.
+     * @param {Function} handler - The handler function to call when write file is requested.
+     * @returns {void}
+     */
+    onWriteFile(handler) {
+        this.waitForReady().then(() => {
+            const handleWriteFile = async (response) => {
+                console.log("Write file event received");
+                if (response.type === "providerWriteFile") {
+                    try {
+                        const result = await handler(response.path, response.content);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerWriteFileResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in write file handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerWriteFileResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleWriteFile);
+        }).catch(error => {
+            console.error('Failed to set up write file handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for delete file events.
+     * @param {Function} handler - The handler function to call when delete file is requested.
+     * @returns {void}
+     */
+    onDeleteFile(handler) {
+        this.waitForReady().then(() => {
+            const handleDeleteFile = async (response) => {
+                console.log("Delete file event received");
+                if (response.type === "providerDeleteFile") {
+                    try {
+                        const result = await handler(response.path);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerDeleteFileResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in delete file handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerDeleteFileResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleDeleteFile);
+        }).catch(error => {
+            console.error('Failed to set up delete file handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for delete folder events.
+     * @param {Function} handler - The handler function to call when delete folder is requested.
+     * @returns {void}
+     */
+    onDeleteFolder(handler) {
+        this.waitForReady().then(() => {
+            const handleDeleteFolder = async (response) => {
+                console.log("Delete folder event received");
+                if (response.type === "providerDeleteFolder") {
+                    try {
+                        const result = await handler(response.path);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerDeleteFolderResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in delete folder handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerDeleteFolderResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleDeleteFolder);
+        }).catch(error => {
+            console.error('Failed to set up delete folder handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for rename item events.
+     * @param {Function} handler - The handler function to call when rename item is requested.
+     * @returns {void}
+     */
+    onRenameItem(handler) {
+        this.waitForReady().then(() => {
+            const handleRenameItem = async (response) => {
+                console.log("Rename item event received");
+                if (response.type === "providerRenameItem") {
+                    try {
+                        const result = await handler(response.oldPath, response.newPath);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerRenameItemResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in rename item handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerRenameItemResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleRenameItem);
+        }).catch(error => {
+            console.error('Failed to set up rename item handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for create folder events.
+     * @param {Function} handler - The handler function to call when create folder is requested.
+     * @returns {void}
+     */
+    onCreateFolder(handler) {
+        this.waitForReady().then(() => {
+            const handleCreateFolder = async (response) => {
+                console.log("Create folder event received");
+                if (response.type === "providerCreateFolder") {
+                    try {
+                        const result = await handler(response.path);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerCreateFolderResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in create folder handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerCreateFolderResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleCreateFolder);
+        }).catch(error => {
+            console.error('Failed to set up create folder handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for copy file events.
+     * @param {Function} handler - The handler function to call when copy file is requested.
+     * @returns {void}
+     */
+    onCopyFile(handler) {
+        this.waitForReady().then(() => {
+            const handleCopyFile = async (response) => {
+                console.log("Copy file event received");
+                if (response.type === "providerCopyFile") {
+                    try {
+                        const result = await handler(response.sourcePath, response.destinationPath);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerCopyFileResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in copy file handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerCopyFileResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleCopyFile);
+        }).catch(error => {
+            console.error('Failed to set up copy file handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for copy folder events.
+     * @param {Function} handler - The handler function to call when copy folder is requested.
+     * @returns {void}
+     */
+    onCopyFolder(handler) {
+        this.waitForReady().then(() => {
+            const handleCopyFolder = async (response) => {
+                console.log("Copy folder event received");
+                if (response.type === "providerCopyFolder") {
+                    try {
+                        const result = await handler(response.sourcePath, response.destinationPath);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerCopyFolderResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in copy folder handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerCopyFolderResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleCopyFolder);
+        }).catch(error => {
+            console.error('Failed to set up copy folder handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for get full project events.
+     * @param {Function} handler - The handler function to call when get full project is requested.
+     * @returns {void}
+     */
+    onGetFullProject(handler) {
+        this.waitForReady().then(() => {
+            const handleGetFullProject = async (response) => {
+                console.log("Get full project event received");
+                if (response.type === "providerGetFullProject") {
+                    try {
+                        const result = await handler();
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerGetFullProjectResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in get full project handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerGetFullProjectResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleGetFullProject);
+        }).catch(error => {
+            console.error('Failed to set up get full project handler:', error);
+        });
+    }
     /**
      * Sets up a listener for close signal events.
      * @param {Function} handler - The handler function to call when close signal is received.
@@ -563,5 +1005,295 @@ class Codebolt {
             console.error('Failed to set up create pull request handler:', error);
         });
     }
+    /**
+     * Sets up a listener for merge as patch events.
+     * @param {Function} handler - The handler function to call when merge as patch is requested.
+     * @returns {void}
+     */
+    onMergeAsPatch(handler) {
+        this.waitForReady().then(() => {
+            const handleMergeAsPatch = async (response) => {
+                console.log("Merge as patch event received");
+                if (response.type === "providerMergeAsPatch") {
+                    try {
+                        const result = await handler();
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerMergeAsPatchResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in merge as patch handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerMergeAsPatchResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleMergeAsPatch);
+        }).catch(error => {
+            console.error('Failed to set up merge as patch handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for send PR events.
+     * @param {Function} handler - The handler function to call when send PR is requested.
+     * @returns {void}
+     */
+    onSendPR(handler) {
+        this.waitForReady().then(() => {
+            const handleSendPR = async (response) => {
+                console.log("Send PR event received");
+                if (response.type === "providerSendPR") {
+                    try {
+                        const result = await handler();
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerSendPRResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in send PR handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerSendPRResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleSendPR);
+        }).catch(error => {
+            console.error('Failed to set up send PR handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for get tree children events.
+     * @param {Function} handler - The handler function to call when tree children are requested.
+     * @returns {void}
+     */
+    onGetTreeChildren(handler) {
+        this.waitForReady().then(() => {
+            const handleGetTreeChildren = async (response) => {
+                console.log("Get tree children event received");
+                if (response.type === "providerGetTreeChildren") {
+                    try {
+                        const result = await handler(response.path);
+                        const message = {
+                            "type": "remoteProviderEvent",
+                            "action": "providerGetTreeChildrenResponse",
+                        };
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in get tree children handler:', error);
+                        websocket_1.default.messageManager.send({
+                            "type": "remoteProviderEvent",
+                            "action": "providerGetTreeChildrenResponse",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleGetTreeChildren);
+        }).catch(error => {
+            console.error('Failed to set up get tree children handler:', error);
+        });
+    }
+    // ===== HEARTBEAT METHODS =====
+    /**
+     * Sends a provider heartbeat to the main application.
+     * Should be called periodically by providers to indicate they are alive.
+     * @param {object} heartbeatData - The heartbeat data to send
+     * @param {string} heartbeatData.providerId - The provider ID
+     * @param {string} heartbeatData.status - The provider health status ('healthy', 'degraded', 'error')
+     * @param {string[]} heartbeatData.connectedEnvironments - Array of connected environment IDs
+     * @param {Record<string, any>} [heartbeatData.metadata] - Optional metadata
+     * @returns {void}
+     */
+    sendProviderHeartbeat(heartbeatData) {
+        if (!this.isReady) {
+            console.warn('Cannot send provider heartbeat - WebSocket not ready');
+            return;
+        }
+        const message = {
+            type: 'providerHeartbeat',
+            providerId: heartbeatData.providerId,
+            timestamp: new Date().toISOString(),
+            status: heartbeatData.status,
+            connectedEnvironments: heartbeatData.connectedEnvironments,
+            uptime: heartbeatData.uptime,
+            metadata: heartbeatData.metadata,
+        };
+        websocket_1.default.messageManager.send(message);
+    }
+    /**
+     * Sends an environment heartbeat request to the remote executor.
+     * @param {object} heartbeatData - The heartbeat data to send
+     * @param {string} heartbeatData.environmentId - The environment ID
+     * @param {string} heartbeatData.providerId - The provider ID
+     * @returns {void}
+     */
+    sendEnvironmentHeartbeat(heartbeatData) {
+        if (!this.isReady) {
+            console.warn('Cannot send environment heartbeat - WebSocket not ready');
+            return;
+        }
+        const message = {
+            type: 'environmentHeartbeat',
+            environmentId: heartbeatData.environmentId,
+            providerId: heartbeatData.providerId,
+            timestamp: new Date().toISOString(),
+        };
+        websocket_1.default.messageManager.send(message);
+    }
+    /**
+     * Sets up a listener for provider heartbeat requests from the main application.
+     * Providers should respond with their current health status.
+     * @param {Function} handler - The handler function to call when heartbeat is requested
+     * @returns {void}
+     */
+    onProviderHeartbeatRequest(handler) {
+        this.waitForReady().then(() => {
+            const handleProviderHeartbeatRequest = async (response) => {
+                if (response.type === "providerHeartbeatRequest") {
+                    try {
+                        const result = await handler({
+                            providerId: response.providerId,
+                            timestamp: response.timestamp,
+                        });
+                        // If handler returns heartbeat data, send it automatically
+                        if (result && typeof result === 'object' && 'status' in result) {
+                            this.sendProviderHeartbeat({
+                                providerId: response.providerId,
+                                status: result.status,
+                                connectedEnvironments: result.connectedEnvironments || [],
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.error('Error in provider heartbeat request handler:', error);
+                        // Send error heartbeat
+                        this.sendProviderHeartbeat({
+                            providerId: response.providerId,
+                            status: 'error',
+                            connectedEnvironments: [],
+                            metadata: {
+                                error: error instanceof Error ? error.message : 'Unknown error',
+                            },
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleProviderHeartbeatRequest);
+        }).catch(error => {
+            console.error('Failed to set up provider heartbeat request handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for environment heartbeat requests.
+     * Environment executors should respond with their current status.
+     * @param {Function} handler - The handler function to call when heartbeat is requested
+     * @returns {void}
+     */
+    onEnvironmentHeartbeatRequest(handler) {
+        this.waitForReady().then(() => {
+            const handleEnvironmentHeartbeatRequest = async (response) => {
+                if (response.type === "environmentHeartbeat") {
+                    try {
+                        const result = await handler({
+                            environmentId: response.environmentId,
+                            providerId: response.providerId,
+                            timestamp: response.timestamp,
+                        });
+                        // Send response if handler returns data
+                        if (result && typeof result === 'object' && 'status' in result) {
+                            const responseMessage = {
+                                type: 'environmentHeartbeatResponse',
+                                environmentId: response.environmentId,
+                                status: result.status,
+                                remoteExecutorStatus: result.remoteExecutorStatus,
+                                timestamp: new Date().toISOString(),
+                            };
+                            websocket_1.default.messageManager.send(responseMessage);
+                        }
+                    }
+                    catch (error) {
+                        console.error('Error in environment heartbeat request handler:', error);
+                        // Send error response
+                        websocket_1.default.messageManager.send({
+                            type: 'environmentHeartbeatResponse',
+                            environmentId: response.environmentId,
+                            status: 'unreachable',
+                            remoteExecutorStatus: 'error',
+                            timestamp: new Date().toISOString(),
+                            metadata: {
+                                error: error instanceof Error ? error.message : 'Unknown error',
+                            },
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleEnvironmentHeartbeatRequest);
+        }).catch(error => {
+            console.error('Failed to set up environment heartbeat request handler:', error);
+        });
+    }
+    /**
+     * Sets up a listener for environment restart requests from the main application.
+     * @param {Function} handler - The handler function to restart the environment/remote executor
+     * @returns {void}
+     */
+    onEnvironmentRestartRequest(handler) {
+        this.waitForReady().then(() => {
+            const handleEnvironmentRestartRequest = async (response) => {
+                if (response.type === "environmentRestartRequest") {
+                    try {
+                        const result = await handler({
+                            environmentId: response.environmentId,
+                            providerId: response.providerId,
+                        });
+                        const responseMessage = {
+                            type: 'environmentRestartResponse',
+                            environmentId: response.environmentId,
+                            success: true,
+                            timestamp: new Date().toISOString(),
+                        };
+                        if (result && typeof result === 'object') {
+                            responseMessage.success = result.success;
+                            responseMessage.message = result.message;
+                        }
+                        websocket_1.default.messageManager.send(responseMessage);
+                    }
+                    catch (error) {
+                        console.error('Error in environment restart request handler:', error);
+                        websocket_1.default.messageManager.send({
+                            type: 'environmentRestartResponse',
+                            environmentId: response.environmentId,
+                            success: false,
+                            message: error instanceof Error ? error.message : 'Unknown error during restart',
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleEnvironmentRestartRequest);
+        }).catch(error => {
+            console.error('Failed to set up environment restart request handler:', error);
+        });
+    }
 }
 exports.default = Codebolt;