Handle settings and lint readiness in initialization handler

Author: chrisqm-dev

package.json

@@ -27,9 +27,6 @@
         "test:integration": "cross-env NODE_ENV=test vitest run --config vitest.integration.config.ts",
         "test:unit": "cross-env NODE_ENV=test vitest run --config vitest.unit.config.ts",
         "test:leaks": "cross-env NODE_ENV=test vitest run --pool=forks --logHeapUsage",
-        "test:long-running": "cross-env NODE_ENV=test NODE_OPTIONS=\"--max-old-space-size=2048\" LONG_RUNNING_DURATION=${LONG_RUNNING_DURATION:-4h} vitest run --config vitest.long-running.config.ts",
-        "test:long-running-standalone": "tsx tools/long-running/run-long-running-test.ts",
-        "test:long-running-local": "npm run bundle:prod && STANDALONE_PATH=./bundle/production/cfn-lsp-server-standalone.js npm run test:long-running-standalone",
         "lint": "eslint --cache --cache-location node_modules/.cache/eslint --max-warnings 0 .",
         "lint:fix": "npm run lint -- --fix",
         "build:go:dev": "GOPROXY=direct go build -C cfn-init/cmd -v -o ../../bundle/development/bin/cfn-init",

src/handlers/Initialize.ts

@@ -13,14 +13,25 @@ export function initializedHandler(workspace: LspWorkspace, components: ServerCo
                 return components.cfnLintService.initialize();
             })
             .then(async () => {
+                let mountingSucceeded = true;
+                let mountingError = '';
+
                 // Process folders sequentially to avoid overwhelming the system
                 for (const folder of workspace.getAllWorkspaceFolders()) {
                     try {
                         await components.cfnLintService.mountFolder(folder);
                     } catch (error) {
                         logger.error(error, `Failed to mount folder ${folder.name}`);
+                        mountingSucceeded = false;
+                        mountingError = `Failed to mount folder ${folder.name}: ${error instanceof Error ? error.message : String(error)}`;
                     }
                 }
+
+                if (mountingSucceeded) {
+                    components.cfnLintService.setReadinessStatus({ ready: true });
+                } else {
+                    components.cfnLintService.setReadinessStatus({ ready: false, reason: mountingError });
+                }
             })
             .catch((error: unknown) => {
                 logger.error(error, `Failed to initialize server`);

src/handlers/SystemHandler.ts

@@ -8,18 +8,22 @@ export function getSystemStatusHandler(
 ): RequestHandler<void, GetSystemStatusResponse, void> {
     return (): GetSystemStatusResponse => {
         try {
-            // If settings are updating, everything is not ready
-            if (components.settingsManager.isSettingsUpdateInProgress()) {
+            const settingsStatus = components.settingsManager.getReadinessStatus();
+
+            if (!settingsStatus.ready) {
+                const reason = settingsStatus.reason ?? 'Server initializing';
                 return {
-                    schemasReady: { ready: false, reason: 'Settings updating', availableRegions: [] },
-                    cfnLintReady: { ready: false, reason: 'Settings updating' },
-                    cfnGuardReady: { ready: false, reason: 'Settings updating' },
+                    settingsReady: settingsStatus,
+                    schemasReady: { ready: false, reason, availableRegions: [] },
+                    cfnLintReady: { ready: false, reason },
+                    cfnGuardReady: { ready: false, reason },
                     currentSettings: components.settingsManager.getCurrentSettings(),
                 };
             }
 
             const availableRegions = components.schemaStore.getPublicSchemaRegions();
             return {
+                settingsReady: settingsStatus,
                 schemasReady: {
                     availableRegions: [...availableRegions],
                     ready: availableRegions.length > 0,

src/services/cfnLint/CfnLintService.ts

@@ -8,6 +8,7 @@ import { LspWorkspace } from '../../protocol/LspWorkspace';
 import { CfnLspServerComponentsType } from '../../server/ServerComponents';
 import { SettingsConfigurable, ISettingsSubscriber, SettingsSubscription } from '../../settings/ISettingsSubscriber';
 import { DefaultSettings, CfnLintSettings } from '../../settings/Settings';
+import { ReadinessStatus } from '../../system/SystemTypes';
 import { LoggerFactory } from '../../telemetry/LoggerFactory';
 import { ScopedTelemetry } from '../../telemetry/ScopedTelemetry';
 import { Count, Telemetry } from '../../telemetry/TelemetryDecorator';
@@ -48,6 +49,7 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
     private static readonly CFN_LINT_SOURCE = 'cfn-lint';
 
     private status: STATUS = STATUS.Uninitialized;
+    private readinessStatus: ReadinessStatus = { ready: false, reason: 'Not initialized' };
     private readonly delayer: Delayer<void>;
     private settings: CfnLintSettings;
     private settingsSubscription?: SettingsSubscription;
@@ -128,6 +130,17 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
         });
     }
 
+    getReadinessStatus(): ReadinessStatus {
+        if (!this.settings.enabled) {
+            return { ready: true }; // Disabled services are considered ready
+        }
+        return this.readinessStatus;
+    }
+
+    setReadinessStatus(status: ReadinessStatus): void {
+        this.readinessStatus = status;
+    }
+
     private onSettingsChanged(newSettings: CfnLintSettings): void {
         this.settings = newSettings;
         this.workerManager.updateSettings(newSettings);
@@ -190,23 +203,6 @@ export class CfnLintService implements SettingsConfigurable, Closeable {
         }
     }
 
-    /**
-     * Get the readiness status of the CfnLint service
-     */
-    public getReadinessStatus(): { ready: boolean; reason?: string } {
-        // If disabled, consider it ready (nothing to do)
-        if (!this.settings.enabled) {
-            return { ready: true };
-        }
-
-        // If enabled, check actual readiness
-        const ready = this.status === STATUS.Initialized;
-        return {
-            ready,
-            ...(ready ? {} : { reason: `Status is ${STATUS[this.status]}` }),
-        };
-    }
-
     /**
      * Mount a workspace folder to the Pyodide filesystem.
      * This allows cfn-lint to access files in the workspace for linting.

src/services/guard/GuardService.ts

@@ -6,6 +6,7 @@ import { DocumentManager } from '../../document/DocumentManager';
 import { ServerComponents } from '../../server/ServerComponents';
 import { SettingsConfigurable, ISettingsSubscriber, SettingsSubscription } from '../../settings/ISettingsSubscriber';
 import { DefaultSettings, GuardSettings } from '../../settings/Settings';
+import { ReadinessStatus } from '../../system/SystemTypes';
 import { LoggerFactory } from '../../telemetry/LoggerFactory';
 import { ScopedTelemetry } from '../../telemetry/ScopedTelemetry';
 import { Count, Telemetry } from '../../telemetry/TelemetryDecorator';
@@ -96,10 +97,7 @@ export class GuardService implements SettingsConfigurable, Closeable {
             });
     }
 
-    /**
-     * Get the readiness status of the Guard service
-     */
-    public getReadinessStatus(): { ready: boolean; reason?: string } {
+    public getReadinessStatus(): ReadinessStatus {
         // If disabled, consider it ready (nothing to do)
         if (!this.settings.enabled) {
             return { ready: true };

src/settings/SettingsManager.ts

@@ -1,6 +1,7 @@
 import { diff } from 'deep-object-diff';
 import { DeepReadonly } from 'ts-essentials';
 import { LspWorkspace } from '../protocol/LspWorkspace';
+import { ReadinessStatus } from '../system/SystemTypes';
 import { LoggerFactory } from '../telemetry/LoggerFactory';
 import { ScopedTelemetry } from '../telemetry/ScopedTelemetry';
 import { Measure, Telemetry } from '../telemetry/TelemetryDecorator';
@@ -18,7 +19,7 @@ export class SettingsManager implements ISettingsSubscriber {
     @Telemetry() private readonly telemetry!: ScopedTelemetry;
     private readonly settingsState = new SettingsState();
     private readonly subscriptionManager = new SubscriptionManager<Settings>();
-    private isUpdatingSettings = false;
+    private readinessStatus: ReadinessStatus = { ready: false, reason: 'Not initialized' };
 
     constructor(
         private readonly workspace: LspWorkspace,
@@ -34,11 +35,8 @@ export class SettingsManager implements ISettingsSubscriber {
         return this.settingsState.toSettings();
     }
 
-    /**
-     * Check if settings update is in progress
-     */
-    isSettingsUpdateInProgress(): boolean {
-        return this.isUpdatingSettings;
+    getReadinessStatus(): ReadinessStatus {
+        return this.readinessStatus;
     }
 
     reset() {
@@ -82,7 +80,10 @@ export class SettingsManager implements ISettingsSubscriber {
 
             const settings = parseWithPrettyError(parseSettings, mergedConfig, this.getCurrentSettings());
             this.validateAndUpdate(settings);
+            this.readinessStatus = { ready: true };
         } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.readinessStatus = { ready: false, reason: `Settings sync failed: ${errorMessage}` };
             logger.error(error, `Failed to sync configuration, keeping previous settings`);
         }
     }
@@ -166,13 +167,16 @@ export class SettingsManager implements ISettingsSubscriber {
         const hasChanged = Object.keys(difference).length > 0;
 
         if (hasChanged) {
-            this.isUpdatingSettings = true;
+            this.readinessStatus = { ready: false, reason: 'Settings updating' };
             try {
                 this.settingsState.update(newSettings);
                 logger.info(`Settings updated: ${toString(difference)}`);
                 this.subscriptionManager.notify(newSettings, oldSettings);
-            } finally {
-                this.isUpdatingSettings = false;
+                this.readinessStatus = { ready: true };
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.readinessStatus = { ready: false, reason: `Settings update failed: ${errorMessage}` };
+                logger.error(error, 'Failed to update settings');
             }
         }
     }

src/system/SystemTypes.ts

@@ -7,6 +7,7 @@ export type ReadinessStatus = {
 };
 
 export type GetSystemStatusResponse = {
+    settingsReady: ReadinessStatus;
     schemasReady: ReadinessStatus & {
         availableRegions: string[];
     };
@@ -15,4 +16,4 @@ export type GetSystemStatusResponse = {
     currentSettings: Settings;
 };
 
-export const GetSystemStatusRequestType = new RequestType<void, GetSystemStatusResponse, void>('aws/cfn/system/status');
+export const GetSystemStatusRequestType = new RequestType<void, GetSystemStatusResponse, void>('aws/system/status');