@aifabrix/builder 2.39.2 → 2.40.0

package/lib/app/deploy-config.js

@@ -8,11 +8,10 @@
  */
 
 const fs = require('fs').promises;
-const path = require('path');
-const yaml = require('js-yaml');
 const config = require('../core/config');
 const { getDeploymentAuth } = require('../utils/token-manager');
-const { detectAppType } = require('../utils/paths');
+const { detectAppType, resolveApplicationConfigPath } = require('../utils/paths');
+const { loadConfigFile } = require('../utils/config-format');
 const { resolveControllerUrl } = require('../utils/controller-url');
 
 /**
@@ -34,18 +33,17 @@ async function validateAppDirectory(builderPath, appName) {
 }
 
 /**
- * Loads variables.yaml file
- * @async
- * @param {string} variablesPath - Path to variables.yaml
- * @returns {Promise<Object>} Variables object
+ * Loads application config (application.yaml or application.json) via resolver + converter.
+ * @param {string} appPath - Path to application directory
+ * @returns {Object} Variables object
  * @throws {Error} If file cannot be loaded
  */
-async function loadVariablesFile(variablesPath) {
+function loadVariablesFile(appPath) {
   try {
-    const variablesContent = await fs.readFile(variablesPath, 'utf8');
-    return yaml.load(variablesContent);
+    const configPath = resolveApplicationConfigPath(appPath);
+    return loadConfigFile(configPath);
   } catch (error) {
-    throw new Error(`Failed to load configuration from variables.yaml: ${error.message}`);
+    throw new Error('Failed to load configuration: ' + error.message);
   }
 }
 
@@ -55,7 +53,7 @@ async function loadVariablesFile(variablesPath) {
  * 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)
+ * @param {Object} _variables - Variables from application config (unused, kept for compatibility)
  * @returns {Promise<Object>} Extracted configuration with resolved controller URL
  */
 async function extractDeploymentConfig(options, _variables) {
@@ -132,7 +130,7 @@ async function refreshDeploymentToken(appName, deploymentConfig) {
 }
 
 /**
- * Loads deployment configuration from variables.yaml and gets/refreshes token
+ * Loads deployment configuration from application.yaml and gets/refreshes token
  * @async
  * @param {string} appName - Application name
  * @param {Object} options - CLI options
@@ -143,8 +141,7 @@ async function loadDeploymentConfig(appName, options) {
   const { appPath } = await detectAppType(appName);
   await validateAppDirectory(appPath, appName);
 
-  const variablesPath = path.join(appPath, 'variables.yaml');
-  const variables = await loadVariablesFile(variablesPath);
+  const variables = loadVariablesFile(appPath);
 
   const deploymentConfig = await extractDeploymentConfig(options, variables);
 
@@ -153,7 +150,7 @@ async function loadDeploymentConfig(appName, options) {
 
   validateDeploymentConfig(deploymentConfig);
 
-  return deploymentConfig;
+  return { ...deploymentConfig, appPath };
 }
 
 module.exports = {

package/lib/app/deploy.js

@@ -10,14 +10,13 @@
  */
 
 const fs = require('fs').promises;
-const path = require('path');
-const yaml = require('js-yaml');
 const chalk = require('chalk');
 const pushUtils = require('../deployment/push');
 const logger = require('../utils/logger');
 const { detectAppType, getBuilderPath, getIntegrationPath } = require('../utils/paths');
 const { checkApplicationExists } = require('../utils/app-existence');
 const { loadDeploymentConfig } = require('./deploy-config');
+const { logOfflinePathWhenType } = require('../utils/cli-utils');
 const { displayAppUrlFromController } = require('./deploy-status-display');
 
 /**
@@ -116,17 +115,20 @@ async function pushApp(appName, options = {}) {
   try {
     validateAppName(appName);
 
-    const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+    const { getBuilderPath, resolveApplicationConfigPath } = require('../utils/paths');
+    const { loadConfigFile } = require('../utils/config-format');
+    const builderPath = getBuilderPath(appName);
     let config;
     try {
-      config = yaml.load(await fs.readFile(configPath, 'utf8'));
+      const configPath = resolveApplicationConfigPath(builderPath);
+      config = loadConfigFile(configPath);
     } catch (error) {
-      throw new Error(`Failed to load configuration: ${configPath}\nRun 'aifabrix create ${appName}' first`);
+      throw new Error(`Failed to load configuration: ${error.message}\nRun 'aifabrix create ${appName}' first`);
     }
 
     const registry = options.registry || config.image?.registry;
     if (!registry) {
-      throw new Error('Registry URL is required. Provide via --registry flag or configure in variables.yaml under image.registry');
+      throw new Error('Registry URL is required. Provide via --registry flag or configure in application.yaml under image.registry');
     }
 
     if (!/^[^.]+\.azurecr\.io$/.test(registry)) {
@@ -148,15 +150,16 @@ async function pushApp(appName, options = {}) {
  * Generates and validates deployment manifest
  * @async
  * @param {string} appName - Application name
+ * @param {Object} [options] - Deployment options (type: 'app' | 'external' for path resolution)
  * @returns {Promise<Object>} Deployment manifest
  * @throws {Error} If generation or validation fails
  */
-async function generateAndValidateManifest(appName) {
+async function generateAndValidateManifest(appName, options = {}) {
   logger.log(chalk.blue(`\n📋 Generating deployment manifest for ${appName}...`));
   const generator = require('../generator');
 
   // generateDeployJson already validates against schema and throws on error
-  const manifestPath = await generator.generateDeployJson(appName);
+  const manifestPath = await generator.generateDeployJson(appName, options);
   const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
 
   // Additional validation for warnings (schema validation already passed)
@@ -220,16 +223,16 @@ function displayDeploymentResults(result) {
 }
 
 /**
- * Check if app is external and handle external deployment.
- * When options.type === 'external', forces deployment from integration/<app> (no app register needed).
+ * Check if app is external (resolved from integration/) and handle external deployment.
+ * Path resolution order: integration first, then builder; no flag overrides.
  * @async
  * @function handleExternalDeployment
  * @param {string} appName - Application name
- * @param {Object} options - Deployment options (type: 'external' to force integration/<app>)
+ * @param {Object} options - Deployment options (poll, etc.)
  * @returns {Promise<Object|null>} Deployment result if external, null otherwise
  */
 async function handleExternalDeployment(appName, options) {
-  const { isExternal } = await detectAppType(appName, options);
+  const { isExternal } = await detectAppType(appName);
   if (isExternal) {
     const externalDeploy = require('../external-system/deploy');
     await externalDeploy.deployExternalSystem(appName, options);
@@ -266,7 +269,7 @@ async function handleDeploymentError(error, appName, controllerUrl, usedExternal
  */
 function validateImageIsPullable(imageRef, appName) {
   if (!imageRef || !imageRef.includes('/')) {
-    const hint = `Set image.registry and image.tag in builder/${appName}/variables.yaml, or pass a full image ref (e.g. --image <registry>/${appName}:<tag>) when deploying`;
+    const hint = `Set image.registry and image.tag in builder/${appName}/application.yaml, or pass a full image ref (e.g. --image <registry>/${appName}:<tag>) when deploying`;
     throw new Error(
       `Deployed image must be pullable (include a registry). Current image: "${imageRef || 'none'}". ${hint}`
     );
@@ -336,10 +339,11 @@ function applyManifestOverrides(manifest, options) {
  */
 async function executeStandardDeployment(appName, options) {
   const config = await loadDeploymentConfig(appName, options);
+  logOfflinePathWhenType(config.appPath, options);
   const controllerUrl = config.controllerUrl || 'unknown';
   const appExists = await checkApplicationExists(appName, controllerUrl, config.envKey, config.auth);
 
-  const { manifest, manifestPath } = await generateAndValidateManifest(appName);
+  const { manifest, manifestPath } = await generateAndValidateManifest(appName, options);
   applyManifestOverrides(manifest, options);
   validateImageIsPullable(manifest.image, appName);
   displayDeploymentInfo(manifest, manifestPath);
@@ -388,7 +392,7 @@ async function tryExternalDeployFallback(appName, options) {
     if (e.code !== 'ENOENT') throw e;
   }
   if (!builderExists && integrationExists) {
-    const fallbackResult = await handleExternalDeployment(appName, { ...options, type: 'external' });
+    const fallbackResult = await handleExternalDeployment(appName, options);
     if (fallbackResult) return { usedExternalDeploy: true, result: fallbackResult };
   }
   return { usedExternalDeploy: false, result: null };
@@ -402,20 +406,21 @@ async function tryExternalDeployFallback(appName, options) {
  * @function deployApp
  * @param {string} appName - Name of the application to deploy
  * @param {Object} options - Deployment options
+ * @param {boolean} [options.local] - If true, caller may run app locally or restart dataplane (for external)
  * @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
+ * @returns {Promise<{ result: Object, usedExternalDeploy: boolean }>} Deployment result and whether external deploy was used
  * @throws {Error} If deployment fails
  *
  * Controller and environment come from config.yaml (set via aifabrix login or aifabrix auth config).
  *
  * @example
- * await deployApp('myapp', { poll: true });
+ * const { result, usedExternalDeploy } = await deployApp('myapp', { poll: true });
  */
 async function deployApp(appName, options = {}) {
   let controllerUrl = null;
-  let usedExternalDeploy = options.type === 'external';
+  let usedExternalDeploy = false;
 
   try {
     if (!appName || typeof appName !== 'string' || appName.trim().length === 0) {
@@ -424,18 +429,20 @@ async function deployApp(appName, options = {}) {
     validateAppName(appName);
 
     const externalResult = await handleExternalDeployment(appName, options);
-    if (externalResult) return externalResult;
+    if (externalResult) {
+      usedExternalDeploy = true;
+      return { result: externalResult, usedExternalDeploy: true };
+    }
 
     const fallback = await tryExternalDeployFallback(appName, options);
     if (fallback.result) {
       usedExternalDeploy = fallback.usedExternalDeploy;
-      return fallback.result;
+      return { result: fallback.result, usedExternalDeploy };
     }
-    usedExternalDeploy = false;
 
     const { result, controllerUrl: url } = await executeStandardDeployment(appName, options);
     controllerUrl = url;
-    return result;
+    return { result, usedExternalDeploy: false };
   } catch (error) {
     await handleDeploymentError(error, appName, controllerUrl, usedExternalDeploy);
   }

package/lib/app/display.js

@@ -25,7 +25,7 @@ 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 validate ' + appName + ' --type external'));
+  logger.log(chalk.white('2. Run: aifabrix validate ' + appName));
   logger.log(chalk.white('3. Run: aifabrix login'));
   logger.log(chalk.white('4. Run: aifabrix deploy ' + appName));
 }

package/lib/app/dockerfile.js

@@ -11,7 +11,6 @@
 const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
-const yaml = require('js-yaml');
 const build = require('../build');
 const { validateAppName } = require('./push');
 const logger = require('../utils/logger');
@@ -40,24 +39,25 @@ async function checkDockerfileExists(dockerfilePath, options) {
 }
 
 /**
- * Loads application configuration from variables.yaml
- * @async
- * @param {string} configPath - Path to variables.yaml
+ * Loads application configuration from application config (application.yaml or application.json)
+ * @param {string} appPath - Application directory path
  * @param {Object} options - Generation options
- * @returns {Promise<Object>} Application configuration
+ * @returns {Object} Application configuration
  * @throws {Error} If configuration cannot be loaded
  */
-async function loadAppConfig(configPath, options) {
+function loadAppConfig(appPath, options) {
+  const { resolveApplicationConfigPath } = require('../utils/paths');
+  const { loadConfigFile } = require('../utils/config-format');
   try {
-    const yamlContent = await fs.readFile(configPath, 'utf8');
-    const variables = yaml.load(yamlContent);
+    const configPath = resolveApplicationConfigPath(appPath);
+    const variables = loadConfigFile(configPath);
     return {
       language: options.language || variables.build?.language || 'typescript',
       port: getContainerPort(variables, 3000),
       ...variables
     };
-  } catch {
-    throw new Error(`Failed to load configuration from ${configPath}`);
+  } catch (error) {
+    throw new Error(`Failed to load configuration: ${error.message}`);
   }
 }
 
@@ -109,8 +109,7 @@ async function generateDockerfileForApp(appName, options = {}) {
     await checkDockerfileExists(dockerfilePath, options);
 
     // Load configuration
-    const configPath = path.join(appPath, 'variables.yaml');
-    const config = await loadAppConfig(configPath, options);
+    const config = loadAppConfig(appPath, options);
 
     // Generate and copy Dockerfile
     return await generateAndCopyDockerfile(appPath, dockerfilePath, config);

package/lib/app/helpers.js

@@ -13,6 +13,40 @@ const path = require('path');
 const chalk = require('chalk');
 const { validateTemplate, copyTemplateFiles, copyAppFiles } = require('../validation/template');
 const logger = require('../utils/logger');
+const { getIntegrationPath, getBuilderPath } = require('../utils/paths');
+
+/**
+ * Validates that no app or external system with this name exists in integration/ or builder/.
+ * Call before create so we do not overwrite existing directories.
+ *
+ * @async
+ * @param {string} appName - Application or external system name
+ * @throws {Error} If integration/<appName> or builder/<appName> already exists
+ */
+async function validateAppOrExternalNameNotExists(appName) {
+  const integrationPath = getIntegrationPath(appName);
+  const builderPath = getBuilderPath(appName);
+  try {
+    await fs.access(integrationPath);
+    throw new Error(
+      `App or external system '${appName}' already exists in integration/. ` +
+      `Use a different name or remove integration/${appName} if you intend to replace it.`
+    );
+  } catch (err) {
+    if (err.code !== 'ENOENT' && err.message.includes('already exists')) throw err;
+    if (err.code !== 'ENOENT') throw err;
+  }
+  try {
+    await fs.access(builderPath);
+    throw new Error(
+      `App or external system '${appName}' already exists in builder/. ` +
+      `Use a different name or remove builder/${appName} if you intend to replace it.`
+    );
+  } catch (err) {
+    if (err.code !== 'ENOENT' && err.message.includes('already exists')) throw err;
+    if (err.code !== 'ENOENT') throw err;
+  }
+}
 
 /**
  * Validates that app directory doesn't already exist
@@ -87,6 +121,7 @@ async function handleGitHubWorkflows(options, config) {
 async function validateAppCreation(appName, options, appPath, baseDir = 'builder') {
   const { validateAppName } = require('./push');
   validateAppName(appName);
+  await validateAppOrExternalNameNotExists(appName);
   await validateAppDirectoryNotExists(appPath, appName, baseDir);
 
   if (!options.app) {
@@ -128,7 +163,7 @@ async function processTemplateFiles(template, appPath, appName, options, config)
 }
 
 /**
- * Updates variables.yaml for --app flag
+ * Updates application config for --app flag
  * @async
  * @function updateVariablesForAppFlag
  * @param {string} appPath - Application directory path
@@ -136,11 +171,11 @@ async function processTemplateFiles(template, appPath, appName, options, config)
  * @throws {Error} If update fails
  */
 async function updateVariablesForAppFlag(appPath, appName) {
+  const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+  const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
   try {
-    const yaml = require('js-yaml');
-    const variablesPath = path.join(appPath, 'variables.yaml');
-    const variablesContent = await fs.readFile(variablesPath, 'utf8');
-    const variables = yaml.load(variablesContent);
+    const variablesPath = resolveApplicationConfigPath(appPath);
+    const variables = loadConfigFile(variablesPath) || {};
 
     if (variables.build) {
       variables.build.context = '../..';
@@ -152,14 +187,16 @@ async function updateVariablesForAppFlag(appPath, appName) {
       };
     }
 
-    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }));
+    writeConfigFile(variablesPath, variables);
   } catch (error) {
-    logger.warn(chalk.yellow(`⚠️  Warning: Could not update variables.yaml: ${error.message}`));
+    if (!error.message.includes('not found')) {
+      logger.warn(chalk.yellow(`⚠️  Warning: Could not update application config: ${error.message}`));
+    }
   }
 }
 
 /**
- * Gets language from config or variables.yaml
+ * Gets language from config or application.yaml
  * @async
  * @function getLanguageForAppFiles
  * @param {string} language - Language from config
@@ -172,14 +209,14 @@ async function getLanguageForAppFiles(language, appPath) {
     return language;
   }
 
-  const yaml = require('js-yaml');
-  const variablesPath = path.join(appPath, 'variables.yaml');
-  const variablesContent = await fs.readFile(variablesPath, 'utf8');
-  const variables = yaml.load(variablesContent);
+  const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+  const { loadConfigFile } = require('../utils/config-format');
+  const configPath = resolveApplicationConfigPath(appPath);
+  const variables = loadConfigFile(configPath) || {};
   const languageFromYaml = variables?.build?.language;
 
   if (!languageFromYaml) {
-    throw new Error('Language not specified and could not be determined from variables.yaml. Use --language flag or ensure variables.yaml contains build.language');
+    throw new Error('Language not specified and could not be determined from application.yaml. Use --language flag or ensure application.yaml contains build.language');
   }
 
   return languageFromYaml;
@@ -207,6 +244,7 @@ async function setupAppFiles(appName, appPath, config, options) {
 
 module.exports = {
   validateAppDirectoryNotExists,
+  validateAppOrExternalNameNotExists,
   getBaseDirForAppType,
   handleGitHubWorkflows,
   validateAppCreation,

package/lib/app/index.js

@@ -52,7 +52,7 @@ const {
  *
  * @example
  * await createApp('myapp', { port: 3000, database: true, language: 'typescript' });
- * // Creates builder/ with variables.yaml, env.template, rbac.yaml
+ * // Creates builder/ with application.yaml, env.template, rbac.yaml
  */
 /**
  * Validates app name and initial setup
@@ -230,7 +230,7 @@ function detectLanguage(appPath) {
  * @function generateDockerfile
  * @param {string} appPath - Path to application directory
  * @param {string} language - Target language ('typescript', 'python')
- * @param {Object} config - Application configuration from variables.yaml
+ * @param {Object} config - Application configuration from application.yaml
  * @returns {Promise<string>} Path to generated Dockerfile
  * @throws {Error} If template generation fails
  *
@@ -263,6 +263,17 @@ async function runApp(appName, options = {}) {
   return appRun.runApp(appName, options);
 }
 
+/**
+ * Restart a running application container (Docker restart).
+ * @async
+ * @function restartApp
+ * @param {string} appName - Application name (must be running)
+ * @returns {Promise<void>} Resolves when container is restarted
+ */
+async function restartApp(appName) {
+  return appRun.restartApp(appName);
+}
+
 /**
  * Deploys application to controller
  * @async
@@ -280,6 +291,7 @@ module.exports = {
   createApp,
   buildApp,
   runApp,
+  restartApp,
   downApp,
   detectLanguage,
   generateDockerfile,

package/lib/app/prompts.js

@@ -112,16 +112,8 @@ function buildServiceQuestions(options, appType) {
   return questions;
 }
 
-/**
- * Builds external system configuration questions
- * @param {Object} options - Provided options
- * @param {string} appName - Application name
- * @returns {Array} Array of question objects
- */
-function buildExternalSystemQuestions(options, appName) {
+function buildExternalSystemIdentityQuestions(options, appName) {
   const questions = [];
-
-  // System key (defaults to app name)
   if (!options.systemKey) {
     questions.push({
       type: 'input',
@@ -129,18 +121,12 @@ function buildExternalSystemQuestions(options, appName) {
       message: 'What is the system key?',
       default: appName,
       validate: (input) => {
-        if (!input || input.trim().length === 0) {
-          return 'System key is required';
-        }
-        if (!/^[a-z0-9-]+$/.test(input)) {
-          return 'System key must contain only lowercase letters, numbers, and hyphens';
-        }
+        if (!input || input.trim().length === 0) return 'System key is required';
+        if (!/^[a-z0-9-]+$/.test(input)) return 'System key must contain only lowercase letters, numbers, and hyphens';
         return true;
       }
     });
   }
-
-  // System display name
   if (!options.systemDisplayName) {
     questions.push({
       type: 'input',
@@ -148,15 +134,11 @@ function buildExternalSystemQuestions(options, appName) {
       message: 'What is the system display name?',
       default: appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
       validate: (input) => {
-        if (!input || input.trim().length === 0) {
-          return 'System display name is required';
-        }
+        if (!input || input.trim().length === 0) return 'System display name is required';
         return true;
       }
     });
   }
-
-  // System description
   if (!options.systemDescription) {
     questions.push({
       type: 'input',
@@ -164,15 +146,16 @@ function buildExternalSystemQuestions(options, appName) {
       message: 'What is the system description?',
       default: `External system integration for ${appName}`,
       validate: (input) => {
-        if (!input || input.trim().length === 0) {
-          return 'System description is required';
-        }
+        if (!input || input.trim().length === 0) return 'System description is required';
         return true;
       }
     });
   }
+  return questions;
+}
 
-  // System type
+function buildExternalSystemTypeQuestions(options) {
+  const questions = [];
   if (!options.systemType) {
     questions.push({
       type: 'list',
@@ -186,8 +169,6 @@ function buildExternalSystemQuestions(options, appName) {
       default: 'openapi'
     });
   }
-
-  // Authentication type
   if (!options.authType) {
     questions.push({
       type: 'list',
@@ -201,25 +182,36 @@ function buildExternalSystemQuestions(options, appName) {
       default: 'apikey'
     });
   }
+  return questions;
+}
 
-  // Number of datasources
-  if (!options.datasourceCount) {
-    questions.push({
-      type: 'input',
-      name: 'datasourceCount',
-      message: 'How many datasources do you want to create?',
-      default: '1',
-      validate: (input) => {
-        const count = parseInt(input, 10);
-        if (isNaN(count) || count < 1 || count > 10) {
-          return 'Datasource count must be a number between 1 and 10';
-        }
-        return true;
-      }
-    });
-  }
+function buildExternalSystemDatasourceQuestion(options) {
+  if (options.datasourceCount) return [];
+  return [{
+    type: 'input',
+    name: 'datasourceCount',
+    message: 'How many datasources do you want to create?',
+    default: '1',
+    validate: (input) => {
+      const count = parseInt(input, 10);
+      if (isNaN(count) || count < 1 || count > 10) return 'Datasource count must be a number between 1 and 10';
+      return true;
+    }
+  }];
+}
 
-  return questions;
+/**
+ * Builds external system configuration questions
+ * @param {Object} options - Provided options
+ * @param {string} appName - Application name
+ * @returns {Array} Array of question objects
+ */
+function buildExternalSystemQuestions(options, appName) {
+  return [
+    ...buildExternalSystemIdentityQuestions(options, appName),
+    ...buildExternalSystemTypeQuestions(options),
+    ...buildExternalSystemDatasourceQuestion(options)
+  ];
 }
 
 /**

package/lib/app/push.js

@@ -8,10 +8,7 @@
  * @version 2.0.0
  */
 
-const fs = require('fs').promises;
-const path = require('path');
 const chalk = require('chalk');
-const yaml = require('js-yaml');
 const pushUtils = require('../deployment/push');
 const logger = require('../utils/logger');
 
@@ -44,7 +41,7 @@ function validateAppName(appName) {
 
 /**
  * Extracts image name from configuration using the same logic as build command
- * @param {Object} config - Configuration object from variables.yaml
+ * @param {Object} config - Configuration object from application.yaml
  * @param {string} appName - Application name (fallback)
  * @returns {string} Image name
  */
@@ -61,7 +58,7 @@ function extractImageName(config, appName) {
 }
 
 /**
- * Loads push configuration from variables.yaml
+ * Loads push configuration from application config (application.yaml or application.json)
  * @async
  * @param {string} appName - Application name
  * @param {Object} options - Push options
@@ -69,15 +66,15 @@ function extractImageName(config, appName) {
  * @throws {Error} If configuration cannot be loaded
  */
 async function loadPushConfig(appName, options) {
-  // Detect app type and get correct path (integration or builder)
-  const { detectAppType } = require('../utils/paths');
+  const { detectAppType, resolveApplicationConfigPath } = require('../utils/paths');
+  const { loadConfigFile } = require('../utils/config-format');
   const { appPath } = await detectAppType(appName);
-  const configPath = path.join(appPath, 'variables.yaml');
   try {
-    const config = yaml.load(await fs.readFile(configPath, 'utf8'));
+    const configPath = resolveApplicationConfigPath(appPath);
+    const config = loadConfigFile(configPath);
     const registry = options.registry || config.image?.registry;
     if (!registry) {
-      throw new Error('Registry URL is required. Provide via --registry flag or configure in variables.yaml under image.registry');
+      throw new Error('Registry URL is required. Provide via --registry flag or configure in application config under image.registry');
     }
     const imageName = extractImageName(config, appName);
     return { registry, imageName };
@@ -85,7 +82,7 @@ async function loadPushConfig(appName, options) {
     if (error.message.includes('Registry URL')) {
       throw error;
     }
-    throw new Error(`Failed to load configuration: ${configPath}\nRun 'aifabrix create ${appName}' first`);
+    throw new Error(`Failed to load configuration: ${error.message}\nRun 'aifabrix create ${appName}' first`);
   }
 }