@alwaysai/device-agent 0.0.13 → 0.0.14

package/src/subcommands/app/app.ts

@@ -4,15 +4,13 @@ import {
   CliStringInput,
   CliTerseError
 } from '@alwaysai/alwayscli';
+import { ClientMessage, keyMirrors } from '@alwaysai/device-agent-schemas';
 import {
-  addModel,
   getAllEnvs,
   getAppLogs,
   getAppModels,
   getAppStatus,
-  installApp,
-  listAppLatestRelease,
-  listAppReleases,
+  readAppCfgFile,
   removeModel,
   replaceModels,
   restartApp,
@@ -23,8 +21,10 @@ import {
   uninstallApp,
   updateModels
 } from '../../application-control';
+import { DeviceAgentCloudConnection } from '../../cloud-connection/device-agent-cloud-connection';
 import { AgentConfigFile } from '../../infrastructure/agent-config';
 import { logger } from '../../util/logger';
+import { timer } from '../../util/timer';
 
 export const listAppsCliLeaf = CliLeaf({
   name: 'list',
@@ -45,10 +45,9 @@ export const listAppReleasesCliLeaf = CliLeaf({
       required: true
     })
   },
+  hidden: true,
   async action(_, opts) {
-    const { project } = opts;
-    const releaseHistory = await listAppReleases({ projectId: project });
-    logger.info(releaseHistory);
+    throw new CliTerseError('This command is yet currently implemented!');
   }
 });
 
@@ -61,15 +60,9 @@ export const listAppLatestReleaseCliLeaf = CliLeaf({
       required: true
     })
   },
+  hidden: 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);
+    throw new CliTerseError('This command is yet currently implemented!');
   }
 });
 
@@ -82,19 +75,32 @@ export const installAppCliLeaf = CliLeaf({
       required: true
     }),
     releaseHash: CliStringInput({
-      description: 'Release Hash'
+      description: 'Release Hash',
+      required: true
     })
   },
   async action(_, opts) {
-    const project = opts.project;
-    let releaseHash = opts.releaseHash;
-    if (releaseHash === undefined) {
-      releaseHash = await listAppLatestRelease({ projectId: project });
+    const { project, releaseHash } = opts;
+    const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.setupHandlers();
+    const topic = deviceAgent.getToDeviceTopic();
+    const message: ClientMessage = {
+      timestamp: '',
+      topic,
+      payload: {
+        messageType: keyMirrors.clientMessageType.app_version_control,
+        appVersionControl: {
+          baseCommand: keyMirrors.appVersionControl.install,
+          projectId: project,
+          appReleaseHash: releaseHash
+        }
+      }
+    };
+    await deviceAgent.handleClientMessage({ topic, message });
+    while (deviceAgent.getCmdStatus(project) === 'in_progress') {
+      await timer(1000);
     }
-    if (releaseHash === undefined) {
-      throw new CliTerseError('This application has not been published yet');
-    }
-    await installApp({ projectId: project, appReleaseHash: releaseHash });
+    deviceAgent.stop();
   }
 });
 
@@ -110,7 +116,7 @@ export const getAppStatusCliLeaf = CliLeaf({
   async action(_, opts) {
     const { project } = opts;
     const appStatus = await getAppStatus({ projectId: project });
-    logger.info(appStatus);
+    logger.info(JSON.stringify(appStatus, null, 2));
   }
 });
 
@@ -205,6 +211,7 @@ export const rollbackAppCliLeaf = CliLeaf({
       required: true
     })
   },
+  hidden: true,
   async action(_, opts) {
     const { project } = opts;
     await rollbackApp({ projectId: project });
@@ -238,11 +245,38 @@ export const addModelCliLeaf = CliLeaf({
     model: CliStringInput({
       description: 'Model ID',
       required: true
+    }),
+    version: CliStringInput({
+      description: 'Model version',
+      required: true
     })
   },
   async action(_, opts) {
-    const { project, model } = opts;
-    await addModel({ projectId: project, modelId: model });
+    const { project, model, version } = opts;
+    const deviceAgent = new DeviceAgentCloudConnection();
+    await deviceAgent.setupHandlers();
+
+    const topic = deviceAgent.getShadowTopics().projects.updateDelta;
+
+    const newAppCfg = await readAppCfgFile({ projectId: project });
+    newAppCfg.models[model] = Number(version);
+
+    const message = {
+      version: 3,
+      timestamp: 0,
+      state: {
+        [project]: {
+          appConfig: JSON.stringify(newAppCfg)
+        }
+      },
+      clientToken: 'not-self'
+    };
+
+    await deviceAgent.handleMessage(topic, message);
+    while (deviceAgent.getCmdStatus(project) === 'in_progress') {
+      await timer(1000);
+    }
+    deviceAgent.stop();
   }
 });
 

package/src/subcommands/device/clean.ts

@@ -1,5 +1,5 @@
 import { CliLeaf } from '@alwaysai/alwayscli';
-import * as rimraf from 'rimraf';
+import { rimraf } from 'rimraf';
 import { LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/constants';
 import { logger } from '../../util/logger';
 import { AgentConfigFile } from '../../infrastructure/agent-config';
@@ -12,15 +12,15 @@ export const cleanCliLeaf = CliLeaf({
   async action(_, opts) {
     logger.info('Cleaning device configuration');
     logger.debug(`Removing ${LOCAL_CERT_AND_KEY_DIR}`);
-    rimraf.sync(LOCAL_CERT_AND_KEY_DIR);
+    await rimraf(LOCAL_CERT_AND_KEY_DIR);
     logger.debug(`Removing ${AgentConfigFile().path}`);
     AgentConfigFile().remove();
     logger.debug(`Removing ${DeviceConfigFile().path}`);
     DeviceConfigFile().remove();
     logger.debug(`Removing ${CREDENTIALS_FILE_PATH}`);
-    rimraf.sync(CREDENTIALS_FILE_PATH);
+    await rimraf(CREDENTIALS_FILE_PATH);
     logger.debug(`Removing ${APP_ROOT}`);
-    rimraf.sync(APP_ROOT);
+    await rimraf(APP_ROOT);
     logger.info('Device configuration cleaned');
   }
 });

package/src/subcommands/device/device.ts

@@ -1,7 +1,5 @@
 import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
-import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
 import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
-import { checkPaidPlan } from 'alwaysai/lib/core/project';
 import { v4 as uuidv4 } from 'uuid';
 import { CliAuthenticationClient } from 'alwaysai/lib/infrastructure';
 import { existsSync } from 'fs';
@@ -22,6 +20,7 @@ import {
 import { writeTokenAndDeviceCfg } from '../../infrastructure/tokens-and-device-cfg';
 import { logger } from '../../util/logger';
 import { DeviceConfigFile } from 'alwaysai/lib/core/device';
+import { requireLoggedInAndPaidPlan } from '../../util/require-logged-in-and-paid-plan';
 
 export const initCliLeaf = CliLeaf({
   name: 'init',
@@ -29,7 +28,7 @@ export const initCliLeaf = CliLeaf({
   namedInputs: {
     name: CliStringInput({
       description: 'Device name',
-      required: true
+      required: false
     }),
     description: CliStringInput({
       description: 'Device description',
@@ -37,19 +36,16 @@ export const initCliLeaf = CliLeaf({
     })
   },
   async action(_, opts) {
-    const { name, description } = opts;
+    let { name } = opts;
+    name = name || uuidv4();
+
     if (DeviceConfigFile().exists() || existsSync(getPrivateKeyFilePath())) {
       throw new Error(
         "Device has been previously provisioned. Run 'aai-agent device clean' to re-provision"
       );
     }
     logger.info(`Initializing device ${name}`);
-    await checkUserIsLoggedInComponent({ yes: true });
-    if (!(await checkPaidPlan())) {
-      throw new Error(
-        `This action only supported for Enterprise alwaysAI accounts!`
-      );
-    }
+    await requireLoggedInAndPaidPlan();
     const { username } = await CliAuthenticationClient().getInfo();
     const hardwareId = await getTargetHardwareUuid(JsSpawner());
     const device = {
@@ -60,6 +56,7 @@ export const initCliLeaf = CliLeaf({
       friendlyName: name
     };
 
+    // FIXME: Use JSON schema to validate input
     const response: { deviceUuid: string; claimCertificate: string[] } =
       await microServiceHttpClient(
         'fleet-provision',
@@ -69,7 +66,7 @@ export const initCliLeaf = CliLeaf({
       );
     logger.debug(`addDevice Response: ${JSON.stringify(response, null, 2)}`);
 
-    if (!Object.hasOwn(response, 'claimCertificate')) {
+    if (!('claimCertificate' in response)) {
       throw new Error(
         "Device cannot be provisioned. Run 'aai-agent device clean' and retry."
       );

package/src/subcommands/login.ts

@@ -1,6 +1,5 @@
 import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
 import { alwaysaiUserLoginYesComponent } from 'alwaysai/lib/components/user';
-import { writeTokenAndDeviceCfg } from '../infrastructure/tokens-and-device-cfg';
 
 export const loginCliLeaf = CliLeaf({
   name: 'login',
@@ -13,21 +12,14 @@ export const loginCliLeaf = CliLeaf({
     password: CliStringInput({
       description: 'Account password',
       required: true
-    }),
-    device: CliStringInput({
-      description: 'The device UUID',
-      required: false
     })
   },
   async action(_, opts) {
-    const { email, password, device } = opts;
+    const { email, password } = opts;
 
     await alwaysaiUserLoginYesComponent({
       alwaysaiUserEmail: email,
       alwaysaiUserPassword: password
     });
-    if (device) {
-      await writeTokenAndDeviceCfg({ deviceUuid: device });
-    }
   }
 });

package/src/util/fetch-with-timeout.ts

@@ -0,0 +1,18 @@
+import nodeFetch from 'node-fetch';
+
+export async function fetchWithTimeout(
+  url: string,
+  options: { timeout?: number } = {}
+) {
+  //time (ms)
+  const { timeout = 60000 } = options;
+
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  const response = await nodeFetch(url, {
+    ...options,
+    signal: controller.signal
+  });
+  clearTimeout(id);
+  return response;
+}

package/src/util/require-logged-in-and-paid-plan.ts

@@ -0,0 +1,16 @@
+import { checkPaidPlan } from 'alwaysai/lib/core/project';
+import { CliAuthenticationClient } from 'alwaysai/lib/infrastructure';
+
+export async function requireLoggedInAndPaidPlan() {
+  // FIXME: Remove this requirement
+  if (!CliAuthenticationClient().isSignedIn()) {
+    throw new Error('You must be logged in to run this command!');
+  }
+  // FIXME: This also requires Cognito and should be replaced by a check in
+  // microServiceHttpClient()
+  if (!(await checkPaidPlan())) {
+    throw new Error(
+      `This action only supported for Enterprise alwaysAI accounts!`
+    );
+  }
+}

package/src/util/timer.ts

@@ -0,0 +1 @@
+export const timer = (ms: number) => new Promise((res) => setTimeout(res, ms));