@alwaysai/device-agent 1.5.0 → 2.0.1

package/src/cloud-connection/transaction-manager.test.ts

@@ -1,13 +1,17 @@
 import {
+  EnvVars,
   ToClientStatusResponseMessage,
   generateTxId,
-  keyMirrors
+  keyMirrors,
+  buildToClientStatusResponseMessage
 } from '@alwaysai/device-agent-schemas';
 import { TransactionManager } from './transaction-manager';
 import { v4 as uuidv4 } from 'uuid';
 import { Publisher } from './publisher';
 import { LiveUpdatesHandler } from './live-updates-handler';
 import { AppConfigUpdate, ShadowUpdate } from './shadow-handler';
+import { AppContent } from './device-agent-message-handler';
+import { AppConfig } from '@alwaysai/app-configuration-schemas';
 
 const mockClient = {
   publish: jest.fn()
@@ -15,8 +19,8 @@ const mockClient = {
 const clientId = 'test-client';
 
 const mockLiveUpdatesHandler = {
-  enableTransactionStatus: jest.fn(),
-  disableTransactionStatus: jest.fn()
+  enable: jest.fn(),
+  disable: jest.fn()
 } as any as LiveUpdatesHandler;
 
 describe('Test Transaction Manager', () => {
@@ -58,11 +62,22 @@ describe('Test Transaction Manager', () => {
   test('Start a new transaction which completes in one step', async () => {
     const txId = generateTxId();
     const projectId = generateRandomProjectId();
+
+    const successFn = (txId: string) => {
+      const msg = buildToClientStatusResponseMessage(
+        clientId,
+        { status: keyMirrors.statusResponse.success },
+        txId
+      );
+      publisher.publishToClient(msg);
+    };
+
     await txnMgr.runTransactionStep({
       func: func_complete,
       projectId,
       txId,
-      start: true
+      start: true,
+      successFn
     });
     expect(txnMgr.isOngoingTransaction(txId)).toBe(false);
     expect(txnMgr.isOngoingTransactionForProjectID(projectId)).toBe(false);
@@ -188,7 +203,7 @@ describe('Test Transaction Manager', () => {
       throw new Error('Expected start transaction to fail!');
     } catch (e) {
       console.log(e);
-      expect(e.code).toBe(txnMgr.Errors.PROJECT_ONGOING);
+      expect(e.code).toBe(txnMgr.Errors.PROJECT_TRANSACTION_ONGOING);
     }
     expect(txnMgr.getTransactionFromProject(projectId)).toEqual(txId);
     expect(txnMgr.getProjectFromTransaction(txId)).toEqual(projectId);
@@ -198,6 +213,19 @@ describe('Test Transaction Manager', () => {
   test('Handle error in step function', async () => {
     const txId = generateTxId();
     const projectId = generateRandomProjectId();
+
+    const errorFn = (txId: string, errorMsg: string) => {
+      const msg = buildToClientStatusResponseMessage(
+        clientId,
+        {
+          status: keyMirrors.statusResponse.failure,
+          message: errorMsg
+        },
+        txId
+      );
+      publisher.publishToClient(msg);
+    };
+
     await txnMgr.runTransactionStep({
       func: jest.fn().mockImplementation(() => {
         throw new Error('Test error!');
@@ -205,7 +233,8 @@ describe('Test Transaction Manager', () => {
       projectId,
       txId,
       start: true,
-      stepName: 'step1'
+      stepName: 'step1',
+      errorFn
     });
     expect(txnMgr.isOngoingTransaction(txId)).toBe(false);
     expect(txnMgr.isOngoingTransactionForProjectID(projectId)).toBe(false);
@@ -369,4 +398,37 @@ describe('Test Transaction Manager', () => {
     expect(txnMgr.isAnyOngoingTransaction()).toBe(false);
     expect(txnMgr.getAppCfgUpdateFromTxID(txId)).toEqual(undefined);
   });
+
+  test('store appContent', async () => {
+    const txId = generateTxId();
+    const projectId = generateRandomProjectId();
+    const appCfg: AppConfig = {
+      models: {},
+      scripts: { start: 'python app.py' }
+    };
+    const envVars: EnvVars = { alwaysai: { TEST: '1' } };
+    const cfgUpdate: AppContent = {
+      projectId: projectId,
+      appCfg: appCfg,
+      envVars: envVars
+    };
+
+    await txnMgr.runTransactionStep({
+      func: func_incomplete,
+      projectId,
+      txId,
+      start: true
+    });
+
+    expect(txnMgr.getAppContentFromTxId(txId)).toEqual(undefined);
+
+    txnMgr.setAppContentToTx(txId, cfgUpdate);
+
+    expect(txnMgr.getProjectFromTransaction(txId)).toEqual(projectId);
+    expect(txnMgr.getTransactionFromProject(projectId)).toEqual(txId);
+    expect(txnMgr.isOngoingTransaction(txId)).toBe(true);
+    expect(txnMgr.isOngoingTransactionForProjectID(projectId)).toBe(true);
+    expect(txnMgr.isAnyOngoingTransaction()).toBe(true);
+    expect(txnMgr.getAppContentFromTxId(txId)).toEqual(cfgUpdate);
+  });
 });

package/src/cloud-connection/transaction-manager.ts

@@ -1,14 +1,15 @@
 import {
-  StatusResponsePayload,
+  ToClientStatusResponseMessage,
   buildToClientStatusResponseMessage,
   keyMirrors
 } from '@alwaysai/device-agent-schemas';
 import { LiveUpdatesHandler } from './live-updates-handler';
 import { Publisher } from './publisher';
 import { logger } from '../util/logger';
-import { keyMirror } from 'alwaysai/lib/util';
+import { keyMirror, stringifyError } from 'alwaysai/lib/util';
 import { CodedError } from '@carnesen/coded-error';
 import { ShadowUpdate } from './shadow-handler';
+import { AppContent } from './device-agent-message-handler';
 
 interface TransactionDetails {
   txId: string;
@@ -18,19 +19,24 @@ interface TransactionDetails {
   update?: string;
   stop?: string;
   appCfgUpdate?: ShadowUpdate;
+  appContent?: AppContent;
 }
 
+export type ErrorFunction = (txid: string, message: string) => void;
+
+export type SuccessFunction = (txId: string) => void;
+
 export class TransactionManager {
   private detailsByTx: Record<string, TransactionDetails> = {};
   private detailsByProject: Record<string, TransactionDetails> = {};
-  private liveUpdatesHandler: LiveUpdatesHandler;
+  private readonly liveUpdatesHandler: LiveUpdatesHandler;
   private publisher: Publisher;
-
-  private startTransaction(
+  private async startTransaction(
     txId: string,
     projectId: string,
+    liveUpdatesPublishFn?: () => Promise<void>,
     stepName?: string
-  ): void {
+  ): Promise<void> {
     // Check if the transaction already exists
     if (this.detailsByTx[txId]) {
       const txnDetails = this.detailsByTx[txId];
@@ -53,7 +59,7 @@ export class TransactionManager {
           null,
           2
         )}`,
-        this.Errors.PROJECT_ONGOING
+        this.Errors.PROJECT_TRANSACTION_ONGOING
       );
     }
 
@@ -67,10 +73,14 @@ export class TransactionManager {
     this.detailsByTx[txId] = txDetails;
     this.detailsByProject[projectId] = txDetails;
     logger.info(`Started transaction:\n${JSON.stringify(txDetails, null, 2)}`);
-    // send live updates
-    void this.liveUpdatesHandler.enableTransactionStatus({
-      txId
-    });
+
+    if (liveUpdatesPublishFn) {
+      await this.liveUpdatesHandler.enable(
+        keyMirrors.toClientMessageType.status_response,
+        liveUpdatesPublishFn,
+        txId
+      );
+    }
   }
 
   private updateTransaction(txId: string, stepName?: string): void {
@@ -95,7 +105,7 @@ export class TransactionManager {
 
   public Errors = keyMirror({
     TRANSACTION_ONGOING: null,
-    PROJECT_ONGOING: null,
+    PROJECT_TRANSACTION_ONGOING: null,
     TRANSACTION_NOT_ONGOING: null
   });
 
@@ -104,11 +114,28 @@ export class TransactionManager {
     projectId: string;
     txId: string;
     start: boolean;
+    liveUpdatesPublishFn?: () => Promise<void>;
     stepName?: string;
+    errorFn?: ErrorFunction;
+    successFn?: SuccessFunction;
   }) {
-    const { func, projectId, txId, start, stepName } = props;
+    const {
+      func,
+      projectId,
+      txId,
+      start,
+      liveUpdatesPublishFn,
+      stepName,
+      errorFn,
+      successFn
+    } = props;
     if (start) {
-      this.startTransaction(txId, projectId, stepName);
+      await this.startTransaction(
+        txId,
+        projectId,
+        liveUpdatesPublishFn,
+        stepName
+      );
     } else {
       this.updateTransaction(txId, stepName);
     }
@@ -116,36 +143,19 @@ export class TransactionManager {
       const completed = await func();
       if (completed) {
         this.completeTransaction(txId);
-        const successStatusResponsePayload: StatusResponsePayload = {
-          status: keyMirrors.statusResponse.success
-        };
-        // Send final status message
-        const message = buildToClientStatusResponseMessage(
-          this.publisher.getClientId(),
-          successStatusResponsePayload,
-          txId
-        );
-        this.publisher.publishToClient(message);
+        if (successFn) {
+          successFn(txId);
+        }
       }
     } catch (e) {
-      const message: string = e.message;
       logger.error(
-        `Failed to execute cmd for ${projectId}:\n${message}\n${e.stack}`
+        `Failed to execute cmd for ${projectId}!\n${stringifyError(e)}`
       );
 
       this.completeTransaction(txId);
-
-      const failureStatusResponsePayload: StatusResponsePayload = {
-        status: keyMirrors.statusResponse.failure,
-        message
-      };
-      // Send final status message
-      const failureStatusResponseMessage = buildToClientStatusResponseMessage(
-        this.publisher.getClientId(),
-        failureStatusResponsePayload,
-        txId
-      );
-      this.publisher.publishToClient(failureStatusResponseMessage);
+      if (errorFn) {
+        errorFn(txId, e.message);
+      }
     }
   }
 
@@ -175,6 +185,10 @@ export class TransactionManager {
     return this.detailsByTx[txId]?.appCfgUpdate;
   }
 
+  public getAppContentFromTxId(txId: string): AppContent | undefined {
+    return this.detailsByTx[txId]?.appContent;
+  }
+
   public setAppCfgUpdateToTx(txId: string, appCfgUpdate: ShadowUpdate) {
     if (this.isOngoingTransaction(txId)) {
       this.detailsByTx[txId].appCfgUpdate = appCfgUpdate;
@@ -184,7 +198,20 @@ export class TransactionManager {
       );
   }
 
-  public completeTransaction(txId: string): void {
+  public setAppContentToTx(txId: string, appContent: AppContent) {
+    if (this.isOngoingTransaction(txId)) {
+      logger.debug(`${txId}: Setting AppContent:${JSON.stringify(appContent)}`);
+      this.detailsByTx[txId].appContent = appContent;
+    } else
+      throw new Error(
+        `Could not set appCfgUpdate, the transaction ${txId} does not exist.`
+      );
+  }
+
+  public completeTransaction(
+    txId: string,
+    messageToPublish?: ToClientStatusResponseMessage
+  ): void {
     const txDetails = this.detailsByTx[txId];
     if (txDetails === undefined) {
       throw new CodedError(
@@ -199,8 +226,9 @@ export class TransactionManager {
     delete this.detailsByTx[txId];
     delete this.detailsByProject[txDetails.projectId];
 
-    void this.liveUpdatesHandler.disableTransactionStatus({
+    this.liveUpdatesHandler.disable(
+      keyMirrors.toClientMessageType.status_response,
       txId
-    });
+    );
   }
 }

package/src/device-control/device-control.ts

@@ -4,9 +4,10 @@ import * as osu from 'node-os-utils';
 import * as si from 'systeminformation';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
 import { DeviceStatsPayload } from '@alwaysai/device-agent-schemas';
 import { getDeviceAgentVersion } from '../util/check-for-updates';
+import AaiError from '../util/aai-error';
 
 const exec_promise = promisify(exec);
 
@@ -14,63 +15,84 @@ const exec_promise = promisify(exec);
 export async function getCpuDetails(): Promise<
   DeviceStatsPayload['cpuDetails']
 > {
-  const cpuFree = await osu.cpu.free();
-  const cpuTemp = await si.cpuTemperature();
-  const cpuDetails: DeviceStatsPayload['cpuDetails'] = {};
-  if (cpuFree !== null) cpuDetails.usedPerc = 100 - cpuFree;
-  if (cpuTemp?.main !== null) cpuDetails.temperature = cpuTemp.main;
-  return cpuDetails;
+  let cpuFree, cpuTemp;
+  try {
+    [cpuFree, cpuTemp] = await Promise.all([
+      osu.cpu.free(),
+      si.cpuTemperature()
+    ]);
+  } catch (error) {
+    logger.error('Error fetching CPU details:', error);
+    return {};
+  }
+
+  return {
+    usedPerc: cpuFree !== null ? 100 - cpuFree : undefined,
+    temperature: cpuTemp?.main !== null ? cpuTemp.main : undefined
+  };
 }
 
 export async function getDiskDetails(): Promise<
   DeviceStatsPayload['diskDetails']
 > {
-  // Types incorrectly specify diskname as required instead of optional
-  // @ts-expect-error
-  const driveInfo = await osu.drive.info();
-  const diskDetails: DeviceStatsPayload['diskDetails'] = {};
-  if (driveInfo?.usedGb !== null)
-    diskDetails.usedGb = parseFloat(driveInfo.usedGb);
-  if (driveInfo?.freeGb !== null) {
-    diskDetails.freeGb = parseFloat(driveInfo.freeGb);
+  let driveInfo;
+  try {
+    // Types incorrectly specify diskname as required instead of optional
+    // @ts-expect-error
+    driveInfo = await osu.drive.info();
+  } catch (error) {
+    logger.error('Error fetching disk details:', error);
+    return {};
   }
-  return diskDetails;
+
+  return {
+    usedGb:
+      driveInfo?.usedGb !== null ? parseFloat(driveInfo.usedGb) : undefined,
+    freeGb:
+      driveInfo?.freeGb !== null ? parseFloat(driveInfo.freeGb) : undefined
+  };
 }
 
 export async function getMemDetails(): Promise<
   DeviceStatsPayload['memDetails']
 > {
-  const memInfo = await osu.mem.info();
-  const memDetails: DeviceStatsPayload['memDetails'] = {};
-  if (memInfo?.usedMemMb !== null) memDetails.usedMb = memInfo.usedMemMb;
-  if (memInfo?.freeMemMb !== null) memDetails.freeMb = memInfo.freeMemMb;
-  return memDetails;
+  let memInfo;
+  try {
+    memInfo = await osu.mem.info();
+  } catch (error) {
+    logger.error('Error fetching memory details:', error);
+    return {};
+  }
+  return {
+    usedMb: memInfo?.usedMemMb !== null ? memInfo.usedMemMb : undefined,
+    freeMb: memInfo?.freeMemMb !== null ? memInfo.freeMemMb : undefined
+  };
 }
 
-// System information
+// System information casted to a string
 export async function getOsInfo() {
   const osInfo = await si.osInfo();
   return {
-    platform: osInfo.platform,
-    distro: osInfo.distro,
-    release: osInfo.release,
-    kernel: osInfo.kernel,
-    architecture: osInfo.arch,
-    hostname: osInfo.hostname
+    platform: String(osInfo.platform),
+    distro: String(osInfo.distro),
+    release: String(osInfo.release),
+    kernel: String(osInfo.kernel),
+    architecture: String(osInfo.arch),
+    hostname: String(osInfo.hostname)
   };
 }
 
 export async function getCpuInfo() {
   const cpuInfo = await si.cpu();
   return {
-    manufacturer: cpuInfo.manufacturer,
-    brand: cpuInfo.brand,
-    vendor: cpuInfo.vendor,
-    model: cpuInfo.model,
-    cores: cpuInfo.cores,
-    physicalCores: cpuInfo.physicalCores,
-    efficiencyCores: cpuInfo.efficiencyCores,
-    processors: cpuInfo.processors
+    manufacturer: String(cpuInfo.manufacturer),
+    brand: String(cpuInfo.brand),
+    vendor: String(cpuInfo.vendor),
+    model: String(cpuInfo.model),
+    cores: String(cpuInfo.cores),
+    physicalCores: String(cpuInfo.physicalCores),
+    efficiencyCores: String(cpuInfo.efficiencyCores),
+    processors: String(cpuInfo.processors)
   };
 }
 
@@ -78,11 +100,11 @@ export async function getDiskInfo() {
   const diskInfo = await si.diskLayout();
   return {
     drives: diskInfo.map((drive) => ({
-      device: drive.device,
-      type: drive.type,
-      name: drive.name,
-      vendor: drive.vendor,
-      size: drive.size
+      device: String(drive.device),
+      type: String(drive.type),
+      name: String(drive.name),
+      vendor: String(drive.vendor),
+      size: String(drive.size)
     }))
   };
 }
@@ -90,14 +112,14 @@ export async function getDiskInfo() {
 export async function getDeviceInfo() {
   const deviceInfo = await si.system();
   return {
-    manufacturer: deviceInfo.manufacturer,
-    model: deviceInfo.model,
-    version: deviceInfo.version,
+    manufacturer: String(deviceInfo.manufacturer),
+    model: String(deviceInfo.model),
+    version: String(deviceInfo.version),
     serial:
       deviceInfo.serial && deviceInfo.serial !== '-'
-        ? deviceInfo.serial
+        ? String(deviceInfo.serial)
         : undefined,
-    virtual: deviceInfo.virtual
+    virtual: deviceInfo.virtual // this should be a boolean
   };
 }
 
@@ -108,9 +130,9 @@ export async function getNetworkInfo() {
     ? networkInterfaces.filter((iface: any) => iface.ip4 !== '127.0.0.1')[0]
     : networkInterfaces;
   return {
-    ipv4Address: defaultNetworkInterface.ip4,
-    ipv6Address: defaultNetworkInterface.ip6,
-    macAddress: defaultNetworkInterface.mac
+    ipv4Address: String(defaultNetworkInterface.ip4),
+    ipv6Address: String(defaultNetworkInterface.ip6),
+    macAddress: String(defaultNetworkInterface.mac)
   };
 }
 
@@ -123,9 +145,9 @@ export async function getDockerVersion() {
         args: ['info', '--format', 'json']
       })
     );
-    return result.ClientInfo.Version;
+    return String(result.ClientInfo.Version);
   } catch (e) {
-    logger.warn(`Cannot get Docker version: ${e}`);
+    logger.warn(`Cannot get Docker version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -138,7 +160,7 @@ export async function getDockerComposeVersion() {
       args: ['compose', 'version']
     });
   } catch (e) {
-    logger.warn(`Cannot get Docker Compose version: ${e}`);
+    logger.warn(`Cannot get Docker Compose version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -151,7 +173,7 @@ export async function getNpmVersion() {
       args: ['--version']
     });
   } catch (e) {
-    logger.warn(`Cannot get npm version: ${e}`);
+    logger.warn(`Cannot get npm version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -164,7 +186,7 @@ export async function getNodeVersion() {
       args: ['-v']
     });
   } catch (e) {
-    logger.warn(`Cannot get Node version: ${e}`);
+    logger.warn(`Cannot get Node version!\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -174,7 +196,6 @@ export async function getPackageVersions() {
   // eslint-disable-next-line
   const deviceAgentSchemasJson = require('../../node_modules/@alwaysai/device-agent-schemas/package.json');
 
-  // Concurrent asynchronous function call
   const [dockerVersion, dockerComposeVersion, nodeVersion, npmVersion] =
     await Promise.all([
       getDockerVersion(),
@@ -207,27 +228,39 @@ export async function getLastBootTime() {
 
     const tokens = latestBootStdout.trim().split(' ');
 
-    return new Date(`${tokens[2]} ${tokens[3]} ${tokens[4]}`);
+    return String(new Date(`${tokens[2]} ${tokens[3]} ${tokens[4]}`));
   } catch (e) {
-    logger.error(`Issue getting last boot time: ${e.message}`);
+    logger.error(`Issue getting last boot time!\n${stringifyError(e)}`);
     return undefined;
   }
 }
 
 export async function getSystemInformation(): Promise<SystemInformationShadowUpdate> {
   try {
+    const [os, cpu, disk, device, network, versions, lastBootTime] =
+      await Promise.all([
+        getOsInfo(),
+        getCpuInfo(),
+        getDiskInfo(),
+        getDeviceInfo(),
+        getNetworkInfo(),
+        getPackageVersions(),
+        getLastBootTime()
+      ]);
     const systemInfo: SystemInformationShadowUpdate = {
-      os: await getOsInfo(),
-      cpu: await getCpuInfo(),
-      disk: await getDiskInfo(),
-      device: await getDeviceInfo(),
-      network: await getNetworkInfo(),
-      versions: await getPackageVersions(),
-      lastBootTime: (await getLastBootTime())?.toString()
+      os,
+      cpu,
+      disk,
+      device,
+      network,
+      versions,
+      lastBootTime
     };
     return systemInfo;
   } catch (e) {
-    logger.error('There was a problem getting system information: ', e);
+    logger.error(
+      `There was a problem getting system information!\n${stringifyError(e)}`
+    );
   }
   return {};
 }
@@ -242,11 +275,10 @@ export async function reboot() {
       timeout: 5000
     });
     logger.info(result.stdout.trim());
-  } catch (err) {
-    throw new Error(
-      `Could not reboot device. You may need to add passwordless access to '/sbin/shutdown'. ${JSON.stringify(
-        err
-      )}`
+  } catch (e) {
+    throw new AaiError(
+      "Could not reboot device. You may need to add passwordless access to '/sbin/shutdown'.",
+      { cause: e }
     );
   }
 }

package/src/docker/docker-compose.ts

@@ -2,7 +2,7 @@ import * as DockerComposeV1 from 'docker-compose';
 import { v2 as DockerComposeV2 } from 'docker-compose';
 import { execSync } from 'child_process';
 import { logger } from '../util/logger';
-import { JsSpawner } from 'alwaysai/lib/util';
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
 
 let dockerCmd = 'docker';
 
@@ -14,11 +14,12 @@ export function importDockerCompose():
     logger.debug('Using Docker Compose V2.');
     return DockerComposeV2;
   } catch (e) {
+    // TODO: Log this error as well
     try {
       execSync('docker-compose -v').toString();
       logger.warn('Using docker-compose V1. Please consider updating to V2.');
     } catch (e) {
-      logger.warn(`Could not determine compose: ${e}`);
+      logger.warn(`Could not determine compose!\n${stringifyError(e)}`);
     }
   }
   dockerCmd = 'docker-compose';

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

@@ -1,7 +1,11 @@
+import { getDeviceConfigPath } from 'alwaysai/lib/infrastructure';
+import { join } from 'path';
 import * as tempy from 'tempy';
-import { AgentConfigFile } from './agent-config';
+import { AGENT_CONFIG_FILE_NAME, AgentConfigFile } from './agent-config';
 
-const configFile = AgentConfigFile(tempy.directory());
+const configFile = AgentConfigFile(
+  join(tempy.directory(), getDeviceConfigPath(), AGENT_CONFIG_FILE_NAME)
+);
 
 describe('Test Agent Config', () => {
   beforeEach(() => {