@alwaysai/device-agent 0.0.3 → 0.0.5

package/src/constants.ts

@@ -1,32 +0,0 @@
-import { 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 DEV_HOST_TOKEN_DIR = join(homedir(), '.config', 'alwaysai');
-export const DEVICE_TOKEN_DIR_LINUX = posix.join('~', '.config', 'alwaysai');
-
-export const DEV_HOST_CERT_AND_KEY_DIR = join(DEV_HOST_TOKEN_DIR, 'certificates');
-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/subcommands/device-control.ts

@@ -1,16 +0,0 @@
-import { CliLeaf } from '@alwaysai/alwayscli';
-import { getCpuUtil, getDiskUtil, getMemUtil } from '../device-control/device-control';
-
-export const getDeviceInfoCliLeaf = CliLeaf({
-  name: 'get-device-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/test-app.ts

@@ -1,30 +0,0 @@
-import { CliLeaf, CliStringInput, CliTerseError } from '@alwaysai/alwayscli';
-const path = require('path');
-import { installApp } from '../application-control/application-control';
-import { JsSpawner } from '../util/spawner/js-spawner';
-
-// export const installTestAppCliLeaf = CliLeaf({
-//   name: 'install-test-app',
-//   description: 'Install a test application',
-//   namedInputs: {
-//     project: CliStringInput({
-//       description: 'Project Id',
-//     }),
-//     version: CliStringInput({
-//       description: 'Version',
-//     }),
-//   },
-//   async action(_, opts) {
-//     const { project, version } = opts;
-//     const postfix = Math.random()
-//       .toString()
-//       .slice(2, 14);
-//     const projectId = project ? project : `16ad11bb-8c3a-4a15-923e-${postfix}`;
-//     const releaseVersion = version ? version : 'f43e816b30aa612f103fe73314f9716a436ce4f5';
-//     // Package test app
-//     const appDir = path.join('test', 'test-app');
-//     const spawner = JsSpawner({ path: appDir });
-//     const appPkg = await spawner.tar(...(await spawner.readdir()));
-//     await installApp({ projectId, appPkg, version: releaseVersion });
-//   },
-// });

package/src/util/spawner/gnu-spawner.ts

@@ -1,114 +0,0 @@
-import { Spawner } from './types';
-import { CodedError } from '@carnesen/coded-error';
-const { Readable } = require('stream');
-
-export function GnuSpawner(context: {
-  resolvePath: Spawner['resolvePath'];
-  run: Spawner['run'];
-  runForegroundSync: Spawner['runForegroundSync'];
-  runForeground: Spawner['runForeground'];
-  runStreaming: Spawner['runStreaming'];
-}): Spawner {
-  const { resolvePath, run, runForegroundSync, runForeground, runStreaming } = context;
-
-  return {
-    run,
-    runForegroundSync,
-    runForeground,
-    runStreaming,
-    resolvePath,
-    readdir,
-    async readFile(path) {
-      const output = await run({
-        exe: 'cat',
-        args: [resolvePath(path)],
-      });
-      return output;
-    },
-    async writeFile(path, data) {
-      await run({
-        exe: 'dd',
-        args: [`of=${resolvePath(path)}`],
-        input: Readable.from(data),
-      });
-    },
-    async rename(oldPath, newPath) {
-      await run({
-        exe: 'mv',
-        args: [resolvePath(oldPath), resolvePath(newPath)],
-      });
-    },
-    mkdirp,
-    rimraf,
-    sanatizedrimraf,
-    tar,
-    untar,
-    exists,
-  };
-
-  async function mkdirp(path?: string) {
-    await run({ exe: 'mkdir', args: ['-p', resolvePath(path)] });
-  }
-
-  async function readdir(path?: string) {
-    let output: string;
-    const resolvedPath = resolvePath(path);
-    try {
-      output = await run({ exe: 'ls', args: ['-A1', resolvedPath] });
-      // ^^ The output looks like '/foo/bar.txt' if path is an existing file
-      // Else it looks like 'a b c' if the path is a directory with files/subdirs a, b, c.
-    } catch (ex) {
-      if (
-        ex &&
-        typeof ex.message === 'string' &&
-        ex.message.includes('No such file or directory')
-      ) {
-        ex.code = 'ENOENT';
-      }
-      throw ex;
-    }
-    if (output.startsWith('/')) {
-      throw new CodedError(`ENOTDIR: not a directory "${resolvedPath}"`, 'ENOTDIR');
-    }
-    return output.length > 0 ? output.split('\n') : [];
-  }
-
-  async function rimraf(path?: string) {
-    await run({ exe: 'rm', args: ['-rf', resolvePath(path)] });
-  }
-
-  async function sanatizedrimraf(path?: string) {
-    const sanatizedPath = resolvePath(path).replace('*', '');
-
-    await run({ exe: 'rm', args: ['-rf', sanatizedPath] });
-  }
-
-  async function tar(...paths: string[]) {
-    return await runStreaming({
-      exe: 'tar',
-      args: ['-cz', ...paths],
-      cwd: resolvePath(),
-    });
-  }
-
-  async function untar(input: NodeJS.ReadableStream, cwd = '.') {
-    await run({
-      exe: 'tar',
-      args: ['-xz'],
-      cwd,
-      input,
-    });
-  }
-
-  async function exists(path: string) {
-    if (!path) {
-      throw new Error('"path" is required');
-    }
-    try {
-      await run({ exe: 'stat', args: [resolvePath(path)] });
-      return true;
-    } catch (ex) {
-      return false;
-    }
-  }
-}

package/src/util/spawner/js-spawner.ts

@@ -1,110 +0,0 @@
-import {
-  readdir as fsReaddir,
-  access as fsAccess,
-  readFile as fsReadFile,
-  writeFile as fsWriteFile,
-  rename as fsRename,
-} from 'fs';
-
-import { promisify } from 'util';
-import { isAbsolute, resolve } from 'path';
-
-import * as tarJs from 'tar';
-import * as mkdirpJs from 'mkdirp';
-import * as rimrafJs from 'rimraf';
-
-import { Spawner, Cmd } from './types';
-import { SpawnerBase } from '../spawner-base';
-import { GnuSpawner } from './gnu-spawner';
-import pump = require('pump');
-
-export function JsSpawner(context: { path?: string } = {}): Spawner {
-  const gnuSpawner = GnuSpawner({ resolvePath, ...SpawnerBase(translate) });
-  return {
-    ...gnuSpawner,
-    resolvePath,
-    readdir,
-    async readFile(path) {
-      return await promisify(fsReadFile)(resolvePath(path), { encoding: 'utf8' });
-    },
-    async writeFile(path, data) {
-      await promisify(fsWriteFile)(resolvePath(path), data, { encoding: 'utf8' });
-    },
-    mkdirp,
-    rimraf,
-    tar,
-    async rename(oldPath, newPath) {
-      await promisify(fsRename)(resolvePath(oldPath), resolvePath(newPath));
-    },
-    async untar(input, cwd) {
-      await new Promise<string | void>((resolve, reject) => {
-        const writable = tarJs.extract({ cwd: resolvePath(cwd) });
-        pump(input, writable, err => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      });
-    },
-    exists,
-  };
-
-  function resolvePath(...paths: (string | undefined)[]) {
-    return resolve(context.path || '', ...paths.map(path => path || ''));
-  }
-
-  function translate(cmd: Cmd) {
-    if (cmd.superuser) {
-      throw new Error(`${JsSpawner.name} does not support cmd option "superuser"`);
-    }
-    const translated: Cmd = {
-      ...cmd,
-    };
-
-    if (cmd.cwd) {
-      translated.cwd = resolvePath(cmd.cwd);
-    }
-
-    return translated;
-  }
-
-  async function mkdirp(path = '') {
-    await mkdirpJs(resolvePath(path));
-  }
-
-  async function rimraf(path = '') {
-    await promisify(rimrafJs)(resolvePath(path));
-  }
-
-  function readdir(path = '') {
-    return promisify(fsReaddir)(resolvePath(path));
-  }
-
-  async function tar(...paths: string[]) {
-    for (const path in paths) {
-      if (isAbsolute(path)) {
-        throw new Error('Paths passed to spawner.tar must not be absolute');
-      }
-    }
-    const packageStream = (tarJs.create(
-      { sync: true, gzip: true, cwd: resolvePath() },
-      paths,
-    ) as unknown) as NodeJS.ReadableStream;
-    // ^^ The @types for tar.create are not correct
-    return packageStream;
-  }
-
-  async function exists(path: string) {
-    if (!path) {
-      throw new Error('path is mandatory');
-    }
-    try {
-      await promisify(fsAccess)(resolvePath(path));
-      return true;
-    } catch (ex) {
-      return false;
-    }
-  }
-}

package/src/util/spawner/types.ts

@@ -1,28 +0,0 @@
-export type Cmd = {
-  exe: string;
-  args?: string[];
-  cwd?: string;
-  tty?: boolean;
-  input?: NodeJS.ReadableStream;
-  superuser?: boolean;
-};
-
-export type Translate = (cmd: Cmd) => Cmd;
-
-export type Spawner = {
-  run: (cmd: Cmd) => Promise<string>;
-  runForegroundSync: (cmd: Cmd) => void;
-  runForeground: (cmd: Cmd) => Promise<number | undefined | void>;
-  runStreaming: (cmd: Cmd) => Promise<NodeJS.ReadableStream>;
-  resolvePath: (...paths: (string | undefined)[]) => string;
-  readdir: (path?: string) => Promise<string[]>;
-  readFile: (path: string) => Promise<string>;
-  writeFile: (path: string, data: string) => Promise<void>;
-  mkdirp: (path?: string) => Promise<void>;
-  rename: (oldPath: string, newPath: string) => Promise<void>;
-  rimraf: (path?: string) => Promise<void>;
-  sanatizedrimraf: (path?: string) => Promise<void>;
-  tar: (...paths: string[]) => Promise<NodeJS.ReadableStream>;
-  untar: (input: NodeJS.ReadableStream, cwd?: string) => Promise<void>;
-  exists: (path: string) => Promise<boolean>;
-};

package/src/util/spawner-base/index.ts

@@ -1,28 +0,0 @@
-import { run } from './run';
-import { runForegroundSync } from './run-foreground-sync';
-import { runForeground } from './run-foreground';
-import { runStreaming } from './run-streaming';
-import { Cmd } from '../spawner/types';
-
-export function SpawnerBase(translate: (cmd: Cmd) => Cmd) {
-  return {
-    run(cmd: Cmd) {
-      return run(translate(cmd));
-    },
-    runForeground(cmd: Cmd) {
-      return runForeground(translate(cmd));
-    },
-    runForegroundSync(cmd: Cmd) {
-      return runForegroundSync(translate(cmd));
-    },
-    runStreaming(cmd: Cmd) {
-      return runStreaming(translate(cmd));
-    },
-  };
-}
-
-export const spawnerBase = {
-  run,
-  runForegroundSync,
-  runStreaming,
-};

package/src/util/spawner-base/run-foreground-sync.ts

@@ -1,16 +0,0 @@
-import { spawnSync } from 'child_process';
-const winston = require('winston');
-
-import { Cmd } from '../spawner/types';
-
-export function runForegroundSync(cmd: Cmd) {
-  const optString = cmd.args ? cmd.args.join(' ') : '';
-  winston.debug(`${cmd.exe} ${optString}`);
-  const out = spawnSync(cmd.exe, cmd.args || [], {
-    cwd: cmd.cwd,
-    stdio: 'inherit',
-  });
-  if (out.error) {
-    throw out.error;
-  }
-}

package/src/util/spawner-base/run-foreground.ts

@@ -1,49 +0,0 @@
-import { spawn } from 'child_process';
-import { Cmd } from '../spawner/types';
-import signalExit = require('signal-exit');
-import rKill = require('tree-kill');
-import { CliTerseError } from '@alwaysai/alwayscli';
-import { ALWAYSAI_OS_PLATFORM } from '../../environment';
-
-export async function runForeground(cmd: Cmd) {
-  const childProcess = spawn(cmd.exe, cmd.args || [], {
-    cwd: cmd.cwd,
-    stdio: 'inherit',
-  });
-
-  // Kill child when parent exits
-  signalExit(() => {
-    if (ALWAYSAI_OS_PLATFORM === 'darwin') {
-      childProcess.kill('SIGINT');
-      // ensures the main process gets killed by the correct signal - this will only activate with a ctrl + c
-      // when it hits the siginit it will then activate the on exit signal and finish
-      process.on('SIGINT', () => {
-        if (childProcess.pid !== undefined) {
-          rKill(childProcess.pid, 'SIGINT', (error?: Error | undefined) => {
-            if (error) {
-              throw new CliTerseError(
-                `Failed to kill child process {error.name} {error.message}`,
-              );
-            }
-          });
-        }
-      });
-    } else {
-      childProcess.kill();
-    }
-  });
-
-  return await new Promise<number | undefined | void>((resolve, reject) => {
-    childProcess.on('error', err => {
-      reject(err);
-    });
-
-    childProcess.on('exit', code => {
-      if (code) {
-        resolve(code);
-      } else {
-        resolve();
-      }
-    });
-  });
-}

package/src/util/spawner-base/run-streaming.ts

@@ -1,40 +0,0 @@
-import { spawn } from 'child_process';
-
-import signalExit = require('signal-exit');
-
-import { Cmd } from '../spawner/types';
-
-export function runStreaming(cmd: Cmd) {
-  return new Promise<NodeJS.ReadableStream>((resolve, reject) => {
-    const child = spawn(cmd.exe, cmd.args || [], {
-      cwd: cmd.cwd,
-    });
-
-    signalExit(() => {
-      child.kill();
-    });
-
-    if (cmd.input) {
-      cmd.input.pipe(child.stdin);
-    }
-
-    const errChunks: Buffer[] = [];
-    function stderrChunkHandler(chunk: Buffer) {
-      errChunks.push(chunk);
-    }
-
-    child.stderr.on('data', stderrChunkHandler);
-
-    child.on('error', (err: any) => {
-      if (err && !err.stderr) {
-        err.stderr = Buffer.concat(errChunks).toString();
-      }
-      reject(err);
-    });
-
-    child.stdout.once('readable', () => {
-      resolve(child.stdout);
-      child.stderr.removeListener('data', stderrChunkHandler);
-    });
-  });
-}

package/src/util/spawner-base/run.ts

@@ -1,60 +0,0 @@
-import { spawn } from 'child_process';
-import signalExit = require('signal-exit');
-
-import { CliTerseError } from '@alwaysai/alwayscli';
-
-import { Cmd } from '../spawner/types';
-
-export const PROCESS_EXITED_WITH_NON_ZERO_STATUS_CODE =
-  'Process exited with non-zero status code';
-
-export async function run(cmd: Cmd) {
-  return new Promise<string>((resolve, reject) => {
-    const optString = cmd.args ? cmd.args.join(' ') : '';
-    const child = spawn(cmd.exe, cmd.args || [], { cwd: cmd.cwd });
-    signalExit(() => {
-      child.kill();
-    });
-
-    if (cmd.input) {
-      cmd.input.pipe(child.stdin);
-    }
-
-    // TODO: Limit buffer size
-    const outChunks: Buffer[] = [];
-    const allChunks: Buffer[] = []; // stderr and stdout
-
-    child.stdout.on('data', chunk => {
-      outChunks.push(chunk);
-      allChunks.push(chunk);
-    });
-
-    child.stderr.on('data', chunk => {
-      allChunks.push(chunk);
-    });
-
-    child.on('error', err => {
-      reject(err);
-    });
-
-    child.on('close', code => {
-      if (code === 0) {
-        const str = Buffer.concat(outChunks).toString('utf8');
-        if (str.endsWith('\n')) {
-          resolve(str.slice(0, -1));
-        } else {
-          resolve(str);
-        }
-      } else if (code !== null) {
-        let message = `${PROCESS_EXITED_WITH_NON_ZERO_STATUS_CODE} ${code.toString()}`;
-        message += '\n\n';
-        message += `$ ${cmd.exe} ${cmd.args ? cmd.args.join(' ') : ''}`;
-        message += '\n\n';
-        message += Buffer.concat(allChunks).toString('utf8');
-        reject(new CliTerseError(message));
-      } else {
-        reject(new CliTerseError('Close code is undefined!'));
-      }
-    });
-  });
-}