@alwaysai/device-agent 1.5.0 → 2.0.1

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);
+  });
+});

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

@@ -0,0 +1,77 @@
+import { DeviceConfigFile } from 'alwaysai/lib/core/device';
+import {
+  DEVICE_CONFIG_FILE_NAME,
+  LocalAaiCfg,
+  LocalDeviceCertificates,
+  getDeviceConfigPath
+} from 'alwaysai/lib/infrastructure';
+import { exists, stringifyError } from 'alwaysai/lib/util';
+import { join } from 'path';
+import { logger } from '../util/logger';
+
+export const validConfigMessage = 'Device config is present and valid.';
+
+export async function checkDeviceConfigPresent(
+  baseDir?: string
+): Promise<boolean> {
+  logger.debug('Checking for required device configuraton file.');
+  const deviceConfig = DeviceConfigFile(
+    baseDir
+      ? join(baseDir, getDeviceConfigPath(), DEVICE_CONFIG_FILE_NAME)
+      : undefined
+  );
+  if (deviceConfig.exists()) {
+    try {
+      deviceConfig.read();
+      logger.debug(validConfigMessage);
+      return true;
+    } catch (e) {
+      logger.debug(stringifyError(e));
+      logger.debug(`${JSON.stringify(deviceConfig.getErrors(), null, 2)}`);
+    }
+  }
+  return false;
+}
+
+export async function checkCertificatesPresent(baseDir?: string) {
+  logger.debug('Checking for required certificates.');
+  const deviceCertificates = new LocalDeviceCertificates(baseDir);
+
+  const certificateFilesPresent = await checkAllFilesArePresent([
+    deviceCertificates.getCertificateFilePath(),
+    deviceCertificates.getPrivateKeyFilePath(),
+    deviceCertificates.getRootCertificateFilePath()
+  ]);
+  return certificateFilesPresent;
+}
+
+export async function checkAaiConfigPresent(
+  baseDir?: string
+): Promise<boolean> {
+  logger.debug('Checking for required alwaysai configuraton file.');
+  const localAaiCfg = new LocalAaiCfg(baseDir);
+
+  try {
+    await localAaiCfg.readAaiCfgFile();
+    logger.debug(validConfigMessage);
+    return true;
+  } catch (e) {
+    logger.debug(stringifyError(e));
+    logger.debug(
+      `${JSON.stringify(localAaiCfg.getValidationErrors(), null, 2)}`
+    );
+  }
+  return false;
+}
+
+export async function checkAllFilesArePresent(requiredFiles: string[]) {
+  for (const path of requiredFiles) {
+    logger.debug(`Checking if file ${path} is present`);
+    if (!(await exists(path))) {
+      logger.debug(`${path} not present.`);
+      return false;
+    }
+  }
+  logger.debug('All files are present');
+  return true;
+}

package/src/infrastructure/device-certificate.test.ts

@@ -0,0 +1,40 @@
+import {
+  LocalDeviceCertificates,
+  getDeviceConfigPath,
+  getLocalDeviceConfigDirectoryPath
+} from 'alwaysai/lib/infrastructure';
+import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/paths';
+import { join } from 'path';
+import {
+  getBootstrapCertificateDirectoryPath,
+  getBootstrapCertificateFileName,
+  getBootstrapIDFileName,
+  getBootstrapPrivateKeyFileName
+} from './device-certificate';
+
+describe('test different bootstrap certificate file paths', () => {
+  it('test bootstrap certificate directory paths and filenames', async () => {
+    const boostrapDir = getBootstrapCertificateDirectoryPath();
+    const mainConfigDir = getLocalDeviceConfigDirectoryPath();
+    const certificates = new LocalDeviceCertificates();
+    const mainCertDir = certificates.getCertificateDirectoryPath();
+    expect(mainConfigDir).toEqual(
+      join(LOCAL_AAI_CFG_DIR, getDeviceConfigPath())
+    );
+    expect(mainCertDir).toEqual(
+      join(LOCAL_AAI_CFG_DIR, getDeviceConfigPath(), 'certificates')
+    );
+    expect(boostrapDir).toEqual(join(mainCertDir, 'bootstrap-certificates'));
+
+    const boostrapCertFileName = getBootstrapCertificateFileName();
+    expect(boostrapCertFileName).toEqual('aai-claim-cert_prod.pem.crt');
+
+    const boostrapIDFileName = getBootstrapIDFileName();
+    expect(boostrapIDFileName).toEqual('aai-claim-cert-id_prod.txt');
+
+    const boostrapPrivateKeyFileName = getBootstrapPrivateKeyFileName();
+    expect(boostrapPrivateKeyFileName).toEqual(
+      'aai-claim-private-key_prod.pem.key'
+    );
+  });
+});

package/src/infrastructure/device-certificate.ts

@@ -0,0 +1,58 @@
+import {
+  DEVICE_CERTIFICATES_DIRECTORY_NAME,
+  getDeviceConfigPath,
+  getLocalDeviceConfigDirectoryPath
+} from 'alwaysai/lib/infrastructure';
+import { join } from 'path';
+import { shortenSystemId } from '../util/directories';
+
+/*===================================================================
+                    Bootstrap Certificates
+===================================================================*/
+
+export const BOOTSTRAP_DIR_NAME = 'bootstrap-certificates';
+
+export function getBootstrapPrivateKeyFileName() {
+  return `aai-claim-private-key_${shortenSystemId()}.pem.key`;
+}
+
+export function getBootstrapCertificateFileName() {
+  return `aai-claim-cert_${shortenSystemId()}.pem.crt`;
+}
+
+export function getBootstrapIDFileName() {
+  return `aai-claim-cert-id_${shortenSystemId()}.txt`;
+}
+
+export const CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME =
+  'certificate-ownership-token.txt';
+
+export function getBootstrapCertificateDirectoryPath(baseDir?) {
+  const LOCAL_DEVICE_DIRECTORY_PATH = baseDir
+    ? join(baseDir, getDeviceConfigPath())
+    : getLocalDeviceConfigDirectoryPath();
+  const bootstrapCertificateDirectoryPath = join(
+    LOCAL_DEVICE_DIRECTORY_PATH, // {homedir}/.config/alwaysai/device{systemId},
+    DEVICE_CERTIFICATES_DIRECTORY_NAME, // certificates
+    BOOTSTRAP_DIR_NAME // bootstrap-certificates
+  );
+  return bootstrapCertificateDirectoryPath;
+}
+
+export function getBootstrapPrivateKeyFilePath() {
+  return join(
+    getBootstrapCertificateDirectoryPath(),
+    getBootstrapPrivateKeyFileName()
+  );
+}
+
+export function getBootstrapCertificateFilePath() {
+  return join(
+    getBootstrapCertificateDirectoryPath(),
+    getBootstrapCertificateFileName()
+  );
+}
+
+export function getBootstrapIDFilePath() {
+  return join(getBootstrapCertificateDirectoryPath(), getBootstrapIDFileName());
+}

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

@@ -0,0 +1,88 @@
+import { ConfigFileSchemaReturnType } from '@alwaysai/config-nodejs/lib/config-file-schema';
+import {
+  AaiConfig,
+  DEVICE_CERTIFICATES_DIRECTORY_NAME
+} from 'alwaysai/lib/infrastructure';
+import {
+  ALWAYSAI_CONFIG_FILE_NAME,
+  DEVICE_TOKEN_FILE_NAME
+} from 'alwaysai/lib/paths';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { join } from 'path';
+import { rimraf } from 'rimraf';
+import * as tempy from 'tempy';
+import { AGENT_CONFIG_FILE_NAME } from '../agent-config';
+import {
+  LegacyAaiConfig,
+  LegacyAaiConfigFile,
+  LegacyFiles
+} from './legacy-files';
+
+describe('test LegacyFiles function', () => {
+  let tmpDir;
+  tmpDir = tempy.directory();
+
+  beforeAll(async () => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    tmpDir = tempy.directory();
+  });
+  afterAll(async () => {
+    await rimraf(tmpDir);
+  });
+
+  test('test LegacyAaiConfigFile', async () => {
+    const deviceId = '123-4567-8910-1234';
+    const systemId = 'production';
+    const aaiConfig: LegacyAaiConfig = {
+      systemId: systemId,
+      deviceUuid: deviceId
+    };
+    const spawner = JsSpawner({ path: tmpDir });
+    await spawner.writeFile(
+      join(tmpDir, ALWAYSAI_CONFIG_FILE_NAME),
+      JSON.stringify(aaiConfig)
+    );
+    const legacyAaiConfig = LegacyAaiConfigFile(tmpDir);
+    const parsedAaiConfig = legacyAaiConfig.read();
+    expect(parsedAaiConfig.deviceUuid).toEqual(deviceId);
+    expect(parsedAaiConfig.systemId).toEqual(systemId);
+  });
+
+  test('test invalid LegacyAaiConfigFile', async () => {
+    const deviceId = '123-4567-8910-1234';
+    const invalidAaiConfig = {
+      deviceUuid: deviceId
+    };
+    const spawner = JsSpawner({ path: tmpDir });
+    await spawner.writeFile(
+      join(tmpDir, ALWAYSAI_CONFIG_FILE_NAME),
+      JSON.stringify(invalidAaiConfig)
+    );
+    const legacyAaiConfig = LegacyAaiConfigFile(tmpDir);
+    expect(() => {
+      legacyAaiConfig.read();
+    }).toThrowError();
+  });
+
+  test('test LegacyFiles with baseDir return values', async () => {
+    const legacyFiles = LegacyFiles(tmpDir);
+    const filePath = legacyFiles.getFilePath();
+    expect(filePath).toBe(tmpDir);
+    const legacyCerts = legacyFiles.getLegacyCertificates();
+    expect(legacyCerts.getBaseCertificateDirectoryPath()).toBe(tmpDir);
+    const legacyMigrationFiles = legacyFiles.getLegacyFileMigrationPaths();
+    expect(legacyMigrationFiles.agentConfig).toEqual(
+      join(tmpDir, AGENT_CONFIG_FILE_NAME)
+    );
+    expect(legacyMigrationFiles.aaiConfig).toEqual(
+      join(tmpDir, ALWAYSAI_CONFIG_FILE_NAME)
+    );
+    expect(legacyMigrationFiles.credentialsConfig).toEqual(
+      join(tmpDir, DEVICE_TOKEN_FILE_NAME)
+    );
+    expect(legacyMigrationFiles.deviceCerts).toEqual(
+      join(tmpDir, DEVICE_CERTIFICATES_DIRECTORY_NAME)
+    );
+  });
+});

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

@@ -0,0 +1,101 @@
+import {
+  ConfigFileSchema,
+  ConfigFileSchemaReturnType
+} from '@alwaysai/config-nodejs';
+import Ajv, { JSONSchemaType } from 'ajv';
+import { SYSTEM_IDS, SystemId } from 'alwaysai/lib/constants';
+import { LocalLegacyDeviceCertificates } from 'alwaysai/lib/infrastructure';
+import {
+  ALWAYSAI_CONFIG_FILE_NAME,
+  DEVICE_TOKEN_FILE_NAME,
+  LOCAL_AAI_CFG_DIR
+} from 'alwaysai/lib/paths';
+import { join } from 'path';
+import { DEVICE_AGENT_CFG_DIR } from '../../util/directories';
+import { AGENT_CONFIG_FILE_NAME, AgentConfigFile } from '../agent-config';
+
+// alwaysai.config.json
+export const LEGACY_AAI_CONFIG_FILE_DIR = join(
+  LOCAL_AAI_CFG_DIR,
+  ALWAYSAI_CONFIG_FILE_NAME
+);
+
+export interface LegacyAaiConfig {
+  systemId: SystemId;
+  deviceUuid: string;
+}
+
+export const legacyAaiConfigSchema: JSONSchemaType<LegacyAaiConfig> = {
+  type: 'object',
+  properties: {
+    systemId: {
+      type: 'string',
+      enum: SYSTEM_IDS
+    },
+    deviceUuid: {
+      type: 'string'
+    }
+  },
+  required: ['systemId', 'deviceUuid']
+};
+
+const ajv = new Ajv();
+
+export const validateLegacyAaiConfig = ajv.compile(legacyAaiConfigSchema);
+
+export function LegacyAaiConfigFile(
+  baseDir?: string
+): ConfigFileSchemaReturnType<LegacyAaiConfig> {
+  const filePath = baseDir
+    ? join(baseDir, ALWAYSAI_CONFIG_FILE_NAME)
+    : LEGACY_AAI_CONFIG_FILE_DIR;
+  const configFile = ConfigFileSchema({
+    path: filePath,
+    validateFunction: validateLegacyAaiConfig
+  });
+
+  return configFile;
+}
+
+export function LegacyFiles(baseDir?: string) {
+  const filePath = baseDir ?? LOCAL_AAI_CFG_DIR;
+  const legacyCertificates = new LocalLegacyDeviceCertificates(filePath);
+  const legacyCredentialsFileDirPath = join(filePath, DEVICE_TOKEN_FILE_NAME);
+  const legacyCertificateDirPath =
+    legacyCertificates.getCertificateDirectoryPath();
+  const legacyAgentConfigFile = AgentConfigFile(
+    join(filePath, AGENT_CONFIG_FILE_NAME)
+  );
+  const legacyAaiCfgFileDirPath = join(filePath, ALWAYSAI_CONFIG_FILE_NAME);
+  const legacyAgentCfgFileDirPath = join(filePath, AGENT_CONFIG_FILE_NAME);
+  const legacyDeviceAgentCfgPath = join(filePath, DEVICE_AGENT_CFG_DIR);
+
+  return {
+    getFilePath() {
+      return filePath;
+    },
+    getLegacyAgentConfigFile() {
+      return legacyAgentConfigFile;
+    },
+    getLegacyCertificates() {
+      return legacyCertificates;
+    },
+    getLegacyDeviceAgentConfigDirPath() {
+      return legacyDeviceAgentCfgPath;
+    },
+    getLegacyFileMigrationPaths() {
+      return {
+        deviceCerts: legacyCertificateDirPath,
+        credentialsConfig: legacyCredentialsFileDirPath,
+        aaiConfig: legacyAaiCfgFileDirPath,
+        agentConfig: legacyAgentCfgFileDirPath
+      };
+    }
+  };
+}
+
+// alwaysai.credentials.json
+export const LEGACY_CREDENTIALS_FILE_DIR = join(
+  LOCAL_AAI_CFG_DIR,
+  DEVICE_TOKEN_FILE_NAME
+);