@alwaysai/device-agent 1.5.0 → 2.0.1

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

@@ -1,19 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDeviceAgentCloudInterface = exports.DeviceAgentCloudConnection = void 0;
-// eslint-disable-next-line
-const awsIot = require('aws-iot-device-sdk');
 const device_agent_schemas_1 = require("@alwaysai/device-agent-schemas");
 const fs_1 = require("fs");
-const application_control_1 = require("../application-control");
-const backup_1 = require("../application-control/backup");
-const device_control_1 = require("../device-control/device-control");
 const environment_1 = require("../environment");
-const agent_config_1 = require("../infrastructure/agent-config");
+const device_certificate_1 = require("../infrastructure/device-certificate");
+const legacy_migration_1 = require("../infrastructure/legacy-migration/legacy-migration");
+const required_config_checks_1 = require("../infrastructure/required-config-checks");
 const urls_1 = require("../infrastructure/urls");
 const secure_tunneling_1 = require("../secure-tunneling/secure-tunneling");
-const cloud_mode_ready_1 = require("../util/cloud-mode-ready");
-const directories_1 = require("../util/directories");
+const secure_tunnel_message_handler_1 = require("../secure-tunneling/secure-tunnel-message-handler");
+const check_for_updates_1 = require("../util/check-for-updates");
 const get_device_id_1 = require("../util/get-device-id");
 const logger_1 = require("../util/logger");
 const sleep_1 = require("../util/sleep");
@@ -22,538 +19,102 @@ const live_updates_handler_1 = require("./live-updates-handler");
 const passthrough_handler_1 = require("./passthrough-handler");
 const publisher_1 = require("./publisher");
 const shadow_handler_1 = require("./shadow-handler");
+const job_handler_1 = require("../jobs/job-handler");
 const transaction_manager_1 = require("./transaction-manager");
-const child_process_1 = require("child_process");
-const util_1 = require("util");
-const models_1 = require("../application-control/models");
-const check_for_updates_1 = require("../util/check-for-updates");
-const exec_promise = (0, util_1.promisify)(child_process_1.exec);
+const connection_manager_1 = require("./connection-manager");
+const device_agent_message_handler_1 = require("./device-agent-message-handler");
 class DeviceAgentCloudConnection {
-    /*=================================================================
-                              Public interface
-    =================================================================*/
     constructor() {
-        this.device = awsIot.device;
         this.clientId = (0, get_device_id_1.getDeviceUuid)();
         this.host = (0, urls_1.getIoTCoreEndpointUrl)();
         this.port = 8883;
         this.toDeviceTopic = (0, device_agent_schemas_1.getToDeviceTopic)(this.clientId);
-        this.secureTunnelNotifyTopic = `$aws/things/${this.clientId}/tunnels/notify`;
         this.secureTunnelHandler = secure_tunneling_1.SecureTunnelHandlerSingleton.getInstance();
-        this.handleAppStateControl = async (payload) => {
-            const { baseCommand, projectId } = payload;
-            switch (baseCommand) {
-                case device_agent_schemas_1.keyMirrors.appStateControl.start:
-                    await (0, application_control_1.startApp)({ projectId });
-                    break;
-                case device_agent_schemas_1.keyMirrors.appStateControl.stop:
-                    await (0, application_control_1.stopApp)({ projectId });
-                    break;
-                case device_agent_schemas_1.keyMirrors.appStateControl.restart:
-                    await (0, application_control_1.restartApp)({ projectId });
-                    break;
-            }
-            return true;
-        };
-        this.handleAppVersionControl = async (payload, txId) => {
-            switch (payload.baseCommand) {
-                case device_agent_schemas_1.keyMirrors.appVersionControl.install: {
-                    const { projectId, appReleaseHash } = payload;
-                    const signedUrlsRequestPayload = {
-                        signedUrlsRequest: {
-                            projectId,
-                            appReleaseHash
-                        }
-                    };
-                    const message = (0, device_agent_schemas_1.buildSignedUrlsRequestMessage)(this.clientId, signedUrlsRequestPayload, txId);
-                    await this.publishCloudRequest(message);
-                    return false;
-                }
-                case device_agent_schemas_1.keyMirrors.appVersionControl.uninstall: {
-                    const { projectId } = payload;
-                    await this.atomicApplicationUninstall(projectId);
-                    return true;
-                }
-                default:
-                    logger_1.logger.warn(`Ignore App Version Control packet: ${JSON.stringify(payload, null, 2)}`);
-                    return true;
-            }
-        };
-        this.handleAppInstallCloudResponsePayload = async (payload) => {
-            const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } = payload.appInstallResponse;
-            const signedUrlsPayload = {
-                appInstallPayload,
-                modelsInstallPayload
-            };
-            await this.atomicApplicationUpdate(async () => {
-                this.shadowHandler.clearProjectShadow(projectId);
-                await (0, application_control_1.installApp)({ projectId, appReleaseHash, signedUrlsPayload });
-            }, projectId);
-            return true;
-        };
-        this.handleModelsInstallCloudResponsePayload = async (payload, txId) => {
-            const projectId = payload.modelsInstallResponse.projectId;
-            const update = this.txnMgr.getAppCfgUpdateFromTxID(txId);
-            if (update === undefined) {
-                throw new Error('Unknown error while updating models via application config! No config present for model update.');
-            }
-            const { appCfgUpdate, envVarUpdate } = update;
-            if (appCfgUpdate) {
-                await this.atomicApplicationUpdate(async () => await (0, application_control_1.updateModelsWithPresignedUrls)({
-                    projectId,
-                    modelInstallPayloads: payload.modelsInstallResponse.newModels,
-                    newAppCfg: appCfgUpdate.newAppCfg
-                }), projectId);
-            }
-            if (envVarUpdate) {
-                await this.atomicApplicationUpdate(async () => await this.shadowHandler.updateProjectEnvVars({
-                    projectId,
-                    envVars: envVarUpdate.envVars
-                }), projectId, true);
-            }
-            return true;
-        };
-        this.handleProjectShadowConfigUpdate = async (update, txId) => {
-            const { projectId, appCfgUpdate, envVarUpdate } = update;
-            if ((appCfgUpdate === null || appCfgUpdate === void 0 ? void 0 : appCfgUpdate.updatedModels) &&
-                Object.keys(appCfgUpdate.updatedModels).length) {
-                // When there are model updates request signed URLs and wait to apply config changes
-                const { updatedModels } = appCfgUpdate;
-                logger_1.logger.debug(`Requesting presigned urls from cloud for model versions: ${JSON.stringify(updatedModels)}`);
-                const modelsOnlyUrlsRequestPayload = {
-                    modelsOnlyUrlsRequest: {
-                        projectId,
-                        models: updatedModels
-                    }
-                };
-                const message = (0, device_agent_schemas_1.buildSignedUrlsRequestMessage)(this.clientId, modelsOnlyUrlsRequestPayload, txId);
-                this.publisher.publishToCloud(message);
-                this.txnMgr.setAppCfgUpdateToTx(txId, update);
-                return false;
-            }
-            if (appCfgUpdate) {
-                await this.atomicApplicationUpdate(async () => {
-                    await (0, models_1.pruneModels)({
-                        projectId,
-                        appCfg: appCfgUpdate.newAppCfg
-                    });
-                    await (0, application_control_1.updateAppCfg)({
-                        projectId,
-                        newAppCfg: appCfgUpdate.newAppCfg
-                    });
-                }, projectId);
-            }
-            if (envVarUpdate) {
-                await this.atomicApplicationUpdate(async () => await this.shadowHandler.updateProjectEnvVars({
-                    projectId,
-                    envVars: envVarUpdate.envVars
-                }), projectId, true);
-            }
-            return true;
-        };
-        this.device = awsIot.device({
-            keyPath: directories_1.DEVICE_PRIVATE_KEY_FILE_PATH,
-            certPath: directories_1.DEVICE_CERTIFICATE_FILE_PATH,
-            caPath: directories_1.AWS_ROOT_CERTIFICATE_FILE_PATH,
-            clientId: this.clientId,
-            host: this.host,
-            port: this.port,
-            keepalive: 1 // time before re-connect attempt on dropped connection, default is 400 seconds
-        });
-        this.publisher = new publisher_1.Publisher(this.device, this.clientId);
+        this.liveUpdatesHandler = new live_updates_handler_1.LiveUpdatesHandler();
+        // Initialize & setup the connection
+        this.connectionManager = new connection_manager_1.ConnectionManager(this.clientId, this.host, this.port);
+        this.connectionManager.setupConnection();
+        // Initialize the Publisher, ShadowHandler & Transaction Manager
+        this.publisher = new publisher_1.Publisher(this.connectionManager.getIoTDevice(), this.clientId);
         this.shadowHandler = new shadow_handler_1.ShadowHandler(this.clientId, this.publisher);
-        this.liveUpdatesHandler = new live_updates_handler_1.LiveUpdatesHandler(this.publisher, this.clientId);
-        this.txnMgr = new transaction_manager_1.TransactionManager(this.publisher, this.liveUpdatesHandler);
-        this.subscribe(this.toDeviceTopic);
-        this.subscribe(this.secureTunnelNotifyTopic);
-        for (const topic of this.shadowHandler.projectShadowTopics) {
-            this.subscribe(topic);
-        }
-        this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.updateDelta);
-        this.subscribe(this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted);
-    }
-    async handleDeviceAction(payload) {
-        const { system_restart } = device_agent_schemas_1.keyMirrors.deviceAction;
-        switch (payload.action) {
-            case system_restart: {
-                await (0, device_control_1.reboot)();
-                break;
-            }
-            default: {
-                logger_1.logger.info(`Unrecognized device action requested: '${payload.action}'.`);
-            }
-        }
-    }
-    async publishCloudRequest(message) {
-        this.publisher.publishToCloud(message);
-    }
-    subscribe(topic) {
-        logger_1.logger.info(`Subscribing to ${topic}`);
-        this.device.subscribe(topic);
-    }
-    async atomicApplicationUninstall(projectId) {
-        try {
-            await (0, application_control_1.uninstallApp)({ projectId });
-            this.shadowHandler.clearProjectShadow(projectId);
-        }
-        catch (e) {
-            logger_1.logger.error(`Failed to uninstall ${projectId}: ${e.message}`);
-            throw e;
-        }
-    }
-    // eslint-disable-next-line
-    async atomicApplicationUpdate(func, projectId, skipUpdateShadow) {
-        // First try to create a backup, so that there is one available if something goes wrong in the next try:catch.
-        if (await (0, agent_config_1.AgentConfigFile)().isAppPresent({ projectId })) {
-            try {
-                await (0, backup_1.createAppBackup)({ projectId });
-            }
-            catch (e) {
-                logger_1.logger.error(`Could not create a backup for the project: ${projectId}:\n${e.message}\n${e.stack}`);
-            }
-        }
-        try {
-            const out = await func();
-            if (!skipUpdateShadow)
-                await this.shadowHandler.updateProjectShadow(projectId);
-            return out;
-        }
-        catch (errorAppUpdate) {
-            logger_1.logger.error(`Failed to update ${projectId}:\n${JSON.stringify(errorAppUpdate)}}`);
-            // If something goes wrong, first try to rollback
-            try {
-                await (0, backup_1.rollbackApp)({ projectId });
-                logger_1.logger.error(`Application update failed, rolled back to previous version: ${errorAppUpdate}`);
-            }
-            catch (errorRollbackApp) {
-                // and if that fails, uninstall the app as a last resort.
-                try {
-                    await this.atomicApplicationUninstall(projectId);
-                }
-                catch (_a) {
-                    // atomicApplicationUninstall handles failing, so there's nothing to handle here.
-                }
-                logger_1.logger.error(`Application update failed, rolled back to previous version: ${errorAppUpdate}`);
-                throw new Error(`Application update and rollback failed, uninstalled the application: ${errorAppUpdate}`);
-            }
-            throw new Error(`Application update failed, rolled the application back: ${errorAppUpdate}`);
-        }
-    }
-    async handleProjectShadowMessage(topic, message) {
-        const shadowUpdates = await this.shadowHandler.handleProjectShadow({
-            topic,
-            payload: message,
-            clientToken: message.clientToken
+        this.transactionManager = new transaction_manager_1.TransactionManager(this.publisher, this.liveUpdatesHandler);
+        // Construct a HandlerContext used by all the message handlers
+        const handlerContext = {
+            clientId: this.clientId,
+            txnMgr: this.transactionManager,
+            publisher: this.publisher,
+            shadowHandler: this.shadowHandler,
+            liveUpdatesHandler: this.liveUpdatesHandler,
+            secureTunnelHandler: this.secureTunnelHandler
+        };
+        // Instantiate & register message handlers for Project Shadow topics
+        const projectShadowMessageHandler = new shadow_handler_1.ProjectShadowMessageHandler(handlerContext);
+        this.shadowHandler.projectShadowTopics.forEach((topic) => {
+            this.connectionManager.registerHandler(topic, projectShadowMessageHandler);
         });
-        if (shadowUpdates.length) {
-            const shadowUpdatePromises = [];
-            for (const shadowUpdate of shadowUpdates) {
-                const projectId = shadowUpdate.projectId;
-                const txId = shadowUpdate.txId;
-                shadowUpdatePromises.push(this.txnMgr
-                    .runTransactionStep({
-                    func: () => this.handleProjectShadowConfigUpdate(shadowUpdate, txId),
-                    projectId,
-                    txId,
-                    start: true,
-                    stepName: topic
-                })
-                    .catch((e) => {
-                    logger_1.logger.error(`There was an issue updating project shadow config: ${JSON.stringify(e)}`);
-                }));
-            }
-            await Promise.all(shadowUpdatePromises);
-        }
-    }
-    async handleSecureTunnelMessage(payload) {
-        logger_1.logger.info(`Received secure tunnel update: ${JSON.stringify(payload)}`);
-        const state = payload.state;
-        if (!state) {
-            logger_1.logger.debug(`No state found in message: ${JSON.stringify(payload)}`);
-            return;
-        }
-        const valid = (0, device_agent_schemas_1.validateSecureTunnelShadowUpdate)(state);
-        if (!valid) {
-            logger_1.logger.error(`Error validating message: ${JSON.stringify({ payload, errors: device_agent_schemas_1.validateSecureTunnelShadowUpdate.errors }, null, 2)}`);
-            return;
-        }
-        const secureTunnelUpdate = await this.secureTunnelHandler.syncShadowToDeviceState(payload);
-        await this.shadowHandler.updateSecureTunnelShadow(secureTunnelUpdate);
-        return;
+        // Instantiate & register message handlers for to-device and secureTunnel topics
+        this.connectionManager.registerHandler(this.toDeviceTopic, new device_agent_message_handler_1.DeviceAgentMessageHandler(handlerContext, (txId, errorMsg) => {
+            const msg = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.publisher.getClientId(), {
+                status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
+                message: errorMsg
+            }, txId);
+            this.publisher.publishToClient(msg);
+        }, (txId) => {
+            const msg = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.publisher.getClientId(), { status: device_agent_schemas_1.keyMirrors.statusResponse.success }, txId);
+            this.publisher.publishToClient(msg);
+        }));
+        const secureTunnelMessageHandler = new secure_tunnel_message_handler_1.SecureTunnelMessageHandler(handlerContext);
+        this.connectionManager.registerHandler(secureTunnelMessageHandler.getNotifyTopic(), secureTunnelMessageHandler);
+        this.connectionManager.registerHandler(this.shadowHandler.shadowTopics.secureTunnel.updateDelta, secureTunnelMessageHandler);
+        this.connectionManager.registerHandler(this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted, secureTunnelMessageHandler);
+        const jobHandler = new job_handler_1.JobHandler(handlerContext);
+        const JOB_HANDLER_TOPICS = jobHandler.getJobTopic();
+        this.connectionManager.registerHandler(JOB_HANDLER_TOPICS.NOTIFY_NEXT, jobHandler);
+        this.connectionManager.registerHandler(JOB_HANDLER_TOPICS.START_NEXT_ACCEPTED, jobHandler);
+        // Initialize job
+        this.publisher.publish(JOB_HANDLER_TOPICS.START_NEXT, JSON.stringify({}));
     }
+    /*=================================================================
+                              Public interface
+    =================================================================*/
     getClientId() {
         return this.clientId;
     }
-    getToDeviceTopic() {
-        return this.toDeviceTopic;
-    }
     isCmdInProgress(projectId) {
-        return this.txnMgr.isOngoingTransactionForProjectID(projectId);
-    }
-    async updateProjectShadow(projectId) {
-        await this.shadowHandler.updateProjectShadow(projectId);
-    }
-    async handleDeviceAgentMessage({ topic, message }) {
-        const valid = (0, device_agent_schemas_1.validateToDeviceAgentMessage)(message);
-        if (!valid) {
-            logger_1.logger.error(`Error validating message: ${JSON.stringify({ topic, message, errors: device_agent_schemas_1.validateToDeviceAgentMessage.errors }, null, 2)}`);
-            // TODO: Send generic error response
-            return;
-        }
-        const txId = message.txId;
-        const { app_state_control, app_version_control, live_state_updates, app_install_response, models_install_response, status_response, device_action } = device_agent_schemas_1.keyMirrors.toDeviceAgentMessageType;
-        switch (message.messageType) {
-            case app_state_control: {
-                // txId sent from cloud, just need to continue it
-                const payload = message.payload;
-                const projectId = payload.projectId;
-                try {
-                    await this.txnMgr.runTransactionStep({
-                        func: () => this.handleAppStateControl(message.payload),
-                        projectId,
-                        txId,
-                        start: true,
-                        stepName: payload.baseCommand
-                    });
-                }
-                catch (e) {
-                    logger_1.logger.error(`Error processing application state control request: ${e}!`);
-                }
-                break;
-            }
-            case app_version_control: {
-                // txId sent from cloud, just need to continue it
-                const payload = message.payload;
-                const projectId = payload.projectId;
-                try {
-                    await this.txnMgr.runTransactionStep({
-                        func: () => this.handleAppVersionControl(payload, txId),
-                        projectId,
-                        txId,
-                        start: true,
-                        stepName: payload.baseCommand
-                    });
-                }
-                catch (e) {
-                    logger_1.logger.error(`Error processing application install request: ${e}!`);
-                }
-                break;
-            }
-            case live_state_updates: {
-                const payload = message.payload;
-                // TODO: Send response?
-                void this.liveUpdatesHandler.handleToggles(payload, txId);
-                break;
-            }
-            case app_install_response: {
-                const payload = message.payload;
-                const { projectId } = payload.appInstallResponse;
-                if (txId !== this.txnMgr.getTransactionFromProject(projectId)) {
-                    throw new Error(`App install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnMgr.getTransactionFromProject(projectId)})!`);
-                }
-                await this.txnMgr.runTransactionStep({
-                    func: () => this.handleAppInstallCloudResponsePayload(payload),
-                    projectId,
-                    txId,
-                    start: false,
-                    stepName: message.messageType
-                });
-                break;
-            }
-            case models_install_response: {
-                // This message doesn't have appReleaseHash in it's payload, but
-                // atomicCmd should be able to read it from the installed app
-                const payload = message.payload;
-                const { projectId } = payload.modelsInstallResponse;
-                if (txId !== this.txnMgr.getTransactionFromProject(projectId)) {
-                    throw new Error(`Model install response received a message for a transaction ID ${txId} that is not currently underway (${this.txnMgr.getTransactionFromProject(projectId)})!`);
-                }
-                await this.txnMgr.runTransactionStep({
-                    func: () => this.handleModelsInstallCloudResponsePayload(payload, txId),
-                    projectId,
-                    txId,
-                    start: false,
-                    stepName: message.messageType
-                });
-                break;
-            }
-            case status_response: {
-                const { failure } = device_agent_schemas_1.keyMirrors.statusResponse;
-                if (message.payload.status === failure) {
-                    this.txnMgr.completeTransaction(txId);
-                    const failureStatusResponsePayload = {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
-                        message: message.payload.message
-                    };
-                    // Send final status message
-                    const failureStatusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, failureStatusResponsePayload, txId);
-                    this.publisher.publishToClient(failureStatusResponseMessage);
-                }
-                break;
-            }
-            case device_action: {
-                try {
-                    const statusResponsePayload = {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.in_progress
-                    };
-                    const statusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, statusResponsePayload, txId);
-                    this.publisher.publishToClient(statusResponseMessage);
-                    await this.handleDeviceAction(message.payload);
-                    const successStatusResponsePayload = {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.success
-                    };
-                    const successStatusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, successStatusResponsePayload, txId);
-                    this.publisher.publishToClient(successStatusResponseMessage);
-                }
-                catch (e) {
-                    logger_1.logger.error(`There was a problem performing device action '${message.payload.action}': ${e.message}`);
-                    const failureStatusResponsePayload = {
-                        status: device_agent_schemas_1.keyMirrors.statusResponse.failure,
-                        message: e.message
-                    };
-                    const failureStatusResponseMessage = (0, device_agent_schemas_1.buildToClientStatusResponseMessage)(this.clientId, failureStatusResponsePayload, txId);
-                    this.publisher.publishToClient(failureStatusResponseMessage);
-                }
-                break;
-            }
-            default:
-                logger_1.logger.error(`Invalid client message: '${JSON.stringify({ topic, message, txId }, null, 2)}'`);
-        }
-    }
-    async handleMessage(topic, message) {
-        logger_1.logger.debug(`Received message: ${JSON.stringify({ topic, message }, null, 2)}`);
-        // ProjectShadow messages
-        if (this.shadowHandler.projectShadowTopics.includes(topic)) {
-            await this.handleProjectShadowMessage(topic, message);
-        }
-        else if (topic === this.toDeviceTopic) {
-            await this.handleDeviceAgentMessage({
-                topic,
-                message
-            });
-            // SecureTunnelNotify messages
-        }
-        else if (topic === this.secureTunnelNotifyTopic) {
-            await this.secureTunnelHandler.secureTunnelNotifyHandler(message);
-            // SecureTunnel messages
-        }
-        else if (topic === this.shadowHandler.shadowTopics.secureTunnel.updateDelta) {
-            await this.handleSecureTunnelMessage(message);
-        }
-        else if (topic === this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted) {
-            logger_1.logger.info(`Received secure tunnel deleteAccepted: ${message}`);
-            await this.secureTunnelHandler.destroy();
-        }
-        else {
-            logger_1.logger.error(`Unexpected topic, ignoring! ${topic}`);
-        }
-    }
-    async setupHandlers() {
-        this.device.on('connect', (connack) => {
-            logger_1.logger.info('Device Agent has connected to the cloud');
-            // FIXME: EI-709 Skip this request for now to prevent kicking off another
-            // shadow update process if IoT Core disconnect occurs during app config update
-            //this.shadowHandler.getShadowUpdates();
-            void this.shadowHandler.updateSystemInfoShadow();
-        });
-        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('error', function (error) {
-            const errorString = error.message.toString();
-            logger_1.logger.error(`${errorString}`);
-        });
-        this.device.on('message', async (topic, payload) => {
-            try {
-                const jsonPacket = JSON.parse(payload);
-                await this.handleMessage(topic, jsonPacket);
-            }
-            catch (e) {
-                logger_1.logger.error(`Error parsing message: ${e.message}`);
-            }
-        });
-        this.device.on('offline', () => {
-            logger_1.logger.warn(`Device Agent is offline ${new Date().toLocaleString()}`);
-            void this.logConnectionInfo();
-        });
-    }
-    async logConnectionInfo() {
-        try {
-            /**
-             * We're using the 'netcat' or 'nc' command to test the connection to the IoT Core endpoint.
-             * This command doesn't always exit (see below), so
-             * we use timeout to break out of the prompt
-             * and catch the resulting error/parse the resulting stderr
-             *
-             * Sample command for current host and port:
-             * nc -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 8883
-             *
-             * Sample output when port is not blocked and host is reachable:
-             * $ nc  -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 443
-             * Connection to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 443 port [tcp/https] succeeded!
-             *
-             *
-             * Sample output when port is blocked (will repeatedly try until ctrl-C out):
-             * $ nc -zv -w 1 a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com 8883
-             * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
-             * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
-             * nc: connect to a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com port 8883 (tcp) timed out: Operation now in progress
-             * ^C
-             *
-             *
-             * Sample command/output when the port isn't enable on that host:
-             * $ nc -zv -w 1 localhost 8883
-             * nc: connect to localhost port 8883 (tcp) failed: Connection refused
-             */
-            await exec_promise(`nc -zv -w 1 ${this.host} ${this.port}`, {
-                timeout: 2000
-            });
-        }
-        catch (err) {
-            const output = JSON.stringify(err['stderr']);
-            if (output.indexOf('not known') !== -1) {
-                logger_1.logger.warn('Iot Core endpoint appears to be unreachable, internet connection may be unstable or the host may be down.');
-            }
-            else if (output.indexOf('timed out') !== -1) {
-                logger_1.logger.warn(`Internet connection appears fine, however the endpoint was not reachable on the current connection port: ${this.port}\nPlease check if a firewall is in place.`);
-            }
-            else if (output.indexOf('refused') !== -1) {
-                logger_1.logger.warn(`The connection was refused, likely ${this.host} is not running a service on ${this.port}.`);
-            }
-            else {
-                logger_1.logger.warn(`Output from checking connection to ${this.host} on ${this.port}: ${output}`);
-            }
-        }
+        return this.transactionManager.isOngoingTransactionForProjectID(projectId);
     }
     async stop() {
         // This method is currently only used by the CLI, and shadow messages can be
         // lost since we aren't waiting for responses so sleep for a short time to
         // receive them
         await (0, sleep_1.default)(1000);
-        this.device.end();
+        this.connectionManager.disconnect();
+    }
+    async handleMessage(topic, message) {
+        this.connectionManager.dispatch(topic, message);
     }
 }
 exports.DeviceAgentCloudConnection = DeviceAgentCloudConnection;
 async function runDeviceAgentCloudInterface() {
     logger_1.logger.info(`Starting alwaysAI Device Agent v${await (0, check_for_updates_1.getDeviceAgentVersion)()}`);
-    if ((0, cloud_mode_ready_1.cloudModeReady)()) {
+    if ((0, fs_1.existsSync)((0, device_certificate_1.getBootstrapPrivateKeyFilePath)())) {
+        await (0, bootstrap_provision_1.bootstrapProvision)();
+        return;
+    }
+    const filesAlreadyMigrated = await (0, required_config_checks_1.requiredConfigFilesPresentAndValid)();
+    if (!filesAlreadyMigrated) {
+        logger_1.logger.debug('Attempting configuration file migration.');
+        await (0, legacy_migration_1.migrateFromLegacyCertsAndTokens)();
+    }
+    if (await (0, required_config_checks_1.requiredConfigFilesPresentAndValid)()) {
         const deviceAgent = new DeviceAgentCloudConnection();
-        await deviceAgent.setupHandlers();
         if (environment_1.ALWAYSAI_ANALYTICS_PASSTHROUGH === true) {
+            const shadowHandler = deviceAgent.shadowHandler;
             const publisher = deviceAgent.publisher;
-            const passthroughHandler = new passthrough_handler_1.PassthroughHandler(publisher);
+            const passthroughHandler = new passthrough_handler_1.PassthroughHandler(publisher, shadowHandler);
             await passthroughHandler.setup();
         }
     }
-    else if ((0, fs_1.existsSync)((0, directories_1.BOOTSTRAP_PRIVATE_KEY_FILE_PATH)())) {
-        await (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");
     }