fix cfnlint init timing issue (#177)

Author: kddejong

src/services/cfnLint/CfnLintService.ts

@@ -51,6 +51,7 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
     private initializationPromise?: Promise<void>;
     private readonly workerManager: PyodideWorkerManager;
     private readonly log = LoggerFactory.getLogger(CfnLintService);
+    private readonly mountedFolders = new Map<string, WorkspaceFolder>();
 
     @Telemetry() private readonly telemetry!: ScopedTelemetry;
 
@@ -123,6 +124,19 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
         try {
             // Initialize the worker manager
             await this.workerManager.initialize();
+
+            // Remount previously mounted folders after worker recovery
+            if (this.mountedFolders.size > 0) {
+                for (const [mountDir, folder] of this.mountedFolders) {
+                    try {
+                        const fsDir = URI.parse(folder.uri).fsPath;
+                        await this.workerManager.mountFolder(fsDir, mountDir);
+                    } catch (error) {
+                        this.logError(`remounting folder ${mountDir}`, error);
+                    }
+                }
+            }
+
             this.status = STATUS.Initialized;
             this.telemetry.count('initialized', 1, { unit: '1' });
         } catch (error) {
@@ -147,8 +161,14 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
         const fsDir = URI.parse(folder.uri).fsPath;
         const mountDir = '/'.concat(folder.name);
 
+        // Check if already mounted
+        if (this.mountedFolders.has(mountDir)) {
+            return;
+        }
+
         try {
             await this.workerManager.mountFolder(fsDir, mountDir);
+            this.mountedFolders.set(mountDir, folder);
             this.telemetry.count('mount.success', 1, { unit: '1' });
         } catch (error) {
             this.logError('mounting folder', error);
@@ -260,6 +280,7 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
                 }
             }
         } catch (error) {
+            this.status = STATUS.Uninitialized;
             const errorMessage = extractErrorMessage(error);
             this.logError(`linting ${fileType} by string`, error);
             this.publishErrorDiagnostics(uri, errorMessage);
@@ -299,6 +320,9 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
         content: string,
     ): Promise<void> {
         try {
+            // Ensure folder is mounted before linting
+            await this.mountFolder(folder);
+
             const relativePath = uri.replace(folder.uri, '/'.concat(folder.name));
 
             // Use worker to lint file
@@ -330,6 +354,7 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
                 }
             }
         } catch (error) {
+            this.status = STATUS.Uninitialized;
             const errorMessage = extractErrorMessage(error);
             this.logError(`linting ${fileType} by file`, error);
             this.publishErrorDiagnostics(uri, errorMessage);

tst/unit/services/cfnLint/CfnLintService.test.ts

@@ -298,6 +298,35 @@ describe('CfnLintService', () => {
 
             await expect(service.mountFolder(mockWorkspaceFolder)).rejects.toThrow('Failed to mount directory');
         });
+
+        test('should not mount folder twice', async () => {
+            await service.initialize();
+
+            // Mount folder first time
+            await service.mountFolder(mockWorkspaceFolder);
+            expect(mockWorkerManager.mountFolder.callCount).toBe(1);
+
+            // Mount same folder again - should not call worker
+            await service.mountFolder(mockWorkspaceFolder);
+            expect(mockWorkerManager.mountFolder.callCount).toBe(1);
+        });
+
+        test('should remount folders after worker recovery', async () => {
+            await service.initialize();
+            await service.mountFolder(mockWorkspaceFolder);
+            expect(mockWorkerManager.mountFolder.callCount).toBe(1);
+
+            // Simulate worker crash - this sets status to uninitialized
+            mockWorkerManager.lintTemplate.rejects(new Error('Worker crashed'));
+            await service.lintDelayed(mockTemplate, mockUri, LintTrigger.OnSave);
+
+            // Reset mock to succeed and trigger recovery
+            mockWorkerManager.lintTemplate.resolves([]);
+            await service.lintDelayed(mockTemplate, mockUri, LintTrigger.OnSave);
+
+            // Should have remounted during recovery
+            expect(mockWorkerManager.mountFolder.callCount).toBe(2);
+        });
     });
 
     describe('lint', () => {
@@ -352,6 +381,7 @@ describe('CfnLintService', () => {
             await service.lint(mockTemplate, mockUri);
 
             expect(mockComponents.workspace.getWorkspaceFolder.calledWith(mockUri)).toBe(true);
+            expect(mockWorkerManager.mountFolder.calledWith('/path/to/workspace/project', '/project')).toBe(true);
             expect(
                 mockWorkerManager.lintFile.calledWith(
                     '/project/template.yaml',
@@ -376,6 +406,30 @@ describe('CfnLintService', () => {
             ).toBe(true);
         });
 
+        test('should handle worker crash during standalone linting', async () => {
+            mockComponents.workspace.getWorkspaceFolder.returns(undefined);
+            mockWorkerManager.lintTemplate.rejects(new Error('Worker exited unexpectedly with code 1'));
+
+            await service.lint(mockTemplate, mockUri);
+
+            // Should publish empty diagnostics and not crash
+            expect(mockComponents.diagnosticCoordinator.publishDiagnostics.called).toBe(true);
+            // Service should be marked as uninitialized for recovery
+            expect(service.isInitialized()).toBe(false);
+        });
+
+        test('should handle worker crash during workspace file linting', async () => {
+            mockComponents.workspace.getWorkspaceFolder.returns(mockWorkspaceFolder);
+            mockWorkerManager.lintFile.rejects(new Error('Worker exited unexpectedly with code 1'));
+
+            await service.lint(mockTemplate, mockUri);
+
+            // Should publish empty diagnostics and not crash
+            expect(mockComponents.diagnosticCoordinator.publishDiagnostics.called).toBe(true);
+            // Service should be marked as uninitialized for recovery
+            expect(service.isInitialized()).toBe(false);
+        });
+
         test('should handle JSON templates', async () => {
             mockComponents.workspace.getWorkspaceFolder.returns(undefined);