@corellium/corellium-cli 1.2.0 → 1.2.2

package/src/commands/index.js

@@ -1,13 +1,11 @@
 module.exports = [
   require('./login'),
   require('./logout'),
-  require('./signup'),
   require('./extensions'),
   require('./instances'),
   require('./firmware'),
   require('./images'),
   require('./projects'),
-  require('./agent'),
   require('./webplayer'),
   require('./mast')
 ]

package/src/commands/{agent → instances}/apps/index.js

@@ -21,16 +21,16 @@ async function builder (yargs) {
     demandOption: true,
     string: true,
     validateNonEmpty
-  }).option('loadIcons', {
+  }).option('load-icons', {
     type: 'input',
     describe: 'Toggle loading of icons',
     demandOption: false,
     boolean: true
   }).option('format', {
     type: 'input',
-    describe: 'Output format (default is table) e.g. json',
+    describe: 'Output format (default is json) e.g. table',
     string: true,
-    choices: ['json', 'csv']
+    choices: ['table', 'json', 'csv']
   }).command(InstallCommand)
 }
 

package/src/commands/instances/create.js

@@ -1,5 +1,9 @@
 const { handleError } = require('../../error')
-const { getApi, waitForState } = require('../../utils')
+const {
+  getApi, waitForState,
+  waitForAgentReady
+} = require('../../utils')
+const AgentCLI = require('../../clients/Agent')
 
 async function builder (yargs) {
   yargs
@@ -10,9 +14,9 @@ async function builder (yargs) {
     })
     .option('format', {
       type: 'input',
-      describe: 'Output format (default is table) e.g. json',
+      describe: 'Output format (default is json) e.g. table',
       string: true,
-      choices: ['json', 'csv']
+      choices: ['table', 'json', 'csv']
     })
     .positional('flavor', {
       type: 'string',
@@ -53,6 +57,8 @@ async function handler (argv) {
     // Wait 360 attempts for the instance to be created (30 minutes)
     if (argv.wait) {
       await waitForState(instance.id, api.v1GetInstance.bind(api), 'on', 360)
+      const agent = new AgentCLI({ instance: instance.id })
+      await waitForAgentReady(agent, 360)
     }
     console.log(instance.id)
   } catch (err) {

package/src/commands/{agent → instances}/file.js

@@ -22,9 +22,9 @@ async function builder (yargs) {
     validateNonEmpty
   }).option('format', {
     type: 'input',
-    describe: 'Output format (default is table) e.g. json',
+    describe: 'Output format (default is json) e.g. table',
     string: true,
-    choices: ['json', 'csv']
+    choices: ['table', 'json', 'csv']
   })
 }
 

package/src/commands/instances/index.js

@@ -6,7 +6,11 @@ const subcommands = [
   require('./start'),
   require('./upgrade'),
   require('./netmon'),
-  require('./restoreBackup')
+  require('./restoreBackup'),
+  require('./ready'),
+  require('./file'),
+  require('./apps'),
+  require('./input')
 ]
 
 let _yargs
@@ -17,3 +21,4 @@ module.exports = {
   command: 'instance',
   describe: 'Instance related commands'
 }
+module.exports.subcommands = subcommands

package/src/commands/instances/input.js

@@ -0,0 +1,52 @@
+
+const { readFile } = require('node:fs/promises')
+const InstanceCLI = require('../../clients/Instance')
+const { handleError } = require('../../error')
+const chalk = require('chalk')
+
+/**
+ * Upload input to a device.
+ *
+ * @param yargs
+ * @returns {Promise<void>}
+ */
+async function builder (yargs) {
+  yargs
+    .positional('instance', {
+      type: 'string',
+      demandOption: true,
+      describe: 'virtual device id',
+      default: process.env.INSTANCE
+    })
+    .positional('file', {
+      type: 'string',
+      demandOption: true,
+      describe: 'JSON file of device inputs'
+      // Input specification https://app.corellium.com/api/docs#post-/v1/instances/-instanceId-/input
+    })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'console will receive verbose error output',
+      default: false
+    })
+}
+
+async function handler (argv) {
+  const { file, verbose } = argv
+  const client = new InstanceCLI(argv)
+  try {
+    const json = JSON.parse((await readFile(file)).toString())
+    await client.input(json)
+    console.log(chalk.green('Successfully uploaded inputs'))
+  } catch (error) {
+    handleError(error, 'input failed', verbose)
+  }
+}
+
+module.exports = {
+  builder,
+  handler,
+  command: 'input <instance> <file>',
+  describe: 'Upload a series of inputs to a device.'
+}

package/src/commands/instances/list.js

@@ -12,9 +12,9 @@ async function builder (yargs) {
     describe: 'Optionally filter by project name'
   }).option('format', {
     type: 'input',
-    describe: 'Output format (default is table) e.g. json',
+    describe: 'Output format (default is json) e.g. table',
     string: true,
-    choices: ['json', 'csv']
+    choices: ['table', 'json', 'csv']
   })
 }
 
@@ -42,5 +42,6 @@ module.exports = {
   builder,
   handler,
   command: 'list',
+  aliases: ['ls'],
   describe: 'List instances'
 }

package/src/commands/instances/upgrade.js

@@ -30,9 +30,9 @@ async function builder (yargs) {
     })
     .option('format', {
       type: 'input',
-      describe: 'Output format (default is table) e.g. json',
+      describe: 'Output format (default is json) e.g. table',
       string: true,
-      choices: ['json', 'csv'],
+      choices: ['table', 'json', 'csv'],
       demandOption: false
     })
     .option('wait', {

package/src/commands/projects/create.js

@@ -11,9 +11,9 @@ async function builder (yargs) {
   })
     .option('format', {
       type: 'input',
-      describe: 'Output format (default is table) e.g. json',
+      describe: 'Output format (default is json) e.g. table',
       string: true,
-      choices: ['json', 'csv']
+      choices: ['table', 'json', 'csv']
     })
     .positional('name', {
       type: 'input',

package/src/commands/projects/delete.js

@@ -44,6 +44,7 @@ async function handler (argv) {
 module.exports = {
   builder,
   handler,
-  command: 'delete [projectId]',
+  command: 'delete <projectId>',
+  aliases: ['rm', 'del'],
   describe: 'Delete project by id'
 }

package/src/commands/projects/list.js

@@ -9,9 +9,9 @@ async function builder (yargs) {
     describe: 'Console will receive verbose error output'
   }).option('format', {
     type: 'input',
-    describe: 'Output format (default is table) e.g. json',
+    describe: 'Output format (default is json) e.g. table',
     string: true,
-    choices: ['json', 'csv']
+    choices: ['table', 'json', 'csv']
   })
 }
 
@@ -29,5 +29,6 @@ module.exports = {
   builder,
   handler,
   command: 'list',
+  aliases: ['ls'],
   describe: 'List projects'
 }

package/src/commands/webplayer/create.js

@@ -40,9 +40,9 @@ async function builder (yargs) {
     validateNonEmpty
   }).option('format', {
     type: 'input',
-    describe: 'Output format (default is json)',
+    describe: 'Output format (default is json) e.g. table',
     string: true,
-    choices: ['json', 'csv']
+    choices: ['table', 'json', 'csv']
   })
 }
 

package/src/commands/webplayer/list.js

@@ -21,9 +21,9 @@ async function builder (yargs) {
     string: true
   }).option('format', {
     type: 'input',
-    describe: 'Output format (default is table) e.g. json',
+    describe: 'Output format (default is json) e.g. table',
     string: true,
-    choices: ['json', 'csv']
+    choices: ['table', 'json', 'csv']
   })
 }
 

package/src/error.js

@@ -12,18 +12,24 @@ function getUserErrorMessage (body) {
   }
   return ''
 }
+
 function getErrorMessage (error) {
-  return (error.body && error.body.error)
-    ? `${error.body.error} ${getUserErrorMessage(error.body)}`
-    : (error.error && error.error.message)
-        ? error.error.message
-        : error
+  const { body, response, error: errorObject } = error
+  if (body && body.error) {
+    return `${body.error} ${getUserErrorMessage(body)}`
+  } else if (response && response.data && response.data.error) {
+    return `${response.data.error} ${getUserErrorMessage(response.data)}`
+  } else if (errorObject && errorObject.message) {
+    return errorObject.message
+  } else {
+    return error.message
+  }
 }
 
 function handleError (error, customMessage, detailed) {
   const errorMessage = getErrorMessage(error)
   console.error(`${customMessage}: ${errorMessage}`)
-  if (detailed) { log.error(error) }
+  if (detailed) { log.error(JSON.stringify(error.body || error.response?.data || error.message, null, 2)) }
   process.exit(1)
 }
 

package/src/table.js

@@ -1,7 +1,7 @@
 const { table } = require('table')
 const log = require('./logging')
 
-async function displayTable (format, data, filteredFields, columnWidths) {
+async function displayTable (format = 'json', data, filteredFields, columnWidths) {
   if (format === 'json') {
     const displayJson = JSON.stringify(data, null, 2)
     log.plain(displayJson)

package/src/utils.js

@@ -1,4 +1,3 @@
-const generator = require('generate-password')
 const CorelliumClient = require('@corellium/client-api')
 const {
   readProfile,
@@ -11,43 +10,6 @@ const https = require('https')
 
 const waitForIntervalMilliSec = 5000
 
-const planOptions = (planId) => {
-  let usageBased = false
-  let cores, licenseType
-  let m = /^(individual)-cloud-(\d+)-device(?:-(\d+)-month){0,1}$/.exec(planId)
-  if (m) {
-    licenseType = m[1]
-    const devicesStr = m[2]
-    cores = parseInt(devicesStr) * 2
-  } else if (m = /^(enterprise|standard)-cloud-(\d+)-core(?:-(\d+)-month){0,1}$/.exec(planId)) { /* eslint-disable-line no-cond-assign */
-    licenseType = m[1]
-    const coresStr = m[2]
-    cores = parseInt(coresStr)
-  } else if (m = /^(enterprise|individual)-cloud-usage-based$/.exec(planId)) { /* eslint-disable-line no-cond-assign */
-    usageBased = true
-    if (m[1] === 'enterprise') {
-      licenseType = 'enterprise-usage'
-      cores = 200
-    } else if (m[1] === 'individual') {
-      licenseType = 'individual-usage'
-      cores = 100
-    }
-  }
-  return {
-    licenseType: /** @type {LicenseType} */ (licenseType),
-    cores,
-    usageBased
-  }
-}
-
-const makePassword = () => {
-  return generator.generate({
-    length: 15,
-    numbers: true,
-    excludeSimilarCharacters: true
-  })
-}
-
 const sleep = (milliseconds) => {
   return new Promise((resolve) => setTimeout(resolve, milliseconds))
 }
@@ -63,6 +25,24 @@ const waitForState = async (instanceId, fn, state, attempts = 20, reporterFn = n
   }
 }
 
+const waitForAgentReady = async (agent, attempts = 20) => {
+  while (attempts > 0) {
+    try {
+      const status = await agent.ready()
+      if (status.ready) {
+        return // Agent is ready, exit the function
+      }
+    } catch (error) {
+      // We don't need to log any errors
+    }
+    // Wait before retrying
+    await sleep(waitForIntervalMilliSec)
+    attempts--
+  }
+  // If max attempts reached and agent is still not ready, throw an error
+  throw new Error('Agent did not become ready within the specified number of attempts.')
+}
+
 const waitForTaskState = async (instanceId, fn, taskState, attempts = 20) => {
   let response = await fn(instanceId)
 
@@ -162,10 +142,9 @@ async function reRequestInsecure (endpoint) {
 const validateNonEmpty = (input) => input !== ''
 
 module.exports = {
-  planOptions,
-  makePassword,
   waitForState,
   waitForTaskState,
+  waitForAgentReady,
   getApi,
   getAxios,
   validateNonEmpty,

package/node_modules/@jridgewell/trace-mapping/src/any-map.ts

@@ -1,166 +0,0 @@
-import { TraceMap, presortedDecodedMap, decodedMappings } from './trace-mapping';
-import {
-  COLUMN,
-  SOURCES_INDEX,
-  SOURCE_LINE,
-  SOURCE_COLUMN,
-  NAMES_INDEX,
-} from './sourcemap-segment';
-
-import type {
-  Section,
-  SectionedSourceMap,
-  DecodedSourceMap,
-  SectionedSourceMapInput,
-} from './types';
-import type { SourceMapSegment } from './sourcemap-segment';
-
-type AnyMap = {
-  new (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
-  (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
-};
-
-export const AnyMap: AnyMap = function (map, mapUrl) {
-  const parsed =
-    typeof map === 'string' ? (JSON.parse(map) as Exclude<SectionedSourceMapInput, string>) : map;
-
-  if (!('sections' in parsed)) return new TraceMap(parsed, mapUrl);
-
-  const mappings: SourceMapSegment[][] = [];
-  const sources: string[] = [];
-  const sourcesContent: (string | null)[] = [];
-  const names: string[] = [];
-
-  recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
-
-  const joined: DecodedSourceMap = {
-    version: 3,
-    file: parsed.file,
-    names,
-    sources,
-    sourcesContent,
-    mappings,
-  };
-
-  return presortedDecodedMap(joined);
-} as AnyMap;
-
-function recurse(
-  input: SectionedSourceMap,
-  mapUrl: string | null | undefined,
-  mappings: SourceMapSegment[][],
-  sources: string[],
-  sourcesContent: (string | null)[],
-  names: string[],
-  lineOffset: number,
-  columnOffset: number,
-  stopLine: number,
-  stopColumn: number,
-) {
-  const { sections } = input;
-  for (let i = 0; i < sections.length; i++) {
-    const { map, offset } = sections[i];
-
-    let sl = stopLine;
-    let sc = stopColumn;
-    if (i + 1 < sections.length) {
-      const nextOffset = sections[i + 1].offset;
-      sl = Math.min(stopLine, lineOffset + nextOffset.line);
-
-      if (sl === stopLine) {
-        sc = Math.min(stopColumn, columnOffset + nextOffset.column);
-      } else if (sl < stopLine) {
-        sc = columnOffset + nextOffset.column;
-      }
-    }
-
-    addSection(
-      map,
-      mapUrl,
-      mappings,
-      sources,
-      sourcesContent,
-      names,
-      lineOffset + offset.line,
-      columnOffset + offset.column,
-      sl,
-      sc,
-    );
-  }
-}
-
-function addSection(
-  input: Section['map'],
-  mapUrl: string | null | undefined,
-  mappings: SourceMapSegment[][],
-  sources: string[],
-  sourcesContent: (string | null)[],
-  names: string[],
-  lineOffset: number,
-  columnOffset: number,
-  stopLine: number,
-  stopColumn: number,
-) {
-  if ('sections' in input) return recurse(...(arguments as unknown as Parameters<typeof recurse>));
-
-  const map = new TraceMap(input, mapUrl);
-  const sourcesOffset = sources.length;
-  const namesOffset = names.length;
-  const decoded = decodedMappings(map);
-  const { resolvedSources, sourcesContent: contents } = map;
-
-  append(sources, resolvedSources);
-  append(names, map.names);
-  if (contents) append(sourcesContent, contents);
-  else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
-
-  for (let i = 0; i < decoded.length; i++) {
-    const lineI = lineOffset + i;
-
-    // We can only add so many lines before we step into the range that the next section's map
-    // controls. When we get to the last line, then we'll start checking the segments to see if
-    // they've crossed into the column range. But it may not have any columns that overstep, so we
-    // still need to check that we don't overstep lines, too.
-    if (lineI > stopLine) return;
-
-    // The out line may already exist in mappings (if we're continuing the line started by a
-    // previous section). Or, we may have jumped ahead several lines to start this section.
-    const out = getLine(mappings, lineI);
-    // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
-    // map can be multiple lines), it doesn't.
-    const cOffset = i === 0 ? columnOffset : 0;
-
-    const line = decoded[i];
-    for (let j = 0; j < line.length; j++) {
-      const seg = line[j];
-      const column = cOffset + seg[COLUMN];
-
-      // If this segment steps into the column range that the next section's map controls, we need
-      // to stop early.
-      if (lineI === stopLine && column >= stopColumn) return;
-
-      if (seg.length === 1) {
-        out.push([column]);
-        continue;
-      }
-
-      const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
-      const sourceLine = seg[SOURCE_LINE];
-      const sourceColumn = seg[SOURCE_COLUMN];
-      out.push(
-        seg.length === 4
-          ? [column, sourcesIndex, sourceLine, sourceColumn]
-          : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]],
-      );
-    }
-  }
-}
-
-function append<T>(arr: T[], other: T[]) {
-  for (let i = 0; i < other.length; i++) arr.push(other[i]);
-}
-
-function getLine<T>(arr: T[][], index: number): T[] {
-  for (let i = arr.length; i <= index; i++) arr[i] = [];
-  return arr[index];
-}

package/node_modules/@jridgewell/trace-mapping/src/binary-search.ts

@@ -1,115 +0,0 @@
-import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment';
-import { COLUMN } from './sourcemap-segment';
-
-export type MemoState = {
-  lastKey: number;
-  lastNeedle: number;
-  lastIndex: number;
-};
-
-export let found = false;
-
-/**
- * A binary search implementation that returns the index if a match is found.
- * If no match is found, then the left-index (the index associated with the item that comes just
- * before the desired index) is returned. To maintain proper sort order, a splice would happen at
- * the next index:
- *
- * ```js
- * const array = [1, 3];
- * const needle = 2;
- * const index = binarySearch(array, needle, (item, needle) => item - needle);
- *
- * assert.equal(index, 0);
- * array.splice(index + 1, 0, needle);
- * assert.deepEqual(array, [1, 2, 3]);
- * ```
- */
-export function binarySearch(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  low: number,
-  high: number,
-): number {
-  while (low <= high) {
-    const mid = low + ((high - low) >> 1);
-    const cmp = haystack[mid][COLUMN] - needle;
-
-    if (cmp === 0) {
-      found = true;
-      return mid;
-    }
-
-    if (cmp < 0) {
-      low = mid + 1;
-    } else {
-      high = mid - 1;
-    }
-  }
-
-  found = false;
-  return low - 1;
-}
-
-export function upperBound(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  index: number,
-): number {
-  for (let i = index + 1; i < haystack.length; index = i++) {
-    if (haystack[i][COLUMN] !== needle) break;
-  }
-  return index;
-}
-
-export function lowerBound(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  index: number,
-): number {
-  for (let i = index - 1; i >= 0; index = i--) {
-    if (haystack[i][COLUMN] !== needle) break;
-  }
-  return index;
-}
-
-export function memoizedState(): MemoState {
-  return {
-    lastKey: -1,
-    lastNeedle: -1,
-    lastIndex: -1,
-  };
-}
-
-/**
- * This overly complicated beast is just to record the last tested line/column and the resulting
- * index, allowing us to skip a few tests if mappings are monotonically increasing.
- */
-export function memoizedBinarySearch(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  state: MemoState,
-  key: number,
-): number {
-  const { lastKey, lastNeedle, lastIndex } = state;
-
-  let low = 0;
-  let high = haystack.length - 1;
-  if (key === lastKey) {
-    if (needle === lastNeedle) {
-      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
-      return lastIndex;
-    }
-
-    if (needle >= lastNeedle) {
-      // lastIndex may be -1 if the previous needle was not found.
-      low = lastIndex === -1 ? 0 : lastIndex;
-    } else {
-      high = lastIndex;
-    }
-  }
-  state.lastKey = key;
-  state.lastNeedle = needle;
-
-  return (state.lastIndex = binarySearch(haystack, needle, low, high));
-}