@alwaysai/device-agent 2.0.2 → 2.0.3

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

@@ -137,30 +137,40 @@ export async function getNetworkInfo() {
 }
 
 export async function getDockerVersion() {
+  let result: string | undefined;
   try {
     const spawner = JsSpawner();
-    const result = JSON.parse(
-      await spawner.run({
-        exe: 'docker',
-        args: ['info', '--format', 'json']
-      })
-    );
-    return String(result.ClientInfo.Version);
+    result = await spawner.run({
+      exe: 'docker',
+      args: ['info', '--format', 'json']
+    });
+    const parsedResult = JSON.parse(result);
+    return String(parsedResult.ClientInfo.Version);
   } catch (e) {
-    logger.warn(`Cannot get Docker version!\n${stringifyError(e)}`);
+    logger.warn(
+      `Cannot get Docker version! Result: ${result} Error:\n${stringifyError(
+        e
+      )}`
+    );
     return 'Not found';
   }
 }
 
 export async function getDockerComposeVersion() {
+  let result: string | undefined;
   try {
     const spawner = JsSpawner();
-    return await spawner.run({
+    result = await spawner.run({
       exe: 'docker',
       args: ['compose', 'version']
     });
+    return result;
   } catch (e) {
-    logger.warn(`Cannot get Docker Compose version!\n${stringifyError(e)}`);
+    logger.warn(
+      `Cannot get Docker Compose version! Results: ${result} Error:\n${stringifyError(
+        e
+      )}`
+    );
     return 'Not found';
   }
 }
@@ -173,7 +183,7 @@ export async function getNpmVersion() {
       args: ['--version']
     });
   } catch (e) {
-    logger.warn(`Cannot get npm version!\n${stringifyError(e)}`);
+    logger.warn(`Cannot get npm version! Error:\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -186,7 +196,7 @@ export async function getNodeVersion() {
       args: ['-v']
     });
   } catch (e) {
-    logger.warn(`Cannot get Node version!\n${stringifyError(e)}`);
+    logger.warn(`Cannot get Node version! Error:\n${stringifyError(e)}`);
     return 'Not found';
   }
 }
@@ -230,7 +240,7 @@ export async function getLastBootTime() {
 
     return String(new Date(`${tokens[2]} ${tokens[3]} ${tokens[4]}`));
   } catch (e) {
-    logger.error(`Issue getting last boot time!\n${stringifyError(e)}`);
+    logger.error(`Issue getting last boot time! Error:\n${stringifyError(e)}`);
     return undefined;
   }
 }

package/src/docker/docker-compose.ts

@@ -19,7 +19,9 @@ export function importDockerCompose():
       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)}`);
+      logger.warn(
+        `Could not determine compose version! Error:\n${stringifyError(e)}`
+      );
     }
   }
   dockerCmd = 'docker-compose';

package/src/environment.ts

@@ -24,8 +24,7 @@ export const ALWAYSAI_LOCAL_CONNECTION_PORT =
   process.env.ALWAYSAI_LOCAL_CONNECTION_PORT;
 export const ALWAYSAI_LOCAL_CONNECTION_ANALYTICS_ROUTING_KEY =
   process.env.ALWAYSAI_LOCAL_CONNECTION_ANALYTICS_ROUTING_KEY;
-export const ALWAYSAI_TARGET_HW_OVERRIDE =
-  process.env.ALWAYSAI_TARGET_HW_OVERRIDE;
+export const ALWAYSAI_TARGET_HW_OVERRIDE = process.env.ALWAYSAI_TARGET_HW;
 
 export function parseTargetHW(
   hardwareType?: string

package/src/index.ts

@@ -11,11 +11,30 @@ import { runDeviceAgentCloudInterface } from './cloud-connection/device-agent-cl
 import { AgentConfigFile } from './infrastructure/agent-config';
 import { ALWAYSAI_DEVICE_AGENT_MODE } from './environment';
 import { checkForUpdatesAndPrompt } from './util/check-for-updates';
+import { logger } from './util/logger';
+import { getSystemId } from './infrastructure/system-id';
+import { stringifyError } from 'alwaysai/lib/util';
 
 if (module === require.main) {
   if (!AgentConfigFile().exists()) {
     AgentConfigFile().initialize();
   }
+  logger.debug(`Starting Device Agent with system ID: ${getSystemId()}`);
+
+  // Catch any unhandled errors to prevent Device Agent crash
+  process.on('unhandledRejection', (reason: Error, p: Promise<any>) => {
+    logger.error(
+      `Unhandled Rejection at: ${JSON.stringify(p)} reason: ${stringifyError(
+        reason
+      )}`
+    );
+  });
+  process.on('uncaughtException', (error: Error) => {
+    logger.error(
+      `Caught exception: ${stringifyError(error)}\n` +
+        `Exception origin: ${error.stack}`
+    );
+  });
 
   if (ALWAYSAI_DEVICE_AGENT_MODE === 'cloud') {
     void runDeviceAgentCloudInterface();

package/src/infrastructure/config-check-utility.ts

@@ -14,7 +14,7 @@ export const validConfigMessage = 'Device config is present and valid.';
 export async function checkDeviceConfigPresent(
   baseDir?: string
 ): Promise<boolean> {
-  logger.debug('Checking for required device configuraton file.');
+  logger.debug('Checking for required device configuration file.');
   const deviceConfig = DeviceConfigFile(
     baseDir
       ? join(baseDir, getDeviceConfigPath(), DEVICE_CONFIG_FILE_NAME)
@@ -48,7 +48,7 @@ export async function checkCertificatesPresent(baseDir?: string) {
 export async function checkAaiConfigPresent(
   baseDir?: string
 ): Promise<boolean> {
-  logger.debug('Checking for required alwaysai configuraton file.');
+  logger.debug('Checking for required alwaysAI configuration file.');
   const localAaiCfg = new LocalAaiCfg(baseDir);
 
   try {

package/src/infrastructure/legacy-migration/legacy-migration.ts

@@ -17,7 +17,7 @@ import rimraf from 'rimraf';
 import {
   checkRabbitMQContainerRunning,
   stopRabbitMQContainer
-} from '../../local-connection/rabbitmq-connection';
+} from '../../local-connection/rabbitmq-container';
 import { copyDir } from '../../util/copy-dir';
 import {
   getDeviceAgentConfigPath,
@@ -54,7 +54,7 @@ export async function migrateAgentConfigFile(baseDir?: string) {
   try {
     parsedAgentConfig = legacyAgentConfigFile.read();
   } catch (e) {
-    logger.error(`Error reading agent config for:\n${stringifyError(e)}`);
+    logger.error(`Error reading agent config! Error:\n${stringifyError(e)}`);
     logger.error(
       `Agent Config Errors: ${JSON.stringify(
         legacyAgentConfigFile.getErrors(),
@@ -73,7 +73,7 @@ export async function migrateAgentConfigFile(baseDir?: string) {
     // we can remove it after migrating it
     await rimraf(legacyAgentConfigFile.path);
   } catch (e) {
-    logger.error(`Error writing agent config for:\n${stringifyError(e)}`);
+    logger.error(`Error writing agent config! Error:\n${stringifyError(e)}`);
     logger.error(
       `Agent Config Errors: ${JSON.stringify(
         newAgentConfig.getErrors(),
@@ -199,17 +199,12 @@ export async function migrateFromLegacyCertsAndTokens(
     await migrateAgentConfigFile(baseDir);
 
     // if rabbitmq container is present, stop container and migrate files
-    try {
-      if (await checkRabbitMQContainerRunning()) {
-        await stopRabbitMQContainer();
+    if (await checkRabbitMQContainerRunning()) {
+      if ((await stopRabbitMQContainer()) === false) {
+        logger.error(
+          `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
+        );
       }
-    } catch (e) {
-      logger.error(
-        `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
-      );
-      logger.debug(
-        `Error in checking / stopping RabbitMQ container!\n${stringifyError(e)}`
-      );
     }
     if (await exists(getDeviceAgentConfigPath(baseDir))) {
       await copyDir({

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

@@ -0,0 +1,255 @@
+import {
+  checkRabbitMQContainerRunning,
+  runRabbitMQContainer,
+  stopRabbitMQContainer
+} from './rabbitmq-container';
+
+const mockJsSpawner = {
+  exists: jest.fn(),
+  mkdirp: jest.fn(),
+  writeFile: jest.fn()
+};
+jest.mock('alwaysai/lib/util/spawner', () => {
+  return {
+    JsSpawner: jest.fn(() => mockJsSpawner)
+  };
+});
+
+jest.mock('../docker/docker-compose', () => {
+  return {
+    compose: {
+      ps: jest.fn(),
+      upAll: jest.fn(),
+      down: jest.fn()
+    }
+  };
+});
+import { compose } from '../docker/docker-compose';
+
+describe('Test check RabbitMQ container running', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('Compose file not found', async () => {
+    mockJsSpawner.exists.mockResolvedValue(false);
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container not found', async () => {
+    mockJsSpawner.exists.mockResolvedValue(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: []
+      }
+    });
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container is not up', async () => {
+    mockJsSpawner.exists.mockResolvedValue(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Down',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container is up', async () => {
+    mockJsSpawner.exists.mockResolvedValue(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Up',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await checkRabbitMQContainerRunning();
+
+    expect(running).toBeTruthy();
+  });
+});
+
+describe('Test run RabbitMQ container', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('Compose file write fails', async () => {
+    mockJsSpawner.exists.mockResolvedValueOnce(false);
+    mockJsSpawner.mkdirp.mockImplementation(async () => {
+      return;
+    });
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      throw new Error('Failed to write file!');
+    });
+
+    const running = await runRabbitMQContainer();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Compose up fails', async () => {
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      return;
+    });
+    jest.mocked(compose.upAll).mockResolvedValue({
+      exitCode: 1,
+      out: '',
+      err: ''
+    });
+
+    const running = await runRabbitMQContainer();
+
+    expect(running).toBeFalsy();
+  });
+
+  test('Container fails to come up', async () => {
+    // exists(deviceAgentConfigPath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      return;
+    });
+    jest.mocked(compose.upAll).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: ''
+    });
+    // exists(deviceAgentDockerComposePath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    jest.mocked(compose.ps).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Down',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await runRabbitMQContainer({ max_attempts: 2 });
+
+    expect(jest.mocked(compose.ps)).toBeCalledTimes(2);
+    expect(running).toBeFalsy();
+  });
+
+  test('Container comes up successfully', async () => {
+    // exists(deviceAgentConfigPath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    mockJsSpawner.writeFile.mockImplementation(async () => {
+      return;
+    });
+    jest.mocked(compose.upAll).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: ''
+    });
+    // exists(deviceAgentDockerComposePath)
+    mockJsSpawner.exists.mockResolvedValueOnce(true);
+    // Check status twice, one with container still down and next up
+    jest.mocked(compose.ps).mockResolvedValueOnce({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Down',
+            ports: []
+          }
+        ]
+      }
+    });
+    jest.mocked(compose.ps).mockResolvedValueOnce({
+      exitCode: 0,
+      out: '',
+      err: '',
+      data: {
+        services: [
+          {
+            name: 'alwaysAIRabbitMQContainer',
+            command: '',
+            state: 'Up',
+            ports: []
+          }
+        ]
+      }
+    });
+
+    const running = await runRabbitMQContainer({ max_attempts: 2 });
+
+    expect(jest.mocked(compose.ps)).toBeCalledTimes(2);
+    expect(running).toBeTruthy();
+  });
+});
+
+describe('Test stopping RabbitMQ container', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('Compose down fails', async () => {
+    jest.mocked(compose.down).mockResolvedValue({
+      exitCode: 1,
+      out: '',
+      err: ''
+    });
+
+    const stopped = await stopRabbitMQContainer();
+
+    expect(stopped).toBeFalsy();
+  });
+
+  test('Stop succeeds', async () => {
+    jest.mocked(compose.down).mockResolvedValue({
+      exitCode: 0,
+      out: '',
+      err: ''
+    });
+
+    const stopped = await stopRabbitMQContainer();
+
+    expect(stopped).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,151 @@
+import { JsSpawner, stringifyError } from 'alwaysai/lib/util';
+import * as YAML from 'yaml';
+import { compose } from '../docker/docker-compose';
+import {
+  getDeviceAgentConfigPath,
+  getDeviceAgentDockerComposePath
+} from '../util/directories';
+import { logger } from '../util/logger';
+import sleep from '../util/sleep';
+import { LOCAL_CONNECTION_PORT } from './constants';
+
+const rabbitMQServiceName = 'alwaysAIRabbitMQ';
+const rabbitMQContainerName = 'alwaysAIRabbitMQContainer';
+
+/*
+Utility functions to control the Local Connection container (RabbitMQ).
+
+All exported functions handle their own errors and log their status, returning a
+boolean indicating whether the action was successful.
+*/
+
+export async function checkRabbitMQContainerRunning(): Promise<boolean> {
+  logger.debug('Checking Local Connection Container status');
+  const spawner = JsSpawner();
+  if (!(await spawner.exists(getDeviceAgentDockerComposePath()))) {
+    logger.warn('Local Connection configuration file is not present');
+    return false;
+  }
+  const containerData = await compose.ps({ cwd: getDeviceAgentConfigPath() });
+  for (const service of containerData.data.services) {
+    if (service?.name === rabbitMQContainerName) {
+      if (service.state.includes('Up')) {
+        logger.debug('Local Connection container is up.');
+        return true;
+      }
+      logger.debug(
+        `Local Connection container is not up. Status: ${service.state}`
+      );
+      return false;
+    }
+  }
+  logger.warn(
+    `Local Connection container not found in container data: ${JSON.stringify(
+      containerData,
+      null,
+      2
+    )}`
+  );
+  return false;
+}
+
+async function writeRabbitMQDockerComposeFile() {
+  const spawner = JsSpawner();
+  if (!(await spawner.exists(getDeviceAgentConfigPath()))) {
+    await JsSpawner().mkdirp(getDeviceAgentConfigPath());
+  }
+
+  logger.debug(
+    `Writing Local Connection Docker compose files with Local Connection port: ${LOCAL_CONNECTION_PORT}`
+  );
+
+  const rabbitmqDockerComposeCmd = {
+    services: {
+      [rabbitMQServiceName]: {
+        container_name: rabbitMQContainerName,
+        image: 'rabbitmq:3.11',
+        ports: [`${LOCAL_CONNECTION_PORT}:${LOCAL_CONNECTION_PORT}`],
+        hostname: 'my-rabbit',
+        restart: 'on-failure',
+        environment: [`RABBITMQ_NODE_PORT=${LOCAL_CONNECTION_PORT}`],
+        volumes: [
+          './rabbitmq/:/var/lib/rabbitmq/',
+          './rabbitmq/log/:/var/log/rabbitmq/'
+        ]
+      }
+    }
+  };
+
+  const RabbitMQDockerComposeYaml = YAML.stringify(rabbitmqDockerComposeCmd);
+  await spawner.writeFile(
+    getDeviceAgentDockerComposePath(),
+    RabbitMQDockerComposeYaml
+  );
+}
+
+export async function runRabbitMQContainer(opts?: {
+  max_attempts: number;
+}): Promise<boolean> {
+  const max_attempts = opts?.max_attempts || 10;
+  logger.debug('Starting the Local Connection container');
+  try {
+    await writeRabbitMQDockerComposeFile();
+    const upOut = await compose.upAll({
+      cwd: getDeviceAgentConfigPath()
+    });
+    logger.debug(
+      `Docker compose up for Local Connection:\n${JSON.stringify(
+        upOut,
+        null,
+        2
+      )}`
+    );
+    if (upOut.exitCode !== 0) {
+      throw new Error(
+        `Failed to start Local Connection! stdout=${upOut.out} stderr=${upOut.err}`
+      );
+    }
+    // check if the container is up
+    let attempts = 0;
+    while (!(await checkRabbitMQContainerRunning())) {
+      attempts++;
+      if (attempts >= max_attempts) {
+        throw new Error(
+          'Local Connection container failed to come up after start!'
+        );
+      }
+      await sleep(1000);
+    }
+    return true;
+  } catch (e) {
+    logger.error(
+      `Unable to start Local Connection container!\n${stringifyError(e)}`
+    );
+    return false;
+  }
+}
+
+export async function stopRabbitMQContainer(): Promise<boolean> {
+  logger.debug(`Stopping alwaysAI Local Connection container`);
+  try {
+    const downOut = await compose.down({ cwd: getDeviceAgentConfigPath() });
+    logger.debug(
+      `Local Connection docker-compose down: ${JSON.stringify(
+        downOut,
+        null,
+        2
+      )}`
+    );
+    if (downOut.exitCode !== 0) {
+      throw new Error(
+        `Failed to stop Local Connection! stdout=${downOut.out} stderr=${downOut.err}`
+      );
+    }
+    return true;
+  } catch (e) {
+    logger.error(
+      `Unable to stop Local Connection Container:\n${stringifyError(e)}`
+    );
+    return false;
+  }
+}

package/src/subcommands/device/clean.ts

@@ -11,7 +11,7 @@ import { AgentConfigFile } from '../../infrastructure/agent-config';
 import {
   checkRabbitMQContainerRunning,
   stopRabbitMQContainer
-} from '../../local-connection/rabbitmq-connection';
+} from '../../local-connection/rabbitmq-container';
 import {
   APP_ROOT,
   CREDENTIALS_FILE_PATH,
@@ -20,28 +20,24 @@ import {
 } from '../../util/directories';
 import { safeRimraf } from '../../util/file';
 import { logger } from '../../util/logger';
+import { existsSync } from 'fs';
 
 export const cleanCliLeaf = CliLeaf({
   name: 'clean',
   description: 'Remove all provisioning files',
   async action(_, opts) {
     logger.info('Removing provisioning files.');
-    try {
-      if (await checkRabbitMQContainerRunning()) {
-        await stopRabbitMQContainer();
+    if (await checkRabbitMQContainerRunning()) {
+      if ((await stopRabbitMQContainer()) === false) {
+        logger.error(
+          `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
+        );
       }
-    } catch (e) {
-      logger.error(
-        `You may need to manually stop the container by running docker-compose down in the following directory: ${getDeviceAgentDockerComposePath()}`
-      );
-      logger.debug(
-        `Error in checking / stopping RabbitMQ container!\n${stringifyError(e)}`
-      );
     }
 
     await safeRimraf(getDeviceAgentConfigPath());
 
-    logger.debug('Checking for alwaysAI applications still running');
+    logger.debug('Checking for alwaysAI applications still installed');
     const apps = await AgentConfigFile().getApps();
     const uninstallAppPromises: Promise<void>[] = [];
     for (const app of apps) {
@@ -60,13 +56,18 @@ export const cleanCliLeaf = CliLeaf({
     DeviceConfigFile().remove();
 
     await safeRimraf(CREDENTIALS_FILE_PATH);
-    const files = await readdir(APP_ROOT);
-    logger.debug(`${APP_ROOT} folder contents ${JSON.stringify(files.length)}`);
-    // This won't handle hidden files, but will remove if truly empty, which is safer
-    if (files.length === 0) {
-      logger.debug('Applications directory is empty, removing.');
-      await safeRimraf(APP_ROOT);
+
+    if (existsSync(APP_ROOT)) {
+      const files = await readdir(APP_ROOT);
+      logger.debug(
+        `${APP_ROOT} folder contents ${JSON.stringify(files.length)}`
+      );
+      // This won't handle hidden files, but will remove if truly empty, which is safer
+      if (files.length === 0) {
+        logger.debug('Applications directory is empty, removing.');
+        await safeRimraf(APP_ROOT);
+      }
+      logger.info('Device configuration cleaned');
     }
-    logger.info('Device configuration cleaned');
   }
 });

package/src/subcommands/device/index.ts

@@ -5,6 +5,7 @@ import { initCliLeaf } from './init';
 import { restartCliLeaf } from './restart';
 import { refreshCliLeaf } from './refresh';
 import { migrateCliLeaf } from './migrate';
+import { stopLocalConnectionCliLeaf } from './local-connection';
 
 export const deviceCliBranch = CliBranch({
   name: 'device',
@@ -15,6 +16,7 @@ export const deviceCliBranch = CliBranch({
     refreshCliLeaf,
     cleanCliLeaf,
     restartCliLeaf,
-    migrateCliLeaf
+    migrateCliLeaf,
+    stopLocalConnectionCliLeaf
   ]
 });