@alwaysai/device-agent 0.0.8 → 0.0.9

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

@@ -13,7 +13,11 @@ import {
   getAppLogs,
   getAppStatus,
 } from '../application-control/status';
-import { installApp, uninstallApp } from '../application-control/install';
+import {
+  getInstalledApps,
+  installApp,
+  uninstallApp,
+} from '../application-control/install';
 import {
   keyMirrors,
   validateClientMessage,
@@ -29,14 +33,18 @@ import {
   AppStateMessage,
   AppLogsMessage,
   AppInstallStatusMessage,
-  AppInstallSignedUrlsRequestMessage,
+  SignedUrlsRequestMessage,
   DeviceAgentMessage,
   ClientMessage,
+  AppDetailsPacket,
 } from '@alwaysai/device-agent-schemas';
 import { getDeviceId } from '../util/get-device-id';
-import { logger } from 'alwaysai/lib/util';
+import { JsSpawner, logger } from 'alwaysai/lib/util';
 import { getCpuUtil, getDiskUtil, getMemUtil } from '../device-control/device-control';
 import { AgentConfigFile } from '../infrastructure/agent-config';
+import { buildApp, getAppConfig, getAppDir } from '../application-control/utils';
+import { updateModelsWithPresignedUrls } from '../application-control/models';
+import { updateAppConfig } from '../application-control/config';
 
 export class DeviceAgentCloudConnection {
   private clientId = getDeviceId();
@@ -55,21 +63,63 @@ export class DeviceAgentCloudConnection {
     [keyMirrors.agentMessageType.app_install_status]: 5000,
   };
   private appLogStreams = new Set<string>();
-  private readonly agentTopicPrefix = `destination/agent/device/${this.clientId}/topic/`;
-  private readonly cloudTopicPrefix = `destination/cloud/device/${this.clientId}/topic/`;
-  private readonly publishableTopics = {
-    deviceStats: `${this.cloudTopicPrefix}device-management`,
-    appState: `${this.cloudTopicPrefix}application-management`,
-    appLogs: `${this.cloudTopicPrefix}application-management`,
-    appInstallStatus: `${this.cloudTopicPrefix}installation-status`,
-    cloudRequest: `${this.cloudTopicPrefix}request`,
-  };
-  private readonly subsribedTopics = {
-    command: `${this.agentTopicPrefix}command`,
-    response: `${this.agentTopicPrefix}response`,
+  private deviceType = 'aai-device';
+  private readonly shadowPrefix = `$aws/things/${this.clientId}/shadow/name/`;
+  private readonly shadowTopics = {
+    projects: {
+      updateDelta: `${this.shadowPrefix}projects/update/delta`,
+      getAccepted: `${this.shadowPrefix}projects/get/accepted`,
+    },
   };
+  private readonly toCloudTopic = `topic/to_cloud/${this.deviceType}/${this.clientId}`;
+  private readonly toClientTopic = `topic/to_client/${this.deviceType}/${this.clientId}`;
+  private readonly toDeviceTopic = `topic/to_device/${this.deviceType}/${this.clientId}`;
+
+  // device shadow utils
+
+  public getShadowPrefix() {
+    return this.shadowPrefix;
+  }
+
+  private async handleNamedShadowUpdate({ payload }: { payload: string }) {
+    const delta = JSON.parse(payload);
+    const deltaKeys = Object.keys(delta);
+
+    for (const projectId of deltaKeys) {
+      const projectShadow = delta[projectId];
+      if (projectShadow.appConfig) {
+        const appConfig = projectShadow.appConfig;
+        const appDir = getAppDir(projectId);
+        await updateAppConfig(projectId, appConfig);
+
+        if (appConfig.models) {
+          this.publishCloudRequest({
+            messageType: keyMirrors.agentMessageType.signed_urls_request,
+            modelsOnlyUrlsRequest: {
+              projectId,
+              models: appConfig.models,
+            },
+          });
+        }
+
+        if (appConfig.scripts && !appConfig.models) {
+          const appState = await getAppStatus({ projectId });
+
+          await buildApp({ appDir });
 
-  public async startAppLogStream(projectId: string) {
+          if (
+            appState.services.length &&
+            appState.services[0].state !== keyMirrors.appState.stopped
+          ) {
+            restartApp({ projectId });
+          }
+          await this.publishReportedState(projectId);
+        }
+      }
+    }
+  }
+
+  private async startAppLogStream(projectId: string) {
     this.appLogStreams.add(projectId);
     const readable = await getAppLogs({
       projectId,
@@ -93,10 +143,10 @@ export class DeviceAgentCloudConnection {
       };
       const packet = this.buildMessagePacket(
         this.getClientId(),
-        this.publishableTopics.appLogs,
+        this.toClientTopic,
         message,
       );
-      this.publishMessage(this.publishableTopics.appLogs, JSON.stringify(packet));
+      this.publishMessage(this.toClientTopic, JSON.stringify(packet));
     });
 
     readable.on('error', (error) => {
@@ -104,7 +154,7 @@ export class DeviceAgentCloudConnection {
     });
 
     readable.on('finished', () => {
-      console.log(`App logs finished piping for project ${projectId}`);
+      logger.info(`App logs finished piping for project ${projectId}`);
     });
   }
 
@@ -233,73 +283,6 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  private async handleCloudResponse(message: ClientMessage) {
-    const payload = message.payload;
-    switch (payload.messageType) {
-      case keyMirrors.clientMessageType.app_install_cloud_response: {
-        const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } =
-          payload.appInstallCloudResponse;
-
-        this.initAppInstallStatus({
-          status: keyMirrors.appInstallStatus.in_progress,
-          appReleaseHash,
-        });
-
-        this.startPublishingLiveUpdates(
-          this.publishableTopics.appInstallStatus,
-          keyMirrors.agentMessageType.app_install_status,
-          this.getAppInstallStatusMessage,
-        );
-
-        // Install the app and models
-        try {
-          const signedUrlsPayload = {
-            appInstallPayload,
-            modelsInstallPayload,
-          };
-          await installApp({
-            projectId,
-            appReleaseHash,
-            signedUrlsPayload,
-          });
-          this.updateAppInstallStatus({
-            status: keyMirrors.appInstallStatus.success,
-          });
-        } catch (e) {
-          console.error(e);
-          const message: string = e.message;
-
-          // uninstall the failed app to put system back in good state
-          await uninstallApp({ projectId });
-          this.updateAppInstallStatus({
-            status: keyMirrors.appInstallStatus.failure,
-            message,
-          });
-        }
-        break;
-      }
-      default:
-        logger.error(`Invalid cloud response message type '${message}'`);
-    }
-  }
-
-  private handleClientMessage(message: ClientMessage) {
-    const payload = message.payload;
-    switch (payload.messageType) {
-      case keyMirrors.clientMessageType.app_state_control:
-        this.handleAppStateControl(payload.appStateControl);
-        break;
-      case keyMirrors.clientMessageType.app_version_control:
-        this.handleAppVersionControl(payload.appVersionControl);
-        break;
-      case keyMirrors.clientMessageType.live_state_updates:
-        this.handleAgentCommand(payload);
-        break;
-      default:
-        logger.error(`Invalid Client Message '${JSON.stringify(payload)}'`);
-    }
-  }
-
   private handleAppStateControl(payload: AppStateControlPacket) {
     const { baseCommand, projectId } = payload;
     switch (baseCommand) {
@@ -319,7 +302,7 @@ export class DeviceAgentCloudConnection {
     const { projectId, appReleaseHash } = payload;
     const signedUrlsRequest = { projectId, appReleaseHash };
     this.publishCloudRequest({
-      messageType: keyMirrors.agentMessageType.app_install_signed_urls_request,
+      messageType: keyMirrors.agentMessageType.signed_urls_request,
       signedUrlsRequest,
     });
   }
@@ -363,12 +346,11 @@ export class DeviceAgentCloudConnection {
     };
   }) {
     this.restartLiveUpdatesTimeout();
-
     if (deviceStats !== undefined) {
       this.liveUpdatesAlive.device_stats = deviceStats;
       if (deviceStats) {
         this.startPublishingLiveUpdates(
-          this.publishableTopics.deviceStats,
+          this.toClientTopic,
           keyMirrors.agentMessageType.device_stats,
           this.getDeviceStatsMessage,
         );
@@ -379,7 +361,7 @@ export class DeviceAgentCloudConnection {
       this.liveUpdatesAlive.app_state = appState;
       if (appState) {
         this.startPublishingLiveUpdates(
-          this.publishableTopics.appState,
+          this.toClientTopic,
           keyMirrors.agentMessageType.app_state,
           this.getAppStateMessage,
         );
@@ -395,8 +377,20 @@ export class DeviceAgentCloudConnection {
     }
   }
 
-  private async publishCloudRequest(payload: AppInstallSignedUrlsRequestMessage) {
-    const topic = this.publishableTopics.cloudRequest;
+  private async publishReportedState(projectId) {
+    const newAppCfg = await getAppConfig(projectId);
+    const packet = {
+      state: {
+        reported: {
+          [projectId]: { appConfig: newAppCfg },
+        },
+      },
+    };
+    this.publishMessage(`${this.shadowPrefix}projects/update`, JSON.stringify(packet));
+  }
+
+  private async publishCloudRequest(payload: SignedUrlsRequestMessage) {
+    const topic = this.toCloudTopic;
     const deviceRequestPacket = this.buildMessagePacket(
       this.getClientId(),
       topic,
@@ -418,9 +412,9 @@ export class DeviceAgentCloudConnection {
       host: this.host,
     });
 
-    Object.values(this.subsribedTopics).forEach((topic: string) => {
-      this.device.subscribe(topic);
-    });
+    this.device.subscribe(this.toDeviceTopic);
+    this.device.subscribe(this.shadowTopics.projects.getAccepted);
+    this.device.subscribe(this.shadowTopics.projects.updateDelta);
   }
 
   public getClientId(): string {
@@ -432,17 +426,105 @@ export class DeviceAgentCloudConnection {
     this.device.publish(topic, message);
   }
 
-  public handleMessageTopic({
+  public async handleClientMessage({
     topic,
     message,
   }: {
     topic: string;
     message: ClientMessage;
   }) {
-    if (topic === this.subsribedTopics.response) {
-      this.handleCloudResponse(message);
-    } else {
-      this.handleClientMessage(message);
+    const payload = message.payload;
+    switch (payload.messageType) {
+      case keyMirrors.clientMessageType.app_state_control: {
+        this.handleAppStateControl(payload.appStateControl);
+        break;
+      }
+      case keyMirrors.clientMessageType.app_version_control: {
+        this.handleAppVersionControl(payload.appVersionControl);
+        break;
+      }
+      case keyMirrors.clientMessageType.live_state_updates: {
+        this.handleAgentCommand(payload);
+        break;
+      }
+      case keyMirrors.clientMessageType.app_install_cloud_response: {
+        const { projectId, appReleaseHash, appInstallPayload, modelsInstallPayload } =
+          payload.appInstallCloudResponse;
+
+        this.initAppInstallStatus({
+          status: keyMirrors.appInstallStatus.in_progress,
+          appReleaseHash,
+        });
+
+        this.startPublishingLiveUpdates(
+          this.toClientTopic,
+          keyMirrors.agentMessageType.app_install_status,
+          this.getAppInstallStatusMessage,
+        );
+
+        // Install the app and models
+        try {
+          const signedUrlsPayload = {
+            appInstallPayload,
+            modelsInstallPayload,
+          };
+          await installApp({
+            projectId,
+            appReleaseHash,
+            signedUrlsPayload,
+          });
+          this.updateAppInstallStatus({
+            status: keyMirrors.appInstallStatus.success,
+          });
+
+          // update app config shadow for project
+          await this.publishReportedState(projectId);
+        } catch (e) {
+          console.error(e);
+          const message: string = e.message;
+
+          // uninstall the failed app to put system back in good state
+          await uninstallApp({ projectId });
+          this.updateAppInstallStatus({
+            status: keyMirrors.appInstallStatus.failure,
+            message,
+          });
+
+          // delete shadow for project
+          this.publishMessage(`${this.shadowPrefix}${projectId}/delete`, '');
+        }
+        break;
+      }
+      case keyMirrors.clientMessageType.models_install_cloud_response: {
+        const { projectId, newModels } = payload.modelsInstallCloudResponse;
+
+        try {
+          await updateModelsWithPresignedUrls(projectId, newModels);
+
+          await this.publishReportedState(projectId);
+        } catch (e) {
+          console.error(e);
+        }
+        break;
+      }
+      default:
+        logger.error(`Invalid Client Message '${JSON.stringify(payload)}'`);
+    }
+  }
+
+  public async handleShadowTopic({ topic, payload }: { topic: string; payload: string }) {
+    const shadowName = topic.split('/')[5];
+    const message = JSON.parse(payload);
+    if (topic === this.shadowTopics.projects.updateDelta) {
+      this.handleNamedShadowUpdate({ payload });
+    } else if (topic === this.shadowTopics.projects.getAccepted) {
+      if (message.delta) {
+        this.handleNamedShadowUpdate({
+          payload: JSON.stringify(message.delta),
+        });
+      } else {
+        console.log(`No delta updates in shadow ${shadowName}`);
+      }
     }
   }
 }
@@ -453,6 +535,9 @@ export function runDeviceAgentCloudInterface() {
   deviceAgent.device.on('connect', function () {
     deviceAgent.publishMessage('connection', deviceAgent.getClientId());
     console.log('Device Agent has connected to the cloud');
+
+    // Get shadow updates
+    deviceAgent.publishMessage(`${deviceAgent.getShadowPrefix()}projects/get`, '');
   });
 
   deviceAgent.device.on('disconnect', function () {
@@ -462,14 +547,21 @@ export function runDeviceAgentCloudInterface() {
   deviceAgent.device.on('message', function (topic: string, payload: string) {
     try {
       const jsonPacket = JSON.parse(payload);
-      const valid = validateClientMessage(jsonPacket);
-      if (!valid) {
-        logger.error(JSON.stringify(validateClientMessage.errors));
+      if (jsonPacket.hasOwnProperty('state')) {
+        deviceAgent.handleShadowTopic({
+          topic,
+          payload: JSON.stringify(jsonPacket.state),
+        });
       } else {
-        deviceAgent.handleMessageTopic({ topic, message: jsonPacket });
+        const valid = validateClientMessage(jsonPacket);
+        if (!valid) {
+          console.error(JSON.stringify(validateClientMessage.errors));
+        } else {
+          deviceAgent.handleClientMessage({ topic, message: jsonPacket });
+        }
       }
     } catch (error) {
-      logger.error(error);
+      console.error(error);
     }
   });
 }

package/src/infrastructure/agent-config.test.ts

@@ -95,7 +95,9 @@ describe('Test Agent Config', () => {
       const version = 'im-a-version';
 
       await configFile.setAppInstalling({ projectId, version });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
       await configFile.setAppInstalled({ projectId, version });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
       await configFile.setAppUninstalled({ projectId });
       const apps = await configFile.getApps();
       expect(apps).toEqual([]);
@@ -110,9 +112,13 @@ describe('Test Agent Config', () => {
     test('Set and get backup', async () => {
       const projectId = 'add-me';
       const version = 'im-a-version';
+      const version2 = 'newer-version';
 
+      // first installation, we use the version
       await configFile.setAppInstalling({ projectId, version });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
       await configFile.setAppInstalled({ projectId, version });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
       const backup1 = await configFile.getAppBackup({ projectId });
       expect(backup1).toBeNull();
       await configFile.setAppBackup({ projectId });
@@ -138,6 +144,56 @@ describe('Test Agent Config', () => {
       });
       const backup2 = await configFile.getAppBackup({ projectId });
       expect(backup2).toEqual({ version });
+
+      await configFile.setAppInstalling({ projectId, version: version2 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
+      await configFile.setAppInstalled({ projectId, version: version2 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version2);
+      const backup3 = await configFile.getAppBackup({ projectId });
+      expect(backup3).toEqual({ version });
+    });
+
+    test('Test app rollback', async () => {
+      const projectId = 'add-me';
+      const version1 = 'original-version';
+      const version2 = 'newer-version';
+      await configFile.setAppInstalling({ projectId, version: version1 });
+      await configFile.setAppInstalled({ projectId, version: version1 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version1);
+      expect(await configFile.getAppBackup({ projectId })).toBeNull();
+
+      // next installation - verify app is present and ready
+      expect(await configFile.isAppPresent({ projectId })).toBe(true);
+      expect(await configFile.isAppReady({ projectId })).toBe(true);
+
+      // test to see if app has backup
+      await configFile.setAppBackup({ projectId });
+      const expectedBackupVersion = (await configFile.getAppBackup({ projectId }))
+        ?.version;
+      expect(expectedBackupVersion).toEqual(version1);
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version1);
+
+      // simulate second version install
+      await configFile.setAppInstalling({ projectId, version: version2 });
+      const newExpectedBackupVersion = (await configFile.getAppBackup({ projectId }))
+        ?.version;
+      expect(newExpectedBackupVersion).toEqual(version1);
+      await configFile.setAppInstalled({ projectId, version: version2 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version2);
+
+      // simulate the rollback step: set the version that we will roll back to
+      await configFile.setAppInstalling({ projectId, version: version1 });
+
+      // test state during rollback
+      expect(await configFile.isAppReady({ projectId })).toEqual(false);
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version2);
+
+      // test final state of rolled-back app
+      await configFile.setAppInstalled({ projectId, version: version1 });
+      const finalBackupVersion = (await configFile.getAppBackup({ projectId }))?.version;
+      expect(finalBackupVersion).toEqual(version1);
+      expect(await configFile.isAppReady({ projectId })).toEqual(true);
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version1);
     });
   });
 });

package/src/infrastructure/agent-config.ts

@@ -2,7 +2,6 @@ import { ConfigFileSchema } from '@alwaysai/config-nodejs';
 import { JSONSchemaType } from 'ajv';
 import { homedir } from 'os';
 import { join } from 'path';
-import { ALWAYSAI_DEVICE_AGENT_MODE } from '../environment';
 
 export interface AppBackupConfig {
   version: string;
@@ -134,17 +133,16 @@ export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
 
   async function setAppInstalling(props: { projectId: string; version: string }) {
     const { projectId, version } = props;
+
     const app = await getApp({ projectId });
     if (app) {
       await removeApp({ projectId });
       const config = configFile.read();
-      config.applications.push({
-        projectId,
-        version,
-        ready: false,
-      });
+      // NOTE: do not update the version for an existing app until it is installed
+      config.applications.push({ ...app, ...{ ready: false } });
       configFile.write(config);
     } else {
+      // NOTE: for a brand-new app, we need to specify the version
       const config = configFile.read();
       config.applications.push({
         projectId,
@@ -161,21 +159,14 @@ export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
     if (app) {
       await removeApp({ projectId });
       const config = configFile.read();
-      app.version = version;
-      config.applications.push({
-        projectId,
-        version,
-        ready: true,
-      });
+      config.applications.push({ ...app, ...{ version, ready: true } });
       configFile.write(config);
     } else {
-      const config = configFile.read();
-      config.applications.push({
-        projectId,
-        version,
-        ready: true,
-      });
-      configFile.write(config);
+      // NOTE: we should never be setting an app as installed
+      // if it doesn't exist (setAppInstalling was never called)
+      throw new Error(
+        `App ${projectId} was not previously configured and could not be set to installed!`,
+      );
     }
   }
 

package/src/subcommands/login.ts

@@ -1,6 +1,6 @@
-import { CliLeaf, CliStringInput, CliUsageError } from '@alwaysai/alwayscli';
+import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
+import { alwaysaiUserLoginYesComponent } from 'alwaysai/lib/components/user';
 import { writeCertificateAndToken } from '../infrastructure/certificates-and-tokens';
-import { runCliCmd } from '../util/run-cli-cmd';
 
 export const loginCliLeaf = CliLeaf({
   name: 'login',
@@ -21,8 +21,10 @@ export const loginCliLeaf = CliLeaf({
   },
   async action(_, opts) {
     const { email, password, device } = opts;
-    await runCliCmd({
-      cmd: ['user', 'login', '--yes', '--email', email, '--password', password],
+
+    await alwaysaiUserLoginYesComponent({
+      alwaysaiUserEmail: email,
+      alwaysaiUserPassword: password,
     });
     if (device) {
       await writeCertificateAndToken({ deviceUuid: device });

package/src/util/copy-dir.ts

@@ -6,5 +6,7 @@ export async function copyDir(props: { srcPath: string; destPath: string }) {
   const allFileNames = await src.readdir();
   const dest = JsSpawner({ path: destPath });
   await dest.mkdirp();
-  await dest.untar(await src.tar(...allFileNames));
+  if (allFileNames.length) {
+    await dest.untar(await src.tar(...allFileNames));
+  }
 }

package/src/util/run-in-dir.ts

@@ -0,0 +1,15 @@
+export async function runInDir<T extends any[], R extends any>(
+  func: (...args: T) => R,
+  args: T,
+  dir: string,
+) {
+  const origCwd = process.cwd();
+  let out: R;
+  try {
+    process.chdir(dir);
+    out = await func(...args);
+  } finally {
+    process.chdir(origCwd);
+  }
+  return out;
+}

package/lib/util/run-cli-cmd.d.ts

@@ -1,5 +0,0 @@
-export declare function runCliCmd(props: {
-    cmd: string[];
-    cwd?: string;
-}): Promise<void>;
-//# sourceMappingURL=run-cli-cmd.d.ts.map

package/lib/util/run-cli-cmd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-cli-cmd.d.ts","sourceRoot":"","sources":["../../src/util/run-cli-cmd.ts"],"names":[],"mappings":"AAEA,wBAAsB,SAAS,CAAC,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAerF"}

package/lib/util/run-cli-cmd.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCliCmd = void 0;
-const alwaysai = require("alwaysai");
-async function runCliCmd(props) {
-    const { cmd, cwd } = props;
-    const origCwd = process.cwd();
-    try {
-        if (cwd) {
-            process.chdir(cwd);
-        }
-        await alwaysai.aai(...cmd);
-    }
-    catch (err) {
-        throw err;
-    }
-    finally {
-        if (cwd) {
-            process.chdir(origCwd);
-        }
-    }
-}
-exports.runCliCmd = runCliCmd;
-//# sourceMappingURL=run-cli-cmd.js.map

package/lib/util/run-cli-cmd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-cli-cmd.js","sourceRoot":"","sources":["../../src/util/run-cli-cmd.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AAE9B,KAAK,UAAU,SAAS,CAAC,KAAsC;IACpE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;IAC3B,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAC9B,IAAI;QACF,IAAI,GAAG,EAAE;YACP,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;SACpB;QACD,MAAM,QAAQ,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;KAC5B;IAAC,OAAO,GAAG,EAAE;QACZ,MAAM,GAAG,CAAC;KACX;YAAS;QACR,IAAI,GAAG,EAAE;YACP,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;SACxB;KACF;AACH,CAAC;AAfD,8BAeC"}

package/src/util/run-cli-cmd.ts

@@ -1,18 +0,0 @@
-import * as alwaysai from 'alwaysai';
-
-export async function runCliCmd(props: { cmd: string[]; cwd?: string }): Promise<void> {
-  const { cmd, cwd } = props;
-  const origCwd = process.cwd();
-  try {
-    if (cwd) {
-      process.chdir(cwd);
-    }
-    await alwaysai.aai(...cmd);
-  } catch (err) {
-    throw err;
-  } finally {
-    if (cwd) {
-      process.chdir(origCwd);
-    }
-  }
-}