@aifabrix/builder 2.49.1 → 2.50.0

package/lib/commands/upload-credential-push-log.js

@@ -0,0 +1,117 @@
+/**
+ * Credential + runtime config push with compact/verbose logging for upload publish.
+ *
+ * @fileoverview Upload credential push helpers
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
+const { pushCredentialSecrets } = require('../utils/credential-secrets-env');
+const { runWithCredentialPushSpinner } = require('../utils/credential-push-ui');
+const { collectResolvedVariableConfigurationNames } = require('../utils/configuration-env-resolver');
+const { pushRuntimeConfigurationValues } = require('../utils/runtime-configuration-values');
+
+/**
+ * @param {Object} pushResult
+ * @param {string[]} resolvedParamNames
+ * @param {boolean} quietLog
+ */
+function logCredentialPushOutcome(pushResult, resolvedParamNames, quietLog) {
+  if (quietLog) {
+    return;
+  }
+  if (pushResult.pushed > 0) {
+    const keyList = pushResult.keys?.length ? ` (${pushResult.keys.join(', ')})` : '';
+    logger.log(
+      formatSuccessLine(`Pushed ${pushResult.pushed} credential secret(s) to dataplane${keyList}.`)
+    );
+  } else {
+    logger.log(chalk.yellow('Secret push skipped'));
+  }
+  if (resolvedParamNames.length > 0) {
+    const nameList = ` (${resolvedParamNames.join(', ')})`;
+    logger.log(
+      formatSuccessLine(
+        `Resolved ${resolvedParamNames.length} integration parameter(s) from .env for publish${nameList}.`
+      )
+    );
+  }
+  if (pushResult.warning) {
+    logger.log(chalk.yellow(`Warning: ${pushResult.warning}`));
+  }
+}
+
+/**
+ * @async
+ * @returns {Promise<{ pushed: number, names: string[] }>}
+ */
+async function pushRuntimeConfigWithLog(dataplaneUrl, authConfig, systemKey, payload, quietLog) {
+  try {
+    const configPush = await pushRuntimeConfigurationValues(dataplaneUrl, authConfig, systemKey, payload);
+    if (configPush.pushed > 0 && !quietLog) {
+      const nameList = configPush.names.length ? ` (${configPush.names.join(', ')})` : '';
+      logger.log(
+        formatSuccessLine(
+          `Stored ${configPush.pushed} runtime configuration value(s) in dataplane${nameList}.`
+        )
+      );
+    }
+    return configPush;
+  } catch (err) {
+    if (!quietLog) {
+      logger.log(chalk.yellow(`Warning: runtime configuration store skipped: ${err.message}`));
+    }
+    return { pushed: 0, names: [] };
+  }
+}
+
+/**
+ * Pushes credential secrets from .env and payload to dataplane; logs result or warning.
+ *
+ * @async
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} systemKey
+ * @param {Object} payload
+ * @param {Object} [uiOpts]
+ * @returns {Promise<Object>}
+ */
+async function pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey, payload, uiOpts = {}) {
+  const pathOptions = uiOpts.pathOptions || {};
+  const envFilePath = path.join(resolveExternalSystemPath(systemKey, pathOptions), '.env');
+  const pushResult = await runWithCredentialPushSpinner(
+    () =>
+      pushCredentialSecrets(dataplaneUrl, authConfig, {
+        envFilePath,
+        appName: systemKey,
+        payload
+      }),
+    { systemKey, json: uiOpts.json === true }
+  );
+  const resolvedParamNames = collectResolvedVariableConfigurationNames(payload);
+  const quietLog = uiOpts.suppressCredentialLog === true;
+  logCredentialPushOutcome(pushResult, resolvedParamNames, quietLog);
+  const configPush = await pushRuntimeConfigWithLog(
+    dataplaneUrl,
+    authConfig,
+    systemKey,
+    payload,
+    quietLog
+  );
+  return {
+    credentialPush: { pushed: pushResult.pushed || 0, keys: pushResult.keys || [] },
+    configPush,
+    resolvedParamNames
+  };
+}
+
+module.exports = {
+  pushAndLogCredentialSecrets
+};

package/lib/commands/upload-data-sync-finalize.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Finalize upload with optional datasource data sync.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { runPostPublishDataSync } = require('./run-post-publish-data-sync');
+const { runUploadSidecarFollowups } = require('./upload-sidecar-followups');
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
+const logger = require('../utils/logger');
+const { isQuietMinimalSync } = require('../utils/upload-sync-options');
+
+/**
+ * @async
+ * @param {Object} ctx
+ * @param {Object} payload
+ * @param {Object} options
+ * @returns {Promise<Object>}
+ */
+async function finalizeUploadPublishResult(ctx, payload, options) {
+  const dataSync = await runPostPublishDataSync({
+    dataplaneUrl: ctx.dataplaneUrl,
+    authConfig: ctx.authConfig,
+    payload,
+    options,
+    label: 'Upload data sync'
+  });
+  return { ...ctx, dataSync };
+}
+
+/**
+ * @async
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function finishUnchangedUploadPublication(params) {
+  const { systemKey, options, payload, dataplaneUrl, authConfig, environment } = params;
+  if (!isQuietMinimalSync(options)) {
+    logger.log(formatSuccessLine('Config unchanged on dataplane — upload skipped.'));
+  }
+  await runUploadSidecarFollowups({
+    systemKey,
+    options,
+    payload,
+    dataplaneUrl,
+    authConfig
+  });
+  return finalizeUploadPublishResult(
+    { dataplaneUrl, authConfig, environment, uploadSkipped: true },
+    payload,
+    options
+  );
+}
+
+module.exports = {
+  finalizeUploadPublishResult,
+  finishUnchangedUploadPublication
+};

package/lib/commands/upload-probe.js

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Optional upload-time runtime probe (--probe).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { testSystemViaPipeline } = require('../api/pipeline.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const { logProbeRuntimeBlock, SEP } = require('../utils/external-system-readiness-display');
+const { formatProgress, sectionTitle } = require('../utils/cli-test-layout-chalk');
+const logger = require('../utils/logger');
+
+/** Omit payloadTemplate so POST /validation/run uses the validation-engine path. */
+const UPLOAD_PROBE_TEST_DATA = {};
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {string} systemKey
+ * @param {Object} authConfig
+ * @param {number|undefined} probeTimeoutMs
+ * @param {{ compact?: boolean }} [opts]
+ * @returns {Promise<Object|null>}
+ */
+async function maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, probeTimeoutMs, opts = {}) {
+  const compact = opts.compact === true;
+  if (!compact) {
+    logger.log('');
+    logger.log(sectionTitle('Runtime checks (--probe)'));
+    logger.log(SEP);
+    logger.log(formatProgress('Running runtime checks...'));
+  }
+  const timeoutMs = probeTimeoutMs === undefined || probeTimeoutMs === null ? 120000 : probeTimeoutMs;
+  try {
+    const pr = await testSystemViaPipeline(
+      dataplaneUrl,
+      systemKey,
+      authConfig,
+      UPLOAD_PROBE_TEST_DATA,
+      { timeout: timeoutMs }
+    );
+    if (pr.success === false) {
+      if (!compact) {
+        logger.log(chalk.yellow(`⚠ Probe request failed: ${pr.formattedError || pr.error || 'unknown error'}`));
+      }
+      return null;
+    }
+    const probeData = unwrapApiData(pr);
+    if (!compact) {
+      logProbeRuntimeBlock(probeData, systemKey);
+    }
+    return probeData;
+  } catch (e) {
+    if (!compact) {
+      logger.log(chalk.yellow(`⚠ Probe failed: ${e.message}`));
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  maybeRunUploadProbe,
+  UPLOAD_PROBE_TEST_DATA
+};

package/lib/commands/upload-publish-context.js

@@ -51,7 +51,10 @@ async function resolveUploadPublishContext(
   payload
 ) {
   const resolved = await resolveDataplaneAndAuth(systemKey, {
-    silent: options.silentResolve === true
+    silent: options.silentResolve === true,
+    authConfig: options.authConfig,
+    dataplaneUrl: options.dataplaneUrl,
+    environment: options.environment
   });
   requireBearerForDataplanePipeline(resolved.authConfig);
   if (options.force === true) {

package/lib/commands/upload-sidecar-followups.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Upload sidecar follow-ups (governance packs, certification sync).
+ * @fileoverview Upload sidecar follow-ups (governance scenario packs).
  * @author AI Fabrix Team
  * @version 1.0.0
  */
@@ -10,19 +10,16 @@ const logger = require('../utils/logger');
 const { formatWarningLine } = require('../utils/cli-test-layout-chalk');
 const { unwrapPublicationResult, isPublicationUnchanged } = require('../utils/external-system-readiness-core');
 const { logUploadReadinessSummary } = require('../utils/external-system-readiness-display');
-const { maybeSyncSystemCertificationFromDataplane } = require('../certification/sync-system-certification');
-const { cliOptsSkipCertSync } = require('../certification/cli-cert-sync-skip');
 const { isQuietMinimalSync } = require('../utils/upload-sync-options');
 
 /**
- * Sidecar follow-ups that are independent of pipeline publish hash (scenario packs, cert sync).
+ * Sidecar follow-ups that are independent of pipeline publish hash (scenario packs).
  * @param {Object} ctx
  * @returns {Promise<void>}
  */
 async function runUploadSidecarFollowups(ctx) {
-  const { systemKey, options, payload, dataplaneUrl, authConfig } = ctx;
+  const { systemKey, options, dataplaneUrl, authConfig } = ctx;
   const quietSidecar = isQuietMinimalSync(options);
-  const dsKeys = (payload.dataSources || []).map((ds) => ds && ds.key).filter(Boolean);
   try {
     const { uploadGovernanceScenarioPacks } = require('../lifecycle/scenario-upload');
     await uploadGovernanceScenarioPacks(systemKey, dataplaneUrl, authConfig, { silent: quietSidecar });
@@ -31,15 +28,30 @@ async function runUploadSidecarFollowups(ctx) {
       logger.log(formatWarningLine(`Governance scenario upload skipped: ${err.message}`));
     }
   }
-  await maybeSyncSystemCertificationFromDataplane({
-    label: 'upload',
-    noCertSync: cliOptsSkipCertSync(options),
-    systemKey,
-    dataplaneUrl,
-    authConfig,
-    datasourceKeys: dsKeys,
-    silent: quietSidecar
-  });
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Function} maybeRunUploadProbeFn
+ * @returns {Promise<{ probeData: Object|null, compact: boolean }>}
+ */
+async function resolveUploadProbeData(ctx, maybeRunUploadProbeFn) {
+  const { systemKey, options, dataplaneUrl, authConfig } = ctx;
+  const compact = !!options.minimal && options.verbose !== true;
+  if (!options.probe) {
+    return { probeData: null, compact };
+  }
+  if (compact) {
+    const probeData = await maybeRunUploadProbeFn(
+      dataplaneUrl,
+      systemKey,
+      authConfig,
+      options.probeTimeout,
+      { compact: true }
+    );
+    return { probeData, compact };
+  }
+  return { probeData: null, compact };
 }
 
 /**
@@ -56,7 +68,9 @@ async function handlePublicationAndFollowups(ctx, maybeRunUploadProbe) {
     environment,
     dataplaneUrl,
     authConfig,
-    rawRes
+    rawRes,
+    credentialPush,
+    configPush
   } = ctx;
   const publication = unwrapPublicationResult(rawRes);
   if (!publication) {
@@ -68,18 +82,32 @@ async function handlePublicationAndFollowups(ctx, maybeRunUploadProbe) {
     await runUploadSidecarFollowups({ systemKey, options, payload, dataplaneUrl, authConfig });
     return;
   }
-  logUploadReadinessSummary({
-    environment,
-    dataplaneUrl,
-    systemKey,
-    publication,
-    manifest,
-    minimal: !!options.minimal,
-    willProbe: !!options.probe
-  });
-  if (options.probe) {
-    await maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, options.probeTimeout);
+
+  const suppressSummary = options.suppressSummary === true;
+  const { probeData, compact } = await resolveUploadProbeData(ctx, maybeRunUploadProbe);
+
+  if (!suppressSummary) {
+    logUploadReadinessSummary({
+      environment,
+      dataplaneUrl,
+      systemKey,
+      publication,
+      manifest,
+      minimal: !!options.minimal,
+      willProbe: false,
+      credentialPush,
+      configPush,
+      forcePublish: options.force === true,
+      probeData
+    });
   }
+
+  if (options.probe && !compact) {
+    await maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, options.probeTimeout, {
+      compact: false
+    });
+  }
+
   await runUploadSidecarFollowups({ systemKey, options, payload, dataplaneUrl, authConfig });
 }