@aifabrix/builder 2.32.2 → 2.33.0

package/lib/commands/wizard.js

@@ -1,28 +1,14 @@
 /**
- * @fileoverview Wizard command handler - interactive external system creation
+ * @fileoverview Wizard command handler - interactive and headless 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,
+  promptForSystemIdOrKey,
   promptForSourceType,
   promptForOpenApiFile,
   promptForOpenApiUrl,
@@ -33,282 +19,148 @@ const {
   promptForConfigReview,
   promptForAppName
 } = require('../generator/wizard-prompts');
-const { generateWizardFiles } = require('../generator/wizard');
+const {
+  validateAndCheckAppDirectory,
+  handleOpenApiParsing,
+  handleCredentialSelection,
+  handleTypeDetection,
+  handleConfigurationGeneration,
+  validateWizardConfiguration,
+  handleFileSaving,
+  setupDataplaneAndAuth
+} = require('./wizard-core');
+const { handleWizardHeadless } = require('./wizard-headless');
+const { createWizardSession, updateWizardSession } = require('../api/wizard.api');
 
 /**
- * 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
+ * Extract session ID from response data
+ * @function extractSessionId
+ * @param {Object} responseData - Response data from API
+ * @returns {string} Session ID
+ * @throws {Error} If session ID not found or invalid
  */
-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');
+function extractSessionId(responseData) {
+  let sessionId = responseData?.data?.sessionId || responseData?.sessionId ||
+                  responseData?.data?.session_id || responseData?.session_id;
+  if (sessionId && typeof sessionId === 'object') {
+    sessionId = sessionId.id || sessionId.sessionId || sessionId.session_id;
   }
-
-  // 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;
-    }
+  if (!sessionId || typeof sessionId !== 'string') {
+    throw new Error(`Session ID not found: ${JSON.stringify(responseData, null, 2)}`);
   }
-  return true;
+  return sessionId;
 }
 
 /**
- * Handle mode selection step
+ * Handle interactive mode selection step
  * @async
- * @function handleModeSelection
+ * @function handleInteractiveModeSelection
  * @param {string} dataplaneUrl - Dataplane URL
  * @param {Object} authConfig - Authentication configuration
- * @returns {Promise<string>} Selected mode
- * @throws {Error} If mode selection fails
+ * @returns {Promise<Object>} Object with mode and sessionId
  */
-async function handleModeSelection(dataplaneUrl, authConfig) {
-  logger.log(chalk.blue('\n📋 Step 1: Mode Selection'));
+async function handleInteractiveModeSelection(dataplaneUrl, authConfig) {
+  logger.log(chalk.blue('\n\uD83D\uDCCB 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}`);
+  let systemIdOrKey = null;
+  if (mode === 'add-datasource') {
+    systemIdOrKey = await promptForSystemIdOrKey();
   }
-  return mode;
+  const sessionResponse = await createWizardSession(dataplaneUrl, authConfig, mode, systemIdOrKey);
+  if (!sessionResponse.success || !sessionResponse.data) {
+    const errorMsg = sessionResponse.formattedError || sessionResponse.error ||
+                     sessionResponse.errorData?.detail || sessionResponse.message ||
+                     (sessionResponse.status ? `HTTP ${sessionResponse.status}` : 'Unknown error');
+    throw new Error(`Failed to create wizard session: ${errorMsg}`);
+  }
+  const sessionId = extractSessionId(sessionResponse.data);
+  return { mode, sessionId, systemIdOrKey };
 }
 
 /**
- * Handle source selection step
+ * Handle interactive source selection step
  * @async
- * @function handleSourceSelection
+ * @function handleInteractiveSourceSelection
  * @param {string} dataplaneUrl - Dataplane URL
+ * @param {string} sessionId - Wizard session ID
  * @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'));
+async function handleInteractiveSourceSelection(dataplaneUrl, sessionId, authConfig) {
+  logger.log(chalk.blue('\n\uD83D\uDCCB Step 2: Source Selection'));
   const sourceType = await promptForSourceType();
   let sourceData = null;
+  const updateData = { currentStep: 1 };
 
   if (sourceType === 'openapi-file') {
-    const filePath = await promptForOpenApiFile();
-    sourceData = filePath;
+    sourceData = await promptForOpenApiFile();
   } else if (sourceType === 'openapi-url') {
-    const url = await promptForOpenApiUrl();
-    sourceData = url;
+    sourceData = await promptForOpenApiUrl();
+    updateData.openapiSpec = null;
   } else if (sourceType === 'mcp-server') {
     const mcpDetails = await promptForMcpServer();
     sourceData = JSON.stringify(mcpDetails);
+    updateData.mcpServerUrl = mcpDetails.url || null;
   } else if (sourceType === 'known-platform') {
-    const platform = await promptForKnownPlatform();
-    sourceData = platform;
+    sourceData = await promptForKnownPlatform();
   }
 
-  const sourceResponse = await selectSource(dataplaneUrl, authConfig, sourceType, sourceData);
-  if (!sourceResponse.success) {
-    throw new Error(`Source selection failed: ${sourceResponse.error || sourceResponse.formattedError}`);
+  const updateResponse = await updateWizardSession(dataplaneUrl, sessionId, authConfig, updateData);
+  if (!updateResponse.success) {
+    throw new Error(`Source selection failed: ${updateResponse.error || updateResponse.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
+ * Handle interactive 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
+ * @function handleInteractiveConfigGeneration
+ * @param {Object} options - Configuration options
+ * @param {string} options.dataplaneUrl - Dataplane URL
+ * @param {Object} options.authConfig - Authentication configuration
+ * @param {string} options.mode - Selected mode
+ * @param {Object} options.openapiSpec - OpenAPI specification
+ * @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
  */
-async function handleConfigurationGeneration(dataplaneUrl, authConfig, mode, sourceType, openApiSpec) {
-  logger.log(chalk.blue('\n📋 Step 5: User Preferences'));
+async function handleInteractiveConfigGeneration(options) {
+  logger.log(chalk.blue('\n\uD83D\uDCCB 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;
-  }
+  const configPrefs = {
+    intent: userIntent,
+    enableMCP: preferences.mcp,
+    enableABAC: preferences.abac,
+    enableRBAC: preferences.rbac
+  };
+
+  return await handleConfigurationGeneration(options.dataplaneUrl, options.authConfig, {
+    mode: options.mode,
+    openapiSpec: options.openapiSpec,
+    detectedType: options.detectedType,
+    configPrefs,
+    credentialIdOrKey: options.credentialIdOrKey,
+    systemIdOrKey: options.systemIdOrKey
+  });
 }
 
 /**
- * Handle configuration review and validation step
+ * Handle configuration review and validation step (interactive mode only)
  * @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
+ * @returns {Promise<Object>} Final configurations
  */
 async function handleConfigurationReview(dataplaneUrl, authConfig, systemConfig, datasourceConfigs) {
-  logger.log(chalk.blue('\n📋 Step 7: Review & Validate'));
+  logger.log(chalk.blue('\n\uD83D\uDCCB Step 6-7: Review & Validate'));
   const reviewResult = await promptForConfigReview(systemConfig, datasourceConfigs);
 
   if (reviewResult.action === 'cancel') {
@@ -316,97 +168,55 @@ async function handleConfigurationReview(dataplaneUrl, authConfig, systemConfig,
     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
+ * Execute wizard flow steps (interactive mode)
  * @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);
+  const { mode, sessionId, systemIdOrKey } = await handleInteractiveModeSelection(dataplaneUrl, authConfig);
 
   // Step 2: Source Selection
-  const { sourceType, sourceData } = await handleSourceSelection(dataplaneUrl, authConfig);
+  const { sourceType, sourceData } = await handleInteractiveSourceSelection(dataplaneUrl, sessionId, authConfig);
 
-  // Step 3: Parse OpenAPI (if applicable)
-  const openApiSpec = await handleOpenApiParsing(dataplaneUrl, authConfig, sourceType, sourceData);
+  // Parse OpenAPI (part of step 2)
+  const openapiSpec = await handleOpenApiParsing(dataplaneUrl, authConfig, sourceType, sourceData);
 
-  // Step 4: Detect Type (optional, if OpenAPI spec available)
-  await handleTypeDetection(dataplaneUrl, authConfig, openApiSpec);
+  // Step 3: Credential Selection (optional)
+  const credentialIdOrKey = await handleCredentialSelection(dataplaneUrl, authConfig);
 
-  // Step 5-6: Generate Configuration
-  const { systemConfig, datasourceConfigs, systemKey } = await handleConfigurationGeneration(
+  // Step 4: Detect Type
+  const detectedType = await handleTypeDetection(dataplaneUrl, authConfig, openapiSpec);
+
+  // Step 5: Generate Configuration
+  const { systemConfig, datasourceConfigs, systemKey } = await handleInteractiveConfigGeneration({
     dataplaneUrl,
     authConfig,
     mode,
-    sourceType,
-    openApiSpec
-  );
+    openapiSpec,
+    detectedType,
+    credentialIdOrKey,
+    systemIdOrKey
+  });
 
-  // Step 7: Review & Validate
+  // Step 6-7: Review & Validate
   const finalConfigs = await handleConfigurationReview(dataplaneUrl, authConfig, systemConfig, datasourceConfigs);
-  if (!finalConfigs) {
-    return; // User cancelled
-  }
+  if (!finalConfigs) return;
 
-  // Step 8: Save Files
+  // Step 7: Save Files
   await handleFileSaving(
     appName,
     finalConfigs.systemConfig,
@@ -426,73 +236,35 @@ async function executeWizardFlow(appName, dataplaneUrl, authConfig) {
  * @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
  */
 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;
+  // Check if headless mode (config file provided)
+  if (options.config) {
+    return await handleWizardHeadless(options);
   }
-}
-
-/**
- * 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}`));
+  logger.log(chalk.blue('\n\uD83E\uDDD9 AI Fabrix External System Wizard\n'));
 
-    return { dataplaneUrl, authConfig };
+  // Get or prompt for app name
+  let appName = options.app;
+  if (!appName) {
+    appName = await promptForAppName();
   }
 
-  // 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.');
+  // Validate app name and check directory
+  const shouldContinue = await validateAndCheckAppDirectory(appName, true);
+  if (!shouldContinue) {
+    return;
   }
 
-  return { dataplaneUrl, authConfig };
+  // Get dataplane URL and authentication
+  const { dataplaneUrl, authConfig } = await setupDataplaneAndAuth(options, appName);
+
+  // Execute wizard flow
+  await executeWizardFlow(appName, dataplaneUrl, authConfig);
 }
-module.exports = { handleWizard };
+
+module.exports = { handleWizard, handleWizardHeadless };