@aifabrix/builder 2.45.0 → 2.45.5

package/lib/commands/protection-cli-leaves.js

@@ -0,0 +1,286 @@
+/**
+ * @fileoverview Protection subcommand registration (keeps setupProtectionCommands under line limit).
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { resolveProtectionArgument } = require('../protection/resolve');
+const {
+  runProtectionValidate,
+  runProtectionUpload,
+  runProtectionList,
+  runProtectionShow,
+  runProtectionDelete
+} = require('../protection/run-commands');
+const { runProtectionCreate } = require('../protection/run-protection-create');
+
+const SHARED_OPTS = [
+  ['-e, --env <environment>', 'Environment key'],
+  ['-v, --verbose', 'Verbose output']
+];
+
+const PROTECTION_CREATE_HELP_AFTER = `
+
+Examples:
+  $ aifabrix protection create hubspot-companies --type country-sales
+  $ aifabrix protection create hr-persons --type department-manager
+  $ aifabrix protection create erp-projects --type project-team
+  $ aifabrix protection create hubspot-companies --dimension-key country --dry-run
+  $ aifabrix protection create hubspot-companies --type country-sales --force
+
+Preset types:
+  country-sales, department-manager, customer-team, project-team, static-region, owner-direct
+`;
+
+const PROTECTION_VALIDATE_HELP_AFTER = `
+
+Examples:
+  $ aifabrix protection validate hubspot-companies
+  $ aifabrix protection validate hubspot-companies --simulate
+  $ aifabrix protection validate hubspot-companies --warnings-as-errors
+  $ aifabrix protection validate hubspot-companies --json
+`;
+
+const PROTECTION_UPLOAD_HELP_AFTER = `
+
+Examples:
+  $ aifabrix protection upload hubspot-companies
+  $ aifabrix protection upload hubspot-companies --dry-run
+  $ aifabrix protection upload hubspot-companies --no-sync
+`;
+
+const PROTECTION_LIST_HELP_AFTER = `
+
+Examples:
+  $ aifabrix protection list
+  $ aifabrix protection list --page 1 --page-size 50
+  $ aifabrix protection list --filter enabled:eq:true
+  $ aifabrix protection list --json
+`;
+
+const PROTECTION_SHOW_HELP_AFTER = `
+
+Examples:
+  $ aifabrix protection show hubspot-companies
+  $ aifabrix protection show hubspot-companies -v
+  $ aifabrix protection show hubspot-companies --json
+`;
+
+const PROTECTION_DELETE_HELP_AFTER = `
+
+Examples:
+  $ aifabrix protection delete hubspot-companies
+  $ aifabrix protection delete hubspot-companies --yes
+`;
+
+/**
+ * @param {import('commander').Command} cmd
+ * @param {string} name
+ * @param {string} description
+ * @param {Function} action
+ * @param {Array<[string, string]>} extraOpts
+ * @param {string} helpAfter
+ */
+function addProtectionLeaf(cmd, name, description, action, extraOpts = [], helpAfter = '') {
+  const leaf = cmd.command(name).description(description);
+  for (const [flags, desc] of [...SHARED_OPTS, ...extraOpts]) {
+    leaf.option(flags, desc);
+  }
+  if (helpAfter) {
+    leaf.addHelpText('after', helpAfter);
+  }
+  leaf.action(async(datasourceKey, options) => {
+    try {
+      const code = await action(datasourceKey, options);
+      if (code && code !== 0) process.exit(code);
+    } catch (err) {
+      const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+      logger.error(formatBlockingError(err.message || String(err)));
+      process.exit(1);
+    }
+  });
+}
+
+/**
+ * @param {import('commander').Command} protection
+ */
+function registerProtectionCreate(protection) {
+  const leaf = protection
+    .command('create <datasourceKey>')
+    .description(
+      'Probe dataplane datasource + Controller dimension, then scaffold under integration/.protection/'
+    );
+  for (const [flags, desc] of SHARED_OPTS) {
+    leaf.option(flags, desc);
+  }
+  leaf
+    .option('--type <type>', 'Preset type (country-sales, department-manager, customer-team, project-team, static-region, owner-direct)')
+    .option('--dimension-key <key>', 'Dimension catalog key (inferred from --type when omitted)')
+    .option('--field <name>', 'Metadata field used by preset value templates when needed')
+    .option('--fk-name <name>', 'FK binding name in expressions (default: same as dimension key)')
+    .option('--protection-key <key>', 'metadata.key (default: <datasource>-<dimension>-access)')
+    .option('--display-name <text>', 'metadata.displayName')
+    .option('--rule-key <key>', 'Rule key inside spec.rules[0]')
+    .option('--principal-expression <expr>', 'Group principal expression (default: Sales {{fk.<fk>.metadata.iso3}} Users)')
+    .option('--value-expression <expr>', 'Grant valueExpression (default: {{fk.<fk>.metadata.iso2}})')
+    .option('--dry-run', 'Print YAML to stdout; do not write file')
+    .option('--force', 'Overwrite existing integration/.protection/<datasourceKey> manifest')
+    .option('--disabled', 'Set spec.enabled to false', false)
+    .addHelpText('after', PROTECTION_CREATE_HELP_AFTER)
+    .action(async(datasourceKey, options) => {
+      try {
+        const code = await runProtectionCreate(datasourceKey, {
+          ...options,
+          dryRun: options.dryRun === true,
+          force: options.force === true,
+          verbose: options.verbose === true,
+          disabled: options.disabled === true
+        }, logger);
+        if (code && code !== 0) process.exit(code);
+      } catch (err) {
+        const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+        if (Array.isArray(err.probeLines)) {
+          for (const line of err.probeLines) {
+            logger.log(line);
+          }
+        }
+        logger.error(formatBlockingError(err.message || String(err)));
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * @param {import('commander').Command} protection
+ */
+function registerProtectionValidate(protection) {
+  addProtectionLeaf(
+    protection,
+    'validate <datasourceKey>',
+    'Validate protection manifest (local schema + dataplane)',
+    async(datasourceKey, options) => {
+      const resolved = resolveProtectionArgument(datasourceKey);
+      return runProtectionValidate(resolved.datasourceKey, resolved.manifest, {
+        ...options,
+        manifestPath: resolved.manifestPath,
+        warningsAsErrors: options.warningsAsErrors === true,
+        simulate: options.simulate === true,
+        json: options.json === true,
+        verbose: options.verbose === true
+      }, logger);
+    },
+    [
+      ['--json', 'Output dataplane report as JSON'],
+      ['--warnings-as-errors', 'Pass strict=true to dataplane validate'],
+      ['--simulate', 'Run simulate after validate passes']
+    ],
+    PROTECTION_VALIDATE_HELP_AFTER
+  );
+}
+
+/**
+ * @param {import('commander').Command} protection
+ */
+function registerProtectionUpload(protection) {
+  addProtectionLeaf(
+    protection,
+    'upload <datasourceKey>',
+    'Validate and upload protection manifest to dataplane',
+    async(datasourceKey, options) => {
+      const resolved = resolveProtectionArgument(datasourceKey);
+      return runProtectionUpload(resolved.datasourceKey, resolved.manifest, {
+        ...options,
+        manifestPath: resolved.manifestPath,
+        warningsAsErrors: options.warningsAsErrors === true,
+        dryRun: options.dryRun === true,
+        noSync: options.noSync === true,
+        verbose: options.verbose === true
+      }, logger);
+    },
+    [
+      ['--dry-run', 'Validate only; no upload or sync'],
+      ['--no-sync', 'Skip datasource sync after upload']
+    ],
+    PROTECTION_UPLOAD_HELP_AFTER
+  );
+}
+
+/**
+ * @param {import('commander').Command} protection
+ */
+function registerProtectionList(protection) {
+  const leaf = protection.command('list').description('List deployed protection manifests on dataplane');
+  for (const [flags, desc] of SHARED_OPTS) {
+    leaf.option(flags, desc);
+  }
+  leaf
+    .option('--json', 'Output paginated list as JSON')
+    .option('--page <n>', 'Page (1-based)', (v) => parseInt(v, 10))
+    .option('--page-size <n>', 'Page size', (v) => parseInt(v, 10))
+    .option('--filter <expr>', 'Filter (e.g. enabled:eq:true)')
+    .addHelpText('after', PROTECTION_LIST_HELP_AFTER)
+    .action(async(options) => {
+      try {
+        const code = await runProtectionList(
+          {
+            ...options,
+            json: options.json === true,
+            verbose: options.verbose === true
+          },
+          logger
+        );
+        if (code && code !== 0) process.exit(code);
+      } catch (err) {
+        const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+        logger.error(formatBlockingError(err.message || String(err)));
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * @param {import('commander').Command} protection
+ */
+function registerProtectionShow(protection) {
+  addProtectionLeaf(
+    protection,
+    'show <datasourceKey>',
+    'Show deployed protection state from dataplane',
+    async(datasourceKey, options) =>
+      runProtectionShow(datasourceKey, {
+        ...options,
+        json: options.json === true,
+        verbose: options.verbose === true
+      }, logger),
+    [['--json', 'Output merged manifest + status as JSON']],
+    PROTECTION_SHOW_HELP_AFTER
+  );
+}
+
+/**
+ * @param {import('commander').Command} protection
+ */
+function registerProtectionDelete(protection) {
+  addProtectionLeaf(
+    protection,
+    'delete <datasourceKey>',
+    'Delete deployed protection for datasource',
+    async(datasourceKey, options) =>
+      runProtectionDelete(datasourceKey, {
+        ...options,
+        yes: options.yes === true
+      }, logger),
+    [['--yes', 'Skip confirmation prompt']],
+    PROTECTION_DELETE_HELP_AFTER
+  );
+}
+
+module.exports = {
+  registerProtectionCreate,
+  registerProtectionValidate,
+  registerProtectionUpload,
+  registerProtectionList,
+  registerProtectionShow,
+  registerProtectionDelete
+};

package/lib/commands/protection.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Protection manifest CLI commands.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const {
+  registerProtectionCreate,
+  registerProtectionValidate,
+  registerProtectionUpload,
+  registerProtectionList,
+  registerProtectionShow,
+  registerProtectionDelete
+} = require('./protection-cli-leaves');
+
+const PROTECTION_HELP_AFTER = `
+
+Examples:
+  $ aifabrix protection create hubspot-companies --type country-sales
+  $ aifabrix protection validate hubspot-companies --simulate
+  $ aifabrix protection upload hubspot-companies --dry-run
+  $ aifabrix protection list
+  $ aifabrix protection show hubspot-companies
+  $ aifabrix protection delete hubspot-companies --yes
+
+Per-command help:  aifabrix protection <command> --help
+`;
+
+/**
+ * @param {import('commander').Command} program
+ */
+function setupProtectionCommands(program) {
+  const protection = program
+    .command('protection')
+    .description('Manage protection manifests in integration/.protection/ (repo root)')
+    .addHelpText('after', PROTECTION_HELP_AFTER);
+
+  registerProtectionCreate(protection);
+  registerProtectionValidate(protection);
+  registerProtectionUpload(protection);
+  registerProtectionList(protection);
+  registerProtectionShow(protection);
+  registerProtectionDelete(protection);
+}
+
+module.exports = {
+  setupProtectionCommands
+};

package/lib/commands/repair.js

@@ -125,11 +125,21 @@ function applyAuthMethod(ctx) {
   const existingAuth = ctx.systemParsed.authentication || ctx.systemParsed.auth || {};
   const { buildAuthenticationFromMethod } = require('../external-system/generator');
   const newAuth = buildAuthenticationFromMethod(ctx.systemKey, method);
-  const existingVars = existingAuth.variables && typeof existingAuth.variables === 'object' ? existingAuth.variables : {};
-  const mergedVariables = { ...newAuth.variables, ...existingVars };
+  const existingVars =
+    existingAuth.variables && typeof existingAuth.variables === 'object'
+      ? existingAuth.variables
+      : {};
+  // When switching auth method, keep only connectivity fields from the wizard draft.
+  // Do not let OAuth-era variables (tokenUrl, scope, headerName, …) override the new method.
+  const mergedVariables = { ...newAuth.variables };
+  for (const key of ['baseUrl', 'testEndpoint']) {
+    if (existingVars[key] !== undefined && existingVars[key] !== null) {
+      mergedVariables[key] = existingVars[key];
+    }
+  }
   ctx.systemParsed.authentication = {
     ...newAuth,
-    variables: Object.keys(mergedVariables).length ? mergedVariables : newAuth.variables
+    variables: mergedVariables
   };
   if (existingAuth.displayName !== undefined) {
     ctx.systemParsed.authentication.displayName = existingAuth.displayName;

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
+};