@aws-cdk/integ-runner
Version:
CDK Integration Testing Tool
286 lines • 46.3 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseCliArgs = parseCliArgs;
exports.main = main;
exports.cli = cli;
// Exercise all integ stacks and if they deploy, update the expected synth files
const fs = require("fs");
const path = require("path");
const chalk = require("chalk");
const workerpool = require("workerpool");
const logger = require("./logger");
const integration_tests_1 = require("./runner/integration-tests");
const workers_1 = require("./workers");
const integ_watch_worker_1 = require("./workers/integ-watch-worker");
// https://github.com/yargs/yargs/issues/1929
// https://github.com/evanw/esbuild/issues/1492
// eslint-disable-next-line @typescript-eslint/no-require-imports
const yargs = require('yargs');
function parseCliArgs(args = []) {
const argv = yargs
.usage('Usage: integ-runner [TEST...]')
.option('config', {
config: true,
configParser: configFromFile,
default: 'integ.config.json',
desc: 'Load options from a JSON config file. Options provided as CLI arguments take precedent.',
})
.option('watch', { type: 'boolean', default: false, desc: 'Perform integ tests in watch mode' })
.option('list', { type: 'boolean', default: false, desc: 'List tests instead of running them' })
.option('clean', { type: 'boolean', default: true, desc: 'Clean up and delete stack after test is completed (use --no-clean to negate)' })
.option('verbose', { type: 'boolean', default: false, alias: 'v', count: true, desc: 'Verbose logs and metrics on integration tests durations (specify multiple times to increase verbosity)' })
.option('dry-run', { type: 'boolean', default: false, desc: 'do not actually deploy the stack. just update the snapshot (not recommended!)' })
.option('update-on-failed', { type: 'boolean', default: false, desc: 'rerun integration tests and update snapshots for failed tests.' })
.option('force', { type: 'boolean', default: false, desc: 'Rerun all integration tests even if tests are passing' })
.option('parallel-regions', { type: 'array', desc: 'Tests are run in parallel across these regions. To prevent tests from running in parallel, provide only a single region', default: [] })
.options('directory', { type: 'string', default: 'test', desc: 'starting directory to discover integration tests. Tests will be discovered recursively from this directory' })
.options('profiles', { type: 'array', desc: 'list of AWS profiles to use. Tests will be run in parallel across each profile+regions', default: [] })
.options('max-workers', { type: 'number', desc: 'The max number of workerpool workers to use when running integration tests in parallel', default: 16 })
.options('exclude', { type: 'boolean', desc: 'Run all tests in the directory, except the specified TESTs', default: false })
.options('from-file', { type: 'string', desc: 'Read TEST names from a file (one TEST per line)' })
.option('inspect-failures', { type: 'boolean', desc: 'Keep the integ test cloud assembly if a failure occurs for inspection', default: false })
.option('disable-update-workflow', { type: 'boolean', default: false, desc: 'If this is "true" then the stack update workflow will be disabled' })
.option('language', {
alias: 'l',
default: ['javascript', 'typescript', 'python', 'go'],
choices: ['javascript', 'typescript', 'python', 'go'],
type: 'array',
nargs: 1,
desc: 'Use these presets to run integration tests for the selected languages',
})
.option('app', { type: 'string', default: undefined, desc: 'The custom CLI command that will be used to run the test files. You can include {filePath} to specify where in the command the test file path should be inserted. Example: --app="python3.8 {filePath}".' })
.option('test-regex', { type: 'array', desc: 'Detect integration test files matching this JavaScript regex pattern. If used multiple times, all files matching any one of the patterns are detected.', default: [] })
.option('unstable', { type: 'array', desc: 'Opt-in to using unstable features. By using this flags acknowledges that the scope and API of the feature may change without notice. Specify multiple times for each unstable feature you want to opt-in to.', nargs: 1, choices: ['toolkit-lib-engine'], default: [] })
.strict()
.parse(args);
const tests = argv._;
const parallelRegions = arrayFromYargs(argv['parallel-regions']);
const testRegions = parallelRegions ?? ['us-east-1', 'us-east-2', 'us-west-2'];
const profiles = arrayFromYargs(argv.profiles);
const fromFile = argv['from-file'];
const maxWorkers = argv['max-workers'];
const verbosity = argv.verbose;
const verbose = verbosity >= 1;
const numTests = testRegions.length * (profiles ?? [1]).length;
if (maxWorkers < numTests) {
logger.warning('You are attempting to run %s tests in parallel, but only have %s workers. Not all of your profiles+regions will be utilized', numTests, maxWorkers);
}
if (tests.length > 0 && fromFile) {
throw new Error('A list of tests cannot be provided if "--from-file" is provided');
}
const requestedTests = fromFile
? (fs.readFileSync(fromFile, { encoding: 'utf8' })).split('\n').filter(x => x)
: (tests.length > 0 ? tests : undefined); // 'undefined' means no request
return {
tests: requestedTests,
app: argv.app,
testRegex: arrayFromYargs(argv['test-regex']),
testRegions,
originalRegions: parallelRegions,
profiles,
runUpdateOnFailed: (argv['update-on-failed'] ?? false),
fromFile,
exclude: argv.exclude,
maxWorkers,
list: argv.list,
directory: argv.directory,
inspectFailures: argv['inspect-failures'],
verbosity,
verbose,
clean: argv.clean,
force: argv.force,
dryRun: argv['dry-run'],
disableUpdateWorkflow: argv['disable-update-workflow'],
language: arrayFromYargs(argv.language),
watch: argv.watch,
unstable: arrayFromYargs(argv.unstable) ?? [],
};
}
async function main(args) {
const options = parseCliArgs(args);
const engine = engineFromOptions(options).engine;
const testsFromArgs = await new integration_tests_1.IntegrationTests(path.resolve(options.directory)).fromCliOptions(options);
// List only prints the discovered tests
if (options.list) {
process.stdout.write(testsFromArgs.map(t => t.discoveryRelativeFileName).join('\n') + '\n');
return;
}
const pool = workerpool.pool(path.join(__dirname, '..', 'lib', 'workers', 'extract', 'index.js'), {
maxWorkers: options.watch ? 1 : options.maxWorkers,
});
const testsToRun = [];
let destructiveChanges = false;
let failedSnapshots = [];
let testsSucceeded = false;
validateWatchArgs({
...options,
testRegions: options.originalRegions,
tests: testsFromArgs,
});
try {
if (!options.watch) {
// always run snapshot tests, but if '--force' is passed then
// run integration tests on all failed tests, not just those that
// failed snapshot tests
failedSnapshots = await (0, workers_1.runSnapshotTests)(pool, testsFromArgs, {
retain: options.inspectFailures,
verbose: options.verbose,
engine,
});
for (const failure of failedSnapshots) {
logger.warning(`Failed: ${failure.fileName}`);
if (failure.destructiveChanges && failure.destructiveChanges.length > 0) {
printDestructiveChanges(failure.destructiveChanges);
destructiveChanges = true;
}
}
if (!options.force) {
testsToRun.push(...failedSnapshots);
}
else {
// if any of the test failed snapshot tests, keep those results
// and merge with the rest of the tests from args
testsToRun.push(...mergeTests(testsFromArgs.map(t => t.info), failedSnapshots));
}
}
else {
testsToRun.push(...testsFromArgs.map(t => t.info));
}
// run integration tests if `--update-on-failed` OR `--force` is used
if (options.runUpdateOnFailed || options.force) {
const { success, metrics } = await (0, workers_1.runIntegrationTests)({
pool,
engine,
tests: testsToRun,
regions: options.testRegions,
profiles: options.profiles,
clean: options.clean,
dryRun: options.dryRun,
verbosity: options.verbosity,
updateWorkflow: !options.disableUpdateWorkflow,
watch: options.watch,
});
testsSucceeded = success;
if (options.clean === false) {
logger.warning('Not cleaning up stacks since "--no-clean" was used');
}
if (Boolean(options.verbose)) {
printMetrics(metrics);
}
if (!success) {
throw new Error('Some integration tests failed!');
}
}
else if (options.watch) {
await (0, integ_watch_worker_1.watchIntegrationTest)(pool, {
watch: true,
engine,
verbosity: options.verbosity,
...testsToRun[0],
profile: options.profiles ? options.profiles[0] : undefined,
region: options.testRegions[0],
});
}
}
finally {
void pool.terminate();
}
if (destructiveChanges) {
throw new Error('Some changes were destructive!');
}
if (failedSnapshots.length > 0) {
let message = '';
if (!options.runUpdateOnFailed) {
message = 'To re-run failed tests run: integ-runner --update-on-failed';
}
if (!testsSucceeded) {
throw new Error(`Some tests failed!\n${message}`);
}
}
}
function validateWatchArgs(args) {
if (args.watch) {
if ((args.testRegions && args.testRegions.length > 1)
|| (args.profiles && args.profiles.length > 1)
|| args.tests.length > 1) {
throw new Error('Running with watch only supports a single test. Only provide a single option' +
'to `--profiles` `--parallel-regions` `--max-workers');
}
if (args.runUpdateOnFailed || args.disableUpdateWorkflow || args.force || args.dryRun) {
logger.warning('args `--update-on-failed`, `--disable-update-workflow`, `--force`, `--dry-run` have no effect when running with `--watch`');
}
}
}
function printDestructiveChanges(changes) {
if (changes.length > 0) {
logger.warning('!!! This test contains %s !!!', chalk.bold('destructive changes'));
changes.forEach(change => {
logger.warning(' Stack: %s - Resource: %s - Impact: %s', change.stackName, change.logicalId, change.impact);
});
logger.warning('!!! If these destructive changes are necessary, please indicate this on the PR !!!');
}
}
function printMetrics(metrics) {
logger.highlight(' --- Integration test metrics ---');
const sortedMetrics = metrics.sort((a, b) => a.duration - b.duration);
sortedMetrics.forEach(metric => {
logger.print('Profile %s + Region %s total time: %s', metric.profile, metric.region, metric.duration);
const sortedTests = Object.entries(metric.tests).sort((a, b) => a[1] - b[1]);
sortedTests.forEach(test => logger.print(' %s: %s', test[0], test[1]));
});
}
/**
* Translate a Yargs input array to something that makes more sense in a programming language
* model (telling the difference between absence and an empty array)
*
* - An empty array is the default case, meaning the user didn't pass any arguments. We return
* undefined.
* - If the user passed a single empty string, they did something like `--array=`, which we'll
* take to mean they passed an empty array.
*/
function arrayFromYargs(xs) {
if (xs.length === 0) {
return undefined;
}
return xs.filter(x => x !== '');
}
/**
* Merge the tests we received from command line arguments with
* tests that failed snapshot tests. The failed snapshot tests have additional
* information that we want to keep so this should override any test from args
*/
function mergeTests(testFromArgs, failedSnapshotTests) {
const failedTestNames = new Set(failedSnapshotTests.map(test => test.fileName));
const final = failedSnapshotTests;
final.push(...testFromArgs.filter(test => !failedTestNames.has(test.fileName)));
return final;
}
function cli(args = process.argv.slice(2)) {
main(args).then().catch(err => {
logger.error(err);
process.exitCode = 1;
});
}
/**
* Read CLI options from a config file if provided.
*
* @returns parsed CLI config options
*/
function configFromFile(fileName) {
if (!fileName) {
return {};
}
try {
return JSON.parse(fs.readFileSync(fileName, { encoding: 'utf-8' }));
}
catch {
return {};
}
}
function engineFromOptions(options) {
if (options.unstable?.includes('toolkit-lib-engine')) {
return { engine: 'toolkit-lib' };
}
return { engine: 'cli-wrapper' };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":"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","sourcesContent":["// Exercise all integ stacks and if they deploy, update the expected synth files\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as chalk from 'chalk';\nimport * as workerpool from 'workerpool';\nimport * as logger from './logger';\nimport type { EngineOptions } from './runner/engine';\nimport type { IntegTest, IntegTestInfo } from './runner/integration-tests';\nimport { IntegrationTests } from './runner/integration-tests';\nimport type { IntegRunnerMetrics, IntegTestWorkerConfig, DestructiveChange } from './workers';\nimport { runSnapshotTests, runIntegrationTests } from './workers';\nimport { watchIntegrationTest } from './workers/integ-watch-worker';\n\n// https://github.com/yargs/yargs/issues/1929\n// https://github.com/evanw/esbuild/issues/1492\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst yargs = require('yargs');\n\nexport function parseCliArgs(args: string[] = []) {\n  const argv = yargs\n    .usage('Usage: integ-runner [TEST...]')\n    .option('config', {\n      config: true,\n      configParser: configFromFile,\n      default: 'integ.config.json',\n      desc: 'Load options from a JSON config file. Options provided as CLI arguments take precedent.',\n    })\n    .option('watch', { type: 'boolean', default: false, desc: 'Perform integ tests in watch mode' })\n    .option('list', { type: 'boolean', default: false, desc: 'List tests instead of running them' })\n    .option('clean', { type: 'boolean', default: true, desc: 'Clean up and delete stack after test is completed (use --no-clean to negate)' })\n    .option('verbose', { type: 'boolean', default: false, alias: 'v', count: true, desc: 'Verbose logs and metrics on integration tests durations (specify multiple times to increase verbosity)' })\n    .option('dry-run', { type: 'boolean', default: false, desc: 'do not actually deploy the stack. just update the snapshot (not recommended!)' })\n    .option('update-on-failed', { type: 'boolean', default: false, desc: 'rerun integration tests and update snapshots for failed tests.' })\n    .option('force', { type: 'boolean', default: false, desc: 'Rerun all integration tests even if tests are passing' })\n    .option('parallel-regions', { type: 'array', desc: 'Tests are run in parallel across these regions. To prevent tests from running in parallel, provide only a single region', default: [] })\n    .options('directory', { type: 'string', default: 'test', desc: 'starting directory to discover integration tests. Tests will be discovered recursively from this directory' })\n    .options('profiles', { type: 'array', desc: 'list of AWS profiles to use. Tests will be run in parallel across each profile+regions', default: [] })\n    .options('max-workers', { type: 'number', desc: 'The max number of workerpool workers to use when running integration tests in parallel', default: 16 })\n    .options('exclude', { type: 'boolean', desc: 'Run all tests in the directory, except the specified TESTs', default: false })\n    .options('from-file', { type: 'string', desc: 'Read TEST names from a file (one TEST per line)' })\n    .option('inspect-failures', { type: 'boolean', desc: 'Keep the integ test cloud assembly if a failure occurs for inspection', default: false })\n    .option('disable-update-workflow', { type: 'boolean', default: false, desc: 'If this is \"true\" then the stack update workflow will be disabled' })\n    .option('language', {\n      alias: 'l',\n      default: ['javascript', 'typescript', 'python', 'go'],\n      choices: ['javascript', 'typescript', 'python', 'go'],\n      type: 'array',\n      nargs: 1,\n      desc: 'Use these presets to run integration tests for the selected languages',\n    })\n    .option('app', { type: 'string', default: undefined, desc: 'The custom CLI command that will be used to run the test files. You can include {filePath} to specify where in the command the test file path should be inserted. Example: --app=\"python3.8 {filePath}\".' })\n    .option('test-regex', { type: 'array', desc: 'Detect integration test files matching this JavaScript regex pattern. If used multiple times, all files matching any one of the patterns are detected.', default: [] })\n    .option('unstable', { type: 'array', desc: 'Opt-in to using unstable features. By using this flags acknowledges that the scope and API of the feature may change without notice. Specify multiple times for each unstable feature you want to opt-in to.', nargs: 1, choices: ['toolkit-lib-engine'], default: [] })\n    .strict()\n    .parse(args);\n\n  const tests: string[] = argv._;\n  const parallelRegions = arrayFromYargs(argv['parallel-regions']);\n  const testRegions: string[] = parallelRegions ?? ['us-east-1', 'us-east-2', 'us-west-2'];\n  const profiles = arrayFromYargs(argv.profiles);\n  const fromFile: string | undefined = argv['from-file'];\n  const maxWorkers: number = argv['max-workers'];\n  const verbosity: number = argv.verbose;\n  const verbose: boolean = verbosity >= 1;\n\n  const numTests = testRegions.length * (profiles ?? [1]).length;\n  if (maxWorkers < numTests) {\n    logger.warning('You are attempting to run %s tests in parallel, but only have %s workers. Not all of your profiles+regions will be utilized', numTests, maxWorkers);\n  }\n\n  if (tests.length > 0 && fromFile) {\n    throw new Error('A list of tests cannot be provided if \"--from-file\" is provided');\n  }\n  const requestedTests = fromFile\n    ? (fs.readFileSync(fromFile, { encoding: 'utf8' })).split('\\n').filter(x => x)\n    : (tests.length > 0 ? tests : undefined); // 'undefined' means no request\n\n  return {\n    tests: requestedTests,\n    app: argv.app as (string | undefined),\n    testRegex: arrayFromYargs(argv['test-regex']),\n    testRegions,\n    originalRegions: parallelRegions,\n    profiles,\n    runUpdateOnFailed: (argv['update-on-failed'] ?? false) as boolean,\n    fromFile,\n    exclude: argv.exclude as boolean,\n    maxWorkers,\n    list: argv.list as boolean,\n    directory: argv.directory as string,\n    inspectFailures: argv['inspect-failures'] as boolean,\n    verbosity,\n    verbose,\n    clean: argv.clean as boolean,\n    force: argv.force as boolean,\n    dryRun: argv['dry-run'] as boolean,\n    disableUpdateWorkflow: argv['disable-update-workflow'] as boolean,\n    language: arrayFromYargs(argv.language),\n    watch: argv.watch as boolean,\n    unstable: arrayFromYargs(argv.unstable) ?? [],\n  };\n}\n\nexport async function main(args: string[]) {\n  const options = parseCliArgs(args);\n  const engine = engineFromOptions(options).engine;\n\n  const testsFromArgs = await new IntegrationTests(path.resolve(options.directory)).fromCliOptions(options);\n\n  // List only prints the discovered tests\n  if (options.list) {\n    process.stdout.write(testsFromArgs.map(t => t.discoveryRelativeFileName).join('\\n') + '\\n');\n    return;\n  }\n\n  const pool = workerpool.pool(path.join(__dirname, '..', 'lib', 'workers', 'extract', 'index.js'), {\n    maxWorkers: options.watch ? 1 : options.maxWorkers,\n  });\n\n  const testsToRun: IntegTestWorkerConfig[] = [];\n  let destructiveChanges: boolean = false;\n  let failedSnapshots: IntegTestWorkerConfig[] = [];\n  let testsSucceeded = false;\n  validateWatchArgs({\n    ...options,\n    testRegions: options.originalRegions,\n    tests: testsFromArgs,\n  });\n\n  try {\n    if (!options.watch) {\n      // always run snapshot tests, but if '--force' is passed then\n      // run integration tests on all failed tests, not just those that\n      // failed snapshot tests\n      failedSnapshots = await runSnapshotTests(pool, testsFromArgs, {\n        retain: options.inspectFailures,\n        verbose: options.verbose,\n        engine,\n      });\n      for (const failure of failedSnapshots) {\n        logger.warning(`Failed: ${failure.fileName}`);\n        if (failure.destructiveChanges && failure.destructiveChanges.length > 0) {\n          printDestructiveChanges(failure.destructiveChanges);\n          destructiveChanges = true;\n        }\n      }\n      if (!options.force) {\n        testsToRun.push(...failedSnapshots);\n      } else {\n        // if any of the test failed snapshot tests, keep those results\n        // and merge with the rest of the tests from args\n        testsToRun.push(...mergeTests(testsFromArgs.map(t => t.info), failedSnapshots));\n      }\n    } else {\n      testsToRun.push(...testsFromArgs.map(t => t.info));\n    }\n\n    // run integration tests if `--update-on-failed` OR `--force` is used\n    if (options.runUpdateOnFailed || options.force) {\n      const { success, metrics } = await runIntegrationTests({\n        pool,\n        engine,\n        tests: testsToRun,\n        regions: options.testRegions,\n        profiles: options.profiles,\n        clean: options.clean,\n        dryRun: options.dryRun,\n        verbosity: options.verbosity,\n        updateWorkflow: !options.disableUpdateWorkflow,\n        watch: options.watch,\n      });\n      testsSucceeded = success;\n\n      if (options.clean === false) {\n        logger.warning('Not cleaning up stacks since \"--no-clean\" was used');\n      }\n\n      if (Boolean(options.verbose)) {\n        printMetrics(metrics);\n      }\n\n      if (!success) {\n        throw new Error('Some integration tests failed!');\n      }\n    } else if (options.watch) {\n      await watchIntegrationTest(pool, {\n        watch: true,\n        engine,\n        verbosity: options.verbosity,\n        ...testsToRun[0],\n        profile: options.profiles ? options.profiles[0] : undefined,\n        region: options.testRegions[0],\n      });\n    }\n  } finally {\n    void pool.terminate();\n  }\n\n  if (destructiveChanges) {\n    throw new Error('Some changes were destructive!');\n  }\n  if (failedSnapshots.length > 0) {\n    let message = '';\n    if (!options.runUpdateOnFailed) {\n      message = 'To re-run failed tests run: integ-runner --update-on-failed';\n    }\n    if (!testsSucceeded) {\n      throw new Error(`Some tests failed!\\n${message}`);\n    }\n  }\n}\n\nfunction validateWatchArgs(args: {\n  tests: IntegTest[];\n  testRegions?: string[];\n  profiles?: string[];\n  maxWorkers: number;\n  force: boolean;\n  dryRun: boolean;\n  disableUpdateWorkflow: boolean;\n  runUpdateOnFailed: boolean;\n  watch: boolean;\n}) {\n  if (args.watch) {\n    if (\n      (args.testRegions && args.testRegions.length > 1)\n        || (args.profiles && args.profiles.length > 1)\n        || args.tests.length > 1) {\n      throw new Error('Running with watch only supports a single test. Only provide a single option'+\n        'to `--profiles` `--parallel-regions` `--max-workers');\n    }\n\n    if (args.runUpdateOnFailed || args.disableUpdateWorkflow || args.force || args.dryRun) {\n      logger.warning('args `--update-on-failed`, `--disable-update-workflow`, `--force`, `--dry-run` have no effect when running with `--watch`');\n    }\n  }\n}\n\nfunction printDestructiveChanges(changes: DestructiveChange[]): void {\n  if (changes.length > 0) {\n    logger.warning('!!! This test contains %s !!!', chalk.bold('destructive changes'));\n    changes.forEach(change => {\n      logger.warning('    Stack: %s - Resource: %s - Impact: %s', change.stackName, change.logicalId, change.impact);\n    });\n    logger.warning('!!! If these destructive changes are necessary, please indicate this on the PR !!!');\n  }\n}\n\nfunction printMetrics(metrics: IntegRunnerMetrics[]): void {\n  logger.highlight('   --- Integration test metrics ---');\n  const sortedMetrics = metrics.sort((a, b) => a.duration - b.duration);\n  sortedMetrics.forEach(metric => {\n    logger.print('Profile %s + Region %s total time: %s', metric.profile, metric.region, metric.duration);\n    const sortedTests = Object.entries(metric.tests).sort((a, b) => a[1] - b[1]);\n    sortedTests.forEach(test => logger.print('  %s: %s', test[0], test[1]));\n  });\n}\n\n/**\n * Translate a Yargs input array to something that makes more sense in a programming language\n * model (telling the difference between absence and an empty array)\n *\n * - An empty array is the default case, meaning the user didn't pass any arguments. We return\n *   undefined.\n * - If the user passed a single empty string, they did something like `--array=`, which we'll\n *   take to mean they passed an empty array.\n */\nfunction arrayFromYargs(xs: string[]): string[] | undefined {\n  if (xs.length === 0) {\n    return undefined;\n  }\n  return xs.filter(x => x !== '');\n}\n\n/**\n * Merge the tests we received from command line arguments with\n * tests that failed snapshot tests. The failed snapshot tests have additional\n * information that we want to keep so this should override any test from args\n */\nfunction mergeTests(testFromArgs: IntegTestInfo[], failedSnapshotTests: IntegTestWorkerConfig[]): IntegTestWorkerConfig[] {\n  const failedTestNames = new Set(failedSnapshotTests.map(test => test.fileName));\n  const final: IntegTestWorkerConfig[] = failedSnapshotTests;\n  final.push(...testFromArgs.filter(test => !failedTestNames.has(test.fileName)));\n  return final;\n}\n\nexport function cli(args: string[] = process.argv.slice(2)) {\n  main(args).then().catch(err => {\n    logger.error(err);\n    process.exitCode = 1;\n  });\n}\n\n/**\n * Read CLI options from a config file if provided.\n *\n * @returns parsed CLI config options\n */\nfunction configFromFile(fileName?: string): Record<string, any> {\n  if (!fileName) {\n    return {};\n  }\n\n  try {\n    return JSON.parse(fs.readFileSync(fileName, { encoding: 'utf-8' }));\n  } catch {\n    return {};\n  }\n}\n\nfunction engineFromOptions(options: { unstable?: string[] }): EngineOptions {\n  if (options.unstable?.includes('toolkit-lib-engine')) {\n    return { engine: 'toolkit-lib' };\n  }\n  return { engine: 'cli-wrapper' };\n}\n"]}