@aifabrix/builder 2.32.1 → 2.32.3

package/lib/utils/error-formatter.js

@@ -10,45 +10,116 @@
  */
 
 /**
- * Formats a single validation error into a developer-friendly message
- *
- * @function formatSingleError
- * @param {Object} error - Raw validation error from Ajv
- * @returns {string} Formatted error message
+ * Maps common regex patterns to human-readable descriptions
+ * @type {Object.<string, string>}
  */
-function formatSingleError(error) {
-  // Handle empty or missing instancePath - use 'Configuration' for root level errors
+const PATTERN_DESCRIPTIONS = {
+  '^[a-z0-9-]+$': 'lowercase letters, numbers, and hyphens only',
+  '^[a-z0-9-:]+$': 'lowercase letters, numbers, hyphens, and colons only (e.g., "entity:action")',
+  '^[a-z-]+$': 'lowercase letters and hyphens only',
+  '^[A-Z_][A-Z0-9_]*$': 'uppercase letters, numbers, and underscores (must start with letter or underscore)',
+  '^[a-zA-Z0-9_-]+$': 'letters, numbers, hyphens, and underscores only',
+  '^(http|https)://.*$': 'valid HTTP or HTTPS URL',
+  '^/[a-z0-9/-]*$': 'URL path starting with / (lowercase letters, numbers, hyphens, slashes)'
+};
+
+/**
+ * Gets a human-readable description of a regex pattern
+ * @function getPatternDescription
+ * @param {string} pattern - The regex pattern
+ * @returns {string} Human-readable description
+ */
+function getPatternDescription(pattern) {
+  return PATTERN_DESCRIPTIONS[pattern] || `must match pattern: ${pattern}`;
+}
+
+/**
+ * Extracts the field name from an error's instancePath
+ * @function getFieldName
+ * @param {Object} error - Validation error object
+ * @returns {string} Formatted field name
+ */
+function getFieldName(error) {
   const instancePath = error.instancePath || '';
   const path = instancePath ? instancePath.slice(1) : '';
-  const field = path ? `Field "${path}"` : 'Configuration';
+  return path ? `Field "${path}"` : 'Configuration';
+}
 
-  // Check if params exists before accessing it
-  const errorMessages = {
-    required: error.params?.missingProperty
-      ? `${field}: Missing required property "${error.params.missingProperty}"`
+/**
+ * Formats a pattern validation error with the actual invalid value
+ * @function formatPatternError
+ * @param {string} field - Field name
+ * @param {Object} error - Validation error object
+ * @returns {string} Formatted error message
+ */
+function formatPatternError(field, error) {
+  const invalidValue = error.data !== undefined ? `"${error.data}"` : 'value';
+  const patternDesc = getPatternDescription(error.params?.pattern);
+  return `${field}: Invalid value ${invalidValue} - ${patternDesc}`;
+}
+
+/**
+ * Creates error message formatters for each validation keyword
+ * @function createKeywordFormatters
+ * @param {string} field - Field name
+ * @param {Object} error - Validation error object
+ * @returns {Object} Object mapping keywords to formatted messages
+ */
+function createKeywordFormatters(field, error) {
+  const params = error.params || {};
+
+  return {
+    required: params.missingProperty
+      ? `${field}: Missing required property "${params.missingProperty}"`
       : `${field}: Missing required property`,
-    type: error.params?.type
-      ? `${field}: Expected ${error.params.type}, got ${typeof error.data}`
+
+    type: params.type
+      ? `${field}: Expected ${params.type}, got ${typeof error.data}`
       : `${field}: Type error`,
-    minimum: error.params?.limit
-      ? `${field}: Value must be at least ${error.params.limit}`
+
+    minimum: params.limit !== undefined
+      ? `${field}: Value must be at least ${params.limit}`
       : `${field}: Value below minimum`,
-    maximum: error.params?.limit
-      ? `${field}: Value must be at most ${error.params.limit}`
+
+    maximum: params.limit !== undefined
+      ? `${field}: Value must be at most ${params.limit}`
       : `${field}: Value above maximum`,
-    minLength: error.params?.limit
-      ? `${field}: Must be at least ${error.params.limit} characters`
+
+    minLength: params.limit !== undefined
+      ? `${field}: Must be at least ${params.limit} characters`
       : `${field}: Too short`,
-    maxLength: error.params?.limit
-      ? `${field}: Must be at most ${error.params.limit} characters`
+
+    maxLength: params.limit !== undefined
+      ? `${field}: Must be at most ${params.limit} characters`
       : `${field}: Too long`,
-    pattern: `${field}: Invalid format`,
-    enum: error.params?.allowedValues && error.params.allowedValues.length > 0
-      ? `${field}: Must be one of: ${error.params.allowedValues.join(', ')}`
+
+    enum: params.allowedValues && params.allowedValues.length > 0
+      ? `${field}: Must be one of: ${params.allowedValues.join(', ')}`
       : `${field}: Must be one of: unknown`
   };
+}
 
-  return errorMessages[error.keyword] || `${field}: ${error.message || 'Validation error'}`;
+/**
+ * Formats a single validation error into a developer-friendly message
+ *
+ * @function formatSingleError
+ * @param {Object} error - Raw validation error from Ajv
+ * @returns {string} Formatted error message
+ */
+function formatSingleError(error) {
+  const field = getFieldName(error);
+
+  // Handle pattern errors with special formatting
+  if (error.keyword === 'pattern') {
+    return formatPatternError(field, error);
+  }
+
+  // Use object lookup for keyword-specific messages
+  const formatters = createKeywordFormatters(field, error);
+  const message = formatters[error.keyword];
+
+  // Return keyword message or fallback to generic message
+  return message || `${field}: ${error.message || 'Validation error'}`;
 }
 
 /**
@@ -73,6 +144,7 @@ function formatValidationErrors(errors) {
 
 module.exports = {
   formatSingleError,
-  formatValidationErrors
+  formatValidationErrors,
+  getPatternDescription,
+  PATTERN_DESCRIPTIONS
 };
-

package/lib/utils/token-manager.js

@@ -357,6 +357,64 @@ async function extractClientCredentials(authConfig, appKey, envKey, _options = {
   throw new Error('Invalid authentication type');
 }
 
+/**
+ * Force refresh device token for controller (regardless of local expiry time)
+ * Used when server returns 401 even though local token hasn't expired
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Promise<{token: string, controller: string}|null>} Token and controller URL, or null if not available
+ */
+async function forceRefreshDeviceToken(controllerUrl) {
+  // Try to get existing token to get refresh token
+  const tokenInfo = await getDeviceToken(controllerUrl);
+
+  if (!tokenInfo) {
+    return null;
+  }
+
+  // Must have refresh token to force refresh
+  if (!tokenInfo.refreshToken) {
+    logger.warn('Cannot refresh: no refresh token available. Please login again using: aifabrix login');
+    return null;
+  }
+
+  try {
+    const refreshed = await refreshDeviceToken(controllerUrl, tokenInfo.refreshToken);
+    return {
+      token: refreshed.token,
+      controller: controllerUrl
+    };
+  } catch (error) {
+    const errorMessage = error.message || String(error);
+    if (errorMessage.includes('Refresh token has expired')) {
+      logger.warn(`Refresh token expired: ${errorMessage}`);
+    } else {
+      logger.warn(`Failed to refresh device token: ${errorMessage}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Get device-only authentication for services that require user-level authentication.
+ * Used for interactive commands like wizard that don't support client credentials.
+ * @async
+ * @function getDeviceOnlyAuth
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Promise<Object>} Auth config with device token
+ * @throws {Error} If device token is not available
+ */
+async function getDeviceOnlyAuth(controllerUrl) {
+  const deviceToken = await getOrRefreshDeviceToken(controllerUrl);
+  if (deviceToken && deviceToken.token) {
+    return {
+      type: 'bearer',
+      token: deviceToken.token,
+      controller: deviceToken.controller
+    };
+  }
+  throw new Error('Device token authentication required. Run "aifabrix login" to authenticate.');
+}
+
 module.exports = {
   getDeviceToken,
   getClientToken,
@@ -367,7 +425,9 @@ module.exports = {
   loadClientCredentials,
   getOrRefreshClientToken,
   getOrRefreshDeviceToken,
+  forceRefreshDeviceToken,
   getDeploymentAuth,
+  getDeviceOnlyAuth,
   extractClientCredentials
 };
 

package/lib/validation/validator.js

@@ -296,7 +296,8 @@ function validateDeploymentJson(deployment) {
     };
   }
 
-  const ajv = new Ajv({ allErrors: true, strict: false });
+  // verbose: true includes the actual data value in error objects for better error messages
+  const ajv = new Ajv({ allErrors: true, strict: false, verbose: true });
   // Register external schemas with their $id (GitHub raw URLs)
   // Create copies to avoid modifying the original schemas
   const externalSystemSchemaCopy = { ...externalSystemSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.32.1",
+  "version": "2.32.3",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {

package/templates/applications/README.md.hbs

@@ -18,8 +18,8 @@ npm install -g @aifabrix/builder
 # Check your environment
 aifabrix doctor
 
-# Login to controller
-aifabrix login --method device --environment dev --offline --controller http://localhost:3000
+# Login to controller (offline tokens are default)
+aifabrix login --method device --environment dev --controller http://localhost:3000
 
 # Register your application (gets you credentials automatically)
 aifabrix app register {{appName}} --environment dev

package/templates/external-system/external-system.json.hbs

@@ -39,7 +39,7 @@
       "name": "{{name}}",
       "value": "{{value}}",
       "description": "{{description}}"{{#if Groups}},
-      "Groups": [{{#each Groups}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}]{{/if}}
+      "groups": [{{#each Groups}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}]{{/if}}
     }{{#unless @last}},{{/unless}}
     {{/each}}
   ]{{/if}}{{#if permissions}},