@corellium/corellium-cli 1.0.9 → 1.1.1

package/.gitlab-ci.yml

@@ -19,3 +19,11 @@ test:
     # - mysqladmin -u root -ppassword -P 3306 -h mariadb status
 
     - npm ci
+    - npm run test:ci
+  artifacts:
+    paths:
+      - coverage/
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage/cobertura-coverage.xml

package/.nycrc

@@ -0,0 +1,16 @@
+{
+    "check-coverage": false,
+    "report-dir": "./coverage",
+    "reporter": ["cobertura", "lcov", "text"],
+    "branches": 60,
+    "lines": 60,
+    "functions": 60,
+    "statements": 60,
+    "temp-dir": "/tmp",
+    "watermarks": {
+        "lines": [60, 80],
+        "functions": [60, 80],
+        "branches": [60, 80],
+        "statements": [60, 80]
+    }
+}

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "@corellium/corellium-cli",
-    "version": "1.0.9",
+    "version": "1.1.1",
     "description": "Corellium CLI Tool",
     "scripts": {
         "corellium": "node index.js",
         "lint": "eslint .",
         "lint-staged": "lint-staged",
-        "lint:fix": "eslint --fix ."
+        "lint:fix": "eslint --fix .",
+        "test:ci": "npx nyc report"
     },
     "bin": {
         "corellium": "index.sh"
@@ -32,6 +33,7 @@
         "progress": "^2.0.3",
         "prompts": "^2.4.2",
         "uuid": "^8.3.2",
+        "websocket-stream": "^5.5.2",
         "xhr2": "^0.2.0",
         "yargs": "^17.5.1"
     },

package/sonar-project.properties

@@ -0,0 +1,2 @@
+sonar.projectKey=middleware_corellium-cli_AYbC7e_Y2VKo8EJiY-py
+sonar.qualitygate.wait=true

package/src/{commands/agent → clients}/Agent.js

@@ -1,4 +1,4 @@
-const Client = require('../Client')
+const Client = require('./Client')
 
 /**
  * @typedef {object} AppsResult

package/src/clients/Client.js

@@ -0,0 +1,89 @@
+const axios = require('axios').default
+const { readProfile } = require('../profile')
+const { createWriteStream } = require('fs')
+const wsstream = require('websocket-stream')
+
+/**
+ * Client Base class
+ */
+class Client {
+  constructor (argv) {
+    this.argv = Object.assign({}, argv)
+    this.project = argv.project || argv.projectId
+    this.instance = argv.instance || argv.instanceId
+    this._profile = readProfile()
+    this._version = require('../../package.json').version
+  }
+
+  /**
+   * @protected
+   * @returns default headers
+   */
+  _headers = () => ({
+    Authorization: `Bearer ${this._profile.token}`,
+    'User-Agent': `corellium-cli v${this._version}`
+  })
+
+  /**
+   * Retrieve file stream
+   * @protected
+   * @param {string} path
+   * @param {PathLike} outputFile
+   * @returns {Promise<any>}
+   */
+  _fetchStream = async (path, outputFile) => {
+    const response = await axios({
+      method: 'GET',
+      url: `${this._profile.endpoint}/api/${path}`,
+      headers: this._headers(),
+      responseType: 'stream'
+    })
+
+    const writeStream = createWriteStream(outputFile)
+    response.data.pipe(writeStream)
+
+    return new Promise((resolve, reject) => {
+      writeStream.on('finish', resolve)
+      writeStream.on('error', reject)
+    })
+  }
+
+  /**
+   * Get Websocket stream
+   * @protected
+   * @param {string} token
+   * @returns {wsstream.WebSocketDuplex}
+   */
+  _fetchWSS = (token) => {
+    const url = `wss://${this._profile.endpoint}/api/v1/agent/${token}`
+    return wsstream(url, ['binary'])
+  }
+
+  /**
+   * Perform HTTP transaction
+   * @protected
+   * @param {string} method
+   * @param {string} path
+   * @param {object} data
+   * @returns {Promise<any>}
+   */
+  _fetch = async (method, path, data) => {
+    const headers = this._headers()
+    let response
+    switch (method) {
+      case 'GET':
+        response = await axios.get(`${this._profile.endpoint}/api/${path}`, { headers })
+        break
+      case 'POST':
+        response = await axios.post(`${this._profile.endpoint}/api/${path}`, data, { headers })
+        break
+      case 'DELETE':
+        response = await axios.delete(`${this._profile.endpoint}/api/${path}`, { headers })
+        break
+    }
+    if (response.status >= 400) { throw new Error(response.statusText) }
+    return response.data || {}
+  }
+}
+
+module.exports = Client

package/src/clients/Instance.js

@@ -0,0 +1,84 @@
+const Client = require('./Client')
+
+/**
+ * Instance class
+ */
+class InstanceCLI extends Client {
+  instanceBasePath = () => `v1/instances/${this.instance}`
+  preauthedBasePath = () => 'v1/preauthed'
+
+  /**
+   * Upgrade iOS version on instance
+   * @returns {Promise<any>}
+   */
+  upgrade = async (options) => {
+    const { os, osbuild } = options
+    return await this._fetch('POST', `${this.instanceBasePath()}/upgrade`, { os, osbuild })
+  }
+
+  /**
+   * Get websocket stream from token
+   * @returns {wsstream.WebSocketDuplex}
+   */
+  wss = (token) => {
+    return this._fetchWSS(token)
+  }
+
+  /**
+   * Start instance
+   */
+  start = async (options) => {
+    const { sockcap, paused } = options
+    return await this._fetch('POST', `${this.instanceBasePath()}/start`, { sockcap, paused })
+  }
+
+  /**
+   * Restore backup to instance
+   * @returns {Promise<any>}
+   */
+  restoreBackup = async () => {
+    return await this._fetch('POST', `${this.instanceBasePath()}/restoreBackup`)
+  }
+
+  /**
+   * Enable monitoring
+   * @returns {Promise<any>}
+   */
+  enableMonitoring = async (options) => {
+    return await this._fetch('POST', `${this.instanceBasePath()}/netdump/enable`, options)
+  }
+
+  /**
+   * Disable monitoring
+   * @returns {Promise<any>}
+   */
+  disableMonitoring = async () => {
+    return await this._fetch('POST', `${this.instanceBasePath()}/netdump/disable`)
+  }
+
+  /**
+   * Authorize pcap download
+   * @returns {Promise<any>}
+   */
+  authorizePcap = async () => {
+    return await this._fetch('POST', `${this.instanceBasePath()}/netdump-authorize`)
+  }
+
+  /**
+   * Download file
+   * @returns {Promise<any>}
+   */
+  download = async (token, file, outputFile) => {
+    return await this._fetchStream(`${this.preauthedBasePath()}/${token}/${file}`, outputFile)
+  }
+
+  /**
+   * Fetch instance information
+   * @returns {Promise<any>}
+   */
+  info = async () => {
+    return await this._fetch('GET', `${this.instanceBasePath()}`, {})
+  }
+}
+
+module.exports = InstanceCLI

package/src/{TrialAccount.js → clients/TrialAccount.js}

@@ -1,6 +1,6 @@
-const Client = require('./commands/Client')
-const util = require('./utils')
-const { handler: login } = require('./commands/login')
+const Client = require('./Client')
+const util = require('../utils')
+const { handler: login } = require('../commands/login')
 
 class TrialAccount extends Client {
   constructor (argv) {

package/src/{commands/webplayer/WebPlayer.js → clients/Webplayer.js}

@@ -1,12 +1,12 @@
-const Client = require('../Client')
+const Client = require('./Client')
 const {
   updateProfile
-} = require('../../profile')
+} = require('../profile')
 
 /**
- * WebPlayer class
+ * Webplayer class
  */
-class WebPlayer extends Client {
+class Webplayer extends Client {
   constructor (argv) {
     super(argv)
     const { features, permissions, expiresIn } = this.argv
@@ -16,7 +16,7 @@ class WebPlayer extends Client {
   }
 
   /**
-   * Create a Web Player session
+   * Create a Webplayer session
    * @returns {Promise<Array<object>>}
    */
   createSession = async () => this._fetch('POST', 'v1/webplayer', {
@@ -28,14 +28,14 @@ class WebPlayer extends Client {
   })
 
   /**
-   * Destroy a Web Player session
+   * Destroy a Webplayer session
    * @param {string} sessionId
    * @returns {Promise<{object}>}
    */
   destroySession = async (sessionId) => this._fetch('DELETE', `v1/webplayer/${sessionId}`, {})
 
   /**
-   * List Web Player sessions
+   * List Webplayer sessions
    * @returns {Promise<Array<object>>}
    */
   listSessions = async (sessionId) => {
@@ -44,7 +44,7 @@ class WebPlayer extends Client {
   }
 
   /**
-   * Log into WebPlayer session by activating WebPlayer credentials
+   * Log into Webplayer session by activating Webplayer credentials
    * @param {string} sessionId
    * @returns {Promise<void>}
    */
@@ -54,4 +54,4 @@ class WebPlayer extends Client {
   }
 }
 
-module.exports = WebPlayer
+module.exports = Webplayer

package/src/commands/agent/apps.js

@@ -1,4 +1,4 @@
-const AgentCLI = require('./Agent')
+const AgentCLI = require('../../clients/Agent')
 const { displayTable } = require('../../table')
 const { validateNonEmpty } = require('../../utils')
 const { getErrorMessage } = require('../../error')

package/src/commands/agent/file.js

@@ -1,4 +1,4 @@
-const AgentCLI = require('./Agent')
+const AgentCLI = require('../../clients/Agent')
 const { displayTable } = require('../../table')
 const { validateNonEmpty } = require('../../utils')
 const { getErrorMessage } = require('../../error')

package/src/commands/agent/ready.js

@@ -1,4 +1,4 @@
-const AgentCLI = require('./Agent')
+const AgentCLI = require('../../clients/Agent')
 const { validateNonEmpty } = require('../../utils')
 const { getErrorMessage } = require('../../error')
 const log = require('../../logging')

package/src/commands/instances/index.js

@@ -4,7 +4,9 @@ const subcommands = [
   require('./delete'),
   require('./stop'),
   require('./start'),
-  require('./upgrade')
+  require('./upgrade'),
+  require('./netmon'),
+  require('./restoreBackup')
 ]
 
 let _yargs

package/src/commands/instances/netmon/disable.js

@@ -0,0 +1,44 @@
+const log = require('../../../logging')
+const InstanceCLI = require('../../../clients/Instance')
+
+async function builder (yargs) {
+  yargs
+    .positional('instanceId', {
+      type: 'string',
+      describe: 'Instance id',
+      demandOption: true
+    })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'Console will receive verbose error output',
+      demandOption: false
+    })
+}
+
+async function handler (argv) {
+  try {
+    const instance = new InstanceCLI(argv)
+    await instance.disableMonitoring()
+    log.info('Success')
+  } catch (e) {
+    if (e.response) {
+      log.error(`${e.response.status} ${e.response.data.error || e.response.statusText}`)
+    } else {
+      if (e.message) {
+        log.error(e.message)
+      } else {
+        log.error('Urecognized error, use --verbose for details')
+      }
+    }
+
+    if (argv.verbose) { log.error(JSON.stringify(e)) }
+  }
+}
+
+module.exports = {
+  builder,
+  handler,
+  command: 'disable <instanceId> [--verbose]',
+  describe: 'Disable network monitoring'
+}

package/src/commands/instances/netmon/download.js

@@ -0,0 +1,50 @@
+const log = require('../../../logging')
+const InstanceCLI = require('../../../clients/Instance')
+
+async function builder (yargs) {
+  yargs
+    .positional('instanceId', {
+      type: 'string',
+      describe: 'Instance id',
+      demandOption: true
+    })
+    .positional('outputFile', {
+      type: 'string',
+      describe: 'Path to output',
+      demandOption: true
+    })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'Console will receive verbose error output',
+      demandOption: false
+    })
+}
+
+async function handler (argv) {
+  try {
+    const instance = new InstanceCLI(argv)
+    const { token } = await instance.authorizePcap()
+    await instance.download(token, 'netdump.pcap', argv.outputFile)
+    log.info(`Success, pcap saved to ${argv.outputFile}`)
+  } catch (e) {
+    if (e.response) {
+      log.error(`${e.response.status} ${e.response.data.error || e.response.statusText}`)
+    } else {
+      if (e.message) {
+        log.error(e.message)
+      } else {
+        log.error('Urecognized error, use --verbose for details')
+      }
+    }
+
+    if (argv.verbose) { log.error(JSON.stringify(e)) }
+  }
+}
+
+module.exports = {
+  builder,
+  handler,
+  command: 'download <instanceId> <outputFile> [--verbose]',
+  describe: 'Download pcap file'
+}

package/src/commands/instances/netmon/enable.js

@@ -0,0 +1,72 @@
+const log = require('../../../logging')
+const InstanceCLI = require('../../../clients/Instance')
+
+async function builder (yargs) {
+  yargs
+    .positional('instanceId', {
+      type: 'string',
+      describe: 'Instance id',
+      demandOption: true
+    })
+    .option('srcPorts', {
+      type: 'array',
+      describe: 'Source ports to filter'
+    })
+    .option('dstPorts', {
+      type: 'array',
+      describe: 'Destination ports to filter'
+    })
+    .option('ports', {
+      type: 'array',
+      describe: 'Source or destination ports to filter'
+    })
+    .option('processes', {
+      type: 'array',
+      describe: 'List of process names or pids to filter'
+    })
+    .option('portRanges', {
+      type: 'array',
+      describe: 'List of port ranges in that format \'[beginPort]-[endport]\''
+    })
+    .option('protocols', {
+      type: 'array',
+      describe: 'List of protocols'
+    })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'Console will receive verbose error output',
+      demandOption: false
+    })
+}
+
+async function handler (argv) {
+  try {
+    const { srcPorts, dstPorts, ports, processes, portRanges, protocols } = argv
+
+    const instance = new InstanceCLI(argv)
+    await instance.enableMonitoring({
+      srcPorts, dstPorts, ports, processes, portRanges, protocols
+    })
+    log.info('Success')
+  } catch (e) {
+    if (e.response) {
+      log.error(`${e.response.status} ${e.response.data.error || e.response.statusText}`)
+    } else {
+      if (e.message) {
+        log.error(e.message)
+      } else {
+        log.error('Urecognized error, use --verbose for details')
+      }
+    }
+
+    if (argv.verbose) { log.error(JSON.stringify(e)) }
+  }
+}
+
+module.exports = {
+  builder,
+  handler,
+  command: 'enable <instanceId> [--verbose]',
+  describe: 'Enable network monitoring'
+}

package/src/commands/instances/netmon/index.js

@@ -0,0 +1,15 @@
+const subcommands = [
+  require('./enable'),
+  require('./disable'),
+  require('./download'),
+  require('./stream')
+]
+
+let _yargs
+
+module.exports = {
+  builder: yargs => (_yargs = yargs) && yargs.command(subcommands).scriptName(''),
+  handler: argv => !argv[1] && _yargs.showHelp(),
+  command: 'netmon',
+  describe: 'Network Monitoring related commands'
+}

package/src/commands/instances/netmon/stream.js

@@ -0,0 +1,48 @@
+const log = require('../../../logging')
+const InstanceCLI = require('../../../clients/Instance')
+
+async function builder (yargs) {
+  yargs
+    .positional('instanceId', {
+      type: 'string',
+      describe: 'Instance id',
+      demandOption: true
+    })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'Console will receive verbose error output',
+      demandOption: false
+    })
+}
+
+async function handler (argv) {
+  try {
+    const instance = new InstanceCLI(argv)
+    const { netdump } = await instance.info()
+    if (netdump && netdump.enabled) {
+      instance.wss(netdump.info).pipe(process.stdout)
+    } else {
+      log.error('Network monitoring is not enabled')
+    }
+  } catch (e) {
+    if (e.response) {
+      log.error(`${e.response.status} ${e.response.data.error || e.response.statusText}`)
+    } else {
+      if (e.message) {
+        log.error(e.message)
+      } else {
+        log.error('Urecognized error, use --verbose for details')
+      }
+    }
+
+    if (argv.verbose) { log.error(JSON.stringify(e)) }
+  }
+}
+
+module.exports = {
+  builder,
+  handler,
+  command: 'stream <instanceId> [--verbose]',
+  describe: 'Stream monitoring events'
+}

package/src/commands/instances/restoreBackup.js

@@ -0,0 +1,77 @@
+const log = require('../../logging')
+const InstanceCLI = require('../../clients/Instance')
+const { readProfile } = require('../../profile')
+const { v4: uuidv4 } = require('uuid')
+const { basename } = require('path')
+const MultiProgress = require('multi-progress')
+const { uploadWithProgress } = require('../../upload')
+const { waitForTaskState } = require('../../utils')
+
+async function builder (yargs) {
+  yargs
+    .positional('instanceId', {
+      type: 'string',
+      describe: 'Instance id',
+      demandOption: true
+    })
+    .positional('zipFile', {
+      type: 'string',
+      describe: 'Path to backup zip file',
+      demandOption: true
+    })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'Console will receive verbose error output',
+      demandOption: false
+    })
+}
+
+async function handler (argv) {
+  const profile = readProfile()
+  const { instanceId, zipFile } = argv
+  const name = basename(zipFile)
+  const image = uuidv4()
+  const url = profile.endpoint +
+    '/api/v1/instances' +
+    '/' +
+    encodeURIComponent(instanceId) +
+    '/' +
+    'image-upload/backup' +
+    '/' +
+    encodeURIComponent(image) +
+    '/' +
+    encodeURIComponent(name)
+
+  const multi = new MultiProgress(process.stderr)
+
+  try {
+    await uploadWithProgress(url, profile.token, zipFile, multi, {
+      'x-corellium-image-encapsulated': 'false'
+    })
+    console.log(`Backup uploaded ${image}`)
+
+    const instance = new InstanceCLI(argv)
+    await instance.restoreBackup()
+
+    await waitForTaskState(instanceId, instance.info.bind(instance), 'restoring-backup')
+    console.log('Restoring in progress')
+    await waitForTaskState(instanceId, instance.info.bind(instance), 'none')
+
+    log.info(`Restored backup ${zipFile} to ${argv.instanceId}`)
+  } catch (err) {
+    const errorMessage = err.message
+    log.error(`Restore backup failed: ${errorMessage}`)
+    if (err.response && err.response.data && err.response.data.error) {
+      log.error(err.response.data.error)
+    }
+    if (argv.verbose) { log.error(err) }
+  }
+}
+
+module.exports = {
+  builder,
+  handler,
+  command: 'restore-backup <instanceId> <zipFile> [--verbose]',
+  describe: 'Restore iOS backup to instance'
+}

package/src/commands/instances/rotate.js

@@ -0,0 +1,47 @@
+const { getErrorMessage } = require('../../error')
+const asciiArt = require('ascii-art')
+
+const Client = require('../../clients/Client')
+async function builder (yargs) {
+  yargs.positional('instanceId', {
+    type: 'string',
+    describe: 'Instance id',
+    demandOption: true
+  })
+    .option('verbose', {
+      alias: 'v',
+      type: 'boolean',
+      describe: 'Console will receive verbose error output'
+    })
+    .option('orientation', {
+      alias: 'o',
+      type: 'number',
+      describe: 'Orientation type'
+    })
+}
+
+async function handler (argv) {
+  const client = new Client(argv)
+  const instanceId = argv.instanceId
+  const orientation = argv.orientation || 4
+  try {
+    await client._fetch('POST', `v1/instances/${instanceId}/rotate`, { orientation })
+    console.log(
+      asciiArt.style(`Successfully rotated instance ${instanceId}`, 'green', true)
+    )
+  } catch (error) {
+    const errorMessage = getErrorMessage(error)
+    console.error(`Failed to rotate ${instanceId}: ${errorMessage}`)
+
+    if (argv.detailedErrors) {
+      console.log(error)
+    }
+  }
+}
+
+module.exports = {
+  builder,
+  handler,
+  command: 'rotate <instanceId> [orientation]',
+  describe: 'Rotate instance'
+}

package/src/commands/instances/start.js

@@ -1,6 +1,7 @@
 const { getErrorMessage } = require('../../error')
 const asciiArt = require('ascii-art')
-const { getApi, waitForState } = require('../../utils')
+const { waitForState } = require('../../utils')
+const InstanceCLI = require('../../clients/Instance')
 
 async function builder (yargs) {
   yargs.positional('instanceId', {
@@ -17,25 +18,33 @@ async function builder (yargs) {
       type: 'boolean',
       describe: 'Wait for the instance to be fully started'
     })
+    .option('paused', {
+      type: 'boolean',
+      describe: 'Start instance in a paused state'
+    })
+    .option('sockcap', {
+      type: 'boolean',
+      describe: 'Start sockcap add-on if loaded'
+    })
 }
 
 async function handler (argv) {
-  const api = await getApi()
-  const instanceId = argv.instanceId
+  const { sockcap, paused } = argv
+  const instance = new InstanceCLI(argv)
   try {
-    await api.v1StartInstance(instanceId)
+    await instance.start({ sockcap, paused })
     if (argv.wait) {
       // Wait 60 attempts for the instance to be created (5 minutes)
-      await waitForState(instanceId, api.v1GetInstance.bind(api), 'on', 60)
+      await waitForState(argv.instanceId, instance.info.bind(instance), 'on', 60)
     }
     console.log(
-      asciiArt.style(`Successfully started instance ${instanceId}`, 'green', true)
+      asciiArt.style(`Successfully started instance ${argv.instanceId}`, 'green', true)
     )
   } catch (error) {
     const errorMessage = getErrorMessage(error)
-    console.error(`Failed to start ${instanceId}: ${errorMessage}`)
+    console.error(`Failed to start ${argv.instance}: ${errorMessage}`)
 
-    if (argv.detailedErrors) {
+    if (argv.verbose) {
       console.log(error)
     }
   }
@@ -44,6 +53,6 @@ async function handler (argv) {
 module.exports = {
   builder,
   handler,
-  command: 'start <instanceId> [wait]',
+  command: 'start <instanceId> [--wait] [--verbose] [--paused] [--sockcap]',
   describe: 'Start instance'
 }

package/src/commands/instances/upgrade.js

@@ -1,5 +1,5 @@
 const log = require('../../logging')
-const InstanceCLI = require('./Instance')
+const InstanceCLI = require('../../clients/Instance')
 const { getErrorMessage } = require('../../error')
 const { waitForState, waitForIntervalMilliSec } = require('../../utils')
 

package/src/commands/signup.js

@@ -1,4 +1,4 @@
-const TrialAccount = require('../TrialAccount')
+const TrialAccount = require('../clients/TrialAccount')
 const { makePassword, validateNonEmpty } = require('../utils')
 const { getErrorMessage } = require('../error')
 const log = require('../logging')
@@ -7,7 +7,7 @@ async function builder (yargs) {
   yargs.options({
     endpoint: {
       type: 'input',
-      describe: 'Server endpoint e.g. https://app.ci-4.corellium.co',
+      describe: 'Server endpoint e.g. https://app.corellium.co',
       demandOption: true,
       string: true,
       validateNonEmpty

package/src/commands/webplayer/create.js

@@ -1,4 +1,4 @@
-const WebPlayer = require('./WebPlayer')
+const Webplayer = require('../../clients/Webplayer')
 const log = require('../../logging')
 const { displayTable } = require('../../table')
 const { validateNonEmpty } = require('../../utils')
@@ -49,13 +49,13 @@ async function builder (yargs) {
 
 async function handler (argv) {
   try {
-    const webplayer = new WebPlayer(argv)
+    const webplayer = new Webplayer(argv)
     const session = await webplayer.createSession()
-    // log.info('Created web player session')
+    // log.info('Created Webplayer session')
     await displayTable(argv.format || 'json', [session], ['identifier', 'token', 'expiration', 'features'])
   } catch (err) {
     const errorMessage = getErrorMessage(err)
-    log.error(`Create web player session failed: ${errorMessage}`)
+    log.error(`Create Webplayer session failed: ${errorMessage}`)
     if (argv.detailedErrors) { log.error(err) }
   }
 }
@@ -64,5 +64,5 @@ module.exports = {
   builder,
   handler,
   command: 'create',
-  describe: 'Create a web player session returning the URL and token'
+  describe: 'Create a Webplayer session returning the URL and token'
 }

package/src/commands/webplayer/destroy.js

@@ -1,4 +1,4 @@
-const WebPlayer = require('./WebPlayer')
+const Webplayer = require('../../clients/Webplayer')
 const log = require('../../logging')
 const { validateNonEmpty } = require('../../utils')
 const { getErrorMessage } = require('../../error')
@@ -16,7 +16,7 @@ async function builder (yargs) {
     validateNonEmpty
   }).option('session', {
     type: 'input',
-    describe: 'WebPlayer Session ID',
+    describe: 'Webplayer Session ID',
     demandOption: true,
     string: true,
     validateNonEmpty
@@ -26,12 +26,12 @@ async function builder (yargs) {
 async function handler (argv) {
   const { session: sessionId } = argv
   try {
-    const webplayer = new WebPlayer(argv)
+    const webplayer = new Webplayer(argv)
     await webplayer.destroySession(sessionId)
-    log.info(`Destroyed web player session ${sessionId}`)
+    log.info(`Destroyed Webplayer session ${sessionId}`)
   } catch (err) {
     const errorMessage = getErrorMessage(err)
-    log.error(`Destroy web player session ${sessionId} failed: ${errorMessage}`)
+    log.error(`Destroy Webplayer session ${sessionId} failed: ${errorMessage}`)
     if (argv.detailedErrors) { log.error(err) }
   }
 }
@@ -40,5 +40,5 @@ module.exports = {
   builder,
   handler,
   command: 'destroy',
-  describe: 'Destroy a web player session'
+  describe: 'Destroy a Webplayer session'
 }

package/src/commands/webplayer/index.js

@@ -11,5 +11,5 @@ module.exports = {
   builder: yargs => (_yargs = yargs) && yargs.command(subcommands).scriptName(''),
   handler: argv => !argv[1] && _yargs.showHelp(),
   command: 'webplayer',
-  describe: 'Web Player related commands'
+  describe: 'Webplayer related commands'
 }

package/src/commands/webplayer/list.js

@@ -1,4 +1,4 @@
-const WebPlayer = require('./WebPlayer')
+const Webplayer = require('../../clients/Webplayer')
 const log = require('../../logging')
 const { displayTable } = require('../../table')
 const { validateNonEmpty } = require('../../utils')
@@ -17,7 +17,7 @@ async function builder (yargs) {
     validateNonEmpty
   }).option('session', {
     type: 'input',
-    describe: 'Web Player Session ID',
+    describe: 'Webplayer Session ID',
     demandOption: false,
     string: true
   }).option('format', {
@@ -30,7 +30,7 @@ async function builder (yargs) {
 
 async function handler (argv) {
   try {
-    const webplayer = new WebPlayer(argv)
+    const webplayer = new Webplayer(argv)
     const result = await webplayer.listSessions(argv.session)
     if (!result.length && argv.format !== 'json') {
       console.error('Found no matching Webplayer sessions')
@@ -63,5 +63,5 @@ module.exports = {
   builder,
   handler,
   command: 'list',
-  describe: 'List web player sessions for a project'
+  describe: 'List Webplayer sessions for a project'
 }

package/src/commands/webplayer/login.js

@@ -1,4 +1,4 @@
-const WebPlayer = require('./WebPlayer')
+const Webplayer = require('../../clients/Webplayer')
 const log = require('../../logging')
 const { validateNonEmpty } = require('../../utils')
 const { getErrorMessage } = require('../../error')
@@ -16,7 +16,7 @@ async function builder (yargs) {
     validateNonEmpty
   }).option('session', {
     type: 'input',
-    describe: 'WebPlayer Session ID',
+    describe: 'Webplayer Session ID',
     demandOption: true,
     string: true,
     validateNonEmpty
@@ -26,12 +26,12 @@ async function builder (yargs) {
 async function handler (argv) {
   const { session: sessionId } = argv
   try {
-    const webplayer = new WebPlayer(argv)
+    const webplayer = new Webplayer(argv)
     await webplayer.login(sessionId)
-    log.info(`Login to Web Player session ${sessionId} successful`)
+    log.info(`Login to Webplayer session ${sessionId} successful`)
   } catch (err) {
     const errorMessage = getErrorMessage(err)
-    log.error(`Login to Web Player session ${sessionId} failed: ${errorMessage}`)
+    log.error(`Login to Webplayer session ${sessionId} failed: ${errorMessage}`)
     if (argv.detailedErrors) {
       log.error(err)
     }
@@ -42,5 +42,5 @@ module.exports = {
   builder,
   handler,
   command: 'login',
-  describe: 'Log CLI into a web player session'
+  describe: 'Log CLI into a Webplayer session'
 }

package/src/upload.js

@@ -19,13 +19,14 @@ class File {
   }
 }
 
-async function uploadFile (token, url, filePath, progress) {
+async function uploadFile (token, url, filePath, progress, headers) {
   return new Promise((resolve, reject) => {
     const r = new Resumable({
       target: url,
       headers: {
         authorization: token,
-        'x-corellium-image-encoding': 'plain'
+        'x-corellium-image-encoding': 'plain',
+        ...headers
       },
       uploadMethod: 'PUT',
       chunkSize: 5 * 1024 * 1024,
@@ -64,7 +65,7 @@ async function uploadFile (token, url, filePath, progress) {
   })
 }
 
-async function uploadWithProgress (url, token, file, multi) {
+async function uploadWithProgress (url, token, file, multi, headers) {
   const fileName = basename(file)
 
   const bar = multi.newBar(` loading ${fileName} [:bar] :percent`, {
@@ -82,7 +83,8 @@ async function uploadWithProgress (url, token, file, multi) {
       (progress) => {
         const ticks = Math.ceil(100 * progress)
         bar.tick(ticks)
-      }
+      },
+      headers
     )
     return res
   } catch (error) {

package/src/utils.js

@@ -63,6 +63,23 @@ const waitForState = async (instanceId, fn, state, attempts = 20, reporterFn = n
   }
 }
 
+const waitForTaskState = async (instanceId, fn, taskState, attempts = 20) => {
+  let response = await fn(instanceId)
+
+  while (response.taskState !== taskState) {
+    if (response.state === 'error') {
+      throw new Error(response.error)
+    }
+
+    if (attempts <= 0) {
+      throw new Error(`Timed out waiting for taskState ${taskState}`)
+    }
+    --attempts
+    await sleep(waitForIntervalMilliSec)
+    response = await fn(instanceId)
+  }
+}
+
 async function getApi () {
   const profile = readProfile()
   const api = new CorelliumClient.CorelliumApi()
@@ -145,6 +162,7 @@ module.exports = {
   planOptions,
   makePassword,
   waitForState,
+  waitForTaskState,
   getApi,
   getAxios,
   validateNonEmpty,

package/src/commands/Client.js

@@ -1,45 +0,0 @@
-const axios = require('axios').default
-const { readProfile } = require('../profile')
-
-/**
- * Client Base class
- */
-class Client {
-  constructor (argv) {
-    this.argv = Object.assign({}, argv)
-    this.project = argv.project || argv.projectId
-    this.instance = argv.instance || argv.instanceId
-    this._profile = readProfile()
-  }
-
-  /**
-   * Perform HTTP transaction
-   * @protected
-   * @param {string} method
-   * @param {string} path
-   * @param {object} data
-   * @returns {Promise<any>}
-   */
-  _fetch = async (method, path, data) => {
-    const headers = {
-      Authorization: `Bearer ${this._profile.token}`,
-      'User-Agent': `corellium-cli v${require('../../package.json').version}`
-    }
-    let response
-    switch (method) {
-      case 'GET':
-        response = await axios.get(`${this._profile.endpoint}/api/${path}`, { headers })
-        break
-      case 'POST':
-        response = await axios.post(`${this._profile.endpoint}/api/${path}`, data, { headers })
-        break
-      case 'DELETE':
-        response = await axios.delete(`${this._profile.endpoint}/api/${path}`, { headers })
-        break
-    }
-    if (response.status >= 400) { throw new Error(response.statusText) }
-    return response.data || {}
-  }
-}
-
-module.exports = Client

package/src/commands/instances/Instance.js

@@ -1,27 +0,0 @@
-const Client = require('../Client')
-
-/**
- * Instance class
- */
-class InstanceCLI extends Client {
-  instanceBasePath = () => `v1/instances/${this.instance}`
-
-  /**
-   * Upgrade iOS version on instance
-   * @returns {Promise<any>}
-   */
-  upgrade = async (options) => {
-    const { os, osbuild } = options
-    return await this._fetch('POST', `${this.instanceBasePath()}/upgrade`, { os, osbuild })
-  }
-
-  /**
-   * Fetch instance information
-   * @returns {Promise<any>}
-   */
-  info = async () => {
-    return await this._fetch('GET', `${this.instanceBasePath()}`, {})
-  }
-}
-
-module.exports = InstanceCLI