@aifabrix/builder 2.44.6 → 2.45.5

package/lib/commands/teardown.js

@@ -24,6 +24,7 @@ const chalk = require('chalk');
 const ora = require('ora');
 
 const config = require('../core/config');
+const installationLog = require('../utils/installation-log');
 const infra = require('../infrastructure');
 const pathsUtil = require('../utils/paths');
 const logger = require('../utils/logger');
@@ -193,6 +194,47 @@ function cleanFilesWithSpinner() {
   return result;
 }
 
+async function appendTeardownAbortedLog(options) {
+  const t = new Date();
+  try {
+    await installationLog.appendInstallationRecord({
+      command: 'teardown',
+      outcome: 'aborted',
+      startedAt: t,
+      completedAt: t,
+      options
+    });
+  } catch {
+    // ignore
+  }
+}
+
+async function appendTeardownSuccessLog(options, startedAt) {
+  let cfg = {};
+  try {
+    cfg = await config.getConfig();
+  } catch {
+    cfg = {};
+  }
+  try {
+    await installationLog.appendInstallationRecord({
+      command: 'teardown',
+      outcome: 'success',
+      startedAt,
+      completedAt: new Date(),
+      options,
+      infra: { cfg, options: {} },
+      cleanup: { volumesRemoved: true, configPreserved: true },
+      configExtra: {
+        controllerUrl: await installationLog.resolveControllerUrlForLog(),
+        adminEmail: await installationLog.resolveAdminEmailPresence()
+      }
+    });
+  } catch {
+    // ignore
+  }
+}
+
 /**
  * Run the teardown.
  *
@@ -208,15 +250,22 @@ async function handleTeardown(options = {}) {
 
   const ok = await confirmTeardown(assumeYes);
   if (!ok) {
+    await appendTeardownAbortedLog(options);
     logger.log(chalk.yellow('Aborted by user.'));
     return;
   }
-  await stopInfraQuietly();
-  const { removed, failed } = cleanFilesWithSpinner();
-  const devStr = await buildDeveloperLabel();
-  logTeardownFooter({ devStr, removedCount: removed.length, failedCount: failed.length });
 
-  logger.log(formatSuccessParagraph('aifabrix teardown complete.'));
+  const startedAt = new Date();
+  try {
+    await stopInfraQuietly();
+    const { removed, failed } = cleanFilesWithSpinner();
+    const devStr = await buildDeveloperLabel();
+    logTeardownFooter({ devStr, removedCount: removed.length, failedCount: failed.length });
+
+    logger.log(formatSuccessParagraph('aifabrix teardown complete.'));
+  } finally {
+    await appendTeardownSuccessLog(options, startedAt);
+  }
 }
 
 module.exports = {

package/lib/commands/test-e2e-external.js

@@ -18,6 +18,9 @@ const { resolveApplicationConfigPath } = require('../utils/app-config-resolver')
 const { loadConfigFile } = require('../utils/config-format');
 const { discoverIntegrationFiles, buildEffectiveDatasourceFiles } = require('./repair-internal');
 const { runDatasourceTestE2E } = require('../datasource/test-e2e');
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { getConfig } = require('../core/config');
+const { setupIntegrationTestAuth } = require('../external-system/test-auth');
 
 /**
  * Derives datasource key from filename when file has no key (same logic as repair).
@@ -89,17 +92,18 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
  * unless ``options.noSync`` is true.
  * @param {string} systemKey
  * @param {Object} options
- * @returns {Promise<void>}
+ * @returns {Promise<{ authConfig: Object, dataplaneUrl: string, environment?: string }|null>}
  */
 async function syncLocalIfRequested(systemKey, options) {
-  if (options.noSync === true) return;
+  if (cliOptsSkipSync(options)) return null;
   logger.log(chalk.cyan('Syncing local config to dataplane…'));
   const { uploadExternalSystem } = require('./upload');
-  await uploadExternalSystem(systemKey, {
+  const uploadCtx = await uploadExternalSystem(systemKey, {
     verbose: !!options.verbose,
     minimal: true
   });
   logger.log(formatSuccessLine('Sync complete'));
+  return uploadCtx && uploadCtx.dataplaneUrl && uploadCtx.authConfig ? uploadCtx : null;
 }
 
 /* eslint-disable max-lines-per-function, max-statements -- Load context, then loop over keys */
@@ -116,7 +120,12 @@ async function syncLocalIfRequested(systemKey, options) {
  * @param {boolean} [options.noSync] - When true, skip upload (E2E uses dataplane config already deployed)
  * @returns {Promise<{ success: boolean, results: Array<{ key: string, success: boolean, error?: string }> }>}
  */
-async function runTestE2EForExternalSystem(externalSystem, options = {}) {
+/**
+ * Resolve integration folder, system key, and datasource keys for system-level tests.
+ * @param {string} externalSystem
+ * @returns {{ systemKey: string, keys: string[] }}
+ */
+function resolveExternalIntegrationContext(externalSystem) {
   if (!externalSystem || typeof externalSystem !== 'string') {
     throw new Error('External system name is required');
   }
@@ -140,9 +149,9 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
   );
   const systemPath = path.join(appPath, systemFiles[0]);
   const systemParsed = loadConfigFile(systemPath);
-  const systemKey = systemParsed.key ||
+  const systemKey =
+    systemParsed.key ||
     path.basename(systemFiles[0], path.extname(systemFiles[0])).replace(/-system$/, '');
-
   const keys = getDatasourceKeys(
     appPath,
     configPath,
@@ -151,12 +160,30 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
     systemParsed,
     datasourceFiles
   );
+  return { systemKey, keys };
+}
+
+async function runTestE2EForExternalSystem(externalSystem, options = {}) {
+  const { systemKey, keys } = resolveExternalIntegrationContext(externalSystem);
   if (keys.length === 0) {
     logger.log(chalk.yellow(`No datasources found for ${externalSystem}. Add datasource files and run aifabrix repair.`));
     return { success: true, results: [] };
   }
 
-  await syncLocalIfRequested(systemKey, options);
+  const uploadCtx = await syncLocalIfRequested(systemKey, options);
+
+  let authConfig;
+  let dataplaneUrl;
+  if (uploadCtx) {
+    ({ authConfig, dataplaneUrl } = uploadCtx);
+  } else {
+    const configObj = await getConfig();
+    ({ authConfig, dataplaneUrl } = await setupIntegrationTestAuth(
+      externalSystem,
+      { environment: options.env },
+      configObj
+    ));
+  }
 
   const results = [];
   const opts = {
@@ -164,7 +191,9 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
     environment: options.env,
     debug: options.debug,
     verbose: options.verbose,
-    async: options.async !== false
+    async: options.async !== false,
+    authConfig,
+    dataplaneUrl
   };
   for (const key of keys) {
     try {
@@ -187,5 +216,7 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
 
 module.exports = {
   runTestE2EForExternalSystem,
-  getDatasourceKeys
+  getDatasourceKeys,
+  resolveExternalIntegrationContext,
+  syncLocalIfRequested
 };

package/lib/commands/test-governance-cli-options.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Normalize test-governance Commander flags
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+
+/**
+ * @param {string[]} [raw]
+ * @param {string[]} [fallback]
+ * @returns {string[]|undefined}
+ */
+function collectScenarioIds(raw, fallback) {
+  const list = Array.isArray(raw) && raw.length > 0 ? raw : fallback;
+  if (!list || list.length === 0) {
+    return undefined;
+  }
+  return list.map(id => String(id).trim()).filter(Boolean);
+}
+
+/**
+ * @param {Object} options
+ * @param {import('commander').Command} [cmd]
+ * @returns {Object}
+ */
+function normalizeTestGovernanceCliOptions(options, cmd) {
+  const raw = cmd && Array.isArray(cmd.rawArgs) ? cmd.rawArgs : [];
+  const has = flag => raw.includes(flag);
+  return {
+    ...options,
+    env: options.env || 'dev',
+    verbose: options.verbose === true || has('-v') || has('--verbose'),
+    json: options.json === true || has('--json'),
+    noSync: cliOptsSkipSync(options, cmd),
+    pack: options.pack,
+    app: options.app,
+    scenarioIds: collectScenarioIds(options.scenario)
+  };
+}
+
+module.exports = {
+  normalizeTestGovernanceCliOptions,
+  collectScenarioIds
+};

package/lib/commands/test-governance-command-action.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview CLI action for `aifabrix test-governance` (plan 406)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { handleCommandError } = require('../utils/cli-utils');
+const { runTestGovernanceForExternalSystem } = require('./test-governance-external');
+const { normalizeTestGovernanceCliOptions } = require('./test-governance-cli-options');
+const {
+  displayGovernanceRunTTY,
+  printGovernanceRunJson,
+  exitCodeFromGovernanceSummary
+} = require('../governance/governance-run-display');
+
+/**
+ * @async
+ * @param {string} appName
+ * @param {Object} options
+ * @param {import('commander').Command} [cmd]
+ */
+async function runTestGovernanceCommandAction(appName, options, cmd) {
+  const opts = normalizeTestGovernanceCliOptions(options, cmd);
+  const { result, packPath, systemKey } = await runTestGovernanceForExternalSystem(appName, opts);
+
+  if (opts.json) {
+    printGovernanceRunJson(result);
+  } else {
+    displayGovernanceRunTTY(systemKey, result, {
+      verbose: opts.verbose,
+      packPath
+    });
+  }
+
+  const exitCode = exitCodeFromGovernanceSummary(result.summary);
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+async function testGovernanceCommandHandler(appName, options, cmd) {
+  try {
+    await runTestGovernanceCommandAction(appName, options, cmd);
+  } catch (error) {
+    handleCommandError(error, 'test-governance');
+    process.exit(3);
+  }
+}
+
+module.exports = {
+  runTestGovernanceCommandAction,
+  testGovernanceCommandHandler
+};

package/lib/commands/test-governance-external.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview test-governance — run governance scenario pack via dataplane API
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { getConfig } = require('../core/config');
+const { setupIntegrationTestAuth } = require('../external-system/test-auth');
+const { runGovernanceScenarios } = require('../api/governance-scenarios.api');
+const {
+  resolveGovernancePackPath,
+  loadGovernancePackYaml
+} = require('../governance/governance-pack-loader');
+
+/**
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {Promise<{ authConfig: Object, dataplaneUrl: string }|null>}
+ */
+async function syncLocalIfRequested(systemKey, options) {
+  if (cliOptsSkipSync(options)) {
+    return null;
+  }
+  const { uploadExternalSystem } = require('./upload');
+  logger.log(chalk.cyan('Syncing local config to dataplane…'));
+  const uploadCtx = await uploadExternalSystem(systemKey, {
+    minimal: true,
+    verbose: !!options.verbose
+  });
+  logger.log(chalk.green('✔ Sync complete'));
+  return uploadCtx && uploadCtx.dataplaneUrl && uploadCtx.authConfig ? uploadCtx : null;
+}
+
+/**
+ * @async
+ * @param {string} externalSystem
+ * @param {Object} options
+ * @returns {Promise<{ result: Object, packPath: string, systemKey: string }>}
+ */
+async function runTestGovernanceForExternalSystem(externalSystem, options = {}) {
+  const pathsUtil = require('../utils/paths');
+  const appType = await pathsUtil.detectAppType(externalSystem).catch(() => null);
+  if (!appType || appType.baseDir !== 'integration') {
+    throw new Error(
+      'test-governance applies to external integration folders only (integration/<systemKey>/).'
+    );
+  }
+
+  const systemKey = externalSystem;
+  const packPath = resolveGovernancePackPath(systemKey, {
+    pack: options.pack,
+    app: options.app
+  });
+  const pack = loadGovernancePackYaml(packPath);
+
+  const uploadCtx = await syncLocalIfRequested(systemKey, options);
+
+  let authConfig;
+  let dataplaneUrl;
+  if (uploadCtx) {
+    ({ authConfig, dataplaneUrl } = uploadCtx);
+  } else {
+    const configObj = await getConfig();
+    ({ authConfig, dataplaneUrl } = await setupIntegrationTestAuth(
+      externalSystem,
+      { environment: options.env },
+      configObj
+    ));
+  }
+
+  const body = {
+    systemKey,
+    pack,
+    scenarios: options.scenarioIds
+  };
+  const result = await runGovernanceScenarios(dataplaneUrl, authConfig, body);
+  return { result, packPath, systemKey };
+}
+
+module.exports = {
+  runTestGovernanceForExternalSystem,
+  syncLocalIfRequested
+};

package/lib/commands/test-trust-cli-options.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Normalize test-trust Commander flags (defensive for -d/-v/--revalidate).
+ */
+
+'use strict';
+
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+
+/**
+ * @param {Object} options - Commander-parsed options
+ * @param {import('commander').Command} [cmd]
+ * @returns {Object}
+ */
+function normalizeTestTrustCliOptions(options, cmd) {
+  const raw = cmd && Array.isArray(cmd.rawArgs) ? cmd.rawArgs : [];
+  const has = flag => raw.includes(flag);
+  return {
+    ...options,
+    debug: options.debug === true || has('-d') || has('--debug'),
+    verbose: options.verbose === true || has('-v') || has('--verbose'),
+    revalidate: options.revalidate === true || has('--revalidate'),
+    noSync: cliOptsSkipSync(options, cmd),
+    strict: options.strict === true || has('--strict'),
+    summary: options.summary === true || has('--summary'),
+    json: options.json === true || has('--json'),
+    warningsAsErrors: options.warningsAsErrors === true || has('--warnings-as-errors')
+  };
+}
+
+module.exports = {
+  normalizeTestTrustCliOptions
+};

package/lib/commands/test-trust-command-action.js

@@ -0,0 +1,118 @@
+/**
+ * @fileoverview CLI action for `aifabrix test-trust` (plan 143).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const { runTestTrustForExternalSystem } = require('./test-trust-external');
+const {
+  displaySystemTrustRollupTTY,
+  displayAgentTrustRunTTY
+} = require('../utils/agent-trust-run-display');
+const { computeSystemExitCodeFromTrustRows } = require('../utils/agent-trust-run-exit');
+const { writeTrustDebugLogAndPrint } = require('../datasource/agent-trust-debug-log');
+const { normalizeTestTrustCliOptions } = require('./test-trust-cli-options');
+
+/**
+ * @async
+ * @param {string} appName
+ * @param {Object} options
+ */
+async function writeSystemTrustDebugLogs(appName, results, options) {
+  if (!options.debug) return;
+  logger.log('');
+  logger.log(chalk.gray('Debug logs:'));
+  for (const row of results) {
+    await writeTrustDebugLogAndPrint(appName, row.key, {
+      request: {
+        datasourceKey: row.key,
+        revalidate: options.revalidate === true,
+        noSync: options.noSync === true
+      },
+      response: row.trustRun,
+      error: row.error || null
+    });
+  }
+}
+
+function displaySystemTrustResults(systemKey, appName, results, options) {
+  if (options.json) {
+    logger.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  if (options.summary) {
+    for (const row of results) {
+      const tr = row.trustRun;
+      const line = tr
+        ? `${row.key}: ${tr.trustDecision} (${tr.validationStatus})`
+        : `${row.key}: fail (${row.error || 'error'})`;
+      logger.log(line);
+    }
+    return;
+  }
+
+  const displayOpts = {
+    strict: options.strict === true,
+    showCache: options.verbose === true || options.revalidate === true
+  };
+  displaySystemTrustRollupTTY(systemKey || appName, results, displayOpts);
+
+  if (!options.verbose) return;
+
+  for (const row of results) {
+    if (!row.trustRun) continue;
+    displayAgentTrustRunTTY(row.trustRun, {
+      environment: options.env,
+      verbose: true,
+      noSync: options.noSync === true,
+      strict: options.strict === true
+    });
+  }
+}
+
+async function runTestTrustCommandAction(appName, options, cmd) {
+  const opts = normalizeTestTrustCliOptions(options, cmd);
+  const pathsUtil = require('../utils/paths');
+  const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+  if (!appType || appType.baseDir !== 'integration') {
+    throw new Error(
+      'test-trust applies to external integration folders only (integration/<systemKey>/).'
+    );
+  }
+  const { success, results, systemKey } = await runTestTrustForExternalSystem(appName, {
+    env: opts.env,
+    verbose: opts.verbose,
+    debug: opts.debug,
+    noSync: opts.noSync === true,
+    revalidate: opts.revalidate === true,
+    summary: opts.summary === true,
+    timeout: opts.timeout
+  });
+  displaySystemTrustResults(systemKey, appName, results, opts);
+  await writeSystemTrustDebugLogs(appName, results, opts);
+  const exitCode = computeSystemExitCodeFromTrustRows(results, {
+    warningsAsErrors: opts.warningsAsErrors === true,
+    strict: opts.strict === true
+  });
+  if (exitCode !== 0) process.exit(exitCode);
+  if (!success) process.exit(1);
+}
+
+async function testTrustCommandHandler(appName, options, cmd) {
+  try {
+    await runTestTrustCommandAction(appName, options, cmd);
+  } catch (error) {
+    handleCommandError(error, 'test-trust');
+    process.exit(3);
+  }
+}
+
+module.exports = {
+  runTestTrustCommandAction,
+  testTrustCommandHandler
+};

package/lib/commands/test-trust-external.js

@@ -0,0 +1,127 @@
+/**
+ * @fileoverview test-trust <systemKey> — semantic agent metadata validation for all datasources.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { getConfig } = require('../core/config');
+const { setupIntegrationTestAuth } = require('../external-system/test-auth');
+const { runDatasourceAgentTrust } = require('../datasource/agent-trust-run');
+const { resolveExternalIntegrationContext } = require('./test-e2e-external');
+
+/**
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {Promise<{ authConfig: Object, dataplaneUrl: string }|null>}
+ */
+async function syncLocalIfRequested(systemKey, options) {
+  if (cliOptsSkipSync(options)) return null;
+  const { uploadExternalSystem } = require('./upload');
+  logger.log(chalk.cyan('Syncing local config to dataplane…'));
+  const uploadCtx = await uploadExternalSystem(systemKey, {
+    minimal: true,
+    verbose: !!options.verbose
+  });
+  logger.log(chalk.green('✔ Sync complete'));
+  return uploadCtx && uploadCtx.dataplaneUrl && uploadCtx.authConfig ? uploadCtx : null;
+}
+
+function pushTrustResult(results, key, trustRun, apiError) {
+  const failed =
+    apiError ||
+    !trustRun ||
+    trustRun.trustDecision === 'notTrusted' ||
+    trustRun.validationStatus === 'failed';
+  results.push({
+    key,
+    success: !failed,
+    error: failed
+      ? apiError
+        ? apiError.message || String(apiError)
+        : trustRun.summary || 'Trust validation failed'
+      : undefined,
+    trustRun
+  });
+}
+
+/**
+ * @async
+ * @param {Object|null} uploadCtx
+ * @param {string} externalSystem
+ * @param {Object} options
+ * @returns {Promise<{ authConfig: Object, dataplaneUrl: string }>}
+ */
+async function resolveTrustAuthContext(uploadCtx, externalSystem, options) {
+  if (uploadCtx) {
+    return { authConfig: uploadCtx.authConfig, dataplaneUrl: uploadCtx.dataplaneUrl };
+  }
+  const configObj = await getConfig();
+  return setupIntegrationTestAuth(externalSystem, { environment: options.env }, configObj);
+}
+
+/**
+ * @async
+ * @param {string[]} keys
+ * @param {Object} runOpts
+ * @param {Array<Object>} results
+ */
+async function runTrustForDatasourceKeys(keys, runOpts, results) {
+  for (const key of keys) {
+    try {
+      const { trustRun, apiError } = await runDatasourceAgentTrust(key, runOpts);
+      pushTrustResult(results, key, trustRun, apiError);
+    } catch (err) {
+      results.push({ key, success: false, error: err.message, trustRun: null });
+    }
+  }
+}
+
+/**
+ * @async
+ * @param {string} externalSystem
+ * @param {Object} options
+ * @returns {Promise<{ success: boolean, results: Array<Object>, systemKey: string }>}
+ */
+async function runTestTrustForExternalSystem(externalSystem, options = {}) {
+  const { systemKey, keys } = resolveExternalIntegrationContext(externalSystem);
+  if (keys.length === 0) {
+    logger.log(chalk.yellow(`No datasources found for ${externalSystem}.`));
+    return { success: true, results: [], systemKey };
+  }
+
+  const uploadCtx = await syncLocalIfRequested(systemKey, options);
+  if (options.revalidate === true) {
+    logger.log(chalk.cyan('Forcing revalidation (cache bypass) for each datasource…'));
+  }
+
+  const { authConfig, dataplaneUrl } = await resolveTrustAuthContext(
+    uploadCtx,
+    externalSystem,
+    options
+  );
+  const results = [];
+  await runTrustForDatasourceKeys(
+    keys,
+    {
+      app: externalSystem,
+      environment: options.env,
+      noSync: true,
+      revalidate: options.revalidate === true,
+      summary: options.summary === true,
+      timeout: options.timeout,
+      authConfig,
+      dataplaneUrl
+    },
+    results
+  );
+  return { success: results.every(r => r.success), results, systemKey };
+}
+
+module.exports = {
+  runTestTrustForExternalSystem
+};