@corellium/corellium-cli 1.0.3 → 1.0.6

package/src/table.js

@@ -6,8 +6,13 @@ async function displayTable (format, data, filteredFields, columnWidths) {
     const displayJson = JSON.stringify(data, null, 2)
     log.plain(displayJson)
   } else {
-    let rows = data.map(i => {
-      return filteredFields.map(key => `${i[key]}`)
+    let rows = data.map(d => {
+      return filteredFields.map(field => {
+        // Not perfect, but this is to avoid the [object Object] scenario for json fields in DB
+        return typeof d[field] === 'object' && d[field] !== null
+          ? JSON.stringify(d[field])
+          : d[field]
+      })
     })
 
     if (format === 'csv') {

package/src/upload.js

@@ -1,7 +1,69 @@
-const images = require('@corellium/corellium-api/src/images')
+const fs = require('fs')
+const path = require('path')
+const util = require('util')
+const Resumable = require('./resumable')
 const { basename } = require('path')
 const { getErrorMessage } = require('./error')
 
+class File {
+  constructor ({ filePath, type, size }) {
+    this.path = filePath
+    this.name = path.basename(filePath)
+    this.type = type
+    this.size = size
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  slice (start, end, _contentType) {
+    return fs.createReadStream(this.path, { start, end })
+  }
+}
+
+async function uploadFile (token, url, filePath, progress) {
+  return new Promise((resolve, reject) => {
+    const r = new Resumable({
+      target: url,
+      headers: {
+        authorization: token,
+        'x-corellium-image-encoding': 'plain'
+      },
+      uploadMethod: 'PUT',
+      chunkSize: 5 * 1024 * 1024,
+      prioritizeFirstAndLastChunk: true,
+      method: 'octet'
+    })
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    r.on('fileAdded', (_file) => {
+      r.upload()
+    })
+
+    r.on('progress', () => {
+      if (progress) progress(r.progress())
+    })
+
+    r.on('fileError', (_file, message) => {
+      reject(message)
+    })
+
+    r.on('fileSuccess', (_file, message) => {
+      resolve(JSON.parse(message))
+    })
+
+    return util
+      .promisify(fs.stat)(filePath)
+      .then((stat) => {
+        const file = new File({
+          filePath: filePath,
+          type: 'application/octet-stream',
+          size: stat.size
+        })
+
+        r.addFile(file)
+      })
+  })
+}
+
 async function uploadWithProgress (url, token, file, multi) {
   const fileName = basename(file)
 
@@ -13,7 +75,7 @@ async function uploadWithProgress (url, token, file, multi) {
   })
 
   try {
-    const res = await images.uploadFile(
+    const res = await uploadFile(
       token,
       url,
       file,

package/src/utils.js

@@ -9,6 +9,8 @@ axios.defaults.headers.common['User-Agent'] = `corellium-cli v${require('../pack
 const superagent = require('superagent')
 const https = require('https')
 
+const waitForIntervalMilliSec = 5000
+
 const planOptions = (planId) => {
   let usageBased = false
   let cores, licenseType
@@ -50,11 +52,14 @@ const sleep = (milliseconds) => {
   return new Promise((resolve) => setTimeout(resolve, milliseconds))
 }
 
-const waitForState = async (instanceId, fn, state, attempts = 20) => {
+const waitForState = async (instanceId, fn, state, attempts = 20, reporterFn = null) => {
   const response = await fn(instanceId)
+  if (typeof reporterFn === 'function') {
+    reporterFn(response)
+  }
   if (response.state !== state && attempts > 0) {
-    await sleep(5000)
-    await waitForState(instanceId, fn, state, --attempts)
+    await sleep(waitForIntervalMilliSec)
+    await waitForState(instanceId, fn, state, --attempts, reporterFn)
   }
 }
 
@@ -143,5 +148,7 @@ module.exports = {
   getApi,
   getAxios,
   validateNonEmpty,
-  getCACert
+  getCACert,
+  sleep,
+  waitForIntervalMilliSec
 }

package/test/test.js

@@ -0,0 +1,89 @@
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const path = require('path')
+const execp = promisify(exec)
+const assert = require('node:assert').strict
+
+test()
+  .catch(e => console.error(e))
+
+async function test () {
+  await testProjects()
+  await testInstances()
+}
+
+async function testInstances () {
+  const projectId = (await ej('project create --cores 20 --instances 10 --ram 5000 CoolNewProject'))[0].id
+
+  const { state, id: instanceId } = (await ej(`instance create ranchu 12.0.0 ${projectId}`))[0]
+  assert.equal(state, 'creating')
+
+  const instances = await ej('instance list')
+  assert.ok(instances.map(p => p.id).includes(instanceId))
+  // TODO: instance stop
+  // TODO: instance start
+  await e(`instance delete ${instanceId}`)
+
+  await pollUntilNoThrow(instanceId)
+
+  // Cleanup
+  await e(`project delete ${projectId}`)
+}
+
+async function testProjects () {
+  const { id: projectId } = (await ej('project create --cores 10 --instances 2 --ram 2000 CoolNewProject'))[0]
+
+  // The list has the newly created project in it
+  let projects = await ej('project list')
+  assert.ok(projects.map(p => p.id).includes(projectId))
+
+  await e(`project delete ${projectId}`)
+
+  // The list has no longer has the project
+  projects = await ej('project list')
+  assert.equal(-1, projects.map(p => p.id).indexOf(projectId))
+}
+
+async function sleep (ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function pollUntilNoThrow (instanceId, tries = 1) {
+  if (tries > 10) {
+    return
+  }
+  console.log(`try ${tries} looking for ${instanceId}`)
+
+  try {
+    const instances = await ej('instance list')
+    assert.equal(-1, instances.map(i => i.id).indexOf(instanceId))
+  } catch (err) {
+    if (err.code === 'ERR_ASSERTION') {
+      const ms = 1 + Math.random() * (2 ** tries * 10)
+      await sleep(ms)
+      await pollUntilNoThrow(instanceId, tries + 1)
+    } else {
+      throw err
+    }
+  }
+}
+
+// short for "execJSON"
+// Used to exec things we want the return value of
+async function ej (s) {
+  const { stdout, stderr } = await execp(`node index.js ${s} --format json`, { cwd: path.join(__dirname, '../') })
+  if (stderr) {
+    console.log(stderr)
+  }
+  return JSON.parse(stdout)
+}
+
+// short for "exec"
+// Used mainly for deletes, which have no --format flag and return no parseable data (204, generally)
+async function e (s) {
+  const { stdout, stderr } = await execp(`node index.js ${s}`, { cwd: path.join(__dirname, '../') })
+  if (stderr) {
+    console.log(stderr)
+  }
+  return stdout
+}

package/example/WebPlayerSample.js

@@ -1,263 +0,0 @@
-#!/usr/bin/env node
-
-const path = require('path')
-const asciiArt = require('../node_modules/ascii-art')
-const { exec } = require('child_process')
-const { promisify } = require('util')
-const execp = promisify(exec)
-
-require('dotenv').config()
-
-const endpoint = process.env.ENDPOINT
-const username = process.env.USERNAME
-const password = process.env.PASSWORD
-const project = process.env.PROJECT
-const flavor = process.env.FLAVOR
-const version = process.env.VERSION
-const apitoken = process.env.APIKEY // Admin's API token
-const expiration = 15 * 60 // seconds (15 minutes), Set < 15 mins to test automatic token renewal
-let projectId, instanceId
-
-const frontendFeatureSet = {
-  apps: true,
-  connect: true,
-  console: true,
-  coretrace: true,
-  deviceControl: true,
-  deviceDelete: true,
-  files: true,
-  frida: true,
-  images: true,
-  messaging: true,
-  netmon: true,
-  network: true,
-  portForwarding: true,
-  powerManagement: true,
-  profile: true,
-  sensors: true,
-  settings: true,
-  snapshots: true,
-  strace: true,
-  system: true
-}
-const features = JSON.stringify(JSON.stringify(frontendFeatureSet))
-
-const execOptions = { cwd: path.join(__dirname, '../.') }
-
-/**
- * Return a timestamp as delta T formatted -> mm:ss.msec
- * @return {string}
- */
-const INFO_COLOR = 'green'
-const CMD_COLOR = 'magenta'
-const ERROR_COLOR = 'red'
-const TIMESTAMP_COLOR = 'cyan'
-const startTime = new Date().getTime()
-const ts = () => asciiArt.style(new Date((new Date().getTime() - startTime)).toISOString().slice(14, 23) + ':', TIMESTAMP_COLOR, true)
-/**
- * Logging with timestamp
- * @param args
- */
-const logInfo = (...args) => {
-  args.unshift(ts())
-  console.log.bind(console, ...args)()
-}
-
-const logResult = (...args) => {
-  args.unshift(asciiArt.style('', INFO_COLOR))
-  args.unshift(ts())
-  args[2] = '\b' + args[2]
-  args.push(asciiArt.style('', INFO_COLOR, true))
-  console.log.bind(console, ...args)()
-}
-
-const logError = (...args) => {
-  args.unshift(asciiArt.style('', ERROR_COLOR))
-  args.unshift(ts())
-  args[2] = '\b' + args[2]
-  args.push(asciiArt.style('', ERROR_COLOR, true))
-  console.error.bind(console, ...args)()
-}
-
-/**
- * Execute a command on the local host
- * @param {string} cmd
- * @return {Promise<{stdout, stderr}>}
- */
-async function execLocal (cmd) {
-  logInfo(asciiArt.style('[CorelliumCLI] ' + cmd, CMD_COLOR, true))
-  let { stdout, stderr } = await execp(cmd, execOptions)
-  stdout = stdout && stdout.trim()
-  stderr = stderr && stderr.trim()
-  // if (stdout && stdout.length) logResult('[execLocal] stdout.:', stdout)
-  // if (stderr && stderr.length) logError('[execLocal] stderr.:', stderr)
-  return { stdout, stderr }
-}
-
-/**
- * Parse command results
- * @param {any} data
- * @returns {any}
- */
-const parse = (data) => { try { return JSON.parse(data) } catch (_e) { return data } }
-
-/**
- * List All Web Players
- */
-const listSessions = async (sessionId) => {
-  const session = sessionId ? ` --session ${sessionId}` : ''
-  const { stdout } = await execLocal(`node index.js webplayer list --project ${projectId}${session} --format json`)
-  const sessions = parse(stdout)
-  if (Array.isArray(sessions)) {
-    logResult('Existing WebPlayers:', sessions.map(s => s.identifier))
-  } else {
-    logError('[listSessions]', sessions)
-  }
-}
-
-// Find project by name or identifier
-const findProject = async (id) => {
-  const { stdout: result } = await execLocal('node index.js project list --format json')
-  // logInfo(result)
-  const projects = parse(result)
-  if (Array.isArray(projects)) {
-    const proj = projects.find(p => p.id === id || p.name === id)
-    if (!proj) {
-      throw new Error(`Could not find project ${id}`)
-    }
-    logResult(`Found project ${proj.id} - ${proj.name}`)
-    return proj
-  }
-}
-
-/**
- * @return {Promise<object | undefined>}
- */
-const createInstance = async () => {
-  const { stdout: result } = await execLocal(`node index.js instance create ${flavor} ${version} ${projectId} --format json`)
-  logResult(`"${result}"`)
-  try {
-    const instances = parse(result)
-    if (Array.isArray(instances)) {
-      return instances[0]
-    }
-  } catch (err) {
-    console.error(err)
-  }
-}
-
-const findInstance = async (id) => {
-  let { stdout: result } = await execLocal(`node index.js instance list --project ${projectId} --format json`)
-  // logResult(`"${result}"`)
-  if (result === '') { result = '[]' }
-  const instances = parse(result)
-  if (Array.isArray(instances)) {
-    const inst = instances.find(i => i.id === id || i.name === id || i.flavor === id)
-    if (inst) {
-      logInfo(`Found instance ${inst.id} - ${inst.name || inst.flavor}`)
-      return inst
-    }
-    return await createInstance()
-  }
-}
-
-const startInstance = async () => {
-  let { stdout: result } = await execLocal(`node index.js instance list --project ${projectId} --format json`)
-  // logResult(`"${result}"`)
-  const instances = parse(result)
-  if (Array.isArray(instances)) {
-    const inst = instances.find(i => i.id === instanceId)
-    if (!inst) {
-      throw new Error(`Could not find instance ${instanceId}`)
-    }
-    logInfo(`Found instance ${instanceId} - ${inst.name || inst.flavor}`)
-    if (inst.state === 'on') {
-      logInfo(`${inst.name || inst.flavor} is ON`)
-    } else {
-      logInfo(`${inst.name || inst.flavor} is OFF. Turning on ${inst.name || inst.flavor}...`);
-      ({ stdout: result } = await execLocal(`node index.js instance start ${instanceId}`))
-      logInfo(result)
-    }
-  }
-  // Kind of a lie, but this is a good place for this msg because...
-  // if the instance has just started, the agent can take an uncomfortable
-  // amount of time to become available.
-  logInfo('Waiting for an agent to become available...')
-}
-
-// Log in as administrator
-const adminLogin = async () => {
-  let cmd
-  if (apitoken) {
-    cmd = `node index.js login --endpoint ${endpoint} --apitoken ${apitoken}`
-  } else {
-    cmd = `node index.js login --endpoint ${endpoint} --username ${username} --password ${password}`
-  }
-  const { stdout: result } = await execLocal(cmd)
-  logResult(result)
-}
-
-/**
- * Main script
- */
-(async () => {
-  await adminLogin()
-
-  // Locate project
-  const p = await findProject(project)
-  if (p) projectId = p.id
-  if (!projectId) throw new Error('Missing projectId')
-
-  // Locate project
-  const i = await findInstance(flavor)
-  if (i) instanceId = i.id
-  if (!instanceId) throw new Error('Missing instanceId')
-
-  // Show existing sessions
-  logInfo('Show all sessions')
-  await listSessions()
-
-  // Create a Web Player session and extract the new session ID
-  let { stdout: result } = await execLocal(`node index.js webplayer create --project ${projectId} --features ${features} --expiresIn ${expiration}`)
-  const parsed = parse(result)
-  if (!Array.isArray(parsed)) { throw new Error('Web Player creation failed') }
-  const { identifier: sessionId } = parsed[0]
-  logResult(`Created Web Player Session ${sessionId}`)
-
-  logInfo('Show all sessions')
-  await listSessions()
-
-  // Verify listing a single session
-  logInfo('Show newly created session only')
-  await listSessions(sessionId);
-
-  // Log into the Web Player session
-  ({ stdout: result } = await execLocal(`node index.js webplayer login --project ${projectId} --session ${sessionId}`))
-  logResult(result)
-
-  // Device must be ON before using agent
-  await startInstance();
-
-  // List files
-  ({ stdout: result } = await execLocal(`node index.js agent files --project ${projectId} --instance ${instanceId}`))
-  logResult('\n', result);
-
-  // List apps
-  ({ stdout: result } = await execLocal(`node index.js agent apps --project ${projectId} --instance ${instanceId}`))
-  logResult('\n', result)
-
-  // Re-login in as administrator since the session has been destroyed
-  await adminLogin();
-
-  // Destroy the Web Player session
-  ({ stdout: result } = await execLocal(`node index.js webplayer destroy --project ${projectId} --session ${sessionId}`))
-  logResult(result)
-
-  await listSessions()
-})()
-  .then(() => {
-    logInfo('-=DONE=-\n\n')
-  })
-  .catch(e => {
-    logError(e)
-  })