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

package/lib/files.js

@@ -50,7 +50,8 @@ function findUp(name, directory = process.cwd()) {
  * Docker-safe home directory
  */
 function homeDir() {
-    return os.userInfo().homedir ?? os.homedir();
+    var _a;
+    return (_a = os.userInfo().homedir) !== null && _a !== void 0 ? _a : os.homedir();
 }
 async function loadLines(filename) {
     return await fs.pathExists(filename) ? (await fs.readFile(filename, { encoding: 'utf-8' })).trim().split('\n') : [];
@@ -76,4 +77,4 @@ function updateIniKey(lines, key, value) {
         lines.push(prefix + value);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/files.ts

@@ -0,0 +1,80 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+
+export async function rmFile(filename: string) {
+  if (await fs.pathExists(filename)) {
+    await fs.unlink(filename);
+  }
+}
+
+export async function addToFile(filename: string, line: string) {
+  let contents = await fs.pathExists(filename) ? await fs.readFile(filename, { encoding: 'utf-8' }) : '';
+  if (!contents.endsWith('\n')) {
+    contents += '\n';
+  }
+  contents += line + '\n';
+
+  await writeFile(filename, contents);
+}
+
+export async function writeFile(filename: string, contents: string) {
+  await fs.mkdirp(path.dirname(filename));
+  await fs.writeFile(filename, contents, { encoding: 'utf-8' });
+}
+
+export async function copyDirectoryContents(dir: string, target: string) {
+  for (const file of await fs.readdir(path.join(dir), { encoding: 'utf-8' })) {
+    await fs.copyFile(path.join(dir, file), path.join(target, file));
+  }
+}
+
+export function findUp(name: string, directory: string = process.cwd()): string | undefined {
+  const absoluteDirectory = path.resolve(directory);
+
+  const file = path.join(directory, name);
+  if (fs.existsSync(file)) {
+    return file;
+  }
+
+  const { root } = path.parse(absoluteDirectory);
+  if (absoluteDirectory == root) {
+    return undefined;
+  }
+
+  return findUp(name, path.dirname(absoluteDirectory));
+}
+
+/**
+ * Docker-safe home directory
+ */
+export function homeDir() {
+  return os.userInfo().homedir ?? os.homedir();
+}
+
+export async function loadLines(filename: string): Promise<string[]> {
+  return await fs.pathExists(filename) ? (await fs.readFile(filename, { encoding: 'utf-8' })).trim().split('\n') : [];
+}
+
+export async function writeLines(filename: string, lines: string[]) {
+  // Must end in a newline or our bash script won't read it properly
+  await fs.writeFile(filename, lines.join('\n') + '\n', { encoding: 'utf-8' });
+}
+
+/**
+ * Update a spaceless ini file in place
+ */
+export function updateIniKey(lines: string[], key: string, value: string) {
+  const prefix = `${key}=`;
+  let found = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith(prefix)) {
+      lines[i] = prefix + value;
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    lines.push(prefix + value);
+  }
+}

package/lib/github.js

@@ -4,6 +4,7 @@ exports.fetchPreviousVersion = fetchPreviousVersion;
 const rest_1 = require("@octokit/rest");
 const semver = require("semver");
 async function fetchPreviousVersion(token, options) {
+    var _a;
     const github = new rest_1.Octokit({ auth: token });
     const releases = await github.repos.listReleases({
         owner: 'aws',
@@ -14,18 +15,18 @@ async function fetchPreviousVersion(token, options) {
     // to previous major versions.
     let previousMVRelease = undefined;
     for (const release of releases.data) {
-        const version = release.name?.replace('v', '');
+        const version = (_a = release.name) === null || _a === void 0 ? void 0 : _a.replace('v', '');
         if (!version) {
             continue;
         }
         // Any old version is fine
-        if (!options?.majorVersion && !options?.priorTo) {
+        if (!(options === null || options === void 0 ? void 0 : options.majorVersion) && !(options === null || options === void 0 ? void 0 : options.priorTo)) {
             return version;
         }
-        if (options?.majorVersion && `${semver.major(version)}` === options.majorVersion) {
+        if ((options === null || options === void 0 ? void 0 : options.majorVersion) && `${semver.major(version)}` === options.majorVersion) {
             return version;
         }
-        if (options?.priorTo && semver.lt(version, options?.priorTo) && semver.major(version) === semver.major(options.priorTo)) {
+        if ((options === null || options === void 0 ? void 0 : options.priorTo) && semver.lt(version, options === null || options === void 0 ? void 0 : options.priorTo) && semver.major(version) === semver.major(options.priorTo)) {
             return version;
         }
         // Otherwise return the most recent version that didn't match any
@@ -39,4 +40,4 @@ async function fetchPreviousVersion(token, options) {
     throw new Error(`Unable to find previous version given ${JSON.stringify(options)}`);
 }
 ;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2l0aHViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZ2l0aHViLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0Esb0RBdUNDO0FBMUNELHdDQUF3QztBQUN4QyxpQ0FBaUM7QUFFMUIsS0FBSyxVQUFVLG9CQUFvQixDQUFDLEtBQWEsRUFBRSxPQUd6RDs7SUFDQyxNQUFNLE1BQU0sR0FBRyxJQUFJLGNBQU8sQ0FBQyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQzVDLE1BQU0sUUFBUSxHQUFHLE1BQU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUM7UUFDL0MsS0FBSyxFQUFFLEtBQUs7UUFDWixJQUFJLEVBQUUsU0FBUztLQUNoQixDQUFDLENBQUM7SUFFSCxpRUFBaUU7SUFDakUscUVBQXFFO0lBQ3JFLDhCQUE4QjtJQUM5QixJQUFJLGlCQUFpQixHQUFHLFNBQVMsQ0FBQztJQUNsQyxLQUFLLE1BQU0sT0FBTyxJQUFJLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNwQyxNQUFNLE9BQU8sR0FBRyxNQUFBLE9BQU8sQ0FBQyxJQUFJLDBDQUFFLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDL0MsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQUMsU0FBUztRQUFDLENBQUM7UUFFM0IsMEJBQTBCO1FBQzFCLElBQUksQ0FBQyxDQUFBLE9BQU8sYUFBUCxPQUFPLHVCQUFQLE9BQU8sQ0FBRSxZQUFZLENBQUEsSUFBSSxDQUFDLENBQUEsT0FBTyxhQUFQLE9BQU8sdUJBQVAsT0FBTyxDQUFFLE9BQU8sQ0FBQSxFQUFFLENBQUM7WUFDaEQsT0FBTyxPQUFPLENBQUM7UUFDakIsQ0FBQztRQUVELElBQUksQ0FBQSxPQUFPLGFBQVAsT0FBTyx1QkFBUCxPQUFPLENBQUUsWUFBWSxLQUFJLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBRSxLQUFLLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUNqRixPQUFPLE9BQU8sQ0FBQztRQUNqQixDQUFDO1FBRUQsSUFBSSxDQUFBLE9BQU8sYUFBUCxPQUFPLHVCQUFQLE9BQU8sQ0FBRSxPQUFPLEtBQUksTUFBTSxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsT0FBTyxhQUFQLE9BQU8sdUJBQVAsT0FBTyxDQUFFLE9BQU8sQ0FBQyxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssTUFBTSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztZQUN4SCxPQUFPLE9BQU8sQ0FBQztRQUNqQixDQUFDO1FBRUQsaUVBQWlFO1FBQ2pFLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1lBQ3ZCLGlCQUFpQixHQUFHLE9BQU8sQ0FBQztRQUM5QixDQUFDO0lBQ0gsQ0FBQztJQUNELElBQUksaUJBQWlCLEVBQUUsQ0FBQztRQUFDLE9BQU8saUJBQWlCLENBQUM7SUFBQyxDQUFDO0lBRXBELE1BQU0sSUFBSSxLQUFLLENBQUMseUNBQXlDLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0FBQ3RGLENBQUM7QUFBQSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2N0b2tpdCB9IGZyb20gJ0BvY3Rva2l0L3Jlc3QnO1xuaW1wb3J0ICogYXMgc2VtdmVyIGZyb20gJ3NlbXZlcic7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBmZXRjaFByZXZpb3VzVmVyc2lvbih0b2tlbjogc3RyaW5nLCBvcHRpb25zPzoge1xuICBwcmlvclRvPzogc3RyaW5nO1xuICBtYWpvclZlcnNpb24/OiBzdHJpbmc7XG59KSB7XG4gIGNvbnN0IGdpdGh1YiA9IG5ldyBPY3Rva2l0KHsgYXV0aDogdG9rZW4gfSk7XG4gIGNvbnN0IHJlbGVhc2VzID0gYXdhaXQgZ2l0aHViLnJlcG9zLmxpc3RSZWxlYXNlcyh7XG4gICAgb3duZXI6ICdhd3MnLFxuICAgIHJlcG86ICdhd3MtY2RrJyxcbiAgfSk7XG5cbiAgLy8gdGhpcyByZXR1cm5zIGEgbGlzdCBpbiBkZXNjZW5kaW5nIG9yZGVyLCBuZXdlc3QgcmVsZWFzZXMgZmlyc3RcbiAgLy8gb3B0cyBmb3Igc2FtZSBtYWpvciB2ZXJzaW9uIHdoZXJlIHBvc3NpYmxlLCBmYWxsaW5nIGJhY2sgb3RoZXJ3aXNlXG4gIC8vIHRvIHByZXZpb3VzIG1ham9yIHZlcnNpb25zLlxuICBsZXQgcHJldmlvdXNNVlJlbGVhc2UgPSB1bmRlZmluZWQ7XG4gIGZvciAoY29uc3QgcmVsZWFzZSBvZiByZWxlYXNlcy5kYXRhKSB7XG4gICAgY29uc3QgdmVyc2lvbiA9IHJlbGVhc2UubmFtZT8ucmVwbGFjZSgndicsICcnKTtcbiAgICBpZiAoIXZlcnNpb24pIHsgY29udGludWU7IH1cblxuICAgIC8vIEFueSBvbGQgdmVyc2lvbiBpcyBmaW5lXG4gICAgaWYgKCFvcHRpb25zPy5tYWpvclZlcnNpb24gJiYgIW9wdGlvbnM/LnByaW9yVG8pIHtcbiAgICAgIHJldHVybiB2ZXJzaW9uO1xuICAgIH1cblxuICAgIGlmIChvcHRpb25zPy5tYWpvclZlcnNpb24gJiYgYCR7c2VtdmVyLm1ham9yKHZlcnNpb24pfWAgPT09IG9wdGlvbnMubWFqb3JWZXJzaW9uKSB7XG4gICAgICByZXR1cm4gdmVyc2lvbjtcbiAgICB9XG5cbiAgICBpZiAob3B0aW9ucz8ucHJpb3JUbyAmJiBzZW12ZXIubHQodmVyc2lvbiwgb3B0aW9ucz8ucHJpb3JUbykgJiYgc2VtdmVyLm1ham9yKHZlcnNpb24pID09PSBzZW12ZXIubWFqb3Iob3B0aW9ucy5wcmlvclRvKSkge1xuICAgICAgcmV0dXJuIHZlcnNpb247XG4gICAgfVxuXG4gICAgLy8gT3RoZXJ3aXNlIHJldHVybiB0aGUgbW9zdCByZWNlbnQgdmVyc2lvbiB0aGF0IGRpZG4ndCBtYXRjaCBhbnlcbiAgICBpZiAoIXByZXZpb3VzTVZSZWxlYXNlKSB7XG4gICAgICBwcmV2aW91c01WUmVsZWFzZSA9IHZlcnNpb247XG4gICAgfVxuICB9XG4gIGlmIChwcmV2aW91c01WUmVsZWFzZSkgeyByZXR1cm4gcHJldmlvdXNNVlJlbGVhc2U7IH1cblxuICB0aHJvdyBuZXcgRXJyb3IoYFVuYWJsZSB0byBmaW5kIHByZXZpb3VzIHZlcnNpb24gZ2l2ZW4gJHtKU09OLnN0cmluZ2lmeShvcHRpb25zKX1gKTtcbn07XG4iXX0=

package/lib/github.ts

@@ -0,0 +1,43 @@
+import { Octokit } from '@octokit/rest';
+import * as semver from 'semver';
+
+export async function fetchPreviousVersion(token: string, options?: {
+  priorTo?: string;
+  majorVersion?: string;
+}) {
+  const github = new Octokit({ auth: token });
+  const releases = await github.repos.listReleases({
+    owner: 'aws',
+    repo: 'aws-cdk',
+  });
+
+  // this returns a list in descending order, newest releases first
+  // opts for same major version where possible, falling back otherwise
+  // to previous major versions.
+  let previousMVRelease = undefined;
+  for (const release of releases.data) {
+    const version = release.name?.replace('v', '');
+    if (!version) { continue; }
+
+    // Any old version is fine
+    if (!options?.majorVersion && !options?.priorTo) {
+      return version;
+    }
+
+    if (options?.majorVersion && `${semver.major(version)}` === options.majorVersion) {
+      return version;
+    }
+
+    if (options?.priorTo && semver.lt(version, options?.priorTo) && semver.major(version) === semver.major(options.priorTo)) {
+      return version;
+    }
+
+    // Otherwise return the most recent version that didn't match any
+    if (!previousMVRelease) {
+      previousMVRelease = version;
+    }
+  }
+  if (previousMVRelease) { return previousMVRelease; }
+
+  throw new Error(`Unable to find previous version given ${JSON.stringify(options)}`);
+};

package/lib/index.ts

@@ -0,0 +1,13 @@
+export * from './aws';
+export * from './corking';
+export * from './integ-test';
+export * from './memoize';
+export * from './resource-pool';
+export * from './with-cli-lib';
+export * from './with-sam';
+export * from './shell';
+export * from './with-aws';
+export * from './with-cdk-app';
+export * from './with-packages';
+export * from './with-temporary-directory';
+export * from './resources';

package/lib/integ-test.ts

@@ -0,0 +1,81 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { MemoryStream } from './corking';
+
+const SKIP_TESTS = fs.readFileSync(path.join(__dirname, '..', 'skip-tests.txt'), { encoding: 'utf-8' })
+  .split('\n')
+  .map(x => x.trim())
+  .filter(x => x && !x.startsWith('#'));
+
+if (SKIP_TESTS) {
+  process.stderr.write(`ℹ️ Skipping tests: ${JSON.stringify(SKIP_TESTS)}\n`);
+}
+
+export interface TestContext {
+  readonly randomString: string;
+  readonly output: NodeJS.WritableStream;
+  log(s: string): void;
+};
+
+if (process.env.JEST_TEST_CONCURRENT === 'true') {
+  process.stderr.write('ℹ️ JEST_TEST_CONCURRENT is true: tests will run concurrently and filters have no effect!\n0');
+}
+
+/**
+ * A wrapper for jest's 'test' which takes regression-disabled tests into account and prints a banner
+ */
+export function integTest(
+  name: string,
+  callback: (context: TestContext) => Promise<void>,
+  timeoutMillis?: number,
+): void {
+  // Integ tests can run concurrently, and are responsible for blocking
+  // themselves if they cannot.  Because `test.concurrent` executes the test
+  // code immediately, regardles of any `--testNamePattern`, this cannot be the
+  // default: test filtering simply does not work with `test.concurrent`.
+  // Instead, we make it opt-in only for the pipeline where we don't do any
+  // selection, but execute all tests unconditionally.
+  const testKind = process.env.JEST_TEST_CONCURRENT === 'true' ? test.concurrent : test;
+  const runner = shouldSkip(name) ? testKind.skip : testKind;
+
+  runner(name, async () => {
+    const output = new MemoryStream();
+
+    output.write('================================================================\n');
+    output.write(`${name}\n`);
+    output.write('================================================================\n');
+
+    const now = Date.now();
+    process.stderr.write(`[INTEG TEST::${name}] Starting (pid ${process.pid})...\n`);
+    try {
+      return await callback({
+        output,
+        randomString: randomString(),
+        log(s: string) {
+          output.write(`${s}\n`);
+        },
+      });
+    } catch (e: any) {
+      process.stderr.write(`[INTEG TEST::${name}] Failed: ${e}\n`);
+      output.write(e.message);
+      output.write(e.stack);
+      // Print output only if the test fails. Use 'console.log' so the output is buffered by
+      // jest and prints without a stack trace (if verbose: false).
+      // eslint-disable-next-line no-console
+      console.log(output.buffer().toString());
+      throw e;
+    } finally {
+      const duration = Date.now() - now;
+      process.stderr.write(`[INTEG TEST::${name}] Done (${duration} ms).\n`);
+    }
+  }, timeoutMillis);
+}
+
+function shouldSkip(testName: string) {
+  return SKIP_TESTS.includes(testName);
+}
+
+export function randomString() {
+  // Crazy
+  return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
+}

package/lib/lists.ts

@@ -0,0 +1,9 @@
+export function chunk<A>(n: number, xs: A[]): A[][] {
+  const ret = new Array<A[]>();
+
+  for (let i = 0; i < xs.length; i += n) {
+    ret.push(xs.slice(i, i + n));
+  }
+
+  return ret;
+}

package/lib/memoize.ts

@@ -0,0 +1,14 @@
+/**
+ * Return a memoized version of an function with 0 arguments.
+ *
+ * Async-safe.
+ */
+export function memoize0<A>(fn: () => Promise<A>): () => Promise<A> {
+  let promise: Promise<A> | undefined;
+  return () => {
+    if (!promise) {
+      promise = fn();
+    }
+    return promise;
+  };
+}

package/lib/npm.ts

@@ -0,0 +1,41 @@
+import { spawnSync } from 'child_process';
+
+const MINIMUM_VERSION = '3.9';
+
+/**
+ * Use NPM preinstalled on the machine to look up a list of TypeScript versions
+ */
+export function typescriptVersionsSync(): string[] {
+  const { stdout } = spawnSync('npm', ['--silent', 'view', `typescript@>=${MINIMUM_VERSION}`, 'version', '--json'], { encoding: 'utf-8' });
+
+  const versions: string[] = JSON.parse(stdout);
+  return Array.from(new Set(versions.map(v => v.split('.').slice(0, 2).join('.'))));
+}
+
+/**
+ * Use NPM preinstalled on the machine to query publish times of versions
+ */
+export function typescriptVersionsYoungerThanDaysSync(days: number, versions: string[]): string[] {
+  const { stdout } = spawnSync('npm', ['--silent', 'view', 'typescript', 'time', '--json'], { encoding: 'utf-8' });
+  const versionTsMap: Record<string, string> = JSON.parse(stdout);
+
+  const cutoffDate = new Date(Date.now() - (days * 24 * 3600 * 1000));
+  const cutoffDateS = cutoffDate.toISOString();
+
+  const recentVersions = Object.entries(versionTsMap)
+    .filter(([_, dateS]) => dateS > cutoffDateS)
+    .map(([v]) => v);
+
+  // Input versions are of the form 3.9, 5.2, etc.
+  // Actual versions are of the form `3.9.15`, `5.3.0-dev.20511311`.
+  // Return only 2-digit versions for which there is a non-prerelease version in the set of recentVersions
+  // So a 2-digit versions that is followed by `.<digits>` until the end of the string.
+  return versions.filter((twoV) => {
+    const re = new RegExp(`^${reQuote(twoV)}\\.\\d+$`);
+    return recentVersions.some(fullV => fullV.match(re));
+  });
+}
+
+function reQuote(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/lib/package-sources/release-source.js

@@ -14,6 +14,7 @@ class ReleasePackageSourceSetup {
         this.description = `release @ ${this.version}`;
     }
     async prepare() {
+        var _a;
         this.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
         fs.mkdirSync(this.tempDir, { recursive: true });
         await (0, shell_1.shell)(['node', require.resolve('npm'), 'install', `aws-cdk@${this.version}`], {
@@ -21,7 +22,7 @@ class ReleasePackageSourceSetup {
         });
         process.env.CDK_CLI_PATH = this.tempDir;
         process.env.VERSION = this.version;
-        process.env.FRAMEWORK_VERSION = this.frameworkVersion ?? this.version;
+        process.env.FRAMEWORK_VERSION = (_a = this.frameworkVersion) !== null && _a !== void 0 ? _a : this.version;
     }
     async cleanup() {
         if (this.tempDir) {
@@ -67,4 +68,4 @@ class ReleasePackageSource {
     }
 }
 exports.ReleasePackageSource = ReleasePackageSource;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/release-source.ts

@@ -0,0 +1,81 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import { IPackageSourceSetup, IPackageSource } from './source';
+import { copyDirectoryContents } from '../files';
+import { shell, rimraf, addToShellPath } from '../shell';
+
+export class ReleasePackageSourceSetup implements IPackageSourceSetup {
+  readonly name = 'release';
+  readonly description = `release @ ${this.version}`;
+
+  private tempDir?: string;
+
+  constructor(private readonly version: string, private readonly frameworkVersion?: string) {
+  }
+
+  public async prepare(): Promise<void> {
+    this.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
+    fs.mkdirSync(this.tempDir, { recursive: true });
+
+    await shell(['node', require.resolve('npm'), 'install', `aws-cdk@${this.version}`], {
+      cwd: this.tempDir,
+    });
+
+    process.env.CDK_CLI_PATH = this.tempDir;
+    process.env.VERSION = this.version;
+    process.env.FRAMEWORK_VERSION = this.frameworkVersion ?? this.version;
+  }
+
+  public async cleanup(): Promise<void> {
+    if (this.tempDir) {
+      rimraf(this.tempDir);
+    }
+  }
+}
+
+export class ReleasePackageSource implements IPackageSource {
+  private readonly cliPath: string;
+  private readonly version: string;
+
+  constructor() {
+    this.cliPath = process.env.CDK_CLI_PATH!;
+    this.version = process.env.VERSION!;
+  }
+
+  public async makeCliAvailable() {
+    addToShellPath(path.join(this.cliPath, 'node_modules', '.bin'));
+  }
+
+  public assertJsiiPackagesAvailable() {
+  }
+
+  public async initializeDotnetPackages(currentDir: string) {
+    if (process.env.CWD_FILES_DIR) {
+      await copyDirectoryContents(process.env.CWD_FILES_DIR, currentDir);
+    }
+  }
+
+  public majorVersion() {
+    return this.version.split('.')[0] as string;
+  }
+
+  public requestedCliVersion() {
+    return this.version;
+  }
+
+  public requestedFrameworkVersion() {
+    return process.env.FRAMEWORK_VERSION!;
+  }
+
+  public requestedAlphaVersion(): string {
+    const frameworkVersion = this.requestedFrameworkVersion();
+    if (frameworkVersion.includes('-rc.')) {
+      // For a pipeline release
+      return frameworkVersion.replace(/-rc\.\d+$/, '-alpha.999');
+    } else {
+      // For a stable release
+      return `${frameworkVersion}-alpha.0`;
+    }
+  }
+}

package/lib/package-sources/repo-source.ts

@@ -0,0 +1,111 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import { IPackageSourceSetup, IPackageSource } from './source';
+import { findUp } from '../files';
+import { shell, addToShellPath } from '../shell';
+
+export class RepoPackageSourceSetup implements IPackageSourceSetup {
+  readonly name = 'repo';
+  readonly description = `repo(${this.repoRoot})`;
+
+  constructor(private readonly repoRoot: string) {
+  }
+
+  public async prepare(): Promise<void> {
+    if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {
+      throw new Error(`${this.repoRoot}: does not look like the repository root`);
+    }
+
+    process.env.REPO_ROOT = this.repoRoot;
+    process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);
+    addToShellPath(path.resolve(__dirname, 'repo-tools'));
+  }
+
+  public async cleanup(): Promise<void> {
+  }
+}
+
+export class RepoPackageSource implements IPackageSource {
+  private readonly repoRoot: string;
+
+  constructor() {
+    this.repoRoot = process.env.REPO_ROOT as string;
+  }
+
+  public async makeCliAvailable() {
+    addToShellPath(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));
+  }
+
+  public assertJsiiPackagesAvailable() {
+    throw new Error('jsii client packages are not available when using REPO source');
+  }
+
+  public async initializeDotnetPackages() {
+  }
+
+  public majorVersion() {
+    const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));
+    return releaseJson.majorVersion;
+  }
+
+  public requestedCliVersion(): string {
+    return '*';
+  }
+
+  public requestedFrameworkVersion(): string {
+    return '*';
+  }
+
+  public requestedAlphaVersion(): string {
+    return '*';
+  }
+}
+
+async function writePackageMap(repoRoot: string): Promise<string> {
+  const packages = await findYarnPackages(repoRoot);
+  const fileName = path.join(os.tmpdir(), 'package-map.json');
+  await fs.writeJson(fileName, packages);
+  return fileName;
+}
+
+/**
+ * Cache monorepo discovery results, we only want to do this once per run
+ */
+const YARN_MONOREPO_CACHE: Record<string, any> = {};
+
+/**
+  * Return a { name -> directory } packages found in a Yarn monorepo
+  *
+  * Cached in YARN_MONOREPO_CACHE.
+  */
+export async function findYarnPackages(root: string): Promise<Record<string, string>> {
+  if (!(root in YARN_MONOREPO_CACHE)) {
+    const outputDataString: string = JSON.parse(await shell(['yarn', 'workspaces', '--json', 'info'], {
+      captureStderr: false,
+      cwd: root,
+      show: 'error',
+    })).data;
+    const output: YarnWorkspacesOutput = JSON.parse(outputDataString);
+
+    const ret: Record<string, string> = {};
+    for (const [k, v] of Object.entries(output)) {
+      ret[k] = path.join(root, v.location);
+    }
+    YARN_MONOREPO_CACHE[root] = ret;
+  }
+  return YARN_MONOREPO_CACHE[root];
+}
+
+/**
+ * Find the root directory of the repo from the current directory
+ */
+export async function autoFindRoot() {
+  const found = findUp('release.json');
+  if (!found) {
+    throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);
+  }
+  return path.dirname(found);
+}
+
+type YarnWorkspacesOutput = Record<string, { location: string }>;