@aifabrix/builder 2.32.2 → 2.33.0

package/lib/api/wizard.api.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Wizard API functions
+ * @fileoverview Wizard API functions for external system creation
  * @author AI Fabrix Team
  * @version 2.0.0
  */
@@ -8,59 +8,147 @@ const { ApiClient } = require('./index');
 const { uploadFile } = require('../utils/file-upload');
 
 /**
- * Select wizard mode
- * POST /api/v1/wizard/mode-selection
+ * Create wizard session
+ * POST /api/v1/wizard/sessions
  * @async
- * @function selectMode
+ * @function createWizardSession
  * @param {string} dataplaneUrl - Dataplane base URL
  * @param {Object} authConfig - Authentication configuration
  * @param {string} mode - Wizard mode ('create-system' | 'add-datasource')
- * @returns {Promise<Object>} Mode selection response
+ * @param {string} [systemIdOrKey] - Existing system ID or key (required when mode='add-datasource')
+ * @returns {Promise<Object>} Session creation response with sessionId
  * @throws {Error} If request fails
  */
-async function selectMode(dataplaneUrl, authConfig, mode) {
+async function createWizardSession(dataplaneUrl, authConfig, mode, systemIdOrKey = null) {
   const client = new ApiClient(dataplaneUrl, authConfig);
-  return await client.post('/api/v1/wizard/mode-selection', {
-    body: { mode }
+  const body = { mode };
+  if (systemIdOrKey) {
+    body.systemIdOrKey = systemIdOrKey;
+  }
+  return await client.post('/api/v1/wizard/sessions', {
+    body
   });
 }
 
 /**
- * Select wizard source
- * POST /api/v1/wizard/source-selection
+ * Get wizard session
+ * GET /api/v1/wizard/sessions/{sessionId}
  * @async
- * @function selectSource
+ * @function getWizardSession
  * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {string} sessionId - Session ID
  * @param {Object} authConfig - Authentication configuration
- * @param {string} sourceType - Source type ('openapi-file' | 'openapi-url' | 'mcp-server' | 'known-platform')
- * @param {string} [sourceData] - Source data (file path, URL, etc.)
- * @returns {Promise<Object>} Source selection response
+ * @returns {Promise<Object>} Session state response
  * @throws {Error} If request fails
  */
-async function selectSource(dataplaneUrl, authConfig, sourceType, sourceData) {
+async function getWizardSession(dataplaneUrl, sessionId, authConfig) {
   const client = new ApiClient(dataplaneUrl, authConfig);
-  return await client.post('/api/v1/wizard/source-selection', {
-    body: {
-      sourceType,
-      sourceData
-    }
+  return await client.get(`/api/v1/wizard/sessions/${sessionId}`);
+}
+
+/**
+ * Update wizard session
+ * PUT /api/v1/wizard/sessions/{sessionId}
+ * @async
+ * @function updateWizardSession
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {string} sessionId - Session ID
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} updateData - Session update data
+ * @param {number} [updateData.currentStep] - Current wizard step (0-6)
+ * @param {string} [updateData.credentialIdOrKey] - Selected credential ID or key
+ * @param {Object} [updateData.openapiSpec] - Parsed OpenAPI specification
+ * @param {string} [updateData.mcpServerUrl] - MCP server URL
+ * @param {Array} [updateData.detectedTypes] - Detected API types
+ * @param {string} [updateData.selectedType] - Selected API type
+ * @param {string} [updateData.intent] - User intent
+ * @param {string} [updateData.fieldOnboardingLevel] - Field onboarding level
+ * @param {boolean} [updateData.enableOpenAPIGeneration] - Enable OpenAPI generation
+ * @param {Object} [updateData.systemConfig] - Generated system configuration
+ * @param {Object} [updateData.datasourceConfig] - Generated datasource configuration
+ * @param {Object} [updateData.validationResults] - Validation results
+ * @returns {Promise<Object>} Updated session state response
+ * @throws {Error} If request fails
+ */
+async function updateWizardSession(dataplaneUrl, sessionId, authConfig, updateData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.put(`/api/v1/wizard/sessions/${sessionId}`, {
+    body: updateData
   });
 }
 
 /**
- * Parse OpenAPI file
+ * Delete wizard session
+ * DELETE /api/v1/wizard/sessions/{sessionId}
+ * @async
+ * @function deleteWizardSession
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {string} sessionId - Session ID
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Delete response
+ * @throws {Error} If request fails
+ */
+async function deleteWizardSession(dataplaneUrl, sessionId, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.delete(`/api/v1/wizard/sessions/${sessionId}`);
+}
+
+/**
+ * Get wizard session progress
+ * GET /api/v1/wizard/sessions/{sessionId}/progress
+ * @async
+ * @function getWizardProgress
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {string} sessionId - Session ID
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Session progress response
+ * @throws {Error} If request fails
+ */
+async function getWizardProgress(dataplaneUrl, sessionId, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/wizard/sessions/${sessionId}/progress`);
+}
+
+/**
+ * Parse OpenAPI file or URL
  * POST /api/v1/wizard/parse-openapi
  * @async
  * @function parseOpenApi
  * @param {string} dataplaneUrl - Dataplane base URL
  * @param {Object} authConfig - Authentication configuration
- * @param {string} openApiFilePath - Path to OpenAPI file
+ * @param {string} openApiFilePathOrUrl - Path to OpenAPI file or URL
+ * @param {boolean} [isUrl=false] - Whether the input is a URL
  * @returns {Promise<Object>} Parsed OpenAPI response
  * @throws {Error} If request fails
  */
-async function parseOpenApi(dataplaneUrl, authConfig, openApiFilePath) {
+async function parseOpenApi(dataplaneUrl, authConfig, openApiFilePathOrUrl, isUrl = false) {
+  if (isUrl) {
+    const client = new ApiClient(dataplaneUrl, authConfig);
+    return await client.post(`/api/v1/wizard/parse-openapi?url=${encodeURIComponent(openApiFilePathOrUrl)}`);
+  }
   const url = `${dataplaneUrl.replace(/\/$/, '')}/api/v1/wizard/parse-openapi`;
-  return await uploadFile(url, openApiFilePath, 'file', authConfig);
+  return await uploadFile(url, openApiFilePathOrUrl, 'file', authConfig);
+}
+
+/**
+ * Credential selection for wizard
+ * POST /api/v1/wizard/credential-selection
+ * @async
+ * @function credentialSelection
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} selectionData - Credential selection data
+ * @param {string} selectionData.action - Action type ('create' | 'select' | 'skip')
+ * @param {Object} [selectionData.credentialConfig] - Credential config (required when action='create')
+ * @param {string} [selectionData.credentialIdOrKey] - Credential ID or key (required when action='select')
+ * @returns {Promise<Object>} Credential selection response
+ * @throws {Error} If request fails
+ */
+async function credentialSelection(dataplaneUrl, authConfig, selectionData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/credential-selection', {
+    body: selectionData
+  });
 }
 
 /**
@@ -70,14 +158,14 @@ async function parseOpenApi(dataplaneUrl, authConfig, openApiFilePath) {
  * @function detectType
  * @param {string} dataplaneUrl - Dataplane base URL
  * @param {Object} authConfig - Authentication configuration
- * @param {Object} openApiSpec - OpenAPI specification object
+ * @param {Object} openapiSpec - OpenAPI specification object
  * @returns {Promise<Object>} Type detection response
  * @throws {Error} If request fails
  */
-async function detectType(dataplaneUrl, authConfig, openApiSpec) {
+async function detectType(dataplaneUrl, authConfig, openapiSpec) {
   const client = new ApiClient(dataplaneUrl, authConfig);
   return await client.post('/api/v1/wizard/detect-type', {
-    body: { openApiSpec }
+    body: { openapiSpec }
   });
 }
 
@@ -89,11 +177,18 @@ async function detectType(dataplaneUrl, authConfig, openApiSpec) {
  * @param {string} dataplaneUrl - Dataplane base URL
  * @param {Object} authConfig - Authentication configuration
  * @param {Object} config - Generation configuration
- * @param {string} config.mode - Wizard mode
- * @param {string} config.sourceType - Source type
- * @param {Object} [config.openApiSpec] - OpenAPI specification (if applicable)
- * @param {string} [config.userIntent] - User intent (e.g., 'sales-focused', 'support-focused')
- * @param {Object} [config.preferences] - User preferences
+ * @param {Object} config.openapiSpec - OpenAPI specification object (required)
+ * @param {string} config.detectedType - Detected API type (required, e.g., 'record-based')
+ * @param {string} config.intent - User intent (required, any descriptive text)
+ * @param {string} config.mode - Wizard mode (required, 'create-system' | 'add-datasource')
+ * @param {string} [config.systemIdOrKey] - Existing system ID/key (required for add-datasource)
+ * @param {string} [config.credentialIdOrKey] - Credential ID or key
+ * @param {string} [config.fieldOnboardingLevel] - Field onboarding level ('full' | 'standard' | 'minimal')
+ * @param {boolean} [config.enableOpenAPIGeneration] - Enable OpenAPI operation generation
+ * @param {Object} [config.userPreferences] - User preferences
+ * @param {boolean} [config.userPreferences.enableMCP] - Enable MCP
+ * @param {boolean} [config.userPreferences.enableABAC] - Enable ABAC
+ * @param {boolean} [config.userPreferences.enableRBAC] - Enable RBAC
  * @returns {Promise<Object>} Generated configuration response
  * @throws {Error} If request fails
  */
@@ -104,6 +199,24 @@ async function generateConfig(dataplaneUrl, authConfig, config) {
   });
 }
 
+/**
+ * Generate configuration via AI (streaming)
+ * POST /api/v1/wizard/generate-config-stream
+ * @async
+ * @function generateConfigStream
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} config - Generation configuration payload
+ * @returns {Promise<Object>} Streaming generation response
+ * @throws {Error} If request fails
+ */
+async function generateConfigStream(dataplaneUrl, authConfig, config) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/generate-config-stream', {
+    body: config
+  });
+}
+
 /**
  * Validate wizard configuration
  * POST /api/v1/wizard/validate
@@ -112,20 +225,69 @@ async function generateConfig(dataplaneUrl, authConfig, config) {
  * @param {string} dataplaneUrl - Dataplane base URL
  * @param {Object} authConfig - Authentication configuration
  * @param {Object} systemConfig - System configuration to validate
- * @param {Object[]} datasourceConfigs - Array of datasource configurations to validate
+ * @param {Object|Object[]} datasourceConfig - Datasource configuration(s) to validate
  * @returns {Promise<Object>} Validation response
  * @throws {Error} If request fails
  */
-async function validateWizardConfig(dataplaneUrl, authConfig, systemConfig, datasourceConfigs) {
+async function validateWizardConfig(dataplaneUrl, authConfig, systemConfig, datasourceConfig) {
   const client = new ApiClient(dataplaneUrl, authConfig);
   return await client.post('/api/v1/wizard/validate', {
     body: {
       systemConfig,
-      datasourceConfigs
+      datasourceConfig
     }
   });
 }
 
+/**
+ * Validate all completed wizard steps
+ * GET /api/v1/wizard/sessions/{sessionId}/validate
+ * @async
+ * @function validateAllSteps
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {string} sessionId - Session ID
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Validation response for all steps
+ * @throws {Error} If request fails
+ */
+async function validateAllSteps(dataplaneUrl, sessionId, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/wizard/sessions/${sessionId}/validate`);
+}
+
+/**
+ * Validate specific wizard step
+ * POST /api/v1/wizard/sessions/{sessionId}/validate-step
+ * @async
+ * @function validateStep
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {string} sessionId - Session ID
+ * @param {Object} authConfig - Authentication configuration
+ * @param {number} stepNumber - Step number to validate (1-7)
+ * @returns {Promise<Object>} Validation response for the step
+ * @throws {Error} If request fails
+ */
+async function validateStep(dataplaneUrl, sessionId, authConfig, stepNumber) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post(`/api/v1/wizard/sessions/${sessionId}/validate-step?step=${stepNumber}`);
+}
+
+/**
+ * Get configuration preview with summaries
+ * GET /api/v1/wizard/preview/{sessionId}
+ * @async
+ * @function getPreview
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {string} sessionId - Session ID
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Preview response with system and datasource summaries
+ * @throws {Error} If request fails
+ */
+async function getPreview(dataplaneUrl, sessionId, authConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/wizard/preview/${sessionId}`);
+}
+
 /**
  * Test MCP server connection
  * POST /api/v1/wizard/test-mcp-connection
@@ -165,13 +327,20 @@ async function getDeploymentDocs(dataplaneUrl, authConfig, systemKey) {
 }
 
 module.exports = {
-  selectMode,
-  selectSource,
+  createWizardSession,
+  getWizardSession,
+  updateWizardSession,
+  deleteWizardSession,
+  getWizardProgress,
   parseOpenApi,
+  credentialSelection,
   detectType,
   generateConfig,
+  generateConfigStream,
   validateWizardConfig,
+  validateAllSteps,
+  validateStep,
+  getPreview,
   testMcpConnection,
   getDeploymentDocs
 };
-

package/lib/app/deploy.js

@@ -18,6 +18,8 @@ const logger = require('../utils/logger');
 const config = require('../core/config');
 const { getDeploymentAuth } = require('../utils/token-manager');
 const { detectAppType } = require('../utils/paths');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { checkApplicationExists } = require('../utils/app-existence');
 
 /**
  * Validate application name format
@@ -178,15 +180,26 @@ async function loadVariablesFile(variablesPath) {
 }
 
 /**
- * Extracts deployment configuration from options and variables
- * @param {Object} options - CLI options
- * @param {Object} variables - Variables from variables.yaml
- * @returns {Object} Extracted configuration
+ * Extracts deployment configuration from config.yaml
+ * Resolves controller URL using fallback chain: config.controller → logged-in user → developer ID default
+ * Resolves environment using fallback chain: config.environment → default 'dev'
+ * @async
+ * @param {Object} options - CLI options (for poll settings only)
+ * @param {Object} _variables - Variables from variables.yaml (unused, kept for compatibility)
+ * @returns {Promise<Object>} Extracted configuration with resolved controller URL
  */
-function extractDeploymentConfig(options, variables) {
+async function extractDeploymentConfig(options, _variables) {
+  const { resolveEnvironment } = require('../core/config');
+
+  // Resolve controller URL from config.yaml (no flags, no options)
+  const controllerUrl = await resolveControllerUrl();
+
+  // Resolve environment from config.yaml (no flags, no options)
+  const envKey = await resolveEnvironment();
+
   return {
-    controllerUrl: options.controller || variables.deployment?.controllerUrl,
-    envKey: options.environment || variables.deployment?.environment,
+    controllerUrl,
+    envKey,
     poll: options.poll !== false,
     pollInterval: options.pollInterval || 5000,
     pollMaxAttempts: options.pollMaxAttempts || 60
@@ -200,7 +213,7 @@ function extractDeploymentConfig(options, variables) {
  */
 function validateDeploymentConfig(deploymentConfig) {
   if (!deploymentConfig.controllerUrl) {
-    throw new Error('Controller URL is required. Set it in variables.yaml or use --controller flag');
+    throw new Error('Controller URL is required. Run "aifabrix login" to set the controller URL in config.yaml');
   }
   if (!deploymentConfig.auth) {
     throw new Error('Authentication is required. Run "aifabrix login" first or ensure credentials are in secrets.local.yaml');
@@ -208,19 +221,15 @@ function validateDeploymentConfig(deploymentConfig) {
 }
 
 /**
- * Configure deployment environment settings
+ * Configure deployment environment settings from config.yaml
  * @async
- * @param {Object} options - CLI options
+ * @param {Object} _options - CLI options (unused, kept for compatibility)
  * @param {Object} deploymentConfig - Deployment configuration to update
  * @returns {Promise<void>}
  */
-async function configureDeploymentEnvironment(options, deploymentConfig) {
-  // Update root-level environment if provided
-  if (options.environment) {
-    await config.setCurrentEnvironment(options.environment);
-  }
-
-  // Get current environment from root-level config
+async function configureDeploymentEnvironment(_options, deploymentConfig) {
+  // Get current environment from root-level config (already resolved in extractDeploymentConfig)
+  // This function is kept for compatibility but no longer updates environment from options
   const currentEnvironment = await config.getCurrentEnvironment();
   deploymentConfig.envKey = deploymentConfig.envKey || currentEnvironment;
 }
@@ -234,9 +243,9 @@ async function configureDeploymentEnvironment(options, deploymentConfig) {
  * @throws {Error} If authentication fails
  */
 async function refreshDeploymentToken(appName, deploymentConfig) {
-  // Get controller URL
+  // Get controller URL (should already be resolved by extractDeploymentConfig)
   if (!deploymentConfig.controllerUrl) {
-    throw new Error('Controller URL is required. Set it in variables.yaml or use --controller flag');
+    throw new Error('Controller URL is required. Run "aifabrix login" to set the controller URL in config.yaml');
   }
 
   // Get deployment authentication (device token → client token → credentials)
@@ -275,7 +284,7 @@ async function loadDeploymentConfig(appName, options) {
   const variablesPath = path.join(appPath, 'variables.yaml');
   const variables = await loadVariablesFile(variablesPath);
 
-  const deploymentConfig = extractDeploymentConfig(options, variables);
+  const deploymentConfig = await extractDeploymentConfig(options, variables);
 
   await configureDeploymentEnvironment(options, deploymentConfig);
   await refreshDeploymentToken(appName, deploymentConfig);
@@ -360,6 +369,80 @@ function displayDeploymentResults(result) {
   }
 }
 
+/**
+ * Check if app is external and handle external deployment
+ * @async
+ * @function handleExternalDeployment
+ * @param {string} appName - Application name
+ * @param {Object} options - Deployment options
+ * @returns {Promise<Object|null>} Deployment result if external, null otherwise
+ */
+async function handleExternalDeployment(appName, options) {
+  const { isExternal } = await detectAppType(appName);
+  if (isExternal) {
+    const externalDeploy = require('../external-system/deploy');
+    await externalDeploy.deployExternalSystem(appName, options);
+    return { success: true, type: 'external' };
+  }
+  return null;
+}
+
+/**
+ * Handle deployment errors
+ * @async
+ * @function handleDeploymentError
+ * @param {Error} error - Error that occurred
+ * @param {string} appName - Application name
+ * @param {string} controllerUrl - Controller URL (from config, or null if not yet resolved)
+ * @param {boolean} usedExternalDeploy - Whether external deployment was used
+ */
+async function handleDeploymentError(error, appName, controllerUrl, usedExternalDeploy) {
+  if (usedExternalDeploy) {
+    throw error;
+  }
+  const alreadyLogged = error._logged === true;
+  const url = controllerUrl || 'unknown';
+  const deployer = require('../deployment/deployer');
+  await deployer.handleDeploymentErrors(error, appName, url, alreadyLogged);
+}
+
+/**
+ * Execute standard application deployment flow
+ * @async
+ * @function executeStandardDeployment
+ * @param {string} appName - Application name
+ * @param {Object} options - Deployment options
+ * @returns {Promise<Object>} Deployment result
+ */
+async function executeStandardDeployment(appName, options) {
+  const config = await loadDeploymentConfig(appName, options);
+  const controllerUrl = config.controllerUrl || 'unknown';
+
+  // Check if application exists before deployment
+  const appExists = await checkApplicationExists(appName, controllerUrl, config.envKey, config.auth);
+
+  const { manifest, manifestPath } = await generateAndValidateManifest(appName);
+  displayDeploymentInfo(manifest, manifestPath);
+
+  try {
+    const result = await executeDeployment(manifest, config);
+    displayDeploymentResults(result);
+    return { result, controllerUrl, appExists };
+  } catch (error) {
+    // Enhance error if app exists and credentials are invalid
+    if (appExists && error.status === 401 && !error.message.includes('rotate-secret')) {
+      const enhancedError = new Error(
+        `${error.message}\n\n💡 The application '${appName}' exists in environment '${config.envKey}'. ` +
+        `To fix invalid credentials, rotate the application secret:\n   aifabrix app rotate-secret ${appName}`
+      );
+      enhancedError.status = 401;
+      enhancedError.formatted = error.formatted || enhancedError.message;
+      throw enhancedError;
+    }
+    throw error;
+  }
+}
+
 /**
  * Deploys application to Miso Controller
  * Orchestrates manifest generation, key creation, and deployment
@@ -368,59 +451,38 @@ function displayDeploymentResults(result) {
  * @function deployApp
  * @param {string} appName - Name of the application to deploy
  * @param {Object} options - Deployment options
- * @param {string} options.controller - Controller URL (required)
- * @param {string} [options.environment] - Target environment (miso/dev/tst/pro)
  * @param {boolean} [options.poll] - Poll for deployment status
  * @param {number} [options.pollInterval] - Polling interval in milliseconds
+ * @param {number} [options.pollMaxAttempts] - Max polling attempts
  * @returns {Promise<Object>} Deployment result
  * @throws {Error} If deployment fails
  *
+ * Controller and environment come from config.yaml (set via aifabrix login or aifabrix auth config).
+ *
  * @example
- * await deployApp('myapp', { controller: 'https://controller.aifabrix.ai', environment: 'dev' });
+ * await deployApp('myapp', { poll: true });
  */
 async function deployApp(appName, options = {}) {
   let controllerUrl = null;
-  let config = null;
+  let usedExternalDeploy = false;
 
   try {
-    // 1. Input validation
     if (!appName || typeof appName !== 'string' || appName.trim().length === 0) {
       throw new Error('App name is required');
     }
-
     validateAppName(appName);
 
-    // 2. Check if app type is external - use normal deployment flow with application-schema.json
-    // External systems now deploy via miso controller as normal application (full application file)
-    // The json command generates application-schema.json which is used for deployment
-
-    // 2. Load deployment configuration
-    config = await loadDeploymentConfig(appName, options);
-    controllerUrl = config.controllerUrl || options.controller || 'unknown';
-
-    // 3. Generate and validate manifest
-    const { manifest, manifestPath } = await generateAndValidateManifest(appName);
-
-    // 4. Display deployment info
-    displayDeploymentInfo(manifest, manifestPath);
-
-    // 5. Execute deployment
-    const result = await executeDeployment(manifest, config);
-
-    // 6. Display results
-    displayDeploymentResults(result);
+    const externalResult = await handleExternalDeployment(appName, options);
+    if (externalResult) {
+      return externalResult;
+    }
+    usedExternalDeploy = false;
 
+    const { result, controllerUrl: url } = await executeStandardDeployment(appName, options);
+    controllerUrl = url;
     return result;
-
   } catch (error) {
-    // Use unified error handler from deployer
-    // Check if error was already logged (from deployer.js)
-    const alreadyLogged = error._logged === true;
-    const url = controllerUrl || options.controller || 'unknown';
-
-    const deployer = require('../deployment/deployer');
-    // handleDeploymentErrors will log, format, and throw the error
-    await deployer.handleDeploymentErrors(error, appName, url, alreadyLogged);
+    await handleDeploymentError(error, appName, controllerUrl, usedExternalDeploy);
   }
 }
 

package/lib/app/display.js

@@ -25,9 +25,9 @@ function displayExternalSystemSuccess(appName, config, location) {
   logger.log(chalk.blue(`System Key: ${config.systemKey || appName}`));
   logger.log(chalk.green('\nNext steps:'));
   logger.log(chalk.white('1. Edit external system JSON files in ' + location));
-  logger.log(chalk.white('2. Run: aifabrix app register ' + appName + ' --environment dev'));
-  logger.log(chalk.white('3. Run: aifabrix build ' + appName + ' (deploys to dataplane)'));
-  logger.log(chalk.white('4. Run: aifabrix deploy ' + appName + ' (publishes to dataplane)'));
+  logger.log(chalk.white('2. Run: aifabrix validate ' + appName + ' --type external'));
+  logger.log(chalk.white('3. Run: aifabrix login'));
+  logger.log(chalk.white('4. Run: aifabrix deploy ' + appName));
 }
 
 /**
@@ -50,8 +50,9 @@ function displayWebappSuccess(appName, config, envConversionMessage) {
 
   logger.log(chalk.green('\nNext steps:'));
   logger.log(chalk.white('1. Copy env.template to .env and fill in your values'));
-  logger.log(chalk.white('2. Run: aifabrix build ' + appName));
-  logger.log(chalk.white('3. Run: aifabrix run ' + appName));
+  logger.log(chalk.white('2. Run: aifabrix up'));
+  logger.log(chalk.white('3. Run: aifabrix build ' + appName));
+  logger.log(chalk.white('4. Run: aifabrix run ' + appName));
 }
 
 /**

package/lib/app/dockerfile.js

@@ -15,6 +15,7 @@ const yaml = require('js-yaml');
 const build = require('../build');
 const { validateAppName } = require('./push');
 const logger = require('../utils/logger');
+const { getContainerPort } = require('../utils/port-resolver');
 
 /**
  * Checks if Dockerfile exists and validates overwrite permission
@@ -52,7 +53,7 @@ async function loadAppConfig(configPath, options) {
     const variables = yaml.load(yamlContent);
     return {
       language: options.language || variables.build?.language || 'typescript',
-      port: variables.build?.port || variables.port || 3000,
+      port: getContainerPort(variables, 3000),
       ...variables
     };
   } catch {