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

package/src/infrastructure/urls.ts

@@ -0,0 +1,21 @@
+import { CliTerseError } from '@alwaysai/alwayscli';
+import { getSystemId } from 'alwaysai/lib/infrastructure';
+
+export function getIoTCoreEndpointUrl() {
+  let iotCoreEndpointUrl = '';
+  switch (getSystemId()) {
+    case 'local':
+    case 'development':
+      iotCoreEndpointUrl = 'a170opbva29ts8-ats.iot.us-west-2.amazonaws.com';
+      break;
+    case 'qa':
+      iotCoreEndpointUrl = 'a3bff3qyyopgws-ats.iot.us-west-2.amazonaws.com';
+      break;
+    case 'production':
+      iotCoreEndpointUrl = 'a3tzi5g7sq5zsj-ats.iot.us-west-2.amazonaws.com';
+      break;
+    default:
+      throw new CliTerseError(`Remote deployment not supported on ${getSystemId()}!`);
+  }
+  return iotCoreEndpointUrl;
+}

package/src/root.ts

@@ -0,0 +1,11 @@
+const winston = require("winston");
+
+import { CliBranch } from "@alwaysai/alwayscli";
+
+import { subcommands } from "./subcommands";
+
+export const root = CliBranch({
+  name: "aai-agent",
+  description: "Manage your alwaysAI production device",
+  subcommands,
+});

package/src/subcommands/app/app.ts

@@ -0,0 +1,337 @@
+import {
+  CliLeaf,
+  CliStringArrayInput,
+  CliStringInput,
+  CliTerseError,
+} from '@alwaysai/alwayscli';
+import {
+  addModel,
+  getAllEnvs,
+  getAppLogs,
+  getAppModels,
+  getAppStatus,
+  installApp,
+  listAppLatestRelease,
+  listAppReleases,
+  removeModel,
+  replaceModels,
+  restartApp,
+  rollbackApp,
+  setEnv,
+  startApp,
+  stopApp,
+  uninstallApp,
+  updateModels,
+} from '../../application-control';
+import { AgentConfigFile } from '../../infrastructure/agent-config';
+import { logger } from '../../util/logger';
+
+export const listAppsCliLeaf = CliLeaf({
+  name: 'list',
+  description: 'List all installed apps',
+  namedInputs: {},
+  async action(_, opts) {
+    const apps = await AgentConfigFile().getApps();
+    console.table(apps);
+  },
+});
+
+export const listAppReleasesCliLeaf = CliLeaf({
+  name: 'list-releases',
+  description: 'List all releases for a given app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    const releaseHistory = await listAppReleases({ projectId: project });
+    logger.info(releaseHistory);
+  },
+});
+
+export const listAppLatestReleaseCliLeaf = CliLeaf({
+  name: 'list-latest-release',
+  description: 'List the latest release hash for a given app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    const latestReleaseHash = await listAppLatestRelease({ projectId: project });
+    if (latestReleaseHash === undefined) {
+      throw new CliTerseError('This application has not been published yet');
+    }
+    logger.info(latestReleaseHash);
+  },
+});
+
+export const installAppCliLeaf = CliLeaf({
+  name: 'install',
+  description: 'Install an alwaysAI app from a project',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+    releaseHash: CliStringInput({
+      description: 'Release Hash',
+    }),
+  },
+  async action(_, opts) {
+    const project = opts.project;
+    let releaseHash = opts.releaseHash;
+    if (releaseHash === undefined) {
+      releaseHash = await listAppLatestRelease({ projectId: project });
+    }
+    if (releaseHash === undefined) {
+      throw new CliTerseError('This application has not been published yet');
+    }
+    await installApp({ projectId: project, appReleaseHash: releaseHash });
+  },
+});
+
+export const getAppStatusCliLeaf = CliLeaf({
+  name: 'status',
+  description: 'Get the status of an installed alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    const appStatus = await getAppStatus({ projectId: project });
+    logger.info(appStatus);
+  },
+});
+
+export const startAppCliLeaf = CliLeaf({
+  name: 'start',
+  description: 'Start an installed alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+    dockerLoginToken: CliStringInput({
+      description: 'Docker login token',
+    }),
+  },
+  async action(_, opts) {
+    const { project, dockerLoginToken } = opts;
+    await startApp({ projectId: project, dockerLoginToken });
+  },
+});
+
+export const getAppLogsCliLeaf = CliLeaf({
+  name: 'logs',
+  description: 'Get logs for an application',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    const readable = await getAppLogs({ projectId: project });
+    readable.setEncoding('utf8');
+    for await (const chunk of readable) {
+      logger.info(chunk);
+    }
+  },
+});
+
+export const stopAppCliLeaf = CliLeaf({
+  name: 'stop',
+  description: 'Stop a running alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    await stopApp({ projectId: project });
+  },
+});
+
+export const restartAppCliLeaf = CliLeaf({
+  name: 'restart',
+  description: 'Restart running alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    await restartApp({ projectId: project });
+  },
+});
+
+export const uninstallAppCliLeaf = CliLeaf({
+  name: 'uninstall',
+  description: 'Remove an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    await uninstallApp({ projectId: project });
+  },
+});
+
+export const rollbackAppCliLeaf = CliLeaf({
+  name: 'rollback',
+  description: 'Rollback an alwaysAI app to the previous version',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    await rollbackApp({ projectId: project });
+  },
+});
+
+export const showAppModelsCliLeaf = CliLeaf({
+  name: 'show-models',
+  description: 'Show the application models',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    const appModels = await getAppModels({ projectId: project });
+    console.table(appModels);
+  },
+});
+
+export const addModelCliLeaf = CliLeaf({
+  name: 'add-model',
+  description: 'Add a model to an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+    model: CliStringInput({
+      description: 'Model ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project, model } = opts;
+    await addModel({ projectId: project, modelId: model });
+  },
+});
+
+export const removeModelCliLeaf = CliLeaf({
+  name: 'remove-model',
+  description: 'Remove a model from an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project ID',
+      required: true,
+    }),
+    model: CliStringInput({
+      description: 'Model ID',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project, model } = opts;
+    await removeModel({ projectId: project, modelId: model });
+  },
+});
+
+export const replaceModelsCliLeaf = CliLeaf({
+  name: 'replace-models',
+  description: 'Replace all models of an alwaysAI app with new models',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+      required: true,
+    }),
+    models: CliStringArrayInput({
+      description: 'One or more model IDs',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project, models } = opts;
+    await replaceModels({ projectId: project, modelIds: models });
+  },
+});
+
+export const updateModelsCliLeaf = CliLeaf({
+  name: 'update-models',
+  description: 'Update all models for an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    await updateModels({ projectId: project });
+  },
+});
+
+export const getAllEnvsCLiLeaf = CliLeaf({
+  name: 'get-all-envs',
+  description: 'Get environment variables for an application',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    logger.info(await getAllEnvs({ projectId: project }));
+  },
+});
+
+export const setEnvCLiLeaf = CliLeaf({
+  name: 'set-env',
+  description: 'Set environment variables for a service',
+  positionalInput: CliStringArrayInput({
+    placeholder: '<NAME=VALUE> [<NAME=VALUE> ...]',
+    required: true,
+  }),
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+      required: true,
+    }),
+    service: CliStringInput({
+      description:
+        'The name of the docker-compose service to apply environment variable to',
+      required: false,
+    }),
+  },
+  async action(args, opts) {
+    const { project, service } = opts;
+    await setEnv({ projectId: project, vars: args, service });
+  },
+});

package/src/subcommands/app/index.ts

@@ -0,0 +1,46 @@
+import { CliBranch } from '@alwaysai/alwayscli';
+import {
+  getAppStatusCliLeaf,
+  listAppsCliLeaf,
+  installAppCliLeaf,
+  rollbackAppCliLeaf,
+  startAppCliLeaf,
+  stopAppCliLeaf,
+  uninstallAppCliLeaf,
+  addModelCliLeaf,
+  removeModelCliLeaf,
+  updateModelsCliLeaf,
+  getAppLogsCliLeaf,
+  listAppReleasesCliLeaf,
+  listAppLatestReleaseCliLeaf,
+  restartAppCliLeaf,
+  replaceModelsCliLeaf,
+  showAppModelsCliLeaf,
+  getAllEnvsCLiLeaf,
+  setEnvCLiLeaf,
+} from './app';
+
+export const appCliBranch = CliBranch({
+  name: 'app',
+  description: 'Manage alwaysAI applications',
+  subcommands: [
+    listAppsCliLeaf,
+    listAppReleasesCliLeaf,
+    listAppLatestReleaseCliLeaf,
+    installAppCliLeaf,
+    getAppStatusCliLeaf,
+    startAppCliLeaf,
+    stopAppCliLeaf,
+    restartAppCliLeaf,
+    getAppLogsCliLeaf,
+    uninstallAppCliLeaf,
+    rollbackAppCliLeaf,
+    showAppModelsCliLeaf,
+    addModelCliLeaf,
+    removeModelCliLeaf,
+    replaceModelsCliLeaf,
+    updateModelsCliLeaf,
+    getAllEnvsCLiLeaf,
+    setEnvCLiLeaf,
+  ],
+});

package/src/subcommands/device/clean.ts

@@ -0,0 +1,16 @@
+import { CliLeaf, CliStringInput } from "@alwaysai/alwayscli";
+import * as rimraf from "rimraf";
+import { AAI_DIR, LOCAL_CERT_AND_KEY_DIR } from "alwaysai/lib/constants";
+import { AGENT_CONFIG_FILE_PATH } from "../../util/directories";
+import { logger } from "../../util/logger";
+export const cleanCliLeaf = CliLeaf({
+  name: "clean",
+  description: "Removes current provisioned device-agent",
+  async action(_, opts) {
+    logger.info("Removing files...");
+    rimraf.sync(AAI_DIR);
+    rimraf.sync(LOCAL_CERT_AND_KEY_DIR);
+    rimraf.sync(AGENT_CONFIG_FILE_PATH);
+    logger.info("Files removed");
+  },
+});

package/src/subcommands/device/device.ts

@@ -0,0 +1,126 @@
+import { CliLeaf, CliStringInput } from "@alwaysai/alwayscli";
+import { checkUserIsLoggedInComponent } from "alwaysai/lib/components/user";
+import { checkPaidPlan } from "alwaysai/lib/core/project";
+import { v4 as uuidv4 } from "uuid";
+import { CliAuthenticationClient } from "alwaysai/lib/infrastructure";
+import { existsSync } from "fs";
+import { httpClient, microServiceHttpClient } from "../../util/http-client";
+import {
+  AWS_ROOT_CERTIFICATE_FILE_NAME,
+  BOOTSTRAP_CERTIFICATES_DIR_PATH,
+  getPrivateKeyFilePath,
+} from "../../util/directories";
+
+import { LOCAL_CERT_AND_KEY_DIR } from "alwaysai/lib/constants";
+import { JsSpawner } from "alwaysai/lib/util";
+import {
+  getCpuUtil,
+  getDiskUtil,
+  getMemUtil,
+} from "../../device-control/device-control";
+import { writeCertificateAndToken } from "../../infrastructure/certificates-and-tokens";
+import { logger } from "../../util/logger";
+
+export const initCliLeaf = CliLeaf({
+  name: "init",
+  description: "Initialize device",
+  namedInputs: {
+    name: CliStringInput({
+      description: "Device name",
+      required: true,
+    }),
+    description: CliStringInput({
+      description: "Device description",
+      required: false,
+    }),
+  },
+  async action(_, opts) {
+    const { name, description } = opts;
+    switch (true) {
+      case !existsSync(getPrivateKeyFilePath()):
+        {
+          logger.info("Initializing device");
+          await checkUserIsLoggedInComponent({ yes: true });
+          if (!(await checkPaidPlan())) {
+            throw new Error(
+              `This action only supported for Enterprise alwaysAI accounts!`
+            );
+          }
+          const { username } = await CliAuthenticationClient().getInfo();
+          const spawner = JsSpawner();
+          const device = {
+            deviceMode: "production",
+            hardwareId: uuidv4(),
+            txId: uuidv4(),
+            userName: username,
+            friendlyName: name,
+          };
+          //**NOTE: hardwareId currently is mocked. The real hardwareId will be used in future work
+
+          const response: { deviceUuid: string; claimCertificate: string[] } =
+            await microServiceHttpClient(
+              "fleet-provision",
+              "addDevice",
+              "POST",
+              JSON.stringify(device)
+            );
+
+          if (Object.hasOwn(response, "claimCertificate")) {
+            const ROOT_CERT_AWS = await httpClient(
+              "https://www.amazontrust.com/repository/AmazonRootCA1.pem",
+              "GET"
+            );
+
+            await writeCertificateAndToken({ deviceUuid: response.deviceUuid });
+
+            const hardwareIdSpawner = JsSpawner({
+              path: LOCAL_CERT_AND_KEY_DIR,
+            });
+
+            await JsSpawner().mkdirp(BOOTSTRAP_CERTIFICATES_DIR_PATH);
+            await hardwareIdSpawner.writeFile(
+              "hardware-id.txt",
+              device.hardwareId
+            );
+
+            JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR }).writeFile(
+              AWS_ROOT_CERTIFICATE_FILE_NAME,
+              ROOT_CERT_AWS
+            );
+            const certSpawner = JsSpawner({
+              path: BOOTSTRAP_CERTIFICATES_DIR_PATH,
+            });
+            for (const key in response.claimCertificate) {
+              await certSpawner.writeFile(key, response.claimCertificate[key]);
+            }
+
+            logger.info(`Initialized device as ${response.deviceUuid}`);
+          } else {
+            logger.info(
+              "Device cannot be provisioned. Run 'device-agent device clean' and retry."
+            );
+          }
+        }
+        break;
+      default: {
+        logger.info(
+          "Device has been previously provisioned. Run 'device-agent device clean' to re-provision"
+        );
+      }
+    }
+  },
+});
+
+export const getInfoCliLeaf = CliLeaf({
+  name: "get-info",
+  description: "Get device info",
+  namedInputs: {},
+  async action(_, opts) {
+    const deviceInfo = [
+      ["CPU Utilization", `${String(await getCpuUtil())} %`],
+      ["Disk Utilization", `${String(await getDiskUtil())} %`],
+      ["Memory Utilization", `${String(await getMemUtil())} %`],
+    ];
+    console.table(deviceInfo);
+  },
+});

package/src/subcommands/device/index.ts

@@ -0,0 +1,9 @@
+import { CliBranch } from "@alwaysai/alwayscli";
+import { getInfoCliLeaf, initCliLeaf } from "./device";
+import { cleanCliLeaf } from "./clean";
+
+export const deviceCliBranch = CliBranch({
+  name: "device",
+  description: "Manage current device",
+  subcommands: [initCliLeaf, getInfoCliLeaf, cleanCliLeaf],
+});

package/src/subcommands/get-model-package.ts

@@ -0,0 +1,33 @@
+import { CliLeaf, CliNumberInput, CliStringInput } from '@alwaysai/alwayscli';
+import { appInstallModel } from 'alwaysai/lib/core/app';
+import { CliRpcClient } from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { logger } from '../util/logger';
+
+export const getModelPackageCliLeaf = CliLeaf({
+  name: 'get-model-package',
+  description: 'Download and unpack a model package',
+  positionalInput: CliStringInput({
+    description: 'For example, "alwaysai/mobilenet_ssd"',
+    required: true,
+    placeholder: '<id>',
+  }),
+  namedInputs: {
+    version: CliNumberInput({
+      description: 'The version number of the model',
+      required: false,
+    }),
+    path: CliStringInput({
+      description: 'The output path to write model package to',
+      required: false,
+    }),
+  },
+  async action(id, opts) {
+    const path = opts.path || process.cwd();
+    const spawner = JsSpawner({ path });
+    const version =
+      opts.version || (await CliRpcClient().getModelVersion({ id })).version;
+    await appInstallModel(spawner, id, version);
+    logger.info(`Completed downloading ${id} to ${path}`);
+  },
+});

package/src/subcommands/index.ts

@@ -0,0 +1,11 @@
+import { appCliBranch } from './app';
+import { deviceCliBranch } from './device';
+import { loginCliLeaf } from './login';
+import { getModelPackageCliLeaf } from './get-model-package';
+
+export const subcommands = [
+  loginCliLeaf,
+  appCliBranch,
+  deviceCliBranch,
+  getModelPackageCliLeaf,
+];

package/src/subcommands/login.ts

@@ -0,0 +1,33 @@
+import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
+import { alwaysaiUserLoginYesComponent } from 'alwaysai/lib/components/user';
+import { writeCertificateAndToken } from '../infrastructure/certificates-and-tokens';
+
+export const loginCliLeaf = CliLeaf({
+  name: 'login',
+  description: 'Login to alwaysAI (this is meant for scripted environments)',
+  namedInputs: {
+    email: CliStringInput({
+      description: 'alwaysAI email',
+      required: true,
+    }),
+    password: CliStringInput({
+      description: 'Account password',
+      required: true,
+    }),
+    device: CliStringInput({
+      description: 'The device UUID',
+      required: false,
+    }),
+  },
+  async action(_, opts) {
+    const { email, password, device } = opts;
+
+    await alwaysaiUserLoginYesComponent({
+      alwaysaiUserEmail: email,
+      alwaysaiUserPassword: password,
+    });
+    if (device) {
+      await writeCertificateAndToken({ deviceUuid: device });
+    }
+  },
+});

package/src/util/clean-certs.ts

@@ -0,0 +1,12 @@
+import { JsSpawner } from "alwaysai/lib/util";
+import { logger } from "../util/logger";
+import { LOCAL_CERT_AND_KEY_DIR } from "alwaysai/lib/constants";
+import { BOOTSTRAP_CERTIFICATES_DIR_PATH } from "../util/directories";
+
+export const rmBootstrapCertsAndClose = async () => {
+  const spawner = JsSpawner();
+  await spawner.rimraf(BOOTSTRAP_CERTIFICATES_DIR_PATH);
+  await spawner.rimraf(LOCAL_CERT_AND_KEY_DIR);
+  logger.info("Could not provision device. Try again.");
+  process.exit();
+};

package/src/util/copy-dir.ts

@@ -0,0 +1,12 @@
+import { JsSpawner } from "alwaysai/lib/util";
+
+export async function copyDir(props: { srcPath: string; destPath: string }) {
+  const { srcPath, destPath } = props;
+  const src = JsSpawner({ path: srcPath });
+  const allFileNames = await src.readdir();
+  const dest = JsSpawner({ path: destPath });
+  await dest.mkdirp();
+  if (allFileNames.length) {
+    await dest.untar(await src.tar(...allFileNames));
+  }
+}