@alwaysai/device-agent 0.0.7 → 0.0.9

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

@@ -5,178 +5,212 @@ import {
   getCertificateFilePath,
   getRootCertificateFilePath,
 } from '../util/directories';
+import sleep from '../util/sleep';
 import {
   startApp,
   stopApp,
   restartApp,
-  getAppStatus,
   getAppLogs,
+  getAppStatus,
 } from '../application-control/status';
-import { installApp } from '../application-control/install';
-import { getCpuUtil, getDiskUtil, getMemUtil } from '../device-control/device-control';
 import {
-  DeviceAgentMessage,
+  getInstalledApps,
+  installApp,
+  uninstallApp,
+} from '../application-control/install';
+import {
+  keyMirrors,
+  validateClientMessage,
+  DeviceAgentMessagePayload,
+  AppInstallStatusPacket,
+  AppStateControlPacket,
+  AppVersionControlPacket,
+  LiveUpdatesToggles,
+  AppLogsPacket,
+  AppStatePacket,
+  LiveUpdatesToggleMessage,
   DeviceStatsMessage,
-  AppState,
   AppStateMessage,
-  ActionMessage,
-  AppLogs,
   AppLogsMessage,
-  InstallationStatusMessage,
-  InstallationStatus,
-  InstallationStatusEnum,
+  AppInstallStatusMessage,
+  SignedUrlsRequestMessage,
+  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';
 
 export class DeviceAgentCloudConnection {
   private clientId = getDeviceId();
   private host = getIoTCoreEndpointUrl();
-  private publishable = false;
-  private readonly publishInterval = 10000;
-  private readonly installationStatusInterval = 5000;
-  private installationStatus: InstallationStatus;
-  private publishableTimeout: ReturnType<typeof setTimeout>;
-
-  public device = awsIot.device;
-  public agentTopicPrefix = `destination/agent/device/${this.clientId}/topic/`;
-  public cloudTopicPrefix = `destination/cloud/device/${this.clientId}/topic/`;
+  private appInstallStatus: AppInstallStatusPacket;
+  private liveUpdatesTimeout: ReturnType<typeof setTimeout>;
+  private liveUpdatesAlive = {
+    [keyMirrors.agentMessageType.device_stats]: false,
+    [keyMirrors.agentMessageType.app_state]: false,
+    [keyMirrors.agentMessageType.app_logs]: false,
+  };
+  private liveUpdatesSleepIntervals = {
+    [keyMirrors.agentMessageType.device_stats]: 5000,
+    [keyMirrors.agentMessageType.app_state]: 5000,
+    [keyMirrors.agentMessageType.app_logs]: 5000,
+    [keyMirrors.agentMessageType.app_install_status]: 5000,
+  };
+  private appLogStreams = new Set<string>();
+  private deviceType = 'aai-device';
+  private readonly shadowPrefix = `$aws/things/${this.clientId}/shadow/name/`;
+  private readonly shadowTopics = {
+    projects: {
+      updateDelta: `${this.shadowPrefix}projects/update/delta`,
+      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}`;
 
-  constructor() {
-    this.device = awsIot.device({
-      keyPath: getPrivateKeyFilePath(),
-      certPath: getCertificateFilePath(),
-      caPath: getRootCertificateFilePath(),
-      clientId: this.clientId,
-      host: this.host,
-    });
+  // device shadow utils
 
-    this.device.subscribe(`${this.agentTopicPrefix}command`);
-    this.device.subscribe(`${this.agentTopicPrefix}response`);
+  public getShadowPrefix() {
+    return this.shadowPrefix;
   }
 
-  public setInstallationStatus(installationStatus: InstallationStatus) {
-    this.installationStatus = installationStatus;
-  }
+  private async handleNamedShadowUpdate({ payload }: { payload: string }) {
+    const delta = JSON.parse(payload);
+    const deltaKeys = Object.keys(delta);
+
+    for (const projectId of deltaKeys) {
+      const projectShadow = delta[projectId];
+      if (projectShadow.appConfig) {
+        const appConfig = projectShadow.appConfig;
+        const appDir = getAppDir(projectId);
+        await updateAppConfig(projectId, appConfig);
+
+        if (appConfig.models) {
+          this.publishCloudRequest({
+            messageType: keyMirrors.agentMessageType.signed_urls_request,
+            modelsOnlyUrlsRequest: {
+              projectId,
+              models: appConfig.models,
+            },
+          });
+        }
 
-  public getInstallationStatus(): InstallationStatus {
-    return this.installationStatus;
-  }
+        if (appConfig.scripts && !appConfig.models) {
+          const appState = await getAppStatus({ projectId });
 
-  public getPublishable(): boolean {
-    return this.publishable;
-  }
+          await buildApp({ appDir });
 
-  public setPublishable(enabled: boolean) {
-    this.publishable = enabled;
+          if (
+            appState.services.length &&
+            appState.services[0].state !== keyMirrors.appState.stopped
+          ) {
+            restartApp({ projectId });
+          }
+          await this.publishReportedState(projectId);
+        }
+      }
+    }
   }
 
-  public restartPublishableTimeout() {
-    clearTimeout(this.publishableTimeout);
-    this.publishableTimeout = setTimeout(() => {
-      this.setPublishable(false);
-    }, 600000); // 10 min
-  }
+  private async startAppLogStream(projectId: string) {
+    this.appLogStreams.add(projectId);
+    const readable = await getAppLogs({
+      projectId,
+      args: ['--tail', '100', '--no-log-prefix'],
+    });
+    readable.on('data', (chunk: Buffer) => {
+      if (!this.appLogStreams.has(projectId)) {
+        // why doesn't typescript know about this function?
+        // @ts-ignore
+        readable.destroy();
+        logger.info(`App log stream terminated for project ${projectId}`);
+        return;
+      }
+      const logStr = chunk.toString();
+      const message = {
+        messageType: keyMirrors.agentMessageType.app_logs,
+        appLogs: {
+          projectId,
+          logChunk: logStr,
+        },
+      };
+      const packet = this.buildMessagePacket(
+        this.getClientId(),
+        this.toClientTopic,
+        message,
+      );
+      this.publishMessage(this.toClientTopic, JSON.stringify(packet));
+    });
 
-  public getPublishInterval() {
-    return this.publishInterval;
-  }
+    readable.on('error', (error) => {
+      logger.error(`App log stream terminated for project ${projectId}: ${error}`);
+    });
 
-  public getInstallationStatusInterval() {
-    return this.installationStatusInterval;
+    readable.on('finished', () => {
+      logger.info(`App logs finished piping for project ${projectId}`);
+    });
   }
 
-  public getClientId(): string {
-    return this.clientId;
+  // must contain app release hash
+  private initAppInstallStatus(installationStatus: AppInstallStatusPacket) {
+    this.appInstallStatus = installationStatus;
   }
 
-  public publishMessage(topic: string, message: string) {
-    this.device.publish(topic, message);
+  private updateAppInstallStatus(
+    installationStatus: Omit<AppInstallStatusPacket, 'appReleaseHash'>,
+  ) {
+    this.appInstallStatus.status = installationStatus.status;
+    this.appInstallStatus.message = installationStatus.message;
   }
-}
 
-export function runDeviceAgentCloudInterface() {
-  const deviceAgent = new DeviceAgentCloudConnection();
+  private getAppInstallStatus(): AppInstallStatusPacket {
+    return this.appInstallStatus;
+  }
 
-  async function buildMessagePacket(
+  // Message Builders
+  private buildMessagePacket(
+    deviceId: string,
     topic: string,
-    payload:
-      | DeviceStatsMessage
-      | ActionMessage
-      | AppStateMessage
-      | AppLogsMessage
-      | InstallationStatusMessage,
-  ): Promise<DeviceAgentMessage> {
+    payload: DeviceAgentMessagePayload,
+  ): DeviceAgentMessage {
     const packet = {
       timestamp: new Date().toUTCString(),
-      deviceId: deviceAgent.getClientId(),
+      deviceId,
       topic,
       payload,
     };
     return packet;
   }
 
-  async function getAppLogsMessage(): Promise<AppLogsMessage> {
-    const appLogsList: AppLogs[] = [];
+  private async getAppStateMessage(): Promise<AppStateMessage> {
+    const appStateMessage: AppStatePacket[] = [];
     const apps = await AgentConfigFile().getReadyApps();
-    for (const app of apps) {
-      const projectId = app.projectId;
-      const readable = await getAppLogs({ projectId });
-      const logs: any[] = [];
-      readable.setEncoding('utf8');
-      for await (const chunk of readable) {
-        logs.push(chunk);
-      }
-      const appLogs = {
-        projectId,
-        logs,
-      };
-      appLogsList.push(appLogs);
-    }
-    const applicationStatePackage = {
-      applicationLogs: appLogsList,
-    };
-    return applicationStatePackage;
-  }
-
-  // * This was causing massive CPU overhead
-  // const publishAppLogs = setInterval(async function () {
-  //   const appLogsMessage = await getAppLogsMessage();
-  //   const topic = `device/${deviceAgent.getClientId()}/topic/application-management`;
-  //   const appLogsPacket = await buildMessagePacket(topic, appLogsMessage);
-
-  //   deviceAgent.publishMessage(topic, JSON.stringify({ appLogsPacket }));
-  // }, deviceAgent.getPublishInterval());
-
-  async function getAppStateMessage(): Promise<AppStateMessage> {
-    const appStateMessage: AppState[] = [];
-    const apps = await AgentConfigFile().getApps();
     for (const app of apps) {
       const projectId = app.projectId;
       const status = await getAppStatus({ projectId });
       appStateMessage.push(status);
     }
-    const applicationStatePackage = {
-      applicationState: appStateMessage,
+    const appStatePackage = {
+      messageType: keyMirrors.agentMessageType.app_state,
+      appState: appStateMessage,
     };
-    return applicationStatePackage;
+    return appStatePackage;
   }
 
-  const publishAppState = setInterval(async function () {
-    if (deviceAgent.getPublishable()) {
-      const topic = `${deviceAgent.cloudTopicPrefix}application-management`;
-      const appStateMessage = await getAppStateMessage();
-      const appStatePacket = await buildMessagePacket(topic, appStateMessage);
-      deviceAgent.publishMessage(topic, JSON.stringify({ appStatePacket }));
-    }
-  }, deviceAgent.getPublishInterval());
-
-  async function getDeviceStatsMessage(): Promise<DeviceStatsMessage> {
+  private async getDeviceStatsMessage(): Promise<DeviceStatsMessage> {
     const cpuUsage = await getCpuUtil();
     const diskUtil = await getDiskUtil();
     const memUtil = await getMemUtil();
 
     const deviceStatsMessage = {
+      messageType: keyMirrors.agentMessageType.device_stats,
       deviceStats: {
         cpuUsage,
         diskUtil,
@@ -186,137 +220,346 @@ export function runDeviceAgentCloudInterface() {
     return deviceStatsMessage;
   }
 
-  const publishDeviceStats = setInterval(async function () {
-    if (deviceAgent.getPublishable()) {
-      const topic = `${deviceAgent.cloudTopicPrefix}device-management`;
-      const deviceStatsMessage = await getDeviceStatsMessage();
-      const deviceStatsPacket = await buildMessagePacket(topic, deviceStatsMessage);
-      deviceAgent.publishMessage(topic, JSON.stringify({ deviceStatsPacket }));
+  // 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,
+    };
+    return appInstallStatusMessage;
+  };
+
+  private async startPublishingLiveUpdates(
+    topic: string,
+    messageType: string,
+    getMessageData: () => Promise<DeviceAgentMessagePayload>,
+  ) {
+    while (true) {
+      try {
+        const message = await getMessageData();
+        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}`);
+        break;
+      }
+      if (!this.continuePublishing(messageType)) {
+        logger.info(`Turned off live updates for ${messageType}`);
+        break;
+      }
+      await sleep(this.getLiveUpdatesInterval(messageType));
     }
-  }, deviceAgent.getPublishInterval());
+  }
 
-  const publishDeviceRequest = async ({ projectId, releaseHash }) => {
-    const topic = `${deviceAgent.cloudTopicPrefix}request`;
-    const deviceRequestPackage = {
-      timestamp: new Date().toUTCString(),
-      deviceId: deviceAgent.getClientId(),
-      projectId,
-      releaseHash,
-      topic,
+  private continuePublishing(flag: string): boolean {
+    switch (flag) {
+      case keyMirrors.agentMessageType.device_stats:
+      case keyMirrors.agentMessageType.app_state:
+        return this.liveUpdatesAlive[flag];
+      case keyMirrors.agentMessageType.app_install_status:
+        return this.appInstallStatus.status === keyMirrors.appInstallStatus.in_progress;
+      default:
+        logger.error(`Unrecognized publishable flag ${flag}`);
+        return false;
+    }
+  }
+
+  private getLiveUpdatesInterval(flag: string): number {
+    const exists = this.liveUpdatesSleepIntervals[flag];
+    if (exists) {
+      return exists;
+    }
+    logger.error(`Unrecognized live updates flag ${flag}`);
+    return -1;
+  }
+
+  private setLiveUpdates(toggles: LiveUpdatesToggles) {
+    if (toggles.deviceStats) {
+      this.liveUpdatesAlive.device_stats = toggles.deviceStats;
+    }
+    if (toggles.appState) {
+      this.liveUpdatesAlive.app_state = toggles.appState;
+    }
+  }
+
+  private handleAppStateControl(payload: AppStateControlPacket) {
+    const { baseCommand, projectId } = payload;
+    switch (baseCommand) {
+      case keyMirrors.appStateControl.start:
+        startApp({ projectId });
+        break;
+      case keyMirrors.appStateControl.stop:
+        stopApp({ projectId });
+        break;
+      case keyMirrors.appStateControl.restart:
+        restartApp({ projectId });
+        break;
+    }
+  }
+
+  private handleAppVersionControl(payload: AppVersionControlPacket) {
+    const { projectId, appReleaseHash } = payload;
+    const signedUrlsRequest = { projectId, appReleaseHash };
+    this.publishCloudRequest({
+      messageType: keyMirrors.agentMessageType.signed_urls_request,
+      signedUrlsRequest,
+    });
+  }
+
+  private handleDeviceCommand = async (packet: any) => {
+    // TODO
+  };
+
+  private handleAgentCommand(message: LiveUpdatesToggleMessage) {
+    switch (message.messageType) {
+      case keyMirrors.clientMessageType.live_state_updates:
+        this.liveUpdatesBroker(message.liveUpdatesToggles);
+        break;
+      default:
+        logger.error(`Invalid agent action message type from message '${message}'`);
+    }
+  }
+
+  private restartLiveUpdatesTimeout() {
+    clearTimeout(this.liveUpdatesTimeout);
+    this.liveUpdatesTimeout = setTimeout(() => {
+      this.setLiveUpdates({
+        deviceStats: false,
+        appState: false,
+      });
+      this.appLogStreams.clear();
+      // TODO: Make constant, not hard coded
+    }, 600000); // 10 min
+  }
+
+  private async liveUpdatesBroker({
+    deviceStats,
+    appState,
+    appLogs,
+  }: {
+    deviceStats?: boolean;
+    appState?: boolean;
+    appLogs?: {
+      projectId: string;
+      toggle: boolean;
     };
-    deviceAgent.publishMessage(
+  }) {
+    this.restartLiveUpdatesTimeout();
+    if (deviceStats !== undefined) {
+      this.liveUpdatesAlive.device_stats = deviceStats;
+      if (deviceStats) {
+        this.startPublishingLiveUpdates(
+          this.toClientTopic,
+          keyMirrors.agentMessageType.device_stats,
+          this.getDeviceStatsMessage,
+        );
+      }
+    }
+
+    if (appState !== undefined) {
+      this.liveUpdatesAlive.app_state = appState;
+      if (appState) {
+        this.startPublishingLiveUpdates(
+          this.toClientTopic,
+          keyMirrors.agentMessageType.app_state,
+          this.getAppStateMessage,
+        );
+      }
+    }
+
+    if (appLogs !== undefined) {
+      if (appLogs.toggle) {
+        this.startAppLogStream(appLogs.projectId);
+      } else {
+        this.appLogStreams.delete(appLogs.projectId);
+      }
+    }
+  }
+
+  private async publishReportedState(projectId) {
+    const newAppCfg = await getAppConfig(projectId);
+    const packet = {
+      state: {
+        reported: {
+          [projectId]: { appConfig: newAppCfg },
+        },
+      },
+    };
+    this.publishMessage(`${this.shadowPrefix}projects/update`, JSON.stringify(packet));
+  }
+
+  private async publishCloudRequest(payload: SignedUrlsRequestMessage) {
+    const topic = this.toCloudTopic;
+    const deviceRequestPacket = this.buildMessagePacket(
+      this.getClientId(),
       topic,
-      JSON.stringify({ device_request: deviceRequestPackage }),
+      payload,
     );
-  };
+    this.publishMessage(topic, JSON.stringify({ deviceRequestPacket }));
+  }
 
-  const publishInstallationStatus = async (interval: NodeJS.Timeout) => {
-    const topic = `${deviceAgent.cloudTopicPrefix}installation-status`;
-    const installationStatus = deviceAgent.getInstallationStatus();
-    const installationStatusPacket = await buildMessagePacket(topic, {
-      installationStatus,
+  // Public Methods
+
+  public device = awsIot.device;
+
+  constructor() {
+    this.device = awsIot.device({
+      keyPath: getPrivateKeyFilePath(),
+      certPath: getCertificateFilePath(),
+      caPath: getRootCertificateFilePath(),
+      clientId: this.clientId,
+      host: this.host,
     });
-    deviceAgent.device.publish(topic, JSON.stringify({ installationStatusPacket }));
-    if (installationStatus.status !== InstallationStatusEnum.IN_PROGRESS) {
-      clearInterval(interval);
-    }
-  };
 
-  const handleMessageTopic = async ({ topic, payload }) => {
-    const action = payload['action'];
-    const actionPayload: any = payload[action];
-    const type = topic.split('/').slice(-1)[0];
+    this.device.subscribe(this.toDeviceTopic);
+    this.device.subscribe(this.shadowTopics.projects.getAccepted);
+    this.device.subscribe(this.shadowTopics.projects.updateDelta);
+  }
 
-    if (!type) {
-      return false;
-    }
+  public getClientId(): string {
+    return this.clientId;
+  }
 
-    switch (action) {
-      /**
-       * Install app package based on the given project ID
-       */
-      case 'install':
-        /**
-          {
-            "action": "install",
-            "install": {
-              "releaseHash": "7fb2a812f9e7aa193208dac353521965da50d755085162066c125592f1ed760b",
-              "projectId": "786e4686-a681-4cff-9e17-1e7d385c0fdb"
-            }
-          }
-         */
-        if (type === 'response') {
-          deviceAgent.setInstallationStatus({
-            status: InstallationStatusEnum.IN_PROGRESS,
-            applicationReleaseHash: actionPayload.releaseHash as string,
-          });
+  public publishMessage(topic: string, message: string) {
+    // TODO: topic validation
+    this.device.publish(topic, message);
+  }
 
-          const installationStatusPing = setInterval(
-            () => publishInstallationStatus(installationStatusPing),
-            deviceAgent.getInstallationStatusInterval(),
-          );
-
-          // Install the app with the given url
-          await (async () => {
-            try {
-              await installApp(actionPayload);
-              deviceAgent.setInstallationStatus({
-                status: InstallationStatusEnum.SUCCESS,
-                applicationReleaseHash: actionPayload.releaseHash as string,
-              });
-            } catch (e) {
-              const reason: string = e.message;
-              deviceAgent.setInstallationStatus({
-                status: InstallationStatusEnum.FAILURE,
-                reason,
-                applicationReleaseHash: actionPayload.releaseHash as string,
-              });
-            }
-          })();
-          break;
-        }
-        publishDeviceRequest(actionPayload);
+  public async handleClientMessage({
+    topic,
+    message,
+  }: {
+    topic: string;
+    message: ClientMessage;
+  }) {
+    const payload = message.payload;
+    switch (payload.messageType) {
+      case keyMirrors.clientMessageType.app_state_control: {
+        this.handleAppStateControl(payload.appStateControl);
         break;
-      case 'start':
-        startApp({ projectId: actionPayload.projectId });
+      }
+      case keyMirrors.clientMessageType.app_version_control: {
+        this.handleAppVersionControl(payload.appVersionControl);
         break;
-      case 'stop':
-        stopApp({ projectId: actionPayload.projectId });
+      }
+      case keyMirrors.clientMessageType.live_state_updates: {
+        this.handleAgentCommand(payload);
         break;
-      case 'restart':
-        restartApp({ projectId: actionPayload.projectId });
+      }
+      case keyMirrors.clientMessageType.app_install_cloud_response: {
+        const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } =
+          payload.appInstallCloudResponse;
+
+        this.initAppInstallStatus({
+          status: keyMirrors.appInstallStatus.in_progress,
+          appReleaseHash,
+        });
+
+        this.startPublishingLiveUpdates(
+          this.toClientTopic,
+          keyMirrors.agentMessageType.app_install_status,
+          this.getAppInstallStatusMessage,
+        );
+
+        // Install the app and models
+        try {
+          const signedUrlsPayload = {
+            appInstallPayload,
+            modelsInstallPayload,
+          };
+          await installApp({
+            projectId,
+            appReleaseHash,
+            signedUrlsPayload,
+          });
+          this.updateAppInstallStatus({
+            status: keyMirrors.appInstallStatus.success,
+          });
+
+          // update app config shadow for project
+          await this.publishReportedState(projectId);
+        } catch (e) {
+          console.error(e);
+          const message: string = e.message;
+
+          // uninstall the failed app to put system back in good state
+          await uninstallApp({ projectId });
+          this.updateAppInstallStatus({
+            status: keyMirrors.appInstallStatus.failure,
+            message,
+          });
+
+          // delete shadow for project
+          this.publishMessage(`${this.shadowPrefix}${projectId}/delete`, '');
+        }
         break;
-      /**
-       * Allow/disallow publishing on this device. By default, (publishable = false)
-       */
-      case 'publishable':
-        /**
-          {
-            "action": "publishable",
-            "publishable": true | false
-          }
-         */
-        deviceAgent.setPublishable(actionPayload);
-        deviceAgent.restartPublishableTimeout();
+      }
+      case keyMirrors.clientMessageType.models_install_cloud_response: {
+        const { projectId, newModels } = payload.modelsInstallCloudResponse;
+
+        try {
+          await updateModelsWithPresignedUrls(projectId, newModels);
+
+          await this.publishReportedState(projectId);
+        } catch (e) {
+          console.error(e);
+        }
         break;
+      }
       default:
-        break;
+        logger.error(`Invalid Client Message '${JSON.stringify(payload)}'`);
     }
-  };
+  }
+
+  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 });
+    } else if (topic === this.shadowTopics.projects.getAccepted) {
+      if (message.delta) {
+        this.handleNamedShadowUpdate({
+          payload: JSON.stringify(message.delta),
+        });
+      } else {
+        console.log(`No delta updates in shadow ${shadowName}`);
+      }
+    }
+  }
+}
+
+export function runDeviceAgentCloudInterface() {
+  const deviceAgent = new DeviceAgentCloudConnection();
 
   deviceAgent.device.on('connect', function () {
     deviceAgent.publishMessage('connection', deviceAgent.getClientId());
     console.log('Device Agent has connected to the cloud');
+
+    // 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('message', function (topic, payload) {
-    // ToDo: insert valdiation here for incoming messages.  Maybe we will use a JSON schema for the message structure.
+  deviceAgent.device.on('message', function (topic: string, payload: string) {
     try {
-      handleMessageTopic({ topic, payload: JSON.parse(payload) });
+      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) {
       console.error(error);
     }