@alwaysai/device-agent 0.0.12 → 0.0.14

package/src/subcommands/app/app.ts

@@ -2,17 +2,15 @@ import {
   CliLeaf,
   CliStringArrayInput,
   CliStringInput,
-  CliTerseError,
+  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,
@@ -21,10 +19,12 @@ import {
   startApp,
   stopApp,
   uninstallApp,
-  updateModels,
+  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',
@@ -33,7 +33,7 @@ export const listAppsCliLeaf = CliLeaf({
   async action(_, opts) {
     const apps = await AgentConfigFile().getApps();
     console.table(apps);
-  },
+  }
 });
 
 export const listAppReleasesCliLeaf = CliLeaf({
@@ -42,14 +42,13 @@ export const listAppReleasesCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      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!');
+  }
 });
 
 export const listAppLatestReleaseCliLeaf = CliLeaf({
@@ -58,17 +57,13 @@ export const listAppLatestReleaseCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      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!');
+  }
 });
 
 export const installAppCliLeaf = CliLeaf({
@@ -77,23 +72,36 @@ export const installAppCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
+      required: true
     }),
     releaseHash: CliStringInput({
       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();
+  }
 });
 
 export const getAppStatusCliLeaf = CliLeaf({
@@ -102,14 +110,14 @@ export const getAppStatusCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
     const appStatus = await getAppStatus({ projectId: project });
-    logger.info(appStatus);
-  },
+    logger.info(JSON.stringify(appStatus, null, 2));
+  }
 });
 
 export const startAppCliLeaf = CliLeaf({
@@ -118,16 +126,16 @@ export const startAppCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
+      required: true
     }),
     dockerLoginToken: CliStringInput({
-      description: 'Docker login token',
-    }),
+      description: 'Docker login token'
+    })
   },
   async action(_, opts) {
     const { project, dockerLoginToken } = opts;
     await startApp({ projectId: project, dockerLoginToken });
-  },
+  }
 });
 
 export const getAppLogsCliLeaf = CliLeaf({
@@ -136,8 +144,8 @@ export const getAppLogsCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
@@ -146,7 +154,7 @@ export const getAppLogsCliLeaf = CliLeaf({
     for await (const chunk of readable) {
       logger.info(chunk);
     }
-  },
+  }
 });
 
 export const stopAppCliLeaf = CliLeaf({
@@ -155,13 +163,13 @@ export const stopAppCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
     await stopApp({ projectId: project });
-  },
+  }
 });
 
 export const restartAppCliLeaf = CliLeaf({
@@ -170,13 +178,13 @@ export const restartAppCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
     await restartApp({ projectId: project });
-  },
+  }
 });
 
 export const uninstallAppCliLeaf = CliLeaf({
@@ -185,13 +193,13 @@ export const uninstallAppCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
     await uninstallApp({ projectId: project });
-  },
+  }
 });
 
 export const rollbackAppCliLeaf = CliLeaf({
@@ -200,13 +208,14 @@ export const rollbackAppCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      required: true
+    })
   },
+  hidden: true,
   async action(_, opts) {
     const { project } = opts;
     await rollbackApp({ projectId: project });
-  },
+  }
 });
 
 export const showAppModelsCliLeaf = CliLeaf({
@@ -215,14 +224,14 @@ export const showAppModelsCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
     const appModels = await getAppModels({ projectId: project });
     console.table(appModels);
-  },
+  }
 });
 
 export const addModelCliLeaf = CliLeaf({
@@ -231,17 +240,44 @@ export const addModelCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
+      required: true
     }),
     model: CliStringInput({
       description: 'Model ID',
-      required: true,
+      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();
+  }
 });
 
 export const removeModelCliLeaf = CliLeaf({
@@ -250,17 +286,17 @@ export const removeModelCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project ID',
-      required: true,
+      required: true
     }),
     model: CliStringInput({
       description: 'Model ID',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project, model } = opts;
     await removeModel({ projectId: project, modelId: model });
-  },
+  }
 });
 
 export const replaceModelsCliLeaf = CliLeaf({
@@ -269,17 +305,17 @@ export const replaceModelsCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project Id',
-      required: true,
+      required: true
     }),
     models: CliStringArrayInput({
       description: 'One or more model IDs',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project, models } = opts;
     await replaceModels({ projectId: project, modelIds: models });
-  },
+  }
 });
 
 export const updateModelsCliLeaf = CliLeaf({
@@ -288,13 +324,13 @@ export const updateModelsCliLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project Id',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
     await updateModels({ projectId: project });
-  },
+  }
 });
 
 export const getAllEnvsCLiLeaf = CliLeaf({
@@ -303,13 +339,13 @@ export const getAllEnvsCLiLeaf = CliLeaf({
   namedInputs: {
     project: CliStringInput({
       description: 'Project Id',
-      required: true,
-    }),
+      required: true
+    })
   },
   async action(_, opts) {
     const { project } = opts;
     logger.info(await getAllEnvs({ projectId: project }));
-  },
+  }
 });
 
 export const setEnvCLiLeaf = CliLeaf({
@@ -317,21 +353,21 @@ export const setEnvCLiLeaf = CliLeaf({
   description: 'Set environment variables for a service',
   positionalInput: CliStringArrayInput({
     placeholder: '<NAME=VALUE> [<NAME=VALUE> ...]',
-    required: true,
+    required: true
   }),
   namedInputs: {
     project: CliStringInput({
       description: 'Project Id',
-      required: true,
+      required: true
     }),
     service: CliStringInput({
       description:
         'The name of the docker-compose service to apply environment variable to',
-      required: false,
-    }),
+      required: false
+    })
   },
   async action(args, opts) {
     const { project, service } = opts;
     await setEnv({ projectId: project, vars: args, service });
-  },
+  }
 });

package/src/subcommands/app/index.ts

@@ -17,7 +17,7 @@ import {
   replaceModelsCliLeaf,
   showAppModelsCliLeaf,
   getAllEnvsCLiLeaf,
-  setEnvCLiLeaf,
+  setEnvCLiLeaf
 } from './app';
 
 export const appCliBranch = CliBranch({
@@ -41,6 +41,6 @@ export const appCliBranch = CliBranch({
     replaceModelsCliLeaf,
     updateModelsCliLeaf,
     getAllEnvsCLiLeaf,
-    setEnvCLiLeaf,
-  ],
+    setEnvCLiLeaf
+  ]
 });

package/src/subcommands/device/clean.ts

@@ -0,0 +1,26 @@
+import { CliLeaf } from '@alwaysai/alwayscli';
+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';
+import { DeviceConfigFile } from 'alwaysai/lib/core/device';
+import { APP_ROOT, CREDENTIALS_FILE_PATH } from '../../util/directories';
+
+export const cleanCliLeaf = CliLeaf({
+  name: 'clean',
+  description: 'Remove all provisioning files',
+  async action(_, opts) {
+    logger.info('Cleaning device configuration');
+    logger.debug(`Removing ${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}`);
+    await rimraf(CREDENTIALS_FILE_PATH);
+    logger.debug(`Removing ${APP_ROOT}`);
+    await rimraf(APP_ROOT);
+    logger.info('Device configuration cleaned');
+  }
+});

package/src/subcommands/device/device.ts

@@ -1,100 +1,113 @@
-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 { httpClient, microServiceHttpClient } from "../../util/http-client";
+import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
+import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
+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,
-} from "../../util/directories";
+  getPrivateKeyFilePath
+} from '../../util/directories';
 
-import { LOCAL_CERT_AND_KEY_DIR } from "alwaysai/lib/constants";
-import fetch from "node-fetch";
-import { JsSpawner } from "alwaysai/lib/util";
+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 {
-  getTargetHardwareUuid,
-  writeCertificateAndToken,
-} from "../../infrastructure/certificates-and-tokens";
-import { logger } from "../../util/logger";
+  getMemUtil
+} from '../../device-control/device-control';
+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",
-  description: "Initialize device",
+  name: 'init',
+  description: 'Initialize device',
   namedInputs: {
     name: CliStringInput({
-      description: "Device name",
-      required: true,
+      description: 'Device name',
+      required: false
     }),
     description: CliStringInput({
-      description: "Device description",
-      required: false,
-    }),
+      description: 'Device description',
+      required: false
+    })
   },
   async action(_, opts) {
-    const { name, description } = opts;
-    logger.info("Initializing device");
-    await checkUserIsLoggedInComponent({ yes: true });
-    if (!(await checkPaidPlan())) {
+    let { name } = opts;
+    name = name || uuidv4();
+
+    if (DeviceConfigFile().exists() || existsSync(getPrivateKeyFilePath())) {
       throw new Error(
-        `This action only supported for Enterprise alwaysAI accounts!`
+        "Device has been previously provisioned. Run 'aai-agent device clean' to re-provision"
       );
     }
+    logger.info(`Initializing device ${name}`);
+    await requireLoggedInAndPaidPlan();
     const { username } = await CliAuthenticationClient().getInfo();
-    const spawner = JsSpawner();
-    const hardwareId = await getTargetHardwareUuid(spawner);
+    const hardwareId = await getTargetHardwareUuid(JsSpawner());
     const device = {
-      deviceMode: "production",
+      deviceMode: 'production',
       hardwareId,
       txId: uuidv4(),
       userName: username,
-      friendlyName: name,
+      friendlyName: name
     };
 
-    const response = await microServiceHttpClient(
-      "fleet-provision",
-      "addDevice",
-      "POST",
-      JSON.stringify(device)
-    );
+    // FIXME: Use JSON schema to validate input
+    const response: { deviceUuid: string; claimCertificate: string[] } =
+      await microServiceHttpClient(
+        'fleet-provision',
+        'addDevice',
+        'POST',
+        JSON.stringify(device)
+      );
+    logger.debug(`addDevice Response: ${JSON.stringify(response, null, 2)}`);
 
+    if (!('claimCertificate' in response)) {
+      throw new Error(
+        "Device cannot be provisioned. Run 'aai-agent device clean' and retry."
+      );
+    }
     const ROOT_CERT_AWS = await httpClient(
-      "https://www.amazontrust.com/repository/AmazonRootCA1.pem",
-      "GET"
+      'https://www.amazontrust.com/repository/AmazonRootCA1.pem',
+      'GET',
+      {}
     );
 
-    await writeCertificateAndToken({ deviceUuid: response.deviceUuid });
+    await writeTokenAndDeviceCfg({
+      deviceUuid: response.deviceUuid
+    });
 
-    await JsSpawner().mkdirp(BOOTSTRAP_CERTIFICATES_DIR_PATH);
-    JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR }).writeFile(
+    await JsSpawner().mkdirp(BOOTSTRAP_CERTIFICATES_DIR_PATH());
+
+    await JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR }).writeFile(
       AWS_ROOT_CERTIFICATE_FILE_NAME,
       ROOT_CERT_AWS
     );
-    const certSpawner = JsSpawner({ path: BOOTSTRAP_CERTIFICATES_DIR_PATH });
+    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}`);
-  },
+    logger.info(`Initialized device ${name}: UUID=${response.deviceUuid}`);
+  }
 });
 
 export const getInfoCliLeaf = CliLeaf({
-  name: "get-info",
-  description: "Get device info",
+  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())} %`],
+      ['CPU Utilization', `${String(await getCpuUtil())} %`],
+      ['Disk Utilization', `${String(await getDiskUtil())} %`],
+      ['Memory Utilization', `${String(await getMemUtil())} %`]
     ];
     console.table(deviceInfo);
-  },
+  }
 });

package/src/subcommands/device/index.ts

@@ -1,8 +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],
+  subcommands: [initCliLeaf, getInfoCliLeaf, cleanCliLeaf]
 });

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

@@ -10,17 +10,17 @@ export const getModelPackageCliLeaf = CliLeaf({
   positionalInput: CliStringInput({
     description: 'For example, "alwaysai/mobilenet_ssd"',
     required: true,
-    placeholder: '<id>',
+    placeholder: '<id>'
   }),
   namedInputs: {
     version: CliNumberInput({
       description: 'The version number of the model',
-      required: false,
+      required: false
     }),
     path: CliStringInput({
       description: 'The output path to write model package to',
-      required: false,
-    }),
+      required: false
+    })
   },
   async action(id, opts) {
     const path = opts.path || process.cwd();
@@ -29,5 +29,5 @@ export const getModelPackageCliLeaf = CliLeaf({
       opts.version || (await CliRpcClient().getModelVersion({ id })).version;
     await appInstallModel(spawner, id, version);
     logger.info(`Completed downloading ${id} to ${path}`);
-  },
+  }
 });