@alwaysai/device-agent 1.5.0 → 2.0.1

package/src/infrastructure/tokens-and-device-cfg.ts

@@ -1,13 +1,14 @@
-import { logger } from '../util/logger';
-import { microServiceHttpClient } from '../util/http-client';
-import { requireLoggedInAndPaidPlan } from '../util/require-logged-in-and-paid-plan';
 import {
   DeviceTokens,
-  writeOrValidateDeviceCfgFile,
-  writeTokens
+  writeOrValidateDeviceCfgFile
 } from 'alwaysai/lib/core/device';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { getDeviceConfigPath } from 'alwaysai/lib/infrastructure';
 import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/paths';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { join } from 'path';
+import { microServiceHttpClient } from '../util/http-client';
+import { logger } from '../util/logger';
+import { requireLoggedInAndPaidPlan } from '../util/require-logged-in-and-paid-plan';
 
 // NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
 export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
@@ -21,14 +22,15 @@ export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
   );
 
   const tokens: DeviceTokens = {
-    deviceId: deviceUuid,
+    deviceUuid,
     accessToken,
     refreshToken,
     idToken
   };
-  const tokenSpawner = JsSpawner({ path: LOCAL_AAI_CFG_DIR });
-  await writeTokens({ spawner: tokenSpawner, tokens });
-  await writeOrValidateDeviceCfgFile({ spawner: tokenSpawner, deviceUuid });
+  const tokenSpawner = JsSpawner({
+    path: join(LOCAL_AAI_CFG_DIR, getDeviceConfigPath())
+  });
+  await writeOrValidateDeviceCfgFile({ spawner: tokenSpawner, ...tokens });
 
   logger.info('Updated tokens and certificate');
 }

package/src/jobs/job-handler.ts

@@ -0,0 +1,146 @@
+import { MessageHandler } from '../cloud-connection/message-dispatcher';
+import { logger } from '../util/logger';
+import {
+  BaseHandler,
+  HandlerContext
+} from '../cloud-connection/base-message-handler';
+import { DeviceAgentMessageHandler } from '../cloud-connection/device-agent-message-handler';
+
+class JobState {
+  private static instance: JobState;
+  public jobInProgress = false;
+
+  // Singleton pattern
+  private constructor() { } // eslint-disable-line
+
+  static getInstance(): JobState {
+    if (!JobState.instance) {
+      JobState.instance = new JobState();
+    }
+    return JobState.instance;
+  }
+}
+
+export class JobHandler extends BaseHandler implements MessageHandler {
+  private readonly msgHandler: DeviceAgentMessageHandler;
+
+  constructor(handlerContext: HandlerContext) {
+    super(handlerContext);
+    this.msgHandler = new DeviceAgentMessageHandler(
+      handlerContext,
+      this.handleJobError,
+      this.handleJobSuccess
+    );
+  }
+  private readonly state = JobState.getInstance();
+  private jobId = '';
+
+  public async handle(message: any, topic: string): Promise<void> {
+    const TOPICS = this.getJobTopic();
+
+    try {
+      switch (topic) {
+        case TOPICS.NOTIFY_NEXT:
+          await this.notifyNext(message);
+          break;
+        case TOPICS.START_NEXT_ACCEPTED:
+          this.startNextAccepted(message);
+          break;
+        default:
+          logger.info(`No handler for topic: ${topic}`);
+      }
+    } catch (error) {
+      logger.error(`Error handling job for topic: ${topic}`, error);
+    }
+  }
+
+  getJobTopic() {
+    const TOPICS = {
+      NOTIFY_NEXT: `$aws/things/${this.clientId}/jobs/notify-next`,
+      START_NEXT: `$aws/things/${this.clientId}/jobs/start-next`,
+      START_NEXT_ACCEPTED: `$aws/things/${this.clientId}/jobs/start-next/accepted`,
+      UPDATE: `$aws/things/${this.clientId}/jobs/${this.jobId}/update`
+    };
+    return TOPICS;
+  }
+
+  private async notifyNext(message: any): Promise<void> {
+    // Triggers when a job is completed and we need to notify the next job
+    logger.info('Invoking NOTIFY_NEXT handler');
+    const TOPICS = this.getJobTopic();
+    this.publisher.publish(TOPICS.START_NEXT, JSON.stringify({}));
+  }
+
+  private startNextAccepted(message: any): void {
+    if (this.state.jobInProgress) {
+      logger.info('Job already in progress');
+      return;
+    }
+
+    this.state.jobInProgress = true;
+
+    try {
+      if (message.execution) {
+        this.processJobExecution(message.execution);
+      } else {
+        this.state.jobInProgress = false;
+      }
+    } catch (error: unknown) {
+      this.handleError(error);
+    }
+    this.state.jobInProgress = false;
+  }
+
+  private processJobExecution(execution: any): void {
+    logger.info('Job in progress...');
+    const { jobDocument, jobId } = execution;
+    this.jobId = jobId;
+    this.msgHandler.handle(jobDocument);
+  }
+
+  private handleError(error: unknown): void {
+    if (error instanceof Error) {
+      logger.error(`Error starting next job`, error);
+      this.handleJobError('', error.message);
+    } else {
+      let errorMessage: string;
+      if (typeof error === 'string') {
+        errorMessage = error;
+      } else if (typeof error === 'object' && error !== null) {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch (jsonError) {
+          errorMessage = 'Unknown error (failed to stringify)';
+        }
+      } else {
+        errorMessage = 'Unknown error';
+      }
+      logger.error(`Unexpected error: ${errorMessage}`);
+      this.handleJobError('', errorMessage);
+    }
+  }
+
+  private updateJobStatus(status: string, message?: string): void {
+    const { UPDATE } = this.getJobTopic();
+    const payload = {
+      status,
+      statusDetails: {
+        message
+      }
+    };
+
+    this.publisher.publish(UPDATE, JSON.stringify(payload));
+    logger.info(`Marked job ${this.jobId} as ${status}`);
+    // Reset the job state
+    this.state.jobInProgress = false;
+  }
+
+  private readonly handleJobSuccess = (txId: string): void => {
+    this.updateJobStatus('SUCCEEDED');
+  };
+
+  private readonly handleJobError = (_txId: string, msg: string): void => {
+    logger.error(`Unexpected error type: ${msg}`);
+    this.updateJobStatus('FAILED', `Unexpected error: ${msg}`);
+  };
+}

package/src/local-connection/rabbitmq-connection.ts

@@ -1,13 +1,12 @@
-import { logger } from '../util/logger';
-import sleep from '../util/sleep';
-import { compose } from '../docker/docker-compose';
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
 import * as YAML from 'yaml';
-
+import { compose } from '../docker/docker-compose';
 import {
-  DEVICE_AGENT_CFG_PATH,
-  DEVICE_AGENT_DOCKER_COMPOSE_PATH
+  getDeviceAgentConfigPath,
+  getDeviceAgentDockerComposePath
 } from '../util/directories';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+import sleep from '../util/sleep';
 import { LOCAL_CONNECTION_PORT } from './constants';
 
 export const rabbitMQServiceName = 'alwaysAIRabbitMQ';
@@ -16,13 +15,13 @@ export const rabbitMQContainerName = 'alwaysAIRabbitMQContainer';
 export async function checkRabbitMQContainerRunning() {
   logger.debug('Checking alwaysAI Local Connection Container status');
   const spawner = JsSpawner();
-  if (!(await spawner.exists(DEVICE_AGENT_DOCKER_COMPOSE_PATH))) {
+  if (!(await spawner.exists(getDeviceAgentDockerComposePath()))) {
     logger.warn(
       'alwaysAI Location Connection configuration file is not present'
     );
     return false;
   }
-  const containerData = await compose.ps({ cwd: DEVICE_AGENT_CFG_PATH });
+  const containerData = await compose.ps({ cwd: getDeviceAgentConfigPath() });
   if (containerData !== undefined) {
     const rabbitmqService = containerData.data.services[0];
     if (
@@ -41,8 +40,8 @@ export async function checkRabbitMQContainerRunning() {
 
 export async function writeRabbitMQDockerComposeFile() {
   const spawner = JsSpawner();
-  if (!(await spawner.exists(DEVICE_AGENT_CFG_PATH))) {
-    await JsSpawner().mkdirp(DEVICE_AGENT_CFG_PATH);
+  if (!(await spawner.exists(getDeviceAgentConfigPath()))) {
+    await JsSpawner().mkdirp(getDeviceAgentConfigPath());
   }
 
   logger.debug(
@@ -68,7 +67,7 @@ export async function writeRabbitMQDockerComposeFile() {
 
   const RabbitMQDockerComposeYaml = YAML.stringify(rabbitmqDockerComposeCmd);
   await spawner.writeFile(
-    DEVICE_AGENT_DOCKER_COMPOSE_PATH,
+    getDeviceAgentDockerComposePath(),
     RabbitMQDockerComposeYaml
   );
 }
@@ -79,12 +78,14 @@ export async function setupRabbitMQContainer() {
     await writeRabbitMQDockerComposeFile();
   } catch (e) {
     logger.error(
-      `An error occurred setting up docker-compose.yaml for Device Agent pass through:\n{e.message}`
+      `An error occurred setting up docker-compose.yaml for Device Agent pass through!\n${stringifyError(
+        e
+      )}`
     );
   }
   try {
     const upOut = await compose.upAll({
-      cwd: DEVICE_AGENT_CFG_PATH
+      cwd: getDeviceAgentConfigPath()
     });
     logger.debug(
       `Docker compose up for alwaysAI Local Connection:\n${JSON.stringify(
@@ -97,14 +98,16 @@ export async function setupRabbitMQContainer() {
     }
   } catch (e) {
     logger.error(
-      `Unable to start alwaysAI Device Agent Local Connection Container:\n${e}`
+      `Unable to start alwaysAI Device Agent Local Connection Container!\n${stringifyError(
+        e
+      )}`
     );
   }
 }
 
 export async function stopRabbitMQContainer() {
   try {
-    const downOut = await compose.down({ cwd: DEVICE_AGENT_CFG_PATH });
+    const downOut = await compose.down({ cwd: getDeviceAgentConfigPath() });
     logger.debug(`Stopping alwaysAI Local Connection container`);
     logger.debug(
       `Docker compose down for alwaysAI Local Connection:\n${JSON.stringify(
@@ -113,7 +116,9 @@ export async function stopRabbitMQContainer() {
     );
   } catch (e) {
     logger.error(
-      `Unable to stop alwaysAI Device Agent Local Connection Container:\n${e.message}`
+      `Unable to stop alwaysAI Device Agent Local Connection Container!\n${stringifyError(
+        e
+      )}`
     );
   }
 }

package/src/secure-tunneling/secure-tunnel-message-handler.ts

@@ -0,0 +1,56 @@
+import {
+  getUpdateDeltaStateFromMessage,
+  validateSecureTunnelShadowUpdate
+} from '@alwaysai/device-agent-schemas';
+import { MessageHandler } from '../cloud-connection/message-dispatcher';
+import { logger } from '../util/logger';
+import { BaseHandler } from '../cloud-connection/base-message-handler';
+
+export class SecureTunnelMessageHandler
+  extends BaseHandler
+  implements MessageHandler<any>
+{
+  public getNotifyTopic(): string {
+    return `$aws/things/${this.clientId}/tunnels/notify`;
+  }
+
+  public async handle(message: any, topic: string): Promise<void> {
+    const secureTunnelNotifyTopic = this.getNotifyTopic();
+    if (topic === secureTunnelNotifyTopic) {
+      await this.secureTunnelHandler.secureTunnelNotifyHandler(message);
+    } else if (
+      topic === this.shadowHandler.shadowTopics.secureTunnel.updateDelta
+    ) {
+      logger.info(`Received secure tunnel update: ${JSON.stringify(message)}`);
+      await this.handleSecureTunnelMessage(message);
+    } else if (
+      topic === this.shadowHandler.shadowTopics.secureTunnel.deleteAccepted
+    ) {
+      logger.info(`Received secure tunnel deleteAccepted: ${message}`);
+      await this.secureTunnelHandler.destroy();
+    }
+  }
+
+  public async handleSecureTunnelMessage(payload: any): Promise<void> {
+    logger.info(`Received secure tunnel update: ${JSON.stringify(payload)}`);
+    const state = getUpdateDeltaStateFromMessage(payload);
+    if (!state) {
+      logger.debug(`No state found in message: ${JSON.stringify(payload)}`);
+      return;
+    }
+    const valid = validateSecureTunnelShadowUpdate(state);
+    if (!valid) {
+      logger.error(
+        `Error validating message: ${JSON.stringify(
+          { payload, errors: validateSecureTunnelShadowUpdate.errors },
+          null,
+          2
+        )}`
+      );
+      return;
+    }
+    const secureTunnelUpdate =
+      await this.secureTunnelHandler.syncShadowToDeviceState(payload);
+    await this.shadowHandler.updateSecureTunnelShadow(secureTunnelUpdate);
+  }
+}

package/src/secure-tunneling/secure-tunneling.test.ts

@@ -1,4 +1,10 @@
+import {
+  SecureTunnelPortInfo,
+  SecureTunnelShadowUpdate
+} from '@alwaysai/device-agent-schemas';
 import { AAI_DIR } from 'alwaysai/lib/paths';
+import { downloadToFile } from '../util/file';
+import { ChildProcess } from 'child_process';
 import { join } from 'path';
 import { aaiArtifactsBucketUrl } from '../urls';
 import {
@@ -7,19 +13,12 @@ import {
   SECURE_TUNNEL_BIN_NAME,
   SECURE_TUNNEL_BIN_PATH
 } from '../util/directories';
-import { downloadFile } from '../util/download-file';
 import { getArch, getDistribution, getOsVersion } from '../util/system-info';
 import {
   SecureTunnelHandlerSingleton,
   SecureTunnelShadowUpdateDelta
 } from './secure-tunneling';
-// import { JsSpawner } from 'alwaysai/lib/util/spawner';
-import { ChildProcess } from 'child_process';
 import { killDetachedProcess, runDetachedProcess } from './spawner-detached';
-import {
-  SecureTunnelPortInfo,
-  SecureTunnelShadowDescriptionReported
-} from '@alwaysai/device-agent-schemas';
 //-----------------------------------------------------------------------------
 // mocks
 //-----------------------------------------------------------------------------
@@ -50,9 +49,8 @@ jest.mock('../util/system-info', () => ({
   getDistribution: jest.fn()
 }));
 
-jest.mock('../util/download-file', () => ({
-  downloadFile: jest.fn()
-}));
+jest.mock('../util/file');
+const mockDownloadToFile = jest.mocked(downloadToFile);
 
 jest.mock('./spawner-detached', () => ({
   runDetachedProcess: jest.fn(),
@@ -174,10 +172,11 @@ describe('SecureTunnelHandlerSingleton', () => {
 
   function transformDeltaToUpdateReported(
     deltaMsg: SecureTunnelShadowUpdateDelta
-  ): SecureTunnelShadowDescriptionReported {
+  ): SecureTunnelShadowUpdate {
     const { version, state } = deltaMsg;
-    const reportedStateReported: SecureTunnelShadowDescriptionReported =
-      JSON.parse(JSON.stringify(state));
+    const reportedStateReported: SecureTunnelShadowUpdate = JSON.parse(
+      JSON.stringify(state)
+    );
     return reportedStateReported;
   }
 
@@ -705,7 +704,7 @@ describe('SecureTunnelHandlerSingleton', () => {
     expect(getDistribution).not.toHaveBeenCalled();
     expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
     expect(mockJsSpawner.run).not.toHaveBeenCalled();
-    expect(downloadFile).not.toHaveBeenCalled();
+    expect(mockDownloadToFile).not.toHaveBeenCalled();
     expect(runDetachedProcess).toHaveBeenCalledTimes(1);
     expect(runDetachedProcess).toHaveBeenCalledWith(
       SECURE_TUNNEL_BIN_PATH,
@@ -782,11 +781,10 @@ describe('SecureTunnelHandlerSingleton', () => {
         exe: 'chmod',
         args: ['+x', SECURE_TUNNEL_BIN_PATH]
       });
-      expect(downloadFile).toHaveBeenCalledTimes(1);
-      expect(downloadFile).toHaveBeenCalledWith({
+      expect(mockDownloadToFile).toHaveBeenCalledTimes(1);
+      expect(mockDownloadToFile).toHaveBeenCalledWith({
         url: expectedUrl,
-        path: SECURE_TUNNEL_BIN_PATH,
-        errorMessage: `Secure Tunnel bin for ${linuxDistro} ${osVersion} ${arch} not found}`
+        path: SECURE_TUNNEL_BIN_PATH
       });
       expect(runDetachedProcess).toHaveBeenCalledTimes(1);
       expect(runDetachedProcess).toHaveBeenCalledWith(
@@ -916,7 +914,7 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(getOsVersion).not.toHaveBeenCalled();
       expect(getDistribution).not.toHaveBeenCalled();
       expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-      expect(downloadFile).not.toHaveBeenCalled();
+      expect(mockDownloadToFile).not.toHaveBeenCalled();
       expect(mockJsSpawner.run).not.toHaveBeenCalled();
       expect(runDetachedProcess).not.toHaveBeenCalled();
       expect(killDetachedProcess).not.toHaveBeenCalled();
@@ -1028,7 +1026,7 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(getOsVersion).not.toHaveBeenCalled();
       expect(getDistribution).not.toHaveBeenCalled();
       expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-      expect(downloadFile).not.toHaveBeenCalled();
+      expect(mockDownloadToFile).not.toHaveBeenCalled();
       expect(runDetachedProcess).not.toHaveBeenCalled();
       expect(killDetachedProcess).not.toHaveBeenCalled();
     }
@@ -1153,7 +1151,7 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(getOsVersion).not.toHaveBeenCalled();
       expect(getDistribution).not.toHaveBeenCalled();
       expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-      expect(downloadFile).not.toHaveBeenCalled();
+      expect(mockDownloadToFile).not.toHaveBeenCalled();
       expect(mockJsSpawner.run).not.toHaveBeenCalled();
       expect(runDetachedProcess).toHaveBeenCalledTimes(1);
       expect(runDetachedProcess).toHaveBeenCalledWith(
@@ -1228,7 +1226,7 @@ describe('SecureTunnelHandlerSingleton', () => {
     expect(getOsVersion).not.toHaveBeenCalled();
     expect(getDistribution).not.toHaveBeenCalled();
     expect(mockJsSpawner.mkdirp).not.toHaveBeenCalled();
-    expect(downloadFile).not.toHaveBeenCalled();
+    expect(mockDownloadToFile).not.toHaveBeenCalled();
     expect(mockJsSpawner.run).not.toHaveBeenCalled();
     expect(runDetachedProcess).toHaveBeenCalledTimes(0);
     expect(killDetachedProcess).toHaveBeenCalledTimes(2);

package/src/secure-tunneling/secure-tunneling.ts

@@ -1,23 +1,23 @@
+import {
+  SecureTunnelPortInfo,
+  SecureTunnelShadowUpdate
+} from '@alwaysai/device-agent-schemas';
 import { AAI_DIR } from 'alwaysai/lib/paths';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
 import { ChildProcess } from 'child_process';
 import { join } from 'path';
 import { aaiArtifactsBucketUrl } from '../urls';
-import { isValidAwsRegion } from '../util/cloud-mode-ready';
+import { isValidAwsRegion } from '../util/aws-regions';
 import {
   AWS_ROOT_CERTIFICATE_FILE_PATH,
   SECURE_TUNNEL_BIN_DIR,
   SECURE_TUNNEL_BIN_NAME,
   SECURE_TUNNEL_BIN_PATH
 } from '../util/directories';
-import { downloadFile } from '../util/download-file';
 import { logger } from '../util/logger';
 import { getArch, getDistribution, getOsVersion } from '../util/system-info';
 import { killDetachedProcess, runDetachedProcess } from './spawner-detached';
-import {
-  SecureTunnelPortInfo,
-  SecureTunnelShadowDescriptionReported
-} from '@alwaysai/device-agent-schemas';
+import { downloadToFile } from '../util/file';
 
 enum SecureTunnelServiceType {
   SSH = 'SSH',
@@ -25,18 +25,18 @@ enum SecureTunnelServiceType {
 }
 
 export type SecureTunnelShadowState = {
-  reported?: SecureTunnelShadowDescriptionReported;
-  desired?: SecureTunnelShadowDescriptionReported;
+  reported?: SecureTunnelShadowUpdate;
+  desired?: SecureTunnelShadowUpdate;
 };
 
 export type SecureTunnelShadowUpdateDelta = {
   version: number;
   timestamp: number;
-  state: SecureTunnelShadowDescriptionReported;
+  state: SecureTunnelShadowUpdate;
   metadata?: any;
 };
 
-export type SecureTunnelShadowUpdate = {
+export type SecureTunnelShadow = {
   version: number;
   state: SecureTunnelShadowState;
 };
@@ -76,7 +76,7 @@ const ST_START_PORT_NUMBER = 5010;
  */
 export class SecureTunnelHandlerSingleton {
   private static instance: SecureTunnelHandlerSingleton;
-  private reported: SecureTunnelShadowDescriptionReported;
+  private reported: SecureTunnelShadowUpdate;
   private httpProxyMap: SecureTunnelProxyMap[];
   private localProxyInfo: SecureTunnelLocalProxyInfo;
 
@@ -146,9 +146,9 @@ export class SecureTunnelHandlerSingleton {
 
   /**
    * Returns current state of SecureTunnel shadow
-   * @returns {SecureTunnelShadowDescriptionReported} - reported state of the SecureTunnel shadow
+   * @returns {SecureTunnelShadowUpdate} - reported state of the SecureTunnel shadow
    */
-  public getSecureTunnelShadow(): SecureTunnelShadowDescriptionReported {
+  public getSecureTunnelShadow(): SecureTunnelShadowUpdate {
     logger.debug('-> SecureTunnelHandlerSingleton.getSecureTunnelShadow');
     logger.debug(`reported: ${JSON.stringify(this.reported)}`);
     logger.debug('<- SecureTunnelHandlerSingleton.getSecureTunnelShadow');
@@ -158,11 +158,11 @@ export class SecureTunnelHandlerSingleton {
   /**
    * Updates current state of SecureTunnel shadow
    * @param {SecureTunnelShadowUpdateDelta} deltaMsg - delta message, which includes desired state of the SecureTunnel shadow
-   * @return {SecureTunnelShadowDescriptionReported} update reported message to send back to AWS IoT device shadow
+   * @return {SecureTunnelShadowUpdate} update reported message to send back to AWS IoT device shadow
    */
   public async syncShadowToDeviceState(
     deltaMsg: SecureTunnelShadowUpdateDelta
-  ): Promise<SecureTunnelShadowDescriptionReported> {
+  ): Promise<SecureTunnelShadowUpdate> {
     logger.debug('-> SecureTunnelHandlerSingleton.syncShadowToDeviceState');
     const { version, state } = deltaMsg;
     if (!state || typeof state.st_ports === 'undefined') {
@@ -234,8 +234,8 @@ export class SecureTunnelHandlerSingleton {
       this.processNotifyMessage(message);
       await this.downloadSecureTunnel();
       await this.startLocalProxy();
-    } catch (error) {
-      logger.error(error);
+    } catch (e) {
+      logger.error(stringifyError(e));
     }
 
     logger.info(`Local Proxy Started: ${JSON.stringify(this.localProxyInfo)}`);
@@ -324,9 +324,11 @@ export class SecureTunnelHandlerSingleton {
           this.httpProxyMap[this.httpProxyMap.length - 1]
         )}`
       );
-    } catch (error) {
+    } catch (e) {
       logger.error(
-        `ERROR: starting socat for: ${portInfo.ip}:${portInfo.port} on localhost port: ${localPort}, error: ${error}`
+        `ERROR: starting socat for: ${portInfo.ip}:${
+          portInfo.port
+        } on localhost port: ${localPort}\nerror:\n${stringifyError(e)}`
       );
       const lastHttpProxyMap = this.httpProxyMap.pop();
       logger.info(`removed last proxyMap: ${JSON.stringify(lastHttpProxyMap)}`);
@@ -371,7 +373,7 @@ export class SecureTunnelHandlerSingleton {
         );
         logger.debug(`Remaining map: ${JSON.stringify(this.httpProxyMap)}`);
       } catch (e) {
-        logger.error('ERROR: killing socat process:', e);
+        logger.error(`ERROR: killing socat process:\n${stringifyError(e)}`);
       }
       logger.debug(
         `Removing map: ${JSON.stringify(this.httpProxyMap[itemIndex])}`
@@ -427,7 +429,7 @@ export class SecureTunnelHandlerSingleton {
       ]);
       logger.debug('SUCCESS: killing local proxy process');
     } catch (e) {
-      logger.error('ERROR: killing local proxy process:', e);
+      logger.error(`ERROR: killing local proxy process:\n${stringifyError(e)}`);
     }
     this.localProxyInfo = {
       lpDstAccessKey: '',
@@ -545,11 +547,21 @@ export class SecureTunnelHandlerSingleton {
     logger.info('Downloading SecureTunnel local proxy ...');
     const url = `${aaiArtifactsBucketUrl}/securetunnel/${linuxDistro}/${osVersion}/${arch}/${SECURE_TUNNEL_BIN_NAME}`;
     await JsSpawner().mkdirp(join(AAI_DIR, SECURE_TUNNEL_BIN_DIR));
-    await downloadFile({
-      url,
-      path: SECURE_TUNNEL_BIN_PATH,
-      errorMessage: `Secure Tunnel bin for ${linuxDistro} ${osVersion} ${arch} not found}`
-    });
+    try {
+      await downloadToFile({
+        url,
+        path: SECURE_TUNNEL_BIN_PATH
+      });
+    } catch (error) {
+      logger.error(
+        `Secure Tunnel bin for ${linuxDistro} ${osVersion} ${arch} not found}: ${stringifyError(
+          error
+        )}`
+      );
+      throw new Error(
+        `Secure Tunnel bin for ${linuxDistro} ${osVersion} ${arch} not found}`
+      );
+    }
 
     await JsSpawner().run({
       exe: 'chmod',
@@ -578,8 +590,8 @@ export class SecureTunnelHandlerSingleton {
   }
 
   private sortPorts(
-    desired: SecureTunnelShadowDescriptionReported
-  ): SecureTunnelShadowDescriptionReported {
+    desired: SecureTunnelShadowUpdate
+  ): SecureTunnelShadowUpdate {
     logger.debug('-> SecureTunnelHandlerSingleton.sortPorts');
     const sortedPorts = JSON.parse(JSON.stringify(this.reported));
     sortedPorts.st_ports.sort((a, b) => {

package/src/subcommands/app/analytics.ts

@@ -7,10 +7,9 @@ import {
 import { readAppCfgFile } from '../../application-control';
 import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-cloud-connection';
 import sleep from '../../util/sleep';
-import { logger } from '../../util/logger';
 import { assign, merge } from 'lodash';
 import {
-  buildUpdateProjectShadowMessage,
+  buildUpdateShadowMessage,
   getShadowTopic
 } from '@alwaysai/device-agent-schemas';
 
@@ -64,7 +63,6 @@ export const setAnalyticsCfgCliLeaf = CliLeaf({
     }
   ) {
     const deviceAgent = new DeviceAgentCloudConnection();
-    await deviceAgent.setupHandlers();
 
     const newAppCfg = {
       analytics: {
@@ -85,7 +83,7 @@ export const setAnalyticsCfgCliLeaf = CliLeaf({
     deviceAgent.publisher.publish(
       getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
       JSON.stringify(
-        buildUpdateProjectShadowMessage({
+        buildUpdateShadowMessage({
           clientId: 'client',
           desired: toDesire
         })