@alwaysai/device-agent 0.0.2

package/src/application-control/application-control.ts

@@ -0,0 +1,233 @@
+import compose from 'docker-compose';
+import * as rimraf from 'rimraf';
+import * as fs from 'fs';
+
+import { runDockerLogin } from '../docker/docker-cmd';
+import { JsSpawner } from '../util/spawner/js-spawner';
+import { copyDir } from '../util/copy-dir';
+import {
+  APP_ROOT,
+  buildApp,
+  getAppDir,
+  getAppVersion,
+  isAppInstalled,
+  setAppVersion,
+} from './utils';
+
+const BACKUP_EXT = '.bak';
+
+export type AppDetails = { projectId: string; version: string };
+
+export async function getInstalledApps(): Promise<AppDetails[]> {
+  const projectIds = fs.readdirSync(APP_ROOT).filter(file => {
+    const isDir = fs.statSync(`${APP_ROOT}/${file}`).isDirectory();
+    const isBak = `${APP_ROOT}/${file}`.includes(BACKUP_EXT);
+    return isDir && !isBak;
+  });
+
+  const appDetails: AppDetails[] = [];
+  for (const projectId of projectIds) {
+    const appDir = getAppDir(projectId);
+    const version = await getAppVersion({ appDir });
+    appDetails.push({ projectId, version });
+  }
+  return appDetails;
+}
+
+async function createAppBackup(props: { projectId: string }) {
+  const { projectId } = props;
+  const appDir = getAppDir(projectId);
+  const backupAppDir = `${appDir}${BACKUP_EXT}`;
+  await copyDir({ srcPath: appDir, destPath: backupAppDir });
+  console.log(`Backed up app ${projectId} to ${backupAppDir}`);
+}
+
+export async function rollbackApp(props: { projectId: string }) {
+  const { projectId } = props;
+  const appDir = getAppDir(projectId);
+  const backupAppDir = `${appDir}${BACKUP_EXT}`;
+  if (!fs.existsSync(backupAppDir)) {
+    throw new Error(`Backup doesn't exist for ${projectId}`);
+  }
+  rimraf.sync(appDir);
+  await copyDir({ srcPath: `${appDir}${BACKUP_EXT}`, destPath: appDir });
+  await buildApp({ appDir });
+  console.log(`Rolled back app ${projectId} to previous version`);
+}
+
+export async function installApp(props: {
+  projectId: string;
+  appPkg: NodeJS.ReadableStream;
+  version: string;
+}): Promise<void> {
+  const { projectId, appPkg, version } = props;
+  console.log(`Installing ${projectId}`);
+  const appDir = getAppDir(projectId);
+  const spawner = JsSpawner();
+  // TODO Check valid projectId
+  // Check if app is installed
+  if (await isAppInstalled({ appDir })) {
+    console.log('Application is already installed, updating');
+    await createAppBackup({ projectId });
+    await spawner.rimraf(appDir);
+  }
+  // Create app directory
+  await spawner.mkdirp(appDir);
+
+  // Unpack app package and move to install dir
+  await spawner.untar(appPkg, appDir);
+  console.log(`Unpacked application to ${appDir}`);
+
+  await setAppVersion({ appDir, version });
+
+  await buildApp({ appDir });
+
+  console.log(`Installed ${projectId} to ${appDir}`);
+}
+
+export type ServiceState = 'Stopped' | 'Up' | 'Restarting';
+export type ServiceStatus = { name: string; state: ServiceState };
+export type AppStatus = { appDetails: AppDetails; services: ServiceStatus[] };
+
+export async function getAppStatus(props: { projectId: string }): Promise<AppStatus> {
+  const { projectId } = props;
+  const appDir = getAppDir(projectId);
+
+  if (!(await isAppInstalled({ appDir }))) {
+    throw new Error('Application is not installed');
+  }
+
+  // Check if app is running
+  const output = await compose.ps({ cwd: appDir });
+  if (output.exitCode !== 0) {
+    throw new Error(
+      `Failed to get application status! stdout=${output.out} stderr=${output.err}`,
+    );
+  }
+
+  const appDetails = { projectId, version: await getAppVersion({ appDir }) };
+  const services: ServiceStatus[] = [];
+  if (output.data.services.length === 0) {
+    // If the app has never been started (or has an empty docker-compose.yaml)
+    // the list will be empty.
+    services.push({ name: '', state: 'Stopped' });
+  } else {
+    for (const service of output.data.services) {
+      // Container name has the format:
+      // <projectId>_name_<number>
+      const matchProjectId = new RegExp(`^${projectId}`);
+      const name = service.name
+        .replace(matchProjectId, '')
+        .replace(/\d+$/, '')
+        .replace(/_/g, '');
+
+      let state: ServiceState;
+      if (service.state.includes('Up')) {
+        state = 'Up';
+      } else if (service.state.includes('Stopped') || service.state.includes('Exit')) {
+        state = 'Stopped';
+      } else if (service.state.includes('Restarting')) {
+        state = 'Restarting';
+      } else {
+        throw new Error(`Unknown state for service! (${service.state})`);
+      }
+      services.push({ name, state });
+    }
+  }
+  return { appDetails, services };
+}
+
+export async function getAppLogs(props: {
+  projectId: string;
+  services?: string[];
+}): Promise<NodeJS.ReadableStream> {
+  const { projectId, services } = props;
+  const appDir = getAppDir(projectId);
+
+  if (!(await isAppInstalled({ appDir }))) {
+    throw new Error('Application is not installed');
+  }
+
+  const serviceList = services
+    ? services
+    : await (async function() {
+        const appStatus = await getAppStatus({ projectId });
+        const services: string[] = [];
+        for (const service of appStatus.services) {
+          services.push(service.name);
+        }
+        return services;
+      })();
+
+  // Use direct command with spawner in order to get a readable stream
+  return await JsSpawner().runStreaming({
+    exe: 'docker-compose',
+    args: ['logs', '-f', ...serviceList],
+    cwd: appDir,
+  });
+}
+
+export async function startApp(props: {
+  projectId: string;
+  dockerLoginToken?: string;
+}): Promise<void> {
+  const { projectId, dockerLoginToken } = props;
+  const appDir = getAppDir(projectId);
+  // Check if app is installed
+  if (!(await isAppInstalled({ appDir }))) {
+    throw new Error('Application is not installed');
+  }
+  if (dockerLoginToken !== undefined) {
+    const result = await runDockerLogin({ token: dockerLoginToken });
+    console.log(result);
+  }
+
+  // TODO: Check if app is running
+  // Start app
+  const upOut = await compose.upAll({ cwd: appDir });
+  console.log(upOut);
+  if (upOut.exitCode !== 0) {
+    throw new Error(
+      `Failed to start application! stdout=${upOut.out} stderr=${upOut.err}`,
+    );
+  }
+  console.log('Started', projectId);
+}
+
+export async function stopApp(props: { projectId: string }): Promise<void> {
+  const { projectId } = props;
+  const appDir = getAppDir(projectId);
+  // Check if app is installed
+  if (!(await isAppInstalled({ appDir }))) {
+    console.log('Application is not installed');
+    return;
+  }
+  // TODO: Check if app is running
+  // Stop app
+  const output = await compose.down({ cwd: appDir });
+  console.log(output);
+  if (output.exitCode !== 0) {
+    throw new Error(
+      `Failed to stop application! stdout=${output.out} stderr=${output.err}`,
+    );
+  }
+  console.log('Stopped', projectId);
+}
+
+export async function uninstallApp(props: { projectId: string }): Promise<void> {
+  const { projectId } = props;
+  const appDir = getAppDir(projectId);
+  if (!(await isAppInstalled({ appDir }))) {
+    console.log(`Application ${projectId} not installed`);
+    return;
+  }
+  try {
+    await stopApp({ projectId });
+  } catch {
+    console.log('Failed to stop app, may be left running...');
+  }
+  // Delete application directory and backup
+  rimraf.sync(appDir);
+  rimraf.sync(`${appDir}${BACKUP_EXT}`);
+  console.log('Uninstalled', projectId);
+}

package/src/application-control/models.ts

@@ -0,0 +1,40 @@
+import { runCliCmd } from '../util/run-cli-cmd';
+import { buildApp, getAppDir, isAppInstalled } from './utils';
+
+export async function addModel(props: { projectId: string; modelId: string }) {
+  const { projectId, modelId } = props;
+  const appDir = getAppDir(projectId);
+  if (!(await isAppInstalled({ appDir }))) {
+    throw new Error('Application is not installed');
+  }
+  await runCliCmd({
+    cmd: ['app', 'models', 'add', modelId],
+    cwd: appDir,
+  });
+  await buildApp({ appDir });
+}
+
+export async function removeModel(props: { projectId: string; modelId: string }) {
+  const { projectId, modelId } = props;
+  const appDir = getAppDir(projectId);
+  if (!(await isAppInstalled({ appDir }))) {
+    throw new Error('Application is not installed');
+  }
+  await runCliCmd({
+    cmd: ['app', 'models', 'remove', modelId],
+    cwd: appDir,
+  });
+}
+
+export async function updateModels(props: { projectId: string }) {
+  const { projectId } = props;
+  const appDir = getAppDir(projectId);
+  if (!(await isAppInstalled({ appDir }))) {
+    throw new Error('Application is not installed');
+  }
+  await runCliCmd({
+    cmd: ['app', 'models', 'update'],
+    cwd: appDir,
+  });
+  await buildApp({ appDir });
+}

package/src/application-control/utils.ts

@@ -0,0 +1,64 @@
+import compose from 'docker-compose';
+import * as path from 'path';
+import * as fs from 'fs';
+
+import { JsSpawner } from '../util/spawner/js-spawner';
+import { DOT_ALWAYSAI_DIR } from '../constants';
+import { runCliCmd } from '../util/run-cli-cmd';
+
+export const APP_ROOT = path.join(DOT_ALWAYSAI_DIR, 'applications');
+const RELEASE_FILENAME = 'alwaysai.release.json';
+const DOCKER_COMPOSE_FILENAME = 'docker-compose.yaml';
+
+export function getAppDir(projectId: string): string {
+  return path.join(APP_ROOT, projectId);
+}
+
+export async function isAppInstalled(props: { appDir: string }): Promise<boolean> {
+  const { appDir } = props;
+  // TODO: Could do more sophisticated check
+  if (fs.existsSync(appDir)) {
+    return true;
+  }
+  return false;
+}
+
+export async function setAppVersion(props: { appDir: string; version: string }) {
+  const { appDir, version } = props;
+  // TODO: Switch to node-config
+  const versionPath = path.join(appDir, RELEASE_FILENAME);
+  const versionData = { version };
+  await JsSpawner().writeFile(versionPath, JSON.stringify(versionData, null, 2));
+}
+
+export async function getAppVersion(props: { appDir: string }) {
+  const { appDir } = props;
+  const versionPath = path.join(appDir, RELEASE_FILENAME);
+  const releaseData = JSON.parse(await JsSpawner().readFile(versionPath));
+  return releaseData.version;
+}
+
+export async function buildApp(props: { appDir: string }) {
+  const { appDir } = props;
+  await runCliCmd({
+    cmd: ['app', 'configure', '--yes', '--protocol', 'docker:'],
+    cwd: appDir,
+  });
+  await runCliCmd({ cmd: ['app', 'install', '--yes', '--clean', '--pull'], cwd: appDir });
+
+  // Build standalone image and docker-compose
+  if (!fs.existsSync(path.join(appDir, DOCKER_COMPOSE_FILENAME))) {
+    await runCliCmd({
+      cmd: ['app', 'deploy', '--yes', '--generateDockerCompose'],
+      cwd: appDir,
+    });
+  }
+
+  const buildOut = await compose.buildAll({ cwd: appDir });
+  console.log(buildOut);
+  if (buildOut.exitCode !== 0) {
+    throw new Error(
+      `Failed to build application! stdout=${buildOut.out} stderr=${buildOut.err}`,
+    );
+  }
+}

package/src/constants.ts

@@ -0,0 +1,29 @@
+import { resolve, join, posix } from 'path';
+import { homedir } from 'os';
+const os = require('os');
+const path = require('path');
+
+export const ALWAYSAI_CLI_EXECUTABLE_NAME = 'aai-agent';
+export const DOT_ALWAYSAI_DIR = join(homedir(), '.alwaysai');
+export const AAI_DIR = path.join(os.homedir(), '.alwaysai');
+
+export const DEVICE_TOKEN_FILE_NAME = 'alwaysai.credentials.json';
+export const DEVICE_CONFIG_FILE_NAME = 'alwaysai.config.json';
+
+export const DEVICE_TOKEN_DIR_LINUX = posix.join('~', '.config', 'alwaysai');
+export const DEVICE_CERT_AND_KEY_DIR_LINUX = posix.join(
+  DEVICE_TOKEN_DIR_LINUX,
+  'certificates',
+);
+
+export const DEVICE_CERTIFICATE_FILE_NAME = 'alwaysai.certificate.pem.crt';
+export const DEVICE_PRIVATE_KEY_FILE_NAME = 'alwaysai.private.pem.key';
+export const DEVICE_PUBLIC_KEY_FILE_NAME = 'alwaysai.public.pem.key';
+export const DEVICE_ROOT_CERT_FILE_NAME = 'alwaysai.root.pem';
+
+export const SUPPORTED_JETPACK_VERSION = 4.4;
+export const JETPACK_IMAGE_LINK =
+  'https://developer.nvidia.com/jetson-nano-sd-card-image-44';
+
+export const PLEASE_REPORT_THIS_ERROR_MESSAGE =
+  'Please report this error message to support@alwaysai.co';

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 '../util/spawner/js-spawner';
+
+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 '../util/spawner/js-spawner';
+
+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/environment.ts

@@ -0,0 +1,20 @@
+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);
+
+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,18 @@
+#!/usr/bin/env node
+
+// This file is the entry point for when this package is run as a CLI. 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 { runWebInterface } from './web/web-interface';
+
+if (module === require.main) {
+  console.log('Starting alwaysAI Device Agent');
+  if (process.env.ALWAYSAI_DEVICE_AGENT_MODE === 'cli') {
+    runCliAndExit(root, {});
+  } else {
+    runWebInterface();
+  }
+}

package/src/root.ts

@@ -0,0 +1,18 @@
+const winston = require('winston');
+
+import { CliBranch } from '@alwaysai/alwayscli';
+
+import { subcommands } from './subcommands';
+import { ALWAYSAI_CLI_EXECUTABLE_NAME } from './constants';
+
+winston.configure({
+  level: process.env.AAI_LOG_LEVEL || 'info',
+  transports: [new winston.transports.Console()],
+  format: winston.format.simple(),
+});
+
+export const root = CliBranch({
+  name: ALWAYSAI_CLI_EXECUTABLE_NAME,
+  description: 'Manage your alwaysAI production device',
+  subcommands,
+});

package/src/subcommands/app/app.ts

@@ -0,0 +1,216 @@
+import { CliLeaf, CliStringInput, CliTerseError } from '@alwaysai/alwayscli';
+import {
+  getAppLogs,
+  getAppStatus,
+  getInstalledApps,
+  installApp,
+  rollbackApp,
+  startApp,
+  stopApp,
+  uninstallApp,
+} from '../../application-control/application-control';
+import { addModel, removeModel, updateModels } from '../../application-control/models';
+
+export const listAppsCliLeaf = CliLeaf({
+  name: 'list',
+  description: 'List all installed apps',
+  namedInputs: {},
+  async action(_, opts) {
+    const apps = await getInstalledApps();
+    console.table(apps);
+  },
+});
+
+export const installAppCliLeaf = CliLeaf({
+  name: 'install',
+  description: 'Install an alwaysAI app from a project',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+    dockerComposeFile: CliStringInput({
+      description: 'Contents of the docker compose file',
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    if (project === undefined) {
+      throw new CliTerseError('--project is required');
+    }
+    // await installApp({ projectId: project, appPkg });
+    throw new CliTerseError('Install not yet implemented!');
+  },
+});
+
+export const getAppStatusCliLeaf = CliLeaf({
+  name: 'status',
+  description: 'Get the status of an installed alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    if (project === undefined) {
+      throw new CliTerseError('--project is required');
+    }
+    const appStatus = await getAppStatus({ projectId: project });
+    console.log(appStatus);
+  },
+});
+
+export const startAppCliLeaf = CliLeaf({
+  name: 'start',
+  description: 'Start an installed alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+    dockerLoginToken: CliStringInput({
+      description: 'Docker login token',
+    }),
+  },
+  async action(_, opts) {
+    const { project, dockerLoginToken } = opts;
+    if (project === undefined) {
+      throw new CliTerseError('--project is required');
+    }
+    await startApp({ projectId: project, dockerLoginToken });
+  },
+});
+
+export const getAppLogsCliLeaf = CliLeaf({
+  name: 'logs',
+  description: 'Get logs for an application',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+  },
+  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) {
+      console.log(chunk);
+    }
+  },
+});
+
+export const stopAppCliLeaf = CliLeaf({
+  name: 'stop',
+  description: 'Stop a running alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    if (project === undefined) {
+      throw new CliTerseError('Project ID is required');
+    }
+    await stopApp({ projectId: project });
+  },
+});
+
+export const uninstallAppCliLeaf = CliLeaf({
+  name: 'uninstall',
+  description: 'Remove an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    if (project === undefined) {
+      throw new CliTerseError('Project ID is required');
+    }
+    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',
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    if (project === undefined) {
+      throw new CliTerseError('Project ID is required');
+    }
+    await rollbackApp({ projectId: project });
+  },
+});
+
+export const addModelCliLeaf = CliLeaf({
+  name: 'add-model',
+  description: 'Add a model to an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+    model: CliStringInput({
+      description: 'Model Id',
+    }),
+  },
+  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 });
+  },
+});
+
+export const removeModelCliLeaf = CliLeaf({
+  name: 'remove-model',
+  description: 'Remove a model from an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+    model: CliStringInput({
+      description: 'Model Id',
+    }),
+  },
+  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 updateModelsCliLeaf = CliLeaf({
+  name: 'update-models',
+  description: 'Update all models for an alwaysAI app',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    if (project === undefined) {
+      throw new CliTerseError('--project is required');
+    }
+    await updateModels({ projectId: project });
+  },
+});