FIx LS not working when webview closed issue

workspaces/mi/mi-extension/src/extension.ts

@@ -34,6 +34,7 @@ import { webviews } from './visualizer/webview';
 import { v4 as uuidv4 } from 'uuid';
 import path from 'path';
 import { COMMANDS } from './constants';
+import { enableLSForWorkspace } from './util/workspace';
 const os = require('os');
 
 export async function activate(context: vscode.ExtensionContext) {
@@ -92,6 +93,10 @@ export async function activate(context: vscode.ExtensionContext) {
 	activateRuntimeService(context, firstProject);
 	activateVisualizer(context, firstProject);
 	activateAiPanel(context);
+
+	workspace.workspaceFolders?.forEach(folder => {
+		enableLSForWorkspace(folder.uri.fsPath);
+	});
 }
 
 export async function deactivate(): Promise<void> {

workspaces/mi/mi-extension/src/project-explorer/activate.ts

@@ -37,11 +37,13 @@ import { webviews } from '../visualizer/webview';
 import { MILanguageClient } from '../lang-client/activator';
 
 let isProjectExplorerInitialized = false;
-export async function activateProjectExplorer(treeviewId: string, context: ExtensionContext, lsClient: ExtendedLanguageClient, isInWI: boolean) {
+export async function activateProjectExplorer(treeviewId: string, context: ExtensionContext, projectUri: string, isInWI: boolean) {
 	if (isProjectExplorerInitialized) {
 		return;
 	}
 	isProjectExplorerInitialized = true;
+	const ls = await MILanguageClient.getInstance(projectUri);
+	const lsClient: ExtendedLanguageClient | undefined = ls.languageClient;
 
 	const projectExplorerDataProvider = new ProjectExplorerEntryProvider(context);
 	await projectExplorerDataProvider.refresh();
@@ -52,12 +54,12 @@ export async function activateProjectExplorer(treeviewId: string, context: Exten
 	const runtimeVersion = projectDetailsRes.primaryDetails.runtimeVersion.value;
 	const isRegistrySupported = compareVersions(runtimeVersion, RUNTIME_VERSION_440) < 0;
 
-	commands.registerCommand(COMMANDS.REFRESH_COMMAND, () => { 
+	commands.registerCommand(COMMANDS.REFRESH_COMMAND, () => {
 		if (isInWI) {
 			commands.executeCommand(COMMANDS.WI_PROJECT_EXPLORER_VIEW_REFRESH);
 			return;
 		}
-		return projectExplorerDataProvider.refresh(); 
+		return projectExplorerDataProvider.refresh();
 	});
 
 	commands.registerCommand(COMMANDS.ADD_ARTIFACT_COMMAND, (entry: ProjectExplorerEntry) => {

workspaces/mi/mi-extension/src/stateMachine.ts

@@ -658,9 +658,8 @@ const stateMachine = createMachine<MachineContext>({
         },
         activateOtherFeatures: (context, event) => {
             return new Promise(async (resolve, reject) => {
-                const ls = await MILanguageClient.getInstance(context.projectUri!);
                 const treeviewId = context.isInWI ? WI_PROJECT_EXPLORER_VIEW_ID : MI_PROJECT_EXPLORER_VIEW_ID;
-                await activateProjectExplorer(treeviewId, extension.context, ls.languageClient!, context.isInWI);
+                await activateProjectExplorer(treeviewId, extension.context, context.projectUri!, context.isInWI);
                 await activateTestExplorer(extension.context);
                 resolve(true);
             });

workspaces/mi/mi-extension/src/util/workspace.ts

@@ -21,7 +21,8 @@ import * as fs from "fs";
 import { COMMANDS } from "../constants";
 import path from "path";
 import { MILanguageClient } from "../lang-client/activator";
-import { extension } from "../MIExtensionContext";
+import * as vscode from 'vscode';
+import { webviews } from "../visualizer/webview";
 
 export async function replaceFullContentToFile(documentUri: string, content: string) {
     // Create the file if not present
@@ -45,7 +46,7 @@ export async function replaceFullContentToFile(documentUri: string, content: str
         // Wait for the file to be fully created and accessible
         const maxRetries = 5;
         const retryDelay = 100;
-        
+
         let retries = 0;
         while (retries < maxRetries) {
             try {
@@ -91,12 +92,12 @@ export async function askForProject(): Promise<string> {
     return projects.get(quickPick)!;
 }
 
-export async function saveIdpSchemaToFile(folderPath: string, fileName:string, fileContent?: string,imageOrPdf?:string): Promise<boolean> {
-    const documentUri = path.join(folderPath, fileName +".json");
+export async function saveIdpSchemaToFile(folderPath: string, fileName: string, fileContent?: string, imageOrPdf?: string): Promise<boolean> {
+    const documentUri = path.join(folderPath, fileName + ".json");
     if (!fs.existsSync(folderPath)) {
         fs.mkdirSync(folderPath, { recursive: true });
     }
-    if(fileContent){
+    if (fileContent) {
         fs.writeFileSync(documentUri, fileContent, 'utf-8');
     }
     if (imageOrPdf) {
@@ -110,27 +111,63 @@ export async function saveIdpSchemaToFile(folderPath: string, fileName:string, f
         }
         const mimeTypeMatch = imageOrPdf.match(/^data:(.*?);base64,/);
         if (mimeTypeMatch) {
-            const mimeType = mimeTypeMatch[1]; 
+            const mimeType = mimeTypeMatch[1];
             let extension = "";
             if (mimeType === "application/pdf") {
                 extension = ".pdf";
             } else if (mimeType.startsWith("image/")) {
-                extension = mimeType.split("/")[1]; 
+                extension = mimeType.split("/")[1];
                 extension = `.${extension}`;
             } else {
                 console.error("Unsupported MIME type:", mimeType);
-                return false; 
+                return false;
             }
-            const base64Data = imageOrPdf.replace(/^data:.*;base64,/, ""); 
+            const base64Data = imageOrPdf.replace(/^data:.*;base64,/, "");
             const binaryData = Buffer.from(base64Data, "base64");
             const filePath = path.join(folderPath, fileName + extension);
             fs.writeFileSync(filePath, binaryData);
         } else {
             console.error("Invalid base64 string format.");
-            return false; 
+            return false;
         }
     }
     commands.executeCommand(COMMANDS.REFRESH_COMMAND);
     return true;
 }
 
+export function enableLSForWorkspace(workspacePath: string): void {
+    window.onDidChangeActiveTextEditor(async (event) => {
+        const artifactsPath = path.join(workspacePath, 'src', 'main', 'wso2mi', 'artifacts');
+        const hasActiveWebview = webviews.has(workspacePath);
+
+        if (hasActiveWebview) {
+            return;
+        }
+        if (!event) { // No text editors
+            await MILanguageClient.stopInstance(workspacePath);
+            return;
+        }
+        if (!event.document.uri.fsPath.startsWith(artifactsPath)) {
+            return;
+        }
+        const hasActiveDocument = hasActiveDocumentInWorkspace(workspacePath);
+
+        if (hasActiveDocument) {
+            await MILanguageClient.getInstance(workspacePath);
+        } else {
+            await MILanguageClient.stopInstance(workspacePath);
+        }
+    });
+}
+
+export function hasActiveDocumentInWorkspace(workspacePath: string): boolean {
+    const artifactsPath = path.join(workspacePath, 'src', 'main', 'wso2mi', 'artifacts');
+    for (const tabGroup of vscode.window.tabGroups.all) {
+        for (const tab of tabGroup.tabs) {
+            if (tab.input instanceof vscode.TabInputText && tab.input.uri.fsPath.startsWith(artifactsPath)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

workspaces/mi/mi-extension/src/visualizer/webview.ts

@@ -29,6 +29,7 @@ import { MACHINE_VIEW } from '@wso2/mi-core';
 import { refreshDiagram } from './activate';
 import { MILanguageClient } from '../lang-client/activator';
 import { deletePopupStateMachine } from '../stateMachinePopup';
+import { hasActiveDocumentInWorkspace } from '../util/workspace';
 
 export const webviews: Map<string, VisualizerWebview> = new Map();
 export class VisualizerWebview {
@@ -124,7 +125,7 @@ export class VisualizerWebview {
         // The JS file from the React build output
         const jsFiles = getComposerJSFiles(extension.context, 'Visualizer', webview);
         console.debug('JS files to be included:', jsFiles);
-        
+
         const scriptUri = jsFiles.map(jsFile => {
             const scriptTag = '<script charset="UTF-8" src="' + jsFile + '"></script>';
             console.debug('Generated script tag:', scriptTag);
@@ -277,7 +278,12 @@ export class VisualizerWebview {
         deleteStateMachine(this.projectUri);
         deletePopupStateMachine(this.projectUri);
         RPCLayer._messengers.delete(this.projectUri);
-        await MILanguageClient.stopInstance(this.projectUri);
+        const hasActiveDocument = hasActiveDocumentInWorkspace(this.projectUri);
+
+        if (!hasActiveDocument) {
+            await MILanguageClient.stopInstance(this.projectUri);
+        }
+
         this._panel?.dispose();
 
         while (this._disposables.length) {