@corellium/corellium-cli 1.4.0 → 1.5.0

package/src/table.js

@@ -1,38 +1,36 @@
-const { table } = require('table')
-const log = require('./logging')
+const { table } = require('table');
+const log = require('./logging');
 
 async function displayTable (format = 'json', data, filteredFields, columnWidths) {
   if (format === 'json') {
-    const displayJson = JSON.stringify(data, null, 2)
-    log.plain(displayJson)
+    const displayJson = JSON.stringify(data, null, 2);
+    log.plain(displayJson);
   } else {
-    let rows = data.map(d => {
-      return filteredFields.map(field => {
+    let rows = data.map((d) => {
+      return filteredFields.map((field) => {
         // Not perfect, but ascii-art-table doesn't really like anything here but strings
-        return typeof d[field] !== 'string' ? JSON.stringify(d[field]) : d[field]
-      })
-    })
+        return typeof d[field] !== 'string' ? JSON.stringify(d[field]) : d[field];
+      });
+    });
 
     if (format === 'csv') {
-      log.plain(filteredFields.join(','))
-      rows.forEach(row => console.log(row.join(',')))
+      log.plain(filteredFields.join(','));
+      rows.forEach((row) => console.log(row.join(',')));
     } else {
       if (columnWidths) {
         // for each column specified, pad all values in column till they are that width
         // TODO: Change this to specify a minimum width that is based on header
-        columnWidths.forEach(columnWidth => {
-          rows = rows.map(row => {
-            row[columnWidth.column] = row[columnWidth.column].padEnd(columnWidth.width)
-            return row
-          })
-        })
+        columnWidths.forEach((columnWidth) => {
+          rows = rows.map((row) => {
+            row[columnWidth.column] = row[columnWidth.column].padEnd(columnWidth.width);
+            return row;
+          });
+        });
       }
-      rows.unshift(filteredFields)
-      console.log(
-        table(rows)
-      )
+      rows.unshift(filteredFields);
+      console.log(table(rows));
     }
   }
 }
 
-module.exports = { displayTable }
+module.exports = { displayTable };

package/src/upload.js

@@ -1,21 +1,21 @@
-const fs = require('fs')
-const path = require('path')
-const util = require('util')
-const Resumable = require('./resumable')
-const { basename } = require('path')
-const { handleError } = require('./error')
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const Resumable = require('./resumable');
+const { basename } = require('path');
+const { handleError } = require('./error');
 
 class File {
   constructor ({ filePath, type, size }) {
-    this.path = filePath
-    this.name = path.basename(filePath)
-    this.type = type
-    this.size = 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 })
+    return fs.createReadStream(this.path, { start, end });
   }
 }
 
@@ -26,30 +26,30 @@ async function uploadFile (token, url, filePath, progress, headers) {
       headers: {
         authorization: token,
         'x-corellium-image-encoding': 'plain',
-        ...headers
+        ...headers,
       },
       uploadMethod: 'PUT',
       chunkSize: 5 * 1024 * 1024,
       prioritizeFirstAndLastChunk: true,
-      method: 'octet'
-    })
+      method: 'octet',
+    });
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     r.on('fileAdded', (_file) => {
-      r.upload()
-    })
+      r.upload();
+    });
 
     r.on('progress', () => {
-      if (progress) progress(r.progress())
-    })
+      if (progress) progress(r.progress());
+    });
 
     r.on('fileError', (_file, message) => {
-      reject(message)
-    })
+      reject(message);
+    });
 
     r.on('fileSuccess', (_file, message) => {
-      resolve(JSON.parse(message))
-    })
+      resolve(JSON.parse(message));
+    });
 
     return util
       .promisify(fs.stat)(filePath)
@@ -57,23 +57,23 @@ async function uploadFile (token, url, filePath, progress, headers) {
         const file = new File({
           filePath: filePath,
           type: 'application/octet-stream',
-          size: stat.size
-        })
+          size: stat.size,
+        });
 
-        r.addFile(file)
-      })
-  })
+        r.addFile(file);
+      });
+  });
 }
 
 async function uploadWithProgress (url, token, file, multi, headers) {
-  const fileName = basename(file)
+  const fileName = basename(file);
 
   const bar = multi.newBar(` loading ${fileName} [:bar] :percent`, {
     complete: '=',
     incomplete: ' ',
     width: 30,
-    total: 100
-  })
+    total: 100,
+  });
 
   try {
     const res = await uploadFile(
@@ -81,17 +81,17 @@ async function uploadWithProgress (url, token, file, multi, headers) {
       url,
       file,
       (progress) => {
-        const ticks = Math.ceil(100 * progress)
-        bar.tick(ticks)
+        const ticks = Math.ceil(100 * progress);
+        bar.tick(ticks);
       },
-      headers
-    )
-    return res
+      headers,
+    );
+    return res;
   } catch (err) {
-    handleError(err, 'Upload failed')
+    handleError(err, 'Upload failed');
   }
 }
 
 module.exports = {
-  uploadWithProgress
-}
+  uploadWithProgress,
+};

package/src/utils.js

@@ -1,89 +1,86 @@
-const CorelliumClient = require('@corellium/client-api')
-const {
-  readProfile,
-  updateProfile
-} = require('./profile')
-const axios = require('axios').default
-axios.defaults.headers.common['User-Agent'] = `corellium-cli v${require('../package.json').version}`
-const superagent = require('superagent')
-const https = require('https')
-
-const waitForIntervalMilliSec = 5000
+const CorelliumClient = require('@corellium/client-api');
+const { readProfile, updateProfile } = require('./profile');
+const axios = require('axios').default;
+axios.defaults.headers.common['User-Agent'] = `corellium-cli v${require('../package.json').version}`;
+const superagent = require('superagent');
+const https = require('https');
+
+const waitForIntervalMilliSec = 5000;
 
 const sleep = (milliseconds) => {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds))
-}
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
 
 const waitForState = async (instanceId, fn, state, attempts = 20, reporterFn = null) => {
-  const response = await fn(instanceId)
+  const response = await fn(instanceId);
   if (typeof reporterFn === 'function') {
-    reporterFn(response)
+    reporterFn(response);
   }
   if (response.state !== state && attempts > 0) {
-    await sleep(waitForIntervalMilliSec)
-    await waitForState(instanceId, fn, state, --attempts, reporterFn)
+    await sleep(waitForIntervalMilliSec);
+    await waitForState(instanceId, fn, state, --attempts, reporterFn);
   }
-}
+};
 
 const waitForAgentReady = async (agent, attempts = 20) => {
   while (attempts > 0) {
     try {
-      const status = await agent.ready()
+      const status = await agent.ready();
       if (status.ready) {
-        return // Agent is ready, exit the function
+        return; // Agent is ready, exit the function
       }
     } catch (error) {
       // We don't need to log any errors
     }
     // Wait before retrying
-    await sleep(waitForIntervalMilliSec)
-    attempts--
+    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.')
-}
+  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)
+  let response = await fn(instanceId);
 
   while (response.taskState !== taskState) {
     if (response.state === 'error') {
-      throw new Error(response.error)
+      throw new Error(response.error);
     }
 
     if (attempts <= 0) {
-      throw new Error(`Timed out waiting for taskState ${taskState}`)
+      throw new Error(`Timed out waiting for taskState ${taskState}`);
     }
-    --attempts
-    await sleep(waitForIntervalMilliSec)
-    response = await fn(instanceId)
+    --attempts;
+    await sleep(waitForIntervalMilliSec);
+    response = await fn(instanceId);
   }
-}
+};
 
 /**
  * Returns an instance of @corellium/client-api
  */
 async function getApi () {
-  const profile = readProfile()
-  const api = new CorelliumClient.CorelliumApi()
-  api.apiClient.basePath = profile.endpoint + '/api'
+  const profile = readProfile();
+  const api = new CorelliumClient.CorelliumApi();
+  api.apiClient.basePath = profile.endpoint + '/api';
   api.apiClient.defaultHeaders = {
     Authorization: `Bearer ${profile.token}`,
-    'User-Agent': `corellium-cli v${require('../package.json').version}`
-  }
+    'User-Agent': `corellium-cli v${require('../package.json').version}`,
+  };
 
-  const CACert = await getCACert(profile)
-  api.apiClient.requestAgent = new https.Agent({ ca: CACert })
+  const CACert = await getCACert(profile);
+  api.apiClient.requestAgent = new https.Agent({ ca: CACert });
 
-  return api
+  return api;
 }
 
 async function getAxios () {
-  const profile = readProfile()
-  axios.defaults.headers.common.Authorization = `Bearer ${profile.token}`
-  const CACert = await getCACert(profile)
-  axios.defaults.httpsAgent = new https.Agent({ ca: CACert })
-  return axios
+  const profile = readProfile();
+  axios.defaults.headers.common.Authorization = `Bearer ${profile.token}`;
+  const CACert = await getCACert(profile);
+  axios.defaults.httpsAgent = new https.Agent({ ca: CACert });
+  return axios;
 }
 
 // Read the CA Cert from profile, if present, test that it works, and return it so that we can set the request agent cert.
@@ -99,47 +96,49 @@ async function getCACert (profile) {
   if (!profile.CACert) {
     // No cert present. Make a request (which we expect to fail) to check if the failure is due to the self-signed cert
     try {
-      await superagent.get(`${profile.endpoint}/api/v1/ready`)
+      await superagent.get(`${profile.endpoint}/api/v1/ready`);
     } catch (e) {
       if (!e.response && e.code === 'DEPTH_ZERO_SELF_SIGNED_CERT') {
-        return await reRequestInsecure(profile.endpoint)
+        return await reRequestInsecure(profile.endpoint);
       }
 
-      throw e // rethrow other errors
+      throw e; // rethrow other errors
     }
   }
 
   // load and try the existing cert:
   try {
-    await superagent
-      .get(`${profile.endpoint}/api/v1/ready`)
-      .ca(profile.CACert)
+    await superagent.get(`${profile.endpoint}/api/v1/ready`).ca(profile.CACert);
 
-    return profile.CACert
+    return profile.CACert;
   } catch (e) {
     if (!e.response && e.code === 'DEPTH_ZERO_SELF_SIGNED_CERT') {
-      return await reRequestInsecure(profile.endpoint)
+      return await reRequestInsecure(profile.endpoint);
     }
 
-    throw e // rethrow other errors
+    throw e; // rethrow other errors
   }
 }
 
 async function reRequestInsecure (endpoint) {
   // Make the request again, this time ignoring SSL errors so we can get the certificate from the response
-  const res = await superagent
-    .get(`${endpoint}/api/v1/ready`)
-    .disableTLSCerts()
+  const res = await superagent.get(`${endpoint}/api/v1/ready`).disableTLSCerts();
 
   // Take the received cert, format it properly and write to profile
-  const certDERFormat = res.res.socket.getPeerCertificate(true).raw
-  const certPEMFormat = '-----BEGIN CERTIFICATE-----\n' + certDERFormat.toString('base64').match(/.{0,64}/g).join('\n') + '-----END CERTIFICATE-----'
-  await updateProfile({ CACert: certPEMFormat })
-
-  return certPEMFormat
+  const certDERFormat = res.res.socket.getPeerCertificate(true).raw;
+  const certPEMFormat =
+    '-----BEGIN CERTIFICATE-----\n' +
+    certDERFormat
+      .toString('base64')
+      .match(/.{0,64}/g)
+      .join('\n') +
+    '-----END CERTIFICATE-----';
+  await updateProfile({ CACert: certPEMFormat });
+
+  return certPEMFormat;
 }
 
-const validateNonEmpty = (input) => input !== ''
+const validateNonEmpty = (input) => input !== '';
 
 module.exports = {
   waitForState,
@@ -150,5 +149,5 @@ module.exports = {
   validateNonEmpty,
   getCACert,
   sleep,
-  waitForIntervalMilliSec
-}
+  waitForIntervalMilliSec,
+};

package/test/test.js

@@ -1,85 +1,84 @@
-const { exec } = require('child_process')
-const { promisify } = require('util')
-const fs = require('fs')
-const path = require('path')
-const execp = promisify(exec)
-const assert = require('node:assert').strict
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const fs = require('fs');
+const path = require('path');
+const execp = promisify(exec);
+const assert = require('node:assert').strict;
 
-test()
-  .catch(e => console.error(e))
+test().catch((e) => console.error(e));
 
 async function test () {
-  await testProjects()
-  await testInstances()
-  await testProjectGetOvpnConfig()
+  await testProjects();
+  await testInstances();
+  await testProjectGetOvpnConfig();
 }
 
 async function testInstances () {
-  const projectId = (await ej('project create --cores 20 --instances 10 --ram 5000 CoolNewProject'))[0].id
+  const projectId = (await ej('project create --cores 6 --instances 1 --ram 5000 CoolNewProject'))[0].id;
 
-  const { state, id: instanceId } = (await ej(`instance create ranchu 12.0.0 ${projectId}`))[0]
-  assert.equal(state, 'creating')
+  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))
+  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 e(`instance delete ${instanceId}`);
 
-  await pollUntilNoThrow(instanceId)
+  await pollUntilNoThrow(instanceId);
 
   // Cleanup
-  await e(`project delete ${projectId}`)
+  await e(`project delete ${projectId}`);
 }
 
 async function testProjects () {
-  const { id: projectId } = (await ej('project create --cores 10 --instances 2 --ram 2000 CoolNewProject'))[0]
+  const { id: projectId } = (await ej('project create --cores 6 --instances 1 --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))
+  let projects = await ej('project list');
+  assert.ok(projects.map((p) => p.id).includes(projectId));
 
-  await e(`project delete ${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))
+  projects = await ej('project list');
+  assert.equal(-1, projects.map((p) => p.id).indexOf(projectId));
 }
 
 async function testProjectGetOvpnConfig () {
-  const projects = (await ej('project list'))
-  const defaultProject = projects.find((p) => p.name === 'Default Project')
-  assert.ok(defaultProject)
+  const projects = await ej('project list');
+  const defaultProject = projects.find((p) => p.name === 'Default Project');
+  assert.ok(defaultProject);
 
-  const instanceId = (await e(`instance create ranchu 12.0.0 ${defaultProject.id}`))
-  assert.ok(instanceId)
+  const instanceId = await e(`instance create ranchu 12.0.0 ${defaultProject.id}`);
+  assert.ok(instanceId);
 
-  await e(`project vpnConfig ${defaultProject.id} ./test/test.ovpn`)
-  assert.ok(fs.existsSync('./test/test.ovpn'))
+  await e(`project vpnConfig ${defaultProject.id} ./test/test.ovpn`);
+  assert.ok(fs.existsSync('./test/test.ovpn'));
 
-  await e(`instance delete ${instanceId}`)
+  await e(`instance delete ${instanceId}`);
 }
 
 async function sleep (ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 async function pollUntilNoThrow (instanceId, tries = 1) {
   if (tries > 10) {
-    return
+    return;
   }
-  console.log(`try ${tries} looking for ${instanceId}`)
+  console.log(`try ${tries} looking for ${instanceId}`);
 
   try {
-    const instances = await ej('instance list')
-    assert.equal(-1, instances.map(i => i.id).indexOf(instanceId))
+    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)
+      const ms = 1 + Math.random() * (2 ** tries * 10);
+      await sleep(ms);
+      await pollUntilNoThrow(instanceId, tries + 1);
     } else {
-      throw err
+      throw err;
     }
   }
 }
@@ -87,19 +86,19 @@ async function pollUntilNoThrow (instanceId, tries = 1) {
 // 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, '../') })
+  const { stdout, stderr } = await execp(`node index.js ${s} --format json`, { cwd: path.join(__dirname, '../') });
   if (stderr) {
-    console.log(stderr)
+    console.log(stderr);
   }
-  return JSON.parse(stdout)
+  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, '../') })
+  const { stdout, stderr } = await execp(`node index.js ${s}`, { cwd: path.join(__dirname, '../') });
   if (stderr) {
-    console.log(stderr)
+    console.log(stderr);
   }
-  return stdout
+  return stdout;
 }

package/coverage/cobertura-coverage.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" ?>
-<!DOCTYPE coverage SYSTEM "http://cobertura.sourceforge.net/xml/coverage-04.dtd">
-<coverage lines-valid="0" lines-covered="0" line-rate="NaN" branches-valid="0" branches-covered="0" branch-rate="NaN" timestamp="1736549777655" complexity="0" version="0.1">
-  <sources>
-    <source>/builds/middleware/corellium-cli</source>
-  </sources>
-  <packages>
-  </packages>
-</coverage>