Prompting users to reload vscode window for proper manifest updates (#811)

* Added log messages to track treeView registration
* Changed to same treeView pattern as live watch
* Check if views are correctly loaded before registering
** Check if related commands are there
** Ask user to reload VS Code window if not
* Added a pop up window to ask the user to reload when component viewer view is not registered
* Add tests, move some local mocks to global vscode mock
* Include extension.ts in coverage

---------
Co-authored-by: Jens Reinecke <jens.reinecke@arm.com>

Author: omarArm

__mocks__/vscode.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2025 Arm Limited
+ * Copyright 2025-2026 Arm Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -73,9 +73,16 @@ module.exports = {
         })),
         registerTreeDataProvider: jest.fn(() => ({ dispose: jest.fn() })),
         showErrorMessage: jest.fn(),
-        showInformationMessage: jest.fn(),
+        showInformationMessage: jest.fn(() => Promise.resolve(undefined)),
         showWarningMessage: jest.fn(),
-        createStatusBarItem: jest.fn(),
+        createStatusBarItem: jest.fn(() => ({
+    		id: 'mockStatusBarItem',
+		    alignment: StatusBarAlignment.Left,
+            text: '',
+            show: jest.fn(),
+            hide: jest.fn(),
+            dispose: jest.fn(),
+        })),
         showQuickPick: jest.fn(),
     },
     env: {
@@ -107,6 +114,13 @@ module.exports = {
     },
     commands: {
         executeCommand: jest.fn(),
+        // Default to all views in extension having been correctly loaded
+        getCommands: jest.fn(() => Promise.resolve([
+            'cmsis-debugger.liveWatch.open',
+            'cmsis-debugger.liveWatch.focus',
+            'cmsis-debugger.componentViewer.open',
+            'cmsis-debugger.componentViewer.focus',
+        ])),
         registerCommand: jest.fn(),
     },
     debug: {

jest.config.ts

@@ -32,8 +32,7 @@ const config: Config = {
     "src/**/*.{ts,tsx}",
     "!**/*.d.ts",
     "!**/*.factories.{ts,tsx}",
-    "!**/__test__/**/*",
-    "!src/desktop/extension.ts",
+    "!**/__test__/**/*"
   ],
   coverageDirectory: "./coverage",
   coverageReporters: ["lcov", "text"],

package.json

@@ -57,13 +57,13 @@
     "views": {
       "cmsis-debugger": [
         {
-          "id": "cmsis-debugger.liveWatch",
-          "name": "Live Watch",
+          "id": "cmsis-debugger.componentViewer",
+          "name": "Component Viewer",
           "icon": "media/trace-and-live-light.svg"
         },
         {
-          "id": "cmsis-debugger.componentViewer",
-          "name": "Component Viewer",
+          "id": "cmsis-debugger.liveWatch",
+          "name": "Live Watch",
           "icon": "media/trace-and-live-light.svg"
         }
       ]

src/desktop/extension.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Copyright 2026 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as vscode from 'vscode';
+import { extensionContextFactory } from '../__test__/vscode.factory';
+import { logger } from '../logger';
+import { activate, deactivate } from './extension';
+import { ComponentViewerTreeDataProvider } from '../views/component-viewer/component-viewer-tree-view';
+import { LiveWatchTreeDataProvider } from '../views/live-watch/live-watch';
+
+describe('extension', () => {
+
+    describe('activate', () => {
+
+        it('activates extension without asking to reload', async () => {
+            const loggerSpy = jest.spyOn(logger, 'debug');
+            await activate(extensionContextFactory());
+            expect(loggerSpy).toHaveBeenCalledWith('CMSIS Debugger activated');
+            expect(vscode.window.showWarningMessage).not.toHaveBeenCalledWith('Cannot activate all Arm CMSIS Debugger views. Please reload the window.', 'Reload Window');
+        });
+
+        it.each([
+            { missingView: 'live watch view', availableCommands: [ 'cmsis-debugger.componentViewer.open', 'cmsis-debugger.componentViewer.focus'] },
+            { missingView: 'component viewer', availableCommands: [ 'cmsis-debugger.liveWatch.open', 'cmsis-debugger.liveWatch.focus'] }
+        ])('activates extension and asks to reload because $missingView is not loaded', async ({ availableCommands }) => {
+            const loggerSpy = jest.spyOn(logger, 'debug');
+            // Resolve once per each view in extension, do not permanently overload global mock
+            (vscode.commands.getCommands as jest.Mock)
+                .mockResolvedValueOnce(availableCommands)
+                .mockResolvedValueOnce(availableCommands);
+            await activate(extensionContextFactory());
+            expect(loggerSpy).toHaveBeenCalledWith('CMSIS Debugger activation incomplete');
+            expect(vscode.window.showWarningMessage).toHaveBeenCalledWith('Cannot activate all Arm CMSIS Debugger views. Please reload the window.', 'Reload Window');
+        });
+
+        it('reloads window if users clicks \'Reload Window\' button', async () => {
+            (vscode.commands.getCommands as jest.Mock).mockResolvedValueOnce([]);
+            (vscode.window.showWarningMessage as jest.Mock).mockResolvedValueOnce('Reload Window');
+            await activate(extensionContextFactory());
+            expect(vscode.commands.executeCommand).toHaveBeenCalledWith('workbench.action.reloadWindow');
+        });
+
+        it('does not reload window if users clicks \'x\' button', async () => {
+            (vscode.commands.getCommands as jest.Mock).mockResolvedValueOnce([]);
+            (vscode.window.showWarningMessage as jest.Mock).mockResolvedValueOnce(undefined);
+            await activate(extensionContextFactory());
+            expect(vscode.commands.executeCommand).not.toHaveBeenCalledWith('workbench.action.reloadWindow');
+        });
+
+    });
+
+    describe('deactivate', () => {
+        const loggerSpy = jest.spyOn(logger, 'debug');
+        const componentViewerClearSpy = jest.spyOn(ComponentViewerTreeDataProvider.prototype, 'clear');
+        const liveWatchDeactivateSpy = jest.spyOn(LiveWatchTreeDataProvider.prototype, 'deactivate');
+
+        beforeEach(() => {
+            loggerSpy.mockClear();
+            componentViewerClearSpy.mockClear();
+            liveWatchDeactivateSpy.mockClear();
+        });
+
+        it('deactivates extension after activation', async () => {
+            await activate(extensionContextFactory());
+            await deactivate();
+            expect(loggerSpy).toHaveBeenCalledWith('CMSIS Debugger deactivated');
+            expect(componentViewerClearSpy).toHaveBeenCalled();
+            expect(liveWatchDeactivateSpy).toHaveBeenCalled();
+        });
+
+        // Cannot test deactivation without activation due to global variables in
+        // extension.ts that are set in other test cases after loading module.
+
+    });
+});
+

src/desktop/extension.ts

@@ -25,24 +25,35 @@ import { CpuStatesCommands } from '../features/cpu-states/cpu-states-commands';
 import { LiveWatchTreeDataProvider } from '../views/live-watch/live-watch';
 import { GenericCommands } from '../features/generic-commands';
 import { ComponentViewer } from '../views/component-viewer/component-viewer-main';
+import { ComponentViewerTreeDataProvider } from '../views/component-viewer/component-viewer-tree-view';
 
 const BUILTIN_TOOLS_PATHS = [
     'tools/pyocd/pyocd',
     'tools/gdb/bin/arm-none-eabi-gdb'
 ];
 
 let liveWatchTreeDataProvider: LiveWatchTreeDataProvider;
+let componentViewerTreeDataProvider: ComponentViewerTreeDataProvider;
+
+const askForReload = async (): Promise<void> => {
+    const result = await vscode.window.showWarningMessage('Cannot activate all Arm CMSIS Debugger views. Please reload the window.', 'Reload Window');
+    if (result === 'Reload Window') {
+        await vscode.commands.executeCommand('workbench.action.reloadWindow');
+    }
+};
 
 export const activate = async (context: vscode.ExtensionContext): Promise<void> => {
+    let canCompleteActivation = true;
     const genericCommands = new GenericCommands();
     const gdbtargetDebugTracker = new GDBTargetDebugTracker();
     const gdbtargetConfigurationProvider = new GDBTargetConfigurationProvider();
     const cpuStates = new CpuStates();
     const cpuStatesCommands = new CpuStatesCommands();
     const cpuStatesStatusBarItem = new CpuStatesStatusBarItem();
-    const componentViewer = new ComponentViewer(context);
     // Register the Tree View under the id from package.json
     liveWatchTreeDataProvider = new LiveWatchTreeDataProvider(context);
+    componentViewerTreeDataProvider = new ComponentViewerTreeDataProvider();
+    const componentViewer = new ComponentViewer(context, componentViewerTreeDataProvider);
 
     addToolsToPath(context, BUILTIN_TOOLS_PATHS);
     // Activate generic commands
@@ -55,17 +66,34 @@ export const activate = async (context: vscode.ExtensionContext): Promise<void>
     cpuStatesCommands.activate(context, cpuStates);
     cpuStatesStatusBarItem.activate(context, cpuStates);
     // Live Watch view
-    liveWatchTreeDataProvider.activate(gdbtargetDebugTracker);
+    logger.debug('Activating Live Watch Tree Data Provider');
+    if (!await liveWatchTreeDataProvider.activate(gdbtargetDebugTracker)) {
+        canCompleteActivation = false;
+    }
     // Component Viewer
-    componentViewer.activate(gdbtargetDebugTracker);
+    logger.debug('Activating Component Viewer');
+    if (!await componentViewer.activate(gdbtargetDebugTracker)) {
+        canCompleteActivation = false;
+    }
+
+    if (!canCompleteActivation) {
+        logger.debug('CMSIS Debugger activation incomplete');
+        // Let promise float, we reload the window.
+        askForReload()
+            .catch(error => logger.error(`Error while asking user to reload window: ${error instanceof Error ? error.message : error}`));
+        return;
+    }
 
-    logger.debug('Extension Pack activated');
+    logger.debug('CMSIS Debugger activated');
 };
 
 export const deactivate = async (): Promise<void> => {
     // Call deactivate of Live Watch to save its state
     if (liveWatchTreeDataProvider) {
         await liveWatchTreeDataProvider.deactivate();
     }
-    logger.debug('Extension Pack deactivated');
+    if (componentViewerTreeDataProvider) {
+        componentViewerTreeDataProvider.clear();
+    }
+    logger.debug('CMSIS Debugger deactivated');
 };

src/manifest.ts

@@ -18,5 +18,6 @@ export const PUBLISHER_NAME = 'arm';
 export const EXTENSION_NAME = 'vscode-cmsis-debugger';
 export const EXTENSION_ID = `${PUBLISHER_NAME}.${EXTENSION_NAME}`;
 export const DISPLAY_NAME = 'Arm CMSIS Debugger';
+export const VIEW_PREFIX = 'cmsis-debugger';
 
 export const COMPONENT_VIEWER_DISPLAY_NAME = 'Arm CMSIS Component Viewer';

src/utils.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2025 Arm Limited
+ * Copyright 2025-2026 Arm Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+// NOTE: Keep vscode imports out of this file.
+// Mocking path in this module's tests causes trouble with path-require in global vscode mock.
+// Can be merged once we found a better solution for path usage in global vscode mock.
 
 import * as os from 'os';
 import * as path from 'path';

src/views/component-viewer/component-viewer-main.ts

@@ -19,9 +19,10 @@ import { GDBTargetDebugTracker, GDBTargetDebugSession } from '../../debug-sessio
 import { ComponentViewerInstance } from './component-viewer-instance';
 import { URI } from 'vscode-uri';
 import { ComponentViewerTreeDataProvider } from './component-viewer-tree-view';
-import { componentViewerLogger } from '../../logger';
+import { componentViewerLogger, logger } from '../../logger';
 import type { ScvdGuiInterface } from './model/scvd-gui-interface';
 import { perf, parsePerf } from './stats-config';
+import { vscodeViewExists } from '../../vscode-utils';
 
 export type UpdateReason = 'sessionChanged' | 'refreshTimer' | 'stackTrace' | 'stackItemChanged' | 'unlockingInstance';
 
@@ -35,7 +36,7 @@ export interface ComponentViewerInstancesWrapper {
 export class ComponentViewer {
     private _activeSession: GDBTargetDebugSession | undefined;
     private _instances: ComponentViewerInstancesWrapper[] = [];
-    private _componentViewerTreeDataProvider: ComponentViewerTreeDataProvider | undefined;
+    private _componentViewerTreeDataProvider: ComponentViewerTreeDataProvider;
     private _context: vscode.ExtensionContext;
     private _instanceUpdateCounter: number = 0;
     private _loadingCounter: number = 0;
@@ -45,20 +46,30 @@ export class ComponentViewer {
     private _refreshTimerEnabled: boolean = true;
     private static readonly pendingUpdateDelayMs = 150;
 
-    public constructor(context: vscode.ExtensionContext) {
+    public constructor(context: vscode.ExtensionContext, componentViewerTreeDataProvider: ComponentViewerTreeDataProvider) {
         this._context = context;
+        this._componentViewerTreeDataProvider = componentViewerTreeDataProvider;
     }
 
-    public activate(tracker: GDBTargetDebugTracker): void {
+    public async activate(tracker: GDBTargetDebugTracker): Promise<boolean> {
         // Register Component Viewer tree view
-        this.registerTreeView();
+        logger.debug('Activating Component Viewer Tree View and commands');
+        if (!await this.registerTreeView()) {
+            logger.error('Component Viewer: Component Viewer cannot be registered, abort activation');
+            return false;
+        }
         // Subscribe to debug tracker events to update active session
+        componentViewerLogger.debug('Subscribing to debug tracker events');
         this.subscribetoDebugTrackerEvents(tracker);
+        return true;
     }
 
-    protected registerTreeView(): void {
-        this._componentViewerTreeDataProvider = new ComponentViewerTreeDataProvider();
+    protected async registerTreeView(): Promise<boolean> {
+        if (!await vscodeViewExists('componentViewer')) {
+            return false;
+        }
         const treeProviderDisposable = vscode.window.registerTreeDataProvider('cmsis-debugger.componentViewer', this._componentViewerTreeDataProvider);
+        componentViewerLogger.debug('Component Viewer: Registered tree data provider for Component Viewer Tree View id: cmsis-debugger.componentViewer');
         const lockInstanceCommandDisposable = vscode.commands.registerCommand('vscode-cmsis-debugger.componentViewer.lockComponent', async (node) => {
             this.handleLockInstance(node);
         });
@@ -80,6 +91,7 @@ export class ComponentViewer {
             enablePeriodicUpdateCommandDisposable,
             disablePeriodicUpdateCommandDisposable
         );
+        return true;
     }
 
     protected handleLockInstance(node: ScvdGuiInterface): void {
@@ -112,7 +124,7 @@ export class ComponentViewer {
             this.schedulePendingUpdate('unlockingInstance');
             instance.dirtyWhileLocked = false;
         }
-        this._componentViewerTreeDataProvider?.refresh();
+        this._componentViewerTreeDataProvider.refresh();
     }
 
     protected async readScvdFiles(tracker: GDBTargetDebugTracker,session?: GDBTargetDebugSession): Promise<void> {
@@ -305,7 +317,7 @@ export class ComponentViewer {
 
     private async updateInstances(updateReason: UpdateReason): Promise<void> {
         if (!this._activeSession) {
-            this._componentViewerTreeDataProvider?.clear();
+            this._componentViewerTreeDataProvider.clear();
             return;
         }
         componentViewerLogger.debug(`Component Viewer: Queuing update due to '${updateReason}'`);
@@ -345,6 +357,6 @@ export class ComponentViewer {
             }
         }
         perf?.logSummaries();
-        this._componentViewerTreeDataProvider?.setRoots(roots);
+        this._componentViewerTreeDataProvider.setRoots(roots);
     }
 }