@aifabrix/builder 2.32.3 → 2.33.1

package/lib/commands/auth-config.js

@@ -0,0 +1,125 @@
+/**
+ * Authentication Configuration Commands
+ *
+ * Handles setting controller, environment, and dataplane URLs in config.yaml
+ *
+ * @fileoverview Authentication configuration commands
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const {
+  setControllerUrl,
+  setCurrentEnvironment,
+  getControllerUrl
+} = require('../core/config');
+const {
+  validateControllerUrl,
+  validateEnvironment,
+  checkUserLoggedIn
+} = require('../utils/auth-config-validator');
+const logger = require('../utils/logger');
+
+/**
+ * Handle set-controller command
+ * @async
+ * @function handleSetController
+ * @param {string} url - Controller URL to set
+ * @returns {Promise<void>}
+ * @throws {Error} If validation fails
+ */
+async function handleSetController(url) {
+  try {
+    // Validate URL format
+    validateControllerUrl(url);
+
+    // Check if user is logged in to that controller
+    const isLoggedIn = await checkUserLoggedIn(url);
+    if (!isLoggedIn) {
+      throw new Error(
+        `You are not logged in to controller ${url}.\n` +
+        'Please run "aifabrix login" first to authenticate with this controller.'
+      );
+    }
+
+    // Save controller URL
+    await setControllerUrl(url);
+
+    logger.log(chalk.green(`✓ Controller URL set to: ${url}`));
+  } catch (error) {
+    logger.error(chalk.red(`✗ Failed to set controller URL: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Handle set-environment command
+ * @async
+ * @function handleSetEnvironment
+ * @param {string} environment - Environment key to set
+ * @returns {Promise<void>}
+ * @throws {Error} If validation fails
+ */
+async function handleSetEnvironment(environment) {
+  try {
+    // Validate environment format
+    validateEnvironment(environment);
+
+    // Get current controller from config
+    const controllerUrl = await getControllerUrl();
+    if (!controllerUrl) {
+      throw new Error(
+        'No controller URL found in config.\n' +
+        'Please run "aifabrix login" first to set the controller URL.'
+      );
+    }
+
+    // Check if user is logged in to that controller
+    const isLoggedIn = await checkUserLoggedIn(controllerUrl);
+    if (!isLoggedIn) {
+      throw new Error(
+        `You are not logged in to controller ${controllerUrl}.\n` +
+        'Please run "aifabrix login" first to authenticate with this controller.'
+      );
+    }
+
+    // Save environment
+    await setCurrentEnvironment(environment);
+
+    logger.log(chalk.green(`✓ Environment set to: ${environment}`));
+  } catch (error) {
+    logger.error(chalk.red(`✗ Failed to set environment: ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Handle auth config command
+ * @async
+ * @function handleAuthConfig
+ * @param {Object} options - Command options
+ * @param {string} [options.setController] - Controller URL to set
+ * @param {string} [options.setEnvironment] - Environment to set
+ * @returns {Promise<void>}
+ * @throws {Error} If command fails
+ */
+async function handleAuthConfig(options) {
+  if (!options.setController && !options.setEnvironment) {
+    throw new Error(
+      'No action specified. Use one of:\n' +
+      '  --set-controller <url>\n' +
+      '  --set-environment <env>'
+    );
+  }
+  if (options.setController) {
+    await handleSetController(options.setController);
+  }
+  if (options.setEnvironment) {
+    await handleSetEnvironment(options.setEnvironment);
+  }
+}
+
+module.exports = {
+  handleAuthConfig
+};

package/lib/commands/auth-status.js

@@ -11,7 +11,7 @@
 const chalk = require('chalk');
 const logger = require('../utils/logger');
 const config = require('../core/config');
-const { getConfig, getCurrentEnvironment } = config;
+const { getConfig } = config;
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
 const { getAuthUser } = require('../api/auth.api');
 const { resolveControllerUrl } = require('../utils/controller-url');
@@ -236,17 +236,16 @@ function displayStatus(controllerUrl, environment, tokenInfo) {
 
 /**
  * Handle auth status command
+ * Controller and environment come from config.yaml (set via aifabrix login or aifabrix auth config).
  * @async
  * @function handleAuthStatus
- * @param {Object} options - Command options
- * @param {string} [options.controller] - Controller URL (uses developer ID-based default if not provided)
- * @param {string} [options.environment] - Environment key (uses current environment from config if not provided)
+ * @param {Object} _options - Command options (unused; controller/environment from config only)
  * @returns {Promise<void>} Resolves when status is displayed
  */
-async function handleAuthStatus(options) {
-  const configData = await getConfig();
-  const controllerUrl = await resolveControllerUrl(options, configData);
-  const environment = options.environment || await getCurrentEnvironment() || 'dev';
+async function handleAuthStatus(_options) {
+  const { resolveEnvironment } = require('../core/config');
+  const controllerUrl = await resolveControllerUrl();
+  const environment = await resolveEnvironment();
 
   // Check device token first (preferred)
   let tokenInfo = await checkDeviceToken(controllerUrl);

package/lib/commands/datasource.js

@@ -50,11 +50,10 @@ function setupDatasourceCommands(program) {
   // List command
   datasource
     .command('list')
-    .description('List datasources from environment')
-    .requiredOption('-e, --environment <env>', 'Environment ID or key')
-    .action(async(options) => {
+    .description('List datasources from environment (uses environment from config.yaml)')
+    .action(async() => {
       try {
-        await listDatasources(options);
+        await listDatasources({});
       } catch (error) {
         logger.error(chalk.red('❌ Failed to list datasources:'), error.message);
         process.exit(1);
@@ -78,8 +77,6 @@ function setupDatasourceCommands(program) {
   datasource
     .command('deploy <myapp> <file>')
     .description('Deploy datasource to dataplane')
-    .requiredOption('--controller <url>', 'Controller URL')
-    .requiredOption('-e, --environment <env>', 'Environment (miso, dev, tst, pro)')
     .action(async(myapp, file, options) => {
       try {
         await deployDatasource(myapp, file, options);

package/lib/commands/login-credentials.js

@@ -54,7 +54,7 @@ async function promptForCredentials(clientId, clientSecret) {
       message: 'Client ID:',
       default: clientId || '',
       validate: (input) => {
-        const value = input.trim();
+        const value = input ? input.trim() : '';
         if (!value || value.length === 0) {
           return 'Client ID is required';
         }
@@ -68,7 +68,7 @@ async function promptForCredentials(clientId, clientSecret) {
       default: clientSecret || '',
       mask: '*',
       validate: (input) => {
-        const value = input.trim();
+        const value = input ? input.trim() : '';
         if (!value || value.length === 0) {
           return 'Client Secret is required';
         }
@@ -78,8 +78,8 @@ async function promptForCredentials(clientId, clientSecret) {
   ]);
 
   return {
-    clientId: credentials.clientId.trim(),
-    clientSecret: credentials.clientSecret.trim()
+    clientId: (credentials.clientId || '').trim(),
+    clientSecret: (credentials.clientSecret || '').trim()
   };
 }
 

package/lib/commands/login-device.js

@@ -11,7 +11,7 @@
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 const ora = require('ora');
-const { setCurrentEnvironment, saveDeviceToken } = require('../core/config');
+const { setCurrentEnvironment, saveDeviceToken, setControllerUrl } = require('../core/config');
 const { initiateDeviceCodeFlow } = require('../api/auth.api');
 const { pollDeviceCodeToken, displayDeviceCodeInfo } = require('../utils/api');
 const logger = require('../utils/logger');
@@ -68,6 +68,30 @@ async function saveDeviceLoginConfig(controllerUrl, token, refreshToken, expires
   await saveDeviceToken(controllerUrl, token, refreshToken, expiresAt);
 }
 
+/**
+ * Save token configuration and display success message
+ * @async
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} token - Access token
+ * @param {string} refreshToken - Refresh token
+ * @param {string} expiresAt - Token expiration time
+ * @param {string} envKey - Environment key
+ * @returns {Promise<void>}
+ */
+async function saveTokenAndDisplaySuccess(controllerUrl, token, refreshToken, expiresAt, envKey) {
+  await saveDeviceLoginConfig(controllerUrl, token, refreshToken, expiresAt);
+  await setControllerUrl(controllerUrl);
+  if (envKey) {
+    await setCurrentEnvironment(envKey);
+  }
+  logger.log(chalk.green('\n✅ Successfully logged in!'));
+  logger.log(chalk.gray(`Controller: ${controllerUrl}`));
+  if (envKey) {
+    logger.log(chalk.gray(`Environment: ${envKey}`));
+  }
+  logger.log(chalk.gray('Token stored securely in ~/.aifabrix/config.yaml\n'));
+}
+
 /**
  * Poll for device code token and save configuration
  * @async
@@ -105,23 +129,8 @@ async function pollAndSaveDeviceCodeToken(controllerUrl, deviceCode, interval, e
     const refreshToken = tokenResponse.refresh_token;
     const expiresAt = new Date(Date.now() + (tokenResponse.expires_in * 1000)).toISOString();
 
-    // Save device token at root level (controller-specific, not environment-specific)
-    await saveDeviceLoginConfig(controllerUrl, token, refreshToken, expiresAt);
-
-    // Still set current environment if provided (for other purposes)
-    if (envKey) {
-      await setCurrentEnvironment(envKey);
-    }
-
-    logger.log(chalk.green('\n✅ Successfully logged in!'));
-    logger.log(chalk.gray(`Controller: ${controllerUrl}`));
-    if (envKey) {
-      logger.log(chalk.gray(`Environment: ${envKey}`));
-    }
-    logger.log(chalk.gray('Token stored securely in ~/.aifabrix/config.yaml\n'));
-
+    await saveTokenAndDisplaySuccess(controllerUrl, token, refreshToken, expiresAt, envKey);
     return { token, environment: envKey };
-
   } catch (pollError) {
     spinner.fail('Authentication failed');
     throw pollError;

package/lib/commands/login.js

@@ -11,11 +11,11 @@
 
 const inquirer = require('inquirer');
 const chalk = require('chalk');
-const { setCurrentEnvironment, saveClientToken } = require('../core/config');
+const { setCurrentEnvironment, saveClientToken, setControllerUrl } = require('../core/config');
 const logger = require('../utils/logger');
 const { handleCredentialsLogin } = require('./login-credentials');
 const { handleDeviceCodeLogin } = require('./login-device');
-const { getDefaultControllerUrl } = require('../utils/controller-url');
+const { resolveControllerUrl } = require('../utils/controller-url');
 
 /**
  * Determine and validate authentication method
@@ -62,7 +62,7 @@ async function saveCredentialsLoginConfig(controllerUrl, token, expiresAt, envir
  * @async
  * @function handleLogin
  * @param {Object} options - Login options
- * @param {string} [options.controller] - Controller URL (default: calculated based on developer ID, e.g., 'http://localhost:3000' for dev ID 0, 'http://localhost:3100' for dev ID 1)
+ * @param {string} [options.controller] - Controller URL (default: from config, device tokens, or developer ID)
  * @param {string} [options.method] - Authentication method ('device' or 'credentials', default: 'device')
  * @param {string} [options.app] - Application name (for credentials method, reads from secrets.local.yaml)
  * @param {string} [options.clientId] - Client ID (for credentials method, overrides secrets.local.yaml)
@@ -72,8 +72,7 @@ async function saveCredentialsLoginConfig(controllerUrl, token, expiresAt, envir
  * @throws {Error} If login fails
  */
 /**
- * Normalizes and logs controller URL
- * Calculates default URL based on developer ID if not provided
+ * Resolves and logs controller URL from --controller, config, device tokens, or developer-ID default
  * @async
  * @function normalizeControllerUrl
  * @param {Object} options - Login options
@@ -82,9 +81,11 @@ async function saveCredentialsLoginConfig(controllerUrl, token, expiresAt, envir
 async function normalizeControllerUrl(options) {
   let controllerUrl = options.controller || options.url;
   if (!controllerUrl) {
-    controllerUrl = await getDefaultControllerUrl();
+    controllerUrl = await resolveControllerUrl();
   }
-  controllerUrl = controllerUrl.replace(/\/$/, '');
+  controllerUrl = String(controllerUrl).replace(/\/+$/, '');
+  // Save controller URL to config
+  await setControllerUrl(controllerUrl);
   logger.log(chalk.gray(`Controller URL: ${controllerUrl}`));
   return controllerUrl;
 }
@@ -144,11 +145,12 @@ async function handleCredentialsLoginFlow(controllerUrl, environment, options) {
  * @async
  * @function handleDeviceCodeLoginFlow
  * @param {string} controllerUrl - Controller URL
+ * @param {string} environment - Resolved environment key (from config or -e/--environment)
  * @param {Object} options - Login options
  * @returns {Promise<{token: string, environment: string}>} Login result
  */
-async function handleDeviceCodeLoginFlow(controllerUrl, options) {
-  return await handleDeviceCodeLogin(controllerUrl, options.environment, options.online, options.scope);
+async function handleDeviceCodeLoginFlow(controllerUrl, environment, options) {
+  return await handleDeviceCodeLogin(controllerUrl, environment, options.online, options.scope);
 }
 
 async function handleLogin(options) {
@@ -163,7 +165,7 @@ async function handleLogin(options) {
   if (method === 'credentials') {
     await handleCredentialsLoginFlow(controllerUrl, environment, options);
   } else if (method === 'device') {
-    await handleDeviceCodeLoginFlow(controllerUrl, options);
+    await handleDeviceCodeLoginFlow(controllerUrl, environment, options);
     return; // Early return for device flow (already saved config)
   }
 

package/lib/commands/wizard-config-normalizer.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Normalize wizard-generated configs before validation
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const ENTITY_TYPE_FALLBACK = 'record-storage';
+const VALID_ENTITY_TYPES = new Set([
+  'document-storage',
+  'documentStorage',
+  'vector-store',
+  'vectorStore',
+  'record-storage',
+  'recordStorage',
+  'message-service',
+  'messageService',
+  'none'
+]);
+const VALID_PORTAL_FIELDS = new Set(['text', 'textarea', 'select', 'json', 'boolean', 'number']);
+
+/**
+ * Normalize system config fields to schema constraints
+ * @function normalizeSystemConfig
+ * @param {Object} systemConfig - External system config
+ * @returns {Object} Normalized config
+ */
+function normalizeSystemConfig(systemConfig) {
+  if (!systemConfig || typeof systemConfig !== 'object') {
+    return systemConfig;
+  }
+  if (typeof systemConfig.description === 'string' && systemConfig.description.length > 500) {
+    systemConfig.description = systemConfig.description.slice(0, 500);
+  }
+  return systemConfig;
+}
+
+/**
+ * Normalize datasource config fields to schema constraints
+ * @function normalizeDatasourceConfig
+ * @param {Object} datasourceConfig - Datasource config
+ * @returns {Object} Normalized config
+ */
+function normalizeDatasourceConfig(datasourceConfig) {
+  if (!datasourceConfig || typeof datasourceConfig !== 'object') {
+    return datasourceConfig;
+  }
+  if (datasourceConfig.entityType && !VALID_ENTITY_TYPES.has(datasourceConfig.entityType)) {
+    datasourceConfig.entityType = ENTITY_TYPE_FALLBACK;
+  }
+  if (Array.isArray(datasourceConfig.portalInput)) {
+    datasourceConfig.portalInput = datasourceConfig.portalInput.filter(item => {
+      if (!item || typeof item !== 'object') {
+        return false;
+      }
+      if (!item.name || !item.field || !item.label) {
+        return false;
+      }
+      return VALID_PORTAL_FIELDS.has(item.field);
+    });
+  }
+  if (datasourceConfig.execution?.cip?.operations) {
+    for (const operation of Object.values(datasourceConfig.execution.cip.operations)) {
+      if (!operation || !Array.isArray(operation.steps)) {
+        continue;
+      }
+      for (const step of operation.steps) {
+        if (step?.output?.mode && step.output.mode !== 'records') {
+          step.output.mode = 'records';
+        }
+      }
+    }
+  }
+  return datasourceConfig;
+}
+
+/**
+ * Normalize system and datasource configs
+ * @function normalizeWizardConfigs
+ * @param {Object} systemConfig - System config
+ * @param {Object|Object[]} datasourceConfigs - Datasource config(s)
+ * @returns {{ systemConfig: Object, datasourceConfigs: Object[] }} Normalized configs
+ */
+function normalizeWizardConfigs(systemConfig, datasourceConfigs) {
+  const normalizedSystem = normalizeSystemConfig(systemConfig);
+  const configs = Array.isArray(datasourceConfigs) ? datasourceConfigs : [datasourceConfigs];
+  const normalizedDatasources = configs.map(normalizeDatasourceConfig);
+  return { systemConfig: normalizedSystem, datasourceConfigs: normalizedDatasources };
+}
+
+module.exports = {
+  normalizeWizardConfigs
+};