@aifabrix/builder 2.43.0 → 2.44.1

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

@@ -0,0 +1,150 @@
+/**
+ * Shared chalk helpers for external system readiness CLI blocks.
+ *
+ * @fileoverview Internals for upload and deploy readiness display
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const { failureGlyph, successGlyph } = require('./cli-test-layout-chalk');
+const logger = require('./logger');
+const { extractIdentitySummary, resolveCredentialTestEndpointDisplay } = require('./external-system-readiness-core');
+
+const SEP = chalk.gray('────────────────────────────────');
+
+/**
+ * @param {string} title
+ */
+function logSectionTitle(title) {
+  logger.log('');
+  logger.log(chalk.bold(title));
+}
+
+function logSeparator() {
+  logger.log('');
+  logger.log(SEP);
+}
+
+/**
+ * @param {'ready'|'partial'|'failed'} tier
+ * @returns {string}
+ */
+function tierGlyph(tier) {
+  if (tier === 'ready') return successGlyph();
+  if (tier === 'failed') return failureGlyph();
+  return chalk.yellow('⚠');
+}
+
+/**
+ * @param {'READY'|'PARTIAL'|'FAILED'} v
+ * @returns {string}
+ */
+function verdictLine(v) {
+  const label = chalk.bold('System Readiness: ');
+  if (v === 'READY') return label + chalk.green('READY');
+  if (v === 'FAILED') return label + chalk.red('FAILED');
+  return label + chalk.yellow('PARTIAL');
+}
+
+/**
+ * @param {Array<{ key: string, tier: string }>} rows
+ * @param {{ ready: number, partial: number, failed: number }} counts
+ */
+function logDatasourceTable(rows, counts) {
+  logSectionTitle('Datasources:');
+  for (const r of rows) {
+    const statusLabel = r.tier === 'ready' ? 'Ready' : r.tier === 'failed' ? 'Failed' : 'Partial';
+    logger.log(
+      `${tierGlyph(r.tier)} ${r.key.padEnd(14, ' ')} ${chalk.gray('(' + statusLabel + ')')}`
+    );
+  }
+  logger.log('');
+  logger.log(
+    chalk.gray('Summary:') +
+      ` ${chalk.green('Ready: ' + counts.ready)} · ${chalk.yellow('Partial: ' + counts.partial)} · ${chalk.red('Failed: ' + counts.failed)}`
+  );
+}
+
+/**
+ * @param {Object} system - manifest.system
+ */
+function logIdentityBlock(system) {
+  const { mode, attribution, tokenBroker } = extractIdentitySummary(system || {});
+  logSectionTitle('Identity:');
+  logger.log(`${chalk.gray('Mode:')} ${mode}`);
+  const attrColor = attribution === 'enabled' ? chalk.white : chalk.yellow;
+  logger.log(`${chalk.gray('Attribution:')} ${attrColor(attribution)}`);
+  logger.log(`${chalk.gray('Token broker:')} ${tokenBroker === 'configured' ? chalk.white(tokenBroker) : chalk.gray(tokenBroker)}`);
+}
+
+/**
+ * @param {Object} system - manifest.system
+ * @param {boolean} probed
+ * @param {boolean} [willProbe] - True when caller will run --probe immediately after this block
+ */
+function logCredentialIntentBlock(system, probed, willProbe = false) {
+  const url = resolveCredentialTestEndpointDisplay(system || {});
+  logSectionTitle('Credential (intent):');
+  if (url) {
+    logger.log(chalk.gray('Test endpoint:'));
+    logger.log(chalk.cyan(`GET ${url}`));
+  } else {
+    logger.log(chalk.gray('Test endpoint: (not configured — defaults may apply on server)'));
+  }
+  if (!probed) {
+    if (willProbe) {
+      logger.log(chalk.gray('⏳ Connectivity will be tested next (--probe)'));
+    } else {
+      logger.log(chalk.yellow('⚠ Connectivity not tested (use --probe)'));
+    }
+  }
+}
+
+/**
+ * @param {string[]} actions
+ * @param {string} [extraLine]
+ */
+function logNextActions(actions, extraLine) {
+  logSectionTitle('Next actions:');
+  for (const a of actions) {
+    if (a.startsWith('Run:')) {
+      logger.log(chalk.cyan('- ') + chalk.white(a));
+    } else {
+      logger.log(chalk.cyan('- ') + a);
+    }
+  }
+  if (extraLine) {
+    logger.log(chalk.cyan('- ') + chalk.white(extraLine));
+  }
+}
+
+/**
+ * @param {Object} sys - ExternalSystemResponse
+ */
+function logDocsBlock(sys) {
+  if (!sys) return;
+  const urls = [];
+  if (sys.openApiDocsPageUrl) urls.push({ label: 'OpenAPI Docs Page', url: sys.openApiDocsPageUrl });
+  if (sys.apiDocumentUrl) urls.push({ label: 'API Docs', url: sys.apiDocumentUrl });
+  if (sys.mcpServerUrl) urls.push({ label: 'MCP Server', url: sys.mcpServerUrl });
+  if (urls.length === 0) return;
+  logSeparator();
+  logSectionTitle('Docs:');
+  for (const { label, url } of urls) {
+    logger.log(`${chalk.gray(label + ':')} ${chalk.cyan(url)}`);
+  }
+}
+
+module.exports = {
+  SEP,
+  logSeparator,
+  logSectionTitle,
+  tierGlyph,
+  verdictLine,
+  logDatasourceTable,
+  logIdentityBlock,
+  logCredentialIntentBlock,
+  logNextActions,
+  logDocsBlock
+};

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

@@ -0,0 +1,186 @@
+const { formatBlockingError, formatSuccessLine } = require('./cli-test-layout-chalk');
+/**
+ * Chalk-based CLI output for external system upload readiness (+ upload-time probe).
+ * Deploy summary lives in external-system-readiness-deploy-display.js.
+ *
+ * @fileoverview Readiness display for upload and optional probe after upload
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('./logger');
+const {
+  summarizeDatasourceTiersA,
+  summarizeProbeResults,
+  buildNextActionsTierA,
+  coerceProbeRunToResultRows
+} = require('./external-system-readiness-core');
+const {
+  logSeparator,
+  logSectionTitle,
+  logDatasourceTable,
+  logIdentityBlock,
+  logCredentialIntentBlock,
+  logNextActions,
+  logDocsBlock,
+  verdictLine,
+  SEP
+} = require('./external-system-readiness-display-internals');
+
+/**
+ * @param {Object} publication - PublicationResult
+ */
+function logPublishResultBlock(publication) {
+  const genMcp = publication.generateMcpContract === true;
+  logSectionTitle('Publish Result:');
+  logger.log(formatSuccessLine('System registered (controller + dataplane)'));
+  if (publication.uploadId) {
+    logger.log(`${chalk.gray('Upload ID:')} ${chalk.cyan(String(publication.uploadId))}`);
+  }
+  const sys = publication.system || {};
+  if (sys.status) {
+    logger.log(`${chalk.gray('System status:')} ${sys.status}`);
+  }
+  logSeparator();
+  logSectionTitle('MCP Contract:');
+  logger.log(genMcp ? formatSuccessLine('Generated') : chalk.gray('○ Not requested (generateMcpContract false)'));
+}
+
+/**
+ * @param {string} systemKey
+ * @param {{ ready: number, partial: number, failed: number }} summary
+ * @param {boolean} willProbe
+ */
+function logUploadReadinessSummaryMinimal(systemKey, summary, willProbe) {
+  logger.log(chalk.green(`\nUpload complete: ${systemKey}`));
+  logger.log(
+    chalk.gray('Summary:') +
+      ` ${chalk.green('Ready: ' + summary.ready)} · ${chalk.yellow('Partial: ' + summary.partial)} · ${chalk.red('Failed: ' + summary.failed)}`
+  );
+  if (!willProbe) logger.log(chalk.gray('Use --probe for runtime verification'));
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} publication
+ * @param {Object} manifest
+ * @param {{ rows: Array<{ key: string, tier: string }>, ready: number, partial: number, failed: number }} summary
+ * @param {boolean} genMcp
+ * @param {boolean} willProbe
+ */
+function logUploadReadinessSummaryExpanded(systemKey, publication, manifest, summary, genMcp, willProbe) {
+  const systemCfg = manifest.system || {};
+  logSeparator();
+  logPublishResultBlock(publication);
+  logSeparator();
+  logDatasourceTable(summary.rows, summary);
+  logSeparator();
+  logIdentityBlock(systemCfg);
+  logSeparator();
+  logCredentialIntentBlock(systemCfg, false, !!willProbe);
+  logSeparator();
+  let hints = buildNextActionsTierA(systemKey, summary, genMcp);
+  if (willProbe) {
+    hints = hints.filter(h => !h.includes(`Run: aifabrix upload ${systemKey} --probe`));
+  }
+  logNextActions(hints);
+}
+
+/**
+ * @param {Object} ctx
+ * @param {string} ctx.systemKey
+ * @param {Object} ctx.publication - PublicationResult
+ * @param {Object} ctx.manifest
+ * @param {boolean} [ctx.minimal] - One-line summary + probe hint only
+ * @param {boolean} [ctx.willProbe] - True when caller will run --probe immediately after this summary
+ */
+function logUploadReadinessSummary(ctx) {
+  const { systemKey, publication, manifest, minimal, willProbe } = ctx;
+  const genMcp = publication.generateMcpContract === true;
+  const summary = summarizeDatasourceTiersA(publication.datasources || [], genMcp);
+  if (minimal) {
+    logUploadReadinessSummaryMinimal(systemKey, summary, willProbe);
+    return;
+  }
+  logUploadReadinessSummaryExpanded(systemKey, publication, manifest, summary, genMcp, willProbe);
+}
+
+/**
+ * @param {Object} validationBody - Unwrapped pipeline/validate response
+ */
+function logServerValidationWarnings(validationBody) {
+  const warnings = validationBody?.warnings;
+  if (!Array.isArray(warnings) || warnings.length === 0) return;
+  logSeparator();
+  logSectionTitle('Server validation:');
+  for (const w of warnings) {
+    logger.log(chalk.yellow(`⚠ Warning: ${typeof w === 'string' ? w : JSON.stringify(w)}`));
+  }
+}
+
+/**
+ * @param {Object} results - Probe result rows
+ * @param {Object} summary - summarizeProbeResults output
+ */
+function logProbeCredentialLine(results, summary) {
+  logSeparator();
+  logSectionTitle('Credential Test:');
+  const anyEndpointFail = results.some(row => row?.endpointTestResults?.success === false);
+  if (anyEndpointFail) {
+    logger.log(formatBlockingError('Failed (see Key Issues / endpoint test)'));
+  } else if (summary.failed > 0) {
+    logger.log(formatBlockingError('Some datasource checks failed'));
+  } else if (summary.partial > 0) {
+    logger.log(chalk.yellow('⚠ Completed with warnings'));
+  } else {
+    logger.log(formatSuccessLine('Passed'));
+  }
+}
+
+/**
+ * @param {Object} probeRaw - Unwrapped POST /validation/run body
+ * @param {string} systemKey
+ */
+function logProbeRuntimeBlock(probeRaw, systemKey) {
+  const results = coerceProbeRunToResultRows(probeRaw);
+  const summary = summarizeProbeResults(results);
+  logSeparator();
+  logger.log(chalk.bold('Runtime Readiness:'));
+  if (results.length === 0) {
+    logger.log(chalk.yellow('⚠ No runtime datasource results were returned by the dataplane probe.'));
+    logger.log(chalk.gray('   Endpoint credential test may still pass even if datasource checks were not reported.'));
+  }
+  logDatasourceTable(summary.rows, summary);
+  if (summary.issues.length > 0) {
+    logSeparator();
+    logSectionTitle('Key Issues:');
+    for (const { key, lines } of summary.issues) {
+      logger.log(chalk.white(key));
+      for (const line of lines) {
+        logger.log(chalk.red(`- ${line}`));
+      }
+    }
+  }
+  logProbeCredentialLine(results, summary);
+  logSeparator();
+  logNextActions(
+    ['Fix API credentials or permissions if endpoint tests failed'],
+    `Run: aifabrix datasource test-e2e <datasourceKey> --app ${systemKey}`
+  );
+}
+
+module.exports = {
+  logUploadReadinessSummary,
+  logServerValidationWarnings,
+  logProbeRuntimeBlock,
+  SEP,
+  logSeparator,
+  logSectionTitle,
+  logDatasourceTable,
+  logIdentityBlock,
+  logCredentialIntentBlock,
+  logNextActions,
+  logDocsBlock,
+  verdictLine
+};

package/lib/utils/external-system-system-test-tty-overview.js

@@ -0,0 +1,120 @@
+/**
+ * @fileoverview Plan §17 blocks: capabilities overview and integration health (split for file-size limits).
+ */
+
+'use strict';
+
+/**
+ * @param {Object|null|undefined} env
+ * @returns {'ok'|'warn'|'fail'}
+ */
+function integrationRollupStatus(env) {
+  const integ = env && env.integration;
+  if (!integ || typeof integ !== 'object') return 'ok';
+  if (typeof integ.status === 'string') {
+    const s = integ.status.toLowerCase();
+    if (s === 'fail' || s === 'failed' || s === 'error') return 'fail';
+    if (s === 'warn' || s === 'warning') return 'warn';
+    if (s === 'ok' || s === 'passed' || s === 'success') return 'ok';
+  }
+  const steps = Array.isArray(integ.stepResults) ? integ.stepResults : [];
+  if (steps.some(s => s && (s.success === false || s.error))) return 'fail';
+  return 'ok';
+}
+
+function buildCapabilityBlocks(rows, statusGlyph) {
+  const blocks = [];
+  for (const r of rows) {
+    if (r && r.skipped) continue;
+    const env = r && r.datasourceTestRun;
+    if (!env || !Array.isArray(env.capabilities) || env.capabilities.length === 0) continue;
+    const dkey = env.datasourceKey || r.key || 'datasource';
+    const caps = [...env.capabilities]
+      .filter(c => c && c.key)
+      .sort((a, b) => String(a.key).localeCompare(String(b.key)))
+      .slice(0, 4);
+    const parts = caps.map(c => `${statusGlyph(c.status)} ${c.key}`);
+    if (parts.length === 0) continue;
+    blocks.push({ dkey: String(dkey), line: parts.join(' ') });
+  }
+  return blocks;
+}
+
+function emitSectionHeader(io, title) {
+  const { log, metaGray, sectionTitle, SEP } = io;
+  log('');
+  log(metaGray(SEP));
+  log('');
+  log(sectionTitle(title));
+  log('');
+}
+
+/**
+ * @param {Array} rows
+ * @param {{ log: Function, chalk: object, metaGray: Function, sectionTitle: Function, statusGlyph: Function, SEP: string }} io
+ * @returns {boolean}
+ */
+function logCapabilitiesOverview(rows, io) {
+  const blocks = buildCapabilityBlocks(rows, io.statusGlyph);
+  if (blocks.length === 0) return false;
+  emitSectionHeader(io, 'Capabilities overview:');
+  for (const b of blocks) {
+    io.log(io.chalk.white(`${b.dkey}:`));
+    io.log(io.chalk.white(`  ${b.line}`));
+  }
+  return true;
+}
+
+function badIntegrationSteps(integ) {
+  if (!integ || !Array.isArray(integ.stepResults)) return [];
+  return integ.stepResults.filter(s => s && (s.success === false || s.error)).slice(0, 2);
+}
+
+function buildIntegrationBlocks(rows) {
+  const blocks = [];
+  for (const r of rows) {
+    if (r && r.skipped) continue;
+    const env = r && r.datasourceTestRun;
+    if (!env) continue;
+    const dkey = env.datasourceKey || r.key || 'datasource';
+    const st = integrationRollupStatus(env);
+    const integ = env.integration && typeof env.integration === 'object' ? env.integration : null;
+    blocks.push({ dkey: String(dkey), st, badSteps: badIntegrationSteps(integ) });
+  }
+  return blocks;
+}
+
+function emitFailedSteps(block, io) {
+  if (block.st !== 'fail' && block.st !== 'warn') return;
+  const { log, chalk, statusGlyph } = io;
+  for (const stp of block.badSteps) {
+    const nm = stp.name || stp.step || 'step';
+    const hint = stp.error || stp.message || '';
+    log(chalk.white(`  ${statusGlyph('fail')} ${nm}${hint ? `: ${hint}` : ''}`));
+  }
+}
+
+/**
+ * @param {Array} rows
+ * @param {'integration'|'e2e'} runType
+ * @param {{ log: Function, chalk: object, metaGray: Function, sectionTitle: Function, statusGlyph: Function, SEP: string }} io
+ * @returns {boolean}
+ */
+function logIntegrationHealthSection(rows, runType, io) {
+  if (runType !== 'integration') return false;
+  const blocks = buildIntegrationBlocks(rows);
+  if (blocks.length === 0) return false;
+  emitSectionHeader(io, 'Integration health:');
+  const { log, chalk, statusGlyph } = io;
+  for (const b of blocks) {
+    log(chalk.white(`${b.dkey}: ${statusGlyph(b.st)} ${b.st}`));
+    emitFailedSteps(b, io);
+  }
+  return true;
+}
+
+module.exports = {
+  integrationRollupStatus,
+  logCapabilitiesOverview,
+  logIntegrationHealthSection
+};