@rockcarver/frodo-cli 2.0.0-51 → 2.0.0-53

package/esm/ops/AgentOps.js

@@ -1,6 +1,6 @@
-import { frodo, state } from '@rockcarver/frodo-lib';
+import { frodo, FrodoError, state } from '@rockcarver/frodo-lib';
 import fs from 'fs';
-import { createProgressIndicator, createTable, debugMessage, printMessage, stopProgressIndicator } from '../utils/Console';
+import { createProgressIndicator, createTable, debugMessage, printError, printMessage, stopProgressIndicator } from '../utils/Console';
 const {
   getRealmName,
   getTypedFilename,
@@ -40,6 +40,7 @@ const agentTypeToFileIdMap = {
 
 /**
  * List agents
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function listAgents(long = false) {
   try {
@@ -67,14 +68,16 @@ export async function listAgents(long = false) {
         printMessage(`${agent._id}`, 'data');
       });
     }
+    return true;
   } catch (error) {
-    printMessage(`Error listing agents - ${error}`, 'error');
-    printMessage(error.stack, 'error');
+    printError(error, `Error listing agents`);
   }
+  return false;
 }
 
 /**
  * List identity gateway agents
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function listIdentityGatewayAgents(long = false) {
   try {
@@ -90,14 +93,16 @@ export async function listIdentityGatewayAgents(long = false) {
         printMessage(`${agent._id}`, 'data');
       });
     }
+    return true;
   } catch (error) {
-    printMessage(`Error listing gateway agents - ${error}`, 'error');
-    printMessage(error.stack, 'error');
+    printError(error, `Error listing gateway agents`);
   }
+  return false;
 }
 
 /**
  * List java agents
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function listJavaAgents(long = false) {
   try {
@@ -113,14 +118,16 @@ export async function listJavaAgents(long = false) {
         printMessage(`${agent._id}`, 'data');
       });
     }
+    return true;
   } catch (error) {
-    printMessage(`Error listing java agents - ${error}`, 'error');
-    printMessage(error.stack, 'error');
+    printError(error, `Error listing java agents`);
   }
+  return false;
 }
 
 /**
  * List web agents
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function listWebAgents(long = false) {
   try {
@@ -136,66 +143,95 @@ export async function listWebAgents(long = false) {
         printMessage(`${agent._id}`, 'data');
       });
     }
+    return true;
   } catch (error) {
-    printMessage(`Error listing web agents - ${error}`, 'error');
-    printMessage(error.stack, 'error');
+    printError(error, `Error listing web agents`);
   }
+  return false;
 }
 
 /**
  * Export all agents to file
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportAgents();
+    let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, 'agent');
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting agents to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
  * Export all identity gateway agents to file
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportIdentityGatewayAgents();
+    let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['IdentityGatewayAgent']);
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting identity gateway agents to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
  * Export all java agents to file
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportJavaAgents();
+    let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['J2EEAgent']);
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting java agents to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
  * Export all web agents to file
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportWebAgents();
+    let fileName = getTypedFilename(`all${titleCase(getRealmName(state.getRealm()))}Agents`, agentTypeToFileIdMap['WebAgent']);
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting web agents to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
@@ -203,14 +239,21 @@ export async function exportWebAgentsToFile(file, includeMeta = true) {
  * @param {string} agentId agent id
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportAgent(agentId);
+    let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting agent ${agentId} to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
@@ -218,14 +261,21 @@ export async function exportAgentToFile(agentId, file, includeMeta = true) {
  * @param {string} agentId agent id
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportIdentityGatewayAgent(agentId);
+    let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting identity gateway agent ${agentId} to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
@@ -233,14 +283,21 @@ export async function exportIdentityGatewayAgentToFile(agentId, file, includeMet
  * @param {string} agentId agent id
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportJavaAgent(agentId);
+    let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting java agent ${agentId} to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
@@ -248,85 +305,121 @@ export async function exportJavaAgentToFile(agentId, file, includeMeta = true) {
  * @param {string} agentId agent id
  * @param {string} file file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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;
+  try {
+    const exportData = await exportWebAgent(agentId);
+    let fileName = getTypedFilename(agentId, agentTypeToFileIdMap[exportData.agents[agentId]._type._id]);
+    if (file) {
+      fileName = file;
+    }
+    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting web agent ${agentId} to file`);
   }
-  saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  return false;
 }
 
 /**
  * Export all agents to separate files
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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 filePath = getFilePath(fileName, true);
-    const exportData = createAgentExportTemplate();
-    exportData.agents[agent._id] = agent;
-    debugMessage(`exportAgentsToFiles: exporting ${agent._id} to ${filePath}`);
-    saveJsonToFile(exportData, filePath, includeMeta);
+  try {
+    const agents = await readAgents();
+    debugMessage(`exportAgentsToFiles: ${agents.length} agents`);
+    for (const agent of agents) {
+      const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
+      const filePath = getFilePath(fileName, true);
+      const exportData = createAgentExportTemplate();
+      exportData.agents[agent._id] = agent;
+      debugMessage(`exportAgentsToFiles: exporting ${agent._id} to ${filePath}`);
+      saveJsonToFile(exportData, filePath, includeMeta);
+    }
+    debugMessage(`exportAgentsToFiles: done.`);
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting agents to files`);
   }
-  debugMessage(`exportAgentsToFiles: done.`);
+  return false;
 }
 
 /**
  * Export all identity gateway agents to separate files
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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 = createAgentExportTemplate();
-    exportData.agents[agent._id] = agent;
-    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  try {
+    const agents = await readIdentityGatewayAgents();
+    for (const agent of agents) {
+      const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
+      const exportData = createAgentExportTemplate();
+      exportData.agents[agent._id] = agent;
+      saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    }
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting identity gateway agents to files`);
   }
+  return false;
 }
 
 /**
  * Export all java agents to separate files
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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 = createAgentExportTemplate();
-    exportData.agents[agent._id] = agent;
-    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  try {
+    const agents = await readJavaAgents();
+    for (const agent of agents) {
+      const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
+      const exportData = createAgentExportTemplate();
+      exportData.agents[agent._id] = agent;
+      saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    }
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting java agents to files`);
   }
+  return false;
 }
 
 /**
  * Export all web agents to separate files
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 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 = createAgentExportTemplate();
-    exportData.agents[agent._id] = agent;
-    saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+  try {
+    const agents = await readWebAgents();
+    for (const agent of agents) {
+      const fileName = getTypedFilename(agent._id, agentTypeToFileIdMap[agent._type._id]);
+      const exportData = createAgentExportTemplate();
+      exportData.agents[agent._id] = agent;
+      saveJsonToFile(exportData, getFilePath(fileName, true), includeMeta);
+    }
+    return true;
+  } catch (error) {
+    printError(error, `Error exporting web agents to files`);
   }
+  return false;
 }
 
 /**
  * Import an agent from file
  * @param {string} agentId agent id/name
  * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function importAgentFromFile(agentId, file) {
-  const verbose = state.getVerbose();
-  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
-    if (err) throw err;
+  try {
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     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]) {
@@ -344,89 +437,33 @@ export async function importAgentFromFile(agentId, file) {
         if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
         await importAgent(agentId, importData);
         stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
-      } catch (importError) {
+        return true;
+      } catch (error) {
         if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
-        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
+        stopProgressIndicator(spinnerId, `Error importing agent ${agentId}`, 'fail');
+        printError(error, `Error importing agent ${agentId}`);
       }
     } else {
       spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
-  });
-}
-
-/**
- * Import first agent from file
- * @param {string} file import file name
- */
-export async function importFirstAgentFromFile(file) {
-  const verbose = state.getVerbose();
-  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) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
-        try {
-          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
-          await importAgent(agent['_id'], importData);
-          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
-        } catch (importError) {
-          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
-          stopProgressIndicator(spinnerId, `${importError}`, 'fail');
-        }
-        return;
-      }
-    } else {
-      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
-      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
-    }
-  });
-}
-
-/**
- * Import agents from file
- * @param {String} file file name
- */
-export async function importAgentsFromFile(file) {
-  debugMessage(`importAgentsFromFile: start`);
-  const filePath = getFilePath(file);
-  fs.readFile(filePath, 'utf8', async (err, data) => {
-    if (err) throw err;
-    debugMessage(`importAgentsFromFile: importing ${filePath}`);
-    const importData = JSON.parse(data);
-    try {
-      await importAgents(importData);
-    } catch (error) {
-      printMessage(`${error.message}`, 'error');
-      printMessage(error.response.status, 'error');
-    }
-    debugMessage(`importAgentsFromFile: end`);
-  });
-}
-
-/**
- * Import all agents from separate files
- */
-export async function importAgentsFromFiles() {
-  const names = fs.readdirSync(getWorkingDirectory());
-  const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
-  for (const file of agentFiles) {
-    await importAgentsFromFile(file);
+  } catch (error) {
+    printError(error, `Error importing agent ${agentId} from file`);
   }
+  return false;
 }
 
 /**
  * Import an identity gateway agent from file
  * @param {string} agentId agent id/name
  * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function importIdentityGatewayAgentFromFile(agentId, file) {
-  debugMessage(`cli.AgentOps.importIdentityGatewayAgentFromFile: start`);
-  const verbose = state.getVerbose();
-  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
-    if (err) throw err;
+  try {
+    debugMessage(`cli.AgentOps.importIdentityGatewayAgentFromFile: start`);
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     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]) {
@@ -444,92 +481,77 @@ export async function importIdentityGatewayAgentFromFile(agentId, file) {
         if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
         await importIdentityGatewayAgent(agentId, importData);
         stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
-      } catch (importError) {
-        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
+        return true;
+      } catch (error) {
+        stopProgressIndicator(spinnerId, `Error importing identity gateway agent ${agentId}`, 'fail');
+        printError(error, `Error importing identity gateway agent ${agentId}`);
       }
     } else {
       spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importIdentityGatewayAgentFromFile: end`);
-  });
+  } catch (error) {
+    printError(error, `Error importing identity gateway agent ${agentId} from file`);
+  }
+  return false;
 }
 
 /**
- * Import first identity gateway agent from file
+ * Import an java agent from file
+ * @param {string} agentId agent id/name
  * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
-export async function importFirstIdentityGatewayAgentFromFile(file) {
-  debugMessage(`cli.AgentOps.importFirstIdentityGatewayAgentFromFile: start`);
-  const verbose = state.getVerbose();
-  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
-    if (err) throw err;
+export async function importJavaAgentFromFile(agentId, file) {
+  try {
+    debugMessage(`cli.AgentOps.importJavaAgentFromFile: start`);
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     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]) {
+      const agent = importData.agents[agentId];
+      importData.agents = {};
+      importData.agents[agentId] = agent;
+    } else if (importData.agents) {
+      importData.agents = null;
+    }
+    // if an agentId was specified, only import the matching agent
     let spinnerId;
-    if (Object.keys(importData.agents).length > 0) {
-      for (const agent of Object.values(importData.agents)) {
-        if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
-        try {
-          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
-          await importIdentityGatewayAgent(agent['_id'], importData);
-          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
-        } catch (importError) {
-          stopProgressIndicator(spinnerId, `${importError}`, 'fail');
-        }
-        return;
+    if (importData.agents) {
+      if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+      try {
+        if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+        await importJavaAgent(agentId, importData);
+        stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
+        return true;
+      } catch (error) {
+        stopProgressIndicator(spinnerId, `Error importing java agent ${agentId}`, 'fail');
+        printError(error, `Error importing java agent ${agentId}`);
       }
     } else {
-      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
-      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
-    }
-    debugMessage(`cli.AgentOps.importFirstIdentityGatewayAgentFromFile: end`);
-  });
-}
-
-/**
- * Import identity gateway agents from file
- * @param {String} file file name
- */
-export async function importIdentityGatewayAgentsFromFile(file) {
-  debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: start`);
-  const filePath = getFilePath(file);
-  fs.readFile(filePath, 'utf8', async (err, data) => {
-    if (err) throw err;
-    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: importing ${filePath}`);
-    const importData = JSON.parse(data);
-    try {
-      await importIdentityGatewayAgents(importData);
-    } catch (error) {
-      printMessage(`${error.message}`, 'error');
-      printMessage(error.response.status, 'error');
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
+      stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
-    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: end`);
-  });
-}
-
-/**
- * Import all identity gateway agents from separate files
- */
-export async function importIdentityGatewayAgentsFromFiles() {
-  debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFiles: start`);
-  const names = fs.readdirSync(getWorkingDirectory());
-  const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
-  for (const file of agentFiles) {
-    await importIdentityGatewayAgentsFromFile(file);
+    debugMessage(`cli.AgentOps.importJavaAgentFromFile: end`);
+  } catch (error) {
+    printError(error, `Error importing java agent ${agentId} from file`);
   }
-  debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFiles: end`);
+  return false;
 }
 
 /**
- * Import an java agent from file
+ * Import an web agent from file
  * @param {string} agentId agent id/name
  * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
-export async function importJavaAgentFromFile(agentId, file) {
-  debugMessage(`cli.AgentOps.importJavaAgentFromFile: start`);
-  const verbose = state.getVerbose();
-  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
-    if (err) throw err;
+export async function importWebAgentFromFile(agentId, file) {
+  try {
+    debugMessage(`cli.AgentOps.importWebAgentFromFile: start`);
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     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]) {
@@ -545,28 +567,33 @@ export async function importJavaAgentFromFile(agentId, file) {
       if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       try {
         if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
-        await importJavaAgent(agentId, importData);
+        await importWebAgent(agentId, importData);
         stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
-      } catch (importError) {
-        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
+        return true;
+      } catch (error) {
+        stopProgressIndicator(spinnerId, `Error importing web agent ${agentId}`, 'fail');
+        printError(error, `Error importing web agent ${agentId}`);
       }
     } else {
       spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
       stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
     }
-    debugMessage(`cli.AgentOps.importJavaAgentFromFile: end`);
-  });
+    debugMessage(`cli.AgentOps.importWebAgentFromFile: end`);
+  } catch (error) {
+    printError(error, `Error importing web agent ${agentId} from file`);
+  }
+  return false;
 }
 
 /**
- * Import first java agent from file
+ * Import first agent from file
  * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
-export async function importFirstJavaAgentFromFile(file) {
-  debugMessage(`cli.AgentOps.importFirstJavaAgentFromFile: start`);
-  const verbose = state.getVerbose();
-  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
-    if (err) throw err;
+export async function importFirstAgentFromFile(file) {
+  try {
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     const importData = JSON.parse(data);
     let spinnerId;
     if (Object.keys(importData.agents).length > 0) {
@@ -574,10 +601,13 @@ export async function importFirstJavaAgentFromFile(file) {
         if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
         try {
           if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
-          await importJavaAgent(agent['_id'], importData);
+          await importAgent(agent['_id'], importData);
           stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
-        } catch (importError) {
-          stopProgressIndicator(spinnerId, `${importError}`, 'fail');
+          return true;
+        } catch (error) {
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          stopProgressIndicator(spinnerId, `${error}`, 'fail');
+          printError(error, `Error importing first agent`);
         }
         return;
       }
@@ -585,91 +615,94 @@ export async function importFirstJavaAgentFromFile(file) {
       spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
       stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
-    debugMessage(`cli.AgentOps.importFirstJavaAgentFromFile: end`);
-  });
+  } catch (error) {
+    printError(error, `Error importing first agent from file`);
+  }
+  return false;
 }
 
 /**
- * Import java agents from file
- * @param {String} file file name
+ * Import first identity gateway agent from file
+ * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
-export async function importJavaAgentsFromFile(file) {
-  debugMessage(`cli.AgentOps.importJavaAgentsFromFile: start`);
-  const filePath = getFilePath(file);
-  fs.readFile(filePath, 'utf8', async (err, data) => {
-    if (err) throw err;
-    debugMessage(`cli.AgentOps.importJavaAgentsFromFile: importing ${filePath}`);
+export async function importFirstIdentityGatewayAgentFromFile(file) {
+  try {
+    debugMessage(`cli.AgentOps.importFirstIdentityGatewayAgentFromFile: start`);
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     const importData = JSON.parse(data);
-    try {
-      await importJavaAgents(importData);
-    } catch (error) {
-      printMessage(`${error.message}`, 'error');
-      printMessage(error.response.status, 'error');
+    let spinnerId;
+    if (Object.keys(importData.agents).length > 0) {
+      for (const agent of Object.values(importData.agents)) {
+        if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+        try {
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          await importIdentityGatewayAgent(agent['_id'], importData);
+          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
+          return true;
+        } catch (error) {
+          stopProgressIndicator(spinnerId, `${error}`, 'fail');
+          printError(error, `Error importing first identity gateway agent from file`);
+        }
+      }
+    } else {
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
+      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
-    debugMessage(`cli.AgentOps.importJavaAgentsFromFile: end`);
-  });
-}
-
-/**
- * Import all java agents from separate files
- */
-export async function importJavaAgentsFromFiles() {
-  debugMessage(`cli.AgentOps.importJavaAgentsFromFiles: start`);
-  const names = fs.readdirSync(getWorkingDirectory());
-  const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
-  for (const file of agentFiles) {
-    await importJavaAgentsFromFile(file);
+    debugMessage(`cli.AgentOps.importFirstIdentityGatewayAgentFromFile: end`);
+  } catch (error) {
+    printError(error, `Error importing first identity gateway agent from file`);
   }
-  debugMessage(`cli.AgentOps.importJavaAgentsFromFiles: end`);
+  return false;
 }
 
 /**
- * Import an web agent from file
- * @param {string} agentId agent id/name
+ * Import first java agent from file
  * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
-export async function importWebAgentFromFile(agentId, file) {
-  debugMessage(`cli.AgentOps.importWebAgentFromFile: start`);
-  const verbose = state.getVerbose();
-  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
-    if (err) throw err;
+export async function importFirstJavaAgentFromFile(file) {
+  try {
+    debugMessage(`cli.AgentOps.importFirstJavaAgentFromFile: start`);
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     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]) {
-      const agent = importData.agents[agentId];
-      importData.agents = {};
-      importData.agents[agentId] = agent;
-    } else if (importData.agents) {
-      importData.agents = null;
-    }
-    // if an agentId was specified, only import the matching agent
     let spinnerId;
-    if (importData.agents) {
-      if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
-      try {
-        if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
-        await importWebAgent(agentId, importData);
-        stopProgressIndicator(spinnerId, `Imported ${agentId}.`, 'success');
-      } catch (importError) {
-        stopProgressIndicator(spinnerId, `${importError}`, 'fail');
+    if (Object.keys(importData.agents).length > 0) {
+      for (const agent of Object.values(importData.agents)) {
+        if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+        try {
+          if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
+          await importJavaAgent(agent['_id'], importData);
+          stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
+          return true;
+        } catch (importError) {
+          stopProgressIndicator(spinnerId, `${importError}`, 'fail');
+        }
+        return;
       }
     } else {
-      spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agentId}...`);
-      stopProgressIndicator(spinnerId, `${agentId} not found!`, 'fail');
+      spinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
+      stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
-    debugMessage(`cli.AgentOps.importWebAgentFromFile: end`);
-  });
+    debugMessage(`cli.AgentOps.importFirstJavaAgentFromFile: end`);
+  } catch (error) {
+    printError(error, `Error importing first java agent from file`);
+  }
+  return false;
 }
 
 /**
  * Import web gateway agent from file
  * @param {string} file import file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function importFirstWebAgentFromFile(file) {
-  debugMessage(`cli.AgentOps.importFirstWebAgentFromFile: start`);
-  const verbose = state.getVerbose();
-  fs.readFile(getFilePath(file), 'utf8', async (err, data) => {
-    if (err) throw err;
+  try {
+    debugMessage(`cli.AgentOps.importFirstWebAgentFromFile: start`);
+    const verbose = state.getVerbose();
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     const importData = JSON.parse(data);
     let spinnerId;
     if (Object.keys(importData.agents).length > 0) {
@@ -679,6 +712,7 @@ export async function importFirstWebAgentFromFile(file) {
           if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `Importing ${agent['_id']}...`);
           await importWebAgent(agent['_id'], importData);
           stopProgressIndicator(spinnerId, `Imported ${agent['_id']}.`, 'success');
+          return true;
         } catch (importError) {
           stopProgressIndicator(spinnerId, `caught it here ${importError}`, 'fail');
         }
@@ -689,40 +723,339 @@ export async function importFirstWebAgentFromFile(file) {
       stopProgressIndicator(spinnerId, `No agents found!`, 'fail');
     }
     debugMessage(`cli.AgentOps.importFirstWebAgentFromFile: end`);
-  });
+  } catch (error) {
+    printError(error, `Error importing first java agent from file`);
+  }
+  return false;
+}
+
+/**
+ * Import agents from file
+ * @param {String} file file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function importAgentsFromFile(file) {
+  try {
+    debugMessage(`importAgentsFromFile: start`);
+    const filePath = getFilePath(file);
+    const data = fs.readFileSync(filePath, 'utf8');
+    debugMessage(`importAgentsFromFile: importing ${filePath}`);
+    const importData = JSON.parse(data);
+    await importAgents(importData);
+    debugMessage(`importAgentsFromFile: end`);
+    return true;
+  } catch (error) {
+    printError(error, `Error importing agents from file`);
+  }
+  return false;
+}
+
+/**
+ * Import identity gateway agents from file
+ * @param {String} file file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function importIdentityGatewayAgentsFromFile(file) {
+  try {
+    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: start`);
+    const filePath = getFilePath(file);
+    const data = fs.readFileSync(filePath, 'utf8');
+    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: importing ${filePath}`);
+    const importData = JSON.parse(data);
+    await importIdentityGatewayAgents(importData);
+    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFile: end`);
+    return true;
+  } catch (error) {
+    printError(error, `Error importing identity gateway agents from file`);
+  }
+  return false;
+}
+
+/**
+ * Import java agents from file
+ * @param {String} file file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function importJavaAgentsFromFile(file) {
+  try {
+    debugMessage(`cli.AgentOps.importJavaAgentsFromFile: start`);
+    const filePath = getFilePath(file);
+    const data = fs.readFileSync(filePath, 'utf8');
+    debugMessage(`cli.AgentOps.importJavaAgentsFromFile: importing ${filePath}`);
+    const importData = JSON.parse(data);
+    await importJavaAgents(importData);
+    debugMessage(`cli.AgentOps.importJavaAgentsFromFile: end`);
+    return true;
+  } catch (error) {
+    printError(error, `Error importing java agents from file`);
+  }
+  return false;
 }
 
 /**
  * Import web agents from file
  * @param {String} file file name
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function importWebAgentsFromFile(file) {
-  debugMessage(`cli.AgentOps.importWebAgentsFromFile: start`);
-  const filePath = getFilePath(file);
-  fs.readFile(filePath, 'utf8', async (err, data) => {
-    if (err) throw err;
+  try {
+    debugMessage(`cli.AgentOps.importWebAgentsFromFile: start`);
+    const filePath = getFilePath(file);
+    const data = fs.readFileSync(filePath, 'utf8');
     debugMessage(`cli.AgentOps.importWebAgentsFromFile: importing ${filePath}`);
     const importData = JSON.parse(data);
-    try {
-      await importWebAgents(importData);
-    } catch (error) {
-      printMessage(`${error.message}`, 'error');
-      printMessage(error.response.status, 'error');
-    }
+    await importWebAgents(importData);
     debugMessage(`cli.AgentOps.importWebAgentsFromFile: end`);
-  });
+    return true;
+  } catch (error) {
+    printError(error, `Error importing web agents from file`);
+  }
+  return false;
+}
+
+/**
+ * Import all agents from separate files
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function importAgentsFromFiles() {
+  const errors = [];
+  try {
+    const names = fs.readdirSync(getWorkingDirectory());
+    const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
+    for (const file of agentFiles) {
+      try {
+        await importAgentsFromFile(file);
+      } catch (error) {
+        errors.push(new FrodoError(`Error importing agents from ${file}`, error));
+      }
+    }
+    if (errors.length > 0) {
+      throw new FrodoError(`One or more errors importing agents`, errors);
+    }
+    return true;
+  } catch (error) {
+    if (errors.length > 0) {
+      printError(error);
+    } else {
+      printError(error, `Error importing agents from files`);
+    }
+  }
+  return false;
+}
+
+/**
+ * Import all identity gateway agents from separate files
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function importIdentityGatewayAgentsFromFiles() {
+  const errors = [];
+  try {
+    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFiles: start`);
+    const names = fs.readdirSync(getWorkingDirectory());
+    const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
+    for (const file of agentFiles) {
+      try {
+        await importIdentityGatewayAgentsFromFile(file);
+      } catch (error) {
+        errors.push(new FrodoError(`Error importing identity gateway agents from ${file}`, error));
+      }
+    }
+    if (errors.length > 0) {
+      throw new FrodoError(`One or more errors importing identity gateway agents`, errors);
+    }
+    debugMessage(`cli.AgentOps.importIdentityGatewayAgentsFromFiles: end`);
+    return true;
+  } catch (error) {
+    if (errors.length > 0) {
+      printError(error);
+    } else {
+      printError(error, `Error importing identity gateway agents from files`);
+    }
+  }
+  return false;
+}
+
+/**
+ * Import all java agents from separate files
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function importJavaAgentsFromFiles() {
+  const errors = [];
+  try {
+    debugMessage(`cli.AgentOps.importJavaAgentsFromFiles: start`);
+    const names = fs.readdirSync(getWorkingDirectory());
+    const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
+    for (const file of agentFiles) {
+      try {
+        await importJavaAgentsFromFile(file);
+      } catch (error) {
+        errors.push(new FrodoError(`Error importing java agents from ${file}`, error));
+      }
+    }
+    if (errors.length > 0) {
+      throw new FrodoError(`One or more errors importing java agents`, errors);
+    }
+    debugMessage(`cli.AgentOps.importJavaAgentsFromFiles: end`);
+    return true;
+  } catch (error) {
+    if (errors.length > 0) {
+      printError(error);
+    } else {
+      printError(error, `Error importing java agents from files`);
+    }
+  }
+  return false;
 }
 
 /**
  * Import all web agents from separate files
+ * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function importWebAgentsFromFiles() {
-  debugMessage(`cli.AgentOps.importWebAgentsFromFiles: start`);
-  const names = fs.readdirSync(getWorkingDirectory());
-  const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
-  for (const file of agentFiles) {
-    await importWebAgentsFromFile(file);
+  const errors = [];
+  try {
+    debugMessage(`cli.AgentOps.importWebAgentsFromFiles: start`);
+    const names = fs.readdirSync(getWorkingDirectory());
+    const agentFiles = names.filter(name => name.toLowerCase().endsWith('.agent.json'));
+    for (const file of agentFiles) {
+      try {
+        await importWebAgentsFromFile(file);
+      } catch (error) {
+        errors.push(new FrodoError(`Error importing web agents from ${file}`, error));
+      }
+    }
+    if (errors.length > 0) {
+      throw new FrodoError(`One or more errors importing web agents`, errors);
+    }
+    debugMessage(`cli.AgentOps.importWebAgentsFromFiles: end`);
+    return true;
+  } catch (error) {
+    if (errors.length > 0) {
+      printError(error);
+    } else {
+      printError(error, `Error importing web agents from files`);
+    }
+  }
+  return false;
+}
+
+/**
+ * Delete agent
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteAgent(agentId) {
+  try {
+    await frodo.agent.deleteAgent(agentId);
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete identity gateway agent
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteIdentityGatewayAgent(agentId) {
+  try {
+    await frodo.agent.deleteIdentityGatewayAgent(agentId);
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete java agent
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteJavaAgent(agentId) {
+  try {
+    await frodo.agent.deleteJavaAgent(agentId);
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete web agent
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteWebAgent(agentId) {
+  try {
+    await frodo.agent.deleteWebAgent(agentId);
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete agents
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteAgents() {
+  try {
+    await frodo.agent.deleteAgents();
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete identity gateway agents
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteIdentityGatewayAgents() {
+  try {
+    await frodo.agent.deleteIdentityGatewayAgents();
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete java agents
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteJavaAgents() {
+  try {
+    await frodo.agent.deleteJavaAgents();
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete web agents
+ * @param {string} agentId agent id/name
+ * @returns {Promise<boolean>} true if successful, false otherwise
+ */
+export async function deleteWebAgents() {
+  try {
+    await frodo.agent.deleteWebAgents();
+    return true;
+  } catch (error) {
+    printError(error);
   }
-  debugMessage(`cli.AgentOps.importWebAgentsFromFiles: end`);
+  return false;
 }
 //# sourceMappingURL=AgentOps.js.map