@alwaysai/device-agent 0.0.3 → 0.0.5

package/src/subcommands/app/app.ts

@@ -1,24 +1,36 @@
-import { CliLeaf, CliStringInput, CliTerseError } from '@alwaysai/alwayscli';
 import {
+  CliLeaf,
+  CliStringArrayInput,
+  CliStringInput,
+  CliTerseError,
+} from '@alwaysai/alwayscli';
+import {
+  addModel,
+  getAllEnvs,
   getAppLogs,
+  getAppModels,
   getAppStatus,
-  getInstalledApps,
   installApp,
+  listAppLatestRelease,
+  listAppReleases,
+  removeModel,
+  replaceModels,
+  restartApp,
   rollbackApp,
+  setEnv,
   startApp,
   stopApp,
   uninstallApp,
-  listAppReleases,
-  listAppLatestRelease,
-} from '../../application-control/application-control';
-import { addModel, removeModel, updateModels } from '../../application-control/models';
+  updateModels,
+} from '../../application-control';
+import { AgentConfigFile } from '../../infrastructure/agent-config';
 
 export const listAppsCliLeaf = CliLeaf({
   name: 'list',
   description: 'List all installed apps',
   namedInputs: {},
   async action(_, opts) {
-    const apps = await getInstalledApps();
+    const apps = await AgentConfigFile().getApps();
     console.table(apps);
   },
 });
@@ -28,14 +40,12 @@ export const listAppReleasesCliLeaf = CliLeaf({
   description: 'List all releases for a given app',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
     const releaseHistory = await listAppReleases({ projectId: project });
     console.log(releaseHistory);
   },
@@ -46,14 +56,12 @@ export const listAppLatestReleaseCliLeaf = CliLeaf({
   description: 'List the latest release hash for a given app',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
     const latestReleaseHash = await listAppLatestRelease({ projectId: project });
     if (latestReleaseHash === undefined) {
       throw new CliTerseError('This application has not been published yet');
@@ -67,7 +75,8 @@ export const installAppCliLeaf = CliLeaf({
   description: 'Install an alwaysAI app from a project',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
     releaseHash: CliStringInput({
       description: 'Release Hash',
@@ -76,9 +85,6 @@ export const installAppCliLeaf = CliLeaf({
   async action(_, opts) {
     const project = opts.project;
     let releaseHash = opts.releaseHash;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
     if (releaseHash === undefined) {
       releaseHash = await listAppLatestRelease({ projectId: project });
     }
@@ -94,14 +100,12 @@ export const getAppStatusCliLeaf = CliLeaf({
   description: 'Get the status of an installed alwaysAI app',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
     const appStatus = await getAppStatus({ projectId: project });
     console.log(appStatus);
   },
@@ -112,7 +116,8 @@ export const startAppCliLeaf = CliLeaf({
   description: 'Start an installed alwaysAI app',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
     dockerLoginToken: CliStringInput({
       description: 'Docker login token',
@@ -120,9 +125,6 @@ export const startAppCliLeaf = CliLeaf({
   },
   async action(_, opts) {
     const { project, dockerLoginToken } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
     await startApp({ projectId: project, dockerLoginToken });
   },
 });
@@ -132,14 +134,12 @@ export const getAppLogsCliLeaf = CliLeaf({
   description: 'Get logs for an application',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
     const readable = await getAppLogs({ projectId: project });
     readable.setEncoding('utf8');
     for await (const chunk of readable) {
@@ -153,31 +153,42 @@ export const stopAppCliLeaf = CliLeaf({
   description: 'Stop a running alwaysAI app',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('Project ID is required');
-    }
     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',
+      description: 'Project ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('Project ID is required');
-    }
     await uninstallApp({ projectId: project });
   },
 });
@@ -187,37 +198,47 @@ export const rollbackAppCliLeaf = CliLeaf({
   description: 'Rollback an alwaysAI app to the previous version',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('Project ID is required');
-    }
     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',
+      description: 'Project ID',
+      required: true,
     }),
     model: CliStringInput({
-      description: 'Model Id',
+      description: 'Model ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project, model } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
-    if (model === undefined) {
-      throw new CliTerseError('--model is required');
-    }
     await addModel({ projectId: project, modelId: model });
   },
 });
@@ -227,37 +248,89 @@ export const removeModelCliLeaf = CliLeaf({
   description: 'Remove a model from an alwaysAI app',
   namedInputs: {
     project: CliStringInput({
-      description: 'Project Id',
+      description: 'Project ID',
+      required: true,
     }),
     model: CliStringInput({
-      description: 'Model Id',
+      description: 'Model ID',
+      required: true,
     }),
   },
   async action(_, opts) {
     const { project, model } = opts;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
-    if (model === undefined) {
-      throw new CliTerseError('--model is required');
-    }
     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;
-    if (project === undefined) {
-      throw new CliTerseError('--project is required');
-    }
     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;
+    console.log(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

@@ -13,6 +13,11 @@ import {
   getAppLogsCliLeaf,
   listAppReleasesCliLeaf,
   listAppLatestReleaseCliLeaf,
+  restartAppCliLeaf,
+  replaceModelsCliLeaf,
+  showAppModelsCliLeaf,
+  getAllEnvsCLiLeaf,
+  setEnvCLiLeaf,
 } from './app';
 
 export const appCliBranch = CliBranch({
@@ -25,12 +30,17 @@ export const appCliBranch = CliBranch({
     installAppCliLeaf,
     getAppStatusCliLeaf,
     startAppCliLeaf,
-    getAppLogsCliLeaf,
     stopAppCliLeaf,
+    restartAppCliLeaf,
+    getAppLogsCliLeaf,
     uninstallAppCliLeaf,
     rollbackAppCliLeaf,
+    showAppModelsCliLeaf,
     addModelCliLeaf,
     removeModelCliLeaf,
+    replaceModelsCliLeaf,
     updateModelsCliLeaf,
+    getAllEnvsCLiLeaf,
+    setEnvCLiLeaf,
   ],
 });

package/src/subcommands/device/device.ts

@@ -0,0 +1,63 @@
+import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
+import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
+import { checkPaidPlan } from 'alwaysai/lib/core/project';
+import { addDevice, CliAuthenticationClient } from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { getCpuUtil, getDiskUtil, getMemUtil } from '../../device-control/device-control';
+import {
+  getTargetHardwareUuid,
+  writeCertificateAndToken,
+} from '../../infrastructure/certificates-and-tokens';
+
+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;
+    console.log('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 hardwareId = await getTargetHardwareUuid(spawner);
+    const deviceToAdd = {
+      owner: username,
+      friendly_name: name,
+      host_name: '',
+      device_user_name: '',
+      description: description || '',
+      hardware_ids: hardwareId,
+      device_hash: '',
+      iotKeys: '',
+    };
+    const response = await addDevice(deviceToAdd, 'production');
+    await writeCertificateAndToken({ deviceUuid: response.deviceUUID });
+    console.log(`Initialized device as ${response.deviceUUID}`);
+  },
+});
+
+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,8 @@
+import { CliBranch } from '@alwaysai/alwayscli';
+import { getInfoCliLeaf, initCliLeaf } from './device';
+
+export const deviceCliBranch = CliBranch({
+  name: 'device',
+  description: 'Manage current device',
+  subcommands: [initCliLeaf, getInfoCliLeaf],
+});

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

@@ -0,0 +1,60 @@
+import { CliLeaf, CliNumberInput, CliStringInput } from '@alwaysai/alwayscli';
+import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
+import {
+  downloadModelPackageToCache,
+  ModelId,
+  modelPackageCache,
+} from 'alwaysai/lib/core/model';
+import { CliRpcClient } from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { join } from 'path';
+
+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) {
+    // NOTE: This code closely follows 'get-model-package.ts' in the CLI
+    const { publisher, name } = ModelId.parse(id);
+    const path = opts.path ? opts.path : process.cwd();
+    // untar will unpack model package contents to <name> so append publisher to path
+    const publisherPath = join(path, publisher);
+    const spawner = JsSpawner({ path: publisherPath });
+
+    if (await spawner.exists(name)) {
+      console.log(
+        `Found existing version of ${id} at ${join(
+          publisherPath,
+          name,
+        )}, removing prior to download`,
+      );
+      spawner.rimraf(name);
+    }
+
+    console.log(`Downloading ${id} to ${path}`);
+    await checkUserIsLoggedInComponent({ yes: true });
+    const version =
+      opts.version || (await CliRpcClient().getModelVersion({ id })).version;
+    if (!modelPackageCache.has(id, version)) {
+      await downloadModelPackageToCache(id, version);
+    }
+    const modelPackageStream = modelPackageCache.read(id, version);
+    await spawner.mkdirp();
+    await spawner.untar(modelPackageStream);
+    console.log(`Completed downloading ${id} to ${path}`);
+  },
+});

package/src/subcommands/index.ts

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

package/src/subcommands/login.ts

@@ -1,4 +1,5 @@
 import { CliLeaf, CliStringInput, CliUsageError } from '@alwaysai/alwayscli';
+import { writeCertificateAndToken } from '../infrastructure/certificates-and-tokens';
 import { runCliCmd } from '../util/run-cli-cmd';
 
 export const loginCliLeaf = CliLeaf({
@@ -7,18 +8,24 @@ export const loginCliLeaf = CliLeaf({
   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 } = opts;
-    if (!email || !password) {
-      throw new CliUsageError('--email and --password are required!');
-    }
+    const { email, password, device } = opts;
     await runCliCmd({
       cmd: ['user', 'login', '--yes', '--email', email, '--password', password],
     });
+    if (device) {
+      await writeCertificateAndToken({ deviceUuid: device });
+    }
   },
 });

package/src/util/copy-dir.ts

@@ -1,4 +1,4 @@
-import { JsSpawner } from '../util/spawner/js-spawner';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 export async function copyDir(props: { srcPath: string; destPath: string }) {
   const { srcPath, destPath } = props;

package/src/util/directories.ts

@@ -1,30 +1,25 @@
-const os = require('os');
-import { join } from 'path';
 import {
-  DEVICE_CERT_AND_KEY_DIR_LINUX,
-  DEV_HOST_CERT_AND_KEY_DIR,
   DEVICE_CERTIFICATE_FILE_NAME,
   DEVICE_PRIVATE_KEY_FILE_NAME,
   DEVICE_ROOT_CERT_FILE_NAME,
-} from '../constants';
-
-const certAndKeyDir = getCertAndKeyDir();
-
-export function getCertAndKeyDir() {
-  if (os.type() === 'Darwin' || os.type() === 'Windows_NT') {
-    return DEV_HOST_CERT_AND_KEY_DIR;
-  }
-  return DEVICE_CERT_AND_KEY_DIR_LINUX;
-}
+  DEVICE_TOKEN_FILE_NAME,
+  LOCAL_AAI_CFG_DIR,
+  LOCAL_CERT_AND_KEY_DIR,
+} from 'alwaysai/lib/constants';
+import { join } from 'path';
 
 export function getPrivateKeyFilePath() {
-  return join(certAndKeyDir, DEVICE_PRIVATE_KEY_FILE_NAME);
+  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_PRIVATE_KEY_FILE_NAME);
 }
 
 export function getCertificateFilePath() {
-  return join(certAndKeyDir, DEVICE_CERTIFICATE_FILE_NAME);
+  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_CERTIFICATE_FILE_NAME);
 }
 
 export function getRootCertificateFilePath() {
-  return join(certAndKeyDir, DEVICE_ROOT_CERT_FILE_NAME);
+  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_ROOT_CERT_FILE_NAME);
+}
+
+export function getCredentialsFilePath() {
+  return join(LOCAL_AAI_CFG_DIR, DEVICE_TOKEN_FILE_NAME);
 }

package/src/util/get-device-id.ts

@@ -0,0 +1,22 @@
+import { getCredentialsFilePath } from '../util/directories';
+import { CliTerseError } from '@alwaysai/alwayscli';
+import { ConfigFile } from '@alwaysai/config-nodejs';
+import * as t from 'io-ts';
+
+export function getDeviceId() {
+  const path = getCredentialsFilePath();
+  const codec = t.type({
+    deviceId: t.union([t.string, t.undefined]),
+  });
+  const credentialsJsonFile = ConfigFile({
+    path,
+    codec,
+  });
+  const config = credentialsJsonFile.readIfExists();
+  if (!config || !config.deviceId) {
+    throw new CliTerseError(
+      'Invalid device credentials! Please ensure you are using the device agent on a valid device.',
+    );
+  }
+  return config.deviceId;
+}