@alwaysai/device-agent 0.0.11 → 0.0.13

package/src/docker/docker-compose-cmd.ts

@@ -1,12 +1,15 @@
 import { JsSpawner } from 'alwaysai/lib/util';
 
-export async function runDockerComposeCmd(props: { args: string[]; dir: string }) {
+export async function runDockerComposeCmd(props: {
+  args: string[];
+  dir: string;
+}) {
   const { args, dir } = props;
   const spawner = JsSpawner();
   const output = await spawner.run({
     exe: 'docker-compose',
     args,
-    cwd: dir,
+    cwd: dir
   });
   return output;
 }

package/src/endpoints.ts

@@ -1,19 +1,19 @@
-import { getSystemId } from "alwaysai/lib/infrastructure";
+import { getSystemId } from './infrastructure/system-id';
 
 export const getSecondLevelDomain = () => {
-  let domain = "";
+  let domain = '';
   switch (getSystemId()) {
-    case "development":
-      domain = "a6i0.net";
+    case 'development':
+      domain = 'a6i0.net';
       break;
-    case "qa":
-      domain = "a6i1.net";
+    case 'qa':
+      domain = 'a6i1.net';
       break;
-    case "production":
-      domain = "alwaysai.co";
+    case 'production':
+      domain = 'alwaysai.co';
       break;
     default:
-      domain = "alwaysai.co";
+      domain = 'alwaysai.co';
       break;
   }
   return domain;

package/src/environment.ts

@@ -1,8 +1,13 @@
 import { platform } from 'os';
 
-export const ALWAYSAI_OS_PLATFORM = parseOsPlatform(process.env.ALWAYSAI_OS_PLATFORM);
-export const ALWAYSAI_SHOW_HIDDEN = parseBoolean(process.env.ALWAYSAI_SHOW_HIDDEN);
-export const ALWAYSAI_DEVICE_AGENT_MODE = process.env.ALWAYSAI_DEVICE_AGENT_MODE;
+export const ALWAYSAI_OS_PLATFORM = parseOsPlatform(
+  process.env.ALWAYSAI_OS_PLATFORM
+);
+export const ALWAYSAI_SHOW_HIDDEN = parseBoolean(
+  process.env.ALWAYSAI_SHOW_HIDDEN
+);
+export const ALWAYSAI_DEVICE_AGENT_MODE =
+  process.env.ALWAYSAI_DEVICE_AGENT_MODE;
 export const ALWAYSAI_LOG_LEVEL = process.env.AAI_LOG_LEVEL;
 export const ALWAYSAI_LOG_TO_CONSOLE = process.env.ALWAYSAI_LOG_TO_CONSOLE;
 

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

@@ -5,7 +5,7 @@ const mockAgentModeGetter = jest.fn().mockReturnValue(undefined);
 jest.mock('../environment', () => ({
   get ALWAYSAI_DEVICE_AGENT_MODE() {
     return mockAgentModeGetter();
-  },
+  }
 }));
 
 const configFile = AgentConfigFile(tempy.directory());
@@ -21,9 +21,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 +41,8 @@ describe('Test Agent Config', () => {
         {
           projectId,
           version,
-          ready: false,
-        },
+          ready: false
+        }
       ]);
       const readyApps = await configFile.getReadyApps();
       expect(readyApps).toEqual([]);
@@ -46,7 +50,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 +69,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 +107,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 +137,9 @@ describe('Test Agent Config', () => {
           version,
           ready: true,
           backup: {
-            version,
-          },
-        },
+            version
+          }
+        }
       ]);
       const app = await configFile.getApp({ projectId });
       expect(app).toEqual({
@@ -139,8 +147,8 @@ describe('Test Agent Config', () => {
         version,
         ready: true,
         backup: {
-          version,
-        },
+          version
+        }
       });
       const backup2 = await configFile.getAppBackup({ projectId });
       expect(backup2).toEqual({ version });
@@ -168,15 +176,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 +200,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,5 @@
 import { ConfigFileSchema } from '@alwaysai/config-nodejs';
-import { JSONSchemaType } from 'ajv';
+import Ajv, { JSONSchemaType } from 'ajv';
 import { homedir } from 'os';
 import { join } from 'path';
 
@@ -33,21 +33,24 @@ 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';
@@ -55,12 +58,12 @@ const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
 export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
   const path = join(dir, AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
-    applications: [],
+    applications: []
   };
   const configFile = ConfigFileSchema({
     path,
-    schema,
-    initialValue,
+    validateFunction,
+    initialValue
   });
 
   return {
@@ -77,19 +80,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 +129,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 +138,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 +157,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 +178,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 { DeviceConfigFile } from 'alwaysai/lib/core/device';
+import { ALWAYSAI_SYSTEM_ID } from 'alwaysai/lib/environment';
+import { SystemId } from 'alwaysai/lib/infrastructure';
+
+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,39 @@
+import {
+  DeviceTokens,
+  writeOrValidateDeviceCfgFile
+} from 'alwaysai/lib/components/device';
+import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
+import { LOCAL_AAI_CFG_DIR } from 'alwaysai/lib/constants';
+import { checkPaidPlan } from 'alwaysai/lib/core/project';
+import { JsSpawner, writeTokens } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+import { microServiceHttpClient } from '../util/http-client';
+
+// NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
+export async function writeTokenAndDeviceCfg(props: { deviceUuid: string }) {
+  const { deviceUuid } = props;
+  await checkUserIsLoggedInComponent({ yes: true });
+  if (!(await checkPaidPlan())) {
+    throw new Error(
+      `This action only supported for Enterprise alwaysAI accounts!`
+    );
+  }
+  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/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
 });