@aws-cdk-testing/cli-integ 2.173.4 → 3.0.1

package/lib/cli/stage-distribution.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const path = require("path");
+const fs = require("fs-extra");
+const glob = require("glob");
+const yargs = require("yargs");
+const __1 = require("..");
+const codeartifact_1 = require("../staging/codeartifact");
+const maven_1 = require("../staging/maven");
+const npm_1 = require("../staging/npm");
+const nuget_1 = require("../staging/nuget");
+const pypi_1 = require("../staging/pypi");
+const usage_dir_1 = require("../staging/usage-dir");
+async function main() {
+    await yargs
+        .usage('$0 <command>')
+        .option('npm', {
+        description: 'Upload NPM packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('python', {
+        description: 'Upload Python packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('java', {
+        description: 'Upload Java packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('dotnet', {
+        description: 'Upload Dotnet packages only',
+        type: 'boolean',
+        requiresArg: false,
+    })
+        .option('regression', {
+        description: 'Enable access to previous versions of the staged packages (this is expensive for CodeArtifact so we only do it when necessary)',
+        type: 'boolean',
+        requiresArg: false,
+        default: false,
+    })
+        .command('publish <DIRECTORY>', 'Publish a given directory', cmd => cmd
+        .positional('DIRECTORY', {
+        descripton: 'Directory distribution',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to create (default: generate unique name)',
+        type: 'string',
+        requiresArg: true,
+    }), async (args) => {
+        await validateDirectory(args);
+        const repo = await (args.name ? codeartifact_1.TestRepository.newWithName(args.name) : codeartifact_1.TestRepository.newRandom());
+        const usageDir = usage_dir_1.UsageDir.default();
+        await doLogin(repo, usageDir, args);
+        await publish(repo, usageDir, args);
+        header('Done');
+        usageDir.advertise();
+    })
+        .command('login', 'Login to a given repository', cmd => cmd
+        .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to log in to',
+        type: 'string',
+        requiresArg: true,
+        demandOption: true,
+    }), async (args) => {
+        const repo = codeartifact_1.TestRepository.existing(args.name);
+        const usageDir = usage_dir_1.UsageDir.default();
+        await doLogin(repo, usageDir, args);
+        usageDir.advertise();
+    })
+        .command('run <DIRECTORY> <COMMAND..>', 'Publish and run a command', cmd => cmd
+        .positional('DIRECTORY', {
+        descripton: 'Directory distribution',
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('COMMAND', {
+        alias: 'c',
+        description: 'Run the given command with the packages staged',
+        type: 'string',
+        array: true,
+        demandOption: true,
+    })
+        .option('cleanup', {
+        alias: 'C',
+        description: 'Cleanup the repository afterwards',
+        type: 'boolean',
+        default: true,
+        requiresArg: false,
+    }), async (args) => {
+        var _a;
+        await validateDirectory(args);
+        const repo = await codeartifact_1.TestRepository.newRandom();
+        const usageDir = usage_dir_1.UsageDir.default();
+        await doLogin(repo, usageDir, args);
+        await publish(repo, usageDir, args);
+        try {
+            await usageDir.activateInCurrentProcess();
+            await (0, __1.shell)((_a = args.COMMAND) !== null && _a !== void 0 ? _a : [], {
+                shell: true,
+                show: 'always',
+            });
+        }
+        finally {
+            if (args.cleanup) {
+                await repo.delete();
+            }
+        }
+    })
+        .command('cleanup', 'Clean up testing repository', cmd => cmd
+        .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to cleanup (default: most recent)',
+        type: 'string',
+        requiresArg: true,
+    }), async (args) => {
+        const usageDir = usage_dir_1.UsageDir.default();
+        let repositoryName = args.name;
+        if (!repositoryName) {
+            repositoryName = (await usageDir.currentEnv()).CODEARTIFACT_REPO;
+        }
+        if (!repositoryName) {
+            console.log(`No --name given and no $CODEARTIFACT_REPO found in ${usageDir.directory}, nothing cleaned up`);
+            return;
+        }
+        const repo = codeartifact_1.TestRepository.existing(repositoryName);
+        await repo.delete();
+    })
+        .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async () => {
+        await codeartifact_1.TestRepository.gc();
+    })
+        .demandCommand(1, 'You must supply a command')
+        .help()
+        .showHelpOnFail(false)
+        .parse();
+}
+async function validateDirectory(args) {
+    if (!await fs.pathExists(path.join(args.DIRECTORY, 'build.json'))) {
+        throw new Error(`${args.DIRECTORY} does not look like a CDK dist directory (build.json missing)`);
+    }
+}
+async function doLogin(repo, usageDir, args) {
+    const login = await repo.loginInformation();
+    const oldEnv = await usageDir.currentEnv();
+    await usageDir.clean();
+    await usageDir.addToEnv({
+        CODEARTIFACT_REPO: login.repositoryName,
+    });
+    if (oldEnv.BUILD_VERSION) {
+        await usageDir.addToEnv({
+            BUILD_VERSION: oldEnv.BUILD_VERSION,
+        });
+    }
+    const doRepo = whichRepos(args);
+    await doRepo.npm(() => (0, npm_1.npmLogin)(login, usageDir));
+    await doRepo.python(() => (0, pypi_1.pypiLogin)(login, usageDir));
+    await doRepo.java(() => (0, maven_1.mavenLogin)(login, usageDir));
+    await doRepo.dotnet(() => (0, nuget_1.nugetLogin)(login, usageDir));
+}
+async function publish(repo, usageDir, args) {
+    const directory = `${args.DIRECTORY}`;
+    const login = await repo.loginInformation();
+    const doRepo = whichRepos(args);
+    const buildJson = await fs.readJson(path.join(directory, 'build.json'));
+    await usageDir.addToEnv({
+        BUILD_VERSION: buildJson.version,
+    });
+    await doRepo.npm(async () => {
+        header('NPM');
+        await (0, npm_1.uploadNpmPackages)(glob.sync(path.join(directory, 'js', '*.tgz')), login, usageDir);
+    });
+    await doRepo.python(async () => {
+        header('Python');
+        await (0, pypi_1.uploadPythonPackages)(glob.sync(path.join(directory, 'python', '*')), login);
+    });
+    await doRepo.java(async () => {
+        header('Java');
+        await (0, maven_1.uploadJavaPackages)(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, usageDir);
+    });
+    await doRepo.dotnet(async () => {
+        header('.NET');
+        await (0, nuget_1.uploadDotnetPackages)(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), usageDir);
+    });
+    if (args.regression) {
+        console.log('🛍 Configuring packages for upstream versions');
+        await repo.markAllUpstreamAllow();
+    }
+}
+function whichRepos(args) {
+    const all = args.npm === undefined && args.python === undefined && args.java === undefined && args.dotnet === undefined;
+    const invoke = (block) => block();
+    const skip = () => { };
+    return {
+        npm: args.npm || all ? invoke : skip,
+        python: args.python || all ? invoke : skip,
+        java: args.java || all ? invoke : skip,
+        dotnet: args.dotnet || all ? invoke : skip,
+    };
+}
+function header(caption) {
+    console.log('');
+    console.log('/'.repeat(70));
+    console.log(`//  ${caption}`);
+    console.log('');
+}
+main().catch(e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stage-distribution.js","sourceRoot":"","sources":["stage-distribution.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport * as glob from 'glob';\nimport * as yargs from 'yargs';\nimport { shell } from '..';\nimport { TestRepository } from '../staging/codeartifact';\nimport { uploadJavaPackages, mavenLogin } from '../staging/maven';\nimport { uploadNpmPackages, npmLogin } from '../staging/npm';\nimport { uploadDotnetPackages, nugetLogin } from '../staging/nuget';\nimport { uploadPythonPackages, pypiLogin } from '../staging/pypi';\nimport { UsageDir } from '../staging/usage-dir';\n\nasync function main() {\n  await yargs\n    .usage('$0 <command>')\n    .option('npm', {\n      description: 'Upload NPM packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('python', {\n      description: 'Upload Python packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('java', {\n      description: 'Upload Java packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('dotnet', {\n      description: 'Upload Dotnet packages only',\n      type: 'boolean',\n      requiresArg: false,\n    })\n    .option('regression', {\n      description: 'Enable access to previous versions of the staged packages (this is expensive for CodeArtifact so we only do it when necessary)',\n      type: 'boolean',\n      requiresArg: false,\n      default: false,\n    })\n    .command('publish <DIRECTORY>', 'Publish a given directory', cmd => cmd\n      .positional('DIRECTORY', {\n        descripton: 'Directory distribution',\n        type: 'string',\n        demandOption: true,\n      })\n      .option('name', {\n        alias: 'n',\n        description: 'Name of the repository to create (default: generate unique name)',\n        type: 'string',\n        requiresArg: true,\n      }), async (args) => {\n\n      await validateDirectory(args);\n      const repo = await (args.name ? TestRepository.newWithName(args.name) : TestRepository.newRandom());\n      const usageDir = UsageDir.default();\n\n      await doLogin(repo, usageDir, args);\n      await publish(repo, usageDir, args);\n\n      header('Done');\n      usageDir.advertise();\n    })\n    .command('login', 'Login to a given repository', cmd => cmd\n      .option('name', {\n        alias: 'n',\n        description: 'Name of the repository to log in to',\n        type: 'string',\n        requiresArg: true,\n        demandOption: true,\n      }), async (args) => {\n\n      const repo = TestRepository.existing(args.name);\n      const usageDir = UsageDir.default();\n\n      await doLogin(repo, usageDir, args);\n\n      usageDir.advertise();\n    })\n    .command('run <DIRECTORY> <COMMAND..>', 'Publish and run a command', cmd => cmd\n      .positional('DIRECTORY', {\n        descripton: 'Directory distribution',\n        type: 'string',\n        demandOption: true,\n      })\n      .positional('COMMAND', {\n        alias: 'c',\n        description: 'Run the given command with the packages staged',\n        type: 'string',\n        array: true,\n        demandOption: true,\n      })\n      .option('cleanup', {\n        alias: 'C',\n        description: 'Cleanup the repository afterwards',\n        type: 'boolean',\n        default: true,\n        requiresArg: false,\n      }), async (args) => {\n\n      await validateDirectory(args);\n      const repo = await TestRepository.newRandom();\n      const usageDir = UsageDir.default();\n\n      await doLogin(repo, usageDir, args);\n      await publish(repo, usageDir, args);\n\n      try {\n        await usageDir.activateInCurrentProcess();\n\n        await shell(args.COMMAND ?? [], {\n          shell: true,\n          show: 'always',\n        });\n\n      } finally {\n        if (args.cleanup) {\n          await repo.delete();\n        }\n      }\n    })\n    .command('cleanup', 'Clean up testing repository', cmd => cmd\n      .option('name', {\n        alias: 'n',\n        description: 'Name of the repository to cleanup (default: most recent)',\n        type: 'string',\n        requiresArg: true,\n      }), async (args) => {\n\n      const usageDir = UsageDir.default();\n\n      let repositoryName = args.name;\n      if (!repositoryName) {\n        repositoryName = (await usageDir.currentEnv()).CODEARTIFACT_REPO;\n      }\n\n      if (!repositoryName) {\n        console.log(`No --name given and no $CODEARTIFACT_REPO found in ${usageDir.directory}, nothing cleaned up`);\n        return;\n      }\n\n      const repo = TestRepository.existing(repositoryName);\n      await repo.delete();\n    })\n    .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async () => {\n      await TestRepository.gc();\n    })\n    .demandCommand(1, 'You must supply a command')\n    .help()\n    .showHelpOnFail(false)\n    .parse();\n}\n\nasync function validateDirectory(args: {\n  DIRECTORY: string;\n}) {\n  if (!await fs.pathExists(path.join(args.DIRECTORY, 'build.json'))) {\n    throw new Error(`${args.DIRECTORY} does not look like a CDK dist directory (build.json missing)`);\n  }\n}\n\nasync function doLogin(repo: TestRepository, usageDir: UsageDir, args: {\n  npm?: boolean;\n  python?: boolean;\n  java?: boolean;\n  dotnet?: boolean;\n}) {\n  const login = await repo.loginInformation();\n\n  const oldEnv = await usageDir.currentEnv();\n\n  await usageDir.clean();\n  await usageDir.addToEnv({\n    CODEARTIFACT_REPO: login.repositoryName,\n  });\n\n  if (oldEnv.BUILD_VERSION) {\n    await usageDir.addToEnv({\n      BUILD_VERSION: oldEnv.BUILD_VERSION,\n    });\n  }\n\n  const doRepo = whichRepos(args);\n\n  await doRepo.npm(() => npmLogin(login, usageDir));\n  await doRepo.python(() => pypiLogin(login, usageDir));\n  await doRepo.java(() => mavenLogin(login, usageDir));\n  await doRepo.dotnet(() => nugetLogin(login, usageDir));\n}\n\nasync function publish(repo: TestRepository, usageDir: UsageDir, args: {\n  DIRECTORY: string;\n  npm?: boolean;\n  python?: boolean;\n  java?: boolean;\n  dotnet?: boolean;\n  regression?: boolean;\n}) {\n  const directory = `${args.DIRECTORY}`;\n  const login = await repo.loginInformation();\n\n  const doRepo = whichRepos(args);\n\n  const buildJson = await fs.readJson(path.join(directory, 'build.json'));\n  await usageDir.addToEnv({\n    BUILD_VERSION: buildJson.version,\n  });\n\n  await doRepo.npm(async () => {\n    header('NPM');\n    await uploadNpmPackages(glob.sync(path.join(directory, 'js', '*.tgz')), login, usageDir);\n  });\n\n  await doRepo.python(async () => {\n    header('Python');\n    await uploadPythonPackages(glob.sync(path.join(directory, 'python', '*')), login);\n  });\n\n  await doRepo.java(async () => {\n    header('Java');\n    await uploadJavaPackages(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, usageDir);\n  });\n\n  await doRepo.dotnet(async () => {\n    header('.NET');\n    await uploadDotnetPackages(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), usageDir);\n  });\n\n  if (args.regression) {\n    console.log('🛍 Configuring packages for upstream versions');\n    await repo.markAllUpstreamAllow();\n  }\n}\n\nfunction whichRepos(args: {\n  npm?: boolean;\n  python?: boolean;\n  java?: boolean;\n  dotnet?: boolean;\n}) {\n  const all = args.npm === undefined && args.python === undefined && args.java === undefined && args.dotnet === undefined;\n\n  const invoke = (block: () => Promise<void>) => block();\n  const skip = () => { };\n\n  return {\n    npm: args.npm || all ? invoke : skip,\n    python: args.python || all ? invoke : skip,\n    java: args.java || all ? invoke : skip,\n    dotnet: args.dotnet || all ? invoke : skip,\n  };\n}\n\nfunction header(caption: string) {\n  console.log('');\n  console.log('/'.repeat(70));\n  console.log(`//  ${caption}`);\n  console.log('');\n}\n\nmain().catch(e => {\n  // eslint-disable-next-line no-console\n  console.error(e);\n  process.exitCode = 1;\n});\n"]}

package/lib/cli/stage-distribution.ts

@@ -0,0 +1,267 @@
+/* eslint-disable no-console */
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import * as glob from 'glob';
+import * as yargs from 'yargs';
+import { shell } from '..';
+import { TestRepository } from '../staging/codeartifact';
+import { uploadJavaPackages, mavenLogin } from '../staging/maven';
+import { uploadNpmPackages, npmLogin } from '../staging/npm';
+import { uploadDotnetPackages, nugetLogin } from '../staging/nuget';
+import { uploadPythonPackages, pypiLogin } from '../staging/pypi';
+import { UsageDir } from '../staging/usage-dir';
+
+async function main() {
+  await yargs
+    .usage('$0 <command>')
+    .option('npm', {
+      description: 'Upload NPM packages only',
+      type: 'boolean',
+      requiresArg: false,
+    })
+    .option('python', {
+      description: 'Upload Python packages only',
+      type: 'boolean',
+      requiresArg: false,
+    })
+    .option('java', {
+      description: 'Upload Java packages only',
+      type: 'boolean',
+      requiresArg: false,
+    })
+    .option('dotnet', {
+      description: 'Upload Dotnet packages only',
+      type: 'boolean',
+      requiresArg: false,
+    })
+    .option('regression', {
+      description: 'Enable access to previous versions of the staged packages (this is expensive for CodeArtifact so we only do it when necessary)',
+      type: 'boolean',
+      requiresArg: false,
+      default: false,
+    })
+    .command('publish <DIRECTORY>', 'Publish a given directory', cmd => cmd
+      .positional('DIRECTORY', {
+        descripton: 'Directory distribution',
+        type: 'string',
+        demandOption: true,
+      })
+      .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to create (default: generate unique name)',
+        type: 'string',
+        requiresArg: true,
+      }), async (args) => {
+
+      await validateDirectory(args);
+      const repo = await (args.name ? TestRepository.newWithName(args.name) : TestRepository.newRandom());
+      const usageDir = UsageDir.default();
+
+      await doLogin(repo, usageDir, args);
+      await publish(repo, usageDir, args);
+
+      header('Done');
+      usageDir.advertise();
+    })
+    .command('login', 'Login to a given repository', cmd => cmd
+      .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to log in to',
+        type: 'string',
+        requiresArg: true,
+        demandOption: true,
+      }), async (args) => {
+
+      const repo = TestRepository.existing(args.name);
+      const usageDir = UsageDir.default();
+
+      await doLogin(repo, usageDir, args);
+
+      usageDir.advertise();
+    })
+    .command('run <DIRECTORY> <COMMAND..>', 'Publish and run a command', cmd => cmd
+      .positional('DIRECTORY', {
+        descripton: 'Directory distribution',
+        type: 'string',
+        demandOption: true,
+      })
+      .positional('COMMAND', {
+        alias: 'c',
+        description: 'Run the given command with the packages staged',
+        type: 'string',
+        array: true,
+        demandOption: true,
+      })
+      .option('cleanup', {
+        alias: 'C',
+        description: 'Cleanup the repository afterwards',
+        type: 'boolean',
+        default: true,
+        requiresArg: false,
+      }), async (args) => {
+
+      await validateDirectory(args);
+      const repo = await TestRepository.newRandom();
+      const usageDir = UsageDir.default();
+
+      await doLogin(repo, usageDir, args);
+      await publish(repo, usageDir, args);
+
+      try {
+        await usageDir.activateInCurrentProcess();
+
+        await shell(args.COMMAND ?? [], {
+          shell: true,
+          show: 'always',
+        });
+
+      } finally {
+        if (args.cleanup) {
+          await repo.delete();
+        }
+      }
+    })
+    .command('cleanup', 'Clean up testing repository', cmd => cmd
+      .option('name', {
+        alias: 'n',
+        description: 'Name of the repository to cleanup (default: most recent)',
+        type: 'string',
+        requiresArg: true,
+      }), async (args) => {
+
+      const usageDir = UsageDir.default();
+
+      let repositoryName = args.name;
+      if (!repositoryName) {
+        repositoryName = (await usageDir.currentEnv()).CODEARTIFACT_REPO;
+      }
+
+      if (!repositoryName) {
+        console.log(`No --name given and no $CODEARTIFACT_REPO found in ${usageDir.directory}, nothing cleaned up`);
+        return;
+      }
+
+      const repo = TestRepository.existing(repositoryName);
+      await repo.delete();
+    })
+    .command('gc', 'Clean up day-old testing repositories', cmd => cmd, async () => {
+      await TestRepository.gc();
+    })
+    .demandCommand(1, 'You must supply a command')
+    .help()
+    .showHelpOnFail(false)
+    .parse();
+}
+
+async function validateDirectory(args: {
+  DIRECTORY: string;
+}) {
+  if (!await fs.pathExists(path.join(args.DIRECTORY, 'build.json'))) {
+    throw new Error(`${args.DIRECTORY} does not look like a CDK dist directory (build.json missing)`);
+  }
+}
+
+async function doLogin(repo: TestRepository, usageDir: UsageDir, args: {
+  npm?: boolean;
+  python?: boolean;
+  java?: boolean;
+  dotnet?: boolean;
+}) {
+  const login = await repo.loginInformation();
+
+  const oldEnv = await usageDir.currentEnv();
+
+  await usageDir.clean();
+  await usageDir.addToEnv({
+    CODEARTIFACT_REPO: login.repositoryName,
+  });
+
+  if (oldEnv.BUILD_VERSION) {
+    await usageDir.addToEnv({
+      BUILD_VERSION: oldEnv.BUILD_VERSION,
+    });
+  }
+
+  const doRepo = whichRepos(args);
+
+  await doRepo.npm(() => npmLogin(login, usageDir));
+  await doRepo.python(() => pypiLogin(login, usageDir));
+  await doRepo.java(() => mavenLogin(login, usageDir));
+  await doRepo.dotnet(() => nugetLogin(login, usageDir));
+}
+
+async function publish(repo: TestRepository, usageDir: UsageDir, args: {
+  DIRECTORY: string;
+  npm?: boolean;
+  python?: boolean;
+  java?: boolean;
+  dotnet?: boolean;
+  regression?: boolean;
+}) {
+  const directory = `${args.DIRECTORY}`;
+  const login = await repo.loginInformation();
+
+  const doRepo = whichRepos(args);
+
+  const buildJson = await fs.readJson(path.join(directory, 'build.json'));
+  await usageDir.addToEnv({
+    BUILD_VERSION: buildJson.version,
+  });
+
+  await doRepo.npm(async () => {
+    header('NPM');
+    await uploadNpmPackages(glob.sync(path.join(directory, 'js', '*.tgz')), login, usageDir);
+  });
+
+  await doRepo.python(async () => {
+    header('Python');
+    await uploadPythonPackages(glob.sync(path.join(directory, 'python', '*')), login);
+  });
+
+  await doRepo.java(async () => {
+    header('Java');
+    await uploadJavaPackages(glob.sync(path.join(directory, 'java', '**', '*.pom')), login, usageDir);
+  });
+
+  await doRepo.dotnet(async () => {
+    header('.NET');
+    await uploadDotnetPackages(glob.sync(path.join(directory, 'dotnet', '**', '*.nupkg')), usageDir);
+  });
+
+  if (args.regression) {
+    console.log('🛍 Configuring packages for upstream versions');
+    await repo.markAllUpstreamAllow();
+  }
+}
+
+function whichRepos(args: {
+  npm?: boolean;
+  python?: boolean;
+  java?: boolean;
+  dotnet?: boolean;
+}) {
+  const all = args.npm === undefined && args.python === undefined && args.java === undefined && args.dotnet === undefined;
+
+  const invoke = (block: () => Promise<void>) => block();
+  const skip = () => { };
+
+  return {
+    npm: args.npm || all ? invoke : skip,
+    python: args.python || all ? invoke : skip,
+    java: args.java || all ? invoke : skip,
+    dotnet: args.dotnet || all ? invoke : skip,
+  };
+}
+
+function header(caption: string) {
+  console.log('');
+  console.log('/'.repeat(70));
+  console.log(`//  ${caption}`);
+  console.log('');
+}
+
+main().catch(e => {
+  // eslint-disable-next-line no-console
+  console.error(e);
+  process.exitCode = 1;
+});

package/lib/cli/test-root.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cli/test-root.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+// eslint-disable-next-line no-console
+console.log(path.resolve(__dirname, '..', '..'));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1yb290LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGVzdC1yb290LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsNkJBQTZCO0FBQzdCLHNDQUFzQztBQUN0QyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgcGF0aCBmcm9tICdwYXRoJztcbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1jb25zb2xlXG5jb25zb2xlLmxvZyhwYXRoLnJlc29sdmUoX19kaXJuYW1lLCAnLi4nLCAnLi4nKSk7XG4iXX0=

package/lib/cli/test-root.ts

@@ -0,0 +1,3 @@
+import * as path from 'path';
+// eslint-disable-next-line no-console
+console.log(path.resolve(__dirname, '..', '..'));

package/lib/corking.ts

@@ -0,0 +1,33 @@
+/**
+ * Routines for corking stdout and stderr
+ */
+import * as stream from 'stream';
+
+export class MemoryStream extends stream.Writable {
+  private parts = new Array<Buffer>();
+
+  public _write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void {
+    this.parts.push(chunk);
+    callback();
+  }
+
+  public buffer() {
+    return Buffer.concat(this.parts);
+  }
+
+  public clear() {
+    this.parts.splice(0, this.parts.length);
+  }
+
+  public async flushTo(strm: NodeJS.WritableStream): Promise<void> {
+    const flushed = strm.write(this.buffer());
+    if (!flushed) {
+      return new Promise(ok => strm.once('drain', ok));
+    }
+    return;
+  }
+
+  public toString() {
+    return this.buffer().toString();
+  }
+}

package/lib/eventually.js

@@ -15,8 +15,8 @@ const DEFAULT_MAX_ATTEMPTS = 10;
  */
 const eventually = async (call, options) => {
     const opts = {
-        interval: options?.interval ? options.interval : DEFAULT_INTERVAL,
-        maxAttempts: options?.maxAttempts ? options.maxAttempts : DEFAULT_MAX_ATTEMPTS,
+        interval: (options === null || options === void 0 ? void 0 : options.interval) ? options.interval : DEFAULT_INTERVAL,
+        maxAttempts: (options === null || options === void 0 ? void 0 : options.maxAttempts) ? options.maxAttempts : DEFAULT_MAX_ATTEMPTS,
     };
     while (opts.maxAttempts-- >= 0) {
         try {
@@ -31,4 +31,4 @@ const eventually = async (call, options) => {
     throw new Error('An unexpected error has occurred.');
 };
 exports.default = eventually;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnR1YWxseS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImV2ZW50dWFsbHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFTQSxNQUFNLElBQUksR0FBRyxDQUFDLEVBQVUsRUFBaUIsRUFBRSxDQUFDLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDOUYsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUM7QUFDOUIsTUFBTSxvQkFBb0IsR0FBRyxFQUFFLENBQUM7QUFFaEM7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxVQUFVLEdBQUcsS0FBSyxFQUFLLElBQXNCLEVBQUUsT0FBMkIsRUFBYyxFQUFFO0lBQzlGLE1BQU0sSUFBSSxHQUFHO1FBQ1gsUUFBUSxFQUFFLENBQUEsT0FBTyxhQUFQLE9BQU8sdUJBQVAsT0FBTyxDQUFFLFFBQVEsRUFBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsZ0JBQWdCO1FBQ2pFLFdBQVcsRUFBRSxDQUFBLE9BQU8sYUFBUCxPQUFPLHVCQUFQLE9BQU8sQ0FBRSxXQUFXLEVBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLG9CQUFvQjtLQUMvRSxDQUFDO0lBRUYsT0FBTyxJQUFJLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDL0IsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLElBQUksRUFBRSxDQUFDO1FBQ3RCLENBQUM7UUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2IsSUFBSSxJQUFJLENBQUMsV0FBVyxJQUFJLENBQUM7Z0JBQUUsTUFBTSxHQUFHLENBQUM7UUFDdkMsQ0FBQztRQUNELE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM1QixDQUFDO0lBRUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxtQ0FBbUMsQ0FBQyxDQUFDO0FBQ3ZELENBQUMsQ0FBQztBQUVGLGtCQUFlLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQHBhcmFtIG1heEF0dGVtcHRzIHRoZSBtYXhpbXVtIG51bWJlciBvZiBhdHRlbXB0c1xuICogQHBhcmFtIGludGVydmFsIGludGVydmFsIGluIG1pbGxpc2Vjb25kcyB0byBvYnNlcnZlIGJldHdlZW4gYXR0ZW1wdHNcbiAqL1xuZXhwb3J0IHR5cGUgRXZlbnR1YWxseU9wdGlvbnMgPSB7XG4gIG1heEF0dGVtcHRzPzogbnVtYmVyO1xuICBpbnRlcnZhbD86IG51bWJlcjtcbn07XG5cbmNvbnN0IHdhaXQgPSAobXM6IG51bWJlcik6IFByb21pc2U8dm9pZD4gPT4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHNldFRpbWVvdXQocmVzb2x2ZSwgbXMpKTtcbmNvbnN0IERFRkFVTFRfSU5URVJWQUwgPSAxMDAwO1xuY29uc3QgREVGQVVMVF9NQVhfQVRURU1QVFMgPSAxMDtcblxuLyoqXG4gKiBSdW5zIGEgZnVuY3Rpb24gb24gYW4gaW50ZXJ2YWwgdW50aWwgdGhlIG1heGltdW0gbnVtYmVyIG9mIGF0dGVtcHRzIGhhc1xuICogYmVlbiByZWFjaGVkLlxuICpcbiAqIERlZmF1bHQgaW50ZXJ2YWwgPSAxMDAwIG1pbGxpc2Vjb25kc1xuICogRGVmYXVsdCBtYXhBdHRlbXB0cyA9IDEwXG4gKlxuICogQHBhcmFtIGZuIGZ1bmN0aW9uIHRvIHJ1blxuICogQHBhcmFtIG9wdGlvbnMgRXZlbnR1YWxseU9wdGlvbnNcbiAqL1xuY29uc3QgZXZlbnR1YWxseSA9IGFzeW5jIDxUPihjYWxsOiAoKSA9PiBQcm9taXNlPFQ+LCBvcHRpb25zPzogRXZlbnR1YWxseU9wdGlvbnMpOiBQcm9taXNlPFQ+ID0+IHtcbiAgY29uc3Qgb3B0cyA9IHtcbiAgICBpbnRlcnZhbDogb3B0aW9ucz8uaW50ZXJ2YWwgPyBvcHRpb25zLmludGVydmFsIDogREVGQVVMVF9JTlRFUlZBTCxcbiAgICBtYXhBdHRlbXB0czogb3B0aW9ucz8ubWF4QXR0ZW1wdHMgPyBvcHRpb25zLm1heEF0dGVtcHRzIDogREVGQVVMVF9NQVhfQVRURU1QVFMsXG4gIH07XG5cbiAgd2hpbGUgKG9wdHMubWF4QXR0ZW1wdHMtLSA+PSAwKSB7XG4gICAgdHJ5IHtcbiAgICAgIHJldHVybiBhd2FpdCBjYWxsKCk7XG4gICAgfSBjYXRjaCAoZXJyKSB7XG4gICAgICBpZiAob3B0cy5tYXhBdHRlbXB0cyA8PSAwKSB0aHJvdyBlcnI7XG4gICAgfVxuICAgIGF3YWl0IHdhaXQob3B0cy5pbnRlcnZhbCk7XG4gIH1cblxuICB0aHJvdyBuZXcgRXJyb3IoJ0FuIHVuZXhwZWN0ZWQgZXJyb3IgaGFzIG9jY3VycmVkLicpO1xufTtcblxuZXhwb3J0IGRlZmF1bHQgZXZlbnR1YWxseTtcbiJdfQ==

package/lib/eventually.ts

@@ -0,0 +1,42 @@
+/**
+ * @param maxAttempts the maximum number of attempts
+ * @param interval interval in milliseconds to observe between attempts
+ */
+export type EventuallyOptions = {
+  maxAttempts?: number;
+  interval?: number;
+};
+
+const wait = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+const DEFAULT_INTERVAL = 1000;
+const DEFAULT_MAX_ATTEMPTS = 10;
+
+/**
+ * Runs a function on an interval until the maximum number of attempts has
+ * been reached.
+ *
+ * Default interval = 1000 milliseconds
+ * Default maxAttempts = 10
+ *
+ * @param fn function to run
+ * @param options EventuallyOptions
+ */
+const eventually = async <T>(call: () => Promise<T>, options?: EventuallyOptions): Promise<T> => {
+  const opts = {
+    interval: options?.interval ? options.interval : DEFAULT_INTERVAL,
+    maxAttempts: options?.maxAttempts ? options.maxAttempts : DEFAULT_MAX_ATTEMPTS,
+  };
+
+  while (opts.maxAttempts-- >= 0) {
+    try {
+      return await call();
+    } catch (err) {
+      if (opts.maxAttempts <= 0) throw err;
+    }
+    await wait(opts.interval);
+  }
+
+  throw new Error('An unexpected error has occurred.');
+};
+
+export default eventually;