@alwaysai/device-agent 1.4.0 → 2.0.0

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

@@ -1,49 +1,42 @@
+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 { downloadToFile } from '../util/file';
 
 enum SecureTunnelServiceType {
   SSH = 'SSH',
   HTTP = 'HTTP'
 }
 
-export type SecureTunnelPortInfo = {
-  enabled: boolean;
-  type: string;
-  ip: string;
-  port: number;
-};
-
-export type SecureTunnelShadowDesRep = {
-  st_ports: SecureTunnelPortInfo[];
-};
-
 export type SecureTunnelShadowState = {
-  reported?: SecureTunnelShadowDesRep;
-  desired?: SecureTunnelShadowDesRep;
+  reported?: SecureTunnelShadowUpdate;
+  desired?: SecureTunnelShadowUpdate;
 };
 
 export type SecureTunnelShadowUpdateDelta = {
   version: number;
   timestamp: number;
-  state: SecureTunnelShadowDesRep;
+  state: SecureTunnelShadowUpdate;
   metadata?: any;
 };
 
-export type SecureTunnelShadowUpdate = {
+export type SecureTunnelShadow = {
   version: number;
   state: SecureTunnelShadowState;
 };
@@ -54,7 +47,7 @@ type SecureTunnelProxyMap = {
   mapProcess: ChildProcess;
 };
 
-type SecureTunnelLocalproxyInfo = {
+type SecureTunnelLocalProxyInfo = {
   lpDstAccessKey: string;
   lpRegion: string;
   lpServices: string;
@@ -83,9 +76,9 @@ const ST_START_PORT_NUMBER = 5010;
  */
 export class SecureTunnelHandlerSingleton {
   private static instance: SecureTunnelHandlerSingleton;
-  private reported: SecureTunnelShadowDesRep;
+  private reported: SecureTunnelShadowUpdate;
   private httpProxyMap: SecureTunnelProxyMap[];
-  private localproxyInfo: SecureTunnelLocalproxyInfo;
+  private localProxyInfo: SecureTunnelLocalProxyInfo;
 
   /**
    * Initializes private variables of SecureTunnel handler.
@@ -97,7 +90,7 @@ export class SecureTunnelHandlerSingleton {
       st_ports: [JSON.parse(JSON.stringify(defaultSecureTunnelPortInfo))]
     };
     this.httpProxyMap = [];
-    this.localproxyInfo = {
+    this.localProxyInfo = {
       lpDstAccessKey: '',
       lpRegion: '',
       lpServices: '',
@@ -147,15 +140,15 @@ export class SecureTunnelHandlerSingleton {
     };
     logger.debug(`httpProxyMap after : ${JSON.stringify(this.httpProxyMap)}`);
     logger.debug(`reported after     : ${JSON.stringify(this.reported)}`);
-    await this.stopLocalproxy();
+    await this.stopLocalProxy();
     logger.debug('<- SecureTunnelHandlerSingleton.destroy');
   }
 
   /**
    * Returns current state of SecureTunnel shadow
-   * @returns {SecureTunnelShadowDesRep} - reported state of the SecureTunnel shadow
+   * @returns {SecureTunnelShadowUpdate} - reported state of the SecureTunnel shadow
    */
-  public getSecureTunnelShadow(): SecureTunnelShadowDesRep {
+  public getSecureTunnelShadow(): SecureTunnelShadowUpdate {
     logger.debug('-> SecureTunnelHandlerSingleton.getSecureTunnelShadow');
     logger.debug(`reported: ${JSON.stringify(this.reported)}`);
     logger.debug('<- SecureTunnelHandlerSingleton.getSecureTunnelShadow');
@@ -165,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 {SecureTunnelShadowDesRep} 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<SecureTunnelShadowDesRep> {
+  ): Promise<SecureTunnelShadowUpdate> {
     logger.debug('-> SecureTunnelHandlerSingleton.syncShadowToDeviceState');
     const { version, state } = deltaMsg;
     if (!state || typeof state.st_ports === 'undefined') {
@@ -216,7 +209,7 @@ export class SecureTunnelHandlerSingleton {
 
     // if all entries are disabled, we need also to kill local proxy
     if (this.reported.st_ports.every((portInfo) => !portInfo.enabled)) {
-      await this.stopLocalproxy();
+      await this.stopLocalProxy();
     }
 
     // need to order list in the same order as desired before sending back
@@ -237,15 +230,15 @@ export class SecureTunnelHandlerSingleton {
     logger.debug('-> SecureTunnelHandlerSingleton.secureTunnelNotifyHandler');
 
     try {
-      await this.stopLocalproxy();
+      await this.stopLocalProxy();
       this.processNotifyMessage(message);
       await this.downloadSecureTunnel();
-      await this.startLocalproxy();
-    } catch (error) {
-      logger.error(error);
+      await this.startLocalProxy();
+    } catch (e) {
+      logger.error(stringifyError(e));
     }
 
-    logger.info(`Local Proxy Started: ${JSON.stringify(this.localproxyInfo)}`);
+    logger.info(`Local Proxy Started: ${JSON.stringify(this.localProxyInfo)}`);
     logger.debug('<- SecureTunnelHandlerSingleton.secureTunnelNotifyHandler');
   }
 
@@ -331,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)}`);
@@ -378,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])}`
@@ -389,60 +384,60 @@ export class SecureTunnelHandlerSingleton {
   }
 
   /**
-   * Starts SecureTunnel localproxy process
+   * Starts SecureTunnel localProxy process
    */
-  private async startLocalproxy(): Promise<void> {
-    logger.debug('-> SecureTunnelHandlerSingleton.startLocalproxy');
+  private async startLocalProxy(): Promise<void> {
+    logger.debug('-> SecureTunnelHandlerSingleton.startLocalProxy');
 
     const args = [
       '--destination-app',
-      this.localproxyInfo.lpServices,
+      this.localProxyInfo.lpServices,
       '--region',
-      this.localproxyInfo.lpRegion,
+      this.localProxyInfo.lpRegion,
       '--capath',
       AWS_ROOT_CERTIFICATE_FILE_PATH,
       '--local-bind-address',
       '0.0.0.0',
       '-t',
-      this.localproxyInfo.lpDstAccessKey
+      this.localProxyInfo.lpDstAccessKey
     ];
 
-    this.localproxyInfo.lpProcess = await runDetachedProcess(
+    this.localProxyInfo.lpProcess = await runDetachedProcess(
       SECURE_TUNNEL_BIN_PATH,
       args
     );
-    logger.debug('<- SecureTunnelHandlerSingleton.startLocalproxy');
+    logger.debug('<- SecureTunnelHandlerSingleton.startLocalProxy');
   }
 
   /**
-   * Stops SecureTunnel localproxy process
+   * Stops SecureTunnel local proxy process
    */
-  private async stopLocalproxy(): Promise<void> {
-    logger.debug('-> SecureTunnelHandlerSingleton.stopLocalproxy');
-    if (!this.localproxyInfo.lpProcess) {
-      logger.debug('No localproxy process running');
-      logger.debug('<- SecureTunnelHandlerSingleton.stopLocalproxy');
+  private async stopLocalProxy(): Promise<void> {
+    logger.debug('-> SecureTunnelHandlerSingleton.stopLocalProxy');
+    if (!this.localProxyInfo.lpProcess) {
+      logger.debug('No local proxy process running');
+      logger.debug('<- SecureTunnelHandlerSingleton.stopLocalProxy');
       return;
     }
 
     try {
       logger.debug(
-        `About to kill localproxy: ${this.localproxyInfo.lpDstAccessKey}`
+        `About to kill local proxy: ${this.localProxyInfo.lpDstAccessKey}`
       );
-      await killDetachedProcess(this.localproxyInfo.lpProcess, [
+      await killDetachedProcess(this.localProxyInfo.lpProcess, [
         SECURE_TUNNEL_BIN_PATH
       ]);
-      logger.debug('SUCCESS: killing localproxy process');
+      logger.debug('SUCCESS: killing local proxy process');
     } catch (e) {
-      logger.error('ERROR: killing localproxy process:', e);
+      logger.error(`ERROR: killing local proxy process:\n${stringifyError(e)}`);
     }
-    this.localproxyInfo = {
+    this.localProxyInfo = {
       lpDstAccessKey: '',
       lpRegion: '',
       lpServices: '',
       lpProcess: null
     };
-    logger.debug('<- SecureTunnelHandlerSingleton.stopLocalproxy');
+    logger.debug('<- SecureTunnelHandlerSingleton.stopLocalProxy');
   }
 
   /**
@@ -524,16 +519,16 @@ export class SecureTunnelHandlerSingleton {
       });
     }
 
-    this.localproxyInfo.lpDstAccessKey = clientAccessToken;
-    this.localproxyInfo.lpRegion = region;
-    this.localproxyInfo.lpServices = portMappingList.join(',');
+    this.localProxyInfo.lpDstAccessKey = clientAccessToken;
+    this.localProxyInfo.lpRegion = region;
+    this.localProxyInfo.lpServices = portMappingList.join(',');
     logger.debug(`reported =  ${JSON.stringify(this.reported.st_ports)}`);
-    logger.debug(`localproxyInfo =  ${JSON.stringify(this.localproxyInfo)}`);
+    logger.debug(`localProxyInfo =  ${JSON.stringify(this.localProxyInfo)}`);
     logger.debug('<- SecureTunnelHandlerSingleton.processNotifyMessage');
   }
 
   /**
-   * Downloads SecureTunnel localproxy, if it was not downloaded before
+   * Downloads SecureTunnel local proxy, if it was not downloaded before
    */
   private async downloadSecureTunnel(): Promise<void> {
     logger.debug('-> SecureTunnelHandlerSingleton.downloadSecureTunnel');
@@ -549,14 +544,24 @@ export class SecureTunnelHandlerSingleton {
       getOsVersion()
     ]);
 
-    logger.info('Downloading SecureTunnel localproxy ...');
+    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',
@@ -585,8 +590,8 @@ export class SecureTunnelHandlerSingleton {
   }
 
   private sortPorts(
-    desired: SecureTunnelShadowDesRep
-  ): SecureTunnelShadowDesRep {
+    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
         })

package/src/subcommands/app/env-vars.ts

@@ -4,13 +4,13 @@ import {
   CliStringInput,
   CliTerseError
 } from '@alwaysai/alwayscli';
-import { EnvVars, getAllEnvs } from '../../application-control';
+import { getAllEnvs } from '../../application-control';
 import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-cloud-connection';
 import sleep from '../../util/sleep';
-import { logger } from '../../util/logger';
 import {
-  buildUpdateProjectShadowMessage,
-  getShadowTopic
+  buildUpdateShadowMessage,
+  getShadowTopic,
+  EnvVars
 } from '@alwaysai/device-agent-schemas';
 
 export const getAllEnvsCliLeaf = CliLeaf({
@@ -48,27 +48,90 @@ export const setEnvCliLeaf = CliLeaf({
   },
   async action(args, opts) {
     const { project: projectId, service } = opts;
-    const envVars: EnvVars = { [service]: {} };
+    const currentEnvs = await getAllEnvs({ projectId });
+    const envVars: EnvVars = { [service]: { ...currentEnvs[service] } };
+
     args.forEach((arg: string) => {
       const nameVal = arg.split('=');
       if (nameVal.length !== 2) {
         throw new CliTerseError(`Invalid argument: ${arg}`);
       }
-      const value = nameVal[1] === '' ? null : nameVal[1];
+      const value = nameVal[1];
       envVars[service][nameVal[0]] = value;
     });
     const deviceAgent = new DeviceAgentCloudConnection();
-    await deviceAgent.setupHandlers();
 
     const toDesire = {
       [projectId]: {
-        envVars
+        envVars: JSON.stringify(envVars)
+      }
+    };
+    deviceAgent.publisher.publish(
+      getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
+      JSON.stringify(
+        buildUpdateShadowMessage({
+          clientId: 'client',
+          desired: toDesire
+        })
+      )
+    );
+    // Sleep for extra time to ensure time for shadow response
+    await sleep(10000);
+
+    while (deviceAgent.isCmdInProgress(projectId)) {
+      await sleep(1000);
+    }
+    await deviceAgent.stop();
+  }
+});
+
+export const rmEnvCliLeaf = CliLeaf({
+  name: 'rm-env',
+  description: 'Remove an environment variable from an application',
+  positionalInput: CliStringInput({
+    description: 'The key of the environment variable to be removed',
+    required: true
+  }),
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+      required: true
+    }),
+    service: CliStringInput({
+      description:
+        'Docker compose service to remove an environment variable from',
+      required: true
+    })
+  },
+  async action(arg, opts) {
+    const { project: projectId, service } = opts;
+    const envVar = arg;
+    const currentEnvs = await getAllEnvs({ projectId: projectId });
+
+    const newEnvs = { ...currentEnvs };
+    if (Object.keys(newEnvs[service]).includes(envVar)) {
+      delete newEnvs[service][envVar];
+    } else {
+      throw new CliTerseError(
+        `Could not find key "${envVar}" in service ${service}. Current keys are:\n ${JSON.stringify(
+          Object.keys(currentEnvs[service]),
+          null,
+          2
+        )}.\nPlease check the key and try again.`
+      );
+    }
+
+    const deviceAgent = new DeviceAgentCloudConnection();
+
+    const toDesire = {
+      [projectId]: {
+        envVars: JSON.stringify(newEnvs)
       }
     };
     deviceAgent.publisher.publish(
       getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
       JSON.stringify(
-        buildUpdateProjectShadowMessage({
+        buildUpdateShadowMessage({
           clientId: 'client',
           desired: toDesire
         })

package/src/subcommands/app/index.ts

@@ -1,12 +1,6 @@
 import { CliBranch } from '@alwaysai/alwayscli';
-import { getAllEnvsCliLeaf, setEnvCliLeaf } from './env-vars';
-import {
-  showAppModelsCliLeaf,
-  addModelCliLeaf,
-  removeModelCliLeaf,
-  replaceModelsCliLeaf,
-  updateModelsCliLeaf
-} from './models';
+import { getAllEnvsCliLeaf, setEnvCliLeaf, rmEnvCliLeaf } from './env-vars';
+import { showAppModelsCliLeaf, addModelCliLeaf } from './models';
 import {
   getAppStatusCliLeaf,
   startAppCliLeaf,
@@ -38,11 +32,9 @@ export const appCliBranch = CliBranch({
     rollbackAppCliLeaf,
     showAppModelsCliLeaf,
     addModelCliLeaf,
-    removeModelCliLeaf,
-    replaceModelsCliLeaf,
-    updateModelsCliLeaf,
     getAllEnvsCliLeaf,
     setEnvCliLeaf,
+    rmEnvCliLeaf,
     getAnalyticsCfgCliLeaf,
     setAnalyticsCfgCliLeaf,
     getShadowCliLeaf,

package/src/subcommands/app/models.ts

@@ -1,23 +1,10 @@
-import {
-  CliLeaf,
-  CliNumberInput,
-  CliStringArrayInput,
-  CliStringInput
-} from '@alwaysai/alwayscli';
-import {
-  getAppModels,
-  readAppCfgFile,
-  removeModel,
-  replaceModels,
-  updateModels
-} from '../../application-control';
+import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
+import { getAppModels, readAppCfgFile } from '../../application-control';
 import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-cloud-connection';
 import sleep from '../../util/sleep';
-import { logger } from '../../util/logger';
 import {
-  buildUpdateProjectShadowMessage,
-  getShadowTopic,
-  validateShadowProjectsUpdateAll
+  buildUpdateShadowMessage,
+  getShadowTopic
 } from '@alwaysai/device-agent-schemas';
 
 export const showAppModelsCliLeaf = CliLeaf({
@@ -56,7 +43,6 @@ export const addModelCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project: projectId, model, version } = opts;
     const deviceAgent = new DeviceAgentCloudConnection();
-    await deviceAgent.setupHandlers();
 
     // Update the shadow as a client
 
@@ -71,7 +57,7 @@ export const addModelCliLeaf = CliLeaf({
     deviceAgent.publisher.publish(
       getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
       JSON.stringify(
-        buildUpdateProjectShadowMessage({
+        buildUpdateShadowMessage({
           clientId: 'client',
           desired: toDesire
         })
@@ -86,65 +72,3 @@ export const addModelCliLeaf = CliLeaf({
     await deviceAgent.stop();
   }
 });
-
-export const removeModelCliLeaf = CliLeaf({
-  name: 'remove-model',
-  description: 'Remove a model from an alwaysAI app',
-  namedInputs: {
-    project: CliStringInput({
-      description: 'Project ID',
-      required: true
-    }),
-    model: CliStringInput({
-      description: 'Model ID',
-      required: true
-    })
-  },
-  async action(_, opts) {
-    const { project, model } = opts;
-    // TODO: Replace with handleMessage()
-    await removeModel({ projectId: project, modelId: model });
-  }
-});
-
-export const replaceModelsCliLeaf = CliLeaf({
-  name: 'replace-models',
-  description: 'Replace all models of an alwaysAI app with new models',
-  namedInputs: {
-    project: CliStringInput({
-      description: 'Project Id',
-      required: true
-    }),
-    models: CliStringArrayInput({
-      description: 'One or more model IDs',
-      required: true
-    })
-  },
-  hidden: true,
-  async action(_, opts) {
-    const { project, models } = opts;
-    console.log(
-      'This command is deprecated and will be removed in a future release'
-    );
-    await replaceModels({ projectId: project, modelIds: models });
-  }
-});
-
-export const updateModelsCliLeaf = CliLeaf({
-  name: 'update-models',
-  description: 'Update all models for an alwaysAI app',
-  namedInputs: {
-    project: CliStringInput({
-      description: 'Project Id',
-      required: true
-    })
-  },
-  hidden: true,
-  async action(_, opts) {
-    const { project } = opts;
-    console.log(
-      'This command is deprecated and will be removed in a future release'
-    );
-    await updateModels({ projectId: project });
-  }
-});

package/src/subcommands/app/shadow.ts

@@ -14,10 +14,9 @@ export const getShadowCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project } = opts;
     const deviceAgent = new DeviceAgentCloudConnection();
-    await deviceAgent.setupHandlers();
+    deviceAgent.shadowHandler.getProjectShadowUpdates();
 
-    // The Device Agent always gets the latest shadow and updates
-    // itself. 5 seconds should cover the initial response wait time
+    // 5 seconds should cover the response wait time
     await sleep(5000);
     while (deviceAgent.isCmdInProgress(project)) {
       await sleep(1000);
@@ -38,11 +37,13 @@ export const updateShadowCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project } = opts;
     const deviceAgent = new DeviceAgentCloudConnection();
-    await deviceAgent.setupHandlers();
-    await deviceAgent.updateProjectShadow(project);
+    await deviceAgent.shadowHandler.updateProjectShadow(project);
 
     // 5 seconds should cover the response wait time
     await sleep(5000);
+    while (deviceAgent.isCmdInProgress(project)) {
+      await sleep(1000);
+    }
     await deviceAgent.stop();
   }
 });

package/src/subcommands/app/version.ts

@@ -2,6 +2,7 @@ import { CliLeaf, CliStringInput, CliTerseError } from '@alwaysai/alwayscli';
 import {
   AppVersionControlMessage,
   generateTxId,
+  getToDeviceTopic,
   keyMirrors
 } from '@alwaysai/device-agent-schemas';
 import { rollbackApp } from '../../application-control';
@@ -50,8 +51,7 @@ export const installAppCliLeaf = CliLeaf({
       throw new CliTerseError('--release-hash flag is required!');
     }
     const deviceAgent = new DeviceAgentCloudConnection();
-    await deviceAgent.setupHandlers();
-    const topic = deviceAgent.getToDeviceTopic();
+    const topic = getToDeviceTopic(deviceAgent.getClientId());
     const message: AppVersionControlMessage = {
       timestamp: '',
       topic,
@@ -83,8 +83,7 @@ export const uninstallAppCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project } = opts;
     const deviceAgent = new DeviceAgentCloudConnection();
-    await deviceAgent.setupHandlers();
-    const topic = deviceAgent.getToDeviceTopic();
+    const topic = getToDeviceTopic(deviceAgent.getClientId());
     const message: AppVersionControlMessage = {
       timestamp: '',
       topic,