@aifabrix/builder 2.32.2 → 2.33.0

package/lib/core/config.js

@@ -95,6 +95,8 @@ function applyConfigDefaults(config) {
   if (typeof config.device !== 'object' || config.device === null) {
     config.device = {};
   }
+  // Ensure controller field exists (but don't set defaults)
+  // It will be set by login or auth config commands
   return config;
 }
 
@@ -107,6 +109,7 @@ function getDefaultConfig() {
   return {
     'developer-id': '0',
     environment: 'dev',
+    controller: undefined,
     environments: {},
     device: {}
   };
@@ -239,6 +242,17 @@ async function getCurrentEnvironment() {
   return config.environment || 'dev';
 }
 
+/**
+ * Resolve environment from configuration
+ * Uses config.environment, defaults to 'dev'
+ * @async
+ * @function resolveEnvironment
+ * @returns {Promise<string>} Environment key
+ */
+async function resolveEnvironment() {
+  return await getCurrentEnvironment();
+}
+
 async function setCurrentEnvironment(environment) {
   if (!environment || typeof environment !== 'string') {
     throw new Error('Environment must be a non-empty string');
@@ -248,6 +262,35 @@ async function setCurrentEnvironment(environment) {
   await saveConfig(config);
 }
 
+/**
+ * Set controller URL in configuration
+ * @async
+ * @function setControllerUrl
+ * @param {string} controllerUrl - Controller URL to save
+ * @returns {Promise<void>}
+ * @throws {Error} If controller URL is invalid
+ */
+async function setControllerUrl(controllerUrl) {
+  if (!controllerUrl || typeof controllerUrl !== 'string') {
+    throw new Error('Controller URL is required and must be a string');
+  }
+  const normalizedUrl = normalizeControllerUrl(controllerUrl);
+  const config = await getConfig();
+  config.controller = normalizedUrl;
+  await saveConfig(config);
+}
+
+/**
+ * Get controller URL from configuration
+ * @async
+ * @function getControllerUrl
+ * @returns {Promise<string|null>} Controller URL or null if not set
+ */
+async function getControllerUrl() {
+  const config = await getConfig();
+  return config.controller || null;
+}
+
 function isTokenExpired(expiresAt) {
   if (!expiresAt) return true;
   const expirationTime = new Date(expiresAt).getTime();
@@ -354,6 +397,7 @@ const exportsObj = {
   loadDeveloperId,
   getCurrentEnvironment,
   setCurrentEnvironment,
+  resolveEnvironment,
   isTokenExpired,
   shouldRefreshToken,
   encryptTokenValue,
@@ -363,6 +407,8 @@ const exportsObj = {
   getSecretsPath,
   setSecretsPath,
   normalizeControllerUrl,
+  setControllerUrl,
+  getControllerUrl,
   CONFIG_DIR,
   CONFIG_FILE
 };

package/lib/core/secrets.js

@@ -44,6 +44,7 @@ const {
 } = require('../utils/secrets-utils');
 const { decryptSecret, isEncrypted } = require('../utils/secrets-encryption');
 const pathsUtil = require('../utils/paths');
+const { getContainerPortFromPath } = require('../utils/port-resolver');
 
 /**
  * Generates a canonical secret name from an environment variable key.
@@ -253,26 +254,6 @@ function applyDockerEnvOverride(dockerEnv) {
   return dockerEnv;
 }
 
-/**
- * Gets container port from variables.yaml
- * @function getContainerPortFromVariables
- * @param {string} variablesPath - Path to variables.yaml
- * @returns {number|null} Container port or null
- */
-function getContainerPortFromVariables(variablesPath) {
-  if (!variablesPath || !fs.existsSync(variablesPath)) {
-    return null;
-  }
-  try {
-    const variablesContent = fs.readFileSync(variablesPath, 'utf8');
-    const variables = yaml.load(variablesContent);
-    // Use containerPort if specified, otherwise use base port (no developer-id offset)
-    return variables?.build?.containerPort || variables?.port || null;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Gets container port from docker environment config
  * @function getContainerPortFromDockerEnv
@@ -305,7 +286,7 @@ async function updatePortForDocker(resolved, variablesPath) {
   dockerEnv = applyDockerEnvOverride(dockerEnv);
 
   // Step 3: Get PORT value for container (should be container port, NOT host port)
-  let containerPort = getContainerPortFromVariables(variablesPath);
+  let containerPort = getContainerPortFromPath(variablesPath);
   if (containerPort === null) {
     containerPort = getContainerPortFromDockerEnv(dockerEnv);
   }
@@ -454,7 +435,7 @@ async function generateAdminSecretsEnv(secretsPath) {
 
   const adminSecrets = `# Infrastructure Admin Credentials
 POSTGRES_PASSWORD=${postgresPassword}
-PGADMIN_DEFAULT_EMAIL=admin@aifabrix.ai
+PGADMIN_DEFAULT_EMAIL=admin@aifabrix.dev
 PGADMIN_DEFAULT_PASSWORD=${postgresPassword}
 REDIS_HOST=local:redis:6379:0:
 REDIS_COMMANDER_USER=admin

package/lib/core/templates-env.js

@@ -104,7 +104,7 @@ function buildMonitoringEnv(config) {
   }
 
   return {
-    'MISO_CONTROLLER_URL': config.controllerUrl || 'https://controller.aifabrix.ai',
+    'MISO_CONTROLLER_URL': config.controllerUrl || 'https://controller.aifabrix.dev',
     'MISO_ENVIRONMENT': 'dev',
     'MISO_CLIENTID': 'kv://miso-controller-client-idKeyVault',
     'MISO_CLIENTSECRET': 'kv://miso-controller-client-secretKeyVault',

package/lib/datasource/deploy.js

@@ -40,14 +40,18 @@ async function getDataplaneUrl(controllerUrl, appKey, environment, authConfig) {
   }
 
   // Extract dataplane URL from application response
-  // This is a placeholder - actual response structure may vary
+  // Try multiple possible locations for the URL
   const application = response.data.data || response.data;
-  const dataplaneUrl = application.dataplaneUrl || application.dataplane?.url || application.configuration?.dataplaneUrl;
+  const dataplaneUrl = application.url ||
+    application.dataplaneUrl ||
+    application.dataplane?.url ||
+    application.configuration?.dataplaneUrl;
 
   if (!dataplaneUrl) {
-    logger.error(chalk.red('❌ Dataplane URL not found in application response'));
-    logger.error(chalk.gray('\nApplication response:'));
-    logger.error(chalk.gray(JSON.stringify(application, null, 2)));
+    const appType = application.configuration?.type || application.type;
+    if (appType === 'external') {
+      throw new Error('Dataplane URL not found for external system. Provide --dataplane <url>.');
+    }
     throw new Error('Dataplane URL not found in application configuration');
   }
 
@@ -61,19 +65,13 @@ async function getDataplaneUrl(controllerUrl, appKey, environment, authConfig) {
  * @param {Object} options - Options
  * @throws {Error} If validation fails
  */
-function validateDeploymentInputs(appKey, filePath, options) {
+function validateDeploymentInputs(appKey, filePath) {
   if (!appKey || typeof appKey !== 'string') {
     throw new Error('Application key is required');
   }
   if (!filePath || typeof filePath !== 'string') {
     throw new Error('File path is required');
   }
-  if (!options.controller) {
-    throw new Error('Controller URL is required (--controller)');
-  }
-  if (!options.environment) {
-    throw new Error('Environment is required (-e, --environment)');
-  }
 }
 
 /**
@@ -109,15 +107,18 @@ async function validateAndLoadDatasourceFile(filePath) {
  * @param {string} controllerUrl - Controller URL
  * @param {string} environment - Environment key
  * @param {string} appKey - Application key
+ * @param {Object} [options] - Options
+ * @param {string} [options.dataplane] - Dataplane URL override
  * @returns {Promise<Object>} Object with authConfig and dataplaneUrl
  */
 async function setupDeploymentAuth(controllerUrl, environment, appKey) {
+  const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
   logger.log(chalk.blue('🔐 Getting authentication...'));
   const authConfig = await getDeploymentAuth(controllerUrl, environment, appKey);
   logger.log(chalk.green('✓ Authentication successful'));
 
-  logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
-  const dataplaneUrl = await getDataplaneUrl(controllerUrl, appKey, environment, authConfig);
+  logger.log(chalk.blue('🌐 Resolving dataplane URL...'));
+  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
   logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
   return { authConfig, dataplaneUrl };
@@ -162,20 +163,30 @@ function displayDeploymentResults(datasourceConfig, systemKey, environment) {
 }
 
 /**
- * Deploys datasource to dataplane
+ * Deploys datasource to dataplane.
+ * Controller and environment come from config.yaml (set via aifabrix login or aifabrix auth config).
  *
  * @async
  * @function deployDatasource
  * @param {string} appKey - Application key
  * @param {string} filePath - Path to datasource JSON file
- * @param {Object} options - Deployment options
- * @param {string} options.controller - Controller URL
- * @param {string} options.environment - Environment key
+ * @param {Object} [_options] - Deployment options (reserved)
  * @returns {Promise<Object>} Deployment result
  * @throws {Error} If deployment fails
  */
-async function deployDatasource(appKey, filePath, options) {
-  validateDeploymentInputs(appKey, filePath, options);
+async function deployDatasource(appKey, filePath, _options) {
+  const { resolveControllerUrl } = require('../utils/controller-url');
+  const { resolveEnvironment } = require('../core/config');
+  const { displayCommandHeader } = require('../utils/command-header');
+
+  validateDeploymentInputs(appKey, filePath);
+
+  // Resolve controller and environment from config
+  const controllerUrl = await resolveControllerUrl();
+  const environment = await resolveEnvironment();
+
+  // Display command header
+  displayCommandHeader(controllerUrl, environment);
 
   logger.log(chalk.blue('📋 Deploying datasource...\n'));
 
@@ -189,19 +200,19 @@ async function deployDatasource(appKey, filePath, options) {
   }
 
   // Setup authentication and get dataplane URL
-  const { authConfig, dataplaneUrl } = await setupDeploymentAuth(options.controller, options.environment, appKey);
+  const { authConfig, dataplaneUrl } = await setupDeploymentAuth(controllerUrl, environment, appKey);
 
   // Publish to dataplane
   await publishDatasourceToDataplane(dataplaneUrl, systemKey, authConfig, datasourceConfig);
 
   // Display results
-  displayDeploymentResults(datasourceConfig, systemKey, options.environment);
+  displayDeploymentResults(datasourceConfig, systemKey, environment);
 
   return {
     success: true,
     datasourceKey: datasourceConfig.key,
     systemKey: systemKey,
-    environment: options.environment,
+    environment: environment,
     dataplaneUrl: dataplaneUrl
   };
 }

package/lib/datasource/list.js

@@ -9,7 +9,7 @@
  */
 
 const chalk = require('chalk');
-const { getConfig } = require('../core/config');
+const { getConfig, resolveEnvironment } = require('../core/config');
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
 const { listEnvironmentDatasources } = require('../api/environments.api');
 const { formatApiError } = require('../utils/api-error-handler');
@@ -130,8 +130,7 @@ function displayDatasources(datasources, environment) {
  *
  * @async
  * @function listDatasources
- * @param {Object} options - Command options
- * @param {string} options.environment - Environment ID or key
+ * @param {Object} _options - Command options (unused, kept for compatibility)
  * @throws {Error} If listing fails
  */
 /**
@@ -190,9 +189,12 @@ function handleDatasourceApiError(response) {
   process.exit(1);
 }
 
-async function listDatasources(options) {
+async function listDatasources(_options) {
   const config = await getConfig();
 
+  // Resolve environment from config.yaml (no flags)
+  const environment = await resolveEnvironment();
+
   // Try to get device token
   const authInfo = await getDeviceTokenFromConfig(config);
   validateDatasourceListingAuth(authInfo?.token, authInfo?.controllerUrl);
@@ -204,7 +206,7 @@ async function listDatasources(options) {
     return; // Never reached, but satisfies linter
   }
   const authConfig = { type: 'bearer', token: authInfo.token };
-  const response = await listEnvironmentDatasources(authInfo.controllerUrl, options.environment, authConfig);
+  const response = await listEnvironmentDatasources(authInfo.controllerUrl, environment, authConfig);
 
   if (!response.success || !response.data) {
     handleDatasourceApiError(response);
@@ -212,7 +214,7 @@ async function listDatasources(options) {
   }
 
   const datasources = extractDatasources(response);
-  displayDatasources(datasources, options.environment);
+  displayDatasources(datasources, environment);
 }
 
 module.exports = {

package/lib/deployment/deployer.js

@@ -52,6 +52,27 @@ async function buildValidationData(manifest, validatedEnvKey, authConfig, option
   return { validationData, pipelineAuthConfig };
 }
 
+/**
+ * Handle authentication errors during validation
+ * @param {Error} error - Error object
+ * @param {string} appKey - Application key
+ * @throws {Error} Enhanced authentication error
+ */
+function handleValidationAuthError(error, appKey) {
+  if (error.status === 401 || (error.response && error.response.status === 401)) {
+    const authError = new Error(
+      `Authentication failed: Invalid or expired credentials for application '${appKey}'.\n` +
+      'The provided Client ID and Client Secret are incorrect or have been revoked.\n\n' +
+      '💡 If the application already exists, rotate the secret:\n' +
+      `   aifabrix app rotate-secret ${appKey}\n\n` +
+      '💡 Otherwise, ensure credentials are correct in ~/.aifabrix/secrets.local.yaml or use --client-id and --client-secret flags.'
+    );
+    authError.status = 401;
+    authError.originalError = error;
+    throw authError;
+  }
+}
+
 /**
  * Validates deployment configuration via validate endpoint
  * This is the first step in the deployment process
@@ -79,6 +100,10 @@ async function validateDeployment(url, envKey, manifest, authConfig, options = {
       return handleValidationResponse(response);
     } catch (error) {
       lastError = error;
+
+      // Handle authentication errors (401) - credentials are invalid, not missing
+      handleValidationAuthError(error, manifest.key);
+
       const shouldRetry = attempt < maxRetries && error.status && error.status >= 500;
       if (shouldRetry) {
         const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);

package/lib/deployment/environment.js

@@ -12,6 +12,7 @@
 const chalk = require('chalk');
 const logger = require('../utils/logger');
 const config = require('../core/config');
+const { resolveControllerUrl } = require('../utils/controller-url');
 const { validateControllerUrl, validateEnvironmentKey } = require('../utils/deployment-validation');
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
 const { getEnvironmentStatus } = require('../api/environments.api');
@@ -266,27 +267,19 @@ function displayDeploymentResults(result) {
  * @throws {Error} If deployment fails
  *
  * @example
- * await deployEnvironment('dev', { controller: 'https://controller.aifabrix.ai' });
+ * await deployEnvironment('dev', { controller: 'https://controller.aifabrix.dev' });
  */
 /**
- * Validates deployment input parameters
+ * Validates deployment input parameters (environment key only).
+ * Controller URL is resolved from config.yaml via resolveControllerUrl().
  * @function validateDeploymentInput
  * @param {string} envKey - Environment key
- * @param {Object} options - Deployment options
- * @returns {string} Controller URL
  * @throws {Error} If validation fails
  */
-function validateDeploymentInput(envKey, options) {
+function validateDeploymentInput(envKey) {
   if (!envKey || typeof envKey !== 'string' || envKey.trim().length === 0) {
     throw new Error('Environment key is required');
   }
-
-  const controllerUrl = options.controller || options['controller-url'];
-  if (!controllerUrl) {
-    throw new Error('Controller URL is required. Use --controller flag');
-  }
-
-  return controllerUrl;
 }
 
 /**
@@ -365,7 +358,11 @@ async function pollDeploymentStatusIfEnabled(result, validatedControllerUrl, env
 
 async function deployEnvironment(envKey, options = {}) {
   try {
-    const controllerUrl = validateDeploymentInput(envKey, options);
+    validateDeploymentInput(envKey);
+    const controllerUrl = await resolveControllerUrl();
+    if (!controllerUrl) {
+      throw new Error('Controller URL is required. Run "aifabrix login" to set the controller URL in config.yaml');
+    }
     const authConfig = await prepareEnvironmentDeployment(envKey, controllerUrl, options);
 
     const validatedControllerUrl = validateControllerUrl(authConfig.controller);

package/lib/external-system/delete.js

@@ -0,0 +1,151 @@
+/**
+ * External System Delete Module
+ *
+ * Deletes external systems from dataplane and confirms before removal.
+ *
+ * @fileoverview External system delete functionality for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const logger = require('../utils/logger');
+const { getDeploymentAuth } = require('../utils/token-manager');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { getExternalSystemConfig, deleteExternalSystem } = require('../api/external-systems.api');
+
+/**
+ * Validates system key format
+ * @param {string} systemKey - System key to validate
+ */
+function validateSystemKey(systemKey) {
+  if (!systemKey || typeof systemKey !== 'string') {
+    throw new Error('System key is required and must be a string');
+  }
+  if (!/^[a-z0-9-_]+$/.test(systemKey)) {
+    throw new Error('System key must contain only lowercase letters, numbers, hyphens, and underscores');
+  }
+}
+
+/**
+ * Gets dataplane URL and authentication configuration
+ * @async
+ * @param {string} systemKey - System key
+ * @param {Object} options - Command options
+ * @returns {Promise<Object>} Auth and dataplane details
+ */
+async function getAuthAndDataplane(systemKey, _options) {
+  const { resolveEnvironment } = require('../core/config');
+  const environment = await resolveEnvironment();
+  const controllerUrl = await resolveControllerUrl();
+  const authConfig = await getDeploymentAuth(controllerUrl, environment, systemKey);
+
+  if (!authConfig.token && !authConfig.clientId) {
+    throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
+  }
+
+  const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
+  logger.log(chalk.blue('🌐 Resolving dataplane URL...'));
+  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+  logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+
+  return { authConfig, dataplaneUrl, environment, controllerUrl };
+}
+
+/**
+ * Fetches external system configuration for warning display
+ * @async
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {string} systemKey - System key
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} System config response data
+ */
+async function fetchExternalSystemConfig(dataplaneUrl, systemKey, authConfig) {
+  const response = await getExternalSystemConfig(dataplaneUrl, systemKey, authConfig);
+  if (!response || response.success === false) {
+    throw new Error(response?.error || response?.formattedError || `External system '${systemKey}' not found`);
+  }
+  return response.data?.data || response.data || {};
+}
+
+/**
+ * Formats datasources for warning output
+ * @param {Array} dataSources - Datasource objects
+ * @returns {string[]} Datasource labels
+ */
+function formatDatasourceList(dataSources) {
+  if (!Array.isArray(dataSources)) {
+    return [];
+  }
+  return dataSources
+    .map(ds => ds.key || ds.displayName || 'unknown-datasource')
+    .filter(Boolean);
+}
+
+/**
+ * Prompts for delete confirmation if needed
+ * @async
+ * @param {string} systemKey - System key
+ * @param {string[]} datasources - Datasource keys
+ * @param {Object} options - Command options
+ * @returns {Promise<boolean>} True if confirmed
+ */
+async function confirmDeletion(systemKey, datasources, options) {
+  if (options.yes || options.force) {
+    return true;
+  }
+
+  logger.log(chalk.yellow(`\n⚠️  Warning: Deleting external system '${systemKey}' will also delete all associated datasources:`));
+  if (datasources.length > 0) {
+    datasources.forEach(ds => logger.log(chalk.yellow(` - ${ds}`)));
+  } else {
+    logger.log(chalk.yellow(' - (no datasources found)'));
+  }
+
+  const answer = await inquirer.prompt([{
+    type: 'input',
+    name: 'confirm',
+    message: `Are you sure you want to delete external system '${systemKey}'? (yes/no):`,
+    default: 'no'
+  }]);
+
+  return String(answer.confirm).trim().toLowerCase() === 'yes';
+}
+
+/**
+ * Deletes an external system from dataplane
+ * @async
+ * @function deleteExternalSystemCommand
+ * @param {string} systemKey - System key
+ * @param {Object} options - Command options
+ * @returns {Promise<void>}
+ * @throws {Error} If deletion fails or is cancelled
+ */
+async function deleteExternalSystemCommand(systemKey, options = {}) {
+  validateSystemKey(systemKey);
+
+  const { authConfig, dataplaneUrl } = await getAuthAndDataplane(systemKey, options);
+  const configData = await fetchExternalSystemConfig(dataplaneUrl, systemKey, authConfig);
+  const dataSources = formatDatasourceList(configData.dataSources || []);
+
+  const confirmed = await confirmDeletion(systemKey, dataSources, options);
+  if (!confirmed) {
+    logger.log(chalk.yellow('Deletion cancelled.'));
+    return;
+  }
+
+  const response = await deleteExternalSystem(dataplaneUrl, systemKey, authConfig);
+  if (!response || response.success === false) {
+    throw new Error(response?.error || response?.formattedError || `Failed to delete external system '${systemKey}'`);
+  }
+
+  logger.log(chalk.green(`✓ External system '${systemKey}' deleted successfully`));
+  logger.log(chalk.green('✓ All associated datasources have been removed'));
+}
+
+module.exports = {
+  deleteExternalSystem: deleteExternalSystemCommand
+};