@alwaysai/device-agent 1.5.0 → 2.0.1

package/src/infrastructure/legacy-migration/legacy-migration.test.ts

@@ -0,0 +1,396 @@
+import { device } from 'alwaysai/lib/components';
+import { SystemId } from 'alwaysai/lib/constants';
+import { DeviceConfigFile } from 'alwaysai/lib/core/device';
+import {
+  DEVICE_CONFIG_FILE_NAME,
+  LocalDeviceCertificates,
+  LocalLegacyDeviceCertificates,
+  getDeviceConfigPath
+} from 'alwaysai/lib/infrastructure';
+import {
+  ALWAYSAI_CONFIG_FILE_NAME,
+  DEVICE_TOKEN_FILE_NAME
+} from 'alwaysai/lib/paths';
+import { JsSpawner, exists } from 'alwaysai/lib/util';
+import exp from 'constants';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { rimraf } from 'rimraf';
+import * as tempy from 'tempy';
+import { AGENT_CONFIG_FILE_NAME, AgentConfigFile } from '../agent-config';
+import { checkAllFilesArePresent } from '../config-check-utility';
+import {
+  getBootstrapCertificateDirectoryPath,
+  getBootstrapCertificateFileName,
+  getBootstrapIDFileName,
+  getBootstrapPrivateKeyFileName,
+  getBootstrapPrivateKeyFilePath
+} from '../device-certificate';
+import { requiredConfigFilesPresentAndValid } from '../required-config-checks';
+import { LegacyFiles } from './legacy-files';
+import {
+  migrateAgentConfigFile,
+  migrateDeviceTokens,
+  migrateFromLegacyCertsAndTokens
+} from './legacy-migration';
+
+describe('test migrateFromLegacyCertsAndTokens function', () => {
+  let tmpDir;
+  tmpDir = tempy.directory();
+
+  beforeAll(async () => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    tmpDir = tempy.directory();
+  });
+  afterAll(async () => {
+    await rimraf(tmpDir);
+  });
+
+  async function setupCurrentFiles(spawner, aaiConfig, deviceConfig) {
+    await spawner.mkdirp(join(tmpDir, getDeviceConfigPath()));
+    await spawner.writeFile(
+      join(tmpDir, getDeviceConfigPath(), DEVICE_CONFIG_FILE_NAME),
+      JSON.stringify(deviceConfig)
+    );
+    spawner.writeFile(
+      join(tmpDir, ALWAYSAI_CONFIG_FILE_NAME),
+      JSON.stringify(aaiConfig)
+    );
+
+    const testCerts = new LocalDeviceCertificates(tmpDir);
+    const certFilePath = testCerts.getCertificateDirectoryName();
+    await spawner.mkdirp(join(tmpDir, getDeviceConfigPath(), certFilePath));
+    await spawner.writeFile(
+      join(
+        tmpDir,
+        getDeviceConfigPath(),
+        certFilePath,
+        testCerts.getCertificateFileName()
+      ),
+      'certificate data'
+    );
+    await spawner.writeFile(
+      join(
+        tmpDir,
+        getDeviceConfigPath(),
+        certFilePath,
+        testCerts.getPrivateKeyFileName()
+      ),
+      'private key data'
+    );
+    await spawner.writeFile(
+      join(
+        tmpDir,
+        getDeviceConfigPath(),
+        certFilePath,
+        testCerts.getRootCertificateFileName()
+      ),
+      'root cert data'
+    );
+  }
+
+  async function setupLegacyFiles(
+    spawner,
+    aaiConfig,
+    deviceConfig,
+    agentConfig
+  ) {
+    const testCerts = new LocalLegacyDeviceCertificates(tmpDir);
+    const certFilePath = testCerts.getCertificateDirectoryPath();
+    await spawner.mkdirp(certFilePath);
+    await spawner.writeFile(
+      join(tmpDir, DEVICE_TOKEN_FILE_NAME),
+      JSON.stringify(deviceConfig)
+    );
+    spawner.writeFile(
+      join(tmpDir, ALWAYSAI_CONFIG_FILE_NAME),
+      JSON.stringify(aaiConfig)
+    );
+    spawner.writeFile(
+      join(tmpDir, AGENT_CONFIG_FILE_NAME),
+      JSON.stringify(agentConfig)
+    );
+    await spawner.mkdirp(certFilePath);
+    await spawner.mkdirp(join(certFilePath, 'bootstrap-certificates'));
+    await spawner.writeFile(
+      join(testCerts.getCertificateFilePath()),
+      'certificate data'
+    );
+    await spawner.writeFile(
+      join(testCerts.getPrivateKeyFilePath()),
+      'private key data'
+    );
+    await spawner.writeFile(
+      join(testCerts.getRootCertificateFilePath()),
+      'root cert data'
+    );
+    await spawner.writeFile(
+      join(testCerts.getCertificateIdFilePath()),
+      'certificate ID data'
+    );
+    await spawner.writeFile(
+      join(
+        certFilePath,
+        'bootstrap-certificates',
+        getBootstrapCertificateFileName()
+      ),
+      'certificate data'
+    );
+    await spawner.writeFile(
+      join(
+        certFilePath,
+        'bootstrap-certificates',
+        getBootstrapPrivateKeyFileName()
+      ),
+      'private key data'
+    );
+    await spawner.writeFile(
+      join(certFilePath, 'bootstrap-certificates', getBootstrapIDFileName()),
+      'root cert data'
+    );
+  }
+
+  test('test current files present migration does not happen', async () => {
+    const spawner = JsSpawner({ path: tmpDir });
+    const legacyCredentialsConfig = {
+      deviceId: '123-4567-8910-1234',
+      refreshToken: 'refresh',
+      accessToken: 'access',
+      idToken: 'id'
+    };
+    const aaiConfig = {
+      systemId: SystemId.production,
+      deviceUuid: '123-4567-8910-1234'
+    };
+    // set up migrated/current configuration files
+    await setupCurrentFiles(spawner, legacyCredentialsConfig, aaiConfig);
+
+    const migrated = await migrateFromLegacyCertsAndTokens(tmpDir);
+
+    // check migration not called
+    expect(migrated).toBe(false);
+  });
+
+  test('test no legacy files migration does not happen', async () => {
+    const testCerts = new LocalDeviceCertificates(tmpDir);
+    const certFilePath = testCerts.getCertificateDirectoryName();
+
+    // check pre-conditions
+    expect(await exists(join(tmpDir, certFilePath))).toBe(false);
+    expect(await exists(join(tmpDir, DEVICE_CONFIG_FILE_NAME))).toBe(false);
+    expect(await exists(join(tmpDir, DEVICE_CONFIG_FILE_NAME))).toBe(false);
+
+    const migrated = await migrateFromLegacyCertsAndTokens(tmpDir);
+
+    // check migration not called
+    expect(migrated).toBe(false);
+  });
+
+  it('test legacy files present but invalid and no current files present migration does not happen', async () => {
+    const spawner = JsSpawner({ path: tmpDir });
+    const legacyCredentialsConfig = {
+      deviceId: '123-abcd-8910-1234',
+      refreshToken: 'refresh',
+      accessToken: 'access',
+      idToken: 'id'
+    };
+    const aaiConfig = {
+      systemId: SystemId.production,
+      deviceUuid: '123-4567-8910-1234'
+    };
+    const agentConfig = {
+      applications: []
+    };
+    // set up legacy files
+    await setupLegacyFiles(
+      spawner,
+      aaiConfig,
+      legacyCredentialsConfig,
+      agentConfig
+    );
+
+    // confirm legacy files present and valid
+    const legacyFiles = LegacyFiles(tmpDir);
+    const legacyFilePaths = legacyFiles.getLegacyFileMigrationPaths();
+    const legacyFilesPresent = await checkAllFilesArePresent(
+      Object.values(legacyFilePaths)
+    );
+    expect(legacyFilesPresent).toBe(true);
+
+    // confirm that an error is thrown when the deviceUuid !== deviceId
+    await expect(
+      migrateFromLegacyCertsAndTokens(tmpDir)
+    ).rejects.toThrowError();
+  });
+
+  it('test legacy files present and no current files present migration does happen', async () => {
+    const spawner = JsSpawner({ path: tmpDir });
+    const legacyCredentialsConfig = {
+      deviceId: '123-4567-8910-1234',
+      refreshToken: 'refresh',
+      accessToken: 'access',
+      idToken: 'id'
+    };
+    const aaiConfig = {
+      systemId: SystemId.production,
+      deviceUuid: '123-4567-8910-1234'
+    };
+    const agentConfig = {
+      applications: []
+    };
+    // set up legacy files
+    await setupLegacyFiles(
+      spawner,
+      aaiConfig,
+      legacyCredentialsConfig,
+      agentConfig
+    );
+
+    // check pre-conditions
+    // check that getBootstrapPrivateKeyFilePath() returns false so that
+    // bootstrapProvision won't be called on runDeviceAgentCloudInterface
+    const newBootstrapsDir = join(
+      getBootstrapCertificateDirectoryPath(tmpDir),
+      getBootstrapPrivateKeyFileName()
+    );
+    const newBootstrapsPresent = existsSync(newBootstrapsDir);
+    expect(newBootstrapsPresent).toBe(false);
+    // check no current files exist
+    const newFilesPresentPreMigrate = await requiredConfigFilesPresentAndValid(
+      tmpDir
+    );
+    expect(newFilesPresentPreMigrate).toBe(false);
+    // check that legacy files are present
+    const legacyFiles = LegacyFiles(tmpDir);
+    const legacyFilePaths = legacyFiles.getLegacyFileMigrationPaths();
+    const legacyFilesPresent = await checkAllFilesArePresent(
+      Object.values(legacyFilePaths)
+    );
+    expect(legacyFilesPresent).toBe(true);
+
+    const migrated = await migrateFromLegacyCertsAndTokens(tmpDir);
+
+    // check output -- current files are present and valid
+    expect(migrated).toBe(true);
+    const newFilesPresentPostMigrate = await requiredConfigFilesPresentAndValid(
+      tmpDir
+    );
+    expect(newFilesPresentPostMigrate).toBe(true);
+    // check that getBootstrapPrivateKeyFilePath() returns false so that
+    // bootstrapProvision won't be called on runDeviceAgentCloudInterface
+    const newBootstrapsDirAfterMigration = join(
+      getBootstrapCertificateDirectoryPath(tmpDir),
+      getBootstrapPrivateKeyFileName()
+    );
+    const newBootstrapsPresentAfterMigration = existsSync(
+      newBootstrapsDirAfterMigration
+    );
+    expect(newBootstrapsPresentAfterMigration).toBe(false);
+  });
+});
+
+describe('test migrateDeviceTokens function', () => {
+  let tmpDir;
+  tmpDir = tempy.directory();
+
+  beforeAll(async () => {
+    tmpDir = tempy.directory();
+  });
+  afterAll(async () => {
+    await rimraf(tmpDir);
+  });
+
+  it('test migrateDeviceTokens', async () => {
+    const deviceId = '123-4567-8910-1234';
+    const parsedConfig = {
+      systemId: SystemId.production,
+      deviceUuid: deviceId
+    };
+    const deviceConfig = {
+      deviceId: deviceId,
+      refreshToken: 'refresh',
+      accessToken: 'access',
+      idToken: 'id'
+    };
+
+    const spawner = JsSpawner({ path: tmpDir });
+    await spawner.mkdirp(join(tmpDir, getDeviceConfigPath()));
+    await spawner.writeFile(
+      join(tmpDir, DEVICE_TOKEN_FILE_NAME),
+      JSON.stringify(deviceConfig)
+    );
+    await migrateDeviceTokens(parsedConfig, tmpDir);
+    const newDeviceConfig = DeviceConfigFile(
+      join(tmpDir, getDeviceConfigPath(), DEVICE_CONFIG_FILE_NAME)
+    );
+    const parsedNewDeviceConfig = newDeviceConfig.read();
+    expect(parsedNewDeviceConfig.deviceUuid).toEqual(deviceId);
+    expect(parsedNewDeviceConfig.idToken).toEqual(deviceConfig.idToken);
+    expect(parsedNewDeviceConfig.accessToken).toEqual(deviceConfig.accessToken);
+    expect(parsedNewDeviceConfig.refreshToken).toEqual(
+      deviceConfig.refreshToken
+    );
+  });
+});
+
+describe('test migrateAgentConfigFile function', () => {
+  let tmpDir;
+  tmpDir = tempy.directory();
+
+  beforeAll(async () => {
+    tmpDir = tempy.directory();
+  });
+  afterAll(async () => {
+    await rimraf(tmpDir);
+  });
+
+  it('test migrateAgentConfigFile', async () => {
+    const newFilePath = join(
+      tmpDir,
+      getDeviceConfigPath(),
+      AGENT_CONFIG_FILE_NAME
+    );
+    const legacyFilePath = join(tmpDir, AGENT_CONFIG_FILE_NAME);
+    const spawner = JsSpawner({ path: tmpDir });
+    const legacyAgentConfigContents = {
+      applications: [
+        {
+          projectId: 'c8a1b5bd-e112-44e4-bfa4-fb9b42a4322c',
+          version:
+            'b0139ac93d91e8bd4bcb69575a7312c646f9af086b83364a3fe0b4472af04353',
+          ready: true
+        }
+      ]
+    };
+    await spawner.writeFile(
+      legacyFilePath,
+      JSON.stringify(legacyAgentConfigContents)
+    );
+    const legacyFileExists = await exists(legacyFilePath);
+    expect(legacyFileExists).toEqual(true);
+    const legacyAgentConfig = AgentConfigFile(
+      join(tmpDir, AGENT_CONFIG_FILE_NAME)
+    );
+    const legacyAgentConfigReadContents = legacyAgentConfig.read();
+    expect(legacyAgentConfigReadContents.applications).toEqual(
+      legacyAgentConfigContents.applications
+    );
+
+    const newFileExists = await exists(newFilePath);
+    expect(newFileExists).toEqual(false);
+
+    await migrateAgentConfigFile(tmpDir);
+
+    // confirm new file is valid
+    const newAgentConfig = AgentConfigFile(
+      join(tmpDir, getDeviceConfigPath(), AGENT_CONFIG_FILE_NAME)
+    );
+    const newAgentConfigContents = newAgentConfig.read();
+    expect(newAgentConfigContents.applications).toEqual(
+      legacyAgentConfigContents.applications
+    );
+    expect(newAgentConfig.path).toEqual(newFilePath);
+    expect(legacyFileExists).toEqual(true);
+  });
+});

package/src/infrastructure/legacy-migration/legacy-migration.ts

@@ -0,0 +1,229 @@
+import { DeviceConfig, DeviceConfigFile } from 'alwaysai/lib/core/device';
+import {
+  CredentialsJsonFile,
+  DEVICE_CONFIG_FILE_NAME,
+  LocalDeviceCertificates,
+  getDeviceConfigPath,
+  getSystemId
+} from 'alwaysai/lib/infrastructure';
+import {
+  ALWAYSAI_CONFIG_FILE_NAME,
+  DEVICE_TOKEN_FILE_NAME,
+  LOCAL_AAI_CFG_DIR
+} from 'alwaysai/lib/paths';
+import { JsSpawner, exists, stringifyError } from 'alwaysai/lib/util';
+import { join } from 'path';
+import rimraf from 'rimraf';
+import {
+  checkRabbitMQContainerRunning,
+  stopRabbitMQContainer
+} from '../../local-connection/rabbitmq-connection';
+import { copyDir } from '../../util/copy-dir';
+import {
+  getDeviceAgentConfigPath,
+  getDeviceAgentDockerComposePath
+} from '../../util/directories';
+import { logger } from '../../util/logger';
+import { AGENT_CONFIG_FILE_NAME, AgentConfigFile } from '../agent-config';
+import { checkAllFilesArePresent } from '../config-check-utility';
+import { getBootstrapCertificateDirectoryPath } from '../device-certificate';
+import { requiredConfigFilesPresentAndValid } from '../required-config-checks';
+import {
+  LEGACY_CREDENTIALS_FILE_DIR,
+  LegacyAaiConfig,
+  LegacyAaiConfigFile,
+  LegacyFiles
+} from './legacy-files';
+
+/*===================================================================
+                      Migration Code
+===================================================================*/
+
+export async function migrateAgentConfigFile(baseDir?: string) {
+  logger.debug('Migrating agent configuration file');
+  const legacyFiles = LegacyFiles(baseDir);
+  const legacyAgentConfigFile = legacyFiles.getLegacyAgentConfigFile();
+  const newAgentConfig = AgentConfigFile(
+    join(
+      baseDir ?? LOCAL_AAI_CFG_DIR,
+      getDeviceConfigPath(),
+      AGENT_CONFIG_FILE_NAME
+    )
+  );
+  let parsedAgentConfig;
+  try {
+    parsedAgentConfig = legacyAgentConfigFile.read();
+  } catch (e) {
+    logger.error(`Error reading agent config for:\n${stringifyError(e)}`);
+    logger.error(
+      `Agent Config Errors: ${JSON.stringify(
+        legacyAgentConfigFile.getErrors(),
+        null,
+        2
+      )}`
+    );
+    throw new Error(
+      `Could not parse ${legacyAgentConfigFile.path} while migrating your legacy device files.`
+    );
+  }
+  try {
+    newAgentConfig.write(parsedAgentConfig);
+
+    // since this file is owned by the Device Agent
+    // we can remove it after migrating it
+    await rimraf(legacyAgentConfigFile.path);
+  } catch (e) {
+    logger.error(`Error writing agent config for:\n${stringifyError(e)}`);
+    logger.error(
+      `Agent Config Errors: ${JSON.stringify(
+        newAgentConfig.getErrors(),
+        null,
+        2
+      )}`
+    );
+    throw new Error(
+      `Could not parse ${newAgentConfig.path} while migrating your legacy device files.`
+    );
+  }
+}
+
+export async function migrateCertificates(baseDir?: string) {
+  logger.debug(`baseDir ${baseDir}`);
+  const legacyFiles = LegacyFiles(baseDir);
+  const legacyCerts = legacyFiles.getLegacyCertificates();
+
+  const newDeviceCertificates = new LocalDeviceCertificates(
+    baseDir ? join(baseDir, getDeviceConfigPath()) : undefined
+  );
+  const spawner = JsSpawner(baseDir ? { path: baseDir } : {});
+  await spawner.mkdirp(
+    join(newDeviceCertificates.getCertificateDirectoryPath())
+  );
+  await copyDir({
+    srcPath: legacyCerts.getCertificateDirectoryPath(),
+    destPath: newDeviceCertificates.getCertificateDirectoryPath()
+  });
+  await rimraf(getBootstrapCertificateDirectoryPath(baseDir));
+}
+
+export async function migrateDeviceTokens(
+  parsedAaiCfg: LegacyAaiConfig,
+  baseDir?: string
+) {
+  const systemId = getSystemId();
+  const deviceConfigDir = baseDir
+    ? join(baseDir, getDeviceConfigPath(), DEVICE_CONFIG_FILE_NAME)
+    : baseDir;
+  const deviceConfig = DeviceConfigFile(deviceConfigDir);
+
+  const deviceUuid = parsedAaiCfg?.deviceUuid;
+  if (!deviceUuid) {
+    throw new Error(`deviceUuid not found in ${ALWAYSAI_CONFIG_FILE_NAME}.`);
+  }
+
+  let legacyCredentialsFile;
+  if (baseDir) {
+    legacyCredentialsFile = CredentialsJsonFile(
+      join(baseDir, DEVICE_TOKEN_FILE_NAME)
+    );
+  } else {
+    legacyCredentialsFile = CredentialsJsonFile(LEGACY_CREDENTIALS_FILE_DIR);
+  }
+  const legacyDeviceId = legacyCredentialsFile.getItem('deviceId');
+  const legacyTokens = {
+    accessToken: legacyCredentialsFile.getItem('accessToken'),
+    refreshToken: legacyCredentialsFile.getItem('refreshToken'),
+    idToken: legacyCredentialsFile.getItem('idToken')
+  };
+  const migratedTokens: DeviceConfig = {
+    ...legacyTokens,
+    systemId,
+    deviceUuid
+  };
+
+  if (legacyDeviceId !== migratedTokens.deviceUuid) {
+    throw new Error(
+      `deviceUuid from ${LEGACY_CREDENTIALS_FILE_DIR} (${legacyDeviceId}) and ${ALWAYSAI_CONFIG_FILE_NAME} (${migratedTokens.deviceUuid}) do not match.`
+    );
+  }
+
+  logger.debug('Copying tokens to new device config file.');
+  deviceConfig.write(migratedTokens);
+}
+
+export async function migrateFromLegacyCertsAndTokens(
+  baseDir?: string
+): Promise<boolean> {
+  const requiredConfiguration = await requiredConfigFilesPresentAndValid(
+    baseDir
+  );
+  if (requiredConfiguration) {
+    logger.debug(
+      'Device appears to be properly configured, no migration needed.'
+    );
+    return false;
+  }
+
+  const legacyFiles = LegacyFiles(baseDir);
+  const legacyFilePaths = legacyFiles.getLegacyFileMigrationPaths();
+  const legacyFilesPresent = await checkAllFilesArePresent(
+    Object.values(legacyFilePaths)
+  );
+  if (legacyFilesPresent) {
+    logger.debug(
+      'Legacy certs and config files found. Migrating device certs and config files to updated folders.'
+    );
+
+    // get device ID from original in order to pass to new AaiCfgFile
+    const aaiConfig = LegacyAaiConfigFile(baseDir);
+    let parsedAaiCfg;
+    try {
+      parsedAaiCfg = aaiConfig.read();
+    } catch (e) {
+      logger.error(`Error reading AAI config for:\n${stringifyError(e)}`);
+      logger.error(`${JSON.stringify(aaiConfig.getErrors(), null, 2)}`);
+      throw new Error(
+        `Could not parse ${aaiConfig.path} while migrating your legacy device files.`
+      );
+    }
+
+    // migrate deviceID to new alwaysai.device.json
+    await migrateDeviceTokens(parsedAaiCfg, baseDir);
+
+    // migrate certificates
+    logger.debug('Copying legacy certificates to new file path.');
+    await migrateCertificates(baseDir);
+
+    // migrate alwaysai.agent.json to device folder
+    logger.debug('Copying agent config file to new file path.');
+    await migrateAgentConfigFile(baseDir);
+
+    // if rabbitmq container is present, stop container and migrate files
+    try {
+      if (await checkRabbitMQContainerRunning()) {
+        await stopRabbitMQContainer();
+      }
+    } catch (e) {
+      logger.error(
+        `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
+      );
+      logger.debug(
+        `Error in checking / stopping RabbitMQ container!\n${stringifyError(e)}`
+      );
+    }
+    if (await exists(getDeviceAgentConfigPath(baseDir))) {
+      await copyDir({
+        srcPath: legacyFiles.getLegacyDeviceAgentConfigDirPath(),
+        destPath: getDeviceAgentConfigPath(baseDir)
+      });
+    }
+
+    // For now, do not remove the legacy files to support legacy edgeIQ
+
+    logger.debug(`Device certs and tokens migrated successfully from legacy.`);
+    return true;
+  }
+
+  logger.debug('No legacy cert or config files found. Skipping migration.');
+  return false;
+}

package/src/infrastructure/require-files-present-ready.test.ts

@@ -0,0 +1,53 @@
+import {
+  checkAaiConfigPresent,
+  checkCertificatesPresent,
+  checkDeviceConfigPresent
+} from './config-check-utility';
+import { requiredConfigFilesPresentAndValid } from './required-config-checks';
+
+const mockedDeviceCfgCheckFunction = jest.fn();
+const mockedCertCheckFunction = jest.fn();
+const mockedAaiCfgCheckFunction = jest.fn();
+
+jest.mock('./config-check-utility');
+
+jest
+  .mocked(checkAaiConfigPresent)
+  .mockImplementation(mockedAaiCfgCheckFunction);
+jest
+  .mocked(checkDeviceConfigPresent)
+  .mockImplementation(mockedDeviceCfgCheckFunction);
+jest
+  .mocked(checkCertificatesPresent)
+  .mockImplementation(mockedCertCheckFunction);
+
+describe('test requiredConfigFilesPresentAndValid', () => {
+  function setupMocks(mockDeviceCfgCheck, mockCertCheck, mockAaiCfgCheck) {
+    mockedDeviceCfgCheckFunction.mockResolvedValue(mockDeviceCfgCheck);
+    mockedCertCheckFunction.mockResolvedValue(mockCertCheck);
+    mockedAaiCfgCheckFunction.mockResolvedValue(mockAaiCfgCheck);
+  }
+
+  it('test return value when checkDeviceConfigPresent is false', async () => {
+    setupMocks(false, true, true);
+    const newConfigsPresent = await requiredConfigFilesPresentAndValid();
+    expect(newConfigsPresent).toBe(false);
+  });
+
+  it('test return value when checkCertificatesPresent is false', async () => {
+    setupMocks(true, false, false);
+    const newConfigsPresent = await requiredConfigFilesPresentAndValid();
+    expect(newConfigsPresent).toBe(false);
+  });
+
+  it('test return value when checkAaiConfigPresent is false', async () => {
+    setupMocks(true, true, false);
+    const newConfigsPresent = await requiredConfigFilesPresentAndValid();
+    expect(newConfigsPresent).toBe(false);
+  });
+
+  it('test return value when all included functions return true', async () => {
+    setupMocks(true, true, true);
+    expect(await requiredConfigFilesPresentAndValid()).toBe(true);
+  });
+});

package/src/infrastructure/required-config-checks.ts

@@ -0,0 +1,33 @@
+import { logger } from '../util/logger';
+import {
+  checkAaiConfigPresent,
+  checkCertificatesPresent,
+  checkDeviceConfigPresent
+} from './config-check-utility';
+
+export async function requiredConfigFilesPresentAndValid(baseDir?) {
+  // we need device/certificates, alwaysai.config.json, and device/alwaysai.device.json
+  logger.debug('Checking for required configuration files.');
+  const newDeviceConfigPresent = await checkDeviceConfigPresent(baseDir);
+  if (!newDeviceConfigPresent) {
+    logger.debug('Required device configuration is not present and valid.');
+    return false;
+  }
+
+  // check new certificates are present
+  const certificatesPresent = await checkCertificatesPresent(baseDir);
+  if (!certificatesPresent) {
+    logger.debug('Required certificates paths not found.');
+    return false;
+  }
+
+  // TODO: add alwaysai.config.json check here
+  const aaiConfigPresent = await checkAaiConfigPresent(baseDir);
+  if (!aaiConfigPresent) {
+    logger.debug('Required aai configuration file is not present and valid.');
+    return false;
+  }
+
+  logger.debug('All configuration files appear to be present.');
+  return true;
+}