@alwaysai/device-agent 1.4.0 → 2.0.0

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

@@ -4,7 +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, 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);
 
@@ -12,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)
   };
 }
 
@@ -76,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)
     }))
   };
 }
@@ -88,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
   };
 }
 
@@ -106,53 +130,137 @@ 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)
   };
 }
 
+export async function getDockerVersion() {
+  try {
+    const spawner = JsSpawner();
+    const result = JSON.parse(
+      await spawner.run({
+        exe: 'docker',
+        args: ['info', '--format', 'json']
+      })
+    );
+    return String(result.ClientInfo.Version);
+  } catch (e) {
+    logger.warn(`Cannot get Docker version!\n${stringifyError(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!\n${stringifyError(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!\n${stringifyError(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!\n${stringifyError(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');
+
+  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 getLastBootTime() {
   try {
-    const test = await exec_promise(
-      "last -x reboot | grep reboot | head -n 1 | awk '{ print $5, $6, $7, $8 }'"
-    );
-    if (test.stderr) {
-      logger.error(`Stderr when getting last boot time: ${test.stderr}`);
+    const out = await exec_promise('journalctl --list-boots');
+    if (!out || out.stderr) {
+      logger.error(`Stderr when getting last boot time: ${out.stderr}`);
       return undefined;
     }
-    return new Date(test.stdout).toString();
+
+    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 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()
+      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 {};
 }
@@ -167,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

@@ -0,0 +1,61 @@
+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, stringifyError } 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) {
+    // 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!\n${stringifyError(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

@@ -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(() => {
@@ -95,6 +99,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

@@ -3,7 +3,8 @@ import {
   ConfigFileSchemaReturnType
 } from '@alwaysai/config-nodejs';
 import Ajv, { JSONSchemaType } from 'ajv';
-import { homedir } from 'os';
+import { getDeviceConfigPath } from 'alwaysai/lib/infrastructure';
+import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/paths';
 import { join } from 'path';
 
 export interface AppBackupConfig {
@@ -54,65 +55,29 @@ const schema: JSONSchemaType<AgentConfig> = {
 const ajv = new Ajv();
 const validateFunction = ajv.compile(schema);
 
-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 const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
 
-export function AgentConfigFile(
-  dir = ALWAYSAI_CONFIG_DIR
-): AgentJsonFileReturnType {
-  const path = join(dir, AGENT_CONFIG_FILE_NAME);
+export function AgentConfigFile(filePath?: string) {
+  const path =
+    filePath ??
+    join(LOCAL_AAI_CFG_DIR, getDeviceConfigPath(), AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
     applications: []
   };
-  const configFile = ConfigFileSchema({
+  const configFile = ConfigFileSchema<AgentConfig>({
     path,
     validateFunction,
     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 +170,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 +217,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
+  };
 }