@alwaysai/device-agent 1.3.1 → 1.5.0

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

@@ -1,38 +1,50 @@
-import { SystemInformationPayload } from '@alwaysai/device-agent-schemas';
+import { SystemInformationShadowUpdate } from '@alwaysai/device-agent-schemas';
 import { logger } from '../util/logger';
 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 { DeviceStatsPayload } from '@alwaysai/device-agent-schemas';
+import { getDeviceAgentVersion } from '../util/check-for-updates';
 
 const exec_promise = promisify(exec);
 
 // Device Stats
-export async function getCpuDetails() {
+export async function getCpuDetails(): Promise<
+  DeviceStatsPayload['cpuDetails']
+> {
   const cpuFree = await osu.cpu.free();
   const cpuTemp = await si.cpuTemperature();
-  return {
-    usedPerc: 100.0 - cpuFree,
-    temperature: cpuTemp.main
-  };
+  const cpuDetails: DeviceStatsPayload['cpuDetails'] = {};
+  if (cpuFree !== null) cpuDetails.usedPerc = 100 - cpuFree;
+  if (cpuTemp?.main !== null) cpuDetails.temperature = cpuTemp.main;
+  return cpuDetails;
 }
 
-export async function getDiskDetails() {
+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();
-  return {
-    usedGb: parseFloat(driveInfo.usedGb),
-    freeGb: parseFloat(driveInfo.freeGb)
-  };
+  const diskDetails: DeviceStatsPayload['diskDetails'] = {};
+  if (driveInfo?.usedGb !== null)
+    diskDetails.usedGb = parseFloat(driveInfo.usedGb);
+  if (driveInfo?.freeGb !== null) {
+    diskDetails.freeGb = parseFloat(driveInfo.freeGb);
+  }
+  return diskDetails;
 }
 
-export async function getMemDetails() {
+export async function getMemDetails(): Promise<
+  DeviceStatsPayload['memDetails']
+> {
   const memInfo = await osu.mem.info();
-  return {
-    usedMb: memInfo.usedMemMb,
-    freeMb: memInfo.freeMemMb
-  };
+  const memDetails: DeviceStatsPayload['memDetails'] = {};
+  if (memInfo?.usedMemMb !== null) memDetails.usedMb = memInfo.usedMemMb;
+  if (memInfo?.freeMemMb !== null) memDetails.freeMb = memInfo.freeMemMb;
+  return memDetails;
 }
 
 // System information
@@ -102,26 +114,116 @@ export async function getNetworkInfo() {
   };
 }
 
+export async function getDockerVersion() {
+  try {
+    const spawner = JsSpawner();
+    const result = JSON.parse(
+      await spawner.run({
+        exe: 'docker',
+        args: ['info', '--format', 'json']
+      })
+    );
+    return result.ClientInfo.Version;
+  } catch (e) {
+    logger.warn(`Cannot get Docker version: ${e}`);
+    return 'Not found';
+  }
+}
+
+export async function getDockerComposeVersion() {
+  try {
+    const spawner = JsSpawner();
+    return await spawner.run({
+      exe: 'docker',
+      args: ['compose', 'version']
+    });
+  } catch (e) {
+    logger.warn(`Cannot get Docker Compose version: ${e}`);
+    return 'Not found';
+  }
+}
+
+export async function getNpmVersion() {
+  try {
+    const spawner = JsSpawner();
+    return await spawner.run({
+      exe: 'npm',
+      args: ['--version']
+    });
+  } catch (e) {
+    logger.warn(`Cannot get npm version: ${e}`);
+    return 'Not found';
+  }
+}
+
+export async function getNodeVersion() {
+  try {
+    const spawner = JsSpawner();
+    return await spawner.run({
+      exe: 'node',
+      args: ['-v']
+    });
+  } catch (e) {
+    logger.warn(`Cannot get Node version: ${e}`);
+    return 'Not found';
+  }
+}
+
 export async function getPackageVersions() {
-  // eslint-disable-next-line
-  const agentJson = require('../../package.json');
+  const agentVersion = await getDeviceAgentVersion();
   // 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(),
+      getDockerComposeVersion(),
+      getNodeVersion(),
+      getNpmVersion()
+    ]);
+
   return {
-    agent: agentJson.version,
-    deviceAgentSchemas: deviceAgentSchemasJson.version
+    agent: agentVersion,
+    deviceAgentSchemas: deviceAgentSchemasJson.version,
+    docker: dockerVersion,
+    dockerCompose: dockerComposeVersion,
+    node: nodeVersion,
+    npm: npmVersion
   };
 }
 
-export async function getSystemInformation(): Promise<SystemInformationPayload> {
+export async function getLastBootTime() {
+  try {
+    const out = await exec_promise('journalctl --list-boots');
+    if (!out || out.stderr) {
+      logger.error(`Stderr when getting last boot time: ${out.stderr}`);
+      return undefined;
+    }
+
+    const bootTimes = out.stdout.split('\n');
+    const latestBootStdout = (bootTimes.pop() || bootTimes.pop())?.trim(); // possible last \n causes '' at end of array
+    if (!latestBootStdout) return undefined;
+
+    const tokens = latestBootStdout.trim().split(' ');
+
+    return new Date(`${tokens[2]} ${tokens[3]} ${tokens[4]}`);
+  } catch (e) {
+    logger.error(`Issue getting last boot time: ${e.message}`);
+    return undefined;
+  }
+}
+
+export async function getSystemInformation(): Promise<SystemInformationShadowUpdate> {
   try {
-    const systemInfo: SystemInformationPayload = {
+    const systemInfo: SystemInformationShadowUpdate = {
       os: await getOsInfo(),
       cpu: await getCpuInfo(),
       disk: await getDiskInfo(),
       device: await getDeviceInfo(),
       network: await getNetworkInfo(),
-      versions: await getPackageVersions()
+      versions: await getPackageVersions(),
+      lastBootTime: (await getLastBootTime())?.toString()
     };
     return systemInfo;
   } catch (e) {

package/src/docker/docker-compose.ts

@@ -0,0 +1,60 @@
+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';
+
+let dockerCmd = 'docker';
+
+export function importDockerCompose():
+  | typeof DockerComposeV1
+  | typeof DockerComposeV2 {
+  try {
+    execSync('docker compose version').toString();
+    logger.debug('Using Docker Compose V2.');
+    return DockerComposeV2;
+  } catch (e) {
+    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}`);
+    }
+  }
+  dockerCmd = 'docker-compose';
+  return DockerComposeV1;
+}
+
+export const compose = importDockerCompose();
+
+export async function runDockerComposeCmd(props: {
+  args: string[];
+  dir: string;
+}) {
+  const { args, dir } = props;
+  const spawner = JsSpawner();
+  if (dockerCmd === 'docker') {
+    args.unshift('compose');
+  }
+  const output = await spawner.run({
+    exe: dockerCmd,
+    args,
+    cwd: dir
+  });
+  return output;
+}
+
+export async function runStreamingDockerComposeCmd(props: {
+  args: string[];
+  dir: string;
+}) {
+  const { args, dir } = props;
+  if (dockerCmd === 'docker') {
+    args.unshift('compose');
+  }
+  return await JsSpawner().runStreaming({
+    exe: dockerCmd,
+    args,
+    cwd: dir
+  });
+}

package/src/index.ts

@@ -10,13 +10,9 @@ import { root } from './root';
 import { runDeviceAgentCloudInterface } from './cloud-connection/device-agent-cloud-connection';
 import { AgentConfigFile } from './infrastructure/agent-config';
 import { ALWAYSAI_DEVICE_AGENT_MODE } from './environment';
-import { logger } from './util/logger';
-
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { version } = require('../package.json');
+import { checkForUpdatesAndPrompt } from './util/check-for-updates';
 
 if (module === require.main) {
-  logger.info(`Starting alwaysAI Device Agent v${version}`);
   if (!AgentConfigFile().exists()) {
     AgentConfigFile().initialize();
   }
@@ -24,6 +20,6 @@ if (module === require.main) {
   if (ALWAYSAI_DEVICE_AGENT_MODE === 'cloud') {
     void runDeviceAgentCloudInterface();
   } else {
-    void runCliAndExit(root, {});
+    void runCliAndExit(root, { postRun: checkForUpdatesAndPrompt });
   }
 }

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

@@ -95,6 +95,9 @@ describe('Test Agent Config', () => {
       expect(await configFile.getAppVersion({ projectId })).toEqual(version);
       await configFile.setAppInstalled({ projectId, version });
       expect(await configFile.getAppVersion({ projectId })).toEqual(version);
+      expect(await configFile.isAppReady({ projectId })).toEqual(true);
+      await configFile.setAppUninstalling({ projectId });
+      expect(await configFile.isAppReady({ projectId })).toEqual(false);
       await configFile.setAppUninstalled({ projectId });
       const apps = await configFile.getApps();
       expect(apps).toEqual([]);

package/src/infrastructure/agent-config.ts

@@ -58,26 +58,7 @@ const ALWAYSAI_CONFIG_DIR = join(homedir(), '.config', 'alwaysai');
 
 const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
 
-export interface AgentJsonFileReturnType
-  extends ConfigFileSchemaReturnType<AgentConfig> {
-  name: string;
-  getApps: () => Promise<InstalledAppConfig[]>;
-  getReadyApps;
-  getApp;
-  isAppPresent;
-  isAppReady;
-  removeApp;
-  setAppInstalling;
-  setAppInstalled;
-  setAppUninstalled;
-  getAppVersion: (props: { projectId: string }) => Promise<string>;
-  setAppBackup;
-  getAppBackup;
-}
-
-export function AgentConfigFile(
-  dir = ALWAYSAI_CONFIG_DIR
-): AgentJsonFileReturnType {
+export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
   const path = join(dir, AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
     applications: []
@@ -88,31 +69,14 @@ export function AgentConfigFile(
     initialValue
   });
 
-  return {
-    ...configFile,
-    name: AGENT_CONFIG_FILE_NAME,
-    getApps,
-    getReadyApps,
-    getApp,
-    isAppPresent,
-    isAppReady,
-    removeApp,
-    setAppInstalling,
-    setAppInstalled,
-    setAppUninstalled,
-    getAppVersion,
-    setAppBackup,
-    getAppBackup
-  };
-
   async function getApps() {
     const config = configFile.read();
-    return config && config.applications ? config.applications : [];
+    return config?.applications ? config.applications : [];
   }
 
   async function getReadyApps() {
     const config = configFile.read();
-    return config && config.applications
+    return config?.applications
       ? config.applications.filter((app) => {
           return app.ready;
         })
@@ -205,6 +169,23 @@ export function AgentConfigFile(
     }
   }
 
+  async function setAppUninstalling(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      await removeApp({ projectId });
+      const config = configFile.read();
+      config.applications.push({ ...app, ...{ ready: false } });
+      configFile.write(config);
+    } else {
+      // 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!`
+      );
+    }
+  }
+
   async function setAppUninstalled(props: { projectId: string }) {
     const { projectId } = props;
     await removeApp({ projectId });
@@ -235,9 +216,26 @@ export function AgentConfigFile(
   async function getAppBackup(props: { projectId: string }) {
     const { projectId } = props;
     const app = await getApp({ projectId });
-    if (app && app.backup) {
+    if (app?.backup) {
       return app.backup;
     }
     return null;
   }
+
+  return {
+    ...configFile,
+    name: AGENT_CONFIG_FILE_NAME,
+    getApps,
+    getReadyApps,
+    getApp,
+    isAppPresent,
+    isAppReady,
+    setAppInstalling,
+    setAppInstalled,
+    setAppUninstalling,
+    setAppUninstalled,
+    getAppVersion,
+    setAppBackup,
+    getAppBackup
+  };
 }

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

@@ -1,6 +1,6 @@
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
-import compose from 'docker-compose';
+import { compose } from '../docker/docker-compose';
 import * as YAML from 'yaml';
 
 import {
@@ -23,19 +23,19 @@ export async function checkRabbitMQContainerRunning() {
     return false;
   }
   const containerData = await compose.ps({ cwd: DEVICE_AGENT_CFG_PATH });
-  if (!(containerData === undefined)) {
+  if (containerData !== undefined) {
     const rabbitmqService = containerData.data.services[0];
     if (
-      rabbitmqService.name === rabbitMQContainerName &&
-      rabbitmqService.state === 'Up'
+      rabbitmqService?.name === rabbitMQContainerName &&
+      rabbitmqService.state.includes('Up')
     ) {
-      logger.debug('alwaysAI Local Connection is running');
+      logger.debug('alwaysAI Local Connection Container is up');
       return true;
     }
-    logger.debug('alwaysAI Local Connection is not running');
+    logger.debug('alwaysAI Local Connection Container is not up');
     return false;
   }
-  logger.warn('alwaysAI Local Connection container was undefined');
+  logger.warn('alwaysAI Local Connection Container is undefined');
   return false;
 }
 
@@ -97,7 +97,7 @@ export async function setupRabbitMQContainer() {
     }
   } catch (e) {
     logger.error(
-      `Unable to start alwaysAI Device Agent Local Connection Container:\n${e.messaage}`
+      `Unable to start alwaysAI Device Agent Local Connection Container:\n${e}`
     );
   }
 }