@aifabrix/builder 2.49.2 → 2.51.0

package/lib/utils/env-dotenv-format.js

@@ -0,0 +1,103 @@
+/**
+ * Dotenv serialization for values that may contain PEM or other multiline secrets.
+ * Docker Compose env_file and Builder .env.run require single-line KEY=value rows.
+ *
+ * @fileoverview Shared dotenv quoting/escaping for resolve, run, and admin env writers
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * Whether a dotenv value should be double-quoted (spaces, #, =, commas, or multiline).
+ * @param {string} value
+ * @returns {boolean}
+ */
+function valueNeedsDotenvQuoting(value) {
+  const s = String(value ?? '');
+  return /[\r\n]/.test(s) || /[,\s#=]/.test(s) || s !== s.trim();
+}
+
+/**
+ * Escape a logical string for placement inside double quotes in a .env file.
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeDotenvQuotedInner(value) {
+  return String(value ?? '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n');
+}
+
+/**
+ * Format the value portion of KEY=value (includes quotes when needed).
+ * Never emits raw newline characters.
+ *
+ * @param {string} value - Logical value (may contain real newlines)
+ * @returns {string}
+ */
+function formatDotenvValuePart(value) {
+  const logical = String(value ?? '');
+  if (!valueNeedsDotenvQuoting(logical)) {
+    return logical;
+  }
+  return `"${escapeDotenvQuotedInner(logical)}"`;
+}
+
+/**
+ * Format a full KEY=value line without trailing newline.
+ * @param {string} key
+ * @param {string} value
+ * @returns {string}
+ */
+function formatDotenvLine(key, value) {
+  return `${key}=${formatDotenvValuePart(value)}`;
+}
+
+/**
+ * Normalize kv:// substitution values so multiline PEM never splits .env rows.
+ * @param {string} value
+ * @returns {string}
+ */
+function formatDotenvSubstitutionValue(value) {
+  const s = String(value ?? '');
+  if (/[\r\n]/.test(s)) {
+    return formatDotenvValuePart(s);
+  }
+  if (/\\n/.test(s) && /-----BEGIN [A-Z ]+-----/.test(s)) {
+    return formatDotenvValuePart(s.replace(/\\n/g, '\n'));
+  }
+  return s;
+}
+
+/**
+ * Parse a raw value segment from KEY=value (after first '=').
+ * @param {string} raw
+ * @returns {string}
+ */
+function parseDotenvRawValue(raw) {
+  let value = raw ?? '';
+  if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+    value = value
+      .slice(1, -1)
+      .replace(/\\n/g, '\n')
+      .replace(/\\"/g, '"')
+      .replace(/\\\\/g, '\\');
+  } else if (value.length >= 2 && value.startsWith('\'') && value.endsWith('\'')) {
+    value = value.slice(1, -1);
+  }
+  return value;
+}
+
+module.exports = {
+  valueNeedsDotenvQuoting,
+  escapeDotenvQuotedInner,
+  formatDotenvValuePart,
+  formatDotenvLine,
+  formatDotenvSubstitutionValue,
+  parseDotenvRawValue
+};

package/lib/utils/error-formatters/error-parser.js

@@ -25,9 +25,6 @@ const { formatNetworkError } = require('./network-errors');
  * @returns {Object} Parsed error data object
  */
 function parseErrorData(errorResponse) {
-  if (errorResponse === undefined || errorResponse === null) {
-    return { message: 'Unknown error occurred' };
-  }
   if (typeof errorResponse === 'string') {
     try {
       return JSON.parse(errorResponse);

package/lib/utils/external-env-template.js

@@ -14,6 +14,7 @@ const fs = require('fs');
 const Handlebars = require('handlebars');
 const { systemKeyToKvPrefix, kvEnvKeyToPath, securityKeyToVar } = require('./credential-secrets-env');
 const { getAuthCredentialTemplate } = require('./authentication-shape');
+const { buildAuthSecureVarsFromAllSlots } = require('./authentication-env-template');
 
 /**
  * Builds hint string from portalInput (options → enum, validation → min-max or pattern).
@@ -141,7 +142,7 @@ function buildConfigurationEntries(system) {
 function buildExternalEnvTemplateContext(system) {
   const authBlock = system?.authentication || system?.auth;
   const credential = getAuthCredentialTemplate(authBlock);
-  let authMethod = 'apikey';
+  let authMethod;
   if (authBlock?.authType === 'apiProvider') {
     authMethod = 'apiprovider';
   } else if (authBlock?.authType === 'none') {
@@ -154,7 +155,9 @@ function buildExternalEnvTemplateContext(system) {
       'apikey'
     ).toLowerCase();
   }
-  const authSecureVars = buildAuthSecureVarsFromSystem(system);
+  const slotSecureVars = buildAuthSecureVarsFromAllSlots(system);
+  const authSecureVars =
+    slotSecureVars.length > 0 ? slotSecureVars : buildAuthSecureVarsFromSystem(system);
   const authVars =
     (credential?.variables && typeof credential.variables === 'object' ? credential.variables : null) ||
     (authBlock?.variables && typeof authBlock.variables === 'object' ? authBlock.variables : {});

package/lib/utils/external-system-display.js

@@ -273,7 +273,11 @@ function displayServerDatasourceTestRunResults(results, verbose, opts = {}) {
   // Plan §17: system-level overview for multi-datasource results (no full §16 dump per datasource by default).
   // Keep legacy per-datasource full envelope available only via datasource commands.
   if (integrationResultsHaveEnvelope(results)) {
-    displaySystemAggregateDatasourceTestRuns(results, { runType, verbose: Boolean(verbose) });
+    displaySystemAggregateDatasourceTestRuns(results, {
+      runType,
+      verbose: Boolean(verbose),
+      debug: opts.debug
+    });
     return;
   }
 

package/lib/utils/external-system-readiness-compact-blocks.js

@@ -0,0 +1,248 @@
+/**
+ * Compact card section loggers (plan 156.0).
+ *
+ * @fileoverview Internal blocks for upload/deploy compact summaries
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('./logger');
+const { formatSuccessLine, formatBlockingError } = require('./cli-test-layout-chalk');
+const { summarizeDatasourceTiersA } = require('./external-system-readiness-core');
+const {
+  PILLAR_LABELS,
+  formatAuthenticationSummary,
+  formatDatasourceAggregateLine,
+  formatCredentialPushLine,
+  formatConfigResolveLine,
+  formatGatePillarLine,
+  formatPreflightLine,
+  formatRuntimeDatasourceIssues,
+  buildProbeCompactContext,
+  resolveConnectedSystemStatus,
+  resolveManifestAuthMethod,
+  logCompactHeader,
+  logCompactPortalLinks,
+  logCompactTip
+} = require('./external-system-readiness-compact-display');
+
+/**
+ * @param {Object|null|undefined} credentialPush
+ * @param {Object|null|undefined} configPush
+ */
+function logCompactPushLines(credentialPush, configPush) {
+  const credLine = formatCredentialPushLine(credentialPush || {});
+  if (credLine) logger.log(`  ${credLine}`);
+  const cfgLine = formatConfigResolveLine({
+    count: configPush?.pushed || configPush?.count,
+    names: configPush?.names
+  });
+  if (cfgLine) logger.log(`  ${cfgLine}`);
+}
+
+/**
+ * @param {Object|null|undefined} probeData
+ */
+function logCompactProbeSection(probeData) {
+  const probeCtx = buildProbeCompactContext({ probeData });
+  if (!probeCtx) return;
+  logger.log('');
+  const conn = probeCtx.connectivityPassed ? 'passed' : 'failed';
+  logger.log(`  Runtime: ${probeCtx.runtimeVerdict}            Connectivity: ${conn}`);
+  logger.log(
+    `  Runtime datasources: ${probeCtx.summary.ready} ready · ${probeCtx.summary.partial} partial · ${probeCtx.summary.failed} failed`
+  );
+  const issueLines = formatRuntimeDatasourceIssues({
+    issues: probeCtx.summary.issues.map(i => ({
+      key: i.key,
+      lines: i.lines,
+      tier: probeCtx.summary.rows.find(r => r.key === i.key)?.tier === 'failed' ? 'Failed' : 'Partial'
+    }))
+  });
+  for (const line of issueLines) {
+    logger.log(chalk.yellow(`  ${line}`));
+  }
+}
+
+/**
+ * @param {Object} ctx
+ */
+function logUploadReadinessSummaryCompact(ctx) {
+  const { systemKey, environment, dataplaneUrl, publication, manifest, forcePublish, probeData } = ctx;
+  const genMcp = publication?.generateMcpContract !== false;
+  const tierA = summarizeDatasourceTiersA(publication?.datasources || [], genMcp);
+  const systemCfg = manifest?.system || {};
+  const statusLabel = resolveConnectedSystemStatus({ publication });
+
+  logCompactHeader({ command: 'upload', systemKey, environment, dataplaneUrl });
+  if (forcePublish) {
+    logger.log(
+      chalk.yellow(
+        '  Warning: --force bypasses active-datasource schema replacement guards on publish.'
+      )
+    );
+  }
+  logCompactPushLines(ctx.credentialPush, ctx.configPush);
+  logger.log('');
+  let statusPart = `Status: ${statusLabel}`;
+  statusPart += `          ${formatAuthenticationSummary({ method: resolveManifestAuthMethod(systemCfg) })}`;
+  statusPart += `          ${formatDatasourceAggregateLine({
+    ready: tierA.ready,
+    partial: tierA.partial,
+    failed: tierA.failed,
+    mcp: genMcp
+  })}`;
+  if (forcePublish) statusPart += '          Publish mode: forced';
+  logger.log(`  ${statusPart}`);
+  logCompactProbeSection(probeData);
+  logger.log('');
+  logCompactPortalLinks({ dataplaneUrl, systemKey });
+  logger.log('');
+  logCompactTip({ systemKey, command: 'upload', probed: !!probeData });
+}
+
+/**
+ * @param {Array<Object>|undefined} dsFromCtx
+ * @param {Object} manifest
+ * @returns {Object[]}
+ */
+function resolveDeployCompactDatasources(dsFromCtx, manifest) {
+  if (Array.isArray(dsFromCtx) && dsFromCtx.length > 0) return dsFromCtx;
+  return (manifest.dataSources || []).map(d => ({
+    key: d.key,
+    status: d.status || 'published',
+    isActive: d.isActive !== false,
+    mcpContract: d.mcpContract
+  }));
+}
+
+/**
+ * @param {Object} ctx
+ */
+function logDeployCompactPreflightAndGates(ctx) {
+  logger.log(`  ${formatSuccessLine('Local validation')}`);
+  const preflight = ctx.gateOutcomes?.baseline;
+  if (preflight) {
+    const pf = formatPreflightLine(preflight);
+    if (pf) logger.log(`  ${pf}`);
+  } else {
+    logger.log(`  ${formatSuccessLine('Preflight: unit + integration')}`);
+  }
+  for (const gate of ctx.gateOutcomes?.gates || []) {
+    if (gate.failedDetail) {
+      logger.log(
+        `  ${formatBlockingError(`${PILLAR_LABELS[gate.pillar] || gate.pillar} · FAILED — ${gate.failedDetail}`)}`
+      );
+    } else {
+      logger.log(`  ${formatGatePillarLine(gate)}`);
+    }
+  }
+}
+
+/**
+ * @param {Object} ctx
+ */
+function logDeployCompactDeploymentSteps(ctx) {
+  logCompactPushLines(ctx.credentialPush, ctx.configPush);
+  if (!ctx.fetchError) {
+    logger.log(`  ${formatSuccessLine('Dataplane validation')}`);
+  }
+  if (ctx.deploymentOk) {
+    const draftPart = ctx.draftDeploymentId
+      ? ` · Draft ID: ${String(ctx.draftDeploymentId).slice(0, 12)}…`
+      : '';
+    logger.log(`  ${formatSuccessLine(`Controller deploy · polled · completed${draftPart}`)}`);
+    return;
+  }
+  logger.log(`  ${formatBlockingError('Controller deploy failed')}`);
+  if (ctx.deploymentDetail?.error) {
+    logger.log(chalk.red(`     Error: ${ctx.deploymentDetail.error}`));
+  }
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Object} systemCfg
+ * @param {Object} tierA
+ * @param {boolean} genMcp
+ * @param {string} statusLabel
+ */
+function logDeployCompactStatusRow(ctx, systemCfg, tierA, genMcp, statusLabel) {
+  const aggregate = formatDatasourceAggregateLine({
+    ready: tierA.ready,
+    partial: tierA.partial,
+    failed: tierA.failed,
+    mcp: genMcp
+  });
+  const auth = formatAuthenticationSummary({ method: resolveManifestAuthMethod(systemCfg) });
+  const isDraftAfterDeploy =
+    ctx.deploymentOk && String(ctx.systemFromDataplane?.status || '').toLowerCase() === 'draft';
+  if (isDraftAfterDeploy) {
+    logger.log(`  ${formatBlockingError('Status: Draft (expected Published after deploy)')}`);
+    logger.log(`     ${auth}          ${aggregate}`);
+    return;
+  }
+  if (ctx.fetchError) {
+    logger.log(chalk.yellow(`  Unable to fetch system status: ${ctx.fetchError.message}`));
+    return;
+  }
+  logger.log(`  Status: ${statusLabel}          ${auth}          ${aggregate}`);
+}
+
+/**
+ * @param {Object} ctx
+ */
+function logDeployReadinessSummaryCompact(ctx) {
+  const systemKey = ctx.manifest.key;
+  const systemCfg = ctx.manifest.system || {};
+  const genMcp = systemCfg.generateMcpContract !== false;
+  const datasources = resolveDeployCompactDatasources(ctx.datasources, ctx.manifest);
+  const tierA = summarizeDatasourceTiersA(datasources, genMcp);
+  const statusLabel = resolveConnectedSystemStatus({ systemFromDataplane: ctx.systemFromDataplane });
+
+  logCompactHeader({ command: 'deploy', systemKey, environment: ctx.environment, dataplaneUrl: ctx.dataplaneUrl });
+  logDeployCompactPreflightAndGates(ctx);
+  logDeployCompactDeploymentSteps(ctx);
+  logger.log('');
+  logDeployCompactStatusRow(ctx, systemCfg, tierA, genMcp, statusLabel);
+  logCompactProbeSection(ctx.probeData);
+  logger.log('');
+  logCompactPortalLinks({ dataplaneUrl: ctx.dataplaneUrl, systemKey });
+  logger.log('');
+  logCompactTip({ systemKey, command: 'deploy', probed: !!ctx.probeData });
+}
+
+/**
+ * Compact abort card when a deploy --gate pillar fails before controller deploy.
+ * @param {Object} ctx
+ */
+function logDeployGateAbortCompact(ctx) {
+  const systemKey = ctx.systemKey || 'system';
+  logCompactHeader({
+    command: 'deploy',
+    systemKey,
+    environment: ctx.environment || 'dev',
+    dataplaneUrl: ctx.dataplaneUrl
+  });
+  logger.log(`  ${formatSuccessLine('Local validation')}`);
+  const pf = formatPreflightLine(ctx.baseline || { unitPassed: true, integrationPassed: true });
+  if (pf) logger.log(`  ${pf}`);
+  for (const gate of ctx.gatesSoFar || []) {
+    logger.log(`  ${formatGatePillarLine(gate)}`);
+  }
+  const pillar = ctx.failedPillar || 'operations';
+  const detail = ctx.failedDetail || 'gate failed';
+  const label = PILLAR_LABELS[pillar] || pillar;
+  logger.log(`  ${formatBlockingError(`${label} · FAILED — ${detail}`)}`);
+  logger.log('');
+  logCompactTip({ systemKey, command: 'deploy', probed: false });
+}
+
+module.exports = {
+  logUploadReadinessSummaryCompact,
+  logDeployReadinessSummaryCompact,
+  logDeployGateAbortCompact
+};