@alwaysai/device-agent 0.0.1-2.1-beta-provision

package/src/cloud-connection/device-agent.ts

@@ -0,0 +1,120 @@
+const awsIot = require("aws-iot-device-sdk");
+import {
+  DEVICE_PRIVATE_KEY_FILE_NAME,
+  CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
+  DEVICE_CLAIM_ID_FILE_NAME,
+  DEVICE_CERTIFICATE_FILE_NAME,
+} from "../util/directories";
+import { getTargetHardwareUuid } from "../infrastructure/certificates-and-tokens";
+import { getDeviceId } from "../util/get-device-id";
+import { LOCAL_CERT_AND_KEY_DIR } from "alwaysai/lib/constants";
+import { JsSpawner } from "alwaysai/lib/util";
+import { logger } from "../util/logger";
+import { v4 as uuidv4 } from "uuid";
+import { join } from "path";
+const process = require("process");
+
+interface DeviceAgentConfigType {
+  keyPath: string;
+  certPath: string;
+  caPath: string;
+  clientId: string;
+  host: string;
+}
+
+interface FleetProvisionTemplateMessageType {
+  certificateOwnershipToken: String;
+  parameters: {
+    hardwareId: String;
+    deviceUuid: String;
+    certificateId: String;
+    deviceType: String;
+  };
+}
+
+export class DeviceAgent {
+  constructor(config: DeviceAgentConfigType) {
+    this.device = awsIot.device(config);
+  }
+
+  public deviceType = "aai-device";
+  public device = awsIot.device;
+  public hardwareId = async () =>
+    await getTargetHardwareUuid(
+      JsSpawner(),
+      join(LOCAL_CERT_AND_KEY_DIR, "hardware-id.txt")
+    );
+  public deviceId = getDeviceId();
+
+  public publishMessage(topic: string, message: string) {
+    this.device.publish(topic, message);
+  }
+}
+
+export class BootstrapAgent extends DeviceAgent {
+  public async subscribeToAllTopics() {
+    const AWS_CERTIFICATE_ACCEPT_TOPIC =
+      "$aws/certificates/create/json/accepted";
+    const PROVISIONING_ACCEPTED_TOPIC =
+      "$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted";
+
+    const topics = [AWS_CERTIFICATE_ACCEPT_TOPIC, PROVISIONING_ACCEPTED_TOPIC];
+    const resp = this.device.subscribe(
+      topics,
+      function (err: any, granted: { topic: string; qos: number }[]) {
+        logger.debug(granted);
+      }
+    );
+  }
+
+  public async handleAwsCertificateTopics(topic: string, payload: any) {
+    switch (topic) {
+      case "$aws/certificates/create/json/accepted": {
+        const {
+          certificateId,
+          certificatePem,
+          privateKey,
+          certificateOwnershipToken,
+        } = JSON.parse(payload);
+
+        const certSpawner = JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR });
+
+        await certSpawner.writeFile(
+          DEVICE_CERTIFICATE_FILE_NAME,
+          certificatePem
+        );
+
+        await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME, privateKey);
+
+        await certSpawner.writeFile(DEVICE_CLAIM_ID_FILE_NAME, certificateId);
+
+        await certSpawner.writeFile(
+          CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
+          certificateOwnershipToken
+        );
+
+        const content: FleetProvisionTemplateMessageType = {
+          certificateOwnershipToken,
+          parameters: {
+            hardwareId: await this.hardwareId(),
+            deviceUuid: this.deviceId,
+            certificateId,
+            deviceType: this.deviceType,
+          },
+        };
+        logger.debug(JSON.stringify(content));
+
+        this.publishMessage(
+          "$aws/provisioning-templates/FleetProvisionTemplate/provision/json",
+          JSON.stringify(content)
+        );
+
+        break;
+      }
+      case "$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted": {
+        logger.info("Device agent provisioning: success");
+        process.exit();
+      }
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+const osu = require('node-os-utils');
+
+export async function getCpuUtil(): Promise<number> {
+  const cpuUsage = await osu.cpu.usage();
+  return cpuUsage;
+}
+
+export async function getDiskUtil(): Promise<number> {
+  const driveInfo = await osu.drive.info();
+  return parseFloat(driveInfo.usedPercentage);
+}
+
+export async function getMemUtil(): Promise<number> {
+  const memInfo = await osu.mem.info();
+  return 100.0 - memInfo.freeMemPercentage;
+}

package/src/docker/docker-cmd.ts

@@ -0,0 +1,12 @@
+import { JsSpawner } from 'alwaysai/lib/util';
+
+export async function runDockerLogin(props: { token: string }) {
+  const { token } = props;
+  const spawner = JsSpawner();
+  const server = '994534263224.dkr.ecr.us-west-2.amazonaws.com';
+  const output = await spawner.run({
+    exe: 'docker',
+    args: ['login', '--username', 'AWS', '--password', token, server],
+  });
+  return output;
+}

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

@@ -0,0 +1,12 @@
+import { JsSpawner } from 'alwaysai/lib/util';
+
+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,
+  });
+  return output;
+}

package/src/endpoints.ts

@@ -0,0 +1,24 @@
+import { getSystemId } from "alwaysai/lib/infrastructure";
+
+export const getSecondLevelDomain = () => {
+  let domain = "";
+  switch (getSystemId()) {
+    case "development":
+      domain = "a6i0.net";
+      break;
+    case "qa":
+      domain = "a6i1.net";
+      break;
+    case "production":
+      domain = "alwaysai.co";
+      break;
+    default:
+      domain = "alwaysai.co";
+      break;
+  }
+  return domain;
+};
+
+export const serviceEndpointBuilder = (service: string, path: string) => {
+  return `https://${service}.${getSecondLevelDomain()}/${path}`;
+};

package/src/environment.ts

@@ -0,0 +1,28 @@
+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_LOG_LEVEL = process.env.AAI_LOG_LEVEL;
+export const ALWAYSAI_LOG_TO_CONSOLE = process.env.ALWAYSAI_LOG_TO_CONSOLE;
+
+function parseOsPlatform(str: string | undefined): NodeJS.Platform {
+  switch (str) {
+    case "win32":
+    case "darwin":
+    case "linux": {
+      return str;
+    }
+    default:
+      return platform();
+  }
+}
+
+function parseBoolean(str: string | undefined) {
+  return str === "1";
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+/*
+Though this file is not executable, the above "shebang" line is necessary as an
+indicator to npm that this file is a Node.js script, not a shell script e.g.
+*/
+
+import { runCliAndExit } from "@alwaysai/alwayscli";
+import { root } from "./root";
+import { runDeviceAgentCloudInterface } from "./cloud-connection/device-agent-cloud-connection";
+import { AgentConfigFile } from "./infrastructure/agent-config";
+import { ALWAYSAI_DEVICE_AGENT_MODE } from "./environment";
+import { logger } from "./util/logger";
+
+if (module === require.main) {
+  logger.info("Starting alwaysAI Device Agent");
+  if (!AgentConfigFile().exists()) {
+    AgentConfigFile().initialize();
+  }
+
+  if (ALWAYSAI_DEVICE_AGENT_MODE === "cloud") {
+    runDeviceAgentCloudInterface();
+  } else {
+    runCliAndExit(root, {});
+  }
+}

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

@@ -0,0 +1,199 @@
+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 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
+      await configFile.setAppInstalled({ projectId, version });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(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';
+      const version2 = 'newer-version';
+
+      // first installation, we use the version
+      await configFile.setAppInstalling({ projectId, version });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
+      await configFile.setAppInstalled({ projectId, version });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(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 });
+
+      await configFile.setAppInstalling({ projectId, version: version2 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version);
+      await configFile.setAppInstalled({ projectId, version: version2 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version2);
+      const backup3 = await configFile.getAppBackup({ projectId });
+      expect(backup3).toEqual({ version });
+    });
+
+    test('Test app rollback', async () => {
+      const projectId = 'add-me';
+      const version1 = 'original-version';
+      const version2 = 'newer-version';
+      await configFile.setAppInstalling({ projectId, version: version1 });
+      await configFile.setAppInstalled({ projectId, version: version1 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version1);
+      expect(await configFile.getAppBackup({ projectId })).toBeNull();
+
+      // next installation - verify app is present and ready
+      expect(await configFile.isAppPresent({ projectId })).toBe(true);
+      expect(await configFile.isAppReady({ projectId })).toBe(true);
+
+      // test to see if app has backup
+      await configFile.setAppBackup({ projectId });
+      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;
+      expect(newExpectedBackupVersion).toEqual(version1);
+      await configFile.setAppInstalled({ projectId, version: version2 });
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version2);
+
+      // simulate the rollback step: set the version that we will roll back to
+      await configFile.setAppInstalling({ projectId, version: version1 });
+
+      // test state during rollback
+      expect(await configFile.isAppReady({ projectId })).toEqual(false);
+      expect(await configFile.getAppVersion({ projectId })).toEqual(version2);
+
+      // test final state of rolled-back app
+      await configFile.setAppInstalled({ projectId, version: version1 });
+      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

@@ -0,0 +1,208 @@
+import { ConfigFileSchema } from '@alwaysai/config-nodejs';
+import { JSONSchemaType } from 'ajv';
+import { homedir } from 'os';
+import { join } from 'path';
+
+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();
+      // NOTE: do not update the version for an existing app until it is installed
+      config.applications.push({ ...app, ...{ ready: false } });
+      configFile.write(config);
+    } else {
+      // NOTE: for a brand-new app, we need to specify the version
+      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();
+      config.applications.push({ ...app, ...{ version, ready: true } });
+      configFile.write(config);
+    } else {
+      // 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!`,
+      );
+    }
+  }
+
+  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,47 @@
+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 {
+  JsSpawner,
+  Spawner,
+  writeCertificate,
+  writeTokens,
+} from "alwaysai/lib/util";
+import { logger } from "../util/logger";
+
+// NOTE: This is reimplemented from the CLI to work for local checks
+export async function getTargetHardwareUuid(spawner: Spawner, path: string) {
+  return await spawner.run({
+    exe: "cat",
+    args: [path],
+  });
+}
+
+// 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 tokens: DeviceTokens = {
+    deviceId: deviceUuid,
+    accessToken: "",
+    refreshToken: "",
+    idToken: "",
+  };
+  const tokenSpawner = JsSpawner({ path: LOCAL_AAI_CFG_DIR });
+  await writeTokens({ spawner: tokenSpawner, tokens });
+  await writeOrUpdateDeviceCfgFile({ spawner: tokenSpawner });
+
+  logger.info("Updated tokens and certificate");
+}