@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/core/Codebolt.d.ts

@@ -0,0 +1,342 @@
+/// <reference types="node" />
+import WebSocket from 'ws';
+import { type NotificationFunctions } from '../notificationfunctions';
+import type { UserMessage } from '../types/libFunctionTypes';
+/**
+ * @class Codebolt
+ * @description This class provides a unified interface to interact with various modules.
+ */
+declare class Codebolt {
+    websocket: WebSocket | null;
+    private isReady;
+    private readyPromise;
+    private readyHandlers;
+    /**
+     * @constructor
+     * @description Initializes the websocket connection.
+     */
+    constructor();
+    /**
+     * @method initializeConnection
+     * @description Initializes the WebSocket connection asynchronously.
+     * @private
+     */
+    private initializeConnection;
+    /**
+     * @method waitForReady
+     * @description Waits for the Codebolt instance to be fully initialized.
+     * @returns {Promise<void>} A promise that resolves when the instance is ready.
+     */
+    waitForReady(): Promise<void>;
+    /**
+     * @method isReady
+     * @description Checks if the Codebolt instance is ready for use.
+     * @returns {boolean} True if the instance is ready, false otherwise.
+     */
+    get ready(): boolean;
+    fs: {
+        createFile: (fileName: string, source: string, filePath: string) => Promise<import("../types/socketMessageTypes").CreateFileResponse>;
+        createFolder: (folderName: string, folderPath: string) => Promise<import("../types/socketMessageTypes").CreateFolderResponse>;
+        readFile: (filePath: string) => Promise<import("../types/socketMessageTypes").ReadFileResponse>;
+        updateFile: (filename: string, filePath: string, newContent: string) => Promise<import("../types/socketMessageTypes").UpdateFileResponse>;
+        deleteFile: (filename: string, filePath: string) => Promise<import("../types/socketMessageTypes").DeleteFileResponse>;
+        deleteFolder: (foldername: string, folderpath: string) => Promise<import("../types/socketMessageTypes").DeleteFolderResponse>;
+        listFile: (folderPath: string, isRecursive?: boolean) => Promise<any>;
+        listCodeDefinitionNames: (path: string) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+        searchFiles: (path: string, regex: string, filePattern: string) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+        writeToFile: (relPath: string, newContent: string) => Promise<any>;
+        grepSearch: (path: string, query: string, includePattern?: string | undefined, excludePattern?: string | undefined, caseSensitive?: boolean) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+        fileSearch: (query: string) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+        editFileWithDiff: (targetFile: string, codeEdit: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<{
+            success: boolean;
+            result: any;
+        }>;
+    };
+    git: {
+        init: (path: string) => Promise<import("../types/socketMessageTypes").GitInitResponse>;
+        pull: () => Promise<import("../types/socketMessageTypes").GitPullResponse>;
+        push: () => Promise<import("../types/socketMessageTypes").GitPushResponse>;
+        status: () => Promise<import("../types/socketMessageTypes").GitStatusResponse>;
+        addAll: () => Promise<import("../types/socketMessageTypes").AddResponse>;
+        commit: (message: string) => Promise<import("../types/socketMessageTypes").GitCommitResponse>;
+        checkout: (branch: string) => Promise<import("../types/socketMessageTypes").GitCheckoutResponse>;
+        branch: (branch: string) => Promise<import("../types/socketMessageTypes").GitBranchResponse>;
+        logs: (path: string) => Promise<import("../types/socketMessageTypes").GitLogsResponse>;
+        diff: (commitHash: string) => Promise<import("../types/socketMessageTypes").GitDiffResponse>;
+    };
+    llm: {
+        inference: (params: {
+            messages: import("../types/libFunctionTypes").Message[];
+            tools?: any[] | undefined;
+            tool_choice?: string | undefined;
+            full?: boolean | undefined;
+            llmrole?: string | undefined;
+            max_tokens?: number | undefined;
+            temperature?: number | undefined;
+            stream?: boolean | undefined;
+        }, llmrole?: string | undefined) => Promise<{
+            /**
+             * @constructor
+             * @description Initializes the websocket connection.
+             */
+            completion: any;
+        }>;
+        legacyInference: (message: string, llmrole: string) => Promise<import("../types/socketMessageTypes").LLMResponse>;
+    };
+    browser: {
+        newPage: () => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        getUrl: () => Promise<import("../types/socketMessageTypes").UrlResponse>;
+        goToPage: (url: string) => Promise<import("../types/socketMessageTypes").GoToPageResponse>;
+        screenshot: () => Promise<import("../types/socketMessageTypes").BrowserScreenshotResponse>;
+        getHTML: () => Promise<import("../types/socketMessageTypes").HtmlReceived>;
+        getMarkdown: () => Promise<import("../types/socketMessageTypes").GetMarkdownResponse>;
+        getPDF: () => void;
+        pdfToText: () => void;
+        getContent: () => Promise<import("../types/socketMessageTypes").GetContentResponse>;
+        getSnapShot: () => Promise<import("../types/socketMessageTypes").BrowserSnapshotResponse>;
+        getBrowserInfo: () => Promise<import("../types/socketMessageTypes").BrowserInfoResponse>;
+        extractText: () => Promise<import("../types/socketMessageTypes").ExtractTextResponse>;
+        close: () => void;
+        scroll: (direction: string, pixels: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        type: (elementid: string, text: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        click: (elementid: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        enter: () => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+        search: (elementid: string, query: string) => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
+    };
+    chat: {
+        getChatHistory: () => Promise<import("../types/socketMessageTypes").ChatMessage[]>;
+        setRequestHandler: (handler: (request: any, response: (data: any) => void) => void | Promise<void>) => void;
+        sendMessage: (message: string, payload: any) => void;
+        waitforReply: (message: string) => Promise<import("../types/socketMessageTypes").UserMessage>;
+        processStarted: (onStopClicked?: ((message: any) => void) | undefined) => {
+            stopProcess: () => void;
+            cleanup: () => void;
+        } | {
+            stopProcess: () => void;
+            cleanup?: undefined;
+        };
+        stopProcess: () => void;
+        processFinished: () => void;
+        sendConfirmationRequest: (confirmationMessage: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
+        askQuestion: (question: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
+        sendNotificationEvent: (notificationMessage: string, type: "browser" | "terminal" | "git" | "debug" | "planner" | "editor" | "preview") => void;
+    };
+    terminal: {
+        eventEmitter: {
+            cleanup?: (() => void) | undefined;
+            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+            addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            once<K_3>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            removeListener<K_4>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            off<K_5>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            removeAllListeners(eventName?: string | symbol | undefined): any;
+            setMaxListeners(n: number): any;
+            getMaxListeners(): number;
+            listeners<K_6>(eventName: string | symbol): Function[];
+            rawListeners<K_7>(eventName: string | symbol): Function[];
+            emit<K_8>(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<K_9>(eventName: string | symbol, listener?: Function | undefined): number;
+            prependListener<K_10>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            eventNames(): (string | symbol)[];
+        };
+        executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
+        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("../types/socketMessageTypes").CommandError>;
+        sendManualInterrupt(): Promise<import("../types/socketMessageTypes").TerminalInterruptResponse>;
+        executeCommandWithStream(command: string, executeInMain?: boolean): {
+            cleanup?: (() => void) | undefined;
+            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+            addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            once<K_3>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            removeListener<K_4>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            off<K_5>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            removeAllListeners(eventName?: string | symbol | undefined): any;
+            setMaxListeners(n: number): any;
+            getMaxListeners(): number;
+            listeners<K_6>(eventName: string | symbol): Function[];
+            rawListeners<K_7>(eventName: string | symbol): Function[];
+            emit<K_8>(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<K_9>(eventName: string | symbol, listener?: Function | undefined): number;
+            prependListener<K_10>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+            eventNames(): (string | symbol)[];
+        };
+    };
+    codeutils: {
+        getJsTree: (filePath?: string | undefined) => Promise<import("../types/InternalTypes").JSTreeResponse>;
+        getAllFilesAsMarkDown: () => Promise<string>;
+        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<import("../types/socketMessageTypes").MatchProblemResponse>;
+        getMatcherList: () => Promise<import("../types/socketMessageTypes").GetMatcherListTreeResponse>;
+        matchDetail: (matcher: string) => Promise<import("../types/socketMessageTypes").getMatchDetail>;
+    };
+    crawler: {
+        start: () => void;
+        screenshot: () => void;
+        goToPage: (url: string) => void;
+        scroll: (direction: string) => void;
+        click: (id: string) => Promise<any>;
+    };
+    search: {
+        init: (engine?: string) => void;
+        search: (query: string) => Promise<string>;
+        get_first_link: (query: string) => Promise<string>;
+    };
+    knowledge: {};
+    rag: {
+        init: () => void;
+        add_file: (filename: string, file_path: string) => void;
+        retrieve_related_knowledge: (query: string, filename: string) => void;
+    };
+    codeparsers: {
+        getClassesInFile: (file: string) => Promise<{
+            error: string;
+        } | {
+            name: any;
+            location: string;
+        }[]>;
+        getFunctionsinClass: (file: string, className: string) => Promise<{
+            error: string;
+        } | {
+            name: string;
+            class: string;
+            location: string;
+        }[]>;
+        getAstTreeInFile: (file: string, className?: string | undefined) => Promise<import("..").ASTNode | {
+            error: string;
+        }>;
+    };
+    outputparsers: {
+        parseJSON: (jsonString: string) => {
+            success: boolean;
+            parsed?: any;
+            error?: Error | undefined;
+        };
+        parseXML: (xmlString: string) => {
+            success: boolean;
+            parsed?: any;
+        };
+        parseCSV: (csvString: string) => {
+            success: boolean;
+            parsed?: any[] | undefined;
+            error?: Error | undefined;
+        };
+        parseText: (text: string) => {
+            success: boolean;
+            parsed: string[];
+        };
+        parseErrors: (output: any) => string[];
+        parseWarnings: (output: any) => string[];
+    };
+    project: {
+        getProjectSettings: () => Promise<import("../types/socketMessageTypes").GetProjectSettingsResponse>;
+        getProjectPath: () => Promise<import("../types/socketMessageTypes").GetProjectPathResponse>;
+        getRepoMap: (message: any) => Promise<import("../types/socketMessageTypes").GetProjectPathResponse>;
+        runProject: () => void;
+        getEditorFileStatus: () => Promise<any>;
+    };
+    dbmemory: {
+        addKnowledge: (key: string, value: any) => Promise<import("../types/socketMessageTypes").MemorySetResponse>;
+        getKnowledge: (key: string) => Promise<import("../types/socketMessageTypes").MemoryGetResponse>;
+    };
+    cbstate: {
+        getApplicationState: () => Promise<import("../types/commonTypes").ApplicationState>;
+        addToAgentState: (key: string, value: string) => Promise<import("../types/socketMessageTypes").AddToAgentStateResponse>;
+        getAgentState: () => Promise<import("../types/socketMessageTypes").GetAgentStateResponse>;
+        getProjectState: () => Promise<import("../types/socketMessageTypes").GetProjectStateResponse>;
+        updateProjectState: (key: string, value: any) => Promise<import("../types/socketMessageTypes").UpdateProjectStateResponse>;
+    };
+    taskplaner: {
+        addTask: (params: import("../types/libFunctionTypes").TaskCreateOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        addSimpleTask: (task: string, agentId?: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        getTasks: (filters?: import("../types/libFunctionTypes").TaskFilterOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        getTasksByAgent: (agentId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        getTasksByCategory: (category: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        getAllAgents: () => Promise<import("../types/commonTypes").TaskResponse>;
+        updateTask: (params: import("../types/libFunctionTypes").TaskUpdateOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        updateSimpleTask: (taskId: string, task: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        deleteTask: (taskId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        addSubTask: (params: import("../types/libFunctionTypes").AddSubTaskOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        updateSubTask: (params: import("../types/libFunctionTypes").UpdateSubTaskOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        deleteSubTask: (taskId: string, subtaskId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        createTasksFromMarkdown: (params: import("../types/libFunctionTypes").TaskMarkdownImportOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        exportTasksToMarkdown: (params?: import("../types/libFunctionTypes").TaskMarkdownExportOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        toggleTaskCompletion: (taskId: string, completed: boolean) => Promise<import("../types/commonTypes").TaskResponse>;
+        toggleSubTaskCompletion: (taskId: string, subtaskId: string, completed: boolean) => Promise<import("../types/commonTypes").TaskResponse>;
+        moveTaskToAgent: (taskId: string, newAgentId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        setTaskPriority: (taskId: string, priority: "low" | "medium" | "high") => Promise<import("../types/commonTypes").TaskResponse>;
+        addTaskTags: (taskId: string, tags: string[]) => Promise<import("../types/commonTypes").TaskResponse>;
+        createQuickTask: (title: string, agentId?: string, category?: string | undefined) => Promise<import("../types/commonTypes").TaskResponse>;
+    };
+    vectordb: {
+        getVector: (key: string) => Promise<import("../types/socketMessageTypes").GetVectorResponse>;
+        addVectorItem: (item: any) => Promise<import("../types/socketMessageTypes").AddVectorItemResponse>;
+        queryVectorItem: (key: string) => Promise<import("../types/socketMessageTypes").QueryVectorItemResponse>;
+        queryVectorItems: (items: [], dbPath: string) => Promise<import("../types/socketMessageTypes").QueryVectorItemResponse>;
+    };
+    debug: {
+        debug: (log: string, type: import("../modules/debug").logType) => Promise<import("../types/socketMessageTypes").DebugAddLogResponse>;
+        openDebugBrowser: (url: string, port: number) => Promise<import("../types/socketMessageTypes").OpenDebugBrowserResponse>;
+    };
+    tokenizer: {
+        addToken: (key: string) => Promise<import("../types/socketMessageTypes").AddTokenResponse>;
+        getToken: (key: string) => Promise<import("../types/socketMessageTypes").GetTokenResponse>;
+    };
+    chatSummary: {
+        summarizeAll: () => Promise<import("../types/socketMessageTypes").GetSummarizeAllResponse>;
+        summarize: (messages: {
+            role: string;
+            content: string;
+        }[], depth: number) => Promise<import("../types/socketMessageTypes").GetSummarizeResponse>;
+    };
+    mcp: {
+        getEnabledMCPServers: () => Promise<import("../types/socketMessageTypes").GetEnabledToolBoxesResponse>;
+        getLocalMCPServers: () => Promise<import("../types/socketMessageTypes").GetLocalToolBoxesResponse>;
+        getMentionedMCPServers: (userMessage: import("../utils").UserMessage) => Promise<import("../types/socketMessageTypes").GetAvailableToolBoxesResponse>;
+        searchAvailableMCPServers: (query: string) => Promise<import("../types/socketMessageTypes").SearchAvailableToolBoxesResponse>;
+        listMcpFromServers: (toolBoxes: string[]) => Promise<import("../types/socketMessageTypes").ListToolsFromToolBoxesResponse>;
+        configureMCPServer: (name: string, config: any) => Promise<import("../types/socketMessageTypes").ConfigureToolBoxResponse>;
+        getTools: (tools: {
+            toolbox: string;
+            toolName: string;
+        }[]) => Promise<import("../types/socketMessageTypes").GetToolsResponse>;
+        executeTool: (toolbox: string, toolName: string, params: any) => Promise<import("../types/socketMessageTypes").ExecuteToolResponse>;
+    };
+    agent: {
+        findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: import("../modules/agent").AgentLocation | undefined, getFrom: import("../modules/agent").FilterUsing.USE_VECTOR_DB) => Promise<import("../types/socketMessageTypes").FindAgentByTaskResponse>;
+        startAgent: (agentId: string, task: string) => Promise<import("../types/socketMessageTypes").TaskCompletionResponse>;
+        getAgentsList: (type?: import("../modules/agent").Agents) => Promise<import("../types/socketMessageTypes").ListAgentsResponse>;
+        getAgentsDetail: (agentList?: never[]) => Promise<import("../types/socketMessageTypes").AgentsDetailResponse>;
+    };
+    utils: {
+        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<import("../types/socketMessageTypes").FsEditFileAndApplyDiffResponse>;
+    };
+    notify: NotificationFunctions;
+    /**
+     * Sets up a handler function to be executed when the WebSocket connection is established.
+     * If the connection is already established, the handler will be executed immediately.
+     * @param {Function} handler - The handler function to call when the connection is ready.
+     * @returns {void}
+     */
+    onReady(handler: () => void | Promise<void>): void;
+    /**
+     * Sets up a listener for incoming messages with a direct handler function.
+     * @param {Function} handler - The handler function to call when a message is received.
+     * @returns {void}
+     */
+    onMessage(handler: (userMessage: UserMessage) => void | Promise<void> | any | Promise<any>): void;
+}
+export default Codebolt;

package/dist/core/Codebolt.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("./websocket"));
+const fs_1 = __importDefault(require("../modules/fs"));
+const llm_1 = __importDefault(require("../modules/llm"));
+const terminal_1 = __importDefault(require("../modules/terminal"));
+const browser_1 = __importDefault(require("../modules/browser"));
+const chat_1 = __importDefault(require("../modules/chat"));
+const codeutils_1 = __importDefault(require("../modules/codeutils"));
+const crawler_1 = __importDefault(require("../modules/crawler"));
+const search_1 = __importDefault(require("../modules/search"));
+const knowledge_1 = __importDefault(require("../modules/knowledge"));
+const rag_1 = __importDefault(require("../modules/rag"));
+const codeparsers_1 = __importDefault(require("../modules/codeparsers"));
+const outputparsers_1 = __importDefault(require("../modules/outputparsers"));
+const project_1 = __importDefault(require("../modules/project"));
+const git_1 = __importDefault(require("../modules/git"));
+const dbmemory_1 = __importDefault(require("../modules/dbmemory"));
+const state_1 = __importDefault(require("../modules/state"));
+const task_1 = __importDefault(require("../modules/task"));
+const vectordb_1 = __importDefault(require("../modules/vectordb"));
+const debug_1 = __importDefault(require("../modules/debug"));
+const tokenizer_1 = __importDefault(require("../modules/tokenizer"));
+const history_1 = require("../modules/history");
+const mcp_1 = __importDefault(require("../modules/mcp"));
+const agent_1 = __importDefault(require("../modules/agent"));
+const utils_1 = __importDefault(require("../modules/utils"));
+const notificationfunctions_1 = require("../notificationfunctions");
+/**
+ * @class Codebolt
+ * @description This class provides a unified interface to interact with various modules.
+ */
+class Codebolt {
+    /**
+     * @constructor
+     * @description Initializes the websocket connection.
+     */
+    constructor() {
+        this.websocket = null;
+        this.isReady = false;
+        this.readyHandlers = [];
+        this.fs = fs_1.default;
+        this.git = git_1.default;
+        this.llm = llm_1.default;
+        this.browser = browser_1.default;
+        this.chat = chat_1.default;
+        this.terminal = terminal_1.default;
+        this.codeutils = codeutils_1.default;
+        this.crawler = crawler_1.default;
+        this.search = search_1.default;
+        this.knowledge = knowledge_1.default;
+        this.rag = rag_1.default;
+        this.codeparsers = codeparsers_1.default;
+        this.outputparsers = outputparsers_1.default;
+        this.project = project_1.default;
+        this.dbmemory = dbmemory_1.default;
+        this.cbstate = state_1.default;
+        this.taskplaner = task_1.default;
+        this.vectordb = vectordb_1.default;
+        this.debug = debug_1.default;
+        this.tokenizer = tokenizer_1.default;
+        this.chatSummary = history_1.chatSummary;
+        this.mcp = mcp_1.default;
+        this.agent = agent_1.default;
+        this.utils = utils_1.default;
+        this.notify = notificationfunctions_1.notificationFunctions;
+        console.log("Codebolt Agent initialized");
+        this.readyPromise = this.initializeConnection();
+    }
+    /**
+     * @method initializeConnection
+     * @description Initializes the WebSocket connection asynchronously.
+     * @private
+     */
+    async initializeConnection() {
+        try {
+            await websocket_1.default.initializeWebSocket();
+            this.websocket = websocket_1.default.getWebsocket;
+            this.isReady = true;
+            console.log("Codebolt WebSocket connection established");
+            // Execute all registered ready handlers
+            for (const handler of this.readyHandlers) {
+                try {
+                    await handler();
+                }
+                catch (error) {
+                    console.error('Error executing ready handler:', error);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to initialize WebSocket connection:', error);
+            throw error;
+        }
+    }
+    /**
+     * @method waitForReady
+     * @description Waits for the Codebolt instance to be fully initialized.
+     * @returns {Promise<void>} A promise that resolves when the instance is ready.
+     */
+    async waitForReady() {
+        return this.readyPromise;
+    }
+    /**
+     * @method isReady
+     * @description Checks if the Codebolt instance is ready for use.
+     * @returns {boolean} True if the instance is ready, false otherwise.
+     */
+    get ready() {
+        return this.isReady;
+    }
+    /**
+     * Sets up a handler function to be executed when the WebSocket connection is established.
+     * If the connection is already established, the handler will be executed immediately.
+     * @param {Function} handler - The handler function to call when the connection is ready.
+     * @returns {void}
+     */
+    onReady(handler) {
+        if (this.isReady) {
+            // If already ready, execute the handler immediately
+            try {
+                const result = handler();
+                if (result instanceof Promise) {
+                    result.catch(error => {
+                        console.error('Error in ready handler:', error);
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Error in ready handler:', error);
+            }
+        }
+        else {
+            // If not ready yet, add to the list of handlers to execute when ready
+            this.readyHandlers.push(handler);
+        }
+    }
+    /**
+     * Sets up a listener for incoming messages with a direct handler function.
+     * @param {Function} handler - The handler function to call when a message is received.
+     * @returns {void}
+     */
+    onMessage(handler) {
+        // Wait for the WebSocket to be ready before setting up the handler
+        this.waitForReady().then(() => {
+            const handleUserMessage = async (response) => {
+                var _a, _b;
+                console.log("Message received By Agent Library Starting Custom Agent Handler Logic");
+                if (response.type === "messageResponse") {
+                    try {
+                        // Extract user-facing message from internal socket message
+                        const userMessage = {
+                            type: response.type,
+                            userMessage: response.message.userMessage,
+                            currentFile: response.message.currentFile,
+                            mentionedFiles: response.message.mentionedFiles || [],
+                            mentionedFullPaths: response.message.mentionedFullPaths || [],
+                            mentionedFolders: response.message.mentionedFolders || [],
+                            uploadedImages: response.message.uploadedImages || [],
+                            mentionedMCPs: response.message.mentionedMCPs || [],
+                            selectedAgent: {
+                                id: ((_a = response.message.selectedAgent) === null || _a === void 0 ? void 0 : _a.id) || '',
+                                name: ((_b = response.message.selectedAgent) === null || _b === void 0 ? void 0 : _b.name) || ''
+                            },
+                            messageId: response.message.messageId,
+                            threadId: response.message.threadId,
+                            selection: response.message.selection,
+                            remixPrompt: response.message.remixPrompt,
+                            mentionedAgents: response.message.mentionedAgents
+                        };
+                        const result = await handler(userMessage);
+                        // Send processStoped with optional message
+                        const message = {
+                            "type": "processStoped"
+                        };
+                        // If handler returned data, include it as message
+                        if (result !== undefined && result !== null) {
+                            message.message = result;
+                        }
+                        websocket_1.default.messageManager.send(message);
+                    }
+                    catch (error) {
+                        console.error('Error in user message handler:', error);
+                        // Send processStoped even if there's an error
+                        websocket_1.default.messageManager.send({
+                            "type": "processStoped",
+                            "error": error instanceof Error ? error.message : "Unknown error occurred"
+                        });
+                    }
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleUserMessage);
+        }).catch(error => {
+            console.error('Failed to set up message handler:', error);
+        });
+    }
+}
+exports.default = Codebolt;

package/dist/core/websocket.js

@@ -65,7 +65,8 @@ class cbws {
         const parentAgentInstanceIdParam = process.env.parentAgentInstanceId ? `&parentAgentInstanceId=${process.env.parentAgentInstanceId}` : '';
         const agentTask = process.env.agentTask ? `&agentTask=${process.env.agentTask}` : '';
         const socketPort = process.env.SOCKET_PORT || '12345';
-        const wsUrl = `ws://localhost:${socketPort}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`;
+        const serverUrl = process.env.CODEBOLT_SERVER_URL || 'localhost';
+        const wsUrl = `ws://${serverUrl}:${socketPort}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`;
         console.log('[WebSocket] Connecting to:', wsUrl);
         this.websocket = new ws_1.default(wsUrl);
         return new Promise((resolve, reject) => {