@aifabrix/builder 2.49.1 → 2.50.0

package/lib/commands/app.js

@@ -17,17 +17,17 @@ const { registerApplication } = require('../app/register');
 const { rotateSecret } = require('../app/rotate-secret');
 const { showApp } = require('../app/show');
 const { runAppDeploymentList } = require('./deployment-list');
-const { isChannelTargetKey } = require('../channels/channel-targets');
-const { addChannelCommand } = require('../channels/add-channel');
+const { registerChannelAddCommand } = require('./channel-add-setup');
 
 const APP_HELP_AFTER = `
 Subcommands:
   register <appKey>     Register app; get pipeline client id/secret
-  list                  Applications in current environment
+  list                  Controller applications only (not connected systems)
   rotate-secret <key>   New ClientSecret (shown once)
-  show <key>            From controller (like show --online)
+  show <key>            Controller application details (pipeline apps only)
   deployment <key>      Deployment history for app
-  add-channel <target>  Configure assistant channel install (after deploy)
+
+Connected systems and channels: aifabrix list · aifabrix channel · aifabrix show <systemKey> --online
 
 Requires: aifabrix login
 `;
@@ -51,7 +51,7 @@ function setupAppRegisterCommand(app) {
 
 function setupAppListCommand(app) {
   app.command('list')
-    .description('List apps in current environment')
+    .description('List controller applications (excludes connected systems)')
     .action(async(options) => {
       try {
         await listApplications(options);
@@ -91,7 +91,8 @@ function setupAppShowCommand(app) {
           online: true,
           json: !!options.json,
           permissions: !!options.permissions,
-          verifyCert: options.verifyCert === true
+          verifyCert: options.verifyCert === true,
+          appsOnly: true
         });
       } catch (error) {
         logger.error(chalk.red(`Error: ${error.message}`));
@@ -121,41 +122,12 @@ function setupAppDeploymentCommand(app) {
     });
 }
 
-function setupAppAddChannelCommand(app) {
-  app.command('add-channel <channelTarget>')
-    .description(
-      'Configure assistant channel install (teams-bot, slack, …) after aifabrix deploy <target>'
-    )
-    .requiredOption('-n, --name <name>', 'Customer-visible channel name')
-    .option('-d, --description <text>', 'Channel description (default generated)')
-    .option('--icon <path>', 'Path to channel icon asset')
-    .option('--template <name>', 'Template override (default from channel target)')
-    .option('--dry-run', 'Generate artifacts only; do not patch external system or credentials')
-    .option('--force', 'Regenerate artifacts and patch config (does not rotate secrets)')
-    .option('--probe', 'After install, validate callbacks and assistant catalog')
-    .action(async(channelTarget, options) => {
-      try {
-        if (!isChannelTargetKey(channelTarget)) {
-          throw new Error(
-            `Unknown channel target "${channelTarget}". Use teams-bot, slack, microsoft-copilot, or chatgpt.`
-          );
-        }
-        await addChannelCommand(channelTarget, {
-          name: options.name,
-          description: options.description,
-          icon: options.icon,
-          template: options.template,
-          dryRun: options.dryRun === true,
-          force: options.force === true,
-          probe: options.probe === true
-        });
-      } catch (error) {
-        if (!error.message?.includes('Authentication required')) {
-          logger.error(formatBlockingError('Channel install failed:'), error.message);
-        }
-        process.exit(1);
-      }
-    });
+function setupAppDeprecatedAddChannelAlias(app) {
+  registerChannelAddCommand(app, {
+    commandName: 'add-channel <channelTarget>',
+    hidden: true,
+    deprecatedVia: 'aifabrix app add-channel'
+  });
 }
 
 /**
@@ -169,7 +141,7 @@ function setupAppCommands(program) {
   setupAppRotateSecretCommand(app);
   setupAppShowCommand(app);
   setupAppDeploymentCommand(app);
-  setupAppAddChannelCommand(app);
+  setupAppDeprecatedAddChannelAlias(app);
 }
 
 module.exports = { setupAppCommands };

package/lib/commands/channel-add-setup.js

@@ -0,0 +1,110 @@
+/**
+ * Register `channel add` (and optional deprecated aliases).
+ *
+ * @fileoverview Shared Commander wiring for assistant channel install (plan 152)
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+const { isChannelTargetKey } = require('../channels/channel-targets');
+const { addChannelCommand } = require('../channels/add-channel');
+
+const CHANNEL_ADD_HELP_AFTER = `
+
+Examples:
+  # After upload/deploy of the communication external system
+  $ aifabrix channel add slack --name "Elsa"
+  $ aifabrix channel add teams-bot --name "Elsa" --description "Enterprise AI assistant for employees"
+
+  # Slack slash-command prefix (registers /{prefix}-help in manifest)
+  $ aifabrix channel add slack --name "Elsa" --command-prefix af
+
+  # Generate artifacts only; no dataplane patch
+  $ aifabrix channel add slack --name "Elsa" --dry-run
+
+  # Regenerate artifacts and patch config (does not rotate secrets)
+  $ aifabrix channel add slack --name "Elsa" --force
+
+  # Validate callbacks and assistant catalog after install
+  $ aifabrix channel add slack --name "Elsa" --probe
+
+Prerequisites: aifabrix upload <target> (or deploy) and aifabrix login
+`;
+
+/**
+ * @param {string} channelTarget
+ * @param {Object} options
+ * @param {{ deprecatedVia?: string }} [meta]
+ */
+async function runChannelAddAction(channelTarget, options, meta = {}) {
+  if (meta.deprecatedVia) {
+    logger.warn(
+      chalk.yellow(
+        `Deprecated: use "aifabrix channel add ${channelTarget} ..." instead of "${meta.deprecatedVia}".`
+      )
+    );
+  }
+  if (!isChannelTargetKey(channelTarget)) {
+    throw new Error(
+      `Unknown channel target "${channelTarget}". Use teams-bot, slack, microsoft-copilot, or chatgpt.`
+    );
+  }
+  await addChannelCommand(channelTarget, {
+    name: options.name,
+    description: options.description,
+    icon: options.icon,
+    template: options.template,
+    commandPrefix: options.commandPrefix,
+    dryRun: options.dryRun === true,
+    force: options.force === true,
+    probe: options.probe === true
+  });
+}
+
+/**
+ * @param {import('commander').Command} parent
+ * @param {{ deprecatedVia?: string, commandName?: string, hidden?: boolean }} [meta]
+ * @returns {import('commander').Command}
+ */
+function registerChannelAddCommand(parent, meta = {}) {
+  const description =
+    'Configure channel install (manifest, credentials, admin guide) after upload/deploy';
+  const commandName = meta.commandName || 'add <channelTarget>';
+  const cmd = meta.hidden
+    ? parent.command(commandName, { hidden: true })
+    : parent.command(commandName);
+  cmd
+    .description(meta.deprecatedVia ? `(deprecated) ${description}` : description)
+    .requiredOption('-n, --name <name>', 'Customer-visible channel name (e.g. "Elsa")')
+    .option('-d, --description <text>', 'Channel description (default generated)')
+    .option('--icon <path>', 'Path to channel icon asset')
+    .option('--template <name>', 'Template override (default from channel target)')
+    .option('--dry-run', 'Generate artifacts only; do not patch external system or credentials')
+    .option('--force', 'Regenerate artifacts and patch config (does not rotate secrets)')
+    .option(
+      '--command-prefix <key>',
+      'Slack slash alias prefix (default af) — registers /{prefix}-help etc. in manifest'
+    )
+    .option('--probe', 'After install, validate callbacks and assistant catalog')
+    .addHelpText('after', CHANNEL_ADD_HELP_AFTER)
+    .action(async(channelTarget, options) => {
+      try {
+        await runChannelAddAction(channelTarget, options, meta);
+      } catch (error) {
+        if (!error.message?.includes('Authentication required')) {
+          logger.error(formatBlockingError('Channel install failed:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+  return cmd;
+}
+
+module.exports = {
+  CHANNEL_ADD_HELP_AFTER,
+  registerChannelAddCommand,
+  runChannelAddAction
+};

package/lib/commands/channel.js

@@ -1,18 +1,43 @@
 /**
  * Channel CLI commands (plan 152).
  *
- * @fileoverview Scaffold communication external systems for channel deploy step 1
+ * @fileoverview Scaffold and install assistant communication channels (Slack, Teams, …)
  * @author AI Fabrix Team
- * @version 1.0.0
+ * @version 1.1.0
  */
 
 'use strict';
 
 const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { formatSuccessLine, formatBlockingError, sectionTitle, metadata } = require('../utils/cli-test-layout-chalk');
+const {
+  formatSuccessLine,
+  formatBlockingError,
+  sectionTitle,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
 const { CHANNEL_TARGET_KEYS, isChannelTargetKey } = require('../channels/channel-targets');
 const { scaffoldChannelIntegration } = require('../channels/channel-integration-generator');
+const { registerChannelAddCommand } = require('./channel-add-setup');
+
+const CHANNEL_HELP_AFTER = `
+Subcommands:
+  scaffold <target>   Create integration/<target>/ files locally (step 1)
+  add <target>        Channel install guide + manifest/credential patch (step 3)
+
+Targets:
+  teams-bot, slack, microsoft-copilot, chatgpt
+  web-embed (experimental — scaffold with --allow-experimental)
+
+Typical flow (channels are connected systems, not controller apps):
+  aifabrix channel scaffold slack
+  aifabrix upload slack --force
+  aifabrix channel add slack --name "Elsa" --probe
+
+Controller pipeline apps only: aifabrix app register · aifabrix app list
+
+Requires: aifabrix login (for add)
+`;
 
 /**
  * @param {import('commander').Command} program
@@ -20,11 +45,16 @@ const { scaffoldChannelIntegration } = require('../channels/channel-integration-
 function setupChannelCommands(program) {
   const channel = program
     .command('channel')
-    .description('Assistant channel integration scaffolds (plan 152)');
+    .description(
+      'Assistant channels (Slack, Teams, Copilot, ChatGPT) — scaffold integration and install'
+    )
+    .addHelpText('after', CHANNEL_HELP_AFTER);
 
   channel
     .command('scaffold <channelTarget>')
-    .description('Generate integration/<target>/ communication external system for deploy step 1')
+    .description(
+      'Generate integration/<target>/ communication external system (local files only)'
+    )
     .option('--force', 'Overwrite generated scaffold files when folder exists')
     .option('--allow-experimental', 'Allow web-embed scaffold')
     .action(async(channelTarget, options) => {
@@ -34,7 +64,7 @@ function setupChannelCommands(program) {
             `Unknown channel target "${channelTarget}". Expected: ${CHANNEL_TARGET_KEYS.join(', ')}`
           );
         }
-        const result = scaffoldChannelIntegration(channelTarget, {
+        const result = await scaffoldChannelIntegration(channelTarget, {
           force: options.force === true,
           allowExperimental: options.allowExperimental === true
         });
@@ -46,13 +76,17 @@ function setupChannelCommands(program) {
         }
         logger.log('');
         logger.log(chalk.white('Next steps:'));
-        logger.log(chalk.gray(`  aifabrix deploy ${channelTarget}`));
-        logger.log(chalk.gray(`  aifabrix app add-channel ${channelTarget} --name "Your Assistant"`));
+        logger.log(chalk.gray(`  aifabrix upload ${channelTarget} --force`));
+        logger.log(
+          chalk.gray(`  aifabrix channel add ${channelTarget} --name "Your Assistant" --probe`)
+        );
       } catch (error) {
         logger.error(formatBlockingError(error.message || String(error)));
         process.exit(1);
       }
     });
+
+  registerChannelAddCommand(channel);
 }
 
 module.exports = { setupChannelCommands };

package/lib/commands/datasource-sync-display.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview TTY/JSON output for post-publish datasource data sync.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const {
+  formatProgress,
+  formatSuccessLine,
+  formatWarningLine,
+  infoLine,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
+
+const SKIP_REASON_LABELS = {
+  has_data: 'records already present',
+  no_connectivity: 'datasource not available on dataplane',
+  skipped: 'sync disabled'
+};
+
+/**
+ * @param {Object|null|undefined} result
+ * @param {Object} [options]
+ * @param {boolean} [options.syncExplicit]
+ * @returns {boolean}
+ */
+function shouldEmitDatasourceSyncSummary(result, options = {}) {
+  if (!result || options.json === true) {
+    return false;
+  }
+  // Default upload/deploy: bootstrap may run, but output only when user passed --sync.
+  if (options.syncExplicit !== true) {
+    return false;
+  }
+  const executed = result.executed || [];
+  const skipped = result.skipped || [];
+  return executed.length > 0 || skipped.length > 0;
+}
+
+/**
+ * @param {Object} row
+ * @returns {string}
+ */
+function formatSkippedSyncLine(row) {
+  const detail = SKIP_REASON_LABELS[row.reason] || row.reason;
+  if (row.reason === 'has_data') {
+    return metadata(`  ${row.datasourceKey}: ${detail} (bootstrap not needed)`);
+  }
+  return formatWarningLine(`  Skipped ${row.datasourceKey}: ${detail}`);
+}
+
+/**
+ * @param {Object} result
+ * @param {Object} [options]
+ * @param {boolean} [options.json]
+ * @param {boolean} [options.syncExplicit]
+ * @param {string} [options.label]
+ */
+function logDatasourceSyncSummary(result, options = {}) {
+  if (!shouldEmitDatasourceSyncSummary(result, options)) {
+    return;
+  }
+  const label = options.label || 'Data sync';
+  logger.log('');
+  logger.log(infoLine(label));
+  for (const row of result.skipped || []) {
+    if (!options.syncExplicit && row.reason === 'has_data') {
+      continue;
+    }
+    logger.log(formatSkippedSyncLine(row));
+  }
+  for (const row of result.executed || []) {
+    if (row.syncJobId) {
+      logger.log(
+        formatSuccessLine(
+          `  Synced ${row.datasourceKey} (${row.reason}; syncJobId ${row.syncJobId})`
+        )
+      );
+      continue;
+    }
+    const warn = row.warning ? ` — ${row.warning}` : '';
+    logger.log(formatWarningLine(`  Sync failed ${row.datasourceKey}${warn}`));
+  }
+  if ((result.executed || []).length === 0 && (result.skipped || []).length === 0) {
+    logger.log(formatProgress('  No datasource keys to evaluate.'));
+  }
+}
+
+module.exports = {
+  logDatasourceSyncSummary,
+  shouldEmitDatasourceSyncSummary,
+  SKIP_REASON_LABELS
+};

package/lib/commands/datasource-sync-policy.js

@@ -0,0 +1,210 @@
+/**
+ * @fileoverview Bootstrap vs explicit datasource data sync policy for upload/deploy.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getDatasource, getDatasourceStatus } = require('../api/datasources-core.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const { assertDatasourceExistsOnDataplane } = require('../protection/preflight-datasource-ready');
+const { syncDatasourceAfterProtectionUpload } = require('../protection/sync-after-upload');
+
+/**
+ * @param {Object|null|undefined} row
+ * @returns {number|null}
+ */
+function readRecordCountFromRow(row) {
+  if (!row || typeof row !== 'object') {
+    return null;
+  }
+  const candidates = [
+    row.recordCount,
+    row.totalRecords,
+    row.activeRecords,
+    row.data?.recordCount,
+    row.data?.totalRecords,
+    row.data?.activeRecords,
+    row.stats?.recordCount,
+    row.stats?.totalRecords
+  ];
+  for (const value of candidates) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} datasourceKey
+ * @param {Map<string, number|null>} [cache]
+ * @returns {Promise<number|null>}
+ */
+async function resolveDatasourceRecordCount(dataplaneUrl, authConfig, datasourceKey, cache) {
+  const key = String(datasourceKey || '').trim();
+  if (!key) {
+    return null;
+  }
+  if (cache && cache.has(key)) {
+    return cache.get(key);
+  }
+
+  let count = null;
+  try {
+    const statusRes = await getDatasourceStatus(dataplaneUrl, key, authConfig);
+    count = readRecordCountFromRow(unwrapApiData(statusRes));
+  } catch {
+    count = null;
+  }
+
+  if (count === null) {
+    try {
+      const dsRes = await getDatasource(dataplaneUrl, key, authConfig);
+      count = readRecordCountFromRow(unwrapApiData(dsRes));
+    } catch {
+      count = null;
+    }
+  }
+
+  if (cache) {
+    cache.set(key, count);
+  }
+  return count;
+}
+
+/**
+ * Bootstrap preflight: datasource is deployed and readable on the dataplane.
+ * Does not call legacy POST /external/{key}/test (removed from dataplane OpenAPI).
+ *
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string} datasourceKey
+ * @returns {Promise<boolean>}
+ */
+async function checkDatasourceConnectivity(dataplaneUrl, authConfig, datasourceKey) {
+  try {
+    await assertDatasourceExistsOnDataplane(dataplaneUrl, authConfig, datasourceKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} datasourceKey
+ * @param {Object} params
+ * @param {Map<string, number|null>} cache
+ * @returns {Promise<{ datasourceKey: string, bucket: string, reason: string }>}
+ */
+async function evaluateBootstrapSyncCandidate(datasourceKey, params, cache) {
+  const count = await resolveDatasourceRecordCount(
+    params.dataplaneUrl,
+    params.authConfig,
+    datasourceKey,
+    cache
+  );
+  if (typeof count === 'number' && count > 0) {
+    return { datasourceKey, bucket: 'skipped', reason: 'has_data' };
+  }
+  const connected = await checkDatasourceConnectivity(
+    params.dataplaneUrl,
+    params.authConfig,
+    datasourceKey
+  );
+  if (!connected) {
+    return { datasourceKey, bucket: 'skipped', reason: 'no_connectivity' };
+  }
+  return { datasourceKey, bucket: 'run', reason: 'bootstrap' };
+}
+
+/**
+ * @param {Object} params
+ * @param {boolean} [params.syncExplicit]
+ * @param {boolean} [params.skipSync]
+ * @param {string[]} params.datasourceKeys
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @returns {Promise<{ run: Object[], skipped: Object[] }>}
+ */
+async function resolveSyncPlan(params) {
+  const keys = [
+    ...new Set((params.datasourceKeys || []).map((k) => String(k || '').trim()).filter(Boolean))
+  ];
+  const skipped = [];
+  const run = [];
+  const cache = new Map();
+
+  if (params.skipSync === true) {
+    keys.forEach((datasourceKey) => skipped.push({ datasourceKey, reason: 'skipped' }));
+    return { run, skipped };
+  }
+
+  if (params.syncExplicit === true) {
+    keys.forEach((datasourceKey) => run.push({ datasourceKey, reason: 'explicit' }));
+    return { run, skipped };
+  }
+
+  for (const datasourceKey of keys) {
+    const decision = await evaluateBootstrapSyncCandidate(datasourceKey, params, cache);
+    if (decision.bucket === 'skipped') {
+      skipped.push({ datasourceKey: decision.datasourceKey, reason: decision.reason });
+      continue;
+    }
+    run.push({ datasourceKey: decision.datasourceKey, reason: decision.reason });
+  }
+  return { run, skipped };
+}
+
+/**
+ * @param {{ run: Object[] }} plan
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @returns {Promise<{ executed: Object[], skipped: Object[] }>}
+ */
+async function executeSyncPlan(plan, dataplaneUrl, authConfig) {
+  const executed = [];
+  for (const item of plan.run) {
+    const syncResult = await syncDatasourceAfterProtectionUpload(
+      dataplaneUrl,
+      authConfig,
+      item.datasourceKey
+    );
+    executed.push({ ...item, ...syncResult });
+  }
+  return { executed, skipped: plan.skipped || [] };
+}
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {string[]} datasourceKeys
+ * @returns {Promise<'never'|'auto'>}
+ */
+async function resolveE2eSyncModeWhenPopulated(dataplaneUrl, authConfig, datasourceKeys) {
+  const keys = [
+    ...new Set((datasourceKeys || []).map((k) => String(k || '').trim()).filter(Boolean))
+  ];
+  if (keys.length === 0) {
+    return 'auto';
+  }
+  const cache = new Map();
+  for (const key of keys) {
+    const count = await resolveDatasourceRecordCount(dataplaneUrl, authConfig, key, cache);
+    if (count === null || count === 0) {
+      return 'auto';
+    }
+  }
+  return 'never';
+}
+
+module.exports = {
+  readRecordCountFromRow,
+  resolveDatasourceRecordCount,
+  resolveSyncPlan,
+  executeSyncPlan,
+  resolveE2eSyncModeWhenPopulated
+};

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

@@ -13,7 +13,7 @@ const { writeTrustDebugLogAndPrint } = require('../datasource/agent-trust-debug-
 const { displayAgentTrustRunTTY } = require('../utils/agent-trust-run-display');
 const { computeExitCodeFromTrustRun } = require('../utils/agent-trust-run-exit');
 const { attachDatasourceTestCommonOptions } = require('./datasource-unified-test-cli.options');
-const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { cliOptsSkipPublish } = require('../utils/cli-sync-options');
 
 function datasourceVerifyTrustHelpAfter() {
   return `
@@ -25,7 +25,7 @@ Examples:
 
 Notes:
   - Semantic trust only (agent metadata validation). For live API proof use test-e2e.
-  - Local files are published before run unless --no-sync.
+  - Local files are published before run unless --no-publish.
   - With --debug, JSON is saved under integration/<app>/logs/ (verify-trust-<key>-*.json). View with: aifabrix datasource log-trust <key>
 `;
 }
@@ -34,7 +34,7 @@ async function runDatasourceVerifyTrustOnce(datasourceKey, options) {
   const { trustRun, apiError } = await runDatasourceAgentTrust(datasourceKey, {
     app: options.app,
     environment: options.env,
-    noSync: options.noSync === true,
+    noPublish: options.noPublish === true,
     force: options.force === true,
     revalidate: options.revalidate === true,
     summary: options.summary === true,
@@ -48,7 +48,7 @@ async function finalizeDatasourceVerifyTrust(datasourceKey, options, result) {
     json: options.json,
     verbose: options.verbose,
     environment: options.env,
-    noSync: options.noSync === true,
+    noPublish: options.noPublish === true,
     strict: options.strict === true
   };
   if (options.json) {
@@ -70,7 +70,7 @@ async function finalizeDatasourceVerifyTrust(datasourceKey, options, result) {
 
 async function datasourceVerifyTrustAction(datasourceKey, options, cmd) {
   try {
-    const merged = { ...options, noSync: cliOptsSkipSync(options, cmd) };
+    const merged = { ...options, noPublish: cliOptsSkipPublish(options, cmd) };
     const result = await runDatasourceVerifyTrustOnce(datasourceKey, merged);
     const { resolveAppKeyForDatasource } = require('../datasource/resolve-app');
     const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
@@ -97,7 +97,7 @@ function attachDatasourceTrustOptions(cmd) {
     timeoutDefault: '120000'
   });
   cmd
-    .option('--no-sync', 'Skip publishing local integration files before validate')
+    .option('--no-publish', 'Skip publishing local integration files before validate')
     .option('--revalidate', 'Force new validation (ignore inputHash cache)')
     .option('--strict', 'Exit 1 unless trustDecision is trusted');
 }

package/lib/commands/datasource-unified-test-cli.js

@@ -47,7 +47,8 @@ async function writeDatasourceTestDebugLogIfRequested(appKey, datasourceKey, res
   const requestMeta = {
     datasourceKey,
     runType: 'test',
-    includeDebug: includeDebugForRequest(options.debug)
+    includeDebug: includeDebugForRequest(options.debug),
+    explainCertification: includeDebugForRequest(options.debug)
   };
   const envelope = result && typeof result === 'object' ? result.envelope : null;
   const apiError = result && typeof result === 'object' ? result.apiError : null;