Refactor RPC calls (#199)

* Refactor RPC calls

* file onDidCbuildCompleted

* common result data

* Run cbuild async

* Wire cbuild complete to solution ,anager

* Tests updates

* Add tests

* remove LoadPacks and getVersion calls from components-packs-webview-main.ts

* Improved getVersion + tests

* Update src/solutions/solution-problems.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Fix problems view

* Method renamed to reflect its purpose

* lock components-packs-webview-main.ts while converting

* Rearrange RPC calls

* add unit tests

* Notify statusbar when cbuild completed

* Remove triggerReload from ActiveSolutionTracker interface

* remove redundant mock, reuse existing one

* Update src/solutions/solution-manager.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Improve output messages and stop spin earlier

* Remove CompileCommandsGenerator interface, run cbuild asynchronously
Move severity calculation to solution-problems.ts

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: edriouk

src/desktop/extension.ts

@@ -32,7 +32,7 @@ import { getCreateSolutionFromDataManager } from '../solutions/create-solution-f
 import { DebugHardwareCommands } from '../solutions/hardware/debug-hardware-commands';
 import { TargetPackCommandImpl } from '../solutions/hardware/target-pack-command';
 import { ArmclangDefineGetter } from '../solutions/intellisense/armclang-define-getter';
-import { CompileCommandsGeneratorImpl } from '../solutions/intellisense/compile-commands-generator';
+import { CompileCommandsGenerator } from '../solutions/intellisense/compile-commands-generator';
 import { CompileCommandsParser } from '../solutions/intellisense/compile-commands-parser';
 import { SolutionLanguageFeaturesProvider } from '../solutions/language-features/solution-language-features-provider';
 import { ConvertMdkToCsolutionCommand } from '../solutions/mdk-conversion/convert-mdk-command';
@@ -170,14 +170,13 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
 
     const buildTaskProvider = new BuildTaskProviderImpl(buildRunner);
     const buildTaskDefinitionBuilder = new BuildTaskDefinitionBuilderImpl(solutionManager, configurationProvider);
-    const compileCommandsGenerator = new CompileCommandsGeneratorImpl(buildTaskProvider, buildTaskDefinitionBuilder);
+    const compileCommandsGenerator = new CompileCommandsGenerator(buildTaskProvider, buildTaskDefinitionBuilder, eventHub, outputChannelProvider);
 
     const solutionConverterImpl = new SolutionConverterImpl(
         eventHub,
         configurationProvider,
         outputChannelProvider,
         cmsisToolboxManager,
-        compileCommandsGenerator,
     );
 
     const solutionProblems = new SolutionProblemsImpl(solutionManager, eventHub);
@@ -221,7 +220,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
     const fileDecorationProviderManager = new FileDecorationProviderManagerImpl();
     const treeViewProviderImpl = new TreeViewProviderImpl(SolutionOutlineView.treeViewId);
     const treeViewFileDecorationProvider = new TreeViewFileDecorationProvider(fileDecorationProviderManager, themeProvider);
-    const mergeCommand = new MergeCommand(commandsProvider, activeSolutionTracker);
+    const mergeCommand = new MergeCommand(commandsProvider);
     const buildCommand = new BuildCommand(buildTaskProvider, commandsProvider, buildTaskDefinitionBuilder);
     const runGeneratorCommand = new GeneratorCommand(commandsProvider, solutionManager, outputChannelProvider, cmsisToolboxManager);
     const armclangDefineGetter = new ArmclangDefineGetter(processManager, workspaceFsProvider);
@@ -265,6 +264,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
         runGeneratorCommand.activate(context),
         convertMdkToCsolution.activate(context),
         solutionConverterImpl.activate(context),
+        compileCommandsGenerator.activate(context),
         solutionProblems.activate(context),
         clangdManager.activate(context),
         componentsManager.activate(context),

src/json-rpc/csolution-rpc-client.ts

@@ -9,7 +9,7 @@ import * as manifest from '../manifest';
 import { ChildProcess, spawn } from 'node:child_process';
 import { MessageConnection } from 'vscode-jsonrpc';
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from 'vscode-jsonrpc/node';
-import { RpcMethods, RpcInterface } from './interface/rpc-interface';
+import { RpcMethods, RpcInterface, GetVersionResult } from './interface/rpc-interface';
 import { constructor } from '../generic/constructor';
 import { Optional } from '../generic/type-helper';
 import { debounce } from 'lodash';
@@ -43,6 +43,7 @@ class CsolutionServiceImpl extends RpcMethods implements CsolutionService {
     private readonly debouncedLoadPacks = debounce(super.loadPacks.bind(this), 1000);
     private csolutionBin = 'csolution';
     private exitPromise: Promise<void> | undefined;
+    private cachedVersion: GetVersionResult = { success: false };
     private readonly mutex: Mutex;
 
     constructor(
@@ -71,10 +72,22 @@ class CsolutionServiceImpl extends RpcMethods implements CsolutionService {
         return (response ?? {}) as TResponse;
     }
 
+    public async getVersion(): Promise<GetVersionResult> {
+        if (!this.cachedVersion.success) {
+            // Query daemon version once per launched session
+            this.cachedVersion = await super.getVersion();
+            console.log('csolution version:', this.cachedVersion);
+        }
+        return this.cachedVersion;
+    }
+
     public async loadPacks() {
         if (this.idxWatcher === undefined) {
             this.watchPackIdxFile();
         }
+        // ensure version is cached
+        await this.getVersion();
+
         return super.loadPacks();
     }
 
@@ -131,6 +144,7 @@ class CsolutionServiceImpl extends RpcMethods implements CsolutionService {
         this.idxWatcher = undefined;
         this.connection?.dispose();
         this.connection = undefined;
+        this.cachedVersion = { success: false };
     }
 
     private async launch(): Promise<boolean> {

src/json-rpc/csolution-rpc-helper.test.ts

@@ -207,6 +207,66 @@ describe('csolution-rpc-client', () => {
         });
     });
 
+    describe('csolution-rpc-client getVersion cache', () => {
+        let service: AnyService;
+
+        beforeEach(() => {
+            service = createService();
+            service.cachedVersion = { success: false };
+        });
+
+        it('caches version after first request and reuses it', async () => {
+            const transceiveSpy = jest.spyOn(service as any, 'transceive')
+                .mockResolvedValue({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+
+            const first = await service.getVersion();
+            const second = await service.getVersion();
+
+            expect(first).toEqual({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+            expect(second).toEqual({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+            expect(transceiveSpy).toHaveBeenCalledTimes(1);
+            expect(transceiveSpy).toHaveBeenCalledWith('GetVersion', undefined);
+        });
+
+        it('resets cached version on terminate and fetches again on next getVersion', async () => {
+            const transceiveSpy = jest.spyOn(service as any, 'transceive')
+                .mockResolvedValue({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+
+            await service.getVersion();
+            expect(transceiveSpy).toHaveBeenCalledTimes(1);
+
+            // Simulate daemon termination lifecycle.
+            service.onTerminate();
+            expect(service.cachedVersion).toEqual({ success: false });
+
+            await service.getVersion();
+            expect(transceiveSpy).toHaveBeenCalledTimes(2);
+        });
+
+        it('primes version cache in loadPacks before LoadPacks RPC', async () => {
+            service.idxWatcher = { close: jest.fn() };
+            const sequence: string[] = [];
+
+            const transceiveSpy = jest.spyOn(service as any, 'transceive').mockImplementation(async (...args: unknown[]) => {
+                const method = String(args[0]);
+                sequence.push(method);
+                if (method === 'GetVersion') {
+                    return { success: true, version: '1.2.3', apiVersion: '0.0.9' };
+                }
+                if (method === 'LoadPacks') {
+                    return { success: true };
+                }
+                return { success: false };
+            });
+
+            await service.loadPacks();
+
+            expect(transceiveSpy).toHaveBeenCalledWith('GetVersion', undefined);
+            expect(transceiveSpy).toHaveBeenCalledWith('LoadPacks', undefined);
+            expect(sequence.indexOf('GetVersion')).toBeLessThan(sequence.indexOf('LoadPacks'));
+        });
+    });
+
 
     describe('csolution-rpc-client watchPackIdxFile', () => {
         let service: AnyService;

src/manifest.ts

@@ -46,6 +46,7 @@ export const CONFIG_AUTO_SHOW_CMSIS_VIEW = 'autoShowCMSISView';
 export const CONFIG_BUILD_OUTPUT_VERBOSITY = 'buildOutputVerbosity';
 export const MANAGE_COMPONENTS_PACKS_COMMAND_ID = `${PACKAGE_NAME}.manageComponentsPacks`;
 export const MERGE_FILE_COMMAND_ID = `${PACKAGE_NAME}.mergeFile`;
+export const REFRESH_COMMAND_ID = `${PACKAGE_NAME}.refresh`;
 export const RUN_GENERATOR_COMMAND_ID = `${PACKAGE_NAME}.runGenerator`;
 
 export const MIN_TOOLBOX_VERSION = '2.12.0';

src/solutions/active-solution-tracker.factories.ts

@@ -69,7 +69,6 @@ export const activeSolutionTrackerFactory = makeFactory<MockActiveSolutionTracke
     solutions: () => [],
     activate: () => jest.fn(),
     getSolutionDetails: () => jest.fn(),
-    triggerReload: (r) => jest.fn(() => r.onActiveSolutionFilesChangedEmitter?.fire()),
     suspendWatch: () => false,
     mockFireActiveSolutionFilesChanged: (r) => () => r.onActiveSolutionFilesChangedEmitter?.fire(),
 });

src/solutions/active-solution-tracker.ts

@@ -83,8 +83,6 @@ export interface ActiveSolutionTracker {
 
     getSolutionDetails(solutionPath: string): SolutionDetails;
 
-    triggerReload(): void;
-
     suspendWatch: boolean;
 }
 
@@ -297,7 +295,7 @@ export class ActiveSolutionTrackerImpl implements ActiveSolutionTracker {
         return this.configurationProvider.getConfigVariable<string>(manifest.CONFIG_EXCLUDE) || undefined;
     }
 
-    public triggerReload(): void {
+    private triggerReload(): void {
         this.activeSolutionFilesChangedEmitter.fire();
     }
 

src/solutions/clangd-manager.test.ts

@@ -69,7 +69,7 @@ describe('ClangdManagerTest', () => {
           Add:
             - '-DDEBUG'
         ---
-        If:  
+        If:
           PathMatch: 'Release'
         CompileFlags:
           CompilationDatabase: >-

src/solutions/clangd-manager.ts

@@ -92,7 +92,7 @@ export class ClangdManager {
 
     public async activate(context: ExtensionContext): Promise<void> {
         this.context = context;
-        this.solutionManager.onUpdatedCompileCommands(this.loadedBuildFiles, this, context.subscriptions);
+        this.solutionManager.onUpdatedCompileCommands(this.updateGlobalContext, this, context.subscriptions);
         this.configurationProvider.onChangeConfiguration(this.debouncedUpdateClangdConfig, CONFIG_CLANGD_GENERATE_SETUP);
         this.commandsProvider.registerCommand(ClangdManager.setClangdContextCommandId, this.setGlobalContext, this);
         this.commandsProvider.registerCommand(ClangdManager.unsetClangdContextCommandId, this.unsetGlobalContext, this);
@@ -181,7 +181,7 @@ export class ClangdManager {
         this.context?.workspaceState.update(clangDActiveContextKey, state);
     }
 
-    private loadedBuildFiles() {
+    private updateGlobalContext() {
         const csolution = this.solutionManager.getCsolution();
         const solutionPath = csolution?.solutionPath;
         if (!solutionPath) {

src/solutions/cmsis-toolbox.ts

@@ -180,8 +180,11 @@ export class CmsisToolboxManagerImpl implements CmsisToolboxManager {
             console.log(msg);
             onOutput(msg);
         }
-        // set 'packs' event flag when installing packs via 'cpackget add' command
-        this.runCmsisToolEmitter.fire([true, tool === 'cpackget' && args.includes('add')]);
+
+        if (tool !== 'cbuild') { // do not notify cbuild is started
+            // set 'packs' event flag when installing packs via 'cpackget add' command
+            this.runCmsisToolEmitter.fire([true, tool === 'cpackget' && args.includes('add')]);
+        }
 
         const [cmdMsg, returnCode] = await this.runCmd(
             toolCmd,

src/solutions/intellisense/compile-commands-generator.test.ts

@@ -17,22 +17,37 @@
 import { expect, it, describe } from '@jest/globals';
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { CompileCommandsGeneratorImpl } from './compile-commands-generator';
+import { CompileCommandsGenerator } from './compile-commands-generator';
 import { buildTaskDefinitionBuilderFactory, MockBuildTaskDefinitionBuilder } from '../../tasks/build/build-task-definition-builder.factories';
 import { BuildTaskDefinition } from '../../tasks/build/build-task-definition';
 import { BuildTaskProvider, BuildTaskProviderImpl } from '../../tasks/build/build-task-provider';
+import { SolutionEventHub } from '../solution-event-hub';
+import * as manifest from '../../manifest';
+import { MockOutputChannelProvider, outputChannelProviderFactory } from '../../vscode-api/output-channel-provider.factories';
+import { waitTimeout } from '../../__test__/test-waits';
 
 jest.mock('which', () => jest.fn((cmd) => Promise.resolve(path.join('path', 'to', cmd))));
 
 describe('CompileCommandsGenerator', () => {
-    let generator: CompileCommandsGeneratorImpl;
+    let generator: CompileCommandsGenerator;
     let mockBuildTaskProvider: BuildTaskProvider;
     let buildTaskDefinitionBuilder: MockBuildTaskDefinitionBuilder;
     let mockExecution: vscode.TaskExecution;
     let exitCode: number;
+    let mockEventHub: jest.Mocked<SolutionEventHub>;
+    let outputChannelProvider: MockOutputChannelProvider;
+    let cbuildSetupRequestedListener: (() => void) | undefined;
 
     beforeEach(async () => {
         exitCode = 0;
+        mockEventHub = {
+            fireCbuildCompleted: jest.fn().mockResolvedValue(undefined),
+            onDidCbuildSetupRequested: jest.fn((listener: () => void) => {
+                cbuildSetupRequestedListener = listener;
+                return { dispose: jest.fn() } as unknown as vscode.Disposable;
+            }),
+        } as unknown as jest.Mocked<SolutionEventHub>;
+        outputChannelProvider = outputChannelProviderFactory();
 
         const buildTaskDefinition: BuildTaskDefinition = {
             type: BuildTaskProviderImpl.taskType,
@@ -59,10 +74,13 @@ describe('CompileCommandsGenerator', () => {
                 return { dispose: jest.fn() } as unknown as vscode.Disposable;
             };
 
-        generator = new CompileCommandsGeneratorImpl(
+        generator = new CompileCommandsGenerator(
             mockBuildTaskProvider,
             buildTaskDefinitionBuilder,
+            mockEventHub,
+            outputChannelProvider,
         );
+        generator.activate({ subscriptions: [] } as unknown as vscode.ExtensionContext);
 
     });
 
@@ -71,18 +89,61 @@ describe('CompileCommandsGenerator', () => {
             getOutputBuffer: () => ['completed with exit code 0']
         });
         exitCode = 0;
-        const [result, output] = await generator.runCbuildSetup();
-        expect(result).toBe(true);
-        expect(output).toEqual(expect.arrayContaining(['completed with exit code 0']));
-    }, 10000);
+        cbuildSetupRequestedListener?.();
+        await waitTimeout();
+
+        const outputChannel = outputChannelProvider.mockGetCreatedChannelByName(manifest.CMSIS_SOLUTION_OUTPUT_CHANNEL);
+        expect(vscode.tasks.executeTask).toHaveBeenCalledTimes(1);
+        expect(outputChannel!.appendLine).toHaveBeenCalledWith('Launching cbuild setup in Terminal to generate IntelliSense database');
+        expect(mockEventHub.fireCbuildCompleted).toHaveBeenCalledWith({ success: true, severity: 'success', toolsOutputMessages: ['completed with exit code 0'] });
+    });
+
+    it('runs cbuild setup when cbuild setup request event is received', async () => {
+        (mockBuildTaskProvider.getActiveTaskRunner as jest.Mock).mockReturnValue({
+            getOutputBuffer: () => ['completed with exit code 0']
+        });
+        exitCode = 0;
+        cbuildSetupRequestedListener?.();
+        await waitTimeout();
+
+        expect(vscode.tasks.executeTask).toHaveBeenCalledTimes(1);
+    });
 
     it('prints an error message if the compilation database could not be generated', async () => {
         (mockBuildTaskProvider.getActiveTaskRunner as jest.Mock).mockReturnValue({
             getOutputBuffer: () => ['failed with exit code 1']
         });
         exitCode = 1;
-        const [result, output] = await generator.runCbuildSetup();
-        expect(result).toBe(false);
-        expect(output).toEqual(expect.arrayContaining(['failed with exit code 1']));
-    }, 10000);
+        cbuildSetupRequestedListener?.();
+        await waitTimeout();
+        expect(mockEventHub.fireCbuildCompleted).toHaveBeenCalledWith({ success: false, severity: 'error', toolsOutputMessages: ['failed with exit code 1'] });
+    });
+
+    it('reports warning severity when exit code is 0 but output contains warning pattern', async () => {
+        (mockBuildTaskProvider.getActiveTaskRunner as jest.Mock).mockReturnValue({
+            getOutputBuffer: () => ['warning cbuild: deprecated option', 'completed with exit code 0']
+        });
+        exitCode = 0;
+        cbuildSetupRequestedListener?.();
+        await waitTimeout();
+        expect(mockEventHub.fireCbuildCompleted).toHaveBeenCalledWith({
+            success: true,
+            severity: 'warning',
+            toolsOutputMessages: ['warning cbuild: deprecated option', 'completed with exit code 0']
+        });
+    });
+
+    it('reports error severity when exit code is 0 but output contains error pattern', async () => {
+        (mockBuildTaskProvider.getActiveTaskRunner as jest.Mock).mockReturnValue({
+            getOutputBuffer: () => ['error cbuild: failed to generate', 'completed with exit code 0']
+        });
+        exitCode = 0;
+        cbuildSetupRequestedListener?.();
+        await waitTimeout();
+        expect(mockEventHub.fireCbuildCompleted).toHaveBeenCalledWith({
+            success: true,
+            severity: 'error',
+            toolsOutputMessages: ['error cbuild: failed to generate', 'completed with exit code 0']
+        });
+    });
 });