@alwaysai/device-agent 1.5.0 → 2.0.0

package/src/cloud-connection/transaction-manager.ts

@@ -1,12 +1,12 @@
 import {
-  StatusResponsePayload,
+  ToClientStatusResponseMessage,
   buildToClientStatusResponseMessage,
   keyMirrors
 } from '@alwaysai/device-agent-schemas';
 import { LiveUpdatesHandler } from './live-updates-handler';
 import { Publisher } from './publisher';
 import { logger } from '../util/logger';
-import { keyMirror } from 'alwaysai/lib/util';
+import { keyMirror, stringifyError } from 'alwaysai/lib/util';
 import { CodedError } from '@carnesen/coded-error';
 import { ShadowUpdate } from './shadow-handler';
 
@@ -26,11 +26,12 @@ export class TransactionManager {
   private liveUpdatesHandler: LiveUpdatesHandler;
   private publisher: Publisher;
 
-  private startTransaction(
+  private async startTransaction(
     txId: string,
     projectId: string,
+    liveUpdatesPublishFn?: () => Promise<void>,
     stepName?: string
-  ): void {
+  ): Promise<void> {
     // Check if the transaction already exists
     if (this.detailsByTx[txId]) {
       const txnDetails = this.detailsByTx[txId];
@@ -53,7 +54,7 @@ export class TransactionManager {
           null,
           2
         )}`,
-        this.Errors.PROJECT_ONGOING
+        this.Errors.PROJECT_TRANSACTION_ONGOING
       );
     }
 
@@ -67,10 +68,14 @@ export class TransactionManager {
     this.detailsByTx[txId] = txDetails;
     this.detailsByProject[projectId] = txDetails;
     logger.info(`Started transaction:\n${JSON.stringify(txDetails, null, 2)}`);
-    // send live updates
-    void this.liveUpdatesHandler.enableTransactionStatus({
-      txId
-    });
+
+    if (liveUpdatesPublishFn) {
+      await this.liveUpdatesHandler.enable(
+        keyMirrors.toClientMessageType.status_response,
+        liveUpdatesPublishFn,
+        txId
+      );
+    }
   }
 
   private updateTransaction(txId: string, stepName?: string): void {
@@ -95,7 +100,7 @@ export class TransactionManager {
 
   public Errors = keyMirror({
     TRANSACTION_ONGOING: null,
-    PROJECT_ONGOING: null,
+    PROJECT_TRANSACTION_ONGOING: null,
     TRANSACTION_NOT_ONGOING: null
   });
 
@@ -104,48 +109,49 @@ export class TransactionManager {
     projectId: string;
     txId: string;
     start: boolean;
+    liveUpdatesPublishFn?: () => Promise<void>;
     stepName?: string;
   }) {
-    const { func, projectId, txId, start, stepName } = props;
+    const { func, projectId, txId, start, liveUpdatesPublishFn, stepName } =
+      props;
     if (start) {
-      this.startTransaction(txId, projectId, stepName);
+      await this.startTransaction(
+        txId,
+        projectId,
+        liveUpdatesPublishFn,
+        stepName
+      );
     } else {
       this.updateTransaction(txId, stepName);
     }
     try {
       const completed = await func();
       if (completed) {
-        this.completeTransaction(txId);
-        const successStatusResponsePayload: StatusResponsePayload = {
-          status: keyMirrors.statusResponse.success
-        };
-        // Send final status message
-        const message = buildToClientStatusResponseMessage(
-          this.publisher.getClientId(),
-          successStatusResponsePayload,
-          txId
+        this.completeTransaction(
+          txId,
+          buildToClientStatusResponseMessage(
+            this.publisher.getClientId(),
+            { status: keyMirrors.statusResponse.success },
+            txId
+          )
         );
-        this.publisher.publishToClient(message);
       }
     } catch (e) {
-      const message: string = e.message;
       logger.error(
-        `Failed to execute cmd for ${projectId}:\n${message}\n${e.stack}`
+        `Failed to execute cmd for ${projectId}!\n${stringifyError(e)}`
       );
 
-      this.completeTransaction(txId);
-
-      const failureStatusResponsePayload: StatusResponsePayload = {
-        status: keyMirrors.statusResponse.failure,
-        message
-      };
-      // Send final status message
-      const failureStatusResponseMessage = buildToClientStatusResponseMessage(
-        this.publisher.getClientId(),
-        failureStatusResponsePayload,
-        txId
+      this.completeTransaction(
+        txId,
+        buildToClientStatusResponseMessage(
+          this.publisher.getClientId(),
+          {
+            status: keyMirrors.statusResponse.failure,
+            message: e.message
+          },
+          txId
+        )
       );
-      this.publisher.publishToClient(failureStatusResponseMessage);
     }
   }
 
@@ -184,7 +190,10 @@ export class TransactionManager {
       );
   }
 
-  public completeTransaction(txId: string): void {
+  public completeTransaction(
+    txId: string,
+    messageToPublish?: ToClientStatusResponseMessage
+  ): void {
     const txDetails = this.detailsByTx[txId];
     if (txDetails === undefined) {
       throw new CodedError(
@@ -199,8 +208,13 @@ export class TransactionManager {
     delete this.detailsByTx[txId];
     delete this.detailsByProject[txDetails.projectId];
 
-    void this.liveUpdatesHandler.disableTransactionStatus({
+    this.liveUpdatesHandler.disable(
+      keyMirrors.toClientMessageType.status_response,
       txId
-    });
+    );
+
+    if (messageToPublish) {
+      this.publisher.publishToClient(messageToPublish);
+    }
   }
 }

package/src/device-control/device-control.ts

@@ -4,9 +4,10 @@ import * as osu from 'node-os-utils';
 import * as si from 'systeminformation';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
 import { DeviceStatsPayload } from '@alwaysai/device-agent-schemas';
 import { getDeviceAgentVersion } from '../util/check-for-updates';
+import AaiError from '../util/aai-error';
 
 const exec_promise = promisify(exec);
 
@@ -14,63 +15,84 @@ const exec_promise = promisify(exec);
 export async function getCpuDetails(): Promise<
   DeviceStatsPayload['cpuDetails']
 > {
-  const cpuFree = await osu.cpu.free();
-  const cpuTemp = await si.cpuTemperature();
-  const cpuDetails: DeviceStatsPayload['cpuDetails'] = {};
-  if (cpuFree !== null) cpuDetails.usedPerc = 100 - cpuFree;
-  if (cpuTemp?.main !== null) cpuDetails.temperature = cpuTemp.main;
-  return cpuDetails;
+  let cpuFree, cpuTemp;
+  try {
+    [cpuFree, cpuTemp] = await Promise.all([
+      osu.cpu.free(),
+      si.cpuTemperature()
+    ]);
+  } catch (error) {
+    logger.error('Error fetching CPU details:', error);
+    return {};
+  }
+
+  return {
+    usedPerc: cpuFree !== null ? 100 - cpuFree : undefined,
+    temperature: cpuTemp?.main !== null ? cpuTemp.main : undefined
+  };
 }
 
 export async function getDiskDetails(): Promise<
   DeviceStatsPayload['diskDetails']
 > {
-  // Types incorrectly specify diskname as required instead of optional
-  // @ts-expect-error
-  const driveInfo = await osu.drive.info();
-  const diskDetails: DeviceStatsPayload['diskDetails'] = {};
-  if (driveInfo?.usedGb !== null)
-    diskDetails.usedGb = parseFloat(driveInfo.usedGb);
-  if (driveInfo?.freeGb !== null) {
-    diskDetails.freeGb = parseFloat(driveInfo.freeGb);
+  let driveInfo;
+  try {
+    // Types incorrectly specify diskname as required instead of optional
+    // @ts-expect-error
+    driveInfo = await osu.drive.info();
+  } catch (error) {
+    logger.error('Error fetching disk details:', error);
+    return {};
   }
-  return diskDetails;
+
+  return {
+    usedGb:
+      driveInfo?.usedGb !== null ? parseFloat(driveInfo.usedGb) : undefined,
+    freeGb:
+      driveInfo?.freeGb !== null ? parseFloat(driveInfo.freeGb) : undefined
+  };
 }
 
 export async function getMemDetails(): Promise<
   DeviceStatsPayload['memDetails']
 > {
-  const memInfo = await osu.mem.info();
-  const memDetails: DeviceStatsPayload['memDetails'] = {};
-  if (memInfo?.usedMemMb !== null) memDetails.usedMb = memInfo.usedMemMb;
-  if (memInfo?.freeMemMb !== null) memDetails.freeMb = memInfo.freeMemMb;
-  return memDetails;
+  let memInfo;
+  try {
+    memInfo = await osu.mem.info();
+  } catch (error) {
+    logger.error('Error fetching memory details:', error);
+    return {};
+  }
+  return {
+    usedMb: memInfo?.usedMemMb !== null ? memInfo.usedMemMb : undefined,
+    freeMb: memInfo?.freeMemMb !== null ? memInfo.freeMemMb : undefined
+  };
 }
 
-// System information
+// System information casted to a string
 export async function getOsInfo() {
   const osInfo = await si.osInfo();
   return {
-    platform: osInfo.platform,
-    distro: osInfo.distro,
-    release: osInfo.release,
-    kernel: osInfo.kernel,
-    architecture: osInfo.arch,
-    hostname: osInfo.hostname
+    platform: String(osInfo.platform),
+    distro: String(osInfo.distro),
+    release: String(osInfo.release),
+    kernel: String(osInfo.kernel),
+    architecture: String(osInfo.arch),
+    hostname: String(osInfo.hostname)
   };
 }
 
 export async function getCpuInfo() {
   const cpuInfo = await si.cpu();
   return {
-    manufacturer: cpuInfo.manufacturer,
-    brand: cpuInfo.brand,
-    vendor: cpuInfo.vendor,
-    model: cpuInfo.model,
-    cores: cpuInfo.cores,
-    physicalCores: cpuInfo.physicalCores,
-    efficiencyCores: cpuInfo.efficiencyCores,
-    processors: cpuInfo.processors
+    manufacturer: String(cpuInfo.manufacturer),
+    brand: String(cpuInfo.brand),
+    vendor: String(cpuInfo.vendor),
+    model: String(cpuInfo.model),
+    cores: String(cpuInfo.cores),
+    physicalCores: String(cpuInfo.physicalCores),
+    efficiencyCores: String(cpuInfo.efficiencyCores),
+    processors: String(cpuInfo.processors)
   };
 }
 
@@ -78,11 +100,11 @@ export async function getDiskInfo() {
   const diskInfo = await si.diskLayout();
   return {
     drives: diskInfo.map((drive) => ({
-      device: drive.device,
-      type: drive.type,
-      name: drive.name,
-      vendor: drive.vendor,
-      size: drive.size
+      device: String(drive.device),
+      type: String(drive.type),
+      name: String(drive.name),
+      vendor: String(drive.vendor),
+      size: String(drive.size)
     }))
   };
 }
@@ -90,14 +112,14 @@ export async function getDiskInfo() {
 export async function getDeviceInfo() {
   const deviceInfo = await si.system();
   return {
-    manufacturer: deviceInfo.manufacturer,
-    model: deviceInfo.model,
-    version: deviceInfo.version,
+    manufacturer: String(deviceInfo.manufacturer),
+    model: String(deviceInfo.model),
+    version: String(deviceInfo.version),
     serial:
       deviceInfo.serial && deviceInfo.serial !== '-'
-        ? deviceInfo.serial
+        ? String(deviceInfo.serial)
         : undefined,
-    virtual: deviceInfo.virtual
+    virtual: deviceInfo.virtual // this should be a boolean
   };
 }
 
@@ -108,9 +130,9 @@ export async function getNetworkInfo() {
     ? networkInterfaces.filter((iface: any) => iface.ip4 !== '127.0.0.1')[0]
     : networkInterfaces;
   return {
-    ipv4Address: defaultNetworkInterface.ip4,
-    ipv6Address: defaultNetworkInterface.ip6,
-    macAddress: defaultNetworkInterface.mac
+    ipv4Address: String(defaultNetworkInterface.ip4),
+    ipv6Address: String(defaultNetworkInterface.ip6),
+    macAddress: String(defaultNetworkInterface.mac)
   };
 }
 
@@ -123,9 +145,9 @@ export async function getDockerVersion() {
         args: ['info', '--format', 'json']
       })
     );
-    return result.ClientInfo.Version;
+    return String(result.ClientInfo.Version);
   } catch (e) {
-    logger.warn(`Cannot get Docker version: ${e}`);
+    logger.warn(`Cannot get Docker version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -138,7 +160,7 @@ export async function getDockerComposeVersion() {
       args: ['compose', 'version']
     });
   } catch (e) {
-    logger.warn(`Cannot get Docker Compose version: ${e}`);
+    logger.warn(`Cannot get Docker Compose version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -151,7 +173,7 @@ export async function getNpmVersion() {
       args: ['--version']
     });
   } catch (e) {
-    logger.warn(`Cannot get npm version: ${e}`);
+    logger.warn(`Cannot get npm version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -164,7 +186,7 @@ export async function getNodeVersion() {
       args: ['-v']
     });
   } catch (e) {
-    logger.warn(`Cannot get Node version: ${e}`);
+    logger.warn(`Cannot get Node version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -174,7 +196,6 @@ export async function getPackageVersions() {
   // eslint-disable-next-line
   const deviceAgentSchemasJson = require('../../node_modules/@alwaysai/device-agent-schemas/package.json');
 
-  // Concurrent asynchronous function call
   const [dockerVersion, dockerComposeVersion, nodeVersion, npmVersion] =
     await Promise.all([
       getDockerVersion(),
@@ -207,27 +228,39 @@ export async function getLastBootTime() {
 
     const tokens = latestBootStdout.trim().split(' ');
 
-    return new Date(`${tokens[2]} ${tokens[3]} ${tokens[4]}`);
+    return String(new Date(`${tokens[2]} ${tokens[3]} ${tokens[4]}`));
   } catch (e) {
-    logger.error(`Issue getting last boot time: ${e.message}`);
+    logger.error(`Issue getting last boot time!\n${stringifyError(e)}`);
     return undefined;
   }
 }
 
 export async function getSystemInformation(): Promise<SystemInformationShadowUpdate> {
   try {
+    const [os, cpu, disk, device, network, versions, lastBootTime] =
+      await Promise.all([
+        getOsInfo(),
+        getCpuInfo(),
+        getDiskInfo(),
+        getDeviceInfo(),
+        getNetworkInfo(),
+        getPackageVersions(),
+        getLastBootTime()
+      ]);
     const systemInfo: SystemInformationShadowUpdate = {
-      os: await getOsInfo(),
-      cpu: await getCpuInfo(),
-      disk: await getDiskInfo(),
-      device: await getDeviceInfo(),
-      network: await getNetworkInfo(),
-      versions: await getPackageVersions(),
-      lastBootTime: (await getLastBootTime())?.toString()
+      os,
+      cpu,
+      disk,
+      device,
+      network,
+      versions,
+      lastBootTime
     };
     return systemInfo;
   } catch (e) {
-    logger.error('There was a problem getting system information: ', e);
+    logger.error(
+      `There was a problem getting system information!\n${stringifyError(e)}`
+    );
   }
   return {};
 }
@@ -242,11 +275,10 @@ export async function reboot() {
       timeout: 5000
     });
     logger.info(result.stdout.trim());
-  } catch (err) {
-    throw new Error(
-      `Could not reboot device. You may need to add passwordless access to '/sbin/shutdown'. ${JSON.stringify(
-        err
-      )}`
+  } catch (e) {
+    throw new AaiError(
+      "Could not reboot device. You may need to add passwordless access to '/sbin/shutdown'.",
+      { cause: e }
     );
   }
 }

package/src/docker/docker-compose.ts

@@ -2,7 +2,7 @@ import * as DockerComposeV1 from 'docker-compose';
 import { v2 as DockerComposeV2 } from 'docker-compose';
 import { execSync } from 'child_process';
 import { logger } from '../util/logger';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
 
 let dockerCmd = 'docker';
 
@@ -14,11 +14,12 @@ export function importDockerCompose():
     logger.debug('Using Docker Compose V2.');
     return DockerComposeV2;
   } catch (e) {
+    // TODO: Log this error as well
     try {
       execSync('docker-compose -v').toString();
       logger.warn('Using docker-compose V1. Please consider updating to V2.');
     } catch (e) {
-      logger.warn(`Could not determine compose: ${e}`);
+      logger.warn(`Could not determine compose!\n${stringifyError(e)}`);
     }
   }
   dockerCmd = 'docker-compose';

package/src/infrastructure/agent-config.test.ts

@@ -1,7 +1,11 @@
+import { getDeviceConfigPath } from 'alwaysai/lib/infrastructure';
+import { join } from 'path';
 import * as tempy from 'tempy';
-import { AgentConfigFile } from './agent-config';
+import { AGENT_CONFIG_FILE_NAME, AgentConfigFile } from './agent-config';
 
-const configFile = AgentConfigFile(tempy.directory());
+const configFile = AgentConfigFile(
+  join(tempy.directory(), getDeviceConfigPath(), AGENT_CONFIG_FILE_NAME)
+);
 
 describe('Test Agent Config', () => {
   beforeEach(() => {

package/src/infrastructure/agent-config.ts

@@ -3,7 +3,8 @@ import {
   ConfigFileSchemaReturnType
 } from '@alwaysai/config-nodejs';
 import Ajv, { JSONSchemaType } from 'ajv';
-import { homedir } from 'os';
+import { getDeviceConfigPath } from 'alwaysai/lib/infrastructure';
+import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/paths';
 import { join } from 'path';
 
 export interface AppBackupConfig {
@@ -54,16 +55,16 @@ const schema: JSONSchemaType<AgentConfig> = {
 const ajv = new Ajv();
 const validateFunction = ajv.compile(schema);
 
-const ALWAYSAI_CONFIG_DIR = join(homedir(), '.config', 'alwaysai');
+export const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
 
-const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
-
-export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
-  const path = join(dir, AGENT_CONFIG_FILE_NAME);
+export function AgentConfigFile(filePath?: string) {
+  const path =
+    filePath ??
+    join(LOCAL_AAI_CFG_DIR, getDeviceConfigPath(), AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
     applications: []
   };
-  const configFile = ConfigFileSchema({
+  const configFile = ConfigFileSchema<AgentConfig>({
     path,
     validateFunction,
     initialValue

package/src/infrastructure/config-check-utility.test.ts

@@ -0,0 +1,154 @@
+import { DeviceConfig, DeviceConfigFile } from 'alwaysai/lib/core/device';
+import {
+  DEVICE_CONFIG_FILE_NAME,
+  DeviceCertificates,
+  getDeviceConfigPath
+} from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { join } from 'path';
+import { rimraf } from 'rimraf';
+import * as tempy from 'tempy';
+import {
+  checkAllFilesArePresent,
+  checkCertificatesPresent,
+  checkDeviceConfigPresent
+} from './config-check-utility';
+import { LegacyFiles } from './legacy-migration/legacy-files';
+
+class TestDeviceCertificates extends DeviceCertificates {
+  constructor(baseDir) {
+    super(baseDir);
+  }
+}
+
+describe('test requiredConfigFilesPresentAndValid', () => {
+  let tmpDir;
+
+  beforeEach(async () => {
+    tmpDir = tempy.directory();
+  });
+
+  afterEach(async () => {
+    await rimraf(tmpDir);
+    jest.clearAllMocks();
+  });
+
+  it('test checkAllFilesArePresent returns false in empty directory', async () => {
+    const legacyFiles = LegacyFiles(tmpDir);
+    const filesPresent = await checkAllFilesArePresent(
+      Object.values(legacyFiles.getLegacyFileMigrationPaths())
+    );
+    expect(filesPresent).toBe(false);
+  });
+
+  it('test device config present and valid, checkDeviceConfigPresent returns true', async () => {
+    // write device credentials data
+    const deviceCredentialsData: DeviceConfig = {
+      systemId: 'production',
+      deviceUuid: '123456-78-901-2345',
+      refreshToken: 'refresh',
+      accessToken: 'access',
+      idToken: 'id'
+    };
+    const spawner = JsSpawner({ path: tmpDir });
+    await spawner.mkdirp(join(tmpDir, getDeviceConfigPath()));
+    const filePath = join(
+      tmpDir,
+      getDeviceConfigPath(),
+      DEVICE_CONFIG_FILE_NAME
+    );
+    await spawner.writeFile(filePath, JSON.stringify(deviceCredentialsData));
+    const newConfigsPresent = await checkDeviceConfigPresent(tmpDir);
+    expect(newConfigsPresent).toBe(true);
+  });
+
+  it.each([
+    {
+      // invalid systemId
+      systemId: 'blah',
+      deviceUuid: '123456-78-901-2345',
+      refreshToken: 'refresh',
+      accessToken: 'access',
+      idToken: 'id'
+    },
+    {
+      // missing refreshToken
+      systemId: 'production',
+      deviceUuid: '123456-78-901-2345',
+      accessToken: 'access',
+      idToken: 'id'
+    },
+    {
+      // missing accessToken
+      systemId: 'development',
+      deviceUuid: '123456-78-901-2345',
+      refreshToken: 'refresh',
+      idToken: 'id'
+    },
+    {
+      // missing idToken
+      systemId: 'development',
+      deviceUuid: '123456-78-901-2345',
+      refreshToken: 'refresh'
+    }
+  ])(
+    'test device config has validation errors, checkDeviceConfigPresent returns false',
+    async (deviceCredentialsData) => {
+      const spawner = JsSpawner({ path: tmpDir });
+      await spawner.mkdirp(join(tmpDir, getDeviceConfigPath()));
+      const filePath = join(
+        tmpDir,
+        getDeviceConfigPath(),
+        DEVICE_CONFIG_FILE_NAME
+      );
+      await spawner.writeFile(filePath, JSON.stringify(deviceCredentialsData));
+      const deviceConfig = DeviceConfigFile(
+        join(tmpDir, getDeviceConfigPath(), DEVICE_CONFIG_FILE_NAME)
+      );
+      expect(deviceConfig.exists()).toBe(true);
+      const newConfigsPresent = await checkDeviceConfigPresent(tmpDir);
+      expect(newConfigsPresent).toBe(false);
+    }
+  );
+
+  it('test device config is missing, checkDeviceConfigPresent returns false', async () => {
+    const deviceConfig = DeviceConfigFile(
+      join(tmpDir, getDeviceConfigPath(), DEVICE_CONFIG_FILE_NAME)
+    );
+    expect(deviceConfig.exists()).toBe(false);
+    const newConfigsPresent = await checkDeviceConfigPresent(tmpDir);
+    expect(newConfigsPresent).toBe(false);
+  });
+
+  it('test empty certificates folder, checkCertificatesPresent returns false', async () => {
+    const certsPresent = await checkCertificatesPresent(tmpDir);
+    expect(certsPresent).toBe(false);
+  });
+
+  test('test full certificates folder, checkCertificatesPresent returns true', async () => {
+    // write certificates
+    const testCerts = new TestDeviceCertificates(tmpDir);
+    const spawner = JsSpawner({ path: tmpDir });
+    const certFilePath = testCerts.getCertificateDirectoryName();
+    await spawner.mkdirp(join(tmpDir, certFilePath));
+    await spawner.writeFile(
+      join(tmpDir, certFilePath, testCerts.getCertificateFileName()),
+      'certificate data'
+    );
+    console.log(
+      'join(tmpDir, certFilePath, testCerts.getCertificateFileName())',
+      join(tmpDir, certFilePath, testCerts.getCertificateFileName())
+    );
+    await spawner.writeFile(
+      join(tmpDir, certFilePath, testCerts.getPrivateKeyFileName()),
+      'private key data'
+    );
+    await spawner.writeFile(
+      join(tmpDir, certFilePath, testCerts.getRootCertificateFileName()),
+      'root cert data'
+    );
+
+    const certsPresent = await checkCertificatesPresent(tmpDir);
+    expect(certsPresent).toBe(true);
+  });
+});