@aifabrix/builder 2.33.5 → 2.36.0

package/lib/generator/wizard-prompts.js

@@ -12,35 +12,41 @@ const fs = require('fs').promises;
  * Prompt for wizard mode selection
  * @async
  * @function promptForMode
+ * @param {string} [defaultMode] - Default value ('create-system' | 'add-datasource')
  * @returns {Promise<string>} Selected mode ('create-system' | 'add-datasource')
  */
-async function promptForMode() {
+async function promptForMode(defaultMode) {
+  const choices = [
+    { name: 'Create a new external system', value: 'create-system' },
+    { name: 'Add datasource to existing system', value: 'add-datasource' }
+  ];
   const { mode } = await inquirer.prompt([
     {
       type: 'list',
       name: 'mode',
       message: 'What would you like to do?',
-      choices: [
-        { name: 'Create a new external system', value: 'create-system' },
-        { name: 'Add datasource to existing system', value: 'add-datasource' }
-      ]
+      choices,
+      default: defaultMode && choices.some(c => c.value === defaultMode) ? defaultMode : undefined
     }
   ]);
   return mode;
 }
 
 /**
- * Prompt for existing system ID or key (for add-datasource mode)
+ * Prompt for existing system ID or key (for add-datasource mode).
+ * Only external systems (OpenAPI, MCP, custom) support add-datasource; webapps do not.
  * @async
  * @function promptForSystemIdOrKey
+ * @param {string} [defaultValue] - Default value (e.g. from loaded wizard.yaml)
  * @returns {Promise<string>} System ID or key
  */
-async function promptForSystemIdOrKey() {
+async function promptForSystemIdOrKey(defaultValue) {
   const { systemIdOrKey } = await inquirer.prompt([
     {
       type: 'input',
       name: 'systemIdOrKey',
-      message: 'Enter the existing system ID or key:',
+      message: 'Enter the existing external system ID or key (not a webapp):',
+      default: defaultValue,
       validate: (input) => {
         if (!input || typeof input !== 'string' || input.trim().length === 0) {
           return 'System ID or key is required';
@@ -55,20 +61,24 @@ async function promptForSystemIdOrKey() {
  * Prompt for source type selection
  * @async
  * @function promptForSourceType
+ * @param {Array<{key: string, displayName?: string}>} [platforms] - If provided and non-empty, include "Known platform"; otherwise omit it
  * @returns {Promise<string>} Selected source type
  */
-async function promptForSourceType() {
+async function promptForSourceType(platforms = []) {
+  const choices = [
+    { name: 'OpenAPI file (local file)', value: 'openapi-file' },
+    { name: 'OpenAPI URL (remote URL)', value: 'openapi-url' },
+    { name: 'MCP server', value: 'mcp-server' }
+  ];
+  if (Array.isArray(platforms) && platforms.length > 0) {
+    choices.push({ name: 'Known platform (pre-configured)', value: 'known-platform' });
+  }
   const { sourceType } = await inquirer.prompt([
     {
       type: 'list',
       name: 'sourceType',
       message: 'What is your source type?',
-      choices: [
-        { name: 'OpenAPI file (local file)', value: 'openapi-file' },
-        { name: 'OpenAPI URL (remote URL)', value: 'openapi-url' },
-        { name: 'MCP server', value: 'mcp-server' },
-        { name: 'Known platform (pre-configured)', value: 'known-platform' }
-      ]
+      choices
     }
   ]);
   return sourceType;
@@ -176,11 +186,74 @@ async function promptForMcpServer() {
   };
 }
 
+/**
+ * Prompt for credential action (skip / create new / use existing).
+ * Choose Skip if you don't have credentials yet; you can add them later in env.template.
+ * @async
+ * @function promptForCredentialAction
+ * @returns {Promise<Object>} Object with action ('skip'|'create'|'select') and optional credentialIdOrKey
+ */
+async function promptForCredentialAction() {
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Credential (optional; choose Skip if you don\'t have credentials yet):',
+      choices: [
+        { name: 'Skip - configure credentials later', value: 'skip' },
+        { name: 'Create new', value: 'create' },
+        { name: 'Use existing', value: 'select' }
+      ]
+    }
+  ]);
+  if (action === 'select') {
+    const { credentialIdOrKey } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'credentialIdOrKey',
+        message: 'Enter credential ID or key (must exist on the dataplane):',
+        validate: (input) => {
+          if (!input || typeof input !== 'string' || input.trim().length === 0) {
+            return 'Credential ID or key is required (or choose Skip at the previous step)';
+          }
+          return true;
+        }
+      }
+    ]);
+    return { action, credentialIdOrKey: credentialIdOrKey.trim() };
+  }
+  return { action };
+}
+
+/**
+ * Re-prompt for credential ID/key when validation failed (e.g. not found on dataplane).
+ * Empty input means skip.
+ * @async
+ * @function promptForCredentialIdOrKeyRetry
+ * @param {string} [previousError] - Error message from dataplane (e.g. "Credential not found")
+ * @returns {Promise<Object>} { credentialIdOrKey: string } or { skip: true } if user leaves empty
+ */
+async function promptForCredentialIdOrKeyRetry(previousError) {
+  const msg = previousError
+    ? `Credential not found or invalid (${String(previousError).slice(0, 60)}). Enter ID/key or leave empty to skip:`
+    : 'Enter credential ID or key (or leave empty to skip):';
+  const { credentialIdOrKey } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'credentialIdOrKey',
+      message: msg,
+      default: ''
+    }
+  ]);
+  const trimmed = (credentialIdOrKey && credentialIdOrKey.trim()) || '';
+  return trimmed ? { credentialIdOrKey: trimmed } : { skip: true };
+}
+
 /**
  * Prompt for known platform selection
  * @async
  * @function promptForKnownPlatform
- * @param {string[]} [platforms] - List of available platforms (if provided)
+ * @param {Array<{key: string, displayName?: string}>} [platforms] - List of available platforms (if provided)
  * @returns {Promise<string>} Selected platform key
  */
 async function promptForKnownPlatform(platforms = []) {
@@ -297,7 +370,6 @@ async function promptForConfigReview(systemConfig, datasourceConfigs) {
       message: 'What would you like to do?',
       choices: [
         { name: 'Accept and save', value: 'accept' },
-        { name: 'Edit configuration manually', value: 'edit' },
         { name: 'Cancel', value: 'cancel' }
       ]
     }
@@ -307,32 +379,6 @@ async function promptForConfigReview(systemConfig, datasourceConfigs) {
     return { action: 'cancel' };
   }
 
-  if (action === 'edit') {
-    const { editedConfig } = await inquirer.prompt([
-      {
-        type: 'editor',
-        name: 'editedConfig',
-        message: 'Edit the configuration (JSON format):',
-        default: JSON.stringify({ systemConfig, datasourceConfigs }, null, 2),
-        validate: (input) => {
-          try {
-            JSON.parse(input);
-            return true;
-          } catch (error) {
-            return `Invalid JSON: ${error.message}`;
-          }
-        }
-      }
-    ]);
-
-    const parsed = JSON.parse(editedConfig);
-    return {
-      action: 'edit',
-      systemConfig: parsed.systemConfig,
-      datasourceConfigs: parsed.datasourceConfigs
-    };
-  }
-
   return { action: 'accept' };
 }
 
@@ -364,6 +410,24 @@ async function promptForAppName(defaultName) {
   return appName.trim();
 }
 
+/**
+ * Prompt: Run with saved config? (Y/n). Used when resuming from existing wizard.yaml.
+ * @async
+ * @function promptForRunWithSavedConfig
+ * @returns {Promise<boolean>} True to run with saved config, false to exit
+ */
+async function promptForRunWithSavedConfig() {
+  const { run } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'run',
+      message: 'Run with saved config?',
+      default: true
+    }
+  ]);
+  return run;
+}
+
 module.exports = {
   promptForMode,
   promptForSystemIdOrKey,
@@ -371,10 +435,13 @@ module.exports = {
   promptForOpenApiFile,
   promptForOpenApiUrl,
   promptForMcpServer,
+  promptForCredentialAction,
+  promptForCredentialIdOrKeyRetry,
   promptForKnownPlatform,
   promptForUserIntent,
   promptForUserPreferences,
   promptForConfigReview,
-  promptForAppName
+  promptForAppName,
+  promptForRunWithSavedConfig
 };
 

package/lib/infrastructure/services.js

@@ -132,6 +132,8 @@ async function waitForServices(devId = null) {
  * @async
  * @function checkInfraHealth
  * @param {number|string|null} [devId] - Developer ID (null = use current)
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.strict=false] - When true, only consider current dev's containers (no fallback to dev 0); use for up-miso and status consistency
  * @returns {Promise<Object>} Health status of each service
  * @throws {Error} If health check fails
  *
@@ -139,20 +141,21 @@ async function waitForServices(devId = null) {
  * const health = await checkInfraHealth();
  * // Returns: { postgres: 'healthy', redis: 'healthy', pgadmin: 'healthy', redis-commander: 'healthy' }
  */
-async function checkInfraHealth(devId = null) {
+async function checkInfraHealth(devId = null, options = {}) {
   const developerId = devId || await config.getDeveloperId();
   const servicesWithHealthCheck = ['postgres', 'redis'];
   const servicesWithoutHealthCheck = ['pgadmin', 'redis-commander'];
   const health = {};
+  const lookupOptions = options.strict ? { strict: true } : {};
 
   // Check health status for services with health checks
   for (const service of servicesWithHealthCheck) {
-    health[service] = await containerUtils.checkServiceWithHealthCheck(service, developerId);
+    health[service] = await containerUtils.checkServiceWithHealthCheck(service, developerId, lookupOptions);
   }
 
   // Check if services without health checks are running
   for (const service of servicesWithoutHealthCheck) {
-    health[service] = await containerUtils.checkServiceWithoutHealthCheck(service, developerId);
+    health[service] = await containerUtils.checkServiceWithoutHealthCheck(service, developerId, lookupOptions);
   }
 
   return health;

package/lib/utils/app-register-auth.js

@@ -138,6 +138,7 @@ async function tryFindDeviceTokenFromConfig(deviceConfig, attemptedUrls) {
 
 /**
  * Creates error data for authentication failure
+ * Deduplicates attemptedUrls so the same URL is not shown twice (e.g. when controller URL and device config URL match).
  * @function createAuthErrorData
  * @param {Error|null} lastError - Last error encountered
  * @param {string|null} controllerUrl - Original controller URL
@@ -145,10 +146,16 @@ async function tryFindDeviceTokenFromConfig(deviceConfig, attemptedUrls) {
  * @returns {Object} Error data object
  */
 function createAuthErrorData(lastError, controllerUrl, attemptedUrls) {
+  const seen = new Set();
+  const uniqueUrls = attemptedUrls.filter(u => {
+    if (seen.has(u)) return false;
+    seen.add(u);
+    return true;
+  });
   return {
     message: lastError ? lastError.message : 'No valid authentication found',
-    controllerUrl: controllerUrl || (attemptedUrls.length > 0 ? attemptedUrls[0] : undefined),
-    attemptedUrls: attemptedUrls.length > 1 ? attemptedUrls : undefined,
+    controllerUrl: controllerUrl || (uniqueUrls.length > 0 ? uniqueUrls[0] : undefined),
+    attemptedUrls: uniqueUrls.length > 1 ? uniqueUrls : undefined,
     correlationId: undefined
   };
 }

package/lib/utils/cli-utils.js

@@ -8,6 +8,8 @@
  * @version 2.0.0
  */
 
+const path = require('path');
+const fs = require('fs').promises;
 const logger = require('./logger');
 
 /**
@@ -289,10 +291,47 @@ function logError(command, errorMessages) {
 function handleCommandError(error, command) {
   const errorMessages = formatError(error);
   logError(command, errorMessages);
+  if (error.wizardResumeMessage) {
+    logger.log(error.wizardResumeMessage);
+  }
+}
+
+/** Strip ANSI escape codes for plain-text logging (ESC [...] m) */
+// eslint-disable-next-line no-control-regex -- intentional: match ANSI CSI sequences
+const ANSI_CODE_RE = /\x1b\[[\d;]*m/g;
+function stripAnsi(str) {
+  return typeof str === 'string' ? str.replace(ANSI_CODE_RE, '') : str;
+}
+
+/**
+ * Appends a wizard error to integration/<appKey>/error.log (timestamp + message only; no stack or secrets).
+ * Uses full formatted message (with validation details) when error.formatted is set, stripped of ANSI.
+ * Does not throw; logs and ignores write failures.
+ * @param {string} appKey - Application/integration key (e.g. app name or system key)
+ * @param {Error} error - The error that occurred
+ * @returns {Promise<void>}
+ */
+async function appendWizardError(appKey, error) {
+  if (!appKey || typeof appKey !== 'string' || !/^[a-z0-9-_]+$/.test(appKey)) {
+    return;
+  }
+  const dir = path.join(process.cwd(), 'integration', appKey);
+  const logPath = path.join(dir, 'error.log');
+  const rawMessage = (error && error.message) ? String(error.message) : String(error);
+  const fullPlain = (error && error.formatted) ? stripAnsi(error.formatted) : null;
+  const message = fullPlain && fullPlain.length > rawMessage.length ? fullPlain : rawMessage;
+  const line = `${new Date().toISOString()} ${message}\n`;
+  try {
+    await fs.mkdir(dir, { recursive: true });
+    await fs.appendFile(logPath, line, 'utf8');
+  } catch (e) {
+    logger.warn(`Could not write wizard error.log: ${e.message}`);
+  }
 }
 
 module.exports = {
   validateCommand,
-  handleCommandError
+  handleCommandError,
+  appendWizardError
 };
 

package/lib/utils/error-formatters/http-status-errors.js

@@ -9,6 +9,7 @@
  */
 
 const chalk = require('chalk');
+const { getPermissionDetailLines } = require('./permission-errors');
 
 /**
  * Formats authentication error
@@ -108,6 +109,13 @@ function formatAuthenticationError(errorData) {
   addControllerUrlInfo(lines, errorData);
   addAttemptedUrlsInfo(lines, errorData);
   addErrorMessageIfNotGeneric(lines, errorData);
+
+  // Show permission details when API returns them (401 "insufficient permissions" etc.)
+  const permissionLines = getPermissionDetailLines(errorData);
+  if (permissionLines.length > 0) {
+    lines.push(...permissionLines);
+  }
+
   addAuthenticationGuidance(lines, errorData);
 
   return lines.join('\n');

package/lib/utils/error-formatters/permission-errors.js

@@ -12,31 +12,44 @@ const chalk = require('chalk');
 
 /**
  * Extracts missing permissions from error data
+ * Supports: missingPermissions, missing.permissions, data.missing.permissions
  * @param {Object} errorData - Error response data
  * @returns {Array<string>} Array of missing permissions
  */
 function extractMissingPermissions(errorData) {
+  if (!errorData || typeof errorData !== 'object') return [];
   if (errorData.missingPermissions && Array.isArray(errorData.missingPermissions)) {
     return errorData.missingPermissions;
   }
   if (errorData.missing && errorData.missing.permissions && Array.isArray(errorData.missing.permissions)) {
     return errorData.missing.permissions;
   }
+  if (errorData.data?.missing?.permissions && Array.isArray(errorData.data.missing.permissions)) {
+    return errorData.data.missing.permissions;
+  }
   return [];
 }
 
 /**
  * Extracts required permissions from error data
+ * Supports: requiredPermissions, required.permissions, permissions (array), data.required.permissions
  * @param {Object} errorData - Error response data
  * @returns {Array<string>} Array of required permissions
  */
 function extractRequiredPermissions(errorData) {
+  if (!errorData || typeof errorData !== 'object') return [];
   if (errorData.requiredPermissions && Array.isArray(errorData.requiredPermissions)) {
     return errorData.requiredPermissions;
   }
   if (errorData.required && errorData.required.permissions && Array.isArray(errorData.required.permissions)) {
     return errorData.required.permissions;
   }
+  if (errorData.permissions && Array.isArray(errorData.permissions)) {
+    return errorData.permissions;
+  }
+  if (errorData.data?.required?.permissions && Array.isArray(errorData.data.required.permissions)) {
+    return errorData.data.required.permissions;
+  }
   return [];
 }
 
@@ -56,6 +69,33 @@ function addPermissionList(lines, perms, label) {
   }
 }
 
+/**
+ * Returns permission detail lines for appending to any error formatter (401, 403).
+ * Use when the API returns required/missing permissions in the error body.
+ * @param {Object} errorData - Error response data (may include required.permissions, missing.permissions, etc.)
+ * @returns {string[]} Array of formatted lines to append (may be empty)
+ */
+function getPermissionDetailLines(errorData) {
+  const lines = [];
+  const missingPerms = extractMissingPermissions(errorData);
+  const requiredPerms = extractRequiredPermissions(errorData);
+  if (missingPerms.length > 0) {
+    lines.push(chalk.yellow('Missing permissions:'));
+    missingPerms.forEach(perm => {
+      lines.push(chalk.gray(`  - ${perm}`));
+    });
+    lines.push('');
+  }
+  if (requiredPerms.length > 0) {
+    lines.push(chalk.yellow('Required permissions:'));
+    requiredPerms.forEach(perm => {
+      lines.push(chalk.gray(`  - ${perm}`));
+    });
+    lines.push('');
+  }
+  return lines;
+}
+
 /**
  * Formats permission error with missing and required permissions
  * @param {Object} errorData - Error response data
@@ -89,6 +129,9 @@ function formatPermissionError(errorData) {
 }
 
 module.exports = {
-  formatPermissionError
+  formatPermissionError,
+  getPermissionDetailLines,
+  extractMissingPermissions,
+  extractRequiredPermissions
 };
 

package/lib/utils/infra-containers.js

@@ -21,24 +21,25 @@ const execAsync = promisify(exec);
  * @async
  * @param {string} serviceName - Service name
  * @param {number|string} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.strict=false] - When true, only match current dev's container (no fallback to dev 0 / infra-*); use for status display
  * @returns {Promise<string|null>} Container name or null if not found
  */
-async function findContainer(serviceName, devId = null) {
+async function findContainer(serviceName, devId = null, options = {}) {
   try {
     const developerId = devId || await config.getDeveloperId();
     const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
     // Dev 0: aifabrix-{serviceName}, Dev > 0: aifabrix-dev{id}-{serviceName}
     const primaryPattern = idNum === 0 ? `aifabrix-${serviceName}` : `aifabrix-dev${developerId}-${serviceName}`;
 
-    // Search order expected by tests:
-    // 1) primaryPattern
-    // 2) infra-{serviceName} (old pattern)
-    // 3) aifabrix-{serviceName} (base pattern)
-    const patternsToTry = [
-      primaryPattern,
-      `infra-${serviceName}`,
-      `aifabrix-${serviceName}`
-    ];
+    // When strict (e.g. status command), only show this developer's infra; no fallback to dev 0
+    const patternsToTry = options.strict
+      ? [primaryPattern]
+      : [
+        primaryPattern,
+        `infra-${serviceName}`,
+        `aifabrix-${serviceName}`
+      ];
 
     for (const pattern of patternsToTry) {
       const { stdout } = await execAsync(`docker ps --filter "name=${pattern}" --format "{{.Names}}"`);
@@ -64,12 +65,13 @@ async function findContainer(serviceName, devId = null) {
  * @private
  * @async
  * @param {string} serviceName - Service name
- * @param {number} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ * @param {number|string} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ * @param {Object} [options] - Options (e.g. { strict: true } for current dev only)
  * @returns {Promise<string>} Health status
  */
-async function checkServiceWithHealthCheck(serviceName, devId = null) {
+async function checkServiceWithHealthCheck(serviceName, devId = null, options = {}) {
   try {
-    const containerName = await findContainer(serviceName, devId);
+    const containerName = await findContainer(serviceName, devId, options);
     if (!containerName) {
       return 'unknown';
     }
@@ -87,12 +89,13 @@ async function checkServiceWithHealthCheck(serviceName, devId = null) {
  * @private
  * @async
  * @param {string} serviceName - Service name
- * @param {number} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ * @param {number|string} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ * @param {Object} [options] - Options (e.g. { strict: true } for current dev only)
  * @returns {Promise<string>} Health status
  */
-async function checkServiceWithoutHealthCheck(serviceName, devId = null) {
+async function checkServiceWithoutHealthCheck(serviceName, devId = null, options = {}) {
   try {
-    const containerName = await findContainer(serviceName, devId);
+    const containerName = await findContainer(serviceName, devId, options);
     if (!containerName) {
       return 'unknown';
     }

package/lib/utils/infra-status.js

@@ -40,7 +40,7 @@ async function getInfraStatus() {
     pgadmin: { port: ports.pgadmin, url: `http://localhost:${ports.pgadmin}` },
     'redis-commander': { port: ports.redisCommander, url: `http://localhost:${ports.redisCommander}` },
     traefik: {
-      port: `${ports.traefikHttp}/${ports.traefikHttps}`,
+      port: `${ports.traefikHttp}, ${ports.traefikHttps}`,
       url: `http://localhost:${ports.traefikHttp}, https://localhost:${ports.traefikHttps}`
     }
   };
@@ -49,7 +49,8 @@ async function getInfraStatus() {
 
   for (const [serviceName, serviceConfig] of Object.entries(services)) {
     try {
-      const containerName = await containerUtils.findContainer(serviceName, devId);
+      // Strict: only this developer's infra (no fallback to dev 0), so status reflects reality
+      const containerName = await containerUtils.findContainer(serviceName, devId, { strict: true });
       if (containerName) {
         const { stdout } = await execAsync(`docker inspect --format='{{.State.Status}}' ${containerName}`);
         // Normalize status value (trim whitespace and remove quotes)
@@ -97,6 +98,9 @@ function getInfraContainerNames(devIdNum, devId) {
   ];
 }
 
+/** Suffixes for init/helper containers to exclude from "Running Applications" (e.g. keycloak-db-init) */
+const INIT_CONTAINER_SUFFIXES = ['-db-init', '-init'];
+
 /**
  * Extracts app name from container name
  * @param {string} containerName - Container name
@@ -107,7 +111,12 @@ function getInfraContainerNames(devIdNum, devId) {
 function extractAppName(containerName, devIdNum, devId) {
   const pattern = devIdNum === 0 ? /^aifabrix-(.+)$/ : new RegExp(`^aifabrix-dev${devId}-(.+)$`);
   const match = containerName.match(pattern);
-  return match ? match[1] : null;
+  if (!match) return null;
+  const appName = match[1];
+  if (INIT_CONTAINER_SUFFIXES.some(suffix => appName.endsWith(suffix))) {
+    return null;
+  }
+  return appName;
 }
 
 /**

package/lib/validation/wizard-config-validator.js

@@ -114,6 +114,39 @@ async function loadWizardConfig(configPath) {
   }
 }
 
+/**
+ * Write wizard configuration to wizard.yaml (creates directory if needed).
+ * @async
+ * @function writeWizardConfig
+ * @param {string} configPath - Path to wizard.yaml file
+ * @param {Object} config - Configuration object to write (will be dumped as YAML)
+ * @returns {Promise<void>}
+ * @throws {Error} If write fails
+ */
+async function writeWizardConfig(configPath, config) {
+  const resolvedPath = path.resolve(configPath);
+  const dir = path.dirname(resolvedPath);
+  await fs.mkdir(dir, { recursive: true });
+  const content = yaml.dump(config, { lineWidth: -1 });
+  await fs.writeFile(resolvedPath, content, 'utf8');
+}
+
+/**
+ * Check if wizard.yaml exists at path
+ * @async
+ * @function wizardConfigExists
+ * @param {string} configPath - Path to wizard.yaml file
+ * @returns {Promise<boolean>}
+ */
+async function wizardConfigExists(configPath) {
+  try {
+    await fs.access(path.resolve(configPath));
+    return true;
+  } catch (error) {
+    return error.code === 'ENOENT' ? false : Promise.reject(error);
+  }
+}
+
 /**
  * Validate wizard configuration against schema
  * @function validateWizardConfigSchema
@@ -258,6 +291,8 @@ function displayValidationResults(result) {
 
 module.exports = {
   loadWizardConfig,
+  writeWizardConfig,
+  wizardConfigExists,
   validateWizardConfig,
   validateWizardConfigSchema,
   resolveEnvVar,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.33.5",
+  "version": "2.36.0",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {
@@ -10,7 +10,7 @@
   "scripts": {
     "test": "node tests/scripts/test-wrapper.js",
     "test:ci": "bash tests/scripts/ci-simulate.sh",
-    "test:coverage": "jest --config jest.config.coverage.js --coverage --runInBand",
+    "test:coverage": "cross-env RUN_COVERAGE=1 node tests/scripts/test-wrapper.js",
     "test:coverage:nyc": "nyc --reporter=text --reporter=lcov --reporter=html jest --config jest.config.coverage.js --runInBand",
     "test:watch": "jest --watch",
     "test:integration": "jest --config jest.config.integration.js --runInBand",