@aifabrix/builder 2.22.1 → 2.31.0

package/lib/utils/paths.js

@@ -57,6 +57,153 @@ function getAifabrixHome() {
   return path.join(safeHomedir(), '.aifabrix');
 }
 
+// Cache project root to avoid repeated filesystem lookups
+let cachedProjectRoot = null;
+
+/**
+ * Clears the cached project root
+ * Useful in tests when global.PROJECT_ROOT changes
+ */
+function clearProjectRootCache() {
+  cachedProjectRoot = null;
+}
+
+/**
+ * Checks if a directory contains package.json
+ * @param {string} dirPath - Directory path to check
+ * @returns {boolean} True if package.json exists
+ */
+function hasPackageJson(dirPath) {
+  const packageJsonPath = path.join(dirPath, 'package.json');
+  return fs.existsSync(packageJsonPath);
+}
+
+/**
+ * Strategy 1: Walk up from a starting directory to find package.json
+ * @param {string} startDir - Starting directory
+ * @param {number} maxDepth - Maximum depth to search
+ * @returns {string|null} Project root path or null if not found
+ */
+function findProjectRootByWalkingUp(startDir, maxDepth = 10) {
+  let currentDir = startDir;
+  for (let i = 0; i < maxDepth; i++) {
+    if (hasPackageJson(currentDir)) {
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      // Reached filesystem root
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+
+/**
+ * Strategy 2: Try from process.cwd()
+ * @returns {string|null} Project root path or null if not found
+ */
+function findProjectRootFromCwd() {
+  try {
+    const cwd = process.cwd();
+    if (cwd && cwd !== '/' && hasPackageJson(cwd)) {
+      return cwd;
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Strategy 3: Check if Jest rootDir is available
+ * @returns {string|null} Project root path or null if not found
+ */
+// eslint-disable-next-line no-unused-vars
+function _findProjectRootFromJest() {
+  if (typeof jest !== 'undefined' && jest.config && jest.config.rootDir) {
+    const jestRoot = jest.config.rootDir;
+    if (hasPackageJson(jestRoot)) {
+      return jestRoot;
+    }
+  }
+  return null;
+}
+
+/**
+ * Strategy 4: Fallback to __dirname relative path
+ * @returns {string} Fallback project root path
+ */
+function getFallbackProjectRoot() {
+  return path.resolve(__dirname, '..', '..');
+}
+
+/**
+ * Gets the project root directory by finding package.json
+ * Works reliably in all environments including Jest tests and CI
+ * @returns {string} Absolute path to project root
+ */
+function getProjectRoot() {
+  // SIMPLIFIED: Always use __dirname walking - most reliable in all environments
+  // This works in: local dev, CI, tests, temp directories, etc.
+  // __dirname is lib/utils/, so we walk up to find package.json
+
+  // Return cached value if available and valid
+  if (cachedProjectRoot && hasPackageJson(cachedProjectRoot)) {
+    return cachedProjectRoot;
+  }
+
+  // Strategy 1: Check global.PROJECT_ROOT if set and valid (for test isolation)
+  // BUT: In CI simulation, the project is copied, so global.PROJECT_ROOT might point to original
+  // We need to verify it's actually the correct root by checking if __dirname is within it
+  if (typeof global !== 'undefined' && global.PROJECT_ROOT) {
+    const globalRoot = global.PROJECT_ROOT;
+    if (hasPackageJson(globalRoot)) {
+      // Verify that __dirname is actually within globalRoot (or they're the same)
+      // This ensures we're using the correct project root in CI simulation
+      const dirnameNormalized = path.resolve(__dirname);
+      const globalRootNormalized = path.resolve(globalRoot);
+      const isWithinGlobalRoot = dirnameNormalized.startsWith(globalRootNormalized + path.sep) ||
+                                  dirnameNormalized === globalRootNormalized;
+
+      if (isWithinGlobalRoot) {
+        cachedProjectRoot = globalRoot;
+        return cachedProjectRoot;
+      }
+      // If global.PROJECT_ROOT doesn't contain __dirname, it's wrong (e.g., original project in CI)
+      // Clear it and continue with other strategies
+    }
+  }
+
+  // Strategy 2: Walk up from __dirname (lib/utils/) - MOST RELIABLE
+  // This always works because __dirname is always correct relative to the code
+  const foundRoot = findProjectRootByWalkingUp(__dirname);
+  if (foundRoot && hasPackageJson(foundRoot)) {
+    cachedProjectRoot = foundRoot;
+    return cachedProjectRoot;
+  }
+
+  // Strategy 3: Try process.cwd() (works in most cases)
+  const cwdRoot = findProjectRootFromCwd();
+  if (cwdRoot && hasPackageJson(cwdRoot)) {
+    cachedProjectRoot = cwdRoot;
+    return cachedProjectRoot;
+  }
+
+  // Strategy 4: Fallback to __dirname relative (lib/utils/ -> project root)
+  const fallbackRoot = getFallbackProjectRoot();
+  if (hasPackageJson(fallbackRoot)) {
+    cachedProjectRoot = fallbackRoot;
+    return cachedProjectRoot;
+  }
+
+  // Last resort: return fallback even if package.json not found
+  // This prevents crashes but should rarely happen
+  cachedProjectRoot = fallbackRoot;
+  return cachedProjectRoot;
+}
+
 /**
  * Returns the applications base directory for a developer.
  * Dev 0: <home>/applications
@@ -169,65 +316,73 @@ function getDeployJsonPath(appName, appType, preferNew = false) {
 }
 
 /**
- * Detects if an app is external type by checking variables.yaml
- * Checks both integration/ and builder/ folders for backward compatibility
- *
- * @param {string} appName - Application name
- * @returns {Promise<{isExternal: boolean, appPath: string, appType: string}>}
+ * Reads and parses variables.yaml file
+ * @param {string} variablesPath - Path to variables.yaml file
+ * @returns {Object|null} Parsed variables object or null if error
  */
-async function detectAppType(appName) {
-  if (!appName || typeof appName !== 'string') {
-    throw new Error('App name is required and must be a string');
+function readVariablesFile(variablesPath) {
+  try {
+    if (!fs.existsSync(variablesPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(variablesPath, 'utf8');
+    return yaml.load(content);
+  } catch {
+    return null;
   }
+}
 
-  // Check integration folder first (new structure)
+/**
+ * Checks if app type is external from variables object
+ * @param {Object} variables - Parsed variables.yaml object
+ * @returns {boolean} True if app type is external
+ */
+function isExternalAppType(variables) {
+  return variables && variables.app && variables.app.type === 'external';
+}
+
+/**
+ * Checks integration folder for external app type
+ * @param {string} appName - Application name
+ * @returns {Object|null} App type info or null if not found
+ */
+function checkIntegrationFolder(appName) {
   const integrationPath = getIntegrationPath(appName);
-  const integrationVariablesPath = path.join(integrationPath, 'variables.yaml');
+  const variablesPath = path.join(integrationPath, 'variables.yaml');
+  const variables = readVariablesFile(variablesPath);
 
-  if (fs.existsSync(integrationVariablesPath)) {
-    try {
-      const content = fs.readFileSync(integrationVariablesPath, 'utf8');
-      const variables = yaml.load(content);
-      if (variables.app && variables.app.type === 'external') {
-        return {
-          isExternal: true,
-          appPath: integrationPath,
-          appType: 'external',
-          baseDir: 'integration'
-        };
-      }
-    } catch {
-      // Ignore errors, continue to check builder folder
-    }
+  if (variables && isExternalAppType(variables)) {
+    return {
+      isExternal: true,
+      appPath: integrationPath,
+      appType: 'external',
+      baseDir: 'integration'
+    };
   }
+  return null;
+}
 
-  // Check builder folder (backward compatibility)
+/**
+ * Checks builder folder for app type
+ * @param {string} appName - Application name
+ * @returns {Object} App type info
+ */
+function checkBuilderFolder(appName) {
   const builderPath = getBuilderPath(appName);
-  const builderVariablesPath = path.join(builderPath, 'variables.yaml');
+  const variablesPath = path.join(builderPath, 'variables.yaml');
+  const variables = readVariablesFile(variablesPath);
 
-  if (fs.existsSync(builderVariablesPath)) {
-    try {
-      const content = fs.readFileSync(builderVariablesPath, 'utf8');
-      const variables = yaml.load(content);
-      const isExternal = variables.app && variables.app.type === 'external';
-      return {
-        isExternal,
-        appPath: builderPath,
-        appType: isExternal ? 'external' : 'regular',
-        baseDir: 'builder'
-      };
-    } catch {
-      // If we can't read it, assume regular app in builder folder
-      return {
-        isExternal: false,
-        appPath: builderPath,
-        appType: 'regular',
-        baseDir: 'builder'
-      };
-    }
+  if (variables) {
+    const isExternal = isExternalAppType(variables);
+    return {
+      isExternal,
+      appPath: builderPath,
+      appType: isExternal ? 'external' : 'regular',
+      baseDir: 'builder'
+    };
   }
 
-  // Default to builder folder if neither exists
+  // Default to regular app in builder folder
   return {
     isExternal: false,
     appPath: builderPath,
@@ -236,14 +391,38 @@ async function detectAppType(appName) {
   };
 }
 
+/**
+ * Detects if an app is external type by checking variables.yaml
+ * Checks both integration/ and builder/ folders for backward compatibility
+ *
+ * @param {string} appName - Application name
+ * @returns {Promise<{isExternal: boolean, appPath: string, appType: string}>}
+ */
+async function detectAppType(appName) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('App name is required and must be a string');
+  }
+
+  // Check integration folder first (new structure)
+  const integrationResult = checkIntegrationFolder(appName);
+  if (integrationResult) {
+    return integrationResult;
+  }
+
+  // Check builder folder (backward compatibility)
+  return checkBuilderFolder(appName);
+}
+
 module.exports = {
   getAifabrixHome,
   getApplicationsBaseDir,
   getDevDirectory,
   getAppPath,
+  getProjectRoot,
   getIntegrationPath,
   getBuilderPath,
   getDeployJsonPath,
-  detectAppType
+  detectAppType,
+  clearProjectRootCache
 };
 

package/lib/utils/schema-loader.js

@@ -111,6 +111,118 @@ function loadExternalDataSourceSchema() {
   return externalDataSourceValidator;
 }
 
+/**
+ * Detect schema type from $id field
+ * @param {Object} parsed - Parsed JSON object
+ * @returns {string|null} Schema type or null if not detected
+ */
+function detectFromId(parsed) {
+  if (!parsed.$id) {
+    return null;
+  }
+
+  if (parsed.$id.includes('external-system')) {
+    return 'external-system';
+  }
+  if (parsed.$id.includes('external-datasource')) {
+    return 'external-datasource';
+  }
+  if (parsed.$id.includes('application-schema')) {
+    return 'application';
+  }
+
+  return null;
+}
+
+/**
+ * Detect schema type from title field
+ * @param {Object} parsed - Parsed JSON object
+ * @returns {string|null} Schema type or null if not detected
+ */
+function detectFromTitle(parsed) {
+  if (!parsed.title) {
+    return null;
+  }
+
+  const titleLower = parsed.title.toLowerCase();
+  if (titleLower.includes('external system') || titleLower.includes('external-system') || titleLower.includes('external system configuration')) {
+    return 'external-system';
+  }
+  if (titleLower.includes('external data source') || titleLower.includes('external datasource') || titleLower.includes('external-datasource')) {
+    return 'external-datasource';
+  }
+  if (titleLower.includes('application')) {
+    return 'application';
+  }
+
+  return null;
+}
+
+/**
+ * Detect schema type from required fields
+ * @param {Object} parsed - Parsed JSON object
+ * @returns {string|null} Schema type or null if not detected
+ */
+function detectFromRequiredFields(parsed) {
+  if (!parsed.key || !parsed.displayName || !parsed.type || !parsed.authentication) {
+    return null;
+  }
+
+  // Check if it has systemKey (datasource) or not (system)
+  if (parsed.systemKey) {
+    return 'external-datasource';
+  }
+  // Check if type is one of external-system types
+  if (['openapi', 'mcp', 'custom'].includes(parsed.type)) {
+    return 'external-system';
+  }
+
+  return null;
+}
+
+/**
+ * Detect schema type from datasource-specific fields
+ * @param {Object} parsed - Parsed JSON object
+ * @returns {string|null} Schema type or null if not detected
+ */
+function detectFromDatasourceFields(parsed) {
+  if (parsed.systemKey && parsed.entityKey && parsed.fieldMappings) {
+    return 'external-datasource';
+  }
+  return null;
+}
+
+/**
+ * Detect schema type from application-specific fields
+ * @param {Object} parsed - Parsed JSON object
+ * @returns {string|null} Schema type or null if not detected
+ */
+function detectFromApplicationFields(parsed) {
+  if (parsed.deploymentKey || (parsed.image && parsed.registryMode && parsed.port)) {
+    return 'application';
+  }
+  return null;
+}
+
+/**
+ * Detect schema type from filename pattern
+ * @param {string} filePath - File path
+ * @returns {string|null} Schema type or null if not detected
+ */
+function detectFromFilename(filePath) {
+  const fileName = path.basename(filePath).toLowerCase();
+  if (fileName.includes('external-system') || fileName.includes('external_system')) {
+    return 'external-system';
+  }
+  if (fileName.includes('external-datasource') || fileName.includes('external_datasource') || fileName.includes('datasource')) {
+    return 'external-datasource';
+  }
+  if (fileName.includes('application') || fileName.includes('variables') || fileName.includes('deploy')) {
+    return 'application';
+  }
+  return null;
+}
+
 /**
  * Detects schema type from file content or path
  * Attempts to identify if file is application, external-system, or external-datasource
@@ -144,68 +256,24 @@ function detectSchemaType(filePath, content) {
     throw new Error(`Invalid JSON in file: ${error.message}`);
   }
 
-  // Check for schema type indicators
-  // Check $id for schema type
-  if (parsed.$id) {
-    if (parsed.$id.includes('external-system')) {
-      return 'external-system';
-    }
-    if (parsed.$id.includes('external-datasource')) {
-      return 'external-datasource';
-    }
-    if (parsed.$id.includes('application-schema')) {
-      return 'application';
-    }
-  }
+  // Try different detection methods in order
+  const idType = detectFromId(parsed);
+  if (idType) return idType;
 
-  // Check title for schema type (works even without $id or $schema)
-  if (parsed.title) {
-    const titleLower = parsed.title.toLowerCase();
-    if (titleLower.includes('external system') || titleLower.includes('external-system') || titleLower.includes('external system configuration')) {
-      return 'external-system';
-    }
-    if (titleLower.includes('external data source') || titleLower.includes('external datasource') || titleLower.includes('external-datasource')) {
-      return 'external-datasource';
-    }
-    if (titleLower.includes('application')) {
-      return 'application';
-    }
-  }
+  const titleType = detectFromTitle(parsed);
+  if (titleType) return titleType;
 
-  // Check for required fields to determine type
-  // External system requires: key, displayName, description, type, authentication
-  if (parsed.key && parsed.displayName && parsed.type && parsed.authentication) {
-    // Check if it has systemKey (datasource) or not (system)
-    if (parsed.systemKey) {
-      return 'external-datasource';
-    }
-    // Check if type is one of external-system types
-    if (['openapi', 'mcp', 'custom'].includes(parsed.type)) {
-      return 'external-system';
-    }
-  }
+  const requiredFieldsType = detectFromRequiredFields(parsed);
+  if (requiredFieldsType) return requiredFieldsType;
 
-  // Check for datasource-specific fields
-  if (parsed.systemKey && parsed.entityKey && parsed.fieldMappings) {
-    return 'external-datasource';
-  }
+  const datasourceType = detectFromDatasourceFields(parsed);
+  if (datasourceType) return datasourceType;
 
-  // Check for application-specific fields
-  if (parsed.deploymentKey || (parsed.image && parsed.registryMode && parsed.port)) {
-    return 'application';
-  }
+  const applicationType = detectFromApplicationFields(parsed);
+  if (applicationType) return applicationType;
 
-  // Fallback: check filename pattern
-  const fileName = path.basename(filePath).toLowerCase();
-  if (fileName.includes('external-system') || fileName.includes('external_system')) {
-    return 'external-system';
-  }
-  if (fileName.includes('external-datasource') || fileName.includes('external_datasource') || fileName.includes('datasource')) {
-    return 'external-datasource';
-  }
-  if (fileName.includes('application') || fileName.includes('variables') || fileName.includes('deploy')) {
-    return 'application';
-  }
+  const filenameType = detectFromFilename(filePath);
+  if (filenameType) return filenameType;
 
   // Default to application if cannot determine
   return 'application';

package/lib/utils/token-manager.js

@@ -11,13 +11,15 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const yaml = require('js-yaml');
 const config = require('../config');
 const { makeApiCall, refreshDeviceToken: apiRefreshDeviceToken } = require('./api');
 const logger = require('./logger');
+const pathsUtil = require('./paths');
 
-const SECRETS_FILE = path.join(os.homedir(), '.aifabrix', 'secrets.local.yaml');
+function getSecretsFilePath() {
+  return path.join(pathsUtil.getAifabrixHome(), 'secrets.local.yaml');
+}
 
 /**
  * Load client credentials from secrets.local.yaml
@@ -31,11 +33,12 @@ async function loadClientCredentials(appName) {
   }
 
   try {
-    if (!fs.existsSync(SECRETS_FILE)) {
+    const secretsFile = getSecretsFilePath();
+    if (!fs.existsSync(secretsFile)) {
       return null;
     }
 
-    const content = fs.readFileSync(SECRETS_FILE, 'utf8');
+    const content = fs.readFileSync(secretsFile, 'utf8');
     const secrets = yaml.load(content) || {};
 
     const clientIdKey = `${appName}-client-idKeyVault`;
@@ -298,7 +301,7 @@ async function getOrRefreshDeviceToken(controllerUrl) {
  * @param {string} controllerUrl - Controller URL
  * @param {string} environment - Environment key
  * @param {string} appName - Application name
- * @returns {Promise<{type: 'bearer'|'credentials', token?: string, clientId?: string, clientSecret?: string, controller: string}>} Auth configuration
+ * @returns {Promise<{type: 'bearer'|'client-credentials', token?: string, clientId?: string, clientSecret?: string, controller: string}>} Auth configuration
  * @throws {Error} If no authentication method is available
  */
 async function getDeploymentAuth(controllerUrl, environment, appName) {
@@ -341,7 +344,7 @@ async function getDeploymentAuth(controllerUrl, environment, appName) {
   const credentials = await loadClientCredentials(appName);
   if (credentials && credentials.clientId && credentials.clientSecret) {
     return {
-      type: 'credentials',
+      type: 'client-credentials',
       clientId: credentials.clientId,
       clientSecret: credentials.clientSecret,
       controller: controllerUrl
@@ -363,7 +366,7 @@ async function getDeploymentAuth(controllerUrl, environment, appName) {
  * @throws {Error} If credentials cannot be obtained
  */
 async function extractClientCredentials(authConfig, appKey, envKey, _options = {}) {
-  if (authConfig.type === 'credentials') {
+  if (authConfig.type === 'client-credentials') {
     if (!authConfig.clientId || !authConfig.clientSecret) {
       throw new Error('Client ID and Client Secret are required');
     }

package/lib/utils/yaml-preserve.js

@@ -11,6 +11,57 @@
 
 const { encryptSecret, isEncrypted } = require('./secrets-encryption');
 
+/**
+ * Check if value is null
+ * @param {string} trimmed - Trimmed value
+ * @returns {boolean} True if null
+ */
+function isNullValue(trimmed) {
+  return trimmed === 'null' || trimmed === '~' || trimmed === '';
+}
+
+/**
+ * Check if value is boolean
+ * @param {string} trimmed - Trimmed value
+ * @returns {boolean} True if boolean
+ */
+function isBooleanValue(trimmed) {
+  const booleanValues = [
+    'true', 'false', 'True', 'False', 'TRUE', 'FALSE',
+    'yes', 'no', 'Yes', 'No', 'YES', 'NO',
+    'on', 'off', 'On', 'Off', 'ON', 'OFF'
+  ];
+  return booleanValues.includes(trimmed);
+}
+
+/**
+ * Check if value is number
+ * @param {string} trimmed - Trimmed value
+ * @returns {boolean} True if number
+ */
+function isNumberValue(trimmed) {
+  return /^[+-]?\d+$/.test(trimmed) ||
+    /^[+-]?\d*\.\d+([eE][+-]?\d+)?$/.test(trimmed) ||
+    /^[+-]?\.\d+([eE][+-]?\d+)?$/.test(trimmed) ||
+    /^0x[0-9a-fA-F]+$/.test(trimmed) ||
+    /^0o[0-7]+$/.test(trimmed) ||
+    /^0b[01]+$/.test(trimmed);
+}
+
+/**
+ * Check if value is YAML special value
+ * @param {string} trimmed - Trimmed value
+ * @returns {boolean} True if YAML special value
+ */
+function isYamlSpecialValue(trimmed) {
+  const specialValues = [
+    '.inf', '.Inf', '.INF',
+    '-.inf', '-.Inf', '-.INF',
+    '.nan', '.NaN', '.NAN'
+  ];
+  return specialValues.includes(trimmed);
+}
+
 /**
  * Checks if a string value represents a YAML primitive (number, boolean, null)
  * When parsing line-by-line, these appear as strings but should not be encrypted
@@ -22,31 +73,19 @@ const { encryptSecret, isEncrypted } = require('./secrets-encryption');
 function isYamlPrimitive(value) {
   const trimmed = value.trim();
 
-  // Check for null
-  if (trimmed === 'null' || trimmed === '~' || trimmed === '') {
+  if (isNullValue(trimmed)) {
     return true;
   }
 
-  // Check for boolean
-  if (trimmed === 'true' || trimmed === 'false' || trimmed === 'True' || trimmed === 'False' ||
-      trimmed === 'TRUE' || trimmed === 'FALSE' || trimmed === 'yes' || trimmed === 'no' ||
-      trimmed === 'Yes' || trimmed === 'No' || trimmed === 'YES' || trimmed === 'NO' ||
-      trimmed === 'on' || trimmed === 'off' || trimmed === 'On' || trimmed === 'Off' ||
-      trimmed === 'ON' || trimmed === 'OFF') {
+  if (isBooleanValue(trimmed)) {
     return true;
   }
 
-  // Check for number (integer or float, with optional sign)
-  if (/^[+-]?\d+$/.test(trimmed) || /^[+-]?\d*\.\d+([eE][+-]?\d+)?$/.test(trimmed) ||
-      /^[+-]?\.\d+([eE][+-]?\d+)?$/.test(trimmed) || /^0x[0-9a-fA-F]+$/.test(trimmed) ||
-      /^0o[0-7]+$/.test(trimmed) || /^0b[01]+$/.test(trimmed)) {
+  if (isNumberValue(trimmed)) {
     return true;
   }
 
-  // Check for YAML special values
-  if (trimmed === '.inf' || trimmed === '.Inf' || trimmed === '.INF' ||
-      trimmed === '-.inf' || trimmed === '-.Inf' || trimmed === '-.INF' ||
-      trimmed === '.nan' || trimmed === '.NaN' || trimmed === '.NAN') {
+  if (isYamlSpecialValue(trimmed)) {
     return true;
   }