@alwaysai/device-agent 0.0.13 → 0.0.15

package/src/cloud-connection/shadow-handler.ts

@@ -7,7 +7,7 @@ import { logger } from '../util/logger';
 import { Publisher } from './publisher';
 import { AppConfigModels, getAppCfgModelsDiff } from './shadow';
 
-interface ShadowTopics {
+export interface ShadowTopics {
   projects: {
     update: string;
     get: string;
@@ -59,8 +59,9 @@ export class ShadowHandler {
       if (projectShadow.appConfig) {
         const newAppCfg = JSON.parse(projectShadow.appConfig);
         if (!validateAppConfig(newAppCfg)) {
+          // FIXME: Raise an exception to be handled at higher layer
           logger.error(
-            `Received invalid app config for ${projectId}!/n${JSON.stringify(
+            `Received invalid app config for ${projectId}!\n${JSON.stringify(
               validateAppConfig.errors,
               null,
               2
@@ -78,6 +79,10 @@ export class ShadowHandler {
         } else {
           appConfigUpdates.push({ projectId, newAppCfg });
         }
+      } else {
+        logger.warn(
+          `Ignoring shadow update for ${projectId} due to no app config`
+        );
       }
     }
     return appConfigUpdates;
@@ -96,6 +101,16 @@ export class ShadowHandler {
     const shadowName = topic.split('/')[5];
     switch (topic) {
       case this.shadowTopics.projects.updateDelta:
+        if (payload.clientToken === this.clientId) {
+          logger.debug(
+            `Ignoring message sent from self: ${JSON.stringify(
+              { topic, payload },
+              null,
+              2
+            )}`
+          );
+          break;
+        }
         return await this.handleNamedShadowUpdate({ delta: payload });
       case this.shadowTopics.projects.getAccepted:
         if (payload['delta']) {
@@ -143,12 +158,18 @@ export class ShadowHandler {
     );
   }
 
-  public deleteProjectShadow() {
+  public deleteProjectShadow(projectId: string) {
+    const packet = {
+      state: {
+        reported: {
+          [projectId]: null
+        }
+      },
+      clientToken: this.clientId
+    };
     this.publisher.publish(
-      `${this.shadowTopics.projects.delete}`,
-      JSON.stringify({
-        clientToken: this.clientId
-      })
+      this.shadowTopics.projects.update,
+      JSON.stringify(packet)
     );
   }
 }

package/src/environment.ts

@@ -8,8 +8,11 @@ export const ALWAYSAI_SHOW_HIDDEN = parseBoolean(
 );
 export const ALWAYSAI_DEVICE_AGENT_MODE =
   process.env.ALWAYSAI_DEVICE_AGENT_MODE;
-export const ALWAYSAI_LOG_LEVEL = process.env.AAI_LOG_LEVEL;
+export const ALWAYSAI_LOG_LEVEL = process.env.ALWAYSAI_LOG_LEVEL;
 export const ALWAYSAI_LOG_TO_CONSOLE = process.env.ALWAYSAI_LOG_TO_CONSOLE;
+export const ALWAYSAI_ANALYTICS_PASSTHROUGH = parseBoolean(
+  process.env.ALWAYSAI_ANALYTICS_PASSTHROUGH
+);
 
 function parseOsPlatform(str: string | undefined): NodeJS.Platform {
   switch (str) {

package/src/index.ts

@@ -19,8 +19,8 @@ if (module === require.main) {
   }
 
   if (ALWAYSAI_DEVICE_AGENT_MODE === 'cloud') {
-    runDeviceAgentCloudInterface();
+    void runDeviceAgentCloudInterface();
   } else {
-    runCliAndExit(root, {});
+    void runCliAndExit(root, {});
   }
 }

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

@@ -1,13 +1,6 @@
 import * as tempy from 'tempy';
 import { AgentConfigFile } from './agent-config';
 
-const mockAgentModeGetter = jest.fn().mockReturnValue(undefined);
-jest.mock('../environment', () => ({
-  get ALWAYSAI_DEVICE_AGENT_MODE() {
-    return mockAgentModeGetter();
-  }
-}));
-
 const configFile = AgentConfigFile(tempy.directory());
 
 describe('Test Agent Config', () => {

package/src/infrastructure/agent-config.ts

@@ -1,4 +1,7 @@
-import { ConfigFileSchema } from '@alwaysai/config-nodejs';
+import {
+  ConfigFileSchema,
+  ConfigFileSchemaReturnType
+} from '@alwaysai/config-nodejs';
 import Ajv, { JSONSchemaType } from 'ajv';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -55,7 +58,26 @@ const ALWAYSAI_CONFIG_DIR = join(homedir(), '.config', 'alwaysai');
 
 const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
 
-export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
+export interface AgentJsonFileReturnType
+  extends ConfigFileSchemaReturnType<AgentConfig> {
+  name: string;
+  getApps: () => Promise<InstalledAppConfig[]>;
+  getReadyApps;
+  getApp;
+  isAppPresent;
+  isAppReady;
+  removeApp;
+  setAppInstalling;
+  setAppInstalled;
+  setAppUninstalled;
+  getAppVersion;
+  setAppBackup;
+  getAppBackup;
+}
+
+export function AgentConfigFile(
+  dir = ALWAYSAI_CONFIG_DIR
+): AgentJsonFileReturnType {
   const path = join(dir, AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
     applications: []

package/src/infrastructure/system-id.ts

@@ -1,6 +1,6 @@
+import { SystemId } from 'alwaysai/lib/constants';
 import { DeviceConfigFile } from 'alwaysai/lib/core/device';
 import { ALWAYSAI_SYSTEM_ID } from 'alwaysai/lib/environment';
-import { SystemId } from 'alwaysai/lib/infrastructure';
 
 export function getSystemId() {
   if (ALWAYSAI_SYSTEM_ID) {

package/src/infrastructure/tokens-and-device-cfg.ts

@@ -1,23 +1,18 @@
-import {
-  DeviceTokens,
-  writeOrValidateDeviceCfgFile
-} from 'alwaysai/lib/components/device';
-import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
 import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/constants';
-import { checkPaidPlan } from 'alwaysai/lib/core/project';
-import { JsSpawner, writeTokens } from 'alwaysai/lib/util';
 import { logger } from '../util/logger';
 import { microServiceHttpClient } from '../util/http-client';
+import { requireLoggedInAndPaidPlan } from '../util/require-logged-in-and-paid-plan';
+import {
+  DeviceTokens,
+  writeOrValidateDeviceCfgFile,
+  writeTokens
+} from 'alwaysai/lib/core/device';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 // NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
 export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
   const { deviceUuid } = props;
-  await checkUserIsLoggedInComponent({ yes: true });
-  if (!(await checkPaidPlan())) {
-    throw new Error(
-      `This action only supported for Enterprise alwaysAI accounts!`
-    );
-  }
+  await requireLoggedInAndPaidPlan();
   const { accessToken, refreshToken, idToken } = await microServiceHttpClient(
     'token-service',
     'create-device-tokens',

package/src/local-connection/rabbitmq-connection.ts

@@ -0,0 +1,53 @@
+import { JsSpawner } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+import sleep from '../util/sleep';
+
+export async function checkRabbitMQContainerRunning() {
+  const spawner = JsSpawner();
+  return await spawner.run({
+    exe: 'docker',
+    args: ['ps', '-q', '--filter', 'ancestor=rabbitmq']
+  });
+}
+
+export async function setupRabbitMQContainer() {
+  const spawner = JsSpawner();
+  const rabbitMqContainerRunning = await checkRabbitMQContainerRunning();
+  logger.debug('Checking for running RabbitMQ container');
+  if (!rabbitMqContainerRunning) {
+    logger.debug('Setting up RabbitMQ container');
+    await spawner.run({
+      exe: 'docker',
+      args: [
+        'run',
+        '--rm',
+        '-p',
+        '5672:5672',
+        '-d',
+        '--hostname',
+        'my-rabbit',
+        'rabbitmq'
+      ]
+    });
+    await sleep(8000);
+    while (!(await checkRabbitMQContainerRunning())) {
+      await sleep(5000);
+    }
+  }
+}
+
+export async function stopRabbitMQContainer() {
+  const spawner = JsSpawner();
+  const rabbitMqContainer = await spawner.run({
+    exe: 'docker',
+    args: ['ps', '-q', '--filter', 'ancestor=rabbitmq']
+  });
+  if (!rabbitMqContainer) {
+    logger.debug('No RabbitMQ container running');
+  } else {
+    await spawner.run({
+      exe: 'docker',
+      args: ['stop', `${rabbitMqContainer}`]
+    });
+  }
+}

package/src/subcommands/app/app.ts

@@ -4,15 +4,13 @@ import {
   CliStringInput,
   CliTerseError
 } from '@alwaysai/alwayscli';
+import { ClientMessage, keyMirrors } from '@alwaysai/device-agent-schemas';
 import {
-  addModel,
   getAllEnvs,
   getAppLogs,
   getAppModels,
   getAppStatus,
-  installApp,
-  listAppLatestRelease,
-  listAppReleases,
+  readAppCfgFile,
   removeModel,
   replaceModels,
   restartApp,
@@ -20,11 +18,12 @@ import {
   setEnv,
   startApp,
   stopApp,
-  uninstallApp,
   updateModels
 } from '../../application-control';
+import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-cloud-connection';
 import { AgentConfigFile } from '../../infrastructure/agent-config';
 import { logger } from '../../util/logger';
+import sleep from '../../util/sleep';
 
 export const listAppsCliLeaf = CliLeaf({
   name: 'list',
@@ -45,10 +44,9 @@ export const listAppReleasesCliLeaf = CliLeaf({
       required: true
     })
   },
+  hidden: true,
   async action(_, opts) {
-    const { project } = opts;
-    const releaseHistory = await listAppReleases({ projectId: project });
-    logger.info(releaseHistory);
+    throw new CliTerseError('This command is yet currently implemented!');
   }
 });
 
@@ -61,15 +59,9 @@ export const listAppLatestReleaseCliLeaf = CliLeaf({
       required: true
     })
   },
+  hidden: true,
   async action(_, opts) {
-    const { project } = opts;
-    const latestReleaseHash = await listAppLatestRelease({
-      projectId: project
-    });
-    if (latestReleaseHash === undefined) {
-      throw new CliTerseError('This application has not been published yet');
-    }
-    logger.info(latestReleaseHash);
+    throw new CliTerseError('This command is yet currently implemented!');
   }
 });
 
@@ -82,19 +74,32 @@ export const installAppCliLeaf = CliLeaf({
       required: true
     }),
     releaseHash: CliStringInput({
-      description: 'Release Hash'
+      description: 'Release Hash',
+      required: true
     })
   },
   async action(_, opts) {
-    const project = opts.project;
-    let releaseHash = opts.releaseHash;
-    if (releaseHash === undefined) {
-      releaseHash = await listAppLatestRelease({ projectId: project });
+    const { project, releaseHash } = opts;
+    const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.setupHandlers();
+    const topic = deviceAgent.getToDeviceTopic();
+    const message: ClientMessage = {
+      timestamp: '',
+      topic,
+      payload: {
+        messageType: keyMirrors.clientMessageType.app_version_control,
+        appVersionControl: {
+          baseCommand: keyMirrors.appVersionControl.install,
+          projectId: project,
+          appReleaseHash: releaseHash
+        }
+      }
+    };
+    await deviceAgent.handleMessage(topic, message);
+    while (deviceAgent.isCmdInProgress(project)) {
+      await sleep(1000);
     }
-    if (releaseHash === undefined) {
-      throw new CliTerseError('This application has not been published yet');
-    }
-    await installApp({ projectId: project, appReleaseHash: releaseHash });
+    deviceAgent.stop();
   }
 });
 
@@ -110,7 +115,7 @@ export const getAppStatusCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project } = opts;
     const appStatus = await getAppStatus({ projectId: project });
-    logger.info(appStatus);
+    logger.info(JSON.stringify(appStatus, null, 2));
   }
 });
 
@@ -192,7 +197,25 @@ export const uninstallAppCliLeaf = CliLeaf({
   },
   async action(_, opts) {
     const { project } = opts;
-    await uninstallApp({ projectId: project });
+    const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.setupHandlers();
+    const topic = deviceAgent.getToDeviceTopic();
+    const message: ClientMessage = {
+      timestamp: '',
+      topic,
+      payload: {
+        messageType: keyMirrors.clientMessageType.app_version_control,
+        appVersionControl: {
+          baseCommand: keyMirrors.appVersionControl.uninstall,
+          projectId: project
+        }
+      }
+    };
+    await deviceAgent.handleMessage(topic, message);
+    while (deviceAgent.isCmdInProgress(project)) {
+      await sleep(1000);
+    }
+    deviceAgent.stop();
   }
 });
 
@@ -205,6 +228,7 @@ export const rollbackAppCliLeaf = CliLeaf({
       required: true
     })
   },
+  hidden: true,
   async action(_, opts) {
     const { project } = opts;
     await rollbackApp({ projectId: project });
@@ -238,11 +262,38 @@ export const addModelCliLeaf = CliLeaf({
     model: CliStringInput({
       description: 'Model ID',
       required: true
+    }),
+    version: CliStringInput({
+      description: 'Model version',
+      required: true
     })
   },
   async action(_, opts) {
-    const { project, model } = opts;
-    await addModel({ projectId: project, modelId: model });
+    const { project, model, version } = opts;
+    const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.setupHandlers();
+
+    const topic = deviceAgent.getShadowTopics().projects.updateDelta;
+
+    const newAppCfg = await readAppCfgFile({ projectId: project });
+    newAppCfg.models[model] = Number(version);
+
+    const message = {
+      version: 3,
+      timestamp: 0,
+      state: {
+        [project]: {
+          appConfig: JSON.stringify(newAppCfg)
+        }
+      },
+      clientToken: 'not-self'
+    };
+
+    await deviceAgent.handleMessage(topic, message);
+    while (deviceAgent.isCmdInProgress(project)) {
+      await sleep(1000);
+    }
+    deviceAgent.stop();
   }
 });
 
@@ -299,7 +350,7 @@ export const updateModelsCliLeaf = CliLeaf({
   }
 });
 
-export const getAllEnvsCLiLeaf = CliLeaf({
+export const getAllEnvsCliLeaf = CliLeaf({
   name: 'get-all-envs',
   description: 'Get environment variables for an application',
   namedInputs: {
@@ -314,7 +365,7 @@ export const getAllEnvsCLiLeaf = CliLeaf({
   }
 });
 
-export const setEnvCLiLeaf = CliLeaf({
+export const setEnvCliLeaf = CliLeaf({
   name: 'set-env',
   description: 'Set environment variables for a service',
   positionalInput: CliStringArrayInput({

package/src/subcommands/app/index.ts

@@ -16,8 +16,8 @@ import {
   restartAppCliLeaf,
   replaceModelsCliLeaf,
   showAppModelsCliLeaf,
-  getAllEnvsCLiLeaf,
-  setEnvCLiLeaf
+  getAllEnvsCliLeaf,
+  setEnvCliLeaf
 } from './app';
 
 export const appCliBranch = CliBranch({
@@ -40,7 +40,7 @@ export const appCliBranch = CliBranch({
     removeModelCliLeaf,
     replaceModelsCliLeaf,
     updateModelsCliLeaf,
-    getAllEnvsCLiLeaf,
-    setEnvCLiLeaf
+    getAllEnvsCliLeaf,
+    setEnvCliLeaf
   ]
 });

package/src/subcommands/device/clean.ts

@@ -1,5 +1,5 @@
 import { CliLeaf } from '@alwaysai/alwayscli';
-import * as rimraf from 'rimraf';
+import { rimraf } from 'rimraf';
 import { LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/constants';
 import { logger } from '../../util/logger';
 import { AgentConfigFile } from '../../infrastructure/agent-config';
@@ -12,15 +12,15 @@ export const cleanCliLeaf = CliLeaf({
   async action(_, opts) {
     logger.info('Cleaning device configuration');
     logger.debug(`Removing ${LOCAL_CERT_AND_KEY_DIR}`);
-    rimraf.sync(LOCAL_CERT_AND_KEY_DIR);
+    await rimraf(LOCAL_CERT_AND_KEY_DIR);
     logger.debug(`Removing ${AgentConfigFile().path}`);
     AgentConfigFile().remove();
     logger.debug(`Removing ${DeviceConfigFile().path}`);
     DeviceConfigFile().remove();
     logger.debug(`Removing ${CREDENTIALS_FILE_PATH}`);
-    rimraf.sync(CREDENTIALS_FILE_PATH);
+    await rimraf(CREDENTIALS_FILE_PATH);
     logger.debug(`Removing ${APP_ROOT}`);
-    rimraf.sync(APP_ROOT);
+    await rimraf(APP_ROOT);
     logger.info('Device configuration cleaned');
   }
 });

package/src/subcommands/device/device.ts

@@ -1,7 +1,5 @@
 import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
-import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
 import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
-import { checkPaidPlan } from 'alwaysai/lib/core/project';
 import { v4 as uuidv4 } from 'uuid';
 import { CliAuthenticationClient } from 'alwaysai/lib/infrastructure';
 import { existsSync } from 'fs';
@@ -9,7 +7,7 @@ import { httpClient, microServiceHttpClient } from '../../util/http-client';
 import {
   AWS_ROOT_CERTIFICATE_FILE_NAME,
   BOOTSTRAP_CERTIFICATES_DIR_PATH,
-  getPrivateKeyFilePath
+  DEVICE_PRIVATE_KEY_FILE_PATH
 } from '../../util/directories';
 
 import { LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/constants';
@@ -22,6 +20,7 @@ import {
 import { writeTokenAndDeviceCfg } from '../../infrastructure/tokens-and-device-cfg';
 import { logger } from '../../util/logger';
 import { DeviceConfigFile } from 'alwaysai/lib/core/device';
+import { requireLoggedInAndPaidPlan } from '../../util/require-logged-in-and-paid-plan';
 
 export const initCliLeaf = CliLeaf({
   name: 'init',
@@ -29,7 +28,7 @@ export const initCliLeaf = CliLeaf({
   namedInputs: {
     name: CliStringInput({
       description: 'Device name',
-      required: true
+      required: false
     }),
     description: CliStringInput({
       description: 'Device description',
@@ -37,19 +36,19 @@ export const initCliLeaf = CliLeaf({
     })
   },
   async action(_, opts) {
-    const { name, description } = opts;
-    if (DeviceConfigFile().exists() || existsSync(getPrivateKeyFilePath())) {
+    let { name } = opts;
+    name = name || uuidv4();
+
+    if (
+      DeviceConfigFile().exists() ||
+      existsSync(DEVICE_PRIVATE_KEY_FILE_PATH)
+    ) {
       throw new Error(
         "Device has been previously provisioned. Run 'aai-agent device clean' to re-provision"
       );
     }
     logger.info(`Initializing device ${name}`);
-    await checkUserIsLoggedInComponent({ yes: true });
-    if (!(await checkPaidPlan())) {
-      throw new Error(
-        `This action only supported for Enterprise alwaysAI accounts!`
-      );
-    }
+    await requireLoggedInAndPaidPlan();
     const { username } = await CliAuthenticationClient().getInfo();
     const hardwareId = await getTargetHardwareUuid(JsSpawner());
     const device = {
@@ -60,6 +59,7 @@ export const initCliLeaf = CliLeaf({
       friendlyName: name
     };
 
+    // FIXME: Use JSON schema to validate input
     const response: { deviceUuid: string; claimCertificate: string[] } =
       await microServiceHttpClient(
         'fleet-provision',
@@ -69,7 +69,7 @@ export const initCliLeaf = CliLeaf({
       );
     logger.debug(`addDevice Response: ${JSON.stringify(response, null, 2)}`);
 
-    if (!Object.hasOwn(response, 'claimCertificate')) {
+    if (!('claimCertificate' in response)) {
       throw new Error(
         "Device cannot be provisioned. Run 'aai-agent device clean' and retry."
       );

package/src/subcommands/login.ts

@@ -1,6 +1,5 @@
 import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
 import { alwaysaiUserLoginYesComponent } from 'alwaysai/lib/components/user';
-import { writeTokenAndDeviceCfg } from '../infrastructure/tokens-and-device-cfg';
 
 export const loginCliLeaf = CliLeaf({
   name: 'login',
@@ -13,21 +12,14 @@ export const loginCliLeaf = CliLeaf({
     password: CliStringInput({
       description: 'Account password',
       required: true
-    }),
-    device: CliStringInput({
-      description: 'The device UUID',
-      required: false
     })
   },
   async action(_, opts) {
-    const { email, password, device } = opts;
+    const { email, password } = opts;
 
     await alwaysaiUserLoginYesComponent({
       alwaysaiUserEmail: email,
       alwaysaiUserPassword: password
     });
-    if (device) {
-      await writeTokenAndDeviceCfg({ deviceUuid: device });
-    }
   }
 });

package/src/util/directories.ts

@@ -33,52 +33,54 @@ export const shortenSystemId = () => {
   }
 };
 
+/*===================================================================
+                    Bootstrap Certificates
+===================================================================*/
+
 export const BOOTSTRAP_DIR_NAME = 'bootstrap-certificates';
-export const BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_NAME = () =>
+export const BOOTSTRAP_PRIVATE_KEY_FILE_NAME = () =>
   `aai-claim-private-key_${shortenSystemId()}.pem.key`;
-export const BOOTSTRAP_DEVICE_CERTIFICATE_FILE_NAME = () =>
+export const BOOTSTRAP_CERTIFICATE_FILE_NAME = () =>
   `aai-claim-cert_${shortenSystemId()}.pem.crt`;
-export const BOOTSTRAP_CLAIM_ID_FILE_NAME = () =>
+export const BOOTSTRAP_ID_FILE_NAME = () =>
   `aai-claim-cert-id_${shortenSystemId()}.txt`;
 export const CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME =
   'certificate-ownership-token.txt';
-export const DEVICE_PRIVATE_KEY_FILE_NAME = () =>
-  `aai-claim-private-key_${shortenSystemId()}.pem.key`;
-export const DEVICE_CERTIFICATE_FILE_NAME = () =>
-  `aai-claim-cert_${shortenSystemId()}.pem.crt`;
-export const DEVICE_CLAIM_ID_FILE_NAME = () =>
-  `aai-claim-cert-id_${shortenSystemId()}.txt`;
-
-export function getPrivateKeyFilePath() {
-  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_PRIVATE_KEY_FILE_NAME());
-}
-
-export function getCertificateFilePath() {
-  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_CERTIFICATE_FILE_NAME());
-}
 
 export const BOOTSTRAP_CERTIFICATES_DIR_PATH = () =>
   join(LOCAL_CERT_AND_KEY_DIR, BOOTSTRAP_DIR_NAME);
-export const DEVICE_CLAIM_ID_FILE_PATH = () =>
-  join(LOCAL_CERT_AND_KEY_DIR, DEVICE_TOKEN_FILE_NAME);
 
-export const BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH = () =>
+export const BOOTSTRAP_PRIVATE_KEY_FILE_PATH = () =>
   join(
     LOCAL_CERT_AND_KEY_DIR,
     BOOTSTRAP_DIR_NAME,
-    BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_NAME()
+    BOOTSTRAP_PRIVATE_KEY_FILE_NAME()
   );
 
-export const BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH = () =>
+export const BOOTSTRAP_CERTIFICATE_FILE_PATH = () =>
   join(
     LOCAL_CERT_AND_KEY_DIR,
     BOOTSTRAP_DIR_NAME,
-    BOOTSTRAP_DEVICE_CERTIFICATE_FILE_NAME()
+    BOOTSTRAP_CERTIFICATE_FILE_NAME()
   );
 
-export const BOOTSTRAP_CLAIM_ID_FILE_PATH = () =>
-  join(
-    LOCAL_CERT_AND_KEY_DIR,
-    BOOTSTRAP_DIR_NAME,
-    BOOTSTRAP_CLAIM_ID_FILE_NAME()
-  );
+export const BOOTSTRAP_ID_FILE_PATH = () =>
+  join(LOCAL_CERT_AND_KEY_DIR, BOOTSTRAP_DIR_NAME, BOOTSTRAP_ID_FILE_NAME());
+
+/*===================================================================
+                      Device Certificates
+===================================================================*/
+
+export const DEVICE_PRIVATE_KEY_FILE_NAME = 'aai-device-private-key.pem.key';
+export const DEVICE_CERTIFICATE_FILE_NAME = 'aai-device-cert.pem.crt';
+export const DEVICE_ID_FILE_NAME = 'aai-device-cert-id.txt';
+
+export const DEVICE_PRIVATE_KEY_FILE_PATH = join(
+  LOCAL_CERT_AND_KEY_DIR,
+  DEVICE_PRIVATE_KEY_FILE_NAME
+);
+
+export const DEVICE_CERTIFICATE_FILE_PATH = join(
+  LOCAL_CERT_AND_KEY_DIR,
+  DEVICE_CERTIFICATE_FILE_NAME
+);