feat: lazily init macadam (#409)

* feat: lazily init macadam when binaries are present or at creation time

* test: fix tests when binaries are installed

* test: add tests when binaries are not available

* test: add unit tests

Author: feloy

src/extension.spec.ts

@@ -49,6 +49,7 @@ vi.mock('@crc-org/macadam.js', async () => {
   Macadam.prototype.stopVm = vi.fn();
   Macadam.prototype.removeVm = vi.fn();
   Macadam.prototype.executeCommand = vi.fn();
+  Macadam.prototype.areBinariesAvailable = vi.fn();
   return { Macadam };
 });
 vi.mock('./macadam-machine-stream.js', async () => {
@@ -61,7 +62,7 @@ beforeEach(() => {
   vol.reset();
 });
 
-describe('activate', () => {
+describe.each([true, false])('activate when binaries availability is %s', binariesAvailable => {
   const extensionContext: extensionApi.ExtensionContext = {
     subscriptions: {
       push: vi.fn(),
@@ -77,11 +78,12 @@ describe('activate', () => {
 
   beforeEach(async () => {
     vi.mocked(extensionApi.provider.createProvider).mockReturnValue(provider);
+    vi.mocked(macadamJSPackage.Macadam.prototype.areBinariesAvailable).mockReturnValue(binariesAvailable);
   });
 
-  test('macadam library is initialized', async () => {
+  test('macadam library is initialized only if binaries are available', async () => {
     await activate(extensionContext);
-    expect(macadamJSPackage.Macadam.prototype.init).toHaveBeenCalled();
+    expect(macadamJSPackage.Macadam.prototype.init).toHaveBeenCalledTimes(binariesAvailable ? 1 : 0);
   });
 
   test('createCliTool is called and its result is added to subscriptions', async () => {
@@ -384,14 +386,14 @@ bla bla
         ]);
       });
 
-      test('listVms is called once', async () => {
+      test('listVms is called once', { skip: !binariesAvailable }, async () => {
         await activate(extensionContext);
         await vi.waitFor(() => {
           expect(macadamJSPackage.Macadam.prototype.listVms).toHaveBeenCalledWith({ containerProvider: 'applehv' });
         });
       });
 
-      test('registerVmProviderConnection is called once', async () => {
+      test('registerVmProviderConnection is called once', { skip: !binariesAvailable }, async () => {
         await activate(extensionContext);
         await vi.waitFor(() => {
           expect(provider.registerVmProviderConnection).toHaveBeenCalledOnce();
@@ -404,6 +406,18 @@ bla bla
         beforeEach(async () => {
           vi.mocked(provider.updateStatus).mockClear();
           await activate(extensionContext);
+
+          if (!binariesAvailable) {
+            expect(provider.setVmProviderConnectionFactory).toHaveBeenCalledOnce();
+            const call = vi.mocked(provider.setVmProviderConnectionFactory).mock.calls[0];
+            assert(!!call[0].create);
+            const create = call[0].create;
+            await create({
+              'rhel-vms.factory.machine.image': 'RHEL 10',
+              'rhel-vms.factory.machine.register': false,
+            });
+          }
+
           await vi.waitFor(() => {
             expect(provider.registerVmProviderConnection).toHaveBeenCalledOnce();
           });
@@ -520,6 +534,16 @@ bla bla
 
       test('listVms is called for each provider', async () => {
         await activate(extensionContext);
+        if (!binariesAvailable) {
+          expect(provider.setVmProviderConnectionFactory).toHaveBeenCalledOnce();
+          const call = vi.mocked(provider.setVmProviderConnectionFactory).mock.calls[0];
+          assert(!!call[0].create);
+          const create = call[0].create;
+          await create({
+            'rhel-vms.factory.machine.image': 'RHEL 10',
+            'rhel-vms.factory.machine.register': false,
+          });
+        }
         await vi.waitFor(() => {
           expect(macadamJSPackage.Macadam.prototype.listVms).toHaveBeenCalledTimes(2);
         });
@@ -566,6 +590,8 @@ describe('register', () => {
     vi.mocked(extensionApi.env).isWindows = false;
     vi.mocked(authentication.initAuthentication).mockResolvedValue(authClient);
 
+    vi.mocked(macadamJSPackage.Macadam.prototype.areBinariesAvailable).mockReturnValue(true);
+
     await activate(extensionContext);
     expect(provider.setVmProviderConnectionFactory).toHaveBeenCalledOnce();
     const call = vi.mocked(provider.setVmProviderConnectionFactory).mock.calls[0];

src/extension.ts

@@ -1,5 +1,5 @@
 /**********************************************************************
- * Copyright (C) 2025 Red Hat, Inc.
+ * Copyright (C) 2025 - 2026 Red Hat, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,6 +30,7 @@ import {
 } from './constants';
 import { getImageSha } from './images';
 import { LoggerDelegator } from './logger';
+import { MacadamInitializer } from './macadam-init';
 import { ProviderConnectionShellAccessImpl } from './macadam-machine-stream';
 import { getErrorMessage, pullImageFromRedHatRegistry, verifyContainerProivder } from './utils';
 import { isHyperVEnabled, isWSLEnabled } from './win/utils';
@@ -88,19 +89,26 @@ type MachineJSONListOutput = {
 };
 
 export let macadam: macadamJSPackage.Macadam;
+export let macadamInitializer: MacadamInitializer;
 
 export const macadamMachinesStatuses = new Map<string, extensionApi.ProviderConnectionStatus>();
 
 export async function activate(extensionContext: extensionApi.ExtensionContext): Promise<void> {
   macadam = new macadamJSPackage.Macadam('rhel');
-  await macadam.init();
+  macadamInitializer = new MacadamInitializer(macadam);
 
   const provider = await createProvider(extensionContext);
 
-  monitorMachines(provider, extensionContext).catch((error: unknown) => {
-    console.error('Error while monitoring machines', error);
+  macadamInitializer.onInitialized(() => {
+    monitorMachines(provider, extensionContext).catch((error: unknown) => {
+      console.error('Error while monitoring machines', error);
+    });
   });
 
+  if (macadam.areBinariesAvailable()) {
+    await macadamInitializer.init();
+  }
+
   // create cli tool for the cliTool page in desktop
   const macadamCli = extensionApi.cli.createCliTool({
     name: MACADAM_CLI_NAME,
@@ -464,6 +472,7 @@ async function createVM(
   logger?: extensionApi.Logger,
   token?: extensionApi.CancellationToken,
 ): Promise<void> {
+  await macadamInitializer.ensureInitialized();
   const telemetryRecords: Record<string, unknown> = {};
   if (extensionApi.env.isMac) {
     telemetryRecords.OS = 'mac';

src/macadam-init.spec.ts

@@ -0,0 +1,64 @@
+/**********************************************************************
+ * Copyright (C) 2026 Red Hat, Inc.
+ *
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+import type { Macadam } from '@crc-org/macadam.js';
+import { beforeEach, expect, test, vi } from 'vitest';
+
+import { MacadamInitializer } from './macadam-init';
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+test('init should initialize the macadam library', async () => {
+  const macadam: Macadam = {
+    init: vi.fn(),
+  } as unknown as Macadam;
+  const initializer = new MacadamInitializer(macadam);
+  expect(macadam.init).not.toHaveBeenCalled();
+  await initializer.init();
+  expect(macadam.init).toHaveBeenCalled();
+});
+
+test('ensureInitialized should initialize the macadam library only it is not initialized', async () => {
+  const macadam: Macadam = {
+    init: vi.fn(),
+  } as unknown as Macadam;
+  const initializer = new MacadamInitializer(macadam);
+
+  expect(macadam.init).not.toHaveBeenCalled();
+  await initializer.ensureInitialized();
+  expect(macadam.init).toHaveBeenCalled();
+
+  // should not be called again
+  vi.mocked(macadam.init).mockClear();
+  expect(macadam.init).not.toHaveBeenCalled();
+  await initializer.ensureInitialized();
+  expect(macadam.init).not.toHaveBeenCalled();
+});
+
+test('onInitialized should call the callback when the macadam library is initialized', async () => {
+  const macadam: Macadam = {
+    init: vi.fn(),
+  } as unknown as Macadam;
+  const initializer = new MacadamInitializer(macadam);
+  const callback = vi.fn();
+  initializer.onInitialized(callback);
+  await initializer.init();
+  expect(callback).toHaveBeenCalled();
+});

src/macadam-init.ts

@@ -0,0 +1,46 @@
+/**********************************************************************
+ * Copyright (C) 2026 Red Hat, Inc.
+ *
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+import { EventEmitter } from 'node:stream';
+
+import type { Macadam } from '@crc-org/macadam.js';
+
+const SIGNAL = 'emit';
+
+export class MacadamInitializer {
+  #onMacadamInit = new EventEmitter();
+  #initialized = false;
+
+  constructor(private readonly macadam: Macadam) {}
+
+  async init(): Promise<void> {
+    await this.macadam.init();
+    this.#initialized = true;
+    this.#onMacadamInit.emit(SIGNAL);
+  }
+
+  async ensureInitialized(): Promise<void> {
+    if (!this.#initialized) {
+      await this.init();
+    }
+  }
+
+  onInitialized(callback: () => void): void {
+    this.#onMacadamInit.on(SIGNAL, callback);
+  }
+}