@alwaysai/device-agent 0.0.14 → 0.0.16

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

@@ -3,11 +3,11 @@ const awsIot = require('aws-iot-device-sdk');
 import { getIoTCoreEndpointUrl } from '../infrastructure/urls';
 import { existsSync } from 'fs';
 import {
-  getPrivateKeyFilePath,
-  getCertificateFilePath,
-  BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
+  BOOTSTRAP_PRIVATE_KEY_FILE_PATH,
   AWS_ROOT_CERTIFICATE_FILE_PATH,
-  BOOTSTRAP_CERTIFICATES_DIR_PATH
+  BOOTSTRAP_CERTIFICATES_DIR_PATH,
+  DEVICE_PRIVATE_KEY_FILE_PATH,
+  DEVICE_CERTIFICATE_FILE_PATH
 } from '../util/directories';
 import {
   keyMirrors,
@@ -35,18 +35,17 @@ import { AppConfigUpdate, ShadowHandler, ShadowTopics } from './shadow-handler';
 import { Publisher } from './publisher';
 import { LiveUpdatesHandler } from './live-updates-handler';
 import { bootstrapProvision } from './bootstrap-provision';
-import { AppInstallStatusManager } from './app-install-status';
 import { AppConfig } from '@alwaysai/app-configuration-schemas';
-import { CmdStatusManager, CmdStatusType } from './cmd-status';
+import { CmdStatusManager } from './cmd-status';
 import { PassthroughHandler, runChannel } from './passthrough-handler';
 import { ALWAYSAI_ANALYTICS_PASSTHROUGH } from '../environment';
+import { getAppInstallStatusMessage } from './messages';
 
 export class DeviceAgentCloudConnection {
   private shadowHandler: ShadowHandler;
   public publisher: Publisher;
   private cmdStatusMgr: CmdStatusManager;
   private liveUpdatesHandler: LiveUpdatesHandler;
-  private appInstallStatusMgr: AppInstallStatusManager;
   private device = awsIot.device;
 
   private clientId = getDeviceUuid();
@@ -55,33 +54,43 @@ export class DeviceAgentCloudConnection {
   // FIXME: Add support for multiple simultaneous project updates
   private newAppCfgQueue: AppConfig[] = [];
 
-  private handleAppStateControl(payload: AppStateControlPacket) {
+  private async handleAppStateControl(payload: AppStateControlPacket) {
     const { baseCommand, projectId } = payload;
     switch (baseCommand) {
       case keyMirrors.appStateControl.start:
-        startApp({ projectId });
+        await startApp({ projectId });
         break;
       case keyMirrors.appStateControl.stop:
-        stopApp({ projectId });
+        await stopApp({ projectId });
         break;
       case keyMirrors.appStateControl.restart:
-        restartApp({ projectId });
+        await restartApp({ projectId });
         break;
     }
   }
 
-  private handleAppVersionControl(payload: AppVersionControlPacket) {
+  private async handleAppVersionControl(payload: AppVersionControlPacket) {
     switch (payload.baseCommand) {
       case keyMirrors.appVersionControl.install: {
         const { projectId, appReleaseHash } = payload;
-        this.cmdStatusMgr.update(projectId, 'in_progress');
+        await this.cmdStatusMgr.start(projectId);
+        await this.liveUpdatesHandler.enableAppInstallStatus({
+          projectId,
+          appReleaseHash
+        });
+
         const signedUrlsRequest = { projectId, appReleaseHash };
-        this.publishCloudRequest({
+        await this.publishCloudRequest({
           messageType: keyMirrors.agentMessageType.signed_urls_request,
           signedUrlsRequest
         });
         break;
       }
+      case keyMirrors.appVersionControl.uninstall: {
+        const { projectId } = payload;
+        await this.atomicApplicationUninstall(projectId);
+        break;
+      }
       default:
         logger.warn(
           `Ignore App Version Control packet: ${JSON.stringify(
@@ -97,10 +106,10 @@ export class DeviceAgentCloudConnection {
     // TODO
   };
 
-  private handleAgentCommand(message: LiveUpdatesToggleMessage) {
+  private async handleAgentCommand(message: LiveUpdatesToggleMessage) {
     switch (message.messageType) {
       case keyMirrors.clientMessageType.live_state_updates:
-        this.liveUpdatesHandler.update(message.liveUpdatesToggles);
+        await this.liveUpdatesHandler.handleToggles(message.liveUpdatesToggles);
         break;
       default:
         logger.error(
@@ -118,6 +127,49 @@ export class DeviceAgentCloudConnection {
     this.device.subscribe(topic);
   }
 
+  private async atomicApplicationUninstall(projectId: string) {
+    const appReleaseHash = await AgentConfigFile().getAppVersion({
+      projectId
+    });
+    await this.cmdStatusMgr.start(projectId);
+    await this.liveUpdatesHandler.enableAppInstallStatus({
+      projectId,
+      appReleaseHash
+    });
+    try {
+      await uninstallApp({ projectId });
+      this.shadowHandler.deleteProjectShadow(projectId);
+
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
+      });
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.success,
+          '',
+          appReleaseHash
+        )
+      );
+    } catch (e) {
+      logger.error(`Failed to uninstall ${projectId}: ${e}`);
+      const message: string = e.message;
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
+      });
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.failure,
+          message,
+          appReleaseHash
+        )
+      );
+    }
+  }
+
   // eslint-disable-next-line
   private async atomicApplicationUpdate<T extends any[], R extends any>(
     func: (...args: T) => R,
@@ -125,55 +177,67 @@ export class DeviceAgentCloudConnection {
     projectId: string,
     appReleaseHash: string
   ) {
-    this.appInstallStatusMgr.update(
-      appReleaseHash,
-      keyMirrors.appInstallStatus.in_progress
-    );
-
-    this.liveUpdatesHandler.update({
-      appInstallStatus: { toggle: true, appReleaseHash }
+    await this.cmdStatusMgr.start(projectId);
+    await this.liveUpdatesHandler.enableAppInstallStatus({
+      projectId,
+      appReleaseHash
     });
 
     // Install the app and models
     try {
       const out: R = await func(...args);
-      this.appInstallStatusMgr.update(
-        appReleaseHash,
-        keyMirrors.appInstallStatus.success
-      );
-      this.liveUpdatesHandler.update({
-        appInstallStatus: { toggle: false, appReleaseHash }
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
       });
-      this.cmdStatusMgr.update(projectId, 'idle');
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.success,
+          '',
+          appReleaseHash
+        )
+      );
 
       // update app config shadow for project
       await this.shadowHandler.publishAppState(projectId);
       return out;
     } catch (e) {
-      logger.error(e);
+      logger.error(`Failed to install ${projectId}: ${e}`);
       const message: string = e.message;
 
       // uninstall the failed app to put system back in good state
+      // TODO: Replace this with rollback
       await uninstallApp({ projectId });
-      this.appInstallStatusMgr.update(
-        appReleaseHash,
-        keyMirrors.appInstallStatus.failure,
-        message
-      );
-      this.liveUpdatesHandler.update({
-        appInstallStatus: { toggle: false, appReleaseHash }
-      });
-      this.cmdStatusMgr.update(projectId, 'idle');
-
-      // delete shadow for project
       this.shadowHandler.deleteProjectShadow(projectId);
+
+      await this.cmdStatusMgr.stop(projectId);
+      await this.liveUpdatesHandler.disableAppInstallStatus({
+        projectId
+      });
+      // Send final status message
+      this.publisher.publishToClient(
+        await getAppInstallStatusMessage(
+          keyMirrors.appInstallStatus.failure,
+          message,
+          appReleaseHash
+        )
+      );
     }
   }
 
-  private async handleAppConfigUpdates(appConfgUpdates: AppConfigUpdate[]) {
-    for (const appConfigUpdate of appConfgUpdates) {
+  private async handleAppConfigUpdates(appCfgUpdates: AppConfigUpdate[]) {
+    for (const appConfigUpdate of appCfgUpdates) {
       const { projectId, newAppCfg, updatedModels } = appConfigUpdate;
-      this.cmdStatusMgr.update(projectId, 'in_progress');
+      const appReleaseHash = await AgentConfigFile().getAppVersion({
+        projectId
+      });
+      await this.cmdStatusMgr.start(projectId);
+      await this.liveUpdatesHandler.enableAppInstallStatus({
+        projectId,
+        appReleaseHash
+      });
+
       if (updatedModels && Object.keys(updatedModels).length) {
         // Publish request for model urls
         this.newAppCfgQueue.push(newAppCfg);
@@ -213,12 +277,14 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  // Public Methods
+  /*=================================================================
+                            Public interface
+  =================================================================*/
 
   constructor() {
     this.device = awsIot.device({
-      keyPath: getPrivateKeyFilePath(),
-      certPath: getCertificateFilePath(),
+      keyPath: DEVICE_PRIVATE_KEY_FILE_PATH,
+      certPath: DEVICE_CERTIFICATE_FILE_PATH,
       caPath: AWS_ROOT_CERTIFICATE_FILE_PATH,
       clientId: this.clientId,
       host: this.host,
@@ -228,11 +294,7 @@ export class DeviceAgentCloudConnection {
     this.publisher = new Publisher(this.device, this.clientId);
     this.shadowHandler = new ShadowHandler(this.clientId, this.publisher);
     this.cmdStatusMgr = new CmdStatusManager();
-    this.appInstallStatusMgr = new AppInstallStatusManager();
-    this.liveUpdatesHandler = new LiveUpdatesHandler(
-      this.publisher,
-      this.appInstallStatusMgr
-    );
+    this.liveUpdatesHandler = new LiveUpdatesHandler(this.publisher);
 
     this.subscribe(this.toDeviceTopic);
     this.subscribe(this.shadowHandler.shadowTopics.projects.getAccepted);
@@ -251,8 +313,8 @@ export class DeviceAgentCloudConnection {
     return this.shadowHandler.shadowTopics;
   }
 
-  public getCmdStatus(projectId: string): CmdStatusType {
-    return this.cmdStatusMgr.getAppCmdStatus(projectId);
+  public isCmdInProgress(projectId: string): boolean {
+    return this.cmdStatusMgr.isCmdInProgress(projectId);
   }
 
   public async handleClientMessage({
@@ -276,15 +338,15 @@ export class DeviceAgentCloudConnection {
     const payload = message.payload;
     switch (payload.messageType) {
       case keyMirrors.clientMessageType.app_state_control: {
-        this.handleAppStateControl(payload.appStateControl);
+        await this.handleAppStateControl(payload.appStateControl);
         break;
       }
       case keyMirrors.clientMessageType.app_version_control: {
-        this.handleAppVersionControl(payload.appVersionControl);
+        await this.handleAppVersionControl(payload.appVersionControl);
         break;
       }
       case keyMirrors.clientMessageType.live_state_updates: {
-        this.handleAgentCommand(payload);
+        await this.handleAgentCommand(payload);
         break;
       }
       case keyMirrors.clientMessageType.app_install_cloud_response: {
@@ -349,6 +411,9 @@ export class DeviceAgentCloudConnection {
   }
 
   public async handleMessage(topic: string, message: ClientMessage | any) {
+    logger.debug(
+      `Received message: ${JSON.stringify({ topic, message }, null, 2)}`
+    );
     switch (topic) {
       case this.shadowHandler.shadowTopics.projects.getAccepted:
       case this.shadowHandler.shadowTopics.projects.updateDelta: {
@@ -360,7 +425,7 @@ export class DeviceAgentCloudConnection {
         break;
       }
       case this.toDeviceTopic:
-        this.handleClientMessage({
+        await this.handleClientMessage({
           topic,
           message
         });
@@ -395,9 +460,6 @@ export class DeviceAgentCloudConnection {
     this.device.on('message', async (topic: string, payload: string) => {
       try {
         const jsonPacket = JSON.parse(payload);
-        logger.debug(
-          `Received message: ${JSON.stringify({ topic, jsonPacket }, null, 2)}`
-        );
         await this.handleMessage(topic, jsonPacket);
       } catch (error) {
         logger.error(`Error parsing message: ${error}`);
@@ -416,17 +478,17 @@ export class DeviceAgentCloudConnection {
 
 export async function runDeviceAgentCloudInterface() {
   // FIXME: Check for KeyPath as well
-  if (existsSync(getCertificateFilePath())) {
+  if (existsSync(DEVICE_CERTIFICATE_FILE_PATH)) {
     const deviceAgent = new DeviceAgentCloudConnection();
     await deviceAgent.setupHandlers();
     if (ALWAYSAI_ANALYTICS_PASSTHROUGH === true) {
       const publisher = deviceAgent.publisher;
       const passthroughHandler = new PassthroughHandler(publisher);
       await passthroughHandler.setup();
-      runChannel(passthroughHandler);
+      await runChannel(passthroughHandler);
     }
-  } else if (existsSync(BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH())) {
-    bootstrapProvision();
+  } else if (existsSync(BOOTSTRAP_PRIVATE_KEY_FILE_PATH())) {
+    await bootstrapProvision();
   } else if (existsSync(BOOTSTRAP_CERTIFICATES_DIR_PATH())) {
     throw new Error(
       "Device has not been created using 'aai-agent device init' or there has been an issue with device initialization"

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

@@ -3,7 +3,7 @@ const awsIot = require('aws-iot-device-sdk');
 import {
   DEVICE_PRIVATE_KEY_FILE_NAME,
   CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
-  DEVICE_CLAIM_ID_FILE_NAME,
+  DEVICE_ID_FILE_NAME,
   DEVICE_CERTIFICATE_FILE_NAME
 } from '../util/directories';
 import { getDeviceUuid } from '../util/get-device-id';
@@ -66,6 +66,9 @@ export class BootstrapAgent extends DeviceAgent {
   public async handleAwsCertificateTopics(topic: string, payload: any) {
     switch (topic) {
       case '$aws/certificates/create/json/accepted': {
+        logger.debug(
+          `Received Certs: ${JSON.stringify(JSON.parse(payload), null, 2)}`
+        );
         const {
           certificateId,
           certificatePem,
@@ -76,13 +79,13 @@ export class BootstrapAgent extends DeviceAgent {
         const certSpawner = JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR });
 
         await certSpawner.writeFile(
-          DEVICE_CERTIFICATE_FILE_NAME(),
+          DEVICE_CERTIFICATE_FILE_NAME,
           certificatePem
         );
 
-        await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME(), privateKey);
+        await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME, privateKey);
 
-        await certSpawner.writeFile(DEVICE_CLAIM_ID_FILE_NAME(), certificateId);
+        await certSpawner.writeFile(DEVICE_ID_FILE_NAME, certificateId);
 
         await certSpawner.writeFile(
           CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,

package/src/cloud-connection/live-updates-handler.ts

@@ -8,13 +8,15 @@ import { getAppLogs } from '../application-control';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
 import { Publisher } from './publisher';
-import { getAppStateMessage, getDeviceStatsMessage } from './messages';
+import {
+  getAppInstallStatusMessage,
+  getAppStateMessage,
+  getDeviceStatsMessage
+} from './messages';
 import { AgentMessageTypeValue } from '@alwaysai/device-agent-schemas/lib/constants';
-import { AppInstallStatusManager } from './app-install-status';
 
 export class LiveUpdatesHandler {
   private publisher: Publisher;
-  private appInstallStatusMgr: AppInstallStatusManager;
 
   private liveUpdatesTimeout: ReturnType<typeof setTimeout>;
   private liveUpdatesAlive = {
@@ -32,14 +34,6 @@ export class LiveUpdatesHandler {
   private appLogStreams = new Set<string>();
   private appInstallStatuses = new Set<string>();
 
-  constructor(
-    publisher: Publisher,
-    appInstallStatusMgr: AppInstallStatusManager
-  ) {
-    this.publisher = publisher;
-    this.appInstallStatusMgr = appInstallStatusMgr;
-  }
-
   private async startAppLogStream(projectId: string) {
     logger.info(`Starting log stream for ${projectId}`);
     this.appLogStreams.add(projectId);
@@ -77,50 +71,19 @@ export class LiveUpdatesHandler {
     });
   }
 
-  // Use arrow function to allow `this` to be accessed
-  private getAppInstallStatusMessage = async (appReleaseHash: string) => {
-    const appInstallStatus =
-      this.appInstallStatusMgr.getStatusPacket(appReleaseHash);
-    const appInstallStatusMessage = {
-      messageType: keyMirrors.agentMessageType.app_install_status,
-      appInstallStatus
-    };
-    return appInstallStatusMessage;
-  };
-
-  public async startPublishingLiveUpdates<T extends any[]>(
-    messageType: AgentMessageTypeValue,
-    getMessageData: (...args: T) => Promise<DeviceAgentMessagePayload>,
-    args: T
-  ) {
-    logger.info(`Turned on live updates for ${messageType}`);
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      try {
-        const message = await getMessageData(...args);
-        this.publisher.publishToClient(message);
-      } catch (e) {
-        logger.error(
-          `Error publishing live updates for ${messageType}: ${e.message}`
-        );
-        break;
-      }
-      if (!this.continuePublishing(messageType, ...args)) {
-        logger.info(`Turned off live updates for ${messageType}`);
-        break;
-      }
-      await sleep(this.getLiveUpdatesInterval(messageType));
-    }
-  }
-
-  private continuePublishing(flag: AgentMessageTypeValue, data?: any): boolean {
+  private continuePublishing(
+    flag: AgentMessageTypeValue,
+    projectId?: string
+  ): boolean {
     switch (flag) {
       case keyMirrors.agentMessageType.device_stats:
       case keyMirrors.agentMessageType.app_state:
         return this.liveUpdatesAlive[flag];
       case keyMirrors.agentMessageType.app_install_status: {
-        const appReleaseHash: string = data;
-        return this.appInstallStatuses.has(appReleaseHash);
+        if (!projectId) {
+          throw new Error(`Project ID not provided to continuePublishing!`);
+        }
+        return this.appInstallStatuses.has(projectId);
       }
       default:
         logger.error(`Unrecognized publishable flag ${flag}`);
@@ -158,28 +121,73 @@ export class LiveUpdatesHandler {
     }, 600000); // 10 min
   }
 
-  public async update({
-    deviceStats,
-    appState,
-    appLogs,
-    appInstallStatus
-  }: {
-    deviceStats?: boolean;
-    appState?: boolean;
-    appLogs?: {
-      projectId: string;
-      toggle: boolean;
-    };
-    appInstallStatus?: {
-      appReleaseHash: string;
-      toggle: boolean;
-    };
+  private async startPublishingLiveUpdates<T extends any[]>(
+    messageType: AgentMessageTypeValue,
+    getMessageData: (...args: T) => Promise<DeviceAgentMessagePayload>,
+    args: T,
+    projectId?: string
+  ) {
+    logger.info(`Turned on live updates for ${messageType}`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        const message = await getMessageData(...args);
+        this.publisher.publishToClient(message);
+      } catch (e) {
+        logger.error(
+          `Error publishing live updates for ${messageType}: ${e.message}`
+        );
+        break;
+      }
+      if (!this.continuePublishing(messageType, projectId)) {
+        logger.info(`Turned off live updates for ${messageType}`);
+        break;
+      }
+      await sleep(this.getLiveUpdatesInterval(messageType));
+    }
+  }
+
+  /*=================================================================
+                            Public interface
+  =================================================================*/
+
+  constructor(publisher: Publisher) {
+    this.publisher = publisher;
+  }
+
+  public async enableAppInstallStatus(props: {
+    projectId: string;
+    appReleaseHash: string;
   }) {
+    const { projectId, appReleaseHash } = props;
+    this.liveUpdatesAlive.app_install_status = true;
+    this.appInstallStatuses.add(projectId);
+    // Don't wait for this call to finish since it loops until disabled
+    void this.startPublishingLiveUpdates(
+      keyMirrors.agentMessageType.app_install_status,
+      getAppInstallStatusMessage,
+      [keyMirrors.appInstallStatus.in_progress, '', appReleaseHash],
+      projectId
+    );
+  }
+
+  public async disableAppInstallStatus(props: { projectId: string }) {
+    const { projectId } = props;
+    this.appInstallStatuses.delete(projectId);
+
+    if (this.appInstallStatuses.size === 0) {
+      this.liveUpdatesAlive.app_install_status = false;
+    }
+  }
+
+  public async handleToggles(toggles: LiveUpdatesToggles) {
+    const { deviceStats, appState, appLogs } = toggles;
     this.restartLiveUpdatesTimeout();
     if (deviceStats !== undefined) {
       this.liveUpdatesAlive.device_stats = deviceStats;
       if (deviceStats) {
-        this.startPublishingLiveUpdates(
+        // Don't wait for this call to finish since it loops until disabled
+        void this.startPublishingLiveUpdates(
           keyMirrors.agentMessageType.device_stats,
           getDeviceStatsMessage,
           []
@@ -190,7 +198,8 @@ export class LiveUpdatesHandler {
     if (appState !== undefined) {
       this.liveUpdatesAlive.app_state = appState;
       if (appState) {
-        this.startPublishingLiveUpdates(
+        // Don't wait for this call to finish since it loops until disabled
+        void this.startPublishingLiveUpdates(
           keyMirrors.agentMessageType.app_state,
           getAppStateMessage,
           []
@@ -200,27 +209,11 @@ export class LiveUpdatesHandler {
 
     if (appLogs !== undefined) {
       if (appLogs.toggle) {
-        this.startAppLogStream(appLogs.projectId);
+        // Don't wait for this call to finish since it loops until disabled
+        void this.startAppLogStream(appLogs.projectId);
       } else {
         this.appLogStreams.delete(appLogs.projectId);
       }
     }
-
-    if (appInstallStatus !== undefined) {
-      if (appInstallStatus.toggle) {
-        this.liveUpdatesAlive.app_install_status = appInstallStatus.toggle;
-        this.appInstallStatuses.add(appInstallStatus.appReleaseHash);
-        this.startPublishingLiveUpdates(
-          keyMirrors.agentMessageType.app_install_status,
-          this.getAppInstallStatusMessage,
-          [appInstallStatus.appReleaseHash]
-        );
-      } else {
-        this.appInstallStatuses.delete(appInstallStatus.appReleaseHash);
-      }
-      if (this.appInstallStatuses.size === 0) {
-        this.liveUpdatesAlive.app_install_status = false;
-      }
-    }
   }
 }

package/src/cloud-connection/messages.ts

@@ -1,4 +1,9 @@
-import { AppStatePacket, keyMirrors } from '@alwaysai/device-agent-schemas';
+import {
+  AppInstallStatusMessage,
+  AppStatePacket,
+  keyMirrors
+} from '@alwaysai/device-agent-schemas';
+import { AppInstallStatusValue } from '@alwaysai/device-agent-schemas/lib/constants';
 import { getAppStatus } from '../application-control';
 import {
   getCpuUtil,
@@ -22,6 +27,22 @@ export async function getAppStateMessage() {
   return appStatePackage;
 }
 
+export async function getAppInstallStatusMessage(
+  status: AppInstallStatusValue,
+  message: string,
+  appReleaseHash: string
+): Promise<AppInstallStatusMessage> {
+  const appInstallStatusMessage: AppInstallStatusMessage = {
+    messageType: keyMirrors.agentMessageType.app_install_status,
+    appInstallStatus: {
+      status,
+      message,
+      appReleaseHash
+    }
+  };
+  return appInstallStatusMessage;
+}
+
 export async function getDeviceStatsMessage() {
   const cpuUsage = await getCpuUtil();
   const diskUtil = await getDiskUtil();

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

@@ -29,7 +29,7 @@ export class PassthroughHandler {
   }
 }
 
-async function processPublish(passthroughHandler: PassthroughHandler) {
+function processPublish(passthroughHandler: PassthroughHandler) {
   while (messageQueue.length > 0) {
     const entry = messageQueue.shift();
     const { packet, msg } = entry;

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

@@ -21,8 +21,8 @@ describe('Test Shadow Handler', () => {
 
   test.skip('reject buffer payload', async () => {
     //FIXME: Invalid input is silently ignored, need input validation
-    expect(() => {
-      shadowHandler.handleShadowTopic({
+    expect(async () => {
+      await shadowHandler.handleShadowTopic({
         topic: shadowHandler.shadowTopics.projects.updateDelta,
         payload: Buffer.from('test-payload')
       });
@@ -317,7 +317,7 @@ describe('Test Shadow Handler', () => {
     };
     jest.mocked(readAppCfgFile).mockResolvedValue(testAppCfg);
 
-    shadowHandler.publishAppState(projectId1);
+    await shadowHandler.publishAppState(projectId1);
     expect(jest.mocked(readAppCfgFile)).toBeCalledWith({ projectId1 });
     const packet = {
       state: {