@aifabrix/builder 2.44.4 → 2.44.6

package/lib/api/integration-clients.api.js

@@ -0,0 +1,168 @@
+/**
+ * @fileoverview Integration clients API (Controller /api/v1/integration-clients)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { ApiClient } = require('./index');
+
+const BASE = '/api/v1/integration-clients';
+
+/**
+ * Create integration client; returns one-time clientSecret
+ * @requiresPermission {Controller} integration-client:create
+ * @async
+ * @function createIntegrationClient
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration (bearer or client-credentials)
+ * @param {Object} body - Request body
+ * @param {string} body.key - Key (required)
+ * @param {string} body.displayName - Display name (required)
+ * @param {string[]} body.redirectUris - Redirect URIs (required, min 1)
+ * @param {string[]} [body.groupNames] - Group names (optional)
+ * @param {string} [body.description] - Optional description
+ * @param {string} [body.keycloakClientId] - Optional Keycloak client id
+ * @returns {Promise<Object>} API response
+ * @throws {Error} If request fails
+ */
+async function createIntegrationClient(controllerUrl, authConfig, body) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  const payload = {
+    key: body.key,
+    displayName: body.displayName,
+    redirectUris: body.redirectUris,
+    groupNames: Array.isArray(body.groupNames) ? body.groupNames : []
+  };
+  if (body.description !== undefined && body.description !== null && body.description !== '') {
+    payload.description = body.description;
+  }
+  if (body.keycloakClientId) {
+    payload.keycloakClientId = body.keycloakClientId;
+  }
+  return await client.post(BASE, { body: payload });
+}
+
+/**
+ * List integration clients
+ * @requiresPermission {Controller} integration-client:read
+ * @async
+ * @function listIntegrationClients
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} [options] - Query options
+ * @param {number} [options.page] - Page number
+ * @param {number} [options.pageSize] - Page size
+ * @param {string} [options.sort] - Sort
+ * @param {string} [options.filter] - Filter
+ * @param {string} [options.search] - Search
+ * @returns {Promise<Object>} API response
+ * @throws {Error} If request fails
+ */
+async function listIntegrationClients(controllerUrl, authConfig, options = {}) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  const params = {};
+  if (options.page !== undefined && options.page !== null) params.page = options.page;
+  if (options.pageSize !== undefined && options.pageSize !== null) params.pageSize = options.pageSize;
+  if (options.sort) params.sort = options.sort;
+  if (options.filter) params.filter = options.filter;
+  if (options.search) params.search = options.search;
+  return await client.get(BASE, { params });
+}
+
+/**
+ * Get integration client by id
+ * @requiresPermission {Controller} integration-client:read
+ * @async
+ * @function getIntegrationClient
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} id - Integration client id
+ * @returns {Promise<Object>} API response
+ * @throws {Error} If request fails
+ */
+async function getIntegrationClient(controllerUrl, authConfig, id) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.get(`${BASE}/${encodeURIComponent(id)}`);
+}
+
+/**
+ * Regenerate client secret (shown once)
+ * @requiresPermission {Controller} integration-client:update
+ * @async
+ * @function regenerateIntegrationClientSecret
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} id - Integration client id
+ * @returns {Promise<Object>} API response
+ * @throws {Error} If request fails
+ */
+async function regenerateIntegrationClientSecret(controllerUrl, authConfig, id) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.post(`${BASE}/${encodeURIComponent(id)}/regenerate-secret`);
+}
+
+/**
+ * Deactivate integration client
+ * @requiresPermission {Controller} integration-client:delete
+ * @async
+ * @function deleteIntegrationClient
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} id - Integration client id
+ * @returns {Promise<Object>} API response
+ * @throws {Error} If request fails
+ */
+async function deleteIntegrationClient(controllerUrl, authConfig, id) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.delete(`${BASE}/${encodeURIComponent(id)}`);
+}
+
+/**
+ * Replace group memberships
+ * @requiresPermission {Controller} integration-client:update
+ * @async
+ * @function updateIntegrationClientGroups
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} id - Integration client id
+ * @param {Object} body - Body with groupNames
+ * @param {string[]} body.groupNames - Group names
+ * @returns {Promise<Object>} API response
+ * @throws {Error} If request fails
+ */
+async function updateIntegrationClientGroups(controllerUrl, authConfig, id, body) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.put(`${BASE}/${encodeURIComponent(id)}/groups`, {
+    body: { groupNames: body.groupNames }
+  });
+}
+
+/**
+ * Replace redirect URIs
+ * @requiresPermission {Controller} integration-client:update
+ * @async
+ * @function updateIntegrationClientRedirectUris
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} id - Integration client id
+ * @param {Object} body - Body with redirectUris
+ * @param {string[]} body.redirectUris - Redirect URIs (min 1)
+ * @returns {Promise<Object>} API response
+ * @throws {Error} If request fails
+ */
+async function updateIntegrationClientRedirectUris(controllerUrl, authConfig, id, body) {
+  const client = new ApiClient(controllerUrl, authConfig);
+  return await client.put(`${BASE}/${encodeURIComponent(id)}/redirect-uris`, {
+    body: { redirectUris: body.redirectUris }
+  });
+}
+
+module.exports = {
+  createIntegrationClient,
+  listIntegrationClients,
+  getIntegrationClient,
+  regenerateIntegrationClientSecret,
+  deleteIntegrationClient,
+  updateIntegrationClientGroups,
+  updateIntegrationClientRedirectUris
+};

package/lib/api/types/dimension-values.types.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Dimension values API type definitions (Controller)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Create dimension value payload
+ * @typedef {Object} DimensionValueCreateRequest
+ * @property {string} value
+ * @property {string} [displayName]
+ * @property {string} [description]
+ */
+
+/**
+ * Dimension value entity
+ * @typedef {Object} DimensionValue
+ * @property {string} id
+ * @property {string} dimensionId
+ * @property {string} value
+ * @property {string|null} [displayName]
+ * @property {string|null} [description]
+ * @property {string|null} [createdBy]
+ * @property {string|null} [updatedBy]
+ * @property {string} [createdAt]
+ * @property {string} [updatedAt]
+ */
+

package/lib/api/types/dimensions.types.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Dimensions API type definitions (Controller)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Dimension create/update payload (Controller catalog)
+ * @typedef {Object} DimensionCreateRequest
+ * @property {string} key
+ * @property {string} displayName
+ * @property {string} [description]
+ * @property {'string'|'number'|'boolean'} dataType
+ * @property {boolean} [isRequired]
+ */
+
+/**
+ * Dimension entity
+ * @typedef {Object} Dimension
+ * @property {string} id
+ * @property {string} key
+ * @property {string} displayName
+ * @property {string|null} [description]
+ * @property {'string'|'number'|'boolean'} dataType
+ * @property {boolean} isRequired
+ * @property {string|null} [createdBy]
+ * @property {string|null} [updatedBy]
+ * @property {string} [createdAt]
+ * @property {string} [updatedAt]
+ */
+

package/lib/api/types/integration-clients.types.js

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Integration clients API type definitions (Controller camelCase)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Integration client create request body (builder → controller)
+ * @typedef {Object} IntegrationClientCreateRequest
+ * @property {string} key - Stable key (lowercase alphanumeric + hyphens)
+ * @property {string} displayName - Human-readable name
+ * @property {string[]} redirectUris - Allowed redirect URIs for OAuth2 (min 1)
+ * @property {string[]} [groupNames] - Optional group names (RBAC); omit or empty for OAuth-only clients
+ * @property {string} [description] - Optional description
+ * @property {string} [keycloakClientId] - Optional fixed Keycloak client id
+ */
+
+/**
+ * Create response (clientSecret is one-time-only)
+ * @typedef {Object} IntegrationClientCreateResponseData
+ * @property {Object} [integrationClient] - Created record
+ * @property {string} [integrationClient.id] - Integration client id
+ * @property {string} [integrationClient.key] - Key
+ * @property {string} [integrationClient.displayName] - Display name
+ * @property {string} [integrationClient.keycloakClientId] - OAuth client id in Keycloak
+ * @property {string} [integrationClient.status] - Status
+ * @property {string} [clientSecret] - One-time secret
+ */
+
+/**
+ * Single integration client in list response
+ * @typedef {Object} ListIntegrationClientItem
+ * @property {string} id - Integration client id
+ * @property {string} [key] - Key
+ * @property {string} [displayName] - Display name
+ * @property {string} [keycloakClientId] - OAuth client id
+ * @property {string} [status] - Status (e.g. active)
+ */
+
+/**
+ * Regenerate secret response
+ * @typedef {Object} RegenerateIntegrationClientSecretResponse
+ * @property {Object} [data] - Nested data
+ * @property {string} [data.clientSecret] - New secret (one-time)
+ */

package/lib/api/types/wizard.types.js

@@ -260,12 +260,13 @@
  * @property {string} [source.serverUrl] - MCP server URL (for mcp-server)
  * @property {string} [source.token] - MCP token (for mcp-server, supports ${ENV_VAR})
  * @property {string} [source.platform] - Known platform (for known-platform)
+ * @property {string} [source.entityName] - Entity from discover-entities (openapi-file / openapi-url); skips interactive Step 4.5 when valid
  * @property {Object} [credential] - Credential configuration
  * @property {string} credential.action - Action ('create' | 'select' | 'skip')
  * @property {string} [credential.credentialIdOrKey] - Credential ID/key (for select)
  * @property {Object} [credential.config] - Credential config (for create)
  * @property {Object} [preferences] - Generation preferences
- * @property {string} [preferences.intent] - User intent (any descriptive text)
+ * @property {string} [preferences.intent] - User intent (any descriptive text, max 1000 chars)
  * @property {string} [preferences.fieldOnboardingLevel] - Field level ('full' | 'standard' | 'minimal')
  * @property {boolean} [preferences.enableOpenAPIGeneration] - Enable OpenAPI generation
  * @property {boolean} [preferences.enableMCP] - Enable MCP

package/lib/api/validation-runner.js

@@ -9,6 +9,8 @@
 const { extractTestRunId } = require('./validation-run.api');
 const { postValidationRunWithTransportRetry } = require('../utils/validation-run-post-retry');
 const { pollValidationRunUntilComplete } = require('../utils/validation-run-poll');
+const { createValidationPollHandlers } = require('../utils/validation-poll-ui');
+const logger = require('../utils/logger');
 
 /**
  * POST /api/v1/validation/run and (when async) poll GET until reportCompleteness is full.
@@ -20,6 +22,8 @@ const { pollValidationRunUntilComplete } = require('../utils/validation-run-poll
  * @param {number} opts.timeoutMs
  * @param {boolean} opts.useAsync
  * @param {boolean} opts.noAsync
+ * @param {boolean} [opts.verbosePoll] - Throttled poll lines when no TTY poll UI (see validation-run-poll)
+ * @param {Function} [opts.onPollProgress] - Extra hook: `(envelope, attemptIndex, meta)` during poll
  * @returns {Promise<{ envelope: Object|null, apiError: Object|null, pollTimedOut: boolean, incompleteNoAsync: boolean }>}
  */
 /* eslint-disable max-lines-per-function, max-statements, complexity -- POST + poll orchestration */
@@ -54,31 +58,48 @@ async function postValidationRunAndOptionalPoll(opts) {
   if (needsPoll && testRunId) {
     const elapsed = Date.now() - started;
     const remaining = Math.max(0, timeoutMs - elapsed);
-    const pollResult = await pollValidationRunUntilComplete({
-      dataplaneUrl,
-      authConfig,
-      testRunId,
-      budgetMs: remaining,
-      verbosePoll: verbosePoll === true,
-      pollRequestTimeoutMs:
-        Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined
-    });
-    if (!pollResult.lastApiResult || !pollResult.lastApiResult.success) {
-      return {
-        envelope: pollResult.envelope,
-        apiError: pollResult.lastApiResult,
-        pollTimedOut: pollResult.timedOut,
-        incompleteNoAsync: false
-      };
-    }
-    envelope = pollResult.envelope;
-    if (pollResult.timedOut) {
-      return {
-        envelope,
-        apiError: null,
-        pollTimedOut: true,
-        incompleteNoAsync: false
-      };
+    const deadlineMs = Date.now() + remaining;
+
+    logger.log('');
+    const pollUi = createValidationPollHandlers(deadlineMs);
+    const mergeOnPollProgress =
+      typeof opts.onPollProgress === 'function'
+        ? (envelope, attemptIndex, meta) => {
+          pollUi.onPollProgress(envelope, attemptIndex, meta);
+          opts.onPollProgress(envelope, attemptIndex, meta);
+        }
+        : pollUi.onPollProgress;
+
+    try {
+      const pollResult = await pollValidationRunUntilComplete({
+        dataplaneUrl,
+        authConfig,
+        testRunId,
+        budgetMs: remaining,
+        verbosePoll: verbosePoll === true,
+        pollRequestTimeoutMs:
+          Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined,
+        onPollProgress: mergeOnPollProgress
+      });
+      if (!pollResult.lastApiResult || !pollResult.lastApiResult.success) {
+        return {
+          envelope: pollResult.envelope,
+          apiError: pollResult.lastApiResult,
+          pollTimedOut: pollResult.timedOut,
+          incompleteNoAsync: false
+        };
+      }
+      envelope = pollResult.envelope;
+      if (pollResult.timedOut) {
+        return {
+          envelope,
+          apiError: null,
+          pollTimedOut: true,
+          incompleteNoAsync: false
+        };
+      }
+    } finally {
+      pollUi.finish();
     }
   }
 

package/lib/app/deploy-config.js

@@ -62,11 +62,21 @@ async function extractDeploymentConfig(options, _variables) {
   const controllerUrl = await resolveControllerUrl();
   const envKey = await resolveEnvironment();
 
+  const pollIntervalExplicit =
+    options.pollInterval !== undefined && options.pollInterval !== null
+      ? Number(options.pollInterval)
+      : undefined;
+
   return {
     controllerUrl,
     envKey,
     poll: options.poll !== false,
-    pollInterval: options.pollInterval || 5000,
+    // When true, polling still happens but is not rendered (no nested ora spinner).
+    // Used by guided installers which already show a top-level spinner.
+    silentPoll: options.silentPoll === true,
+    repositoryUrl: options.repositoryUrl,
+    // Omit default here so deployer can resolve 2s vs 5s from controller deploymentType (GET /api/v1/health)
+    pollInterval: Number.isFinite(pollIntervalExplicit) ? pollIntervalExplicit : undefined,
     pollMaxAttempts: options.pollMaxAttempts || 60
   };
 }

package/lib/app/deploy-status-display.js

@@ -5,8 +5,8 @@
  * @version 2.0.0
  */
 
-const chalk = require('chalk');
 const logger = require('../utils/logger');
+const { formatSuccessLine, metadata } = require('../utils/cli-test-layout-chalk');
 const { getApplicationStatus } = require('../api/applications.api');
 
 /**
@@ -69,9 +69,9 @@ async function displayAppUrlFromController(controllerUrl, envKey, appKey, authCo
     url = buildAppUrlFromControllerAndPort(controllerUrl, port);
   }
   if (url) {
-    logger.log(chalk.green(`   ✔ App running at ${url}`));
+    logger.log(formatSuccessLine(`App running at ${url}`));
   } else {
-    logger.log(chalk.blue('   ✔ App deployed. Get URL from controller dashboard.'));
+    logger.log(metadata('App deployed. Resolve URL from the controller dashboard.'));
   }
 }
 

package/lib/app/deploy.js

@@ -1,4 +1,10 @@
-const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+const {
+  formatSuccessLine,
+  formatSuccessParagraph,
+  sectionTitle,
+  headerKeyValue,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder Application Deployment Module
  *
@@ -13,6 +19,8 @@ const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test
 const fs = require('fs').promises;
 const chalk = require('chalk');
 const pushUtils = require('../deployment/push');
+
+const SEP = chalk.gray('────────────────────────────────────────');
 const logger = require('../utils/logger');
 const { detectAppType, getBuilderPath, getIntegrationPath } = require('../utils/paths');
 const { checkApplicationExists } = require('../utils/app-existence');
@@ -156,7 +164,10 @@ async function pushApp(appName, options = {}) {
  * @throws {Error} If generation or validation fails
  */
 async function generateAndValidateManifest(appName, options = {}) {
-  logger.log(chalk.blue(`\n📋 Generating deployment manifest for ${appName}...`));
+  logger.log('');
+  logger.log(sectionTitle('Deployment manifest'));
+  logger.log(SEP);
+  logger.log(metadata(`Generating manifest for ${appName}...`));
   const generator = require('../generator');
 
   // generateDeployJson already validates against schema and throws on error
@@ -175,10 +186,10 @@ async function generateAndValidateManifest(appName, options = {}) {
  */
 function displayDeploymentInfo(manifest, manifestPath) {
   logger.log(formatSuccessLine(`Manifest generated: ${manifestPath}`));
-  logger.log(chalk.blue(`   Key: ${manifest.key}`));
-  logger.log(chalk.blue(`   Display Name: ${manifest.displayName}`));
-  logger.log(chalk.blue(`   Image: ${manifest.image}`));
-  logger.log(chalk.blue(`   Port: ${manifest.port}`));
+  logger.log(headerKeyValue('Key:', manifest.key));
+  logger.log(headerKeyValue('Display Name:', manifest.displayName));
+  logger.log(headerKeyValue('Image:', manifest.image));
+  logger.log(headerKeyValue('Port:', String(manifest.port)));
 }
 
 /**
@@ -189,7 +200,11 @@ function displayDeploymentInfo(manifest, manifestPath) {
  * @returns {Promise<Object>} Deployment result
  */
 async function executeDeployment(manifest, deploymentConfig) {
-  logger.log(chalk.blue(`\n🚀 Deploying to ${deploymentConfig.controllerUrl} (environment: ${deploymentConfig.envKey})...`));
+  logger.log('');
+  logger.log(sectionTitle('Deploy to controller'));
+  logger.log(SEP);
+  logger.log(headerKeyValue('URL:', deploymentConfig.controllerUrl));
+  logger.log(headerKeyValue('Environment:', deploymentConfig.envKey));
   const deployer = require('../deployment/deployer');
   return await deployer.deployToController(
     manifest,
@@ -199,7 +214,9 @@ async function executeDeployment(manifest, deploymentConfig) {
     {
       poll: deploymentConfig.poll,
       pollInterval: deploymentConfig.pollInterval,
-      pollMaxAttempts: deploymentConfig.pollMaxAttempts
+      pollMaxAttempts: deploymentConfig.pollMaxAttempts,
+      repositoryUrl: deploymentConfig.repositoryUrl,
+      silentPoll: deploymentConfig.silentPoll === true
     }
   );
 }
@@ -209,17 +226,22 @@ async function executeDeployment(manifest, deploymentConfig) {
  * @param {Object} result - Deployment result
  */
 function displayDeploymentResults(result) {
-  logger.log(chalk.green('\n✅ Deployment initiated successfully'));
+  logger.log(formatSuccessParagraph('Deployment initiated successfully'));
   if (result.deploymentUrl) {
-    logger.log(chalk.blue(`   URL: ${result.deploymentUrl}`));
+    logger.log(headerKeyValue('URL:', result.deploymentUrl));
   }
   if (result.deploymentId) {
-    logger.log(chalk.blue(`   Deployment ID: ${result.deploymentId}`));
+    logger.log(headerKeyValue('Deployment ID:', result.deploymentId));
   }
   if (result.status) {
-    const statusIcon = result.status.status === 'completed' ? '✔' :
-      result.status.status === 'failed' ? '✖' : '⏳';
-    logger.log(chalk.blue(`   Status: ${statusIcon} ${result.status.status}`));
+    const st = result.status.status;
+    const statusText =
+      st === 'completed'
+        ? formatSuccessLine(st)
+        : st === 'failed' || st === 'cancelled'
+          ? chalk.red(`✖ ${st}`)
+          : chalk.yellow(`⏳ ${st}`);
+    logger.log(`${chalk.gray('Status:')} ${statusText}`);
   }
 }
 

package/lib/app/display.js

@@ -1,4 +1,4 @@
-const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+const { formatNextActions, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 /**
  * Application Display Utilities
  *
@@ -24,11 +24,13 @@ const logger = require('../utils/logger');
 function displayExternalSystemSuccess(appName, config, location) {
   logger.log(chalk.blue('Type: External System'));
   logger.log(chalk.blue(`System Key: ${config.systemKey || appName}`));
-  logger.log(chalk.green('\nNext steps:'));
-  logger.log(chalk.white('1. Edit external system JSON files in ' + location));
-  logger.log(chalk.white('2. Run: aifabrix validate ' + appName));
-  logger.log(chalk.white('3. Run: aifabrix login'));
-  logger.log(chalk.white('4. Run: aifabrix deploy ' + appName));
+  logger.log('');
+  logger.log(formatNextActions([
+    `Edit external system JSON files in ${location}`,
+    `Run: aifabrix validate ${appName}`,
+    'Run: aifabrix login',
+    `Run: aifabrix deploy ${appName}`
+  ]));
 }
 
 /**
@@ -49,11 +51,13 @@ function displayWebappSuccess(appName, config, envConversionMessage) {
 
   logger.log(chalk.gray(envConversionMessage));
 
-  logger.log(chalk.green('\nNext steps:'));
-  logger.log(chalk.white('1. Copy env.template to .env and fill in your values'));
-  logger.log(chalk.white('2. Run: aifabrix up-infra'));
-  logger.log(chalk.white('3. Run: aifabrix build ' + appName));
-  logger.log(chalk.white('4. Run: aifabrix run ' + appName));
+  logger.log('');
+  logger.log(formatNextActions([
+    'Copy env.template to .env and fill in your values',
+    'Run: aifabrix up-infra',
+    `Run: aifabrix build ${appName}`,
+    `Run: aifabrix run ${appName}`
+  ]));
 }
 
 /**