@alwaysai/device-agent 0.0.9 → 0.0.11

package/src/cloud-connection/device-agent-cloud-connection.ts

@@ -1,23 +1,32 @@
-const awsIot = require('aws-iot-device-sdk');
-import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
+const awsIot = require("aws-iot-device-sdk");
+import { getIoTCoreEndpointUrl } from "../infrastructure/urls";
+import { existsSync, createReadStream } from "fs";
 import {
   getPrivateKeyFilePath,
   getCertificateFilePath,
   getRootCertificateFilePath,
-} from '../util/directories';
-import sleep from '../util/sleep';
+  BOOTSTRAP_CLAIM_ID_FILE_PATH,
+  DEVICE_CLAIM_ID_FILE_PATH,
+  BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH,
+  BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
+  AWS_ROOT_CERTIFICATE_FILE_PATH,
+} from "../util/directories";
+
+import { BootstrapAgent } from "./device-agent";
+
+import sleep from "../util/sleep";
 import {
   startApp,
   stopApp,
   restartApp,
   getAppLogs,
   getAppStatus,
-} from '../application-control/status';
+} from "../application-control/status";
 import {
   getInstalledApps,
   installApp,
   uninstallApp,
-} from '../application-control/install';
+} from "../application-control/install";
 import {
   keyMirrors,
   validateClientMessage,
@@ -37,14 +46,22 @@ import {
   DeviceAgentMessage,
   ClientMessage,
   AppDetailsPacket,
-} from '@alwaysai/device-agent-schemas';
-import { getDeviceId } from '../util/get-device-id';
-import { JsSpawner, logger } from 'alwaysai/lib/util';
-import { getCpuUtil, getDiskUtil, getMemUtil } from '../device-control/device-control';
-import { AgentConfigFile } from '../infrastructure/agent-config';
-import { buildApp, getAppConfig, getAppDir } from '../application-control/utils';
-import { updateModelsWithPresignedUrls } from '../application-control/models';
-import { updateAppConfig } from '../application-control/config';
+} from "@alwaysai/device-agent-schemas";
+import { getDeviceId } from "../util/get-device-id";
+import { JsSpawner, logger } from "alwaysai/lib/util";
+import {
+  getCpuUtil,
+  getDiskUtil,
+  getMemUtil,
+} from "../device-control/device-control";
+import { AgentConfigFile } from "../infrastructure/agent-config";
+import {
+  buildApp,
+  getAppConfig,
+  getAppDir,
+} from "../application-control/utils";
+import { updateModelsWithPresignedUrls } from "../application-control/models";
+import { updateAppConfig } from "../application-control/config";
 
 export class DeviceAgentCloudConnection {
   private clientId = getDeviceId();
@@ -63,7 +80,7 @@ export class DeviceAgentCloudConnection {
     [keyMirrors.agentMessageType.app_install_status]: 5000,
   };
   private appLogStreams = new Set<string>();
-  private deviceType = 'aai-device';
+  private deviceType = "aai-device";
   private readonly shadowPrefix = `$aws/things/${this.clientId}/shadow/name/`;
   private readonly shadowTopics = {
     projects: {
@@ -71,9 +88,9 @@ export class DeviceAgentCloudConnection {
       getAccepted: `${this.shadowPrefix}projects/get/accepted`,
     },
   };
-  private readonly toCloudTopic = `topic/to_cloud/${this.deviceType}/${this.clientId}`;
-  private readonly toClientTopic = `topic/to_client/${this.deviceType}/${this.clientId}`;
-  private readonly toDeviceTopic = `topic/to_device/${this.deviceType}/${this.clientId}`;
+  private readonly toCloudTopic = `to-cloud/${this.deviceType}/${this.clientId}`;
+  private readonly toClientTopic = `to-client/${this.deviceType}/${this.clientId}`;
+  private readonly toDeviceTopic = `to-device/${this.deviceType}/${this.clientId}`;
 
   // device shadow utils
 
@@ -123,9 +140,9 @@ export class DeviceAgentCloudConnection {
     this.appLogStreams.add(projectId);
     const readable = await getAppLogs({
       projectId,
-      args: ['--tail', '100', '--no-log-prefix'],
+      args: ["--tail", "100", "--no-log-prefix"],
     });
-    readable.on('data', (chunk: Buffer) => {
+    readable.on("data", (chunk: Buffer) => {
       if (!this.appLogStreams.has(projectId)) {
         // why doesn't typescript know about this function?
         // @ts-ignore
@@ -144,16 +161,18 @@ export class DeviceAgentCloudConnection {
       const packet = this.buildMessagePacket(
         this.getClientId(),
         this.toClientTopic,
-        message,
+        message
       );
       this.publishMessage(this.toClientTopic, JSON.stringify(packet));
     });
 
-    readable.on('error', (error) => {
-      logger.error(`App log stream terminated for project ${projectId}: ${error}`);
+    readable.on("error", (error) => {
+      logger.error(
+        `App log stream terminated for project ${projectId}: ${error}`
+      );
     });
 
-    readable.on('finished', () => {
+    readable.on("finished", () => {
       logger.info(`App logs finished piping for project ${projectId}`);
     });
   }
@@ -164,7 +183,7 @@ export class DeviceAgentCloudConnection {
   }
 
   private updateAppInstallStatus(
-    installationStatus: Omit<AppInstallStatusPacket, 'appReleaseHash'>,
+    installationStatus: Omit<AppInstallStatusPacket, "appReleaseHash">
   ) {
     this.appInstallStatus.status = installationStatus.status;
     this.appInstallStatus.message = installationStatus.message;
@@ -178,7 +197,7 @@ export class DeviceAgentCloudConnection {
   private buildMessagePacket(
     deviceId: string,
     topic: string,
-    payload: DeviceAgentMessagePayload,
+    payload: DeviceAgentMessagePayload
   ): DeviceAgentMessage {
     const packet = {
       timestamp: new Date().toUTCString(),
@@ -221,27 +240,34 @@ export class DeviceAgentCloudConnection {
   }
 
   // must be arrow function due to this context when function is passed as param
-  private getAppInstallStatusMessage = async (): Promise<AppInstallStatusMessage> => {
-    const appInstallStatus = this.getAppInstallStatus();
-    const appInstallStatusMessage = {
-      messageType: keyMirrors.agentMessageType.app_install_status,
-      appInstallStatus,
+  private getAppInstallStatusMessage =
+    async (): Promise<AppInstallStatusMessage> => {
+      const appInstallStatus = this.getAppInstallStatus();
+      const appInstallStatusMessage = {
+        messageType: keyMirrors.agentMessageType.app_install_status,
+        appInstallStatus,
+      };
+      return appInstallStatusMessage;
     };
-    return appInstallStatusMessage;
-  };
 
   private async startPublishingLiveUpdates(
     topic: string,
     messageType: string,
-    getMessageData: () => Promise<DeviceAgentMessagePayload>,
+    getMessageData: () => Promise<DeviceAgentMessagePayload>
   ) {
     while (true) {
       try {
         const message = await getMessageData();
-        const packet = this.buildMessagePacket(this.getClientId(), topic, message);
+        const packet = this.buildMessagePacket(
+          this.getClientId(),
+          topic,
+          message
+        );
         this.publishMessage(topic, JSON.stringify(packet));
       } catch (e) {
-        logger.error(`Error publishing live updates for ${messageType}: ${e.message}`);
+        logger.error(
+          `Error publishing live updates for ${messageType}: ${e.message}`
+        );
         break;
       }
       if (!this.continuePublishing(messageType)) {
@@ -258,7 +284,10 @@ export class DeviceAgentCloudConnection {
       case keyMirrors.agentMessageType.app_state:
         return this.liveUpdatesAlive[flag];
       case keyMirrors.agentMessageType.app_install_status:
-        return this.appInstallStatus.status === keyMirrors.appInstallStatus.in_progress;
+        return (
+          this.appInstallStatus.status ===
+          keyMirrors.appInstallStatus.in_progress
+        );
       default:
         logger.error(`Unrecognized publishable flag ${flag}`);
         return false;
@@ -317,7 +346,9 @@ export class DeviceAgentCloudConnection {
         this.liveUpdatesBroker(message.liveUpdatesToggles);
         break;
       default:
-        logger.error(`Invalid agent action message type from message '${message}'`);
+        logger.error(
+          `Invalid agent action message type from message '${message}'`
+        );
     }
   }
 
@@ -352,7 +383,7 @@ export class DeviceAgentCloudConnection {
         this.startPublishingLiveUpdates(
           this.toClientTopic,
           keyMirrors.agentMessageType.device_stats,
-          this.getDeviceStatsMessage,
+          this.getDeviceStatsMessage
         );
       }
     }
@@ -363,7 +394,7 @@ export class DeviceAgentCloudConnection {
         this.startPublishingLiveUpdates(
           this.toClientTopic,
           keyMirrors.agentMessageType.app_state,
-          this.getAppStateMessage,
+          this.getAppStateMessage
         );
       }
     }
@@ -386,7 +417,10 @@ export class DeviceAgentCloudConnection {
         },
       },
     };
-    this.publishMessage(`${this.shadowPrefix}projects/update`, JSON.stringify(packet));
+    this.publishMessage(
+      `${this.shadowPrefix}projects/update`,
+      JSON.stringify(packet)
+    );
   }
 
   private async publishCloudRequest(payload: SignedUrlsRequestMessage) {
@@ -394,7 +428,7 @@ export class DeviceAgentCloudConnection {
     const deviceRequestPacket = this.buildMessagePacket(
       this.getClientId(),
       topic,
-      payload,
+      payload
     );
     this.publishMessage(topic, JSON.stringify({ deviceRequestPacket }));
   }
@@ -407,9 +441,10 @@ export class DeviceAgentCloudConnection {
     this.device = awsIot.device({
       keyPath: getPrivateKeyFilePath(),
       certPath: getCertificateFilePath(),
-      caPath: getRootCertificateFilePath(),
+      caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
       clientId: this.clientId,
       host: this.host,
+      port: 8883,
     });
 
     this.device.subscribe(this.toDeviceTopic);
@@ -423,7 +458,7 @@ export class DeviceAgentCloudConnection {
 
   public publishMessage(topic: string, message: string) {
     // TODO: topic validation
-    this.device.publish(topic, message);
+    this.device.publish(topic, message, (err: any) => {});
   }
 
   public async handleClientMessage({
@@ -448,8 +483,12 @@ export class DeviceAgentCloudConnection {
         break;
       }
       case keyMirrors.clientMessageType.app_install_cloud_response: {
-        const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } =
-          payload.appInstallCloudResponse;
+        const {
+          projectId,
+          appReleaseHash,
+          appInstallPayload,
+          modelsInstallPayload,
+        } = payload.appInstallCloudResponse;
 
         this.initAppInstallStatus({
           status: keyMirrors.appInstallStatus.in_progress,
@@ -459,7 +498,7 @@ export class DeviceAgentCloudConnection {
         this.startPublishingLiveUpdates(
           this.toClientTopic,
           keyMirrors.agentMessageType.app_install_status,
-          this.getAppInstallStatusMessage,
+          this.getAppInstallStatusMessage
         );
 
         // Install the app and models
@@ -480,7 +519,7 @@ export class DeviceAgentCloudConnection {
           // update app config shadow for project
           await this.publishReportedState(projectId);
         } catch (e) {
-          console.error(e);
+          logger.error(e);
           const message: string = e.message;
 
           // uninstall the failed app to put system back in good state
@@ -491,7 +530,7 @@ export class DeviceAgentCloudConnection {
           });
 
           // delete shadow for project
-          this.publishMessage(`${this.shadowPrefix}${projectId}/delete`, '');
+          this.publishMessage(`${this.shadowPrefix}${projectId}/delete`, "");
         }
         break;
       }
@@ -503,7 +542,7 @@ export class DeviceAgentCloudConnection {
 
           await this.publishReportedState(projectId);
         } catch (e) {
-          console.error(e);
+          logger.error(e);
         }
         break;
       }
@@ -512,8 +551,14 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  public async handleShadowTopic({ topic, payload }: { topic: string; payload: string }) {
-    const shadowName = topic.split('/')[5];
+  public async handleShadowTopic({
+    topic,
+    payload,
+  }: {
+    topic: string;
+    payload: string;
+  }) {
+    const shadowName = topic.split("/")[5];
     const message = JSON.parse(payload);
     if (topic === this.shadowTopics.projects.updateDelta) {
       this.handleNamedShadowUpdate({ payload });
@@ -523,45 +568,94 @@ export class DeviceAgentCloudConnection {
           payload: JSON.stringify(message.delta),
         });
       } else {
-        console.log(`No delta updates in shadow ${shadowName}`);
+        logger.info(`No delta updates in shadow ${shadowName}`);
       }
     }
   }
 }
 
-export function runDeviceAgentCloudInterface() {
-  const deviceAgent = new DeviceAgentCloudConnection();
+export async function runDeviceAgentCloudInterface() {
+  switch (existsSync(getCertificateFilePath())) {
+    case true:
+      {
+        const deviceAgent = new DeviceAgentCloudConnection();
 
-  deviceAgent.device.on('connect', function () {
-    deviceAgent.publishMessage('connection', deviceAgent.getClientId());
-    console.log('Device Agent has connected to the cloud');
+        deviceAgent.device.on("connect", function (connack: any) {
+          logger.info("Device Agent has connected to the cloud");
 
-    // Get shadow updates
-    deviceAgent.publishMessage(`${deviceAgent.getShadowPrefix()}projects/get`, '');
-  });
+          // Get shadow updates
+          deviceAgent.publishMessage(
+            `${deviceAgent.getShadowPrefix()}projects/get`,
+            ""
+          );
+        });
 
-  deviceAgent.device.on('disconnect', function () {
-    console.log('Device Agent has been disconnected from the cloud');
-  });
+        deviceAgent.device.on("disconnect", function () {
+          logger.info("Device Agent has been disconnected from the cloud");
+        });
 
-  deviceAgent.device.on('message', function (topic: string, payload: string) {
-    try {
-      const jsonPacket = JSON.parse(payload);
-      if (jsonPacket.hasOwnProperty('state')) {
-        deviceAgent.handleShadowTopic({
-          topic,
-          payload: JSON.stringify(jsonPacket.state),
+        deviceAgent.device.on(
+          "message",
+          function (topic: string, payload: string) {
+            console.log(topic);
+            console.log(JSON.parse(payload));
+            try {
+              const jsonPacket = JSON.parse(payload);
+              if (jsonPacket.hasOwnProperty("state")) {
+                deviceAgent.handleShadowTopic({
+                  topic,
+                  payload: JSON.stringify(jsonPacket.state),
+                });
+              } else {
+                const valid = validateClientMessage(jsonPacket);
+                if (!valid) {
+                  console.error(JSON.stringify(validateClientMessage.errors));
+                } else {
+                  deviceAgent.handleClientMessage({
+                    topic,
+                    message: jsonPacket,
+                  });
+                }
+              }
+            } catch (error) {
+              logger.error(error);
+            }
+          }
+        );
+
+        deviceAgent.device.on("packetsend", (packet: any) => {
+          //console.log({ packet: packet });
         });
-      } else {
-        const valid = validateClientMessage(jsonPacket);
-        if (!valid) {
-          console.error(JSON.stringify(validateClientMessage.errors));
-        } else {
-          deviceAgent.handleClientMessage({ topic, message: jsonPacket });
-        }
       }
-    } catch (error) {
-      console.error(error);
+
+      break;
+    case false: {
+      //set timer
+      const clientId = getDeviceId();
+      const bootstrapConfig = {
+        keyPath: BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
+        certPath: BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH,
+        caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
+        clientId,
+        host: getIoTCoreEndpointUrl(),
+      };
+
+      const bootstrapAgent = new BootstrapAgent(bootstrapConfig);
+      bootstrapAgent.subscribeToAllTopics();
+
+      bootstrapAgent.publishMessage("$aws/certificates/create/json", "");
+
+      bootstrapAgent.device.on("connect", () => {
+        console.log("Your device is being provisioned");
+      });
+
+      bootstrapAgent.device.on("message", (topic: string, payload: string) => {
+        bootstrapAgent.handleAwsCertificateTopics(topic, payload);
+      });
+
+      bootstrapAgent.device.on("packetsend", (packet: any) => {
+        console.log({ packet: packet.subscriptions });
+      });
     }
-  });
+  }
 }

package/src/cloud-connection/device-agent.ts

@@ -0,0 +1,122 @@
+const awsIot = require("aws-iot-device-sdk");
+import {
+  BOOTSTRAP_CLAIM_ID_FILE_NAME,
+  BOOTSTRAP_CLAIM_ID_FILE_PATH,
+  DEVICE_PRIVATE_KEY_FILE_NAME,
+  CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
+  DEVICE_CLAIM_ID_FILE_NAME,
+  DEVICE_CERTIFICATE_FILE_NAME,
+} from "../util/directories";
+import { getTargetHardwareUuid } from "../infrastructure/certificates-and-tokens";
+import { getDeviceId } from "../util/get-device-id";
+import { LOCAL_CERT_AND_KEY_DIR } from "alwaysai/lib/constants";
+import { JsSpawner } from "alwaysai/lib/util";
+import { logger } from "alwaysai/lib/util/logger";
+import { DeviceAgentCloudConnection } from "./device-agent-cloud-connection";
+const process = require("process");
+
+interface DeviceAgentConfigType {
+  keyPath: string;
+  certPath: string;
+  caPath: string;
+  clientId: string;
+  host: string;
+}
+
+interface FleetProvisionTemplateMessageType {
+  certificateOwnershipToken: String;
+  parameters: {
+    hardwareId: String;
+    deviceUuid: String;
+    certificateId: String;
+    deviceType: String;
+  };
+}
+
+export class DeviceAgent {
+  constructor(config: DeviceAgentConfigType) {
+    this.device = awsIot.device(config);
+  }
+
+  public deviceType = "aai-device";
+  public device = awsIot.device;
+  public hardwareId = async () => await getTargetHardwareUuid(JsSpawner());
+  public deviceId = getDeviceId();
+
+  public publishMessage(topic: string, message: string) {
+    this.device.publish(topic, message);
+  }
+}
+
+export class BootstrapAgent extends DeviceAgent {
+  public async subscribeToAllTopics() {
+    const AWS_CERTIFICATE_ACCEPT_TOPIC =
+      "$aws/certificates/create/json/accepted";
+    const PROVISIONING_ACCEPTED_TOPIC =
+      "$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted";
+
+    const topics = [AWS_CERTIFICATE_ACCEPT_TOPIC, PROVISIONING_ACCEPTED_TOPIC];
+    const resp = this.device.subscribe(
+      topics,
+      function (err: any, granted: { topic: string; qos: number }[]) {
+        logger.debug(granted);
+      }
+    );
+  }
+
+  public async handleAwsCertificateTopics(topic: string, payload: any) {
+    switch (topic) {
+      case "$aws/certificates/create/json/accepted": {
+        const {
+          certificateId,
+          certificatePem,
+          privateKey,
+          certificateOwnershipToken,
+        } = JSON.parse(payload);
+        console.log(certificateId);
+
+        const certSpawner = JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR });
+
+        await certSpawner.writeFile(
+          DEVICE_CERTIFICATE_FILE_NAME,
+          certificatePem
+        );
+
+        await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME, privateKey);
+
+        await certSpawner.writeFile(DEVICE_CLAIM_ID_FILE_NAME, certificateId);
+
+        await certSpawner.writeFile(
+          CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
+          certificateOwnershipToken
+        );
+
+        const content: FleetProvisionTemplateMessageType = {
+          certificateOwnershipToken,
+          parameters: {
+            hardwareId: await this.hardwareId(),
+            deviceUuid: this.deviceId,
+            certificateId,
+            deviceType: this.deviceType,
+          },
+        };
+        console.log(content);
+
+        this.publishMessage(
+          "$aws/provisioning-templates/FleetProvisionTemplate/provision/json",
+          JSON.stringify(content)
+        );
+
+        break;
+      }
+      case "$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted": {
+        console.log("success");
+        //  Resolve the `child_process` module, and `spawn`
+        //  a new process.
+        //  The `child_process` module lets us
+        //  access OS functionalities by running any bash command.`.
+        process.exit();
+      }
+    }
+  }
+}

package/src/endpoints.ts

@@ -0,0 +1,24 @@
+import { getSystemId } from "alwaysai/lib/infrastructure";
+
+export const getSecondLevelDomain = () => {
+  let domain = "";
+  switch (getSystemId()) {
+    case "development":
+      domain = "a6i0.net";
+      break;
+    case "qa":
+      domain = "a6i1.net";
+      break;
+    case "production":
+      domain = "alwaysai.co";
+      break;
+    default:
+      domain = "alwaysai.co";
+      break;
+  }
+  return domain;
+};
+
+export const serviceEndpointBuilder = (service: string, path: string) => {
+  return `https://${service}.${getSecondLevelDomain()}/${path}`;
+};

package/src/environment.ts

@@ -4,6 +4,7 @@ export const ALWAYSAI_OS_PLATFORM = parseOsPlatform(process.env.ALWAYSAI_OS_PLAT
 export const ALWAYSAI_SHOW_HIDDEN = parseBoolean(process.env.ALWAYSAI_SHOW_HIDDEN);
 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_TO_CONSOLE = process.env.ALWAYSAI_LOG_TO_CONSOLE;
 
 function parseOsPlatform(str: string | undefined): NodeJS.Platform {
   switch (str) {

package/src/index.ts

@@ -10,9 +10,10 @@ import { root } from './root';
 import { runDeviceAgentCloudInterface } from './cloud-connection/device-agent-cloud-connection';
 import { AgentConfigFile } from './infrastructure/agent-config';
 import { ALWAYSAI_DEVICE_AGENT_MODE } from './environment';
+import { logger } from './util/logger';
 
 if (module === require.main) {
-  console.log('Starting alwaysAI Device Agent');
+  logger.info('Starting alwaysAI Device Agent');
   if (!AgentConfigFile().exists()) {
     AgentConfigFile().initialize();
   }