@alwaysai/device-agent 1.3.1 → 1.5.0

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

@@ -0,0 +1,123 @@
+import { ChildProcess, spawn } from 'child_process';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+
+const DEFAULT_TIMEOUT_MS = 5000;
+
+export async function runDetachedProcess(
+  command: string,
+  args: string[],
+  timeoutMs = DEFAULT_TIMEOUT_MS
+): Promise<ChildProcess> {
+  logger.debug('-> runDetachedProcess');
+
+  let isSpawned = false; // Flag to indicate if process has been successfully spawned
+
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: 'ignore'
+  });
+
+  child.unref();
+
+  // Create a promise that resolves after the specified timeout
+  const timeoutPromise = new Promise<ChildProcess>((resolve, reject) => {
+    setTimeout(() => {
+      if (!isSpawned) {
+        logger.error('Timeout spawning off detached process');
+        resolve(child); // Resolve the promise with the child process even if timeout occurs
+      }
+    }, timeoutMs);
+  });
+
+  // Handle 'spawn' event
+  child.once('spawn', () => {
+    isSpawned = true;
+  });
+
+  // Race between the actual process spawning and the timeout
+  await Promise.race([
+    new Promise<ChildProcess>((resolve) => {
+      if (isSpawned) {
+        resolve(child); // Resolve immediately if process has already been spawned
+      } else {
+        child.once('spawn', () => resolve(child));
+      }
+    }),
+    timeoutPromise
+  ]);
+
+  logger.debug('<- runDetachedProcess');
+  return child;
+}
+
+export async function killDetachedProcess(
+  detachedProcess: ChildProcess,
+  processName?: string[],
+  timeoutMs = DEFAULT_TIMEOUT_MS
+): Promise<void> {
+  logger.debug('-> killDetachedProcess');
+  return new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      if (processName) {
+        killDetachedProcessByName(processName, timeoutMs)
+          .then(() => resolve())
+          .catch((err) => reject(err));
+      } else {
+        reject(new Error('killDetachedProcess timeout'));
+      }
+    }, timeoutMs);
+
+    detachedProcess.on('exit', (code) => {
+      clearTimeout(timeout);
+      logger.debug(`Process exited with code ${code}`);
+      resolve();
+    });
+
+    detachedProcess.on('error', (error) => {
+      clearTimeout(timeout);
+      if (processName) {
+        killDetachedProcessByName(processName, timeoutMs)
+          .then(() => resolve())
+          .catch((err) => reject(err));
+      } else {
+        logger.error('killDetachedProcess error occurred:', error);
+        reject(error);
+      }
+    });
+
+    detachedProcess.kill('SIGTERM');
+    logger.debug('<- killDetachedProcess');
+  });
+}
+
+export async function killDetachedProcessByName(
+  processName: string[],
+  timeoutMs = DEFAULT_TIMEOUT_MS
+): Promise<void> {
+  logger.debug('-> killDetachedProcessByName');
+  return new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      logger.error('Timeout waiting for process kill by name');
+      reject(new Error('killDetachedProcessByName timeout'));
+    }, timeoutMs);
+
+    JsSpawner()
+      .run({
+        exe: 'pkill',
+        args: processName
+      })
+      .then(() => {
+        clearTimeout(timeout);
+        resolve();
+      })
+      .catch((error) => {
+        clearTimeout(timeout);
+        logger.error('killDetachedProcessByName error occurred:', error);
+        reject(error);
+      })
+      .finally(() => {
+        logger.debug('<- killDetachedProcessByName');
+      });
+  });
+}

package/src/subcommands/app/analytics.ts

@@ -9,6 +9,10 @@ import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-
 import sleep from '../../util/sleep';
 import { logger } from '../../util/logger';
 import { assign, merge } from 'lodash';
+import {
+  buildUpdateProjectShadowMessage,
+  getShadowTopic
+} from '@alwaysai/device-agent-schemas';
 
 export const getAnalyticsCfgCliLeaf = CliLeaf({
   name: 'get-analytics-cfg',
@@ -73,21 +77,20 @@ export const setAnalyticsCfgCliLeaf = CliLeaf({
     const appCfg = assign(existingAppCfg, merge(existingAppCfg, newAppCfg));
 
     // Update the shadow as a client
-    const topic = deviceAgent.getShadowTopics().projects.update;
-    const packet = {
-      state: {
-        desired: {
-          [project]: {
-            appConfig: JSON.stringify(appCfg) // Pack app config as string as dictated by schema
-          }
-        }
-      },
-      clientToken: 'client'
+    const toDesire = {
+      [project]: {
+        appConfig: JSON.stringify(appCfg) // Pack app config as string as dictated by schema
+      }
     };
-    logger.debug(
-      `Publishing message:\n${JSON.stringify({ topic, packet }, null, 2)}`
+    deviceAgent.publisher.publish(
+      getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
+      JSON.stringify(
+        buildUpdateProjectShadowMessage({
+          clientId: 'client',
+          desired: toDesire
+        })
+      )
     );
-    deviceAgent.publisher.publish(topic, JSON.stringify(packet));
     // Sleep for extra time to ensure time for shadow response
     await sleep(10000);
 

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

@@ -8,6 +8,10 @@ import { EnvVars, 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
+} from '@alwaysai/device-agent-schemas';
 
 export const getAllEnvsCliLeaf = CliLeaf({
   name: 'get-all-envs',
@@ -43,7 +47,7 @@ export const setEnvCliLeaf = CliLeaf({
     })
   },
   async action(args, opts) {
-    const { project, service } = opts;
+    const { project: projectId, service } = opts;
     const envVars: EnvVars = { [service]: {} };
     args.forEach((arg: string) => {
       const nameVal = arg.split('=');
@@ -56,26 +60,24 @@ export const setEnvCliLeaf = CliLeaf({
     const deviceAgent = new DeviceAgentCloudConnection();
     await deviceAgent.setupHandlers();
 
-    // Update the shadow as a client
-    const topic = deviceAgent.getShadowTopics().projects.update;
-    const packet = {
-      state: {
-        desired: {
-          [project]: {
-            envVars
-          }
-        }
-      },
-      clientToken: 'client'
+    const toDesire = {
+      [projectId]: {
+        envVars
+      }
     };
-    logger.debug(
-      `Publishing message:\n${JSON.stringify({ topic, packet }, null, 2)}`
+    deviceAgent.publisher.publish(
+      getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
+      JSON.stringify(
+        buildUpdateProjectShadowMessage({
+          clientId: 'client',
+          desired: toDesire
+        })
+      )
     );
-    deviceAgent.publisher.publish(topic, JSON.stringify(packet));
     // Sleep for extra time to ensure time for shadow response
     await sleep(10000);
 
-    while (deviceAgent.isCmdInProgress(project)) {
+    while (deviceAgent.isCmdInProgress(projectId)) {
       await sleep(1000);
     }
     await deviceAgent.stop();

package/src/subcommands/app/models.ts

@@ -14,6 +14,11 @@ import {
 import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-cloud-connection';
 import sleep from '../../util/sleep';
 import { logger } from '../../util/logger';
+import {
+  buildUpdateProjectShadowMessage,
+  getShadowTopic,
+  validateShadowProjectsUpdateAll
+} from '@alwaysai/device-agent-schemas';
 
 export const showAppModelsCliLeaf = CliLeaf({
   name: 'show-models',
@@ -49,34 +54,33 @@ export const addModelCliLeaf = CliLeaf({
     })
   },
   async action(_, opts) {
-    const { project, model, version } = opts;
+    const { project: projectId, model, version } = opts;
     const deviceAgent = new DeviceAgentCloudConnection();
     await deviceAgent.setupHandlers();
 
     // Update the shadow as a client
-    const topic = deviceAgent.getShadowTopics().projects.update;
 
-    const newAppCfg = await readAppCfgFile({ projectId: project });
+    const newAppCfg = await readAppCfgFile({ projectId: projectId });
     newAppCfg.models[model] = Number(version);
 
-    const packet = {
-      state: {
-        desired: {
-          [project]: {
-            appConfig: JSON.stringify(newAppCfg)
-          }
-        }
-      },
-      clientToken: 'client'
+    const toDesire = {
+      [projectId]: {
+        appConfig: JSON.stringify(newAppCfg)
+      }
     };
-    logger.debug(
-      `Publishing message:\n${JSON.stringify({ topic, packet }, null, 2)}`
+    deviceAgent.publisher.publish(
+      getShadowTopic(deviceAgent.getClientId(), 'projects', 'update'),
+      JSON.stringify(
+        buildUpdateProjectShadowMessage({
+          clientId: 'client',
+          desired: toDesire
+        })
+      )
     );
-    deviceAgent.publisher.publish(topic, JSON.stringify(packet));
     // Sleep for extra time to ensure time for shadow response
     await sleep(10000);
 
-    while (deviceAgent.isCmdInProgress(project)) {
+    while (deviceAgent.isCmdInProgress(projectId)) {
       await sleep(1000);
     }
     await deviceAgent.stop();

package/src/subcommands/device/clean.ts

@@ -14,7 +14,7 @@ import {
 } from '../../local-connection/rabbitmq-connection';
 import { stopApp } from '../../application-control';
 import { LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/paths';
-import safeRimraf from '../../util/safe-rimraf';
+import { safeRimraf } from '../../util/file';
 
 export const cleanCliLeaf = CliLeaf({
   name: 'clean',
@@ -36,10 +36,13 @@ export const cleanCliLeaf = CliLeaf({
 
     logger.debug('Checking for alwaysAI applications still running');
     const apps = await AgentConfigFile().getApps();
+    const stopAppPromises: Promise<void>[] = [];
     for (const app of apps) {
       const { projectId } = app;
-      await stopApp({ projectId });
+      stopAppPromises.push(stopApp({ projectId }));
     }
+    await Promise.all(stopAppPromises);
+
     await safeRimraf(LOCAL_CERT_AND_KEY_DIR);
 
     logger.debug(`Removing ${AgentConfigFile().path}`);

package/src/subcommands/device/get-info.ts

@@ -0,0 +1,49 @@
+import { CliLeaf } from '@alwaysai/alwayscli';
+import {
+  getCpuDetails,
+  getDiskDetails,
+  getMemDetails,
+  getSystemInformation
+} from '../../device-control/device-control';
+
+export const getInfoCliLeaf = CliLeaf({
+  name: 'get-info',
+  description: 'Get device info',
+  namedInputs: {},
+  async action(_, opts) {
+    const cpuDetails = await getCpuDetails();
+    const diskDetails = await getDiskDetails();
+    const memDetails = await getMemDetails();
+    const out = {
+      'CPU Utilization': `${
+        cpuDetails?.usedPerc && cpuDetails.temperature
+          ? `Used ${cpuDetails?.usedPerc?.toFixed(2)}%, Temperature ${
+              cpuDetails?.temperature
+            } °C`
+          : 'Unavailable'
+      }`,
+      'Disk Utilization': `${
+        diskDetails?.usedGb && diskDetails.freeGb
+          ? `${diskDetails?.usedGb} GB / ${
+              diskDetails?.usedGb + diskDetails?.freeGb
+            } GB`
+          : 'Unavailable'
+      }`,
+      'Memory Utilization': `${
+        memDetails?.usedMb && memDetails.freeMb
+          ? `${memDetails.usedMb} MB / ${
+              memDetails.usedMb + memDetails.freeMb
+            } MB`
+          : 'Unavailable'
+      }`
+    };
+    console.table(out);
+    const systemInfo = await getSystemInformation();
+    console.table(systemInfo.os);
+    console.table(systemInfo.cpu);
+    console.table(systemInfo.disk?.drives);
+    console.table(systemInfo.device);
+    console.table(systemInfo.network);
+    console.table(systemInfo.versions);
+  }
+});

package/src/subcommands/device/index.ts

@@ -1,9 +1,18 @@
 import { CliBranch } from '@alwaysai/alwayscli';
-import { getInfoCliLeaf, initCliLeaf, restartCliLeaf } from './device';
+import { getInfoCliLeaf } from './get-info';
 import { cleanCliLeaf } from './clean';
+import { initCliLeaf } from './init';
+import { restartCliLeaf } from './restart';
+import { refreshCliLeaf } from './refresh';
 
 export const deviceCliBranch = CliBranch({
   name: 'device',
   description: 'Manage current device',
-  subcommands: [initCliLeaf, getInfoCliLeaf, cleanCliLeaf, restartCliLeaf]
+  subcommands: [
+    initCliLeaf,
+    getInfoCliLeaf,
+    refreshCliLeaf,
+    cleanCliLeaf,
+    restartCliLeaf
+  ]
 });

package/src/subcommands/device/{device.ts → init.ts}

@@ -11,13 +11,6 @@ import {
 } from '../../util/directories';
 
 import { JsSpawner } from 'alwaysai/lib/util';
-import {
-  getCpuDetails,
-  getDiskDetails,
-  getMemDetails,
-  getSystemInformation,
-  reboot
-} from '../../device-control/device-control';
 import { writeTokenAndDeviceCfg } from '../../infrastructure/tokens-and-device-cfg';
 import { logger } from '../../util/logger';
 import { DeviceConfigFile } from 'alwaysai/lib/core/device';
@@ -95,49 +88,14 @@ export const initCliLeaf = CliLeaf({
     const certSpawner = JsSpawner({
       path: BOOTSTRAP_CERTIFICATES_DIR_PATH()
     });
+    const writeCertFilePromises: Promise<void>[] = [];
     for (const key in response.claimCertificate) {
-      await certSpawner.writeFile(key, response.claimCertificate[key]);
+      writeCertFilePromises.push(
+        certSpawner.writeFile(key, response.claimCertificate[key])
+      );
     }
+    await Promise.all(writeCertFilePromises);
 
     logger.info(`Initialized device ${name}: UUID=${response.deviceUuid}`);
   }
 });
-
-export const getInfoCliLeaf = CliLeaf({
-  name: 'get-info',
-  description: 'Get device info',
-  namedInputs: {},
-  async action(_, opts) {
-    const cpuDetails = await getCpuDetails();
-    const diskDetails = await getDiskDetails();
-    const memDetails = await getMemDetails();
-    const out = {
-      'CPU Utilization': `Used ${cpuDetails.usedPerc.toFixed(
-        2
-      )}%, Temperature ${cpuDetails.temperature} °C`,
-      'Disk Utilization': `${diskDetails.usedGb} GB / ${
-        diskDetails.usedGb + diskDetails.freeGb
-      } GB`,
-      'Memory Utilization': `${memDetails.usedMb} MB / ${
-        memDetails.usedMb + memDetails.freeMb
-      } MB`
-    };
-    console.table(out);
-    const systemInfo = await getSystemInformation();
-    console.table(systemInfo.os);
-    console.table(systemInfo.cpu);
-    console.table(systemInfo.disk?.drives);
-    console.table(systemInfo.device);
-    console.table(systemInfo.network);
-    console.table(systemInfo.versions);
-  }
-});
-
-export const restartCliLeaf = CliLeaf({
-  name: 'restart',
-  description: 'Restart the device',
-  namedInputs: {},
-  async action(_, opts) {
-    await reboot();
-  }
-});

package/src/subcommands/device/refresh.ts

@@ -0,0 +1,22 @@
+import { CliLeaf, CliTerseError } from '@alwaysai/alwayscli';
+import { writeTokenAndDeviceCfg } from '../../infrastructure/tokens-and-device-cfg';
+import { logger } from '../../util/logger';
+import { DeviceConfigFile } from 'alwaysai/lib/core/device';
+
+export const refreshCliLeaf = CliLeaf({
+  name: 'refresh',
+  description: 'Refresh the device tokens',
+  namedInputs: {},
+  async action(_, opts) {
+    logger.info(`Refreshing device tokens`);
+    const cfg = DeviceConfigFile().readIfExists();
+    if (cfg === undefined) {
+      throw new CliTerseError('Configuration not found on current device!');
+    }
+    const deviceUuid = cfg.deviceUuid;
+
+    await writeTokenAndDeviceCfg({
+      deviceUuid
+    });
+  }
+});

package/src/subcommands/device/restart.ts

@@ -0,0 +1,11 @@
+import { CliLeaf } from '@alwaysai/alwayscli';
+import { reboot } from '../../device-control/device-control';
+
+export const restartCliLeaf = CliLeaf({
+  name: 'restart',
+  description: 'Restart the device',
+  namedInputs: {},
+  async action(_, opts) {
+    await reboot();
+  }
+});

package/src/util/check-for-updates.ts

@@ -0,0 +1,69 @@
+import { logger } from '../util/logger';
+import { JsSpawner } from 'alwaysai/lib/util';
+import * as path from 'path';
+import { get } from 'https';
+
+const appPrompt =
+  'Please restart the Device Agent or reboot the device to update. ';
+const updatePrompt = `A new version of the Device Agent is available! \n\n`;
+
+function getLatestVersion(packageName: string): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    const url = `https://registry.npmjs.org/${packageName}/latest`;
+
+    get(url, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        try {
+          const latestPackage = JSON.parse(data);
+          resolve(latestPackage.version);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }).on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+export async function getDeviceAgentVersion(): Promise<string> {
+  let daVersion = '';
+  try {
+    const packagePath = path.join(__dirname, '../../');
+    const spawner = JsSpawner({ path: packagePath });
+    const output = await spawner.readFile('package.json');
+    const parsed = JSON.parse(output);
+    daVersion = parsed.version;
+  } catch (e) {
+    logger.error(`Could not retrieve the Device Agent version: $ {e}`);
+  }
+  return daVersion;
+}
+
+function constructPrompt(props: { currentVer: string; latestVer: string }) {
+  const { currentVer, latestVer } = props;
+  const prompt = `${updatePrompt}${appPrompt}\nYour version: ${currentVer}. Newest version: ${latestVer}`;
+  return prompt;
+}
+
+export async function checkForUpdatesAndPrompt() {
+  try {
+    logger.debug('Checking for updates...');
+    const latestVersion = await getLatestVersion('@alwaysai/device-agent');
+    const version = await getDeviceAgentVersion();
+    if (version !== latestVersion) {
+      logger.warn(
+        constructPrompt({
+          currentVer: version,
+          latestVer: latestVersion
+        })
+      );
+    }
+  } catch (error) {
+    logger.error(`Could not check for updates: ${error}`);
+  }
+}

package/src/util/cloud-mode-ready.ts

@@ -5,6 +5,42 @@ import {
   DEVICE_CERTIFICATE_FILE_PATH
 } from '../util/directories';
 
+const VALID_AWS_REGIONS = [
+  // 'af-south-1', // Africa (Cape Town)
+  // 'ap-east-1', // Asia Pacific (Hong Kong)
+  // 'ap-south-2', // Asia Pacific (Hyderabad)
+  // 'ap-northeast-1', // Asia Pacific (Tokyo)
+  // 'ap-northeast-2', // Asia Pacific (Seoul)
+  // 'ap-northeast-3', // Asia Pacific (Osaka)
+  // 'ap-south-1', // Asia Pacific (Mumbai)
+  // 'ap-southeast-1', // Asia Pacific (Singapore)
+  // 'ap-southeast-2', // Asia Pacific (Sydney)
+  // 'ap-southeast-3', // Asia Pacific (Jakarta)
+  // 'ap-southeast-4', // Asia Pacific (Melbourne)
+  // 'ca-central-1', // Canada (Central)
+  // 'ca-west-1', // Canada West (Calgary)
+  // 'eu-west-2', // Europe (London)
+  // 'eu-west-3', // Europe (Paris)
+  // 'eu-central-1', // Europe (Frankfurt)
+  // 'eu-central-2', // Europe (Zurich)
+  // 'eu-north-1', // Europe (Stockholm)
+  // 'eu-south-1', // Europe (Milan)
+  // 'eu-south-2', // Europe (Spain)
+  // 'eu-west-1', // Europe (Ireland)
+  // 'il-central-1', // Israel (Tel Aviv)
+  // 'me-south-1', // Middle East (Bahrain)
+  // 'me-central-1', // Middle East (UAE)
+  // 'sa-east-1' // South America (São Paulo)
+  // 'us-east-2', // US East (Ohio)
+  // 'us-east-1', // US East (Virginia)
+  // 'us-west-1', // US West (N. California)
+  'us-west-2' // US West (Oregon)
+];
+
+export function isValidAwsRegion(region: string): boolean {
+  return VALID_AWS_REGIONS.includes(region);
+}
+
 export function cloudModeReady() {
   let ready = true;
   const requiredFiles = [