@aifabrix/builder 2.31.1 → 2.32.2

package/lib/commands/wizard.js

@@ -0,0 +1,498 @@
+/**
+ * @fileoverview Wizard command handler - interactive external system creation
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const fs = require('fs').promises;
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const { getDeploymentAuth } = require('../utils/token-manager');
+const { getDataplaneUrl } = require('../datasource/deploy');
+const {
+  selectMode,
+  selectSource,
+  parseOpenApi,
+  detectType,
+  generateConfig,
+  validateWizardConfig,
+  getDeploymentDocs
+} = require('../api/wizard.api');
+const {
+  promptForMode,
+  promptForSourceType,
+  promptForOpenApiFile,
+  promptForOpenApiUrl,
+  promptForMcpServer,
+  promptForKnownPlatform,
+  promptForUserIntent,
+  promptForUserPreferences,
+  promptForConfigReview,
+  promptForAppName
+} = require('../generator/wizard-prompts');
+const { generateWizardFiles } = require('../generator/wizard');
+
+/**
+ * Validate app name and check if directory exists
+ * @async
+ * @function validateAndCheckAppDirectory
+ * @param {string} appName - Application name
+ * @returns {Promise<boolean>} True if should continue, false if cancelled
+ * @throws {Error} If validation fails
+ */
+async function validateAndCheckAppDirectory(appName) {
+  // Validate app name
+  if (!/^[a-z0-9-_]+$/.test(appName)) {
+    throw new Error('Application name must contain only lowercase letters, numbers, hyphens, and underscores');
+  }
+
+  // Check if app directory already exists
+  const appPath = path.join(process.cwd(), 'integration', appName);
+  try {
+    await fs.access(appPath);
+    const { overwrite } = await require('inquirer').prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `Directory ${appPath} already exists. Overwrite?`,
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      logger.log(chalk.yellow('Wizard cancelled.'));
+      return false;
+    }
+  } catch (error) {
+    // Directory doesn't exist, continue
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+  return true;
+}
+
+/**
+ * Handle mode selection step
+ * @async
+ * @function handleModeSelection
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<string>} Selected mode
+ * @throws {Error} If mode selection fails
+ */
+async function handleModeSelection(dataplaneUrl, authConfig) {
+  logger.log(chalk.blue('\n📋 Step 1: Mode Selection'));
+  const mode = await promptForMode();
+  const modeResponse = await selectMode(dataplaneUrl, authConfig, mode);
+  if (!modeResponse.success) {
+    throw new Error(`Mode selection failed: ${modeResponse.error || modeResponse.formattedError}`);
+  }
+  return mode;
+}
+
+/**
+ * Handle source selection step
+ * @async
+ * @function handleSourceSelection
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Object with sourceType and sourceData
+ * @throws {Error} If source selection fails
+ */
+async function handleSourceSelection(dataplaneUrl, authConfig) {
+  logger.log(chalk.blue('\n📋 Step 2: Source Selection'));
+  const sourceType = await promptForSourceType();
+  let sourceData = null;
+
+  if (sourceType === 'openapi-file') {
+    const filePath = await promptForOpenApiFile();
+    sourceData = filePath;
+  } else if (sourceType === 'openapi-url') {
+    const url = await promptForOpenApiUrl();
+    sourceData = url;
+  } else if (sourceType === 'mcp-server') {
+    const mcpDetails = await promptForMcpServer();
+    sourceData = JSON.stringify(mcpDetails);
+  } else if (sourceType === 'known-platform') {
+    const platform = await promptForKnownPlatform();
+    sourceData = platform;
+  }
+
+  const sourceResponse = await selectSource(dataplaneUrl, authConfig, sourceType, sourceData);
+  if (!sourceResponse.success) {
+    throw new Error(`Source selection failed: ${sourceResponse.error || sourceResponse.formattedError}`);
+  }
+
+  return { sourceType, sourceData };
+}
+
+/**
+ * Parse OpenAPI file
+ * @async
+ * @function parseOpenApiFile
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} sourceData - Source data (file path)
+ * @returns {Promise<Object>} OpenAPI spec
+ * @throws {Error} If parsing fails
+ */
+async function parseOpenApiFile(dataplaneUrl, authConfig, sourceData) {
+  logger.log(chalk.blue('\n📋 Step 3: Parsing OpenAPI File'));
+  const spinner = ora('Parsing OpenAPI file...').start();
+  try {
+    const parseResponse = await parseOpenApi(dataplaneUrl, authConfig, sourceData);
+    spinner.stop();
+    if (!parseResponse.success) {
+      throw new Error(`OpenAPI parsing failed: ${parseResponse.error || parseResponse.formattedError}`);
+    }
+    logger.log(chalk.green('✓ OpenAPI file parsed successfully'));
+    return parseResponse.data?.spec;
+  } catch (error) {
+    spinner.stop();
+    throw error;
+  }
+}
+
+/**
+ * Handle OpenAPI parsing step
+ * @async
+ * @function handleOpenApiParsing
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} sourceType - Source type
+ * @param {string} sourceData - Source data
+ * @returns {Promise<Object|null>} OpenAPI spec or null
+ * @throws {Error} If parsing fails
+ */
+async function handleOpenApiParsing(dataplaneUrl, authConfig, sourceType, sourceData) {
+  if (sourceType === 'openapi-file') {
+    return await parseOpenApiFile(dataplaneUrl, authConfig, sourceData);
+  }
+  if (sourceType === 'openapi-url') {
+    logger.log(chalk.blue('\n📋 Step 3: Parsing OpenAPI URL'));
+    logger.log(chalk.green('✓ OpenAPI URL processed'));
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Handle type detection step
+ * @async
+ * @function handleTypeDetection
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} openApiSpec - OpenAPI specification
+ * @returns {Promise<Object|null>} Detected type or null
+ */
+async function handleTypeDetection(dataplaneUrl, authConfig, openApiSpec) {
+  if (!openApiSpec) {
+    return null;
+  }
+
+  logger.log(chalk.blue('\n📋 Step 4: Detecting API Type'));
+  const spinner = ora('Detecting API type...').start();
+  try {
+    const detectResponse = await detectType(dataplaneUrl, authConfig, openApiSpec);
+    spinner.stop();
+    if (detectResponse.success && detectResponse.data) {
+      const detectedType = detectResponse.data;
+      logger.log(chalk.green(`✓ API type detected: ${detectedType.apiType || 'unknown'}`));
+      if (detectedType.category) {
+        logger.log(chalk.gray(`  Category: ${detectedType.category}`));
+      }
+      return detectedType;
+    }
+  } catch (error) {
+    spinner.stop();
+    logger.log(chalk.yellow(`⚠ Type detection failed: ${error.message}`));
+  }
+  return null;
+}
+
+/**
+ * Handle configuration generation step
+ * @async
+ * @function handleConfigurationGeneration
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} mode - Selected mode
+ * @param {string} sourceType - Source type
+ * @param {Object} openApiSpec - OpenAPI specification
+ * @returns {Promise<Object>} Generated configuration with systemConfig, datasourceConfigs, and systemKey
+ * @throws {Error} If generation fails
+ */
+async function handleConfigurationGeneration(dataplaneUrl, authConfig, mode, sourceType, openApiSpec) {
+  logger.log(chalk.blue('\n📋 Step 5: User Preferences'));
+  const userIntent = await promptForUserIntent();
+  const preferences = await promptForUserPreferences();
+
+  logger.log(chalk.blue('\n📋 Step 6: Generating Configuration'));
+  const spinner = ora('Generating configuration via AI (this may take 10-30 seconds)...').start();
+  try {
+    const generateResponse = await generateConfig(dataplaneUrl, authConfig, {
+      mode,
+      sourceType,
+      openApiSpec,
+      userIntent,
+      preferences
+    });
+    spinner.stop();
+    if (!generateResponse.success) {
+      throw new Error(`Configuration generation failed: ${generateResponse.error || generateResponse.formattedError}`);
+    }
+
+    const systemConfig = generateResponse.data?.systemConfig;
+    const datasourceConfigs = generateResponse.data?.datasourceConfigs || [];
+    const systemKey = generateResponse.data?.systemKey;
+
+    if (!systemConfig) {
+      throw new Error('System configuration not found in generation response');
+    }
+
+    logger.log(chalk.green('✓ Configuration generated successfully'));
+    return { systemConfig, datasourceConfigs, systemKey };
+  } catch (error) {
+    spinner.stop();
+    throw error;
+  }
+}
+
+/**
+ * Validate wizard configuration
+ * @async
+ * @function validateWizardConfiguration
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} systemConfig - System configuration
+ * @param {Object[]} datasourceConfigs - Datasource configurations
+ * @throws {Error} If validation fails
+ */
+async function validateWizardConfiguration(dataplaneUrl, authConfig, systemConfig, datasourceConfigs) {
+  const validateSpinner = ora('Validating configuration...').start();
+  try {
+    const validateResponse = await validateWizardConfig(dataplaneUrl, authConfig, systemConfig, datasourceConfigs);
+    validateSpinner.stop();
+    if (!validateResponse.success || !validateResponse.data?.valid) {
+      const errors = validateResponse.data?.errors || [];
+      const errorMsg = errors.length > 0
+        ? errors.map(e => e.message || e).join(', ')
+        : validateResponse.error || validateResponse.formattedError || 'Validation failed';
+      throw new Error(`Configuration validation failed: ${errorMsg}`);
+    }
+    logger.log(chalk.green('✓ Configuration validated successfully'));
+    if (validateResponse.data?.warnings && validateResponse.data.warnings.length > 0) {
+      logger.log(chalk.yellow('\n⚠ Warnings:'));
+      validateResponse.data.warnings.forEach(warning => {
+        logger.log(chalk.yellow(`  - ${warning.message || warning}`));
+      });
+    }
+  } catch (error) {
+    validateSpinner.stop();
+    throw error;
+  }
+}
+
+/**
+ * Handle configuration review and validation step
+ * @async
+ * @function handleConfigurationReview
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} systemConfig - System configuration
+ * @param {Object[]} datasourceConfigs - Datasource configurations
+ * @returns {Promise<Object>} Final configurations with systemConfig and datasourceConfigs
+ * @throws {Error} If validation fails
+ */
+async function handleConfigurationReview(dataplaneUrl, authConfig, systemConfig, datasourceConfigs) {
+  logger.log(chalk.blue('\n📋 Step 7: Review & Validate'));
+  const reviewResult = await promptForConfigReview(systemConfig, datasourceConfigs);
+
+  if (reviewResult.action === 'cancel') {
+    logger.log(chalk.yellow('Wizard cancelled.'));
+    return null;
+  }
+
+  // Use edited configs if user edited them
+  const finalSystemConfig = reviewResult.systemConfig || systemConfig;
+  const finalDatasourceConfigs = reviewResult.datasourceConfigs || datasourceConfigs;
+
+  // Validate configuration
+  await validateWizardConfiguration(dataplaneUrl, authConfig, finalSystemConfig, finalDatasourceConfigs);
+
+  return { systemConfig: finalSystemConfig, datasourceConfigs: finalDatasourceConfigs };
+}
+
+/**
+ * Handle file saving step
+ * @async
+ * @function handleFileSaving
+ * @param {string} appName - Application name
+ * @param {Object} systemConfig - System configuration
+ * @param {Object[]} datasourceConfigs - Datasource configurations
+ * @param {string} systemKey - System key
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Generated files information
+ * @throws {Error} If file saving fails
+ */
+async function handleFileSaving(appName, systemConfig, datasourceConfigs, systemKey, dataplaneUrl, authConfig) {
+  logger.log(chalk.blue('\n📋 Step 8: Saving Files'));
+  const saveSpinner = ora('Saving files...').start();
+  try {
+    let aiGeneratedReadme = null;
+    if (systemKey && dataplaneUrl && authConfig) {
+      try {
+        const docsResponse = await getDeploymentDocs(dataplaneUrl, authConfig, systemKey);
+        if (docsResponse.success && docsResponse.data?.content) {
+          aiGeneratedReadme = docsResponse.data.content;
+          logger.log(chalk.gray('  ✓ Fetched AI-generated README.md from dataplane'));
+        }
+      } catch (error) {
+        logger.log(chalk.gray(`  ⚠ Could not fetch AI-generated README: ${error.message}`));
+      }
+    }
+    const generatedFiles = await generateWizardFiles(appName, systemConfig, datasourceConfigs, systemKey, { aiGeneratedReadme });
+    saveSpinner.stop();
+    logger.log(chalk.green('\n✓ Wizard completed successfully!'));
+    logger.log(chalk.green(`\nFiles created in: ${generatedFiles.appPath}`));
+    logger.log(chalk.blue('\nNext steps:'));
+    [`  1. Review the generated files in integration/${appName}/`, '  2. Update env.template with your authentication details', `  3. Deploy using: ./deploy.sh or .\\deploy.ps1 (or aifabrix deploy ${appName})`].forEach(step => logger.log(chalk.gray(step)));
+    return generatedFiles;
+  } catch (error) {
+    saveSpinner.stop();
+    throw error;
+  }
+}
+
+/**
+ * Execute wizard flow steps
+ * @async
+ * @function executeWizardFlow
+ * @param {string} appName - Application name
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<void>} Resolves when wizard flow completes
+ * @throws {Error} If wizard flow fails
+ */
+async function executeWizardFlow(appName, dataplaneUrl, authConfig) {
+  // Step 1: Mode Selection
+  const mode = await handleModeSelection(dataplaneUrl, authConfig);
+
+  // Step 2: Source Selection
+  const { sourceType, sourceData } = await handleSourceSelection(dataplaneUrl, authConfig);
+
+  // Step 3: Parse OpenAPI (if applicable)
+  const openApiSpec = await handleOpenApiParsing(dataplaneUrl, authConfig, sourceType, sourceData);
+
+  // Step 4: Detect Type (optional, if OpenAPI spec available)
+  await handleTypeDetection(dataplaneUrl, authConfig, openApiSpec);
+
+  // Step 5-6: Generate Configuration
+  const { systemConfig, datasourceConfigs, systemKey } = await handleConfigurationGeneration(
+    dataplaneUrl,
+    authConfig,
+    mode,
+    sourceType,
+    openApiSpec
+  );
+
+  // Step 7: Review & Validate
+  const finalConfigs = await handleConfigurationReview(dataplaneUrl, authConfig, systemConfig, datasourceConfigs);
+  if (!finalConfigs) {
+    return; // User cancelled
+  }
+
+  // Step 8: Save Files
+  await handleFileSaving(
+    appName,
+    finalConfigs.systemConfig,
+    finalConfigs.datasourceConfigs,
+    systemKey || appName,
+    dataplaneUrl,
+    authConfig
+  );
+}
+
+/**
+ * Handle wizard command
+ * @async
+ * @function handleWizard
+ * @param {Object} options - Command options
+ * @param {string} [options.app] - Application name
+ * @param {string} [options.controller] - Controller URL
+ * @param {string} [options.environment] - Environment key
+ * @param {string} [options.dataplane] - Dataplane URL (overrides controller lookup)
+ * @returns {Promise<void>} Resolves when wizard completes
+ * @throws {Error} If wizard fails
+ */
+async function handleWizard(options = {}) {
+  try {
+    logger.log(chalk.blue('\n🧙 AI Fabrix External System Wizard\n'));
+
+    // Get or prompt for app name
+    let appName = options.app;
+    if (!appName) {
+      appName = await promptForAppName();
+    }
+
+    // Validate app name and check directory
+    const shouldContinue = await validateAndCheckAppDirectory(appName);
+    if (!shouldContinue) {
+      return;
+    }
+
+    // Get dataplane URL and authentication
+    const { dataplaneUrl, authConfig } = await setupDataplaneAndAuth(options, appName);
+
+    // Execute wizard flow
+    await executeWizardFlow(appName, dataplaneUrl, authConfig);
+  } catch (error) {
+    logger.error(chalk.red(`\n❌ Wizard failed: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Setup dataplane URL and authentication
+ * @async
+ * @function setupDataplaneAndAuth
+ * @param {Object} options - Command options
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Object with dataplaneUrl and authConfig
+ * @throws {Error} If setup fails
+ */
+async function setupDataplaneAndAuth(options, appName) {
+  const configData = await config.getConfig();
+  const environment = options.environment || 'dev';
+  const controllerUrl = options.controller || configData.deployment?.controllerUrl || 'http://localhost:3000';
+
+  // Get dataplane URL (either from option or from controller)
+  let dataplaneUrl = options.dataplane;
+  if (!dataplaneUrl) {
+    // Get authentication first
+    const authConfig = await getDeploymentAuth(controllerUrl, environment, appName);
+    if (!authConfig.token && !authConfig.clientId) {
+      throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
+    }
+
+    // Get dataplane URL from controller
+    logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
+    dataplaneUrl = await getDataplaneUrl(controllerUrl, appName, environment, authConfig);
+    logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+
+    return { dataplaneUrl, authConfig };
+  }
+
+  // If dataplane URL provided directly, still need auth
+  const authConfig = await getDeploymentAuth(controllerUrl, environment, appName);
+  if (!authConfig.token && !authConfig.clientId) {
+    throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
+  }
+
+  return { dataplaneUrl, authConfig };
+}
+module.exports = { handleWizard };

package/lib/{audit-logger.js → core/audit-logger.js}

@@ -14,7 +14,7 @@
 const fs = require('fs').promises;
 const path = require('path');
 const os = require('os');
-const paths = require('./utils/paths');
+const paths = require('../utils/paths');
 
 // Audit log file path (in user's home directory for compliance)
 let auditLogPath = null;

package/lib/{config.js → core/config.js}

@@ -12,7 +12,7 @@ const fs = require('fs').promises;
 const path = require('path');
 const yaml = require('js-yaml');
 const os = require('os');
-const { encryptToken, decryptToken, isTokenEncrypted } = require('./utils/token-encryption');
+const { encryptToken, decryptToken, isTokenEncrypted } = require('../utils/token-encryption');
 // Avoid importing paths here to prevent circular dependency.
 // Config location is always under OS home at ~/.aifabrix/config.yaml
 
@@ -62,19 +62,19 @@ function validateAndNormalizeDeveloperId(developerId) {
 
   if (typeof developerId === 'number') {
     if (developerId < 0 || !Number.isFinite(developerId)) {
-      throw new Error(`Invalid developer-id value: "${developerId}". Must be a non-negative digit string.`);
+      throw new Error('Developer ID must be a non-negative digit string or number');
     }
     return String(developerId);
   }
 
   if (typeof developerId === 'string') {
     if (!DEV_ID_DIGITS_REGEX.test(developerId)) {
-      throw new Error(`Invalid developer-id value: "${developerId}". Must contain only digits 0-9.`);
+      throw new Error('Developer ID must be a non-negative digit string or number');
     }
     return developerId;
   }
 
-  throw new Error(`Invalid developer-id value type: ${typeof developerId}. Must be a non-negative digit string.`);
+  throw new Error('Developer ID must be a non-negative digit string or number');
 }
 
 /**
@@ -204,24 +204,15 @@ async function getDeveloperId() {
  * @param {number|string} developerId - Developer ID to set (digit-only string preserved, or number). "0" = default infra, > "0" = developer-specific
  * @returns {Promise<void>}
  */
-async function setDeveloperId(developerId) {
-  const DEV_ID_DIGITS_REGEX = /^[0-9]+$/;
-  const errorMsg = 'Developer ID must be a non-negative digit string or number (0 = default infra, > 0 = developer-specific)';
-  let devIdString;
-  if (typeof developerId === 'number') {
-    if (!Number.isFinite(developerId) || developerId < 0) throw new Error(errorMsg);
-    devIdString = String(developerId);
-  } else if (typeof developerId === 'string') {
-    if (!DEV_ID_DIGITS_REGEX.test(developerId)) throw new Error(errorMsg);
-    devIdString = developerId;
-  } else {
-    throw new Error(errorMsg);
-  }
-  cachedDeveloperId = null;
-  const config = await getConfig();
-  config['developer-id'] = devIdString;
-  cachedDeveloperId = devIdString;
-  await saveConfig(config);
+
+/**
+ * Verifies developer ID was saved correctly
+ * @async
+ * @function verifyDeveloperIdSaved
+ * @param {string} devIdString - Developer ID string
+ * @throws {Error} If verification fails
+ */
+async function verifyDeveloperIdSaved(devIdString) {
   await new Promise(resolve => setTimeout(resolve, 100));
   const savedContent = await fs.readFile(RUNTIME_CONFIG_FILE, 'utf8');
   const savedConfig = yaml.load(savedContent);
@@ -229,6 +220,17 @@ async function setDeveloperId(developerId) {
   if (savedDevIdString !== devIdString) {
     throw new Error(`Failed to save developer ID: expected ${devIdString}, got ${savedDevIdString}. File content: ${savedContent.substring(0, 200)}`);
   }
+}
+
+async function setDeveloperId(developerId) {
+  const devIdString = validateAndNormalizeDeveloperId(developerId);
+
+  cachedDeveloperId = null;
+  const config = await getConfig();
+  config['developer-id'] = devIdString;
+  cachedDeveloperId = devIdString;
+  await saveConfig(config);
+  await verifyDeveloperIdSaved(devIdString);
   cachedDeveloperId = null;
 }
 
@@ -320,7 +322,7 @@ async function setSecretsEncryptionKey(key) {
   }
 
   // Validate key format using encryption utilities
-  const { validateEncryptionKey } = require('./utils/secrets-encryption');
+  const { validateEncryptionKey } = require('../utils/secrets-encryption');
   validateEncryptionKey(key);
 
   const config = await getConfig();
@@ -377,19 +379,19 @@ Object.defineProperty(exportsObj, 'developerId', {
 });
 
 // Token management functions - created after dependencies are defined
-const { createTokenManagementFunctions } = require('./utils/config-tokens');
+const { createTokenManagementFunctions } = require('../utils/config-tokens');
 const tokenFunctions = createTokenManagementFunctions({
   getConfigFn: getConfig,
   saveConfigFn: saveConfig,
   getSecretsEncryptionKeyFn: getSecretsEncryptionKey,
   encryptTokenValueFn: encryptTokenValue,
   decryptTokenValueFn: decryptTokenValue,
-  isTokenEncryptedFn: require('./utils/token-encryption').isTokenEncrypted
+  isTokenEncryptedFn: require('../utils/token-encryption').isTokenEncrypted
 });
 Object.assign(exportsObj, tokenFunctions);
 
 // Path configuration functions - created after getConfig/saveConfig are defined
-const { createPathConfigFunctions } = require('./utils/config-paths');
+const { createPathConfigFunctions } = require('../utils/config-paths');
 const pathConfigFunctions = createPathConfigFunctions(getConfig, saveConfig);
 Object.assign(exportsObj, pathConfigFunctions);