@aifabrix/builder 2.37.5 → 2.38.0

package/lib/deployment/environment.js

@@ -82,20 +82,8 @@ async function getEnvironmentAuth(controllerUrl) {
  * @returns {Promise<Object>} Deployment result
  * @throws {Error} If deployment fails
  */
-/**
- * Loads and validates environment deploy config from a JSON file
- * @param {string} configPath - Absolute or relative path to config JSON
- * @returns {Object} Valid deploy request { environmentConfig, dryRun? }
- * @throws {Error} If file missing, invalid JSON, or validation fails
- */
-function loadAndValidateEnvironmentDeployConfig(configPath) {
-  const resolvedPath = path.isAbsolute(configPath) ? configPath : path.resolve(process.cwd(), configPath);
-  if (!fs.existsSync(resolvedPath)) {
-    throw new Error(
-      `Environment config file not found: ${resolvedPath}\n` +
-      'Use --config <file> with a JSON file containing "environmentConfig" (e.g. templates/infra/environment-dev.json).'
-    );
-  }
+/** Reads and parses config file; throws if missing, unreadable, or invalid structure. */
+function parseEnvironmentConfigFile(resolvedPath) {
   let raw;
   try {
     raw = fs.readFileSync(resolvedPath, 'utf8');
@@ -124,14 +112,21 @@ function loadAndValidateEnvironmentDeployConfig(configPath) {
     );
   }
   if (typeof parsed.environmentConfig !== 'object' || parsed.environmentConfig === null) {
-    throw new Error(
-      `"environmentConfig" must be an object. File: ${resolvedPath}`
-    );
+    throw new Error(`"environmentConfig" must be an object. File: ${resolvedPath}`);
   }
+  return parsed;
+}
+
+/**
+ * Validates parsed config against schema and returns deploy request.
+ * @param {Object} parsed - Parsed config object
+ * @param {string} resolvedPath - Path for error messages
+ * @returns {Object} { environmentConfig, dryRun? }
+ */
+function validateEnvironmentDeployParsed(parsed, resolvedPath) {
   const ajv = new Ajv({ allErrors: true, strict: false });
   const validate = ajv.compile(environmentDeployRequestSchema);
-  const valid = validate(parsed);
-  if (!valid) {
+  if (!validate(parsed)) {
     const messages = formatValidationErrors(validate.errors);
     throw new Error(
       `Environment config validation failed (${resolvedPath}):\n  • ${messages.join('\n  • ')}\n` +
@@ -144,6 +139,24 @@ function loadAndValidateEnvironmentDeployConfig(configPath) {
   };
 }
 
+/**
+ * Loads and validates environment deploy config from a JSON file
+ * @param {string} configPath - Absolute or relative path to config JSON
+ * @returns {Object} Valid deploy request { environmentConfig, dryRun? }
+ * @throws {Error} If file missing, invalid JSON, or validation fails
+ */
+function loadAndValidateEnvironmentDeployConfig(configPath) {
+  const resolvedPath = path.isAbsolute(configPath) ? configPath : path.resolve(process.cwd(), configPath);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(
+      `Environment config file not found: ${resolvedPath}\n` +
+      'Use --config <file> with a JSON file containing "environmentConfig" (e.g. templates/infra/environment-dev.json).'
+    );
+  }
+  const parsed = parseEnvironmentConfigFile(resolvedPath);
+  return validateEnvironmentDeployParsed(parsed, resolvedPath);
+}
+
 /**
  * Builds environment deployment request from options (config file required)
  * @function buildEnvironmentDeploymentRequest
@@ -479,8 +492,6 @@ async function deployEnvironment(envKey, options = {}) {
     throw error;
   }
 }
-
 module.exports = {
   deployEnvironment
 };
-

package/lib/generator/builders.js

@@ -126,11 +126,17 @@ function buildAuthentication(rbac) {
  * @returns {Object} App metadata
  */
 function buildAppMetadata(appName, variables) {
+  const rawVersion = variables.app?.version;
+  const version =
+    rawVersion !== undefined && rawVersion !== null && String(rawVersion).trim()
+      ? String(rawVersion).trim()
+      : '1.0.0';
   return {
     key: variables.app?.key || appName,
     displayName: variables.app?.displayName || appName,
     description: variables.app?.description || '',
-    type: variables.app?.type || 'webapp'
+    type: variables.app?.type || 'webapp',
+    version
   };
 }
 
@@ -375,12 +381,11 @@ function buildOptionalFields(deployment, variables, rbac) {
  * Builds deployment manifest structure
  * @param {string} appName - Application name
  * @param {Object} variables - Variables configuration
- * @param {string} deploymentKey - Deployment key
  * @param {Array} configuration - Environment configuration
  * @param {Object|null} rbac - RBAC configuration
  * @returns {Object} Deployment manifest
  */
-function buildManifestStructure(appName, variables, deploymentKey, configuration, rbac) {
+function buildManifestStructure(appName, variables, configuration, rbac) {
   const registryMode = variables.image?.registryMode || 'external';
   const filteredConfiguration = filterConfigurationByRegistryMode(configuration, registryMode);
   const deployment = buildBaseDeployment(appName, variables, filteredConfiguration);

package/lib/generator/external-controller-manifest.js

@@ -11,7 +11,6 @@
 
 const path = require('path');
 const { detectAppType } = require('../utils/paths');
-const { generateDeploymentKeyFromJson } = require('../core/key-generator');
 const { loadSystemFile, loadDatasourceFiles } = require('./external');
 const { loadVariables, loadRbac } = require('./helpers');
 
@@ -97,7 +96,7 @@ async function loadSystemWithRbac(appPath, schemaBasePath, systemFile) {
  *
  * @example
  * const manifest = await generateControllerManifest('my-hubspot');
- * // Returns: { key, displayName, description, type: "external", system: {...}, dataSources: [...], deploymentKey }
+ * // Returns: { key, displayName, description, type: "external", system: {...}, dataSources: [...] }
  */
 async function generateControllerManifest(appName, options = {}) {
   if (!appName || typeof appName !== 'string') {
@@ -124,13 +123,15 @@ async function generateControllerManifest(appName, options = {}) {
   const datasourceFiles = variables.externalIntegration.dataSources || [];
   const datasourceJsons = await loadDatasourceFiles(appPath, schemaBasePath, datasourceFiles);
 
+  const appVersion = variables.app?.version || variables.externalIntegration?.version || '1.0.0';
+
   // Build externalIntegration block (required by application schema for type: "external")
   const externalIntegration = {
     schemaBasePath: schemaBasePath,
     systems: systemFiles,
     dataSources: datasourceFiles,
     autopublish: variables.externalIntegration.autopublish !== false, // default true
-    version: variables.externalIntegration.version || '1.0.0'
+    version: appVersion
   };
 
   const manifest = {
@@ -138,6 +139,7 @@ async function generateControllerManifest(appName, options = {}) {
     displayName: metadata.displayName,
     description: metadata.description,
     type: 'external',
+    version: appVersion,
     externalIntegration: externalIntegration,
     // Inline system and dataSources for atomic deployment (optional but recommended)
     system: systemJson,
@@ -148,7 +150,6 @@ async function generateControllerManifest(appName, options = {}) {
     requiresStorage: false
   };
 
-  manifest.deploymentKey = generateDeploymentKeyFromJson(manifest);
   return manifest;
 }
 

package/lib/generator/index.js

@@ -11,7 +11,6 @@
 
 const fs = require('fs');
 const path = require('path');
-const _keyGenerator = require('../core/key-generator');
 const _validator = require('../validation/validator');
 const builders = require('./builders');
 const { detectAppType, getDeployJsonPath } = require('../utils/paths');
@@ -19,6 +18,7 @@ const splitFunctions = require('./split');
 const { loadVariables, loadEnvTemplate, loadRbac, parseEnvironmentVariables } = require('./helpers');
 const { generateExternalSystemApplicationSchema, splitExternalApplicationSchema } = require('./external');
 const { generateControllerManifest } = require('./external-controller-manifest');
+const { resolveVersionForApp } = require('../utils/image-version');
 
 /**
  * Generates deployment JSON from application configuration files
@@ -65,21 +65,15 @@ function loadDeploymentConfigFiles(appPath, appType, appName) {
  * @param {Object} variables - Variables configuration
  * @param {Object} envTemplate - Environment template
  * @param {Object} rbac - RBAC configuration
- * @returns {Object} Deployment manifest with deploymentKey
+ * @returns {Object} Deployment manifest
  * @throws {Error} If validation fails
  */
 function buildAndValidateDeployment(appName, variables, envTemplate, rbac) {
   // Parse environment variables from template and merge portalInput from variables.yaml
   const configuration = parseEnvironmentVariables(envTemplate, variables);
 
-  // Build deployment manifest WITHOUT deploymentKey initially
-  const deployment = builders.buildManifestStructure(appName, variables, null, configuration, rbac);
-
-  // Generate deploymentKey from the manifest object (excluding deploymentKey field)
-  const deploymentKey = _keyGenerator.generateDeploymentKeyFromJson(deployment);
-
-  // Add deploymentKey to manifest
-  deployment.deploymentKey = deploymentKey;
+  // Build deployment manifest (Controller computes deploymentKey from schema)
+  const deployment = builders.buildManifestStructure(appName, variables, configuration, rbac);
 
   // Validate deployment JSON against schema
   const validation = _validator.validateDeploymentJson(deployment);
@@ -114,10 +108,13 @@ async function buildDeploymentManifestInMemory(appName, options = {}) {
   }
 
   const { variables, envTemplate, rbac } = loadDeploymentConfigFiles(appPath, appType, appName);
+  const resolved = await resolveVersionForApp(appName, variables, { updateBuilder: false });
+  const variablesWithVersion = {
+    ...variables,
+    app: { ...variables.app, version: resolved.version }
+  };
   const configuration = parseEnvironmentVariables(envTemplate, variables);
-  const deployment = builders.buildManifestStructure(appName, variables, null, configuration, rbac);
-  const deploymentKey = _keyGenerator.generateDeploymentKeyFromJson(deployment);
-  deployment.deploymentKey = deploymentKey;
+  const deployment = builders.buildManifestStructure(appName, variablesWithVersion, configuration, rbac);
 
   return { deployment, appPath };
 }
@@ -145,7 +142,12 @@ async function generateDeployJson(appName, options = {}) {
 
   // Regular app: generate deployment manifest
   const { variables, envTemplate, rbac, jsonPath } = loadDeploymentConfigFiles(appPath, appType, appName);
-  const deployment = buildAndValidateDeployment(appName, variables, envTemplate, rbac);
+  const resolved = await resolveVersionForApp(appName, variables, { updateBuilder: false });
+  const variablesWithVersion = {
+    ...variables,
+    app: { ...variables.app, version: resolved.version }
+  };
+  const deployment = buildAndValidateDeployment(appName, variablesWithVersion, envTemplate, rbac);
 
   // Write deployment JSON
   const jsonContent = JSON.stringify(deployment, null, 2);

package/lib/generator/split.js

@@ -98,6 +98,7 @@ function extractAppSection(deployment) {
   if (deployment.displayName) app.displayName = deployment.displayName;
   if (deployment.description) app.description = deployment.description;
   if (deployment.type) app.type = deployment.type;
+  if (deployment.version) app.version = deployment.version;
   return app;
 }
 

package/lib/generator/wizard.js

@@ -234,8 +234,11 @@ async function generateOrUpdateVariablesYaml(params) {
         key: appName,
         displayName: systemConfig.displayName || appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
         description: systemConfig.description || `External system integration for ${appName}`,
-        type: 'external'
+        type: 'external',
+        version: '1.0.0'
       };
+    } else {
+      variables.app.version = variables.app.version || '1.0.0';
     }
 
     // Set deployment config if not present

package/lib/schema/application-schema.json

@@ -57,8 +57,7 @@
     "key",
     "displayName",
     "description",
-    "type",
-    "deploymentKey"
+    "type"
   ],
   "properties": {
     "key": {
@@ -91,6 +90,11 @@
         "external"
       ]
     },
+    "version": {
+      "type": "string",
+      "description": "Application version (semantic); default 1.0.0 when empty",
+      "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9.-]+)?$"
+    },
     "image": {
       "type": "string",
       "description": "Container image reference",

package/lib/schema/deployment-rules.yaml

@@ -0,0 +1,121 @@
+# Deployment rules – Central mapping for Controller
+#
+# Defines which manifest paths trigger deployment and which can differ per environment.
+# Controller uses this file (or equivalent) for deployment key computation and value merge.
+# Schemas (application, external-system, external-datasource) remain clean; no x-* annotations.
+#
+# Semantics:
+#   triggerPaths:   Change affects deployment key / requires deploy
+#   overridablePaths: Value can differ per environment (preserve on promote)
+# A path may appear in both (e.g. authentication.endpoints triggers deploy and is overridable).
+#
+# Path format: Dot notation. Child paths override parent when both match.
+# Schema keys: application | externalSystem | externalDataSource
+
+application:
+  triggerPaths:
+    - key
+    - displayName
+    - description
+    - type
+    - version
+    - image
+    - registryMode
+    - port
+    - requiresDatabase
+    - databases
+    - requiresRedis
+    - requiresStorage
+    - configuration
+    - configuration.items
+    - configuration.items.required
+    - configuration.items.portalInput
+    - healthCheck
+    - healthCheck.path
+    - healthCheck.probePath
+    - healthCheck.probeRequestType
+    - healthCheck.probeProtocol
+    - frontDoorRouting
+    - authentication
+    - roles
+    - permissions
+    - repository
+    - startupCommand
+    - runtimeVersion
+    - scaling
+    - build
+    - deployment
+    - externalIntegration
+  overridablePaths:
+    - configuration.items.value
+    - authentication.endpoints
+    - deployment.controllerUrl
+    - healthCheck.interval
+    - healthCheck.probeIntervalInSeconds
+
+externalSystem:
+  triggerPaths:
+    - key
+    - displayName
+    - description
+    - type
+    - enabled
+    - environment
+    - authentication
+    - openapi
+    - mcp
+    - dataSources
+    - configuration
+    - configuration.items
+    - tags
+    - roles
+    - permissions
+    - endpoints
+    - endpointsActive
+    - generateMcpContract
+    - generateOpenApiContract
+  overridablePaths:
+    - environment.baseUrl
+    - environment.region
+    - authentication.oauth2
+    - authentication.apikey
+    - authentication.basic
+    - authentication.aad
+    - openapi.specUrl
+    - openapi.documentKey
+    - mcp.serverUrl
+    - mcp.toolPrefix
+    - configuration.items.value
+    - credentialIdOrKey
+
+externalDataSource:
+  triggerPaths:
+    - key
+    - displayName
+    - description
+    - enabled
+    - systemKey
+    - entityType
+    - resourceType
+    - version
+    - metadataSchema
+    - fieldMappings
+    - exposed
+    - validation
+    - quality
+    - indexing
+    - context
+    - documentStorage
+    - portalInput
+    - capabilities
+    - execution
+    - config
+    - openapi
+  overridablePaths:
+    - sync
+    - sync.mode
+    - sync.schedule
+    - sync.batchSize
+    - sync.maxParallelRequests
+    - openapi.baseUrl
+    - openapi.resourcePath

package/lib/utils/app-run-containers.js

@@ -156,6 +156,7 @@ module.exports = {
   checkImageExists,
   checkContainerRunning,
   stopAndRemoveContainer,
-  logContainerStatus
+  logContainerStatus,
+  getContainerName
 };
 

package/lib/utils/compose-generator.js

@@ -458,7 +458,8 @@ async function generateDockerCompose(appName, appConfig, options) {
   const language = appConfig.build?.language || appConfig.language || 'typescript';
   const template = loadDockerComposeTemplate(language);
   const port = options.port || appConfig.port || 3000;
-  const imageOverride = options.image || options.imageOverride;
+  const imageOverride = options.image || options.imageOverride ||
+    (options.tag ? `${getImageName(appConfig, appName)}:${options.tag}` : null);
   const { devId, idNum } = await getDeveloperIdAndNumeric();
   const { networkName, containerName } = buildNetworkAndContainerNames(appName, devId, idNum);
   const serviceConfig = buildServiceConfig(appName, appConfig, port, devId, imageOverride);

package/lib/utils/help-builder.js

@@ -75,7 +75,6 @@ const CATEGORIES = [
       { name: 'resolve', term: 'resolve <app>' },
       { name: 'json', term: 'json <app>' },
       { name: 'split-json', term: 'split-json <app>' },
-      { name: 'genkey', term: 'genkey <app>' },
       { name: 'validate', term: 'validate <appOrFile>' },
       { name: 'diff', term: 'diff <file1> <file2>' }
     ]

package/lib/utils/image-version.js

@@ -0,0 +1,209 @@
+/**
+ * AI Fabrix Builder - Image Version Resolution
+ *
+ * Resolves application version from Docker image (OCI label or semver tag).
+ * When template is empty or image version is greater, uses image version.
+ *
+ * @fileoverview Image version resolution utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const { getBuilderPath } = require('./paths');
+const composeGenerator = require('./compose-generator');
+const containerHelpers = require('./app-run-containers');
+
+const execAsync = promisify(exec);
+
+const OCI_VERSION_LABEL = 'org.opencontainers.image.version';
+const SEMVER_REGEX = /^v?(\d+\.\d+\.\d+)(?:-[-.\w]+)?(?:\+[-.\w]+)?$/i;
+
+/**
+ * Gets version from Docker image via OCI label or semver tag
+ * @async
+ * @param {string} imageName - Image name (e.g. aifabrix/dataplane)
+ * @param {string} imageTag - Image tag (e.g. v1.0.0, latest)
+ * @returns {Promise<string|null>} Version string or null if not found
+ */
+async function getVersionFromImage(imageName, imageTag) {
+  if (!imageName || typeof imageName !== 'string') {
+    return null;
+  }
+  const tag = imageTag || 'latest';
+  const fullImage = `${imageName}:${tag}`;
+
+  try {
+    const labelFormat = `{{index .Config.Labels "${OCI_VERSION_LABEL}"}}`;
+    const { stdout } = await execAsync(
+      `docker inspect --format '${labelFormat}' "${fullImage}" 2>/dev/null || true`,
+      { timeout: 10000 }
+    );
+    const labelValue = (stdout || '').trim();
+    if (labelValue && labelValue !== '<no value>') {
+      return labelValue;
+    }
+
+    const tagMatch = tag.match(SEMVER_REGEX);
+    if (tagMatch) {
+      return tagMatch[1];
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compares two semantic versions
+ * @param {string} a - First version
+ * @param {string} b - Second version
+ * @returns {number} -1 if a < b, 0 if a === b, 1 if a > b
+ */
+function compareSemver(a, b) {
+  if (!a || !b) {
+    return 0;
+  }
+  const parse = (v) => {
+    const m = String(v).match(SEMVER_REGEX);
+    if (!m) return null;
+    const parts = m[1].split('.').map(Number);
+    return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0 };
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) return 0;
+  if (pa.major !== pb.major) return pa.major > pb.major ? 1 : -1;
+  if (pa.minor !== pb.minor) return pa.minor > pb.minor ? 1 : -1;
+  if (pa.patch !== pb.patch) return pa.patch > pb.patch ? 1 : -1;
+  return 0;
+}
+
+/**
+ * Resolves version for external app (app.version or externalIntegration.version)
+ * @param {Object} variables - Parsed variables.yaml
+ * @returns {string}
+ */
+function resolveExternalVersion(variables) {
+  const version =
+    variables.app?.version ||
+    variables.externalIntegration?.version ||
+    '1.0.0';
+  return String(version).trim() || '1.0.0';
+}
+
+/**
+ * Resolves version for regular app when image exists
+ * @async
+ * @param {string} imageName - Image name
+ * @param {string} imageTag - Image tag
+ * @param {string} templateVersion - Template version (may be empty)
+ * @returns {Promise<{ version: string, fromImage: boolean }>}
+ */
+async function resolveRegularVersion(imageName, imageTag, templateVersion) {
+  const templateEmpty =
+    templateVersion === undefined ||
+    templateVersion === null ||
+    String(templateVersion).trim() === '';
+  const templateStr = String(templateVersion || '').trim();
+
+  const imageVersion = await getVersionFromImage(imageName, imageTag);
+  const useImage =
+    imageVersion &&
+    (templateEmpty || compareSemver(imageVersion, templateStr) >= 0);
+
+  const version = useImage ? imageVersion : (templateEmpty ? '1.0.0' : templateStr);
+  return { version, fromImage: Boolean(useImage) };
+}
+
+/**
+ * Resolves version for an app: from image when image exists and template empty or smaller
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} variables - Parsed variables.yaml
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.updateBuilder] - When true, update builder/variables.yaml if fromImage
+ * @param {string} [options.builderPath] - Builder path (defaults to getBuilderPath(appName))
+ * @returns {Promise<{ version: string, fromImage: boolean, updated: boolean }>}
+ */
+async function resolveVersionForApp(appName, variables, options = {}) {
+  if (!appName || typeof appName !== 'string') {
+    return { version: '1.0.0', fromImage: false, updated: false };
+  }
+
+  if (variables?.externalIntegration) {
+    const version = resolveExternalVersion(variables);
+    return { version, fromImage: false, updated: false };
+  }
+
+  const imageName = composeGenerator.getImageName(variables, appName);
+  const imageTag = variables?.image?.tag || 'latest';
+  const imageExists = await containerHelpers.checkImageExists(imageName, imageTag);
+
+  if (!imageExists) {
+    const templateVersion = variables?.app?.version;
+    const templateEmpty =
+      templateVersion === undefined ||
+      templateVersion === null ||
+      String(templateVersion).trim() === '';
+    const fallback = templateEmpty ? '1.0.0' : String(templateVersion).trim();
+    return { version: fallback, fromImage: false, updated: false };
+  }
+
+  const { version, fromImage } = await resolveRegularVersion(
+    imageName,
+    imageTag,
+    variables?.app?.version
+  );
+
+  let updated = false;
+  if (fromImage && options.updateBuilder) {
+    const builderPath = options.builderPath || getBuilderPath(appName);
+    updated = await updateAppVersionInVariablesYaml(builderPath, version);
+  }
+
+  return { version, fromImage, updated };
+}
+
+/**
+ * Updates app.version in builder variables.yaml
+ * @async
+ * @param {string} builderPath - Path to builder app directory
+ * @param {string} version - Version to set
+ * @returns {Promise<boolean>} True if file was updated
+ */
+async function updateAppVersionInVariablesYaml(builderPath, version) {
+  if (!builderPath || !version || typeof version !== 'string') {
+    return false;
+  }
+  const variablesPath = path.join(builderPath, 'variables.yaml');
+  if (!fsSync.existsSync(variablesPath)) {
+    return false;
+  }
+
+  try {
+    const content = await fs.readFile(variablesPath, 'utf8');
+    const parsed = yaml.load(content) || {};
+    if (!parsed.app) {
+      parsed.app = {};
+    }
+    parsed.app.version = version;
+    const dumped = yaml.dump(parsed, { lineWidth: -1 });
+    await fs.writeFile(variablesPath, dumped, { mode: 0o644, encoding: 'utf8' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  getVersionFromImage,
+  compareSemver,
+  resolveVersionForApp,
+  updateAppVersionInVariablesYaml
+};

package/lib/utils/paths.js

@@ -31,11 +31,15 @@ function safeHomedir() {
 }
 
 /**
- * Returns the path to the config file (AIFABRIX_HOME env or ~/.aifabrix).
- * Used so getAifabrixHome can read from the same location as config.js.
+ * Returns the path to the config directory (same precedence as config.js so both read the same config).
+ * Priority: AIFABRIX_CONFIG (dirname) → AIFABRIX_HOME → ~/.aifabrix.
  * @returns {string} Absolute path to config directory
  */
 function getConfigDirForPaths() {
+  const configFile = process.env.AIFABRIX_CONFIG && typeof process.env.AIFABRIX_CONFIG === 'string';
+  if (configFile) {
+    return path.dirname(path.resolve(process.env.AIFABRIX_CONFIG.trim()));
+  }
   if (process.env.AIFABRIX_HOME && typeof process.env.AIFABRIX_HOME === 'string') {
     return path.resolve(process.env.AIFABRIX_HOME.trim());
   }
@@ -480,7 +484,6 @@ async function detectAppType(appName, options = {}) {
   // Check builder folder (backward compatibility)
   return checkBuilderFolder(appName);
 }
-
 module.exports = {
   getAifabrixHome,
   getConfigDirForPaths,

package/lib/utils/schema-loader.js

@@ -199,7 +199,7 @@ function detectFromDatasourceFields(parsed) {
  * @returns {string|null} Schema type or null if not detected
  */
 function detectFromApplicationFields(parsed) {
-  if (parsed.deploymentKey || (parsed.image && parsed.registryMode && parsed.port)) {
+  if (parsed.image && parsed.registryMode && parsed.port) {
     return 'application';
   }
   return null;