@alwaysai/device-agent 0.0.12 → 0.0.14

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

@@ -1,13 +1,6 @@
 import * as tempy from 'tempy';
 import { AgentConfigFile } from './agent-config';
 
-const mockAgentModeGetter = jest.fn().mockReturnValue(undefined);
-jest.mock('../environment', () => ({
-  get ALWAYSAI_DEVICE_AGENT_MODE() {
-    return mockAgentModeGetter();
-  },
-}));
-
 const configFile = AgentConfigFile(tempy.directory());
 
 describe('Test Agent Config', () => {
@@ -21,9 +14,13 @@ describe('Test Agent Config', () => {
       expect(apps).toEqual([]);
       const app = await configFile.getApp({ projectId: 'wrong-id' });
       expect(app).toBeNull();
-      const present = await configFile.isAppPresent({ projectId: 'another-id' });
+      const present = await configFile.isAppPresent({
+        projectId: 'another-id'
+      });
       expect(present).toBeFalsy();
-      const ready = await configFile.isAppReady({ projectId: 'yet-another-id' });
+      const ready = await configFile.isAppReady({
+        projectId: 'yet-another-id'
+      });
       expect(ready).toBeFalsy();
     });
 
@@ -37,8 +34,8 @@ describe('Test Agent Config', () => {
         {
           projectId,
           version,
-          ready: false,
-        },
+          ready: false
+        }
       ]);
       const readyApps = await configFile.getReadyApps();
       expect(readyApps).toEqual([]);
@@ -46,7 +43,7 @@ describe('Test Agent Config', () => {
       expect(app).toEqual({
         projectId,
         version,
-        ready: false,
+        ready: false
       });
       const present = await configFile.isAppPresent({ projectId });
       expect(present).toBeTruthy();
@@ -65,22 +62,22 @@ describe('Test Agent Config', () => {
         {
           projectId,
           version,
-          ready: true,
-        },
+          ready: true
+        }
       ]);
       const readyApps = await configFile.getReadyApps();
       expect(readyApps).toEqual([
         {
           projectId,
           version,
-          ready: true,
-        },
+          ready: true
+        }
       ]);
       const app = await configFile.getApp({ projectId });
       expect(app).toEqual({
         projectId,
         version,
-        ready: true,
+        ready: true
       });
       const appVersion = await configFile.getAppVersion({ projectId });
       expect(appVersion).toEqual(version);
@@ -103,9 +100,13 @@ describe('Test Agent Config', () => {
       expect(apps).toEqual([]);
       const app = await configFile.getApp({ projectId: 'wrong-id' });
       expect(app).toBeNull();
-      const present = await configFile.isAppPresent({ projectId: 'another-id' });
+      const present = await configFile.isAppPresent({
+        projectId: 'another-id'
+      });
       expect(present).toBeFalsy();
-      const ready = await configFile.isAppReady({ projectId: 'yet-another-id' });
+      const ready = await configFile.isAppReady({
+        projectId: 'yet-another-id'
+      });
       expect(ready).toBeFalsy();
     });
 
@@ -129,9 +130,9 @@ describe('Test Agent Config', () => {
           version,
           ready: true,
           backup: {
-            version,
-          },
-        },
+            version
+          }
+        }
       ]);
       const app = await configFile.getApp({ projectId });
       expect(app).toEqual({
@@ -139,8 +140,8 @@ describe('Test Agent Config', () => {
         version,
         ready: true,
         backup: {
-          version,
-        },
+          version
+        }
       });
       const backup2 = await configFile.getAppBackup({ projectId });
       expect(backup2).toEqual({ version });
@@ -168,15 +169,17 @@ describe('Test Agent Config', () => {
 
       // test to see if app has backup
       await configFile.setAppBackup({ projectId });
-      const expectedBackupVersion = (await configFile.getAppBackup({ projectId }))
-        ?.version;
+      const expectedBackupVersion = (
+        await configFile.getAppBackup({ projectId })
+      )?.version;
       expect(expectedBackupVersion).toEqual(version1);
       expect(await configFile.getAppVersion({ projectId })).toEqual(version1);
 
       // simulate second version install
       await configFile.setAppInstalling({ projectId, version: version2 });
-      const newExpectedBackupVersion = (await configFile.getAppBackup({ projectId }))
-        ?.version;
+      const newExpectedBackupVersion = (
+        await configFile.getAppBackup({ projectId })
+      )?.version;
       expect(newExpectedBackupVersion).toEqual(version1);
       await configFile.setAppInstalled({ projectId, version: version2 });
       expect(await configFile.getAppVersion({ projectId })).toEqual(version2);
@@ -190,7 +193,8 @@ describe('Test Agent Config', () => {
 
       // test final state of rolled-back app
       await configFile.setAppInstalled({ projectId, version: version1 });
-      const finalBackupVersion = (await configFile.getAppBackup({ projectId }))?.version;
+      const finalBackupVersion = (await configFile.getAppBackup({ projectId }))
+        ?.version;
       expect(finalBackupVersion).toEqual(version1);
       expect(await configFile.isAppReady({ projectId })).toEqual(true);
       expect(await configFile.getAppVersion({ projectId })).toEqual(version1);

package/src/infrastructure/agent-config.ts

@@ -1,5 +1,8 @@
-import { ConfigFileSchema } from '@alwaysai/config-nodejs';
-import { JSONSchemaType } from 'ajv';
+import {
+  ConfigFileSchema,
+  ConfigFileSchemaReturnType
+} from '@alwaysai/config-nodejs';
+import Ajv, { JSONSchemaType } from 'ajv';
 import { homedir } from 'os';
 import { join } from 'path';
 
@@ -33,34 +36,56 @@ const schema: JSONSchemaType<AgentConfig> = {
             type: 'object',
             nullable: true,
             properties: {
-              version: { type: 'string' },
+              version: { type: 'string' }
             },
             required: ['version'],
-            additionalProperties: true,
-          },
+            additionalProperties: true
+          }
         },
         required: ['projectId', 'version', 'ready'],
-        additionalProperties: true,
-      },
-    },
+        additionalProperties: true
+      }
+    }
   },
   required: ['applications'],
-  additionalProperties: true,
+  additionalProperties: true
 };
 
+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 function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
+export interface AgentJsonFileReturnType
+  extends ConfigFileSchemaReturnType<AgentConfig> {
+  name: string;
+  getApps: () => Promise<InstalledAppConfig[]>;
+  getReadyApps;
+  getApp;
+  isAppPresent;
+  isAppReady;
+  removeApp;
+  setAppInstalling;
+  setAppInstalled;
+  setAppUninstalled;
+  getAppVersion;
+  setAppBackup;
+  getAppBackup;
+}
+
+export function AgentConfigFile(
+  dir = ALWAYSAI_CONFIG_DIR
+): AgentJsonFileReturnType {
   const path = join(dir, AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
-    applications: [],
+    applications: []
   };
   const configFile = ConfigFileSchema({
     path,
-    schema,
-    initialValue,
+    validateFunction,
+    initialValue
   });
 
   return {
@@ -77,19 +102,21 @@ export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
     setAppUninstalled,
     getAppVersion,
     setAppBackup,
-    getAppBackup,
+    getAppBackup
   };
 
   async function getApps() {
     const config = configFile.read();
-    return config.applications;
+    return config && config.applications ? config.applications : [];
   }
 
   async function getReadyApps() {
     const config = configFile.read();
-    return config.applications.filter((app) => {
-      return app.ready;
-    });
+    return config && config.applications
+      ? config.applications.filter((app) => {
+          return app.ready;
+        })
+      : [];
   }
 
   async function getApp(props: { projectId: string }) {
@@ -124,6 +151,8 @@ export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
   async function removeApp(props: { projectId: string }) {
     const { projectId } = props;
     const config = configFile.read();
+    if (!config) return;
+
     const newList = config.applications.filter((app) => {
       return app.projectId !== projectId;
     });
@@ -131,7 +160,10 @@ export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
     configFile.write(config);
   }
 
-  async function setAppInstalling(props: { projectId: string; version: string }) {
+  async function setAppInstalling(props: {
+    projectId: string;
+    version: string;
+  }) {
     const { projectId, version } = props;
 
     const app = await getApp({ projectId });
@@ -147,13 +179,16 @@ export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
       config.applications.push({
         projectId,
         version,
-        ready: false,
+        ready: false
       });
       configFile.write(config);
     }
   }
 
-  async function setAppInstalled(props: { projectId: string; version: string }) {
+  async function setAppInstalled(props: {
+    projectId: string;
+    version: string;
+  }) {
     const { projectId, version } = props;
     const app = await getApp({ projectId });
     if (app) {
@@ -165,7 +200,7 @@ export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
       // 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!`,
+        `App ${projectId} was not previously configured and could not be set to installed!`
       );
     }
   }

package/src/infrastructure/system-id.ts

@@ -0,0 +1,18 @@
+import { SystemId } from 'alwaysai/lib/constants';
+import { DeviceConfigFile } from 'alwaysai/lib/core/device';
+import { ALWAYSAI_SYSTEM_ID } from 'alwaysai/lib/environment';
+
+export function getSystemId() {
+  if (ALWAYSAI_SYSTEM_ID) {
+    // When the env var is set return the overridden value without updating the config file.
+    // This prevents one-off commands from having side effects.
+    if (Object.keys(SystemId).includes(ALWAYSAI_SYSTEM_ID)) {
+      return ALWAYSAI_SYSTEM_ID as SystemId;
+    }
+    throw new Error(`Invalid ALWAYSAI_SYSTEM_ID: ${ALWAYSAI_SYSTEM_ID}`);
+  }
+  const maybeConfig = DeviceConfigFile().readIfExists();
+  const systemId =
+    maybeConfig && maybeConfig.systemId ? maybeConfig.systemId : 'production';
+  return systemId;
+}

package/src/infrastructure/tokens-and-device-cfg.ts

@@ -0,0 +1,34 @@
+import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/constants';
+import { logger } from '../util/logger';
+import { microServiceHttpClient } from '../util/http-client';
+import { requireLoggedInAndPaidPlan } from '../util/require-logged-in-and-paid-plan';
+import {
+  DeviceTokens,
+  writeOrValidateDeviceCfgFile,
+  writeTokens
+} from 'alwaysai/lib/core/device';
+import { JsSpawner } from 'alwaysai/lib/util';
+
+// NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
+export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
+  const { deviceUuid } = props;
+  await requireLoggedInAndPaidPlan();
+  const { accessToken, refreshToken, idToken } = await microServiceHttpClient(
+    'token-service',
+    'create-device-tokens',
+    'POST',
+    JSON.stringify({})
+  );
+
+  const tokens: DeviceTokens = {
+    deviceId: deviceUuid,
+    accessToken,
+    refreshToken,
+    idToken
+  };
+  const tokenSpawner = JsSpawner({ path: LOCAL_AAI_CFG_DIR });
+  await writeTokens({ spawner: tokenSpawner, tokens });
+  await writeOrValidateDeviceCfgFile({ spawner: tokenSpawner, deviceUuid });
+
+  logger.info('Updated tokens and certificate');
+}

package/src/infrastructure/urls.ts

@@ -1,5 +1,5 @@
 import { CliTerseError } from '@alwaysai/alwayscli';
-import { getSystemId } from 'alwaysai/lib/infrastructure';
+import { getSystemId } from './system-id';
 
 export function getIoTCoreEndpointUrl() {
   let iotCoreEndpointUrl = '';
@@ -15,7 +15,9 @@ export function getIoTCoreEndpointUrl() {
       iotCoreEndpointUrl = 'a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com';
       break;
     default:
-      throw new CliTerseError(`Remote deployment not supported on ${getSystemId()}!`);
+      throw new CliTerseError(
+        `Remote deployment not supported on ${getSystemId()}!`
+      );
   }
   return iotCoreEndpointUrl;
 }

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

@@ -0,0 +1,53 @@
+import { JsSpawner } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+import sleep from '../util/sleep';
+
+export async function checkRabbitMQContainerRunning() {
+  const spawner = JsSpawner();
+  return await spawner.run({
+    exe: 'docker',
+    args: ['ps', '-q', '--filter', 'ancestor=rabbitmq']
+  });
+}
+
+export async function setupRabbitMQContainer() {
+  const spawner = JsSpawner();
+  const rabbitMqContainerRunning = await checkRabbitMQContainerRunning();
+  logger.debug('Checking for running RabbitMQ container');
+  if (!rabbitMqContainerRunning) {
+    logger.debug('Setting up RabbitMQ container');
+    await spawner.run({
+      exe: 'docker',
+      args: [
+        'run',
+        '--rm',
+        '-p',
+        '5672:5672',
+        '-d',
+        '--hostname',
+        'my-rabbit',
+        'rabbitmq'
+      ]
+    });
+    await sleep(8000);
+    while (!(await checkRabbitMQContainerRunning())) {
+      await sleep(5000);
+    }
+  }
+}
+
+export async function stopRabbitMQContainer() {
+  const spawner = JsSpawner();
+  const rabbitMqContainer = await spawner.run({
+    exe: 'docker',
+    args: ['ps', '-q', '--filter', 'ancestor=rabbitmq']
+  });
+  if (!rabbitMqContainer) {
+    logger.debug('No RabbitMQ container running');
+  } else {
+    await spawner.run({
+      exe: 'docker',
+      args: ['stop', `${rabbitMqContainer}`]
+    });
+  }
+}

package/src/root.ts

@@ -1,18 +1,12 @@
+// eslint-disable-next-line
 const winston = require('winston');
 
 import { CliBranch } from '@alwaysai/alwayscli';
 
 import { subcommands } from './subcommands';
-import { ALWAYSAI_LOG_LEVEL } from './environment';
-
-winston.configure({
-  level: ALWAYSAI_LOG_LEVEL || 'info',
-  transports: [new winston.transports.Console()],
-  format: winston.format.simple(),
-});
 
 export const root = CliBranch({
   name: 'aai-agent',
   description: 'Manage your alwaysAI production device',
-  subcommands,
+  subcommands
 });