@aifabrix/builder 2.33.5 → 2.36.0

package/lib/commands/wizard.js

@@ -13,14 +13,17 @@ const {
   promptForOpenApiFile,
   promptForOpenApiUrl,
   promptForMcpServer,
+  promptForCredentialAction,
   promptForKnownPlatform,
   promptForUserIntent,
   promptForUserPreferences,
   promptForConfigReview,
-  promptForAppName
+  promptForAppName,
+  promptForRunWithSavedConfig
 } = require('../generator/wizard-prompts');
 const {
   validateAndCheckAppDirectory,
+  formatDataplaneRejectedTokenMessage,
   handleOpenApiParsing,
   handleCredentialSelection,
   handleTypeDetection,
@@ -30,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
@@ -52,29 +65,29 @@ 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
- * @returns {Promise<Object>} Object with mode and sessionId
+ * @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<string>} Session ID
  */
-async function handleInteractiveModeSelection(dataplaneUrl, authConfig) {
-  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 ||
                      (sessionResponse.status ? `HTTP ${sessionResponse.status}` : 'Unknown error');
-    throw new Error(`Failed to create wizard session: ${errorMsg}`);
+    const apiMessage = sessionResponse.errorData?.message || sessionResponse.errorData?.detail || sessionResponse.error || '';
+    const fullMsg = sessionResponse.status === 401
+      ? formatDataplaneRejectedTokenMessage(dataplaneUrl, appName, apiMessage)
+      : `Failed to create wizard session: ${errorMsg}`;
+    throw new Error(fullMsg);
   }
-  const sessionId = extractSessionId(sessionResponse.data);
-  return { mode, sessionId, systemIdOrKey };
+  return extractSessionId(sessionResponse.data);
 }
 
 /**
@@ -84,11 +97,12 @@ async function handleInteractiveModeSelection(dataplaneUrl, authConfig) {
  * @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 };
 
@@ -102,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);
@@ -125,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'));
@@ -139,7 +153,7 @@ async function handleInteractiveConfigGeneration(options) {
     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,
@@ -147,6 +161,11 @@ async function handleInteractiveConfigGeneration(options) {
     credentialIdOrKey: options.credentialIdOrKey,
     systemIdOrKey: options.systemIdOrKey
   });
+
+  return {
+    ...result,
+    preferences: buildPreferencesForSave(userIntent, preferences)
+  };
 }
 
 /**
@@ -177,32 +196,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);
-
-  // 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,
@@ -211,60 +235,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/datasource/list.js

@@ -1,8 +1,8 @@
 /**
  * Datasource List Command
  *
- * Lists datasources from an environment via dataplane API.
- * Gets dataplane URL from controller, then lists datasources from dataplane.
+ * Lists datasources from the dataplane (GET /api/v1/external/).
+ * Resolves dataplane URL from the controller, then calls the dataplane list API.
  *
  * @fileoverview Datasource listing for AI Fabrix Builder
  * @author AI Fabrix Team
@@ -12,7 +12,7 @@
 const chalk = require('chalk');
 const { getConfig, resolveEnvironment } = require('../core/config');
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
-const { listDatasources: listDatasourcesFromDataplane } = require('../api/datasources-core.api');
+const { listDatasources: listDatasourcesFromDataplane } = require('../api/datasources.api');
 const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
 const { formatApiError } = require('../utils/api-error-handler');
 const logger = require('../utils/logger');
@@ -291,8 +291,11 @@ async function listDatasources(_options) {
 
   const controllerUrl = validateControllerUrl(authInfo.controllerUrl);
   const authConfig = setupAuthConfig(authInfo.token, controllerUrl);
+
+  // Resolve dataplane URL first (required for list call)
   const dataplaneUrl = await resolveAndValidateDataplaneUrl(controllerUrl, environment, authConfig);
 
+  // List datasources from dataplane (GET /api/v1/external/)
   const response = await listDatasourcesFromDataplane(dataplaneUrl, authConfig);
 
   if (!response.success || !response.data) {

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,