@rockcarver/frodo-cli 2.0.0-4 → 2.0.0-41

package/esm/ops/AgentOps.js

@@ -1,7 +1,37 @@
 import { frodo, state } from '@rockcarver/frodo-lib';
 import fs from 'fs';
-import { printMessage, createTable, debugMessage, showSpinner, succeedSpinner, failSpinner } from '../utils/Console';
-import { getTypedFilename, saveJsonToFile, titleCase } from '../utils/ExportImportUtils';
+import { createProgressIndicator, createTable, debugMessage, printMessage, stopProgressIndicator } from '../utils/Console';
+const {
+  getRealmName,
+  getTypedFilename,
+  saveJsonToFile,
+  titleCase,
+  getFilePath,
+  getWorkingDirectory
+} = frodo.utils;
+const {
+  createAgentExportTemplate,
+  readAgents,
+  readIdentityGatewayAgents,
+  readJavaAgents,
+  readWebAgents,
+  exportAgents,
+  exportIdentityGatewayAgents,
+  exportJavaAgents,
+  exportWebAgents,
+  exportAgent,
+  exportIdentityGatewayAgent,
+  exportJavaAgent,
+  exportWebAgent,
+  importAgent,
+  importIdentityGatewayAgent,
+  importJavaAgent,
+  importWebAgent,
+  importAgents,
+  importIdentityGatewayAgents,
+  importJavaAgents,
+  importWebAgents
+} = frodo.agent;
 const agentTypeToFileIdMap = {
   IdentityGatewayAgent: 'gateway.agent',
   J2EEAgent: 'java.agent',
@@ -13,7 +43,7 @@ const agentTypeToFileIdMap = {
  */
 export async function listAgents(long = false) {
   try {
-    const agents = await frodo.agent.getAgents();
+    const agents = await readAgents();
     if (long) {
       const table = createTable(['Agent Id', 'Status', 'Agent Type']);
       for (const agent of agents) {
@@ -48,7 +78,7 @@ export async function listAgents(long = false) {
  */
 export async function listIdentityGatewayAgents(long = false) {
   try {
-    const agents = await frodo.agent.getIdentityGatewayAgents();
+    const agents = await readIdentityGatewayAgents();
     if (long) {
       const table = createTable(['Gateway Agent Id', 'Status']);
       for (const agent of agents) {
@@ -71,7 +101,7 @@ export async function listIdentityGatewayAgents(long = false) {
  */
 export async function listJavaAgents(long = false) {
   try {
-    const agents = await frodo.agent.getJavaAgents();
+    const agents = await readJavaAgents();
     if (long) {
       const table = createTable(['Java Agent Id', 'Status']);
       for (const agent of agents) {
@@ -94,7 +124,7 @@ export async function listJavaAgents(long = false) {
  */
 export async function listWebAgents(long = false) {
   try {
-    const agents = await frodo.agent.getWebAgents();
+    const agents = await readWebAgents();
     if (long) {
       const table = createTable(['Web Agent Id', 'Status']);
       for (const agent of agents) {
@@ -115,163 +145,176 @@ export async function listWebAgents(long = false) {
 /**
  * Export all agents to file
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportAgentsToFile(file) {
-  const exportData = await frodo.agent.exportAgents();
-  let fileName = getTypedFilename(`all${titleCase(frodo.helper.utils.getRealmName(state.getRealm()))}Agents`, 'agent');
+export async function exportAgentsToFile(file, includeMeta = true) {
+  const exportData = await exportAgents();
+  let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, 'agent');
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export all identity gateway agents to file
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportIdentityGatewayAgentsToFile(file) {
-  const exportData = await frodo.agent.exportIdentityGatewayAgents();
-  let fileName = getTypedFilename(`all${titleCase(frodo.helper.utils.getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['IdentityGatewayAgent']);
+export async function exportIdentityGatewayAgentsToFile(file, includeMeta = true) {
+  const exportData = await exportIdentityGatewayAgents();
+  let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['IdentityGatewayAgent']);
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export all java agents to file
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportJavaAgentsToFile(file) {
-  const exportData = await frodo.agent.exportJavaAgents();
-  let fileName = getTypedFilename(`all${titleCase(frodo.helper.utils.getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['J2EEAgent']);
+export async function exportJavaAgentsToFile(file, includeMeta = true) {
+  const exportData = await exportJavaAgents();
+  let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['J2EEAgent']);
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export all web agents to file
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportWebAgentsToFile(file) {
-  const exportData = await frodo.agent.exportWebAgents();
-  let fileName = getTypedFilename(`all${titleCase(frodo.helper.utils.getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['WebAgent']);
+export async function exportWebAgentsToFile(file, includeMeta = true) {
+  const exportData = await exportWebAgents();
+  let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['WebAgent']);
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export agent to file
  * @param {string} agentId agent id
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportAgent(agentId);
+export async function exportAgentToFile(agentId, file, includeMeta = true) {
+  const exportData = await exportAgent(agentId);
   let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export identity gateway agent to file
  * @param {string} agentId agent id
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportIdentityGatewayAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportIdentityGatewayAgent(agentId);
+export async function exportIdentityGatewayAgentToFile(agentId, file, includeMeta = true) {
+  const exportData = await exportIdentityGatewayAgent(agentId);
   let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export java agent to file
  * @param {string} agentId agent id
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportJavaAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportJavaAgent(agentId);
+export async function exportJavaAgentToFile(agentId, file, includeMeta = true) {
+  const exportData = await exportJavaAgent(agentId);
   let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export web agent to file
  * @param {string} agentId agent id
  * @param {string} file file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportWebAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportWebAgent(agentId);
+export async function exportWebAgentToFile(agentId, file, includeMeta = true) {
+  const exportData = await exportWebAgent(agentId);
   let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
   if (file) {
     fileName = file;
   }
-  saveJsonToFile(exportData, fileName);
+  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
 }
 
 /**
  * Export all agents to separate files
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportAgentsToFiles() {
-  const agents = await frodo.agent.getAgents();
+export async function exportAgentsToFiles(includeMeta = true) {
+  const agents = await readAgents();
   debugMessage(`exportAgentsToFiles: ${agents.length} agents`);
   for (const agent of agents) {
     const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
-    const exportData = frodo.agent.createAgentExportTemplate();
+    const filePath = getFilePath(fileName, true);
+    const exportData = createAgentExportTemplate();
     exportData.agents[agent._id] = agent;
-    debugMessage(`exportAgentsToFiles: exporting ${agent._id} to ${fileName}`);
-    saveJsonToFile(exportData, fileName);
+    debugMessage(`exportAgentsToFiles: exporting ${agent._id} to ${filePath}`);
+    saveJsonToFile(exportData, filePath, includeMeta);
   }
   debugMessage(`exportAgentsToFiles: done.`);
 }
 
 /**
  * Export all identity gateway agents to separate files
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportIdentityGatewayAgentsToFiles() {
-  const agents = await frodo.agent.getIdentityGatewayAgents();
+export async function exportIdentityGatewayAgentsToFiles(includeMeta = true) {
+  const agents = await readIdentityGatewayAgents();
   for (const agent of agents) {
     const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
-    const exportData = frodo.agent.createAgentExportTemplate();
+    const exportData = createAgentExportTemplate();
     exportData.agents[agent._id] = agent;
-    saveJsonToFile(exportData, fileName);
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
   }
 }
 
 /**
  * Export all java agents to separate files
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportJavaAgentsToFiles() {
-  const agents = await frodo.agent.getJavaAgents();
+export async function exportJavaAgentsToFiles(includeMeta = true) {
+  const agents = await readJavaAgents();
   for (const agent of agents) {
     const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
-    const exportData = frodo.agent.createAgentExportTemplate();
+    const exportData = createAgentExportTemplate();
     exportData.agents[agent._id] = agent;
-    saveJsonToFile(exportData, fileName);
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
   }
 }
 
 /**
  * Export all web agents to separate files
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  */
-export async function exportWebAgentsToFiles() {
-  const agents = await frodo.agent.getWebAgents();
+export async function exportWebAgentsToFiles(includeMeta = true) {
+  const agents = await readWebAgents();
   for (const agent of agents) {
     const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
-    const exportData = frodo.agent.createAgentExportTemplate();
+    const exportData = createAgentExportTemplate();
     exportData.agents[agent._id] = agent;
-    saveJsonToFile(exportData, fileName);
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
   }
 }
 
@@ -282,29 +325,32 @@ export async function exportWebAgentsToFiles() {
  */
 export async function importAgentFromFile(agentId, file) {
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
-    let importData = JSON.parse(data);
+    const importData = JSON.parse(data);
     // check if this is a file with multiple agents and get agent by id
     if (importData.agents && importData.agents[agentId]) {
-      importData = importData.agents[agentId];
+      const agent = importData.agents[agentId];
+      importData.agents = {};
+      importData.agents[agentId] = agent;
     } else if (importData.agents) {
-      importData = null;
+      importData.agents = null;
     }
     // if an agentId was specified, only import the matching agent
-    if (importData && agentId === importData.agents._id) {
-      if (!verbose) showSpinner(`Importing ${agentId}...`);
+    let spinnerId;
+    if (importData.agents) {
+      if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       try {
-        if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importAgent(agentId, importData);
-        succeedSpinner(`Imported ${agentId}.`);
+        if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+        await importAgent(agentId, importData);
+        stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
       } catch (importError) {
-        if (verbose) showSpinner(`Importing ${agentId}...`);
-        failSpinner(`${importError}`);
+        if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
       }
     } else {
-      showSpinner(`Importing ${agentId}...`);
-      failSpinner(`${agentId} not found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+      stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
   });
 }
@@ -315,25 +361,26 @@ export async function importAgentFromFile(agentId, file) {
  */
 export async function importFirstAgentFromFile(file) {
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
     const importData = JSON.parse(data);
+    let spinnerId;
     if (Object.keys(importData.agents).length > 0) {
       for (const agent of Object.values(importData.agents)) {
-        if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
+        if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
         try {
-          if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importAgent(agent['_id'], importData);
-          succeedSpinner(`Imported ${agent['_id']}.`);
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          await importAgent(agent['_id'], importData);
+          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
         } catch (importError) {
-          if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          failSpinner(`${importError}`);
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          stopProgressIndicator(spinnerId, `${importError}`, 'fail');
         }
         return;
       }
     } else {
-      showSpinner(`Importing...`);
-      failSpinner(`No agents found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
+      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
   });
 }
@@ -344,12 +391,13 @@ export async function importFirstAgentFromFile(file) {
  */
 export async function importAgentsFromFile(file) {
   debugMessage(`importAgentsFromFile: start`);
-  fs.readFile(file, 'utf8', async (err, data) => {
+  const filePath = getFilePath(file);
+  fs.readFile(filePath, 'utf8', async (err, data) => {
     if (err) throw err;
-    debugMessage(`importAgentsFromFile: importing ${file}`);
+    debugMessage(`importAgentsFromFile: importing ${filePath}`);
     const importData = JSON.parse(data);
     try {
-      await frodo.agent.importAgents(importData);
+      await importAgents(importData);
     } catch (error) {
       printMessage(`${error.message}`, 'error');
       printMessage(error.response.status, 'error');
@@ -362,7 +410,7 @@ export async function importAgentsFromFile(file) {
  * Import all agents from separate files
  */
 export async function importAgentsFromFiles() {
-  const names = fs.readdirSync('.');
+  const names = fs.readdirSync(getWorkingDirectory());
   const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
   for (const file of agentFiles) {
     await importAgentsFromFile(file);
@@ -377,28 +425,31 @@ export async function importAgentsFromFiles() {
 export async function importIdentityGatewayAgentFromFile(agentId, file) {
   debugMessage(`cli.AgentOps.importIdentityGatewayAgentFromFile: start`);
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
-    let importData = JSON.parse(data);
+    const importData = JSON.parse(data);
     // check if this is a file with multiple agents and get agent by id
     if (importData.agents && importData.agents[agentId]) {
-      importData = importData.agents[agentId];
+      const agent = importData.agents[agentId];
+      importData.agents = {};
+      importData.agents[agentId] = agent;
     } else if (importData.agents) {
-      importData = null;
+      importData.agents = null;
     }
     // if an agentId was specified, only import the matching agent
-    if (importData && agentId === importData.agents._id) {
-      if (!verbose) showSpinner(`Importing ${agentId}...`);
+    let spinnerId;
+    if (importData.agents) {
+      if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       try {
-        if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importIdentityGatewayAgent(agentId, importData);
-        succeedSpinner(`Imported ${agentId}.`);
+        if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+        await importIdentityGatewayAgent(agentId, importData);
+        stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
       } catch (importError) {
-        failSpinner(`${importError}`);
+        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
       }
     } else {
-      showSpinner(`Importing ${agentId}...`);
-      failSpinner(`${agentId} not found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+      stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importIdentityGatewayAgentFromFile: end`);
   });
@@ -411,24 +462,25 @@ export async function importIdentityGatewayAgentFromFile(agentId, file) {
 export async function importFirstIdentityGatewayAgentFromFile(file) {
   debugMessage(`cli.AgentOps.importFirstIdentityGatewayAgentFromFile: start`);
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
     const importData = JSON.parse(data);
+    let spinnerId;
     if (Object.keys(importData.agents).length > 0) {
       for (const agent of Object.values(importData.agents)) {
-        if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
+        if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
         try {
-          if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importIdentityGatewayAgent(agent['_id'], importData);
-          succeedSpinner(`Imported ${agent['_id']}.`);
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          await importIdentityGatewayAgent(agent['_id'], importData);
+          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
         } catch (importError) {
-          failSpinner(`${importError}`);
+          stopProgressIndicator(spinnerId, `${importError}`, 'fail');
         }
         return;
       }
     } else {
-      showSpinner(`Importing...`);
-      failSpinner(`No agents found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
+      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importFirstIdentityGatewayAgentFromFile: end`);
   });
@@ -440,12 +492,13 @@ export async function importFirstIdentityGatewayAgentFromFile(file) {
  */
 export async function importIdentityGatewayAgentsFromFile(file) {
   debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: start`);
-  fs.readFile(file, 'utf8', async (err, data) => {
+  const filePath = getFilePath(file);
+  fs.readFile(filePath, 'utf8', async (err, data) => {
     if (err) throw err;
-    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: importing ${file}`);
+    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: importing ${filePath}`);
     const importData = JSON.parse(data);
     try {
-      await frodo.agent.importIdentityGatewayAgents(importData);
+      await importIdentityGatewayAgents(importData);
     } catch (error) {
       printMessage(`${error.message}`, 'error');
       printMessage(error.response.status, 'error');
@@ -459,7 +512,7 @@ export async function importIdentityGatewayAgentsFromFile(file) {
  */
 export async function importIdentityGatewayAgentsFromFiles() {
   debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFiles: start`);
-  const names = fs.readdirSync('.');
+  const names = fs.readdirSync(getWorkingDirectory());
   const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
   for (const file of agentFiles) {
     await importIdentityGatewayAgentsFromFile(file);
@@ -475,28 +528,31 @@ export async function importIdentityGatewayAgentsFromFiles() {
 export async function importJavaAgentFromFile(agentId, file) {
   debugMessage(`cli.AgentOps.importJavaAgentFromFile: start`);
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
-    let importData = JSON.parse(data);
+    const importData = JSON.parse(data);
     // check if this is a file with multiple agents and get agent by id
     if (importData.agents && importData.agents[agentId]) {
-      importData = importData.agents[agentId];
+      const agent = importData.agents[agentId];
+      importData.agents = {};
+      importData.agents[agentId] = agent;
     } else if (importData.agents) {
-      importData = null;
+      importData.agents = null;
     }
     // if an agentId was specified, only import the matching agent
-    if (importData && agentId === importData.agents._id) {
-      if (!verbose) showSpinner(`Importing ${agentId}...`);
+    let spinnerId;
+    if (importData.agents) {
+      if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       try {
-        if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importJavaAgent(agentId, importData);
-        succeedSpinner(`Imported ${agentId}.`);
+        if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+        await importJavaAgent(agentId, importData);
+        stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
       } catch (importError) {
-        failSpinner(`${importError}`);
+        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
       }
     } else {
-      showSpinner(`Importing ${agentId}...`);
-      failSpinner(`${agentId} not found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+      stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importJavaAgentFromFile: end`);
   });
@@ -509,24 +565,25 @@ export async function importJavaAgentFromFile(agentId, file) {
 export async function importFirstJavaAgentFromFile(file) {
   debugMessage(`cli.AgentOps.importFirstJavaAgentFromFile: start`);
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
     const importData = JSON.parse(data);
+    let spinnerId;
     if (Object.keys(importData.agents).length > 0) {
       for (const agent of Object.values(importData.agents)) {
-        if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
+        if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
         try {
-          if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importJavaAgent(agent['_id'], importData);
-          succeedSpinner(`Imported ${agent['_id']}.`);
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          await importJavaAgent(agent['_id'], importData);
+          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
         } catch (importError) {
-          failSpinner(`${importError}`);
+          stopProgressIndicator(spinnerId, `${importError}`, 'fail');
         }
         return;
       }
     } else {
-      showSpinner(`Importing...`);
-      failSpinner(`No agents found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
+      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importFirstJavaAgentFromFile: end`);
   });
@@ -538,12 +595,13 @@ export async function importFirstJavaAgentFromFile(file) {
  */
 export async function importJavaAgentsFromFile(file) {
   debugMessage(`cli.AgentOps.importJavaAgentsFromFile: start`);
-  fs.readFile(file, 'utf8', async (err, data) => {
+  const filePath = getFilePath(file);
+  fs.readFile(filePath, 'utf8', async (err, data) => {
     if (err) throw err;
-    debugMessage(`cli.AgentOps.importJavaAgentsFromFile: importing ${file}`);
+    debugMessage(`cli.AgentOps.importJavaAgentsFromFile: importing ${filePath}`);
     const importData = JSON.parse(data);
     try {
-      await frodo.agent.importJavaAgents(importData);
+      await importJavaAgents(importData);
     } catch (error) {
       printMessage(`${error.message}`, 'error');
       printMessage(error.response.status, 'error');
@@ -557,7 +615,7 @@ export async function importJavaAgentsFromFile(file) {
  */
 export async function importJavaAgentsFromFiles() {
   debugMessage(`cli.AgentOps.importJavaAgentsFromFiles: start`);
-  const names = fs.readdirSync('.');
+  const names = fs.readdirSync(getWorkingDirectory());
   const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
   for (const file of agentFiles) {
     await importJavaAgentsFromFile(file);
@@ -573,28 +631,31 @@ export async function importJavaAgentsFromFiles() {
 export async function importWebAgentFromFile(agentId, file) {
   debugMessage(`cli.AgentOps.importWebAgentFromFile: start`);
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
-    let importData = JSON.parse(data);
+    const importData = JSON.parse(data);
     // check if this is a file with multiple agents and get agent by id
     if (importData.agents && importData.agents[agentId]) {
-      importData = importData.agents[agentId];
+      const agent = importData.agents[agentId];
+      importData.agents = {};
+      importData.agents[agentId] = agent;
     } else if (importData.agents) {
-      importData = null;
+      importData.agents = null;
     }
     // if an agentId was specified, only import the matching agent
-    if (importData && agentId === importData.agents._id) {
-      if (!verbose) showSpinner(`Importing ${agentId}...`);
+    let spinnerId;
+    if (importData.agents) {
+      if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       try {
-        if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importWebAgent(agentId, importData);
-        succeedSpinner(`Imported ${agentId}.`);
+        if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+        await importWebAgent(agentId, importData);
+        stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
       } catch (importError) {
-        failSpinner(`${importError}`);
+        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
       }
     } else {
-      showSpinner(`Importing ${agentId}...`);
-      failSpinner(`${agentId} not found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+      stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importWebAgentFromFile: end`);
   });
@@ -607,24 +668,25 @@ export async function importWebAgentFromFile(agentId, file) {
 export async function importFirstWebAgentFromFile(file) {
   debugMessage(`cli.AgentOps.importFirstWebAgentFromFile: start`);
   const verbose = state.getVerbose();
-  fs.readFile(file, 'utf8', async (err, data) => {
+  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
     if (err) throw err;
     const importData = JSON.parse(data);
+    let spinnerId;
     if (Object.keys(importData.agents).length > 0) {
       for (const agent of Object.values(importData.agents)) {
-        if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
+        if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
         try {
-          if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importWebAgent(agent['_id'], importData);
-          succeedSpinner(`Imported ${agent['_id']}.`);
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          await importWebAgent(agent['_id'], importData);
+          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
         } catch (importError) {
-          failSpinner(`caught it here ${importError}`);
+          stopProgressIndicator(spinnerId, `caught it here ${importError}`, 'fail');
         }
         break;
       }
     } else {
-      showSpinner(`Importing...`);
-      failSpinner(`No agents found!`);
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
+      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importFirstWebAgentFromFile: end`);
   });
@@ -636,12 +698,13 @@ export async function importFirstWebAgentFromFile(file) {
  */
 export async function importWebAgentsFromFile(file) {
   debugMessage(`cli.AgentOps.importWebAgentsFromFile: start`);
-  fs.readFile(file, 'utf8', async (err, data) => {
+  const filePath = getFilePath(file);
+  fs.readFile(filePath, 'utf8', async (err, data) => {
     if (err) throw err;
-    debugMessage(`cli.AgentOps.importWebAgentsFromFile: importing ${file}`);
+    debugMessage(`cli.AgentOps.importWebAgentsFromFile: importing ${filePath}`);
     const importData = JSON.parse(data);
     try {
-      await frodo.agent.importWebAgents(importData);
+      await importWebAgents(importData);
     } catch (error) {
       printMessage(`${error.message}`, 'error');
       printMessage(error.response.status, 'error');
@@ -655,11 +718,11 @@ export async function importWebAgentsFromFile(file) {
  */
 export async function importWebAgentsFromFiles() {
   debugMessage(`cli.AgentOps.importWebAgentsFromFiles: start`);
-  const names = fs.readdirSync('.');
+  const names = fs.readdirSync(getWorkingDirectory());
   const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
   for (const file of agentFiles) {
     await importWebAgentsFromFile(file);
   }
   debugMessage(`cli.AgentOps.importWebAgentsFromFiles: end`);
 }
-//# sourceMappingURL=AgentOps.js.map
+//# sourceMappingURL=AgentOps.js.map