@aifabrix/builder 2.33.6 → 2.36.1

package/lib/commands/wizard-helpers.js

@@ -0,0 +1,152 @@
+/**
+ * @fileoverview Wizard command helpers - pure and I/O helpers for wizard flow
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+
+/**
+ * Build preferences object for wizard.yaml (schema shape: intent, fieldOnboardingLevel, enableOpenAPIGeneration, enableMCP, enableABAC, enableRBAC)
+ * @param {string} intent - User intent
+ * @param {Object} preferences - From promptForUserPreferences (fieldOnboardingLevel, mcp, abac, rbac)
+ * @returns {Object} Preferences for wizard-config schema
+ */
+function buildPreferencesForSave(intent, preferences) {
+  const level = preferences?.fieldOnboardingLevel;
+  const validLevel = level === 'standard' || level === 'minimal' ? level : 'full';
+  return {
+    intent: intent || 'general integration',
+    fieldOnboardingLevel: validLevel,
+    enableOpenAPIGeneration: true,
+    enableMCP: Boolean(preferences?.mcp),
+    enableABAC: Boolean(preferences?.abac),
+    enableRBAC: Boolean(preferences?.rbac)
+  };
+}
+
+/**
+ * Build source object for wizard.yaml (no secrets)
+ * @param {Object} [source] - Source state
+ * @returns {Object|undefined}
+ */
+function buildSourceForSave(source) {
+  if (!source) return undefined;
+  const out = { type: source.type };
+  if (source.type === 'openapi-file' && source.filePath) out.filePath = source.filePath;
+  if (source.type === 'openapi-url' && source.url) out.url = source.url;
+  if (source.type === 'mcp-server' && source.serverUrl) {
+    out.serverUrl = source.serverUrl;
+    out.token = source.token ? '(set)' : undefined;
+  }
+  if (source.type === 'known-platform' && source.platform) out.platform = source.platform;
+  return out;
+}
+
+/**
+ * Build partial wizard state for saving to wizard.yaml (no secrets)
+ * @param {Object} opts - Collected state
+ * @returns {Object} Serializable wizard config shape
+ */
+function buildWizardStateForSave(opts) {
+  const state = {
+    appName: opts.appKey,
+    mode: opts.mode,
+    source: buildSourceForSave(opts.source)
+  };
+  if (opts.mode === 'add-datasource' && opts.systemIdOrKey) state.systemIdOrKey = opts.systemIdOrKey;
+  if (opts.credential) state.credential = opts.credential;
+  if (opts.preferences) state.preferences = opts.preferences;
+  return state;
+}
+
+/**
+ * Format source config as a short line for display
+ * @param {Object} [source] - Source config
+ * @returns {string|null}
+ */
+function formatSourceLine(source) {
+  if (!source) return null;
+  const s = source;
+  return s.type + (s.filePath ? ` (${s.filePath})` : s.url ? ` (${s.url})` : s.platform ? ` (${s.platform})` : '');
+}
+
+/**
+ * Format preferences config as a short line for display
+ * @param {Object} [preferences] - Preferences config
+ * @returns {string|null}
+ */
+function formatPreferencesLine(preferences) {
+  if (!preferences || (!preferences.intent && (preferences.enableMCP === undefined || preferences.enableMCP === null) && !preferences.fieldOnboardingLevel)) {
+    return null;
+  }
+  const p = preferences;
+  const parts = [
+    p.fieldOnboardingLevel && `level=${p.fieldOnboardingLevel}`,
+    p.intent && `intent=${p.intent}`,
+    p.enableMCP && 'MCP',
+    p.enableABAC && 'ABAC',
+    p.enableRBAC && 'RBAC'
+  ].filter(Boolean);
+  return parts.length ? parts.join(', ') : '(defaults)';
+}
+
+/**
+ * Show a short summary of loaded wizard config (for resume flow)
+ * @param {Object} config - Loaded wizard config
+ * @param {string} displayPath - Path to show (e.g. integration/test/wizard.yaml)
+ */
+function showWizardConfigSummary(config, displayPath) {
+  logger.log(chalk.blue('\n📋 Saved config summary'));
+  logger.log(chalk.gray(`  From: ${displayPath}`));
+  if (config.appName) logger.log(chalk.gray(`  App: ${config.appName}`));
+  if (config.mode) logger.log(chalk.gray(`  Mode: ${config.mode}`));
+  const srcLine = formatSourceLine(config.source);
+  if (srcLine) logger.log(chalk.gray(`  Source: ${srcLine}`));
+  if (config.credential) logger.log(chalk.gray(`  Credential: ${config.credential.action || 'skip'}`));
+  const prefs = formatPreferencesLine(config.preferences);
+  if (prefs) logger.log(chalk.gray(`  Preferences: ${prefs}`));
+  logger.log('');
+}
+
+/**
+ * Ensure integration/<appKey> directory exists
+ * @param {string} appKey - Application key
+ * @returns {Promise<string>} Resolved config path (integration/<appKey>/wizard.yaml)
+ */
+async function ensureIntegrationDir(appKey) {
+  const dir = path.join(process.cwd(), 'integration', appKey);
+  await fs.mkdir(dir, { recursive: true });
+  return path.join(dir, 'wizard.yaml');
+}
+
+/** External system types that support add-datasource (excludes webapp/application) */
+const EXTERNAL_SYSTEM_TYPES = ['openapi', 'mcp', 'custom'];
+
+/**
+ * Returns true if the system is an external system that supports add-datasource (not a webapp).
+ * @param {Object} sys - System object from getExternalSystem (may have type, systemType, or kind)
+ * @returns {boolean}
+ */
+function isExternalSystemForAddDatasource(sys) {
+  const type = (sys?.type || sys?.systemType || sys?.kind || '').toLowerCase();
+  if (!type) return true;
+  if (EXTERNAL_SYSTEM_TYPES.includes(type)) return true;
+  if (['webapp', 'application', 'app'].includes(type)) return false;
+  return true;
+}
+
+module.exports = {
+  buildPreferencesForSave,
+  buildSourceForSave,
+  buildWizardStateForSave,
+  formatSourceLine,
+  formatPreferencesLine,
+  showWizardConfigSummary,
+  ensureIntegrationDir,
+  EXTERNAL_SYSTEM_TYPES,
+  isExternalSystemForAddDatasource
+};

package/lib/commands/wizard.js

@@ -13,11 +13,13 @@ const {
   promptForOpenApiFile,
   promptForOpenApiUrl,
   promptForMcpServer,
+  promptForCredentialAction,
   promptForKnownPlatform,
   promptForUserIntent,
   promptForUserPreferences,
   promptForConfigReview,
-  promptForAppName
+  promptForAppName,
+  promptForRunWithSavedConfig
 } = require('../generator/wizard-prompts');
 const {
   validateAndCheckAppDirectory,
@@ -31,7 +33,17 @@ const {
   setupDataplaneAndAuth
 } = require('./wizard-core');
 const { handleWizardHeadless } = require('./wizard-headless');
-const { createWizardSession, updateWizardSession } = require('../api/wizard.api');
+const { createWizardSession, updateWizardSession, getWizardPlatforms } = require('../api/wizard.api');
+const { getExternalSystem } = require('../api/external-systems.api');
+const { writeWizardConfig, wizardConfigExists, validateWizardConfig } = require('../validation/wizard-config-validator');
+const { appendWizardError } = require('../utils/cli-utils');
+const {
+  buildPreferencesForSave,
+  buildWizardStateForSave,
+  showWizardConfigSummary,
+  ensureIntegrationDir,
+  isExternalSystemForAddDatasource
+} = require('./wizard-helpers');
 
 /**
  * Extract session ID from response data
@@ -53,22 +65,18 @@ function extractSessionId(responseData) {
 }
 
 /**
- * Handle interactive mode selection step
+ * Create wizard session with given mode and optional systemIdOrKey (no prompts)
  * @async
- * @function handleInteractiveModeSelection
+ * @function createSessionFromParams
  * @param {string} dataplaneUrl - Dataplane URL
  * @param {Object} authConfig - Authentication configuration
+ * @param {string} mode - Mode ('create-system' | 'add-datasource')
+ * @param {string} [systemIdOrKey] - System ID or key (for add-datasource)
  * @param {string} [appName] - Application name (for 401 hint)
- * @returns {Promise<Object>} Object with mode and sessionId
+ * @returns {Promise<string>} Session ID
  */
-async function handleInteractiveModeSelection(dataplaneUrl, authConfig, appName) {
-  logger.log(chalk.blue('\n\uD83D\uDCCB Step 1: Mode Selection'));
-  const mode = await promptForMode();
-  let systemIdOrKey = null;
-  if (mode === 'add-datasource') {
-    systemIdOrKey = await promptForSystemIdOrKey();
-  }
-  const sessionResponse = await createWizardSession(dataplaneUrl, authConfig, mode, systemIdOrKey);
+async function createSessionFromParams(dataplaneUrl, authConfig, mode, systemIdOrKey, appName) {
+  const sessionResponse = await createWizardSession(dataplaneUrl, authConfig, mode, systemIdOrKey || null);
   if (!sessionResponse.success || !sessionResponse.data) {
     const errorMsg = sessionResponse.formattedError || sessionResponse.error ||
                      sessionResponse.errorData?.detail || sessionResponse.message ||
@@ -79,8 +87,7 @@ async function handleInteractiveModeSelection(dataplaneUrl, authConfig, appName)
       : `Failed to create wizard session: ${errorMsg}`;
     throw new Error(fullMsg);
   }
-  const sessionId = extractSessionId(sessionResponse.data);
-  return { mode, sessionId, systemIdOrKey };
+  return extractSessionId(sessionResponse.data);
 }
 
 /**
@@ -90,11 +97,12 @@ async function handleInteractiveModeSelection(dataplaneUrl, authConfig, appName)
  * @param {string} dataplaneUrl - Dataplane URL
  * @param {string} sessionId - Wizard session ID
  * @param {Object} authConfig - Authentication configuration
+ * @param {Array<{key: string, displayName?: string}>} [platforms] - Known platforms from dataplane (empty = hide "Known platform")
  * @returns {Promise<Object>} Object with sourceType and sourceData
  */
-async function handleInteractiveSourceSelection(dataplaneUrl, sessionId, authConfig) {
+async function handleInteractiveSourceSelection(dataplaneUrl, sessionId, authConfig, platforms = []) {
   logger.log(chalk.blue('\n\uD83D\uDCCB Step 2: Source Selection'));
-  const sourceType = await promptForSourceType();
+  const sourceType = await promptForSourceType(platforms);
   let sourceData = null;
   const updateData = { currentStep: 1 };
 
@@ -108,7 +116,7 @@ async function handleInteractiveSourceSelection(dataplaneUrl, sessionId, authCon
     sourceData = JSON.stringify(mcpDetails);
     updateData.mcpServerUrl = mcpDetails.url || null;
   } else if (sourceType === 'known-platform') {
-    sourceData = await promptForKnownPlatform();
+    sourceData = await promptForKnownPlatform(platforms);
   }
 
   const updateResponse = await updateWizardSession(dataplaneUrl, sessionId, authConfig, updateData);
@@ -131,7 +139,7 @@ async function handleInteractiveSourceSelection(dataplaneUrl, sessionId, authCon
  * @param {Object} options.detectedType - Detected type info
  * @param {string} [options.credentialIdOrKey] - Credential ID or key (optional)
  * @param {string} [options.systemIdOrKey] - System ID or key (optional)
- * @returns {Promise<Object>} Generated configuration
+ * @returns {Promise<Object>} Generated configuration and preferences { systemConfig, datasourceConfigs, systemKey, preferences }
  */
 async function handleInteractiveConfigGeneration(options) {
   logger.log(chalk.blue('\n\uD83D\uDCCB Step 5: User Preferences'));
@@ -140,12 +148,13 @@ async function handleInteractiveConfigGeneration(options) {
 
   const configPrefs = {
     intent: userIntent,
+    fieldOnboardingLevel: preferences.fieldOnboardingLevel || 'full',
     enableMCP: preferences.mcp,
     enableABAC: preferences.abac,
     enableRBAC: preferences.rbac
   };
 
-  return await handleConfigurationGeneration(options.dataplaneUrl, options.authConfig, {
+  const result = await handleConfigurationGeneration(options.dataplaneUrl, options.authConfig, {
     mode: options.mode,
     openapiSpec: options.openapiSpec,
     detectedType: options.detectedType,
@@ -153,6 +162,11 @@ async function handleInteractiveConfigGeneration(options) {
     credentialIdOrKey: options.credentialIdOrKey,
     systemIdOrKey: options.systemIdOrKey
   });
+
+  return {
+    ...result,
+    preferences: buildPreferencesForSave(userIntent, preferences)
+  };
 }
 
 /**
@@ -183,32 +197,37 @@ async function handleConfigurationReview(dataplaneUrl, authConfig, systemConfig,
 }
 
 /**
- * Execute wizard flow steps (interactive mode)
+ * Run steps 2–7 after session is created (source, credential, type, generate, review, save).
+ * On any error, saves partial wizard.yaml with all collected state so far, appends to error.log, then rethrows.
  * @async
- * @function executeWizardFlow
- * @param {string} appName - Application name
+ * @param {string} appKey - Application key
  * @param {string} dataplaneUrl - Dataplane URL
  * @param {Object} authConfig - Authentication configuration
- * @returns {Promise<void>} Resolves when wizard flow completes
+ * @param {string} sessionId - Wizard session ID
+ * @param {Object} flowOpts - Mode, systemIdOrKey, platforms, configPath
+ * @returns {Promise<Object>} Collected state (source, credential, preferences) for wizard.yaml save
  */
-async function executeWizardFlow(appName, dataplaneUrl, authConfig) {
-  // Step 1: Mode Selection
-  const { mode, sessionId, systemIdOrKey } = await handleInteractiveModeSelection(dataplaneUrl, authConfig, appName);
-
-  // Step 2: Source Selection
-  const { sourceType, sourceData } = await handleInteractiveSourceSelection(dataplaneUrl, sessionId, authConfig);
+async function doWizardSteps(appKey, dataplaneUrl, authConfig, sessionId, flowOpts, state) {
+  const { mode, systemIdOrKey, platforms } = flowOpts;
+  const { sourceType, sourceData } = await handleInteractiveSourceSelection(
+    dataplaneUrl, sessionId, authConfig, platforms
+  );
+  state.source = { type: sourceType };
+  if (sourceType === 'openapi-file') state.source.filePath = sourceData;
+  else if (sourceType === 'openapi-url') state.source.url = sourceData;
+  else if (sourceType === 'mcp-server') state.source.serverUrl = JSON.parse(sourceData).serverUrl;
+  else if (sourceType === 'known-platform') state.source.platform = sourceData;
 
-  // Parse OpenAPI (part of step 2)
   const openapiSpec = await handleOpenApiParsing(dataplaneUrl, authConfig, sourceType, sourceData);
+  const credentialAction = await promptForCredentialAction();
+  const configCredential = credentialAction.action === 'skip'
+    ? { action: 'skip' }
+    : { action: credentialAction.action, credentialIdOrKey: credentialAction.credentialIdOrKey };
+  state.credential = configCredential;
+  const credentialIdOrKey = await handleCredentialSelection(dataplaneUrl, authConfig, configCredential);
 
-  // Step 3: Credential Selection (optional)
-  const credentialIdOrKey = await handleCredentialSelection(dataplaneUrl, authConfig);
-
-  // Step 4: Detect Type
   const detectedType = await handleTypeDetection(dataplaneUrl, authConfig, openapiSpec);
-
-  // Step 5: Generate Configuration
-  const { systemConfig, datasourceConfigs, systemKey } = await handleInteractiveConfigGeneration({
+  const genResult = await handleInteractiveConfigGeneration({
     dataplaneUrl,
     authConfig,
     mode,
@@ -217,60 +236,249 @@ async function executeWizardFlow(appName, dataplaneUrl, authConfig) {
     credentialIdOrKey,
     systemIdOrKey
   });
+  const { systemConfig, datasourceConfigs, systemKey, preferences: savedPrefs } = genResult;
+  state.preferences = savedPrefs || {};
 
-  // Step 6-7: Review & Validate
   const finalConfigs = await handleConfigurationReview(dataplaneUrl, authConfig, systemConfig, datasourceConfigs);
-  if (!finalConfigs) return;
+  if (!finalConfigs) return null;
 
-  // Step 7: Save Files
   await handleFileSaving(
-    appName,
+    appKey,
     finalConfigs.systemConfig,
     finalConfigs.datasourceConfigs,
-    systemKey || appName,
+    systemKey || appKey,
     dataplaneUrl,
     authConfig
   );
+  return state;
+}
+
+async function runWizardStepsAfterSession(appKey, dataplaneUrl, authConfig, sessionId, flowOpts) {
+  const { mode, systemIdOrKey, configPath } = flowOpts;
+  const state = { appKey, mode, systemIdOrKey: mode === 'add-datasource' ? systemIdOrKey : undefined };
+
+  const savePartialOnError = async(err) => {
+    state.preferences = state.preferences || {};
+    if (configPath) {
+      try {
+        await writeWizardConfig(configPath, buildWizardStateForSave(state));
+      } catch (e) {
+        logger.warn(`Could not save partial wizard.yaml: ${e.message}`);
+      }
+    }
+    await appendWizardError(appKey, err);
+    err.wizardResumeMessage = `To resume: aifabrix wizard ${appKey}\nSee integration/${appKey}/error.log for details.`;
+    err.wizardPartialSaved = true;
+  };
+
+  try {
+    return await doWizardSteps(appKey, dataplaneUrl, authConfig, sessionId, flowOpts, state);
+  } catch (err) {
+    await savePartialOnError(err);
+    throw err;
+  }
 }
 
 /**
- * Handle wizard command
+ * Execute wizard flow steps (interactive mode). Mode and systemIdOrKey are already set; creates session then runs steps 2–7.
  * @async
- * @function handleWizard
+ * @function executeWizardFlow
+ * @param {string} appKey - Application/integration key (folder name under integration/)
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} flowOpts - Flow options (mode, systemIdOrKey, configPath)
+ * @returns {Promise<void>} Resolves when wizard flow completes
+ */
+async function executeWizardFlow(appKey, dataplaneUrl, authConfig, flowOpts = {}) {
+  const { mode, systemIdOrKey, configPath } = flowOpts;
+
+  logger.log(chalk.blue('\n\uD83D\uDCCB Step 1: Create Session'));
+  const sessionId = await createSessionFromParams(dataplaneUrl, authConfig, mode, systemIdOrKey, appKey);
+  logger.log(chalk.green('\u2713 Session created'));
+
+  const platforms = await getWizardPlatforms(dataplaneUrl, authConfig);
+  const state = await runWizardStepsAfterSession(appKey, dataplaneUrl, authConfig, sessionId, {
+    mode,
+    systemIdOrKey,
+    platforms,
+    configPath
+  });
+  if (!state) return;
+
+  if (configPath) {
+    await writeWizardConfig(configPath, buildWizardStateForSave(state));
+  }
+}
+
+/**
+ * Load wizard config from configPath if it exists (for prefill)
+ * @param {string} [configPath] - Path to wizard.yaml (e.g. integration/<app>/wizard.yaml)
+ * @param {string} [appName] - App name (for log message)
+ * @returns {Promise<Object|null>} Loaded config or null
+ */
+async function loadWizardConfigIfExists(configPath, appName) {
+  if (!configPath) return null;
+  const displayPath = appName ? `integration/${appName}/wizard.yaml` : configPath;
+  try {
+    const exists = await wizardConfigExists(configPath);
+    if (!exists) {
+      logger.log(chalk.gray(`No saved state at ${displayPath}; starting from step 1.`));
+      return null;
+    }
+    const result = await validateWizardConfig(configPath, { validateFilePaths: false });
+    if (result.valid && result.config) {
+      logger.log(chalk.green(`Loaded saved state from ${displayPath}. Resuming with saved choices.`));
+      return result.config;
+    }
+    if (result.errors?.length) {
+      logger.log(chalk.yellow(`Loaded ${displayPath} but it has errors; prompting for missing fields.`));
+    }
+  } catch (e) {
+    logger.log(chalk.gray(`Could not load wizard config from ${displayPath}: ${e.message}`));
+  }
+  return null;
+}
+
+/**
+ * Resolve appKey, configPath, dataplane and auth for "create-system" mode
  * @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)
- * @param {string} [options.config] - Path to wizard.yaml config file (headless mode)
- * @returns {Promise<void>} Resolves when wizard completes
- * @throws {Error} If wizard fails
+ * @param {Object} [loadedConfig] - Loaded wizard config
+ * @returns {Promise<Object|null>} { appKey, configPath, dataplaneUrl, authConfig } or null if cancelled
  */
-async function handleWizard(options = {}) {
-  // Check if headless mode (config file provided)
-  if (options.config) {
-    return await handleWizardHeadless(options);
+async function resolveCreateNewPath(options, loadedConfig) {
+  const appName = options.app || loadedConfig?.appName || (await promptForAppName(loadedConfig?.appName));
+  const shouldContinue = await validateAndCheckAppDirectory(appName, true);
+  if (!shouldContinue) return null;
+  const appKey = appName;
+  const configPath = await ensureIntegrationDir(appKey);
+  const { dataplaneUrl, authConfig } = await setupDataplaneAndAuth(options, appName);
+  return { appKey, configPath, dataplaneUrl, authConfig };
+}
+
+/**
+ * Resolve appKey, configPath, dataplane and auth for "add-datasource" mode (validates system)
+ * @param {Object} options - Command options
+ * @param {Object} [loadedConfig] - Loaded wizard config
+ * @returns {Promise<Object>} { appKey, configPath, dataplaneUrl, authConfig, systemIdOrKey }
+ */
+async function resolveAddDatasourcePath(options, loadedConfig) {
+  let systemIdOrKey = loadedConfig?.systemIdOrKey || (await promptForSystemIdOrKey(loadedConfig?.systemIdOrKey));
+  const { dataplaneUrl, authConfig } = await setupDataplaneAndAuth(options, systemIdOrKey || 'wizard');
+  let systemResponse;
+  for (;;) {
+    try {
+      systemResponse = await getExternalSystem(dataplaneUrl, systemIdOrKey, authConfig);
+      const sys = systemResponse?.data || systemResponse;
+      if (sys && (systemResponse?.data || systemResponse?.success)) {
+        if (!isExternalSystemForAddDatasource(sys)) {
+          logger.log(chalk.red('Cannot add datasource to a webapp. Please enter an external system ID or key.'));
+          systemIdOrKey = await promptForSystemIdOrKey(systemIdOrKey);
+          continue;
+        }
+        break;
+      }
+    } catch (err) {
+      logger.log(chalk.red(`System not found or error: ${err.message}`));
+    }
+    systemIdOrKey = await promptForSystemIdOrKey(systemIdOrKey);
   }
+  const sys = systemResponse?.data || systemResponse;
+  const appKey = sys?.key || sys?.systemKey || systemIdOrKey;
+  const configPath = await ensureIntegrationDir(appKey);
+  return { appKey, configPath, dataplaneUrl, authConfig, systemIdOrKey };
+}
 
-  logger.log(chalk.blue('\n\uD83E\uDDD9 AI Fabrix External System Wizard\n'));
+/**
+ * On wizard error: append to error.log, save partial wizard.yaml, set resume message
+ * @param {string} appKey - Application key
+ * @param {string} [configPath] - Path to wizard.yaml
+ * @param {string} mode - Wizard mode
+ * @param {string} [systemIdOrKey] - System ID (add-datasource)
+ * @param {Error} error - The error
+ */
+async function handleWizardError(appKey, configPath, mode, systemIdOrKey, error) {
+  await appendWizardError(appKey, error);
+  if (!error.wizardPartialSaved && configPath) {
+    const partial = buildWizardStateForSave({
+      appKey,
+      mode,
+      systemIdOrKey: mode === 'add-datasource' ? systemIdOrKey : undefined
+    });
+    try {
+      await writeWizardConfig(configPath, partial);
+    } catch (e) {
+      logger.warn(`Could not save partial wizard.yaml: ${e.message}`);
+    }
+  }
+  error.wizardResumeMessage = `To resume: aifabrix wizard ${appKey}\nSee integration/${appKey}/error.log for details.`;
+}
 
-  // Get or prompt for app name
-  let appName = options.app;
-  if (!appName) {
-    appName = await promptForAppName();
+/**
+ * Handle wizard command (mode-first, load/save wizard.yaml, error.log on failure)
+ * @async
+ * @function handleWizard
+ * @param {Object} options - Command options
+ * @param {string} [options.app] - Application name (from positional or -a)
+ * @param {string} [options.config] - Path to wizard.yaml (headless mode)
+ * @param {string} [options.configPath] - Resolved path integration/<app>/wizard.yaml for load/save
+ * @returns {Promise<void>} Resolves when wizard completes
+ * @throws {Error} If wizard fails (wizardResumeMessage set when appKey known)
+ */
+async function handleWizardSilent(options) {
+  if (!options.configPath) {
+    throw new Error('--silent requires an app name (e.g. aifabrix wizard test --silent)');
+  }
+  const result = await validateWizardConfig(options.configPath, { validateFilePaths: false });
+  if (!result.valid || !result.config) {
+    const displayPath = options.app ? `integration/${options.app}/wizard.yaml` : '';
+    const errMsg = result.errors?.length ? result.errors.join('; ') : 'Invalid or missing wizard.yaml';
+    throw new Error(`Cannot run --silent: ${displayPath} is invalid or missing. ${errMsg}`);
   }
+  return await handleWizardHeadless({ ...options, config: options.configPath });
+}
 
-  // Validate app name and check directory
-  const shouldContinue = await validateAndCheckAppDirectory(appName, true);
-  if (!shouldContinue) {
+async function handleWizardWithSavedConfig(options, loadedConfig, displayPath) {
+  showWizardConfigSummary(loadedConfig, displayPath);
+  const runWithSaved = await promptForRunWithSavedConfig();
+  if (!runWithSaved) {
+    logger.log(chalk.gray(`To change settings, edit ${displayPath} and run: aifabrix wizard ${options.app}`));
     return;
   }
+  logger.log(chalk.gray(`Running with saved config from ${displayPath}...\n`));
+  return await handleWizardHeadless({ ...options, config: options.configPath });
+}
 
-  // Get dataplane URL and authentication
-  const { dataplaneUrl, authConfig } = await setupDataplaneAndAuth(options, appName);
+async function handleWizardInteractive(options) {
+  const mode = await promptForMode();
+  const resolved = mode === 'create-system'
+    ? await resolveCreateNewPath(options, null)
+    : await resolveAddDatasourcePath(options, null);
+  if (!resolved) return;
+  const { appKey, configPath, dataplaneUrl, authConfig } = resolved;
+  const systemIdOrKey = mode === 'add-datasource' ? resolved.systemIdOrKey : undefined;
+  try {
+    await executeWizardFlow(appKey, dataplaneUrl, authConfig, { mode, systemIdOrKey, configPath });
+    logger.log(chalk.gray(`To change settings, edit integration/${appKey}/wizard.yaml and run: aifabrix wizard ${appKey}`));
+  } catch (error) {
+    await handleWizardError(appKey, configPath, mode, systemIdOrKey, error);
+    throw error;
+  }
+}
 
-  // Execute wizard flow
-  await executeWizardFlow(appName, dataplaneUrl, authConfig);
+async function handleWizard(options = {}) {
+  if (options.config) {
+    return await handleWizardHeadless(options);
+  }
+  const displayPath = options.app ? `integration/${options.app}/wizard.yaml` : '';
+  if (options.silent && options.app) {
+    return await handleWizardSilent(options);
+  }
+  logger.log(chalk.blue('\n\uD83E\uDDD9 AI Fabrix External System Wizard\n'));
+  const loadedConfig = await loadWizardConfigIfExists(options.configPath, options.app);
+  if (loadedConfig) {
+    return await handleWizardWithSavedConfig(options, loadedConfig, displayPath);
+  }
+  return await handleWizardInteractive(options);
 }
 
 module.exports = { handleWizard, handleWizardHeadless };

package/lib/generator/index.js

@@ -91,6 +91,37 @@ function buildAndValidateDeployment(appName, variables, envTemplate, rbac) {
   return deployment;
 }
 
+/**
+ * Builds deployment manifest in memory (no file write, no schema validation).
+ * Same structure as generateDeployJson output; used by "aifabrix show" offline.
+ * @async
+ * @function buildDeploymentManifestInMemory
+ * @param {string} appName - Application name
+ * @param {Object} [options] - Options (e.g. type for external)
+ * @returns {Promise<{ deployment: Object, appPath: string }>} Manifest and app path
+ * @throws {Error} If variables.yaml/env.template missing or generation fails
+ */
+async function buildDeploymentManifestInMemory(appName, options = {}) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('App name is required and must be a string');
+  }
+
+  const { isExternal, appPath, appType } = await detectAppType(appName, options);
+
+  if (isExternal) {
+    const manifest = await generateControllerManifest(appName);
+    return { deployment: manifest, appPath };
+  }
+
+  const { variables, envTemplate, rbac } = loadDeploymentConfigFiles(appPath, appType, appName);
+  const configuration = parseEnvironmentVariables(envTemplate, variables);
+  const deployment = builders.buildManifestStructure(appName, variables, null, configuration, rbac);
+  const deploymentKey = _keyGenerator.generateDeploymentKeyFromJson(deployment);
+  deployment.deploymentKey = deploymentKey;
+
+  return { deployment, appPath };
+}
+
 async function generateDeployJson(appName, options = {}) {
   if (!appName || typeof appName !== 'string') {
     throw new Error('App name is required and must be a string');
@@ -153,6 +184,7 @@ async function generateDeployJsonWithValidation(appName, options = {}) {
 module.exports = {
   generateDeployJson,
   generateDeployJsonWithValidation,
+  buildDeploymentManifestInMemory,
   generateExternalSystemApplicationSchema,
   splitExternalApplicationSchema,
   parseEnvironmentVariables,