@rockcarver/frodo-cli 2.0.0-3 → 2.0.0-31

package/esm/ops/AgentOps.js

@@ -1,7 +1,35 @@
 import { frodo, state } from '@rockcarver/frodo-lib';
 import fs from 'fs';
-import { printMessage, createTable, debugMessage, showSpinner, succeedSpinner, failSpinner } from '../utils/Console';
+import { createTable, debugMessage, failSpinner, printMessage, showSpinner, succeedSpinner } from '../utils/Console';
 import { getTypedFilename, saveJsonToFile, titleCase } from '../utils/ExportImportUtils';
+const {
+  getRealmName,
+  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 +41,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 +76,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 +99,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 +122,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) {
@@ -117,12 +145,12 @@ export async function listWebAgents(long = false) {
  * @param {string} file file name
  */
 export async function exportAgentsToFile(file) {
-  const exportData = await frodo.agent.exportAgents();
-  let fileName = getTypedFilename(`all${titleCase(frodo.helper.utils.getRealmName(state.getRealm()))}Agents`, 'agent');
+  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));
 }
 
 /**
@@ -130,12 +158,12 @@ export async function exportAgentsToFile(file) {
  * @param {string} file file name
  */
 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']);
+  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));
 }
 
 /**
@@ -143,12 +171,12 @@ export async function exportIdentityGatewayAgentsToFile(file) {
  * @param {string} file file name
  */
 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']);
+  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));
 }
 
 /**
@@ -156,12 +184,12 @@ export async function exportJavaAgentsToFile(file) {
  * @param {string} file file name
  */
 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']);
+  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));
 }
 
 /**
@@ -170,12 +198,12 @@ export async function exportWebAgentsToFile(file) {
  * @param {string} file file name
  */
 export async function exportAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportAgent(agentId);
+  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));
 }
 
 /**
@@ -184,12 +212,12 @@ export async function exportAgentToFile(agentId, file) {
  * @param {string} file file name
  */
 export async function exportIdentityGatewayAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportIdentityGatewayAgent(agentId);
+  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));
 }
 
 /**
@@ -198,12 +226,12 @@ export async function exportIdentityGatewayAgentToFile(agentId, file) {
  * @param {string} file file name
  */
 export async function exportJavaAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportJavaAgent(agentId);
+  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));
 }
 
 /**
@@ -212,26 +240,27 @@ export async function exportJavaAgentToFile(agentId, file) {
  * @param {string} file file name
  */
 export async function exportWebAgentToFile(agentId, file) {
-  const exportData = await frodo.agent.exportWebAgent(agentId);
+  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));
 }
 
 /**
  * Export all agents to separate files
  */
 export async function exportAgentsToFiles() {
-  const agents = await frodo.agent.getAgents();
+  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);
   }
   debugMessage(`exportAgentsToFiles: done.`);
 }
@@ -240,12 +269,12 @@ export async function exportAgentsToFiles() {
  * Export all identity gateway agents to separate files
  */
 export async function exportIdentityGatewayAgentsToFiles() {
-  const agents = await frodo.agent.getIdentityGatewayAgents();
+  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));
   }
 }
 
@@ -253,12 +282,12 @@ export async function exportIdentityGatewayAgentsToFiles() {
  * Export all java agents to separate files
  */
 export async function exportJavaAgentsToFiles() {
-  const agents = await frodo.agent.getJavaAgents();
+  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));
   }
 }
 
@@ -266,12 +295,12 @@ export async function exportJavaAgentsToFiles() {
  * Export all web agents to separate files
  */
 export async function exportWebAgentsToFiles() {
-  const agents = await frodo.agent.getWebAgents();
+  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));
   }
 }
 
@@ -282,21 +311,23 @@ 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 (importData.agents) {
       if (!verbose) showSpinner(`Importing ${agentId}...`);
       try {
         if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importAgent(agentId, importData);
+        await importAgent(agentId, importData);
         succeedSpinner(`Imported ${agentId}.`);
       } catch (importError) {
         if (verbose) showSpinner(`Importing ${agentId}...`);
@@ -315,7 +346,7 @@ 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);
     if (Object.keys(importData.agents).length > 0) {
@@ -323,7 +354,7 @@ export async function importFirstAgentFromFile(file) {
         if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
         try {
           if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importAgent(agent['_id'], importData);
+          await importAgent(agent['_id'], importData);
           succeedSpinner(`Imported ${agent['_id']}.`);
         } catch (importError) {
           if (verbose) showSpinner(`Importing ${agent['_id']}...`);
@@ -344,12 +375,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 +394,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,21 +409,23 @@ 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 (importData.agents) {
       if (!verbose) showSpinner(`Importing ${agentId}...`);
       try {
         if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importIdentityGatewayAgent(agentId, importData);
+        await importIdentityGatewayAgent(agentId, importData);
         succeedSpinner(`Imported ${agentId}.`);
       } catch (importError) {
         failSpinner(`${importError}`);
@@ -411,7 +445,7 @@ 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);
     if (Object.keys(importData.agents).length > 0) {
@@ -419,7 +453,7 @@ export async function importFirstIdentityGatewayAgentFromFile(file) {
         if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
         try {
           if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importIdentityGatewayAgent(agent['_id'], importData);
+          await importIdentityGatewayAgent(agent['_id'], importData);
           succeedSpinner(`Imported ${agent['_id']}.`);
         } catch (importError) {
           failSpinner(`${importError}`);
@@ -440,12 +474,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 +494,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,21 +510,23 @@ 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 (importData.agents) {
       if (!verbose) showSpinner(`Importing ${agentId}...`);
       try {
         if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importJavaAgent(agentId, importData);
+        await importJavaAgent(agentId, importData);
         succeedSpinner(`Imported ${agentId}.`);
       } catch (importError) {
         failSpinner(`${importError}`);
@@ -509,7 +546,7 @@ 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);
     if (Object.keys(importData.agents).length > 0) {
@@ -517,7 +554,7 @@ export async function importFirstJavaAgentFromFile(file) {
         if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
         try {
           if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importJavaAgent(agent['_id'], importData);
+          await importJavaAgent(agent['_id'], importData);
           succeedSpinner(`Imported ${agent['_id']}.`);
         } catch (importError) {
           failSpinner(`${importError}`);
@@ -538,12 +575,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 +595,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,21 +611,23 @@ 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 (importData.agents) {
       if (!verbose) showSpinner(`Importing ${agentId}...`);
       try {
         if (verbose) showSpinner(`Importing ${agentId}...`);
-        await frodo.agent.importWebAgent(agentId, importData);
+        await importWebAgent(agentId, importData);
         succeedSpinner(`Imported ${agentId}.`);
       } catch (importError) {
         failSpinner(`${importError}`);
@@ -607,7 +647,7 @@ 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);
     if (Object.keys(importData.agents).length > 0) {
@@ -615,7 +655,7 @@ export async function importFirstWebAgentFromFile(file) {
         if (!verbose) showSpinner(`Importing ${agent['_id']}...`);
         try {
           if (verbose) showSpinner(`Importing ${agent['_id']}...`);
-          await frodo.agent.importWebAgent(agent['_id'], importData);
+          await importWebAgent(agent['_id'], importData);
           succeedSpinner(`Imported ${agent['_id']}.`);
         } catch (importError) {
           failSpinner(`caught it here ${importError}`);
@@ -636,12 +676,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 +696,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