@alwaysai/device-agent 0.0.3 → 0.0.5

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

@@ -0,0 +1,143 @@
+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', () => {
+  beforeEach(() => {
+    configFile.remove();
+    configFile.initialize();
+  });
+  describe('Test applications', () => {
+    test('Commands with no apps', async () => {
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([]);
+      const app = await configFile.getApp({ projectId: 'wrong-id' });
+      expect(app).toBeNull();
+      const present = await configFile.isAppPresent({ projectId: 'another-id' });
+      expect(present).toBeFalsy();
+      const ready = await configFile.isAppReady({ projectId: 'yet-another-id' });
+      expect(ready).toBeFalsy();
+    });
+
+    test('Indicate app installation in progress', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([
+        {
+          projectId,
+          version,
+          ready: false,
+        },
+      ]);
+      const readyApps = await configFile.getReadyApps();
+      expect(readyApps).toEqual([]);
+      const app = await configFile.getApp({ projectId });
+      expect(app).toEqual({
+        projectId,
+        version,
+        ready: false,
+      });
+      const present = await configFile.isAppPresent({ projectId });
+      expect(present).toBeTruthy();
+      const ready = await configFile.isAppReady({ projectId });
+      expect(ready).toBeFalsy();
+    });
+
+    test('Indicate app installation complete', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      await configFile.setAppInstalled({ projectId, version });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([
+        {
+          projectId,
+          version,
+          ready: true,
+        },
+      ]);
+      const readyApps = await configFile.getReadyApps();
+      expect(readyApps).toEqual([
+        {
+          projectId,
+          version,
+          ready: true,
+        },
+      ]);
+      const app = await configFile.getApp({ projectId });
+      expect(app).toEqual({
+        projectId,
+        version,
+        ready: true,
+      });
+      const appVersion = await configFile.getAppVersion({ projectId });
+      expect(appVersion).toEqual(version);
+      const present = await configFile.isAppPresent({ projectId });
+      expect(present).toBeTruthy();
+      const ready = await configFile.isAppReady({ projectId });
+      expect(ready).toBeTruthy();
+    });
+
+    test('Indicate app uninstalled', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      await configFile.setAppInstalled({ projectId, version });
+      await configFile.setAppUninstalled({ projectId });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([]);
+      const app = await configFile.getApp({ projectId: 'wrong-id' });
+      expect(app).toBeNull();
+      const present = await configFile.isAppPresent({ projectId: 'another-id' });
+      expect(present).toBeFalsy();
+      const ready = await configFile.isAppReady({ projectId: 'yet-another-id' });
+      expect(ready).toBeFalsy();
+    });
+
+    test('Set and get backup', async () => {
+      const projectId = 'add-me';
+      const version = 'im-a-version';
+
+      await configFile.setAppInstalling({ projectId, version });
+      await configFile.setAppInstalled({ projectId, version });
+      const backup1 = await configFile.getAppBackup({ projectId });
+      expect(backup1).toBeNull();
+      await configFile.setAppBackup({ projectId });
+      const apps = await configFile.getApps();
+      expect(apps).toEqual([
+        {
+          projectId,
+          version,
+          ready: true,
+          backup: {
+            version,
+          },
+        },
+      ]);
+      const app = await configFile.getApp({ projectId });
+      expect(app).toEqual({
+        projectId,
+        version,
+        ready: true,
+        backup: {
+          version,
+        },
+      });
+      const backup2 = await configFile.getAppBackup({ projectId });
+      expect(backup2).toEqual({ version });
+    });
+  });
+});

package/src/infrastructure/agent-config.ts

@@ -0,0 +1,217 @@
+import { ConfigFileSchema } from '@alwaysai/config-nodejs';
+import { JSONSchemaType } from 'ajv';
+import { homedir } from 'os';
+import { join } from 'path';
+import { ALWAYSAI_DEVICE_AGENT_MODE } from '../environment';
+
+export interface AppBackupConfig {
+  version: string;
+}
+
+export interface InstalledAppConfig {
+  projectId: string;
+  version: string;
+  ready: boolean;
+  backup?: AppBackupConfig;
+}
+
+export interface AgentConfig {
+  applications: InstalledAppConfig[];
+}
+
+const schema: JSONSchemaType<AgentConfig> = {
+  type: 'object',
+  properties: {
+    applications: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          projectId: { type: 'string' },
+          version: { type: 'string' },
+          ready: { type: 'boolean' },
+          backup: {
+            type: 'object',
+            nullable: true,
+            properties: {
+              version: { type: 'string' },
+            },
+            required: ['version'],
+            additionalProperties: true,
+          },
+        },
+        required: ['projectId', 'version', 'ready'],
+        additionalProperties: true,
+      },
+    },
+  },
+  required: ['applications'],
+  additionalProperties: true,
+};
+
+const ALWAYSAI_CONFIG_DIR = join(homedir(), '.config', 'alwaysai');
+
+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: [],
+  };
+  const configFile = ConfigFileSchema({
+    path,
+    schema,
+    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.applications;
+  }
+
+  async function getReadyApps() {
+    const config = configFile.read();
+    return config.applications.filter((app) => {
+      return app.ready;
+    });
+  }
+
+  async function getApp(props: { projectId: string }) {
+    const { projectId } = props;
+    const apps = await getApps();
+    for (const app of apps) {
+      if (app.projectId === projectId) {
+        return app;
+      }
+    }
+    return null;
+  }
+
+  async function isAppPresent(props: { projectId: string }): Promise<boolean> {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      return true;
+    }
+    return false;
+  }
+
+  async function isAppReady(props: { projectId: string }): Promise<boolean> {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app && app.ready) {
+      return true;
+    }
+    return false;
+  }
+
+  async function removeApp(props: { projectId: string }) {
+    const { projectId } = props;
+    const config = configFile.read();
+    const newList = config.applications.filter((app) => {
+      return app.projectId !== projectId;
+    });
+    config.applications = newList;
+    configFile.write(config);
+  }
+
+  async function setAppInstalling(props: { projectId: string; version: string }) {
+    const { projectId, version } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      await removeApp({ projectId });
+      const config = configFile.read();
+      config.applications.push({
+        projectId,
+        version,
+        ready: false,
+      });
+      configFile.write(config);
+    } else {
+      const config = configFile.read();
+      config.applications.push({
+        projectId,
+        version,
+        ready: false,
+      });
+      configFile.write(config);
+    }
+  }
+
+  async function setAppInstalled(props: { projectId: string; version: string }) {
+    const { projectId, version } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      await removeApp({ projectId });
+      const config = configFile.read();
+      app.version = version;
+      config.applications.push({
+        projectId,
+        version,
+        ready: true,
+      });
+      configFile.write(config);
+    } else {
+      const config = configFile.read();
+      config.applications.push({
+        projectId,
+        version,
+        ready: true,
+      });
+      configFile.write(config);
+    }
+  }
+
+  async function setAppUninstalled(props: { projectId: string }) {
+    const { projectId } = props;
+    await removeApp({ projectId });
+  }
+
+  async function getAppVersion(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (!app) {
+      throw new Error(`App ${projectId} not installed`);
+    }
+    return app.version;
+  }
+
+  async function setAppBackup(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (!app) {
+      throw new Error(`Project ${projectId} not installed!`);
+    }
+    await removeApp({ projectId });
+    const config = configFile.read();
+    app.backup = { version: app.version };
+    config.applications.push(app);
+    configFile.write(config);
+  }
+
+  async function getAppBackup(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app && app.backup) {
+      return app.backup;
+    }
+    return null;
+  }
+}

package/src/infrastructure/certificates-and-tokens.ts

@@ -0,0 +1,71 @@
+import { DeviceTokens, writeOrUpdateDeviceCfgFile } from 'alwaysai/lib/components/device';
+import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
+import { LOCAL_AAI_CFG_DIR, LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/constants';
+import { checkPaidPlan } from 'alwaysai/lib/core/project';
+import {
+  CliRpcClient,
+  getDeviceCertificates,
+  IotRpcDevice,
+  refreshDevice,
+} from 'alwaysai/lib/infrastructure';
+import { JsSpawner, Spawner, writeCertificate, writeTokens } from 'alwaysai/lib/util';
+
+// NOTE: This is reimplemented from the CLI to work for local checks
+export async function getTargetHardwareUuid(spawner: Spawner) {
+  if (await spawner.exists('/var/lib/dbus/machine-id')) {
+    return await spawner.run({ exe: 'cat', args: ['/var/lib/dbus/machine-id'] });
+  }
+  if (await spawner.exists('/etc/machine-id')) {
+    return await spawner.run({ exe: 'cat', args: ['/etc/machine-id'] });
+  }
+  return await spawner.run({ exe: 'hostname' });
+}
+
+// NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
+export async function writeCertificateAndToken(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 device: IotRpcDevice = (await CliRpcClient().getDeviceByUUID({
+    uuid: deviceUuid,
+  })) as IotRpcDevice;
+  if (!device) {
+    throw new Error(`Device not found for deviceId=${deviceUuid}`);
+  }
+  // TODO: Update HW ID if not there
+  if (device.hardware_ids && device.hardware_ids !== '') {
+    const spawner = JsSpawner();
+    const hardwareId = await getTargetHardwareUuid(spawner);
+    if (hardwareId !== device.hardware_ids) {
+      throw new Error('Certificates not intended for this device!');
+    }
+  }
+  const response = await refreshDevice(device.uuid);
+  const tokens: DeviceTokens = {
+    deviceId: deviceUuid,
+    accessToken: response.accessToken,
+    refreshToken: response.refreshToken,
+    idToken: response.idToken,
+  };
+  const tokenSpawner = JsSpawner({ path: LOCAL_AAI_CFG_DIR });
+  await writeTokens({ spawner: tokenSpawner, tokens });
+  await writeOrUpdateDeviceCfgFile({ spawner: tokenSpawner });
+
+  let iotKeys = device.iot_keys;
+  if (!iotKeys) {
+    // there are no certificates, we need to generate new ones
+    console.log('Generating new certificate');
+    const response = await getDeviceCertificates(device.uuid, device.mode);
+    iotKeys = response.iotKeys;
+  }
+  const certSpawner = JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR });
+  await writeCertificate({
+    spawner: certSpawner,
+    certificate: iotKeys.certificatePem,
+    privateKey: iotKeys.keyPair.PrivateKey,
+    rootCa: iotKeys.rootCA,
+  });
+  console.log('Updated tokens and certificate');
+}

package/src/{util → infrastructure}/urls.ts

@@ -1,5 +1,5 @@
-import { getSystemId } from 'alwaysai';
 import { CliTerseError } from '@alwaysai/alwayscli';
+import { getSystemId } from 'alwaysai/lib/infrastructure';
 
 export function getIoTCoreEndpointUrl() {
   let iotCoreEndpointUrl = '';

package/src/root.ts

@@ -3,16 +3,16 @@ const winston = require('winston');
 import { CliBranch } from '@alwaysai/alwayscli';
 
 import { subcommands } from './subcommands';
-import { ALWAYSAI_CLI_EXECUTABLE_NAME } from './constants';
+import { ALWAYSAI_LOG_LEVEL } from './environment';
 
 winston.configure({
-  level: process.env.AAI_LOG_LEVEL || 'info',
+  level: ALWAYSAI_LOG_LEVEL || 'info',
   transports: [new winston.transports.Console()],
   format: winston.format.simple(),
 });
 
 export const root = CliBranch({
-  name: ALWAYSAI_CLI_EXECUTABLE_NAME,
+  name: 'aai-agent',
   description: 'Manage your alwaysAI production device',
   subcommands,
 });