@aws/lsp-codewhisperer 0.0.39 → 0.0.41

package/out/language-server/workspaceContext/workspaceContextServer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkspaceContextServer = void 0;
+const crypto = require("crypto");
 const util_1 = require("./util");
 const artifactManager_1 = require("./artifactManager");
 const workspaceFolderManager_1 = require("./workspaceFolderManager");
@@ -13,6 +14,7 @@ const AmazonQTokenServiceManager_1 = require("../../shared/amazonQServiceManager
 const Q_CONTEXT_CONFIGURATION_SECTION = 'aws.q.workspaceContext';
 const WorkspaceContextServer = () => features => {
     const { credentialsProvider, workspace, logging, lsp, runtime, sdkInitializator } = features;
+    let workspaceIdentifier = '';
     let workspaceFolders = [];
     let artifactManager;
     let dependencyDiscoverer;
@@ -22,12 +24,27 @@ const WorkspaceContextServer = () => features => {
     let abTestingEvaluated = false;
     let abTestingEnabled = false;
     let amazonQServiceManager;
+    let allowedExtension = ['AmazonQ-For-VSCode', 'Amazon Q For JetBrains'];
+    let isSupportedExtension = false;
     lsp.addInitializer((params) => {
-        workspaceFolders = params.workspaceFolders || [];
-        if (params.workspaceFolders) {
-            workspaceFolders = params.workspaceFolders;
+        let clientExtension = params.initializationOptions?.aws?.clientInfo?.extension.name || '';
+        if (!allowedExtension.includes(clientExtension)) {
+            logging.warn(`Server context is currently not supported in ${clientExtension}`);
+            return {
+                capabilities: {},
+            };
         }
         else {
+            isSupportedExtension = true;
+        }
+        workspaceIdentifier = params.initializationOptions?.aws?.contextConfiguration?.workspaceIdentifier || '';
+        if (!workspaceIdentifier) {
+            logging.warn(`No workspaceIdentifier set. Treating this workspace as a temporary session.`);
+            workspaceIdentifier = crypto.randomUUID();
+        }
+        const folders = workspace.getAllWorkspaceFolders();
+        workspaceFolders = folders || params.workspaceFolders || [];
+        if (!folders) {
             logging.warn(`No workspace folders set during initialization`);
         }
         return {
@@ -66,20 +83,18 @@ const WorkspaceContextServer = () => features => {
     });
     lsp.extensions.onGetConfigurationFromServer(async (params, token) => {
         if (params.section === Q_CONTEXT_CONFIGURATION_SECTION) {
-            const workspaceMap = workspaceFolderManager.getWorkspaces();
-            // Filter workspaces to only include those with websocket connected.
-            // To reduce the error of GenerateCompletions getting repoMap from server-side workspace context,
-            // with websocket connected, at least workspace/didChangeWorkspaceFolders websocket request has been sent.
-            // When the workspace is reopened and server-side was prepared, compared to filter with READY state of workspace,
-            // this filter would add delay to wait for websocket connection being established
-            const workspaceArray = Array.from(workspaceMap)
-                .filter(([_, workspaceState]) => workspaceState.webSocketClient?.isConnected())
-                .map(([workspaceRoot, workspaceState]) => ({
-                workspaceRoot,
-                workspaceId: workspaceState.workspaceId ?? '',
-            }));
+            // Only append workspaceId to GenerateCompletions when WebSocket client is connected
+            if (!workspaceFolderManager.getWorkspaceState().webSocketClient?.isConnected() ||
+                !workspaceFolderManager.getWorkspaceState().workspaceId) {
+                return {
+                    workspaces: [],
+                };
+            }
             return {
-                workspaces: workspaceArray,
+                workspaces: workspaceFolders.map(workspaceFolder => ({
+                    workspaceRoot: workspaceFolder.uri,
+                    workspaceId: workspaceFolderManager.getWorkspaceState().workspaceId,
+                })),
             };
         }
         return {
@@ -120,7 +135,7 @@ const WorkspaceContextServer = () => features => {
             logging.log(`${JSON.stringify(result)}`);
             abTestingEnabled =
                 result.featureEvaluations?.some(feature => feature.feature === 'ServiceSideWorkspaceContext' && feature.variation === 'TREATMENT') ?? false;
-            logging.log(`A/B testing enabled: ${abTestingEnabled}`);
+            logging.info(`A/B testing enabled: ${abTestingEnabled}`);
             abTestingEvaluated = true;
         }
         catch (error) {
@@ -133,275 +148,290 @@ const WorkspaceContextServer = () => features => {
         return (isOptedIn &&
             (0, util_1.isLoggedInUsingBearerToken)(credentialsProvider) &&
             abTestingEnabled &&
-            !workspaceFolderManager.getOptOutStatus());
+            !workspaceFolderManager.getOptOutStatus() &&
+            workspaceIdentifier);
     };
     lsp.onInitialized(async (params) => {
-        amazonQServiceManager = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance();
-        artifactManager = new artifactManager_1.ArtifactManager(workspace, logging, workspaceFolders);
-        dependencyDiscoverer = new dependencyDiscoverer_1.DependencyDiscoverer(workspace, logging, workspaceFolders, artifactManager);
-        workspaceFolderManager = workspaceFolderManager_1.WorkspaceFolderManager.createInstance(amazonQServiceManager, logging, artifactManager, dependencyDiscoverer, workspaceFolders, credentialsProvider);
-        await updateConfiguration();
-        lsp.workspace.onDidChangeWorkspaceFolders(async (params) => {
-            const addedFolders = params.event.added;
-            if (addedFolders.length > 0) {
-                workspaceFolders.push(...addedFolders);
+        try {
+            if (!isSupportedExtension) {
+                return {};
             }
-            const removedFolders = params.event.removed;
-            if (removedFolders.length > 0) {
-                for (const folder of removedFolders) {
-                    const index = workspaceFolders.findIndex(f => f.uri === folder.uri);
-                    if (index !== -1) {
-                        workspaceFolders.splice(index, 1);
-                    }
+            amazonQServiceManager = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance();
+            artifactManager = new artifactManager_1.ArtifactManager(workspace, logging, workspaceFolders);
+            dependencyDiscoverer = new dependencyDiscoverer_1.DependencyDiscoverer(workspace, logging, workspaceFolders, artifactManager);
+            workspaceFolderManager = workspaceFolderManager_1.WorkspaceFolderManager.createInstance(amazonQServiceManager, logging, artifactManager, dependencyDiscoverer, workspaceFolders, credentialsProvider, workspaceIdentifier);
+            await updateConfiguration();
+            lsp.workspace.onDidChangeWorkspaceFolders(async (params) => {
+                const addedFolders = params.event.added;
+                if (addedFolders.length > 0) {
+                    workspaceFolders.push(...addedFolders);
                 }
-            }
-            workspaceFolderManager.updateWorkspaceFolders(workspaceFolders);
-            if (!isUserEligibleForWorkspaceContext()) {
-                return;
-            }
-            if (addedFolders.length > 0) {
-                await workspaceFolderManager.processNewWorkspaceFolders(addedFolders);
-            }
-            if (removedFolders.length > 0) {
-                await workspaceFolderManager.processWorkspaceFoldersDeletion(removedFolders);
-            }
-        });
-        /**
-         * The below code checks the login state of the workspace and initializes the workspace
-         * folders. *isWorkflowInitialized* variable is used to keep track if the workflow has been initialized
-         * or not to prevent it from initializing again. However, there can be a case when user logs out, does some
-         * activity with removing or adding workspace folders, and logs back in. To handle this case- the new state
-         * of workspace folders is updated using *artifactManager.updateWorkspaceFolders(workspaceFolders)* before
-         * initializing again.
-         */
-        setInterval(async () => {
-            if (!isOptedIn) {
-                return;
-            }
-            const isLoggedIn = (0, util_1.isLoggedInUsingBearerToken)(credentialsProvider);
-            if (isLoggedIn && !isWorkflowInitialized) {
-                try {
-                    // getCodewhispererService only returns the cwspr client if the service manager was initialized i.e. profile was selected otherwise it throws an error
-                    // we will not evaluate a/b status until profile is selected and service manager is fully initialized
-                    amazonQServiceManager.getCodewhispererService();
+                const removedFolders = params.event.removed;
+                if (removedFolders.length > 0) {
+                    for (const folder of removedFolders) {
+                        const index = workspaceFolders.findIndex(f => f.uri === folder.uri);
+                        if (index !== -1) {
+                            workspaceFolders.splice(index, 1);
+                        }
+                    }
                 }
-                catch (e) {
+                workspaceFolderManager.updateWorkspaceFolders(workspaceFolders);
+                if (!isUserEligibleForWorkspaceContext()) {
                     return;
                 }
-                await evaluateABTesting();
-                isWorkflowInitialized = true;
-                if (!isUserEligibleForWorkspaceContext()) {
+                if (addedFolders.length > 0) {
+                    await workspaceFolderManager.processNewWorkspaceFolders(addedFolders);
+                }
+                if (removedFolders.length > 0) {
+                    await workspaceFolderManager.processWorkspaceFoldersDeletion(removedFolders);
+                }
+            });
+            /**
+             * The below code checks the login state of the workspace and initializes the workspace
+             * folders. *isWorkflowInitialized* variable is used to keep track if the workflow has been initialized
+             * or not to prevent it from initializing again. However, there can be a case when user logs out, does some
+             * activity with removing or adding workspace folders, and logs back in. To handle this case- the new state
+             * of workspace folders is updated using *artifactManager.updateWorkspaceFolders(workspaceFolders)* before
+             * initializing again.
+             */
+            setInterval(async () => {
+                if (!isOptedIn) {
                     return;
                 }
-                logging.log(`Workspace context workflow initialized`);
-                artifactManager.updateWorkspaceFolders(workspaceFolders);
-                workspaceFolderManager.processNewWorkspaceFolders(workspaceFolders).catch(error => {
-                    logging.error(`Error while processing new workspace folders: ${error}`);
-                });
-            }
-            else if (!isLoggedIn) {
-                if (isWorkflowInitialized) {
-                    // If user is not logged in but the workflow is marked as initialized, it means user was logged in and is now logged out
-                    // In this case, clear the resources and stop the monitoring
-                    await workspaceFolderManager.clearAllWorkspaceResources();
+                const isLoggedIn = (0, util_1.isLoggedInUsingBearerToken)(credentialsProvider);
+                if (isLoggedIn && !isWorkflowInitialized) {
+                    try {
+                        // getCodewhispererService only returns the cwspr client if the service manager was initialized i.e. profile was selected otherwise it throws an error
+                        // we will not evaluate a/b status until profile is selected and service manager is fully initialized
+                        amazonQServiceManager.getCodewhispererService();
+                    }
+                    catch (e) {
+                        return;
+                    }
+                    await evaluateABTesting();
+                    isWorkflowInitialized = true;
+                    if (!isUserEligibleForWorkspaceContext()) {
+                        return;
+                    }
+                    workspaceFolderManager.initializeWorkspaceStatusMonitor().catch(error => {
+                        logging.error(`Error while initializing workspace status monitoring: ${error}`);
+                    });
+                    logging.log(`Workspace context workflow initialized`);
+                    artifactManager.updateWorkspaceFolders(workspaceFolders);
+                    workspaceFolderManager.processNewWorkspaceFolders(workspaceFolders).catch(error => {
+                        logging.error(`Error while processing new workspace folders: ${error}`);
+                    });
                 }
-                isWorkflowInitialized = false;
-            }
-        }, 5000);
+                else if (!isLoggedIn) {
+                    if (isWorkflowInitialized) {
+                        // If user is not logged in but the workflow is marked as initialized, it means user was logged in and is now logged out
+                        // In this case, clear the resources and stop the monitoring
+                        await workspaceFolderManager.clearAllWorkspaceResources();
+                    }
+                    isWorkflowInitialized = false;
+                }
+            }, 5000);
+        }
+        catch (error) {
+            logging.error(`Failed to initialize workspace context server: ${error}`);
+        }
     });
     lsp.didChangeConfiguration(updateConfiguration);
     lsp.onDidSaveTextDocument(async (event) => {
-        if (!isUserEligibleForWorkspaceContext()) {
-            return;
-        }
-        const programmingLanguage = (0, languageDetection_1.getCodeWhispererLanguageIdFromPath)(event.textDocument.uri);
-        if (!programmingLanguage || !artifactManager_1.SUPPORTED_WORKSPACE_CONTEXT_LANGUAGES.includes(programmingLanguage)) {
-            return;
-        }
-        logging.log(`Received didSave event for ${event.textDocument.uri}`);
-        const result = workspaceFolderManager.getWorkspaceDetailsWithId(event.textDocument.uri, workspaceFolders);
-        if (!result) {
-            logging.log(`No workspace found for ${event.textDocument.uri} discarding the save event`);
-            return;
-        }
-        const { workspaceDetails, workspaceRoot } = result;
-        const fileMetadata = await artifactManager.processNewFile(workspaceRoot, event.textDocument.uri);
-        const s3Url = await workspaceFolderManager.uploadToS3(fileMetadata);
-        if (!s3Url) {
-            return;
-        }
-        const message = JSON.stringify({
-            method: 'textDocument/didSave',
-            params: {
-                textDocument: { uri: (0, util_1.getRelativePath)(fileMetadata.workspaceFolder, event.textDocument.uri) },
-                workspaceChangeMetadata: {
-                    workspaceId: workspaceDetails.workspaceId,
-                    s3Path: (0, util_1.cleanUrl)(s3Url),
-                    programmingLanguage: programmingLanguage,
+        try {
+            if (!isUserEligibleForWorkspaceContext()) {
+                return;
+            }
+            const programmingLanguage = (0, languageDetection_1.getCodeWhispererLanguageIdFromPath)(event.textDocument.uri);
+            if (!programmingLanguage || !artifactManager_1.SUPPORTED_WORKSPACE_CONTEXT_LANGUAGES.includes(programmingLanguage)) {
+                return;
+            }
+            logging.log(`Received didSave event for ${event.textDocument.uri}`);
+            const workspaceFolder = workspaceFolderManager.getWorkspaceFolder(event.textDocument.uri, workspaceFolders);
+            if (!workspaceFolder) {
+                logging.log(`No workspaceFolder found for ${event.textDocument.uri} discarding the save event`);
+                return;
+            }
+            const workspaceId = await workspaceFolderManager.waitForRemoteWorkspaceId();
+            const fileMetadata = await artifactManager.processNewFile(workspaceFolder, event.textDocument.uri);
+            const s3Url = await workspaceFolderManager.uploadToS3(fileMetadata);
+            if (!s3Url) {
+                return;
+            }
+            const message = JSON.stringify({
+                method: 'textDocument/didSave',
+                params: {
+                    textDocument: {
+                        uri: event.textDocument.uri,
+                    },
+                    workspaceChangeMetadata: {
+                        workspaceId: workspaceId,
+                        s3Path: (0, util_1.cleanUrl)(s3Url),
+                        programmingLanguage: programmingLanguage,
+                    },
                 },
-            },
-        });
-        if (!workspaceDetails.webSocketClient) {
-            logging.log(`WebSocket client is not connected yet: ${workspaceRoot.uri}, adding didSave message to queue`);
-            workspaceDetails.messageQueue?.push(message);
-        }
-        else {
-            workspaceDetails.webSocketClient.send(message).catch(error => {
-                logging.error(`Error while sending didSave message: ${error}`);
             });
+            const workspaceState = workspaceFolderManager.getWorkspaceState();
+            workspaceState.messageQueue.push(message);
+        }
+        catch (error) {
+            logging.error(`Error handling save event: ${error}`);
         }
     });
     lsp.workspace.onDidCreateFiles(async (event) => {
-        if (!isUserEligibleForWorkspaceContext()) {
-            return;
-        }
-        logging.log(`Received didCreateFiles event of length ${event.files.length}`);
-        for (const file of event.files) {
-            const isDir = (0, util_1.isDirectory)(file.uri);
-            const result = workspaceFolderManager.getWorkspaceDetailsWithId(file.uri, workspaceFolders);
-            if (!result) {
-                continue;
-            }
-            const { workspaceDetails, workspaceRoot } = result;
-            let filesMetadata = [];
-            if (isDir && (0, util_1.isEmptyDirectory)(file.uri)) {
-                continue;
-            }
-            else if (isDir) {
-                filesMetadata = await artifactManager.addNewDirectories([vscode_uri_1.URI.parse(file.uri)]);
-            }
-            else {
-                filesMetadata = [await artifactManager.processNewFile(workspaceRoot, file.uri)];
+        try {
+            if (!isUserEligibleForWorkspaceContext()) {
+                return;
             }
-            for (const fileMetadata of filesMetadata) {
-                const s3Url = await workspaceFolderManager.uploadToS3(fileMetadata);
-                if (!s3Url) {
+            logging.log(`Received didCreateFiles event of length ${event.files.length}`);
+            const workspaceState = workspaceFolderManager.getWorkspaceState();
+            for (const file of event.files) {
+                const isDir = (0, util_1.isDirectory)(file.uri);
+                const workspaceFolder = workspaceFolderManager.getWorkspaceFolder(file.uri, workspaceFolders);
+                if (!workspaceFolder) {
                     continue;
                 }
-                const message = JSON.stringify({
-                    method: 'workspace/didCreateFiles',
-                    params: {
-                        files: [
-                            {
-                                uri: (0, util_1.getRelativePath)(fileMetadata.workspaceFolder, file.uri),
-                            },
-                        ],
-                        workspaceChangeMetadata: {
-                            workspaceId: workspaceDetails.workspaceId,
-                            s3Path: (0, util_1.cleanUrl)(s3Url),
-                            programmingLanguage: fileMetadata.language,
-                        },
-                    },
-                });
-                if (!workspaceDetails.webSocketClient) {
-                    logging.log(`WebSocket client is not connected yet: ${workspaceRoot.uri}, adding didCreateFiles message to queue`);
-                    workspaceDetails.messageQueue?.push(message);
+                const programmingLanguage = (0, languageDetection_1.getCodeWhispererLanguageIdFromPath)(file.uri);
+                if (!programmingLanguage || !artifactManager_1.SUPPORTED_WORKSPACE_CONTEXT_LANGUAGES.includes(programmingLanguage)) {
+                    continue;
+                }
+                let filesMetadata = [];
+                if (isDir && (0, util_1.isEmptyDirectory)(file.uri)) {
+                    continue;
+                }
+                else if (isDir) {
+                    filesMetadata = await artifactManager.addNewDirectories([vscode_uri_1.URI.parse(file.uri)]);
                 }
                 else {
-                    workspaceDetails.webSocketClient.send(message).catch(error => {
-                        logging.error(`Error while sending didCreateFiles message: ${error}`);
+                    filesMetadata = [await artifactManager.processNewFile(workspaceFolder, file.uri)];
+                }
+                const workspaceId = await workspaceFolderManager.waitForRemoteWorkspaceId();
+                for (const fileMetadata of filesMetadata) {
+                    const s3Url = await workspaceFolderManager.uploadToS3(fileMetadata);
+                    if (!s3Url) {
+                        continue;
+                    }
+                    const message = JSON.stringify({
+                        method: 'workspace/didCreateFiles',
+                        params: {
+                            files: [
+                                {
+                                    uri: file.uri,
+                                },
+                            ],
+                            workspaceChangeMetadata: {
+                                workspaceId: workspaceId,
+                                s3Path: (0, util_1.cleanUrl)(s3Url),
+                                programmingLanguage: fileMetadata.language,
+                            },
+                        },
                     });
+                    workspaceState.messageQueue.push(message);
                 }
             }
         }
+        catch (error) {
+            logging.error(`Error handling create event: ${error}`);
+        }
     });
     lsp.workspace.onDidDeleteFiles(async (event) => {
-        if (!isUserEligibleForWorkspaceContext()) {
-            return;
-        }
-        logging.log(`Received didDeleteFiles event of length ${event.files.length}`);
-        for (const file of event.files) {
-            const result = workspaceFolderManager.getWorkspaceDetailsWithId(file.uri, workspaceFolders);
-            if (!result) {
-                logging.log(`Workspace details not found for deleted file: ${file.uri}`);
-                continue;
-            }
-            const { workspaceDetails, workspaceRoot } = result;
-            const programmingLanguages = artifactManager.handleDeletedPathAndGetLanguages(file.uri, workspaceRoot);
-            if (programmingLanguages.length === 0) {
-                logging.log(`No programming languages determined for: ${file.uri}`);
-                continue;
+        try {
+            if (!isUserEligibleForWorkspaceContext()) {
+                return;
             }
-            // Send notification for each programming language
-            for (const language of programmingLanguages) {
-                const message = JSON.stringify({
-                    method: 'workspace/didDeleteFiles',
-                    params: {
-                        files: [
-                            {
-                                uri: (0, util_1.getRelativePath)(workspaceRoot, file.uri),
+            logging.log(`Received didDeleteFiles event of length ${event.files.length}`);
+            const workspaceState = workspaceFolderManager.getWorkspaceState();
+            for (const file of event.files) {
+                const workspaceFolder = workspaceFolderManager.getWorkspaceFolder(file.uri, workspaceFolders);
+                if (!workspaceFolder) {
+                    logging.log(`Workspace details not found for deleted file: ${file.uri}`);
+                    continue;
+                }
+                const programmingLanguages = artifactManager.handleDeletedPathAndGetLanguages(file.uri, workspaceFolder);
+                if (programmingLanguages.length === 0) {
+                    logging.log(`No programming languages determined for: ${file.uri}`);
+                    continue;
+                }
+                const workspaceId = await workspaceFolderManager.waitForRemoteWorkspaceId();
+                // Send notification for each programming language
+                for (const language of programmingLanguages) {
+                    const message = JSON.stringify({
+                        method: 'workspace/didDeleteFiles',
+                        params: {
+                            files: [
+                                {
+                                    uri: file.uri,
+                                },
+                            ],
+                            workspaceChangeMetadata: {
+                                workspaceId: workspaceId,
+                                programmingLanguage: language,
                             },
-                        ],
-                        workspaceChangeMetadata: {
-                            workspaceId: workspaceDetails.workspaceId,
-                            programmingLanguage: language,
                         },
-                    },
-                });
-                if (!workspaceDetails.webSocketClient) {
-                    logging.log(`WebSocket client is not connected yet: ${workspaceRoot.uri}, adding didDeleteFiles message to queue`);
-                    workspaceDetails.messageQueue?.push(message);
-                }
-                else {
-                    workspaceDetails.webSocketClient.send(message).catch(error => {
-                        logging.error(`Error while sending didDeleteFiles message: ${error}`);
                     });
+                    workspaceState.messageQueue.push(message);
                 }
             }
         }
+        catch (error) {
+            logging.error(`Error handling delete event: ${error}`);
+        }
     });
     lsp.workspace.onDidRenameFiles(async (event) => {
-        if (!isUserEligibleForWorkspaceContext()) {
-            return;
-        }
-        logging.log(`Received didRenameFiles event of length ${event.files.length}`);
-        for (const file of event.files) {
-            const result = workspaceFolderManager.getWorkspaceDetailsWithId(file.newUri, workspaceFolders);
-            if (!result) {
-                continue;
+        try {
+            if (!isUserEligibleForWorkspaceContext()) {
+                return;
             }
-            const { workspaceDetails, workspaceRoot } = result;
-            const filesMetadata = await artifactManager.handleRename(workspaceRoot, file.oldUri, file.newUri);
-            for (const fileMetadata of filesMetadata) {
-                const s3Url = await workspaceFolderManager.uploadToS3(fileMetadata);
-                if (!s3Url) {
+            logging.log(`Received didRenameFiles event of length ${event.files.length}`);
+            const workspaceState = workspaceFolderManager.getWorkspaceState();
+            for (const file of event.files) {
+                const workspaceFolder = workspaceFolderManager.getWorkspaceFolder(file.newUri, workspaceFolders);
+                if (!workspaceFolder) {
                     continue;
                 }
-                const message = JSON.stringify({
-                    method: 'workspace/didRenameFiles',
-                    params: {
-                        files: [
-                            {
-                                old_uri: (0, util_1.getRelativePath)(fileMetadata.workspaceFolder, file.oldUri),
-                                new_uri: (0, util_1.getRelativePath)(fileMetadata.workspaceFolder, file.newUri),
+                const filesMetadata = await artifactManager.handleRename(workspaceFolder, file.oldUri, file.newUri);
+                const workspaceId = await workspaceFolderManager.waitForRemoteWorkspaceId();
+                for (const fileMetadata of filesMetadata) {
+                    const s3Url = await workspaceFolderManager.uploadToS3(fileMetadata);
+                    if (!s3Url) {
+                        continue;
+                    }
+                    const message = JSON.stringify({
+                        method: 'workspace/didRenameFiles',
+                        params: {
+                            files: [
+                                {
+                                    old_uri: file.oldUri,
+                                    new_uri: file.newUri,
+                                },
+                            ],
+                            workspaceChangeMetadata: {
+                                workspaceId: workspaceId,
+                                s3Path: (0, util_1.cleanUrl)(s3Url),
+                                programmingLanguage: fileMetadata.language,
                             },
-                        ],
-                        workspaceChangeMetadata: {
-                            workspaceId: workspaceDetails.workspaceId,
-                            s3Path: (0, util_1.cleanUrl)(s3Url),
-                            programmingLanguage: fileMetadata.language,
                         },
-                    },
-                });
-                if (!workspaceDetails.webSocketClient) {
-                    logging.log(`WebSocket client is not connected yet: ${workspaceRoot.uri}, adding didRenameFiles message to queue`);
-                    workspaceDetails.messageQueue?.push(message);
-                }
-                else {
-                    workspaceDetails.webSocketClient.send(message).catch(error => {
-                        logging.error(`Error while sending didRenameFiles message: ${error}`);
                     });
+                    workspaceState.messageQueue.push(message);
                 }
             }
         }
+        catch (error) {
+            logging.error(`Error handling rename event: ${error}`);
+        }
     });
     lsp.extensions.onDidChangeDependencyPaths(async (params) => {
-        if (!isUserEligibleForWorkspaceContext()) {
-            return;
+        try {
+            if (!isUserEligibleForWorkspaceContext()) {
+                return;
+            }
+            logging.log(`Received onDidChangeDependencyPaths event for ${params.moduleName}`);
+            const workspaceFolder = workspaceFolderManager.getWorkspaceFolder(params.moduleName);
+            await dependencyDiscoverer.handleDependencyUpdateFromLSP(params.runtimeLanguage, params.paths, workspaceFolder);
+        }
+        catch (error) {
+            logging.error(`Error handling didChangeDependencyPaths event: ${error}`);
         }
-        logging.log(`Received onDidChangeDependencyPaths event for ${params.moduleName}`);
-        const workspaceFolder = workspaceFolderManager.getWorkspaceFolder(params.moduleName);
-        await dependencyDiscoverer.handleDependencyUpdateFromLSP(params.runtimeLanguage, params.paths, workspaceFolder);
     });
     logging.log('Workspace context server has been initialized');
     return () => {