@aifabrix/builder 2.49.1 → 2.50.0

package/lib/datasource/test-e2e.js

@@ -40,6 +40,8 @@ function buildUnifiedE2eRunOptions(options, timeoutMs, pk) {
     minProcessed: options.minProcessed,
     minRecordCount: options.minRecordCount,
     capabilityKey: options.capabilityKey,
+    version: options.version,
+    syncMode: options.syncMode,
     timeout: timeoutMs,
     sync: options.sync === true,
     force: options.force === true,
@@ -114,10 +116,13 @@ function resolveE2ePollTimeoutMs(options) {
  * @returns {Object}
  */
 function buildE2eRequestMeta(datasourceKey, options, pk) {
+  const includeDebug = includeDebugForRequest(options.debug);
   return {
     datasourceKey,
     runType: 'e2e',
-    includeDebug: includeDebugForRequest(options.debug),
+    includeDebug,
+    explainCertification: includeDebug,
+    explainMetrics: includeDebug,
     cleanup: options.cleanup,
     runScenarios: options.runScenarios,
     primaryKeyValue: pk !== undefined && pk !== null,

package/lib/datasource/unified-validation-run-body.js

@@ -53,14 +53,17 @@ async function buildUnifiedValidationBody(params) {
       })
       : undefined;
 
+  const includeDebug = includeDebugForRequest(options.debug);
   const body = buildExternalDataSourceValidationRequest({
     systemKey,
     datasourceKey,
     runType,
     payloadTemplate,
     asyncRun: runType === 'e2e' && useAsync === true,
-    includeDebug: includeDebugForRequest(options.debug),
+    includeDebug,
     explain: options.verbose === true,
+    explainCertification: includeDebug,
+    explainMetrics: includeDebug,
     e2eOptions: e2eOptions && Object.keys(e2eOptions).length > 0 ? e2eOptions : undefined
   });
   return withStageOnValidationRunBody(body, runType);

package/lib/datasource/unified-validation-run.js

@@ -121,7 +121,7 @@ async function runUnifiedDatasourceValidation(datasourceKey, options) {
 
   const ctx = await prepareValidationRunContext(datasourceKey, options);
   const useAsync = options.noAsync ? false : options.async !== false;
-  const timeoutMs = parseInt(String(options.timeout || '30000'), 10) || 30000;
+  const timeoutMs = parseInt(String(options.timeout || '60000'), 10) || 60000;
   const body = await buildUnifiedValidationBody({
     systemKey: ctx.systemKey,
     datasourceKey,

package/lib/deployment/deploy-poll-ui.js

@@ -24,37 +24,98 @@ function shouldUseDeployPollSpinner() {
  */
 function createDeployPollHandlers(maxAttempts, options = {}) {
   const silent = options && options.silent === true;
+  const noop = () => {};
   if (silent) {
     return {
-      onPollProgress: () => {},
-      finish: () => {}
+      setText: noop,
+      onPollProgress: noop,
+      onPollWait: noop,
+      finish: noop
     };
   }
   if (shouldUseDeployPollSpinner()) {
-    const spinner = ora({
-      text: buildDeployPollSpinnerText(null, 0, maxAttempts),
-      spinner: 'dots'
-    }).start();
+    let spinner = null;
+    const ensureSpinner = (text) => {
+      if (!spinner) {
+        spinner = ora({
+          text,
+          spinner: 'dots'
+        }).start();
+        return;
+      }
+      spinner.text = text;
+    };
     return {
+      setText(text) {
+        ensureSpinner(text);
+      },
       onPollProgress: (deploymentData, attempt, maxA) => {
-        spinner.text = buildDeployPollSpinnerText(deploymentData, attempt, maxA);
+        ensureSpinner(buildDeployPollSpinnerText(deploymentData, attempt, maxA));
+      },
+      onPollWait: (attempt, maxA) => {
+        ensureSpinner(buildDeployPollWaitText(attempt, maxA));
       },
       finish: () => {
-        spinner.stop();
+        if (spinner) {
+          spinner.stop();
+        }
       }
     };
   }
   return {
+    setText: noop,
     onPollProgress: (deploymentData, attempt, maxA) => {
-      const status = deploymentData.status ?? 'pending';
-      const progress = deploymentData.progress ?? 0;
+      const status = deploymentData?.status ?? 'pending';
+      const progress =
+        deploymentData && Number.isFinite(Number(deploymentData.progress))
+          ? Number(deploymentData.progress)
+          : 0;
       logger.log(chalk.gray(`Status: ${status} (${progress}%) (attempt ${attempt + 1}/${maxA})`));
     },
-    finish: () => {}
+    onPollWait: noop,
+    finish: noop
   };
 }
 
+/**
+ * Plain progress while awaiting the next status poll (HTTP in flight).
+ * @param {number} attempt
+ * @param {number} maxAttempts
+ * @returns {string}
+ */
+function buildDeployPollWaitText(attempt, maxAttempts) {
+  return `Deploying application... Checking status (attempt ${attempt + 1}/${maxAttempts})`;
+}
+
+/**
+ * Run async deploy follow-up work with ora on TTY (post-controller finalize, etc.).
+ *
+ * @async
+ * @param {string} label
+ * @param {Function} work
+ * @param {{ silent?: boolean }} [opts]
+ * @returns {Promise<*>}
+ */
+async function runWithDeployPollSpinner(label, work, opts = {}) {
+  if (opts.silent === true) {
+    return work();
+  }
+  if (!shouldUseDeployPollSpinner()) {
+    logger.log(chalk.blue(`⏳ ${label}`));
+    return work();
+  }
+  const handlers = createDeployPollHandlers(1, { silent: false });
+  handlers.setText(label);
+  try {
+    return await work();
+  } finally {
+    handlers.finish();
+  }
+}
+
 module.exports = {
   createDeployPollHandlers,
-  shouldUseDeployPollSpinner
+  shouldUseDeployPollSpinner,
+  buildDeployPollWaitText,
+  runWithDeployPollSpinner
 };

package/lib/deployment/deployer-poll-run.js

@@ -0,0 +1,113 @@
+/**
+ * Controller deployment status polling (extracted from deployer.js for file size limits).
+ *
+ * @fileoverview Deploy pipeline poll loop
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { validateEnvironmentKey } = require('../utils/deployment-validation');
+const { getPipelineDeployment } = require('../api/pipeline.api');
+const {
+  convertToPipelineAuthConfig,
+  processDeploymentStatusResponse
+} = require('./deployer-status');
+const { resolvePollIntervalFromController } = require('./poll-interval');
+const { createDeployPollHandlers } = require('./deploy-poll-ui');
+
+/**
+ * Polls deployment status from controller.
+ *
+ * @async
+ * @param {string} deploymentId
+ * @param {string} controllerUrl
+ * @param {string} envKey
+ * @param {Object} authConfig
+ * @param {Object} [options]
+ * @returns {Promise<Object>}
+ */
+async function pollDeploymentStatus(deploymentId, controllerUrl, envKey, authConfig, options = {}) {
+  const interval = options.interval || 5000;
+  const maxAttempts = options.maxAttempts || 60;
+
+  const validatedEnvKey = validateEnvironmentKey(envKey);
+  const pipelineAuthConfig = convertToPipelineAuthConfig(authConfig);
+
+  const onPollProgress = typeof options.onPollProgress === 'function' ? options.onPollProgress : null;
+  const onPollWait = typeof options.onPollWait === 'function' ? options.onPollWait : null;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      if (onPollWait) {
+        onPollWait(attempt, maxAttempts);
+      }
+      const response = await getPipelineDeployment(controllerUrl, validatedEnvKey, deploymentId, pipelineAuthConfig);
+      const deploymentData = await processDeploymentStatusResponse(
+        response,
+        attempt,
+        maxAttempts,
+        interval,
+        deploymentId,
+        onPollProgress
+      );
+      if (deploymentData) {
+        return deploymentData;
+      }
+    } catch (error) {
+      if (error.message && error.message.includes('not found')) {
+        throw error;
+      }
+      throw error;
+    }
+  }
+
+  throw new Error('Deployment timeout: Maximum polling attempts reached');
+}
+
+/** Poll pipeline deployment to terminal status (TTY: ora spinner). */
+async function pollDeployment(result, url, validatedEnvKey, authConfig, options) {
+  if (!options.poll || !result.deploymentId) {
+    return result;
+  }
+
+  const resolvedInterval = await resolvePollIntervalFromController(url, options.pollInterval);
+  const maxAttempts = options.pollMaxAttempts || 60;
+  const ownsPollUi = !options.pollUi;
+  const pollUi =
+    options.pollUi ||
+    createDeployPollHandlers(maxAttempts, { silent: options.silentPoll === true });
+
+  if (ownsPollUi) {
+    logger.log('');
+  }
+
+  try {
+    const status = await pollDeploymentStatus(
+      result.deploymentId,
+      url,
+      validatedEnvKey,
+      authConfig,
+      {
+        interval: resolvedInterval,
+        maxAttempts,
+        onPollProgress: pollUi.onPollProgress,
+        onPollWait: pollUi.onPollWait
+      }
+    );
+
+    result.status = status;
+    return result;
+  } finally {
+    if (ownsPollUi) {
+      pollUi.finish();
+    }
+  }
+}
+
+module.exports = {
+  pollDeployment,
+  pollDeploymentStatus
+};

package/lib/deployment/deployer.js

@@ -15,16 +15,15 @@ const auditLogger = require('../core/audit-logger');
 const logger = require('../utils/logger');
 const { validateControllerUrl, validateEnvironmentKey } = require('../utils/deployment-validation');
 const { handleDeploymentError, handleDeploymentErrors } = require('../utils/deployment-errors');
-const { validatePipeline, deployPipeline, getPipelineDeployment } = require('../api/pipeline.api');
+const { validatePipeline, deployPipeline } = require('../api/pipeline.api');
 const { getAuthUser } = require('../api/auth.api');
 const { handleValidationResponse } = require('../utils/deployment-validation-helpers');
 const {
   convertToPipelineAuthConfig,
-  processDeploymentStatusResponse,
   isTokenOnlyPipelineAuth
 } = require('./deployer-status');
-const { resolvePollIntervalFromController } = require('./poll-interval');
 const { createDeployPollHandlers } = require('./deploy-poll-ui');
+const { pollDeployment, pollDeploymentStatus } = require('./deployer-poll-run');
 
 /**
  * For external systems, send full manifest (application + inline system + full dataSources).
@@ -274,52 +273,6 @@ async function sendDeploymentRequest(url, envKey, validateToken, authConfig, opt
   throwDeploymentError(lastError, maxRetries);
 }
 
-/**
- * Polls deployment status from controller
- * Uses pipeline endpoint for CI/CD monitoring with minimal deployment info
- *
- * @async
- * @param {string} deploymentId - Deployment ID to poll
- * @param {string} controllerUrl - Controller URL
- * @param {string} envKey - Environment key
- * @param {Object} authConfig - Authentication configuration
- * @param {Object} options - Polling options (interval, maxAttempts, etc.)
- * @returns {Promise<Object>} Deployment status
- */
-async function pollDeploymentStatus(deploymentId, controllerUrl, envKey, authConfig, options = {}) {
-  const interval = options.interval || 5000;
-  const maxAttempts = options.maxAttempts || 60;
-
-  const validatedEnvKey = validateEnvironmentKey(envKey);
-  const pipelineAuthConfig = convertToPipelineAuthConfig(authConfig);
-
-  const onPollProgress = typeof options.onPollProgress === 'function' ? options.onPollProgress : null;
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const response = await getPipelineDeployment(controllerUrl, validatedEnvKey, deploymentId, pipelineAuthConfig);
-      const deploymentData = await processDeploymentStatusResponse(
-        response,
-        attempt,
-        maxAttempts,
-        interval,
-        deploymentId,
-        onPollProgress
-      );
-      if (deploymentData) {
-        return deploymentData;
-      }
-    } catch (error) {
-      if (error.message && error.message.includes('not found')) {
-        throw error;
-      }
-      throw error;
-    }
-  }
-
-  throw new Error('Deployment timeout: Maximum polling attempts reached');
-}
-
 /**
  * When using bearer token only (no client credentials), verify token is valid before deploy.
  * @async
@@ -378,8 +331,9 @@ async function sendDeployment(url, validatedEnvKey, manifest, authConfig, option
     logger.log(metadata(`Draft Deployment ID: ${validateResult.draftDeploymentId}`));
   }
 
-  // Step 2: Deploy using validateToken (when not polling, show a clear line; otherwise poll phase uses ora)
-  if (options.poll === false) {
+  if (options.pollUi && typeof options.pollUi.setText === 'function') {
+    options.pollUi.setText('Submitting deployment to controller...');
+  } else if (options.poll === false) {
     logger.log(formatProgress('Deploying application...'));
   }
   const result = await sendDeploymentRequest(url, validatedEnvKey, validateResult.validateToken, authConfig, {
@@ -395,39 +349,6 @@ async function sendDeployment(url, validatedEnvKey, manifest, authConfig, option
   return result;
 }
 
-/** Poll pipeline deployment to terminal status (TTY: ora spinner). */
-async function pollDeployment(result, url, validatedEnvKey, authConfig, options) {
-  if (!options.poll || !result.deploymentId) {
-    return result;
-  }
-
-  // Separate validation/draft block from deploy polling (matches guided CLI spacing)
-  logger.log('');
-
-  const resolvedInterval = await resolvePollIntervalFromController(url, options.pollInterval);
-  const maxAttempts = options.pollMaxAttempts || 60;
-  const pollUi = createDeployPollHandlers(maxAttempts, { silent: options.silentPoll === true });
-
-  try {
-    const status = await pollDeploymentStatus(
-      result.deploymentId,
-      url,
-      validatedEnvKey,
-      authConfig,
-      {
-        interval: resolvedInterval,
-        maxAttempts,
-        onPollProgress: pollUi.onPollProgress
-      }
-    );
-
-    result.status = status;
-    return result;
-  } finally {
-    pollUi.finish();
-  }
-}
-
 /**
  * Deploys application to Miso Controller with authentication
  * Supports both Bearer token and client credentials authentication
@@ -464,16 +385,25 @@ async function deployToController(manifest, controllerUrl, envKey, authConfig, o
 
   const pipelineManifest = transformExternalManifestForPipeline(manifest);
 
+  const usePollUi = options.poll !== false && options.silentPoll !== true;
+  const pollUi = usePollUi
+    ? createDeployPollHandlers(options.pollMaxAttempts || 60, { silent: false })
+    : null;
+  const deployOpts = pollUi ? { ...options, pollUi } : options;
+
   try {
     // Send deployment request
-    const result = await sendDeployment(url, validatedEnvKey, pipelineManifest, authConfig, options);
+    const result = await sendDeployment(url, validatedEnvKey, pipelineManifest, authConfig, deployOpts);
 
     // Poll for deployment status if enabled
-    return await pollDeployment(result, url, validatedEnvKey, authConfig, options);
-
+    return await pollDeployment(result, url, validatedEnvKey, authConfig, deployOpts);
   } catch (error) {
     // Use unified error handler (already logged in deployToController, so pass alreadyLogged=true)
     await handleDeploymentErrors(error, manifest.key, url, false);
+  } finally {
+    if (pollUi) {
+      pollUi.finish();
+    }
   }
 }
 

package/lib/evidence/dataplane-context.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Dataplane auth/url resolution for evidence commands.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { resolveProtectionDataplaneContext } = require('../protection/auth-context');
+
+/**
+ * @param {Object} [options]
+ * @returns {Promise<{ environment: string, controllerUrl: string, dataplaneUrl: string, authConfig: Object }>}
+ */
+async function resolveEvidenceDataplaneContext(options = {}) {
+  return resolveProtectionDataplaneContext(options);
+}
+
+module.exports = {
+  resolveEvidenceDataplaneContext
+};

package/lib/evidence/evidence-display.js

@@ -0,0 +1,78 @@
+/**
+ * @fileoverview TTY display helpers for evidence commands.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { formatSuccessLine, headerKeyValue } = require('../utils/cli-layout-chalk');
+
+/**
+ * @param {string|null|undefined} roleKey
+ * @returns {string}
+ */
+function formatScopeLabel(roleKey) {
+  return roleKey && String(roleKey).trim() ? String(roleKey).trim() : 'Generic';
+}
+
+/**
+ * @param {Object[]} rows
+ * @returns {string}
+ */
+function formatEvidenceListTTY(rows) {
+  if (!rows.length) {
+    return chalk.gray('No evidence rows matched the filters.');
+  }
+  const lines = rows.map((row) => {
+    const scope = formatScopeLabel(row.roleKey);
+    return `${chalk.cyan(row.id)}  ${row.title}  ${chalk.gray(
+      `[${row.resourceType} · ${scope} · order ${row.order} · ${row.status}]`
+    )}`;
+  });
+  return `${headerKeyValue('Evidence rows', String(rows.length))}\n${lines.join('\n')}`;
+}
+
+/**
+ * @param {Object} row
+ * @returns {string}
+ */
+function formatEvidenceGetTTY(row) {
+  return [
+    headerKeyValue('Evidence', row.title),
+    `  id: ${row.id}`,
+    `  resourceType: ${row.resourceType}`,
+    `  scope: ${formatScopeLabel(row.roleKey)}`,
+    `  order: ${row.order}`,
+    `  status: ${row.status}`,
+    `  when: ${row.when}`,
+    `  expectedBehavior: ${row.expectedBehavior}`
+  ].join('\n');
+}
+
+/**
+ * @param {Object} summary
+ * @returns {string}
+ */
+function formatEvidenceLoadSummaryTTY(summary) {
+  return formatSuccessLine(
+    `Load complete — inserted ${summary.inserted}, updated ${summary.updated}, skipped ${summary.skipped}`
+  );
+}
+
+/**
+ * @param {Object} summary
+ * @returns {string}
+ */
+function formatEvidenceExportSummaryTTY(summary) {
+  return formatSuccessLine(`Exported ${summary.count} row(s) to ${summary.file}`);
+}
+
+module.exports = {
+  formatEvidenceListTTY,
+  formatEvidenceGetTTY,
+  formatEvidenceLoadSummaryTTY,
+  formatEvidenceExportSummaryTTY,
+  formatScopeLabel
+};