@alwaysai/device-agent 0.0.11 → 0.0.13

package/lib/cloud-connection/device-agent-cloud-connection.js

@@ -1,63 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDeviceAgentCloudInterface = exports.DeviceAgentCloudConnection = void 0;
-const awsIot = require("aws-iot-device-sdk");
+// eslint-disable-next-line
+const awsIot = require('aws-iot-device-sdk');
 const urls_1 = require("../infrastructure/urls");
 const fs_1 = require("fs");
 const directories_1 = require("../util/directories");
-const device_agent_1 = require("./device-agent");
-const sleep_1 = require("../util/sleep");
-const status_1 = require("../application-control/status");
-const install_1 = require("../application-control/install");
 const device_agent_schemas_1 = require("@alwaysai/device-agent-schemas");
 const get_device_id_1 = require("../util/get-device-id");
-const util_1 = require("alwaysai/lib/util");
-const device_control_1 = require("../device-control/device-control");
+const logger_1 = require("../util/logger");
 const agent_config_1 = require("../infrastructure/agent-config");
-const utils_1 = require("../application-control/utils");
-const models_1 = require("../application-control/models");
-const config_1 = require("../application-control/config");
+const application_control_1 = require("../application-control");
+const shadow_handler_1 = require("./shadow-handler");
+const publisher_1 = require("./publisher");
+const live_updates_handler_1 = require("./live-updates-handler");
+const bootstrap_provision_1 = require("./bootstrap-provision");
+const app_install_status_1 = require("./app-install-status");
 class DeviceAgentCloudConnection {
+    // Public Methods
     constructor() {
-        this.clientId = (0, get_device_id_1.getDeviceId)();
+        this.device = awsIot.device;
+        this.clientId = (0, get_device_id_1.getDeviceUuid)();
         this.host = (0, urls_1.getIoTCoreEndpointUrl)();
-        this.liveUpdatesAlive = {
-            [device_agent_schemas_1.keyMirrors.agentMessageType.device_stats]: false,
-            [device_agent_schemas_1.keyMirrors.agentMessageType.app_state]: false,
-            [device_agent_schemas_1.keyMirrors.agentMessageType.app_logs]: false,
-        };
-        this.liveUpdatesSleepIntervals = {
-            [device_agent_schemas_1.keyMirrors.agentMessageType.device_stats]: 5000,
-            [device_agent_schemas_1.keyMirrors.agentMessageType.app_state]: 5000,
-            [device_agent_schemas_1.keyMirrors.agentMessageType.app_logs]: 5000,
-            [device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status]: 5000,
-        };
-        this.appLogStreams = new Set();
-        this.deviceType = "aai-device";
-        this.shadowPrefix = `$aws/things/${this.clientId}/shadow/name/`;
-        this.shadowTopics = {
-            projects: {
-                updateDelta: `${this.shadowPrefix}projects/update/delta`,
-                getAccepted: `${this.shadowPrefix}projects/get/accepted`,
-            },
-        };
-        this.toCloudTopic = `to-cloud/${this.deviceType}/${this.clientId}`;
-        this.toClientTopic = `to-client/${this.deviceType}/${this.clientId}`;
-        this.toDeviceTopic = `to-device/${this.deviceType}/${this.clientId}`;
-        // must be arrow function due to this context when function is passed as param
-        this.getAppInstallStatusMessage = async () => {
-            const appInstallStatus = this.getAppInstallStatus();
-            const appInstallStatusMessage = {
-                messageType: device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status,
-                appInstallStatus,
-            };
-            return appInstallStatusMessage;
-        };
+        this.toDeviceTopic = (0, device_agent_schemas_1.getDeviceTopic)(this.clientId);
+        // FIXME: Add support for multiple simultaneous project updates
+        this.newAppCfgQueue = [];
         this.handleDeviceCommand = async (packet) => {
             // TODO
         };
-        // Public Methods
-        this.device = awsIot.device;
         this.device = awsIot.device({
             keyPath: (0, directories_1.getPrivateKeyFilePath)(),
             certPath: (0, directories_1.getCertificateFilePath)(),
@@ -65,184 +35,27 @@ class DeviceAgentCloudConnection {
             clientId: this.clientId,
             host: this.host,
             port: 8883,
+            keepalive: 1 // time before re-connect attempt on dropped connection, default is 400 seconds
         });
-        this.device.subscribe(this.toDeviceTopic);
-        this.device.subscribe(this.shadowTopics.projects.getAccepted);
-        this.device.subscribe(this.shadowTopics.projects.updateDelta);
-    }
-    // device shadow utils
-    getShadowPrefix() {
-        return this.shadowPrefix;
-    }
-    async handleNamedShadowUpdate({ payload }) {
-        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 = (0, utils_1.getAppDir)(projectId);
-                await (0, config_1.updateAppConfig)(projectId, appConfig);
-                if (appConfig.models) {
-                    this.publishCloudRequest({
-                        messageType: device_agent_schemas_1.keyMirrors.agentMessageType.signed_urls_request,
-                        modelsOnlyUrlsRequest: {
-                            projectId,
-                            models: appConfig.models,
-                        },
-                    });
-                }
-                if (appConfig.scripts && !appConfig.models) {
-                    const appState = await (0, status_1.getAppStatus)({ projectId });
-                    await (0, utils_1.buildApp)({ appDir });
-                    if (appState.services.length &&
-                        appState.services[0].state !== device_agent_schemas_1.keyMirrors.appState.stopped) {
-                        (0, status_1.restartApp)({ projectId });
-                    }
-                    await this.publishReportedState(projectId);
-                }
-            }
-        }
-    }
-    async startAppLogStream(projectId) {
-        this.appLogStreams.add(projectId);
-        const readable = await (0, status_1.getAppLogs)({
-            projectId,
-            args: ["--tail", "100", "--no-log-prefix"],
-        });
-        readable.on("data", (chunk) => {
-            if (!this.appLogStreams.has(projectId)) {
-                // why doesn't typescript know about this function?
-                // @ts-ignore
-                readable.destroy();
-                util_1.logger.info(`App log stream terminated for project ${projectId}`);
-                return;
-            }
-            const logStr = chunk.toString();
-            const message = {
-                messageType: device_agent_schemas_1.keyMirrors.agentMessageType.app_logs,
-                appLogs: {
-                    projectId,
-                    logChunk: logStr,
-                },
-            };
-            const packet = this.buildMessagePacket(this.getClientId(), this.toClientTopic, message);
-            this.publishMessage(this.toClientTopic, JSON.stringify(packet));
-        });
-        readable.on("error", (error) => {
-            util_1.logger.error(`App log stream terminated for project ${projectId}: ${error}`);
-        });
-        readable.on("finished", () => {
-            util_1.logger.info(`App logs finished piping for project ${projectId}`);
-        });
-    }
-    // must contain app release hash
-    initAppInstallStatus(installationStatus) {
-        this.appInstallStatus = installationStatus;
-    }
-    updateAppInstallStatus(installationStatus) {
-        this.appInstallStatus.status = installationStatus.status;
-        this.appInstallStatus.message = installationStatus.message;
-    }
-    getAppInstallStatus() {
-        return this.appInstallStatus;
-    }
-    // Message Builders
-    buildMessagePacket(deviceId, topic, payload) {
-        const packet = {
-            timestamp: new Date().toUTCString(),
-            deviceId,
-            topic,
-            payload,
-        };
-        return packet;
-    }
-    async getAppStateMessage() {
-        const appStateMessage = [];
-        const apps = await (0, agent_config_1.AgentConfigFile)().getReadyApps();
-        for (const app of apps) {
-            const projectId = app.projectId;
-            const status = await (0, status_1.getAppStatus)({ projectId });
-            appStateMessage.push(status);
-        }
-        const appStatePackage = {
-            messageType: device_agent_schemas_1.keyMirrors.agentMessageType.app_state,
-            appState: appStateMessage,
-        };
-        return appStatePackage;
-    }
-    async getDeviceStatsMessage() {
-        const cpuUsage = await (0, device_control_1.getCpuUtil)();
-        const diskUtil = await (0, device_control_1.getDiskUtil)();
-        const memUtil = await (0, device_control_1.getMemUtil)();
-        const deviceStatsMessage = {
-            messageType: device_agent_schemas_1.keyMirrors.agentMessageType.device_stats,
-            deviceStats: {
-                cpuUsage,
-                diskUtil,
-                usedMemoryPercentage: memUtil,
-            },
-        };
-        return deviceStatsMessage;
-    }
-    async startPublishingLiveUpdates(topic, messageType, getMessageData) {
-        while (true) {
-            try {
-                const message = await getMessageData();
-                const packet = this.buildMessagePacket(this.getClientId(), topic, message);
-                this.publishMessage(topic, JSON.stringify(packet));
-            }
-            catch (e) {
-                util_1.logger.error(`Error publishing live updates for ${messageType}: ${e.message}`);
-                break;
-            }
-            if (!this.continuePublishing(messageType)) {
-                util_1.logger.info(`Turned off live updates for ${messageType}`);
-                break;
-            }
-            await (0, sleep_1.default)(this.getLiveUpdatesInterval(messageType));
-        }
-    }
-    continuePublishing(flag) {
-        switch (flag) {
-            case device_agent_schemas_1.keyMirrors.agentMessageType.device_stats:
-            case device_agent_schemas_1.keyMirrors.agentMessageType.app_state:
-                return this.liveUpdatesAlive[flag];
-            case device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status:
-                return (this.appInstallStatus.status ===
-                    device_agent_schemas_1.keyMirrors.appInstallStatus.in_progress);
-            default:
-                util_1.logger.error(`Unrecognized publishable flag ${flag}`);
-                return false;
-        }
-    }
-    getLiveUpdatesInterval(flag) {
-        const exists = this.liveUpdatesSleepIntervals[flag];
-        if (exists) {
-            return exists;
-        }
-        util_1.logger.error(`Unrecognized live updates flag ${flag}`);
-        return -1;
-    }
-    setLiveUpdates(toggles) {
-        if (toggles.deviceStats) {
-            this.liveUpdatesAlive.device_stats = toggles.deviceStats;
-        }
-        if (toggles.appState) {
-            this.liveUpdatesAlive.app_state = toggles.appState;
-        }
+        this.publisher = new publisher_1.Publisher(this.device, this.clientId);
+        this.shadowHandler = new shadow_handler_1.ShadowHandler(this.clientId, this.publisher);
+        this.appInstallStatusMgr = new app_install_status_1.AppInstallStatusManager();
+        this.liveUpdatesHandler = new live_updates_handler_1.LiveUpdatesHandler(this.publisher, this.appInstallStatusMgr);
+        this.subscribe(this.toDeviceTopic);
+        this.subscribe(this.shadowHandler.shadowTopics.projects.getAccepted);
+        this.subscribe(this.shadowHandler.shadowTopics.projects.updateDelta);
     }
     handleAppStateControl(payload) {
         const { baseCommand, projectId } = payload;
         switch (baseCommand) {
             case device_agent_schemas_1.keyMirrors.appStateControl.start:
-                (0, status_1.startApp)({ projectId });
+                (0, application_control_1.startApp)({ projectId });
                 break;
             case device_agent_schemas_1.keyMirrors.appStateControl.stop:
-                (0, status_1.stopApp)({ projectId });
+                (0, application_control_1.stopApp)({ projectId });
                 break;
             case device_agent_schemas_1.keyMirrors.appStateControl.restart:
-                (0, status_1.restartApp)({ projectId });
+                (0, application_control_1.restartApp)({ projectId });
                 break;
         }
     }
@@ -251,76 +64,91 @@ class DeviceAgentCloudConnection {
         const signedUrlsRequest = { projectId, appReleaseHash };
         this.publishCloudRequest({
             messageType: device_agent_schemas_1.keyMirrors.agentMessageType.signed_urls_request,
-            signedUrlsRequest,
+            signedUrlsRequest
         });
     }
     handleAgentCommand(message) {
         switch (message.messageType) {
             case device_agent_schemas_1.keyMirrors.clientMessageType.live_state_updates:
-                this.liveUpdatesBroker(message.liveUpdatesToggles);
+                this.liveUpdatesHandler.update(message.liveUpdatesToggles);
                 break;
             default:
-                util_1.logger.error(`Invalid agent action message type from message '${message}'`);
+                logger_1.logger.error(`Invalid agent action message type from message '${message}'`);
         }
     }
-    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
+    async publishCloudRequest(payload) {
+        this.publisher.publishToCloud(payload);
     }
-    async liveUpdatesBroker({ deviceStats, appState, appLogs, }) {
-        this.restartLiveUpdatesTimeout();
-        if (deviceStats !== undefined) {
-            this.liveUpdatesAlive.device_stats = deviceStats;
-            if (deviceStats) {
-                this.startPublishingLiveUpdates(this.toClientTopic, device_agent_schemas_1.keyMirrors.agentMessageType.device_stats, this.getDeviceStatsMessage);
-            }
+    subscribe(topic) {
+        logger_1.logger.info(`Subscribing to ${topic}`);
+        this.device.subscribe(topic);
+    }
+    // eslint-disable-next-line
+    async atomicApplicationUpdate(func, args, projectId, appReleaseHash) {
+        this.appInstallStatusMgr.update(appReleaseHash, device_agent_schemas_1.keyMirrors.appInstallStatus.in_progress);
+        this.liveUpdatesHandler.update({
+            appInstallStatus: { toggle: true, appReleaseHash }
+        });
+        // Install the app and models
+        try {
+            const out = await func(...args);
+            this.appInstallStatusMgr.update(appReleaseHash, device_agent_schemas_1.keyMirrors.appInstallStatus.success);
+            this.liveUpdatesHandler.update({
+                appInstallStatus: { toggle: false, appReleaseHash }
+            });
+            // update app config shadow for project
+            await this.shadowHandler.publishAppState(projectId);
+            return out;
         }
-        if (appState !== undefined) {
-            this.liveUpdatesAlive.app_state = appState;
-            if (appState) {
-                this.startPublishingLiveUpdates(this.toClientTopic, device_agent_schemas_1.keyMirrors.agentMessageType.app_state, this.getAppStateMessage);
-            }
+        catch (e) {
+            logger_1.logger.error(e);
+            const message = e.message;
+            // uninstall the failed app to put system back in good state
+            await (0, application_control_1.uninstallApp)({ projectId });
+            this.appInstallStatusMgr.update(appReleaseHash, device_agent_schemas_1.keyMirrors.appInstallStatus.failure, message);
+            this.liveUpdatesHandler.update({
+                appInstallStatus: { toggle: false, appReleaseHash }
+            });
+            // delete shadow for project
+            // FIXME: Why do we delete the shadow? Doesn't this delete it for all projects?
+            this.shadowHandler.deleteProjectShadow();
         }
-        if (appLogs !== undefined) {
-            if (appLogs.toggle) {
-                this.startAppLogStream(appLogs.projectId);
+    }
+    async handleAppConfigUpdates(appConfgUpdates) {
+        for (const appConfigUpdate of appConfgUpdates) {
+            const { projectId, newAppCfg, updatedModels } = appConfigUpdate;
+            if (updatedModels && Object.keys(updatedModels).length) {
+                // Publish request for model urls
+                this.newAppCfgQueue.push(newAppCfg);
+                logger_1.logger.debug(`Requesting presigned urls from cloud for model versions: ${JSON.stringify(updatedModels)}`);
+                this.publisher.publishToCloud({
+                    messageType: device_agent_schemas_1.keyMirrors.agentMessageType.signed_urls_request,
+                    modelsOnlyUrlsRequest: {
+                        projectId,
+                        models: updatedModels
+                    }
+                });
             }
             else {
-                this.appLogStreams.delete(appLogs.projectId);
+                // FIXME: do we need to send this up to the cloud?
+                // should it be something other than appReleaseHash?
+                const appReleaseHash = await (0, agent_config_1.AgentConfigFile)().getAppVersion({
+                    projectId
+                });
+                await this.atomicApplicationUpdate(application_control_1.updateAppCfg, [
+                    {
+                        projectId,
+                        appReleaseHash,
+                        newAppCfg
+                    }
+                ], projectId, appReleaseHash);
             }
         }
     }
-    async publishReportedState(projectId) {
-        const newAppCfg = await (0, utils_1.getAppConfig)(projectId);
-        const packet = {
-            state: {
-                reported: {
-                    [projectId]: { appConfig: newAppCfg },
-                },
-            },
-        };
-        this.publishMessage(`${this.shadowPrefix}projects/update`, JSON.stringify(packet));
-    }
-    async publishCloudRequest(payload) {
-        const topic = this.toCloudTopic;
-        const deviceRequestPacket = this.buildMessagePacket(this.getClientId(), topic, payload);
-        this.publishMessage(topic, JSON.stringify({ deviceRequestPacket }));
-    }
     getClientId() {
         return this.clientId;
     }
-    publishMessage(topic, message) {
-        // TODO: topic validation
-        this.device.publish(topic, message, (err) => { });
-    }
-    async handleClientMessage({ topic, message, }) {
+    async handleClientMessage({ topic, message }) {
         const payload = message.payload;
         switch (payload.messageType) {
             case device_agent_schemas_1.keyMirrors.clientMessageType.app_state_control: {
@@ -336,146 +164,101 @@ class DeviceAgentCloudConnection {
                 break;
             }
             case device_agent_schemas_1.keyMirrors.clientMessageType.app_install_cloud_response: {
-                const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload, } = payload.appInstallCloudResponse;
-                this.initAppInstallStatus({
-                    status: device_agent_schemas_1.keyMirrors.appInstallStatus.in_progress,
-                    appReleaseHash,
-                });
-                this.startPublishingLiveUpdates(this.toClientTopic, device_agent_schemas_1.keyMirrors.agentMessageType.app_install_status, this.getAppInstallStatusMessage);
-                // Install the app and models
-                try {
-                    const signedUrlsPayload = {
-                        appInstallPayload,
-                        modelsInstallPayload,
-                    };
-                    await (0, install_1.installApp)({
-                        projectId,
-                        appReleaseHash,
-                        signedUrlsPayload,
-                    });
-                    this.updateAppInstallStatus({
-                        status: device_agent_schemas_1.keyMirrors.appInstallStatus.success,
-                    });
-                    // update app config shadow for project
-                    await this.publishReportedState(projectId);
-                }
-                catch (e) {
-                    util_1.logger.error(e);
-                    const message = e.message;
-                    // uninstall the failed app to put system back in good state
-                    await (0, install_1.uninstallApp)({ projectId });
-                    this.updateAppInstallStatus({
-                        status: device_agent_schemas_1.keyMirrors.appInstallStatus.failure,
-                        message,
-                    });
-                    // delete shadow for project
-                    this.publishMessage(`${this.shadowPrefix}${projectId}/delete`, "");
-                }
+                const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } = payload.appInstallCloudResponse;
+                const signedUrlsPayload = {
+                    appInstallPayload,
+                    modelsInstallPayload
+                };
+                await this.atomicApplicationUpdate(application_control_1.installApp, [{ projectId, appReleaseHash, signedUrlsPayload }], projectId, appReleaseHash);
                 break;
             }
             case device_agent_schemas_1.keyMirrors.clientMessageType.models_install_cloud_response: {
                 const { projectId, newModels } = payload.modelsInstallCloudResponse;
-                try {
-                    await (0, models_1.updateModelsWithPresignedUrls)(projectId, newModels);
-                    await this.publishReportedState(projectId);
-                }
-                catch (e) {
-                    util_1.logger.error(e);
+                const appReleaseHash = await (0, agent_config_1.AgentConfigFile)().getAppVersion({
+                    projectId
+                });
+                const newAppCfg = this.newAppCfgQueue.shift();
+                if (newAppCfg === undefined) {
+                    throw new Error('Unknown error while updating models via application config! No config present for model update.');
                 }
+                await this.atomicApplicationUpdate(application_control_1.updateModelsWithPresignedUrls, [
+                    {
+                        projectId,
+                        modelInstallPayloads: newModels,
+                        newAppCfg,
+                        appReleaseHash
+                    }
+                ], projectId, appReleaseHash);
                 break;
             }
             default:
-                util_1.logger.error(`Invalid Client Message '${JSON.stringify(payload)}'`);
+                logger_1.logger.error(`Invalid client message: '${JSON.stringify({ topic, message }, null, 2)}'`);
         }
     }
-    async handleShadowTopic({ topic, payload, }) {
-        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),
-                });
+    async setupHandlers() {
+        this.device.on('connect', (connack) => {
+            logger_1.logger.info('Device Agent has connected to the cloud');
+            // Get shadow updates
+            this.shadowHandler.getShadowUpdates();
+        });
+        this.device.on('disconnect', () => {
+            logger_1.logger.warn('Device Agent has been disconnected from the cloud');
+        });
+        this.device.on('reconnect', () => {
+            logger_1.logger.info(`Device Agent attempting to re-connect ${new Date().toLocaleString()}`);
+        });
+        this.device.on('message', async (topic, payload) => {
+            try {
+                const jsonPacket = JSON.parse(payload);
+                logger_1.logger.debug(`Received message: ${JSON.stringify({ topic, jsonPacket }, null, 2)}`);
+                if (Object.prototype.hasOwnProperty.call(jsonPacket, 'state')) {
+                    if (jsonPacket.clientToken === this.getClientId()) {
+                        logger_1.logger.debug(`Ignoring message sent from self: ${JSON.stringify({ topic, jsonPacket }, null, 2)}`);
+                        return;
+                    }
+                    const appConfigUpdates = await this.shadowHandler.handleShadowTopic({
+                        topic,
+                        payload: jsonPacket.state
+                    });
+                    await this.handleAppConfigUpdates(appConfigUpdates);
+                }
+                else {
+                    const valid = (0, device_agent_schemas_1.validateClientMessage)(jsonPacket);
+                    if (!valid) {
+                        logger_1.logger.error(`Error validating message: ${JSON.stringify(device_agent_schemas_1.validateClientMessage.errors, null, 2)}`);
+                    }
+                    else {
+                        this.handleClientMessage({
+                            topic,
+                            message: jsonPacket
+                        });
+                    }
+                }
             }
-            else {
-                util_1.logger.info(`No delta updates in shadow ${shadowName}`);
+            catch (error) {
+                logger_1.logger.error(`Error parsing message: ${error}`);
             }
-        }
+        });
+        this.device.on('offline', () => {
+            logger_1.logger.warn(`Device Agent is offline ${new Date().toLocaleString()}`);
+        });
     }
 }
 exports.DeviceAgentCloudConnection = DeviceAgentCloudConnection;
 async function runDeviceAgentCloudInterface() {
-    switch ((0, fs_1.existsSync)((0, directories_1.getCertificateFilePath)())) {
-        case true:
-            {
-                const deviceAgent = new DeviceAgentCloudConnection();
-                deviceAgent.device.on("connect", function (connack) {
-                    util_1.logger.info("Device Agent has connected to the cloud");
-                    // Get shadow updates
-                    deviceAgent.publishMessage(`${deviceAgent.getShadowPrefix()}projects/get`, "");
-                });
-                deviceAgent.device.on("disconnect", function () {
-                    util_1.logger.info("Device Agent has been disconnected from the cloud");
-                });
-                deviceAgent.device.on("message", function (topic, payload) {
-                    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 = (0, device_agent_schemas_1.validateClientMessage)(jsonPacket);
-                            if (!valid) {
-                                console.error(JSON.stringify(device_agent_schemas_1.validateClientMessage.errors));
-                            }
-                            else {
-                                deviceAgent.handleClientMessage({
-                                    topic,
-                                    message: jsonPacket,
-                                });
-                            }
-                        }
-                    }
-                    catch (error) {
-                        util_1.logger.error(error);
-                    }
-                });
-                deviceAgent.device.on("packetsend", (packet) => {
-                    //console.log({ packet: packet });
-                });
-            }
-            break;
-        case false: {
-            //set timer
-            const clientId = (0, get_device_id_1.getDeviceId)();
-            const bootstrapConfig = {
-                keyPath: directories_1.BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH,
-                certPath: directories_1.BOOTSTRAP_DEVICE_CERTIFICATE_FILE_PATH,
-                caPath: directories_1.AWS_ROOT_CERTIFICATE_FILE_PATH,
-                clientId,
-                host: (0, urls_1.getIoTCoreEndpointUrl)(),
-            };
-            const bootstrapAgent = new device_agent_1.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, payload) => {
-                bootstrapAgent.handleAwsCertificateTopics(topic, payload);
-            });
-            bootstrapAgent.device.on("packetsend", (packet) => {
-                console.log({ packet: packet.subscriptions });
-            });
-        }
+    // FIXME: Check for KeyPath as well
+    if ((0, fs_1.existsSync)((0, directories_1.getCertificateFilePath)())) {
+        const deviceAgent = new DeviceAgentCloudConnection();
+        await deviceAgent.setupHandlers();
+    }
+    else if ((0, fs_1.existsSync)((0, directories_1.BOOTSTRAP_DEVICE_PRIVATE_KEY_FILE_PATH)())) {
+        (0, bootstrap_provision_1.bootstrapProvision)();
+    }
+    else if ((0, fs_1.existsSync)((0, directories_1.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");
+    }
+    else {
+        throw new Error("Set device agent to local mode and retry the 'aai-agent device init' command");
     }
 }
 exports.runDeviceAgentCloudInterface = runDeviceAgentCloudInterface;