@aifabrix/builder 2.31.0 → 2.32.1

package/lib/app/index.js

@@ -0,0 +1,298 @@
+/**
+ * AI Fabrix Builder Application Management
+ *
+ * This module handles application building, running, and deployment.
+ * Includes runtime detection, Dockerfile generation, and container management.
+ *
+ * @fileoverview Application build and run management for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const { readExistingEnv } = require('../core/env-reader');
+const build = require('../build');
+const appRun = require('./run');
+const { promptForOptions } = require('./prompts');
+const { generateConfigFiles } = require('./config');
+const { pushApp } = require('./push');
+const { generateDockerfileForApp } = require('./dockerfile');
+const { loadTemplateVariables, updateTemplateVariables, mergeTemplateVariables } = require('../utils/template-helpers');
+const { validateTemplate } = require('../validation/template');
+const auditLogger = require('../core/audit-logger');
+const { downApp } = require('./down');
+const { getAppPath } = require('../utils/paths');
+const { displaySuccessMessage } = require('./display');
+const {
+  validateAppDirectoryNotExists,
+  getBaseDirForAppType,
+  handleGitHubWorkflows,
+  validateAppCreation,
+  processTemplateFiles,
+  setupAppFiles
+} = require('./helpers');
+
+/**
+ * Creates new application with scaffolded configuration files
+ * Prompts for configuration options and generates builder/ folder structure
+ *
+ * @async
+ * @function createApp
+ * @param {string} appName - Name of the application to create
+ * @param {Object} options - Creation options
+ * @param {number} [options.port] - Application port
+ * @param {boolean} [options.database] - Requires database
+ * @param {boolean} [options.redis] - Requires Redis
+ * @param {boolean} [options.storage] - Requires file storage
+ * @param {boolean} [options.authentication] - Requires authentication/RBAC
+ * @param {string} [options.language] - Runtime language (typescript/python)
+ * @param {string} [options.template] - Template to use (e.g., controller, keycloak)
+ * @returns {Promise<void>} Resolves when app is created
+ * @throws {Error} If creation fails
+ *
+ * @example
+ * await createApp('myapp', { port: 3000, database: true, language: 'typescript' });
+ * // Creates builder/ with variables.yaml, env.template, rbac.yaml
+ */
+/**
+ * Validates app name and initial setup
+ * @function validateAppNameAndSetup
+ * @param {string} appName - Application name
+ * @param {Object} options - Options
+ * @returns {Object} Initial paths and type
+ */
+function validateAppNameAndSetup(appName, options) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('Application name is required');
+  }
+
+  const initialType = options.type || 'webapp';
+  const baseDir = getBaseDirForAppType(initialType);
+  const appPath = getAppPath(appName, initialType);
+
+  return { initialType, baseDir, appPath };
+}
+
+/**
+ * Handles template validation and loading
+ * @async
+ * @function handleTemplateSetup
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Merged options with template variables
+ */
+async function handleTemplateSetup(options) {
+  if (options.template) {
+    await validateTemplate(options.template);
+  }
+  const templateVariables = await loadTemplateVariables(options.template);
+  return mergeTemplateVariables(options, templateVariables);
+}
+
+/**
+ * Validates and prepares final app path
+ * @async
+ * @function prepareFinalAppPath
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {string} initialAppPath - Initial app path
+ * @returns {Promise<string>} Final app path
+ */
+async function prepareFinalAppPath(appName, config, initialAppPath) {
+  const finalBaseDir = getBaseDirForAppType(config.type);
+  const finalAppPath = getAppPath(appName, config.type);
+
+  // If path changed, validate the new path
+  if (finalAppPath !== initialAppPath) {
+    await validateAppDirectoryNotExists(finalAppPath, appName, finalBaseDir);
+  }
+
+  return finalAppPath;
+}
+
+/**
+ * Generates all application files
+ * @async
+ * @function generateApplicationFiles
+ * @param {string} finalAppPath - Final app path
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {Object} options - Options
+ * @returns {Promise<string>} Environment conversion message
+ */
+async function generateApplicationFiles(finalAppPath, appName, config, options) {
+  await fs.mkdir(finalAppPath, { recursive: true });
+  await processTemplateFiles(options.template, finalAppPath, appName, options, config);
+
+  const existingEnv = await readExistingEnv(process.cwd());
+  const envConversionMessage = existingEnv
+    ? '\n✓ Found existing .env file - sensitive values will be converted to kv:// references'
+    : '';
+
+  await generateConfigFiles(finalAppPath, appName, config, existingEnv);
+
+  // Generate external system files if type is external
+  if (config.type === 'external') {
+    const externalGenerator = require('../external-system/generator');
+    await externalGenerator.generateExternalSystemFiles(finalAppPath, appName, config);
+  }
+
+  if (options.app) {
+    await setupAppFiles(appName, finalAppPath, config, options);
+  }
+
+  await handleGitHubWorkflows(options, config);
+  return envConversionMessage;
+}
+
+/**
+ * Logs application creation for audit
+ * @async
+ * @function logApplicationCreation
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {Object} options - Options
+ */
+async function logApplicationCreation(appName, config, options) {
+  await auditLogger.logApplicationCreation(appName, {
+    language: config.language,
+    port: config.port,
+    database: config.database,
+    redis: config.redis,
+    storage: config.storage,
+    authentication: config.authentication,
+    template: options.template,
+    api: null // Local operation, no API involved
+  });
+}
+
+async function createApp(appName, options = {}) {
+  try {
+    const { appPath } = validateAppNameAndSetup(appName, options);
+    await validateAppCreation(appName, options, appPath, getBaseDirForAppType(options.type || 'webapp'));
+
+    const mergedOptions = await handleTemplateSetup(options);
+    const config = await promptForOptions(appName, mergedOptions);
+
+    const finalAppPath = await prepareFinalAppPath(appName, config, appPath);
+    const envConversionMessage = await generateApplicationFiles(finalAppPath, appName, config, options);
+
+    displaySuccessMessage(appName, config, envConversionMessage, options.app, finalAppPath);
+    await logApplicationCreation(appName, config, options);
+  } catch (error) {
+    throw new Error(`Failed to create application: ${error.message}`);
+  }
+}
+
+/**
+ * Builds a container image for the specified application
+ * Auto-detects runtime and generates Dockerfile if needed
+ *
+ * @async
+ * @function buildApp
+ * @param {string} appName - Name of the application to build
+ * @param {Object} options - Build options
+ * @param {string} [options.language] - Override language detection
+ * @param {boolean} [options.forceTemplate] - Force rebuild from template
+ * @param {string} [options.tag] - Image tag (default: latest)
+ * @returns {Promise<string>} Image tag that was built
+ * @throws {Error} If build fails or app configuration is invalid
+ *
+ * @example
+ * const imageTag = await buildApp('myapp', { language: 'typescript' });
+ * // Returns: 'myapp:latest'
+ */
+async function buildApp(appName, options = {}) {
+  return build.buildApp(appName, options);
+}
+
+/**
+ * Detects the runtime language of an application
+ * Analyzes project files to determine TypeScript, Python, etc.
+ *
+ * @function detectLanguage
+ * @param {string} appPath - Path to application directory
+ * @returns {string} Detected language ('typescript', 'python', etc.)
+ * @throws {Error} If language cannot be detected
+ *
+ * @example
+ * const language = detectLanguage('./myapp');
+ * // Returns: 'typescript'
+ */
+function detectLanguage(appPath) {
+  return build.detectLanguage(appPath);
+}
+
+/**
+ * Generates a Dockerfile from template based on detected language
+ * Uses Handlebars templates to create optimized Dockerfiles
+ *
+ * @async
+ * @function generateDockerfile
+ * @param {string} appPath - Path to application directory
+ * @param {string} language - Target language ('typescript', 'python')
+ * @param {Object} config - Application configuration from variables.yaml
+ * @returns {Promise<string>} Path to generated Dockerfile
+ * @throws {Error} If template generation fails
+ *
+ * @example
+ * const dockerfilePath = await generateDockerfile('./myapp', 'typescript', config);
+ * // Returns: './myapp/.aifabrix/Dockerfile.typescript'
+ */
+async function generateDockerfile(appPath, language, config) {
+  return build.generateDockerfile(appPath, language, config);
+}
+
+/**
+ * Runs the application locally using Docker
+ * Starts container with proper port mapping and environment
+ *
+ * @async
+ * @function runApp
+ * @param {string} appName - Name of the application to run
+ * @param {Object} options - Run options
+ * @param {number} [options.port] - Override local port
+ * @param {boolean} [options.debug] - Enable debug output
+ * @returns {Promise<void>} Resolves when app is running
+ * @throws {Error} If run fails or app is not built
+ *
+ * @example
+ * await runApp('myapp', { port: 3001 });
+ * // Application is now running on localhost:3001
+ */
+async function runApp(appName, options = {}) {
+  return appRun.runApp(appName, options);
+}
+
+/**
+ * Deploys application to controller
+ * @async
+ * @function deployApp
+ * @param {string} appName - Name of the application
+ * @param {Object} options - Deployment options
+ * @returns {Promise<void>} Resolves when deployment is complete
+ */
+async function deployApp(appName, options = {}) {
+  const appDeploy = require('./deploy');
+  return appDeploy.deployApp(appName, options);
+}
+
+module.exports = {
+  createApp,
+  buildApp,
+  runApp,
+  downApp,
+  detectLanguage,
+  generateDockerfile,
+  generateDockerfileForApp,
+  pushApp,
+  deployApp,
+  loadTemplateVariables,
+  updateTemplateVariables,
+  mergeTemplateVariables,
+  checkImageExists: appRun.checkImageExists,
+  checkContainerRunning: appRun.checkContainerRunning,
+  stopAndRemoveContainer: appRun.stopAndRemoveContainer,
+  checkPortAvailable: appRun.checkPortAvailable,
+  generateDockerCompose: appRun.generateDockerCompose,
+  waitForHealthCheck: appRun.waitForHealthCheck
+};

package/lib/{app-list.js → app/list.js}

@@ -9,12 +9,12 @@
  */
 
 const chalk = require('chalk');
-const { getConfig, normalizeControllerUrl } = require('./config');
-const { getOrRefreshDeviceToken } = require('./utils/token-manager');
-const { listEnvironmentApplications } = require('./api/environments.api');
-const { formatApiError } = require('./utils/api-error-handler');
-const { formatAuthenticationError } = require('./utils/error-formatters/http-status-errors');
-const logger = require('./utils/logger');
+const { getConfig, normalizeControllerUrl } = require('../core/config');
+const { getOrRefreshDeviceToken } = require('../utils/token-manager');
+const { listEnvironmentApplications } = require('../api/environments.api');
+const { formatApiError } = require('../utils/api-error-handler');
+const { formatAuthenticationError } = require('../utils/error-formatters/http-status-errors');
+const logger = require('../utils/logger');
 
 /**
  * Extract wrapped array format: { success: true, data: { success: true, data: [...] } }

package/lib/{app-push.js → app/push.js}

@@ -12,8 +12,8 @@ const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
-const pushUtils = require('./push');
-const logger = require('./utils/logger');
+const pushUtils = require('../deployment/push');
+const logger = require('../utils/logger');
 
 /**
  * Validate application name format
@@ -70,7 +70,7 @@ function extractImageName(config, appName) {
  */
 async function loadPushConfig(appName, options) {
   // Detect app type and get correct path (integration or builder)
-  const { detectAppType } = require('./utils/paths');
+  const { detectAppType } = require('../utils/paths');
   const { appPath } = await detectAppType(appName);
   const configPath = path.join(appPath, 'variables.yaml');
   try {
@@ -183,7 +183,7 @@ function displayPushResults(registry, imageName, tags) {
  */
 async function pushApp(appName, options = {}) {
   // Check if app type is external - skip push
-  const { detectAppType } = require('./utils/paths');
+  const { detectAppType } = require('../utils/paths');
   try {
     const { isExternal } = await detectAppType(appName);
     if (isExternal) {

package/lib/{app-readme.js → app/readme.js}

@@ -48,7 +48,7 @@ function formatAppDisplayName(appName) {
  */
 function _loadReadmeTemplate() {
   // Use getProjectRoot to reliably find templates in all environments
-  const { getProjectRoot } = require('./utils/paths');
+  const { getProjectRoot } = require('../utils/paths');
   const projectRoot = getProjectRoot();
   const templatePath = path.join(projectRoot, 'templates', 'applications', 'README.md.hbs');
 
@@ -71,32 +71,51 @@ function _loadReadmeTemplate() {
  * @param {Object} config - Application configuration
  * @returns {string} README.md content
  */
-function generateReadmeMd(appName, config) {
+/**
+ * Extracts service flags from config
+ * @function extractServiceFlags
+ * @param {Object} config - Application configuration
+ * @returns {Object} Service flags object
+ */
+function extractServiceFlags(config) {
+  return {
+    hasDatabase: config.database || config.requires?.database || false,
+    hasRedis: config.redis || config.requires?.redis || false,
+    hasStorage: config.storage || config.requires?.storage || false,
+    hasAuthentication: config.authentication || false
+  };
+}
+
+/**
+ * Builds template context for README generation
+ * @function buildReadmeContext
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @returns {Object} Template context
+ */
+function buildReadmeContext(appName, config) {
   const displayName = formatAppDisplayName(appName);
   const imageName = `aifabrix/${appName}`;
   const port = config.port || 3000;
   // Extract registry from nested structure (config.image.registry) or flattened (config.registry)
   const registry = config.image?.registry || config.registry || 'myacr.azurecr.io';
 
-  const hasDatabase = config.database || config.requires?.database || false;
-  const hasRedis = config.redis || config.requires?.redis || false;
-  const hasStorage = config.storage || config.requires?.storage || false;
-  const hasAuthentication = config.authentication || false;
-  const hasAnyService = hasDatabase || hasRedis || hasStorage || hasAuthentication;
+  const serviceFlags = extractServiceFlags(config);
+  const hasAnyService = serviceFlags.hasDatabase || serviceFlags.hasRedis || serviceFlags.hasStorage || serviceFlags.hasAuthentication;
 
-  const context = {
+  return {
     appName,
     displayName,
     imageName,
     port,
     registry,
-    hasDatabase,
-    hasRedis,
-    hasStorage,
-    hasAuthentication,
+    ...serviceFlags,
     hasAnyService
   };
+}
 
+function generateReadmeMd(appName, config) {
+  const context = buildReadmeContext(appName, config);
   // Always generate comprehensive README programmatically to ensure consistency
   // regardless of template file content
   return generateComprehensiveReadme(context);
@@ -220,10 +239,12 @@ For more information, see the [AI Fabrix Builder documentation](https://docs.aif
  * @throws {Error} If file generation fails
  */
 async function generateReadmeMdFile(appPath, appName, config) {
+  // Ensure directory exists
+  await fs.mkdir(appPath, { recursive: true });
   const readmePath = path.join(appPath, 'README.md');
   if (!(await fileExists(readmePath))) {
     const readmeContent = generateReadmeMd(appName, config);
-    await fs.writeFile(readmePath, readmeContent);
+    await fs.writeFile(readmePath, readmeContent, 'utf8');
   }
 }
 

package/lib/{app-register.js → app/register.js}

@@ -9,19 +9,19 @@
  */
 
 const chalk = require('chalk');
-const logger = require('./utils/logger');
-const { saveLocalSecret, isLocalhost } = require('./utils/local-secrets');
-const { updateEnvTemplate } = require('./utils/env-template');
-const { generateEnvFile } = require('./secrets');
-const { registerApplicationSchema, validateAppRegistrationData } = require('./utils/app-register-validator');
+const logger = require('../utils/logger');
+const { saveLocalSecret, isLocalhost } = require('../utils/local-secrets');
+const { updateEnvTemplate } = require('../utils/env-template');
+const { generateEnvFile } = require('../core/secrets');
+const { registerApplicationSchema, validateAppRegistrationData } = require('../utils/app-register-validator');
 const {
   loadVariablesYaml,
   createMinimalAppIfNeeded,
   extractAppConfiguration
-} = require('./utils/app-register-config');
-const { checkAuthentication } = require('./utils/app-register-auth');
-const { callRegisterApi } = require('./utils/app-register-api');
-const { displayRegistrationResults, getEnvironmentPrefix } = require('./utils/app-register-display');
+} = require('../utils/app-register-config');
+const { checkAuthentication } = require('../utils/app-register-auth');
+const { callRegisterApi } = require('../utils/app-register-api');
+const { displayRegistrationResults, getEnvironmentPrefix } = require('../utils/app-register-display');
 
 /**
  * Build registration data payload from app configuration

package/lib/{app-rotate-secret.js → app/rotate-secret.js}

@@ -9,16 +9,16 @@
  */
 
 const chalk = require('chalk');
-const { getConfig, normalizeControllerUrl } = require('./config');
-const { getOrRefreshDeviceToken } = require('./utils/token-manager');
-const { rotateApplicationSecret } = require('./api/applications.api');
-const { formatApiError } = require('./utils/api-error-handler');
-const { formatAuthenticationError } = require('./utils/error-formatters/http-status-errors');
-const logger = require('./utils/logger');
-const { saveLocalSecret, isLocalhost } = require('./utils/local-secrets');
-const { updateEnvTemplate } = require('./utils/env-template');
-const { getEnvironmentPrefix } = require('./app-register');
-const { generateEnvFile } = require('./secrets');
+const { getConfig, normalizeControllerUrl } = require('../core/config');
+const { getOrRefreshDeviceToken } = require('../utils/token-manager');
+const { rotateApplicationSecret } = require('../api/applications.api');
+const { formatApiError } = require('../utils/api-error-handler');
+const { formatAuthenticationError } = require('../utils/error-formatters/http-status-errors');
+const logger = require('../utils/logger');
+const { saveLocalSecret, isLocalhost } = require('../utils/local-secrets');
+const { updateEnvTemplate } = require('../utils/env-template');
+const { getEnvironmentPrefix } = require('./register');
+const { generateEnvFile } = require('../core/secrets');
 
 /**
  * Find device token from config by trying each stored URL
@@ -61,20 +61,83 @@ function validateEnvironment(environment) {
   }
 }
 
+/**
+ * Validate credentials object structure
+ * @param {Object} credentials - Credentials object to validate
+ * @returns {boolean} True if credentials are valid
+ */
+function isValidCredentials(credentials) {
+  return credentials &&
+    typeof credentials === 'object' &&
+    typeof credentials.clientId === 'string' &&
+    typeof credentials.clientSecret === 'string';
+}
+
+/**
+ * Extract credentials from API response
+ * Handles multiple response formats:
+ * 1. Direct format: { success: true, data: { credentials: {...} } }
+ * 2. Wrapped format: { success: true, data: { success: true, data: { credentials: {...} } } }
+ * @param {Object} response - API response from centralized API client
+ * @returns {Object|null} Object with credentials and message, or null if not found
+ */
+function extractCredentials(response) {
+  // Note: response.data is already validated in validateResponse
+  const apiResponse = response.data;
+
+  // Try wrapped format first: response.data.data.credentials
+  if (apiResponse.data && apiResponse.data.credentials) {
+    const credentials = apiResponse.data.credentials;
+    if (isValidCredentials(credentials)) {
+      return {
+        credentials: credentials,
+        message: apiResponse.data.message || apiResponse.message
+      };
+    }
+  }
+
+  // Try direct format: response.data.credentials
+  if (apiResponse.credentials) {
+    const credentials = apiResponse.credentials;
+    if (isValidCredentials(credentials)) {
+      return {
+        credentials: credentials,
+        message: apiResponse.message
+      };
+    }
+  }
+
+  return null;
+}
+
 /**
  * Validate API response structure
  * @param {Object} response - API response
+ * @returns {Object} Object with credentials and message
  * @throws {Error} If response structure is invalid
  */
 function validateResponse(response) {
   if (!response.data || typeof response.data !== 'object') {
+    logger.error(chalk.red('❌ Invalid response: missing data'));
+    logger.error(chalk.gray('\nAPI response type:'), typeof response.data);
+    logger.error(chalk.gray('API response:'), JSON.stringify(response.data, null, 2));
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(response, null, 2)));
     throw new Error('Invalid response: missing data');
   }
 
-  const credentials = response.data.credentials;
-  if (!credentials || typeof credentials !== 'object' || typeof credentials.clientId !== 'string' || typeof credentials.clientSecret !== 'string') {
+  const result = extractCredentials(response);
+
+  if (!result) {
+    logger.error(chalk.red('❌ Invalid response: missing or invalid credentials'));
+    logger.error(chalk.gray('\nAPI response type:'), typeof response.data);
+    logger.error(chalk.gray('API response:'), JSON.stringify(response.data, null, 2));
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(response, null, 2)));
     throw new Error('Invalid response: missing or invalid credentials');
   }
+
+  return result;
 }
 
 /**
@@ -108,6 +171,47 @@ function displayRotationResults(appKey, environment, credentials, apiUrl, messag
   }
 }
 
+/**
+ * Get device token from provided controller URL
+ * @async
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Promise<Object|null>} Object with token and controllerUrl, or null if failed
+ */
+async function getTokenFromUrl(controllerUrl) {
+  try {
+    const normalizedUrl = normalizeControllerUrl(controllerUrl);
+    const deviceToken = await getOrRefreshDeviceToken(normalizedUrl);
+    if (deviceToken && deviceToken.token) {
+      return {
+        token: deviceToken.token,
+        controllerUrl: deviceToken.controller || normalizedUrl
+      };
+    }
+  } catch (error) {
+    logger.error(chalk.red(`❌ Failed to authenticate with controller: ${controllerUrl}`));
+    logger.error(chalk.gray(`Error: ${error.message}`));
+    process.exit(1);
+  }
+  return null;
+}
+
+/**
+ * Validate and handle missing authentication token
+ * @param {string|null} token - Authentication token
+ * @param {string|null} controllerUrl - Controller URL
+ * @param {string} [providedUrl] - Original provided URL for error context
+ */
+function validateAuthToken(token, controllerUrl, providedUrl) {
+  if (!token || !controllerUrl) {
+    const formattedError = formatAuthenticationError({
+      controllerUrl: providedUrl || undefined,
+      message: 'No valid authentication found'
+    });
+    logger.error(formattedError);
+    process.exit(1);
+  }
+}
+
 /**
  * Get authentication token for rotation
  * @async
@@ -122,17 +226,10 @@ async function getRotationAuthToken(controllerUrl, config) {
 
   // If controller URL provided, try to get device token
   if (controllerUrl) {
-    try {
-      const normalizedUrl = normalizeControllerUrl(controllerUrl);
-      const deviceToken = await getOrRefreshDeviceToken(normalizedUrl);
-      if (deviceToken && deviceToken.token) {
-        token = deviceToken.token;
-        actualControllerUrl = deviceToken.controller || normalizedUrl;
-      }
-    } catch (error) {
-      logger.error(chalk.red(`❌ Failed to authenticate with controller: ${controllerUrl}`));
-      logger.error(chalk.gray(`Error: ${error.message}`));
-      process.exit(1);
+    const tokenResult = await getTokenFromUrl(controllerUrl);
+    if (tokenResult) {
+      token = tokenResult.token;
+      actualControllerUrl = tokenResult.controllerUrl;
     }
   }
 
@@ -145,15 +242,7 @@ async function getRotationAuthToken(controllerUrl, config) {
     }
   }
 
-  if (!token || !actualControllerUrl) {
-    const formattedError = formatAuthenticationError({
-      controllerUrl: controllerUrl || undefined,
-      message: 'No valid authentication found'
-    });
-    logger.error(formattedError);
-    process.exit(1);
-  }
-
+  validateAuthToken(token, actualControllerUrl, controllerUrl);
   return { token, actualControllerUrl };
 }
 
@@ -228,11 +317,8 @@ async function rotateSecret(appKey, options) {
       process.exit(1);
     }
 
-    // Validate response structure
-    validateResponse(response);
-
-    const credentials = response.data.credentials;
-    const message = response.data.message;
+    // Validate response structure and extract credentials
+    const { credentials, message } = validateResponse(response);
 
     // Save credentials locally
     await saveCredentialsLocally(appKey, credentials, actualControllerUrl);