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

package/lib/package-sources/repo-tools/npm.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process = require("child_process");
 const fs = require("fs-extra");
@@ -13,15 +14,15 @@ if (argv[0] === 'install') {
     // Replace paths in the 'package.json' in the current directory
     if (fs.pathExistsSync('package.json')) {
         const packageJson = fs.readJsonSync('package.json', { encoding: 'utf-8' });
-        for (const deps of [packageJson.dependencies ?? {}, packageJson.devDependencies ?? {}]) {
+        for (const deps of [(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : {}, (_b = packageJson.devDependencies) !== null && _b !== void 0 ? _b : {}]) {
             for (const [name, version] of Object.entries(deps)) {
-                deps[name] = repoPackageMap[name] ?? version;
+                deps[name] = (_c = repoPackageMap[name]) !== null && _c !== void 0 ? _c : version;
             }
         }
         fs.writeJsonSync('package.json', packageJson, { encoding: 'utf-8' });
     }
     // Replace package names on the command line
-    argv = argv.map(x => repoPackageMap[x] ?? x);
+    argv = argv.map(x => { var _a; return (_a = repoPackageMap[x]) !== null && _a !== void 0 ? _a : x; });
 }
 ////////////////////////////////////////////////////////////////////////
 //  Shell out to original npm
@@ -39,4 +40,4 @@ child.once('close', code => {
         process.exitCode = code;
     }
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/repo-tools/npm.ts

@@ -0,0 +1,48 @@
+import * as child_process from 'child_process';
+import * as fs from 'fs-extra';
+
+let argv = process.argv.slice(2);
+
+// eslint-disable-next-line no-console
+console.log('fake npm');
+
+if (argv[0] === 'install') {
+  if (!process.env.REPO_PACKAGE_MAP) {
+    throw new Error('REPO_PACKAGE_MAP not set');
+  }
+  const repoPackageMap = fs.readJsonSync(process.env.REPO_PACKAGE_MAP, { encoding: 'utf-8' });
+
+  // Replace paths in the 'package.json' in the current directory
+  if (fs.pathExistsSync('package.json')) {
+    const packageJson = fs.readJsonSync('package.json', { encoding: 'utf-8' });
+    for (const deps of [packageJson.dependencies ?? {}, packageJson.devDependencies ?? {}]) {
+      for (const [name, version] of Object.entries(deps)) {
+        deps[name] = repoPackageMap[name] ?? version;
+      }
+    }
+    fs.writeJsonSync('package.json', packageJson, { encoding: 'utf-8' });
+  }
+
+  // Replace package names on the command line
+  argv = argv.map(x => repoPackageMap[x] ?? x);
+}
+
+////////////////////////////////////////////////////////////////////////
+//  Shell out to original npm
+
+const child = child_process.spawn('node', [require.resolve('npm'), ...argv], {
+  shell: false,
+  stdio: ['ignore', 'inherit', 'inherit'],
+});
+
+child.once('error', e => {
+  // eslint-disable-next-line no-console
+  console.error(e);
+  process.exitCode = 1;
+});
+
+child.once('close', code => {
+  if (code) {
+    process.exitCode = code;
+  }
+});

package/lib/package-sources/source.ts

@@ -0,0 +1,35 @@
+export interface IPackageSourceSetup {
+  readonly name: string;
+  readonly description: string;
+
+  prepare(): Promise<void>;
+  cleanup(): Promise<void>;
+}
+
+export interface IPackageSource {
+  makeCliAvailable(): Promise<void>;
+
+  assertJsiiPackagesAvailable(): void;
+  majorVersion(): string;
+
+  initializeDotnetPackages(targetDir: string): Promise<void>;
+
+  /**
+   * CLI version
+   */
+  requestedCliVersion(): string;
+
+  /**
+   * Framework version if it's different than the CLI version
+   *
+   * Not all tests will respect this.
+   */
+  requestedFrameworkVersion(): string;
+
+  /**
+   * Versions of alpha packages if different than the CLI version
+   *
+   * Not all tests will respect this.
+   */
+  requestedAlphaVersion(): string;
+}

package/lib/package-sources/subprocess.ts

@@ -0,0 +1,15 @@
+import { ReleasePackageSource } from './release-source';
+import { RepoPackageSource } from './repo-source';
+import { IPackageSourceSetup, IPackageSource } from './source';
+
+export function serializeForSubprocess(s: IPackageSourceSetup) {
+  process.env.PACKAGE_SOURCE = s.name;
+}
+
+export function packageSourceInSubprocess(): IPackageSource {
+  switch (process.env.PACKAGE_SOURCE) {
+    case 'repo': return new RepoPackageSource();
+    case 'release': return new ReleasePackageSource();
+    default: throw new Error(`Unrecognized package source: ${process.env.PACKAGE_SOURCE}`);
+  }
+}

package/lib/resource-pool.js

@@ -99,7 +99,7 @@ class ResourcePool {
     async returnValue(value) {
         const lock = this.locks[value];
         delete this.locks[value];
-        await lock?.release();
+        await (lock === null || lock === void 0 ? void 0 : lock.release());
     }
 }
 exports.ResourcePool = ResourcePool;
@@ -114,4 +114,4 @@ function fisherYatesShuffle(xs) {
         xs[i] = h;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-pool.js","sourceRoot":"","sources":["resource-pool.ts"],"names":[],"mappings":"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","sourcesContent":["import { ILock, XpMutex, XpMutexPool } from './xpmutex';\n\n/**\n * A class that holds a pool of resources and gives them out and returns them on-demand\n *\n * The resources will be given out front to back, when they are returned\n * the most recently returned version will be given out again (for best\n * cache coherency).\n *\n * If there are multiple consumers waiting for a resource, consumers are serviced\n * in FIFO order for most fairness.\n */\nexport class ResourcePool<A extends string=string> {\n  public static withResources<A extends string>(name: string, resources: A[]) {\n    const pool = XpMutexPool.fromName(name);\n    return new ResourcePool(pool, resources);\n  }\n\n  private readonly resources: ReadonlyArray<A>;\n  private readonly mutexes: Record<string, XpMutex> = {};\n  private readonly locks: Record<string, ILock | undefined> = {};\n\n  private constructor(private readonly pool: XpMutexPool, resources: A[]) {\n    if (resources.length === 0) {\n      throw new Error('Must have at least one resource in the pool');\n    }\n\n    // Shuffle to reduce contention\n    resources = [...resources];\n    fisherYatesShuffle(resources);\n    this.resources = resources;\n\n    for (const res of resources) {\n      this.mutexes[res] = this.pool.mutex(res);\n    }\n  }\n\n  /**\n   * Take one value from the resource pool\n   *\n   * If no such value is currently available, wait until it is.\n   */\n  public async take(): Promise<ILease<A>> {\n    while (true) {\n      // Start a wait on the unlock now -- if the unlock signal comes after\n      // we try to acquire but before we start the wait, we might miss it.\n      //\n      // (The timeout is in case the unlock signal doesn't come for whatever reason).\n      const wait = this.pool.awaitUnlock(10_000);\n\n      // Try all mutexes, we might need to reacquire an expired lock\n      for (const res of this.resources) {\n        const lease = await this.tryObtainLease(res);\n        if (lease) {\n          // Ignore the wait (count as handled)\n          wait.then(() => {}, () => {});\n          return lease;\n        }\n      }\n\n      // None available, wait until one gets unlocked then try again\n      await wait;\n    }\n  }\n\n  /**\n   * Execute a block using a single resource from the pool\n   */\n  public async using<B>(block: (x: A) => B | Promise<B>): Promise<B> {\n    const lease = await this.take();\n    try {\n      return await block(lease.value);\n    } finally {\n      await lease.dispose();\n    }\n  }\n\n  private async tryObtainLease(value: A) {\n    const lock = await this.mutexes[value].tryAcquire();\n    if (!lock) {\n      return undefined;\n    }\n\n    this.locks[value] = lock;\n    return this.makeLease(value);\n  }\n\n  private makeLease(value: A): ILease<A> {\n    let disposed = false;\n    return {\n      value,\n      dispose: async () => {\n        if (disposed) {\n          throw new Error('Calling dispose() on an already-disposed lease.');\n        }\n        disposed = true;\n        return this.returnValue(value);\n      },\n    };\n  }\n\n  /**\n   * When a value is returned:\n   *\n   * - If someone's waiting for it, give it to them\n   * - Otherwise put it back into the pool\n   */\n  private async returnValue(value: string) {\n    const lock = this.locks[value];\n    delete this.locks[value];\n    await lock?.release();\n  }\n}\n\n/**\n * A single value taken from the pool\n */\nexport interface ILease<A> {\n  /**\n   * The value obtained by the lease\n   */\n  readonly value: A;\n\n  /**\n   * Return the leased value to the pool\n   */\n  dispose(): Promise<void>;\n}\n\n/**\n * Shuffle an array in-place\n */\nfunction fisherYatesShuffle<A>(xs: A[]) {\n  for (let i = xs.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * i);\n    const h = xs[j];\n    xs[j] = xs[i];\n    xs[i] = h;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-pool.js","sourceRoot":"","sources":["resource-pool.ts"],"names":[],"mappings":"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","sourcesContent":["import { ILock, XpMutex, XpMutexPool } from './xpmutex';\n\n/**\n * A class that holds a pool of resources and gives them out and returns them on-demand\n *\n * The resources will be given out front to back, when they are returned\n * the most recently returned version will be given out again (for best\n * cache coherency).\n *\n * If there are multiple consumers waiting for a resource, consumers are serviced\n * in FIFO order for most fairness.\n */\nexport class ResourcePool<A extends string=string> {\n  public static withResources<A extends string>(name: string, resources: A[]) {\n    const pool = XpMutexPool.fromName(name);\n    return new ResourcePool(pool, resources);\n  }\n\n  private readonly resources: ReadonlyArray<A>;\n  private readonly mutexes: Record<string, XpMutex> = {};\n  private readonly locks: Record<string, ILock | undefined> = {};\n\n  private constructor(private readonly pool: XpMutexPool, resources: A[]) {\n    if (resources.length === 0) {\n      throw new Error('Must have at least one resource in the pool');\n    }\n\n    // Shuffle to reduce contention\n    resources = [...resources];\n    fisherYatesShuffle(resources);\n    this.resources = resources;\n\n    for (const res of resources) {\n      this.mutexes[res] = this.pool.mutex(res);\n    }\n  }\n\n  /**\n   * Take one value from the resource pool\n   *\n   * If no such value is currently available, wait until it is.\n   */\n  public async take(): Promise<ILease<A>> {\n    while (true) {\n      // Start a wait on the unlock now -- if the unlock signal comes after\n      // we try to acquire but before we start the wait, we might miss it.\n      //\n      // (The timeout is in case the unlock signal doesn't come for whatever reason).\n      const wait = this.pool.awaitUnlock(10_000);\n\n      // Try all mutexes, we might need to reacquire an expired lock\n      for (const res of this.resources) {\n        const lease = await this.tryObtainLease(res);\n        if (lease) {\n          // Ignore the wait (count as handled)\n          wait.then(() => {}, () => {});\n          return lease;\n        }\n      }\n\n      // None available, wait until one gets unlocked then try again\n      await wait;\n    }\n  }\n\n  /**\n   * Execute a block using a single resource from the pool\n   */\n  public async using<B>(block: (x: A) => B | Promise<B>): Promise<B> {\n    const lease = await this.take();\n    try {\n      return await block(lease.value);\n    } finally {\n      await lease.dispose();\n    }\n  }\n\n  private async tryObtainLease(value: A) {\n    const lock = await this.mutexes[value].tryAcquire();\n    if (!lock) {\n      return undefined;\n    }\n\n    this.locks[value] = lock;\n    return this.makeLease(value);\n  }\n\n  private makeLease(value: A): ILease<A> {\n    let disposed = false;\n    return {\n      value,\n      dispose: async () => {\n        if (disposed) {\n          throw new Error('Calling dispose() on an already-disposed lease.');\n        }\n        disposed = true;\n        return this.returnValue(value);\n      },\n    };\n  }\n\n  /**\n   * When a value is returned:\n   *\n   * - If someone's waiting for it, give it to them\n   * - Otherwise put it back into the pool\n   */\n  private async returnValue(value: string) {\n    const lock = this.locks[value];\n    delete this.locks[value];\n    await lock?.release();\n  }\n}\n\n/**\n * A single value taken from the pool\n */\nexport interface ILease<A> {\n  /**\n   * The value obtained by the lease\n   */\n  readonly value: A;\n\n  /**\n   * Return the leased value to the pool\n   */\n  dispose(): Promise<void>;\n}\n\n/**\n * Shuffle an array in-place\n */\nfunction fisherYatesShuffle<A>(xs: A[]) {\n  for (let i = xs.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * i);\n    const h = xs[j];\n    xs[j] = xs[i];\n    xs[i] = h;\n  }\n}\n"]}

package/lib/resource-pool.ts

@@ -0,0 +1,140 @@
+import { ILock, XpMutex, XpMutexPool } from './xpmutex';
+
+/**
+ * A class that holds a pool of resources and gives them out and returns them on-demand
+ *
+ * The resources will be given out front to back, when they are returned
+ * the most recently returned version will be given out again (for best
+ * cache coherency).
+ *
+ * If there are multiple consumers waiting for a resource, consumers are serviced
+ * in FIFO order for most fairness.
+ */
+export class ResourcePool<A extends string=string> {
+  public static withResources<A extends string>(name: string, resources: A[]) {
+    const pool = XpMutexPool.fromName(name);
+    return new ResourcePool(pool, resources);
+  }
+
+  private readonly resources: ReadonlyArray<A>;
+  private readonly mutexes: Record<string, XpMutex> = {};
+  private readonly locks: Record<string, ILock | undefined> = {};
+
+  private constructor(private readonly pool: XpMutexPool, resources: A[]) {
+    if (resources.length === 0) {
+      throw new Error('Must have at least one resource in the pool');
+    }
+
+    // Shuffle to reduce contention
+    resources = [...resources];
+    fisherYatesShuffle(resources);
+    this.resources = resources;
+
+    for (const res of resources) {
+      this.mutexes[res] = this.pool.mutex(res);
+    }
+  }
+
+  /**
+   * Take one value from the resource pool
+   *
+   * If no such value is currently available, wait until it is.
+   */
+  public async take(): Promise<ILease<A>> {
+    while (true) {
+      // Start a wait on the unlock now -- if the unlock signal comes after
+      // we try to acquire but before we start the wait, we might miss it.
+      //
+      // (The timeout is in case the unlock signal doesn't come for whatever reason).
+      const wait = this.pool.awaitUnlock(10_000);
+
+      // Try all mutexes, we might need to reacquire an expired lock
+      for (const res of this.resources) {
+        const lease = await this.tryObtainLease(res);
+        if (lease) {
+          // Ignore the wait (count as handled)
+          wait.then(() => {}, () => {});
+          return lease;
+        }
+      }
+
+      // None available, wait until one gets unlocked then try again
+      await wait;
+    }
+  }
+
+  /**
+   * Execute a block using a single resource from the pool
+   */
+  public async using<B>(block: (x: A) => B | Promise<B>): Promise<B> {
+    const lease = await this.take();
+    try {
+      return await block(lease.value);
+    } finally {
+      await lease.dispose();
+    }
+  }
+
+  private async tryObtainLease(value: A) {
+    const lock = await this.mutexes[value].tryAcquire();
+    if (!lock) {
+      return undefined;
+    }
+
+    this.locks[value] = lock;
+    return this.makeLease(value);
+  }
+
+  private makeLease(value: A): ILease<A> {
+    let disposed = false;
+    return {
+      value,
+      dispose: async () => {
+        if (disposed) {
+          throw new Error('Calling dispose() on an already-disposed lease.');
+        }
+        disposed = true;
+        return this.returnValue(value);
+      },
+    };
+  }
+
+  /**
+   * When a value is returned:
+   *
+   * - If someone's waiting for it, give it to them
+   * - Otherwise put it back into the pool
+   */
+  private async returnValue(value: string) {
+    const lock = this.locks[value];
+    delete this.locks[value];
+    await lock?.release();
+  }
+}
+
+/**
+ * A single value taken from the pool
+ */
+export interface ILease<A> {
+  /**
+   * The value obtained by the lease
+   */
+  readonly value: A;
+
+  /**
+   * Return the leased value to the pool
+   */
+  dispose(): Promise<void>;
+}
+
+/**
+ * Shuffle an array in-place
+ */
+function fisherYatesShuffle<A>(xs: A[]) {
+  for (let i = xs.length - 1; i >= 1; i--) {
+    const j = Math.floor(Math.random() * i);
+    const h = xs[j];
+    xs[j] = xs[i];
+    xs[i] = h;
+  }
+}

package/lib/resources.ts

@@ -0,0 +1,4 @@
+import * as path from 'path';
+
+export const RESOURCES_DIR = path.resolve(__dirname, '..', 'resources');
+

package/lib/shell.js

@@ -13,6 +13,7 @@ const path = require("path");
  * Is platform-aware, handles errors nicely.
  */
 async function shell(command, options = {}) {
+    var _a, _b;
     if (options.modEnv && options.env) {
         throw new Error('Use either env or modEnv but not both');
     }
@@ -24,11 +25,11 @@ async function shell(command, options = {}) {
     };
     // Always output the command
     writeToOutputs(`💻 ${command.join(' ')}\n`);
-    const show = options.show ?? 'always';
+    const show = (_a = options.show) !== null && _a !== void 0 ? _a : 'always';
     if (process.env.VERBOSE) {
         outputs.add(process.stdout);
     }
-    const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);
+    const env = (_b = options.env) !== null && _b !== void 0 ? _b : (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);
     const child = child_process.spawn(command[0], command.slice(1), {
         ...options,
         env,
@@ -46,10 +47,11 @@ async function shell(command, options = {}) {
             stdout.push(chunk);
         });
         child.stderr.on('data', chunk => {
+            var _a;
             if (show === 'always') {
                 writeToOutputs(chunk);
             }
-            if (options.captureStderr ?? true) {
+            if ((_a = options.captureStderr) !== null && _a !== void 0 ? _a : true) {
                 stderr.push(chunk);
             }
         });
@@ -111,10 +113,11 @@ function rimraf(fsPath) {
     }
 }
 function addToShellPath(x) {
-    const parts = process.env.PATH?.split(':') ?? [];
+    var _a, _b;
+    const parts = (_b = (_a = process.env.PATH) === null || _a === void 0 ? void 0 : _a.split(':')) !== null && _b !== void 0 ? _b : [];
     if (!parts.includes(x)) {
         parts.unshift(x);
     }
     process.env.PATH = parts.join(':');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell.js","sourceRoot":"","sources":["shell.ts"],"names":[],"mappings":";;;AAWA,sBAkEC;AAgED,wBAgBC;AAED,wCAQC;AAvKD,+CAA+C;AAC/C,yBAAyB;AACzB,6BAA6B;AAI7B;;;;GAIG;AACI,KAAK,UAAU,KAAK,CAAC,OAAiB,EAAE,UAAwB,EAAE;IACvE,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC3D,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,MAAM,cAAc,GAAG,CAAC,CAAS,EAAE,EAAE;QACnC,KAAK,MAAM,YAAY,IAAI,OAAO,EAAE,CAAC;YACnC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC;IACH,CAAC,CAAC;IAEF,4BAA4B;IAC5B,cAAc,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,QAAQ,CAAC;IAEtC,IAAI,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACxB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAElG,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;QAC9D,GAAG,OAAO;QACV,GAAG;QACH,yEAAyE;QACzE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC;KAClC,CAAC,CAAC;IAEH,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC7C,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QAEnC,KAAK,CAAC,MAAO,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE;YAC/B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,cAAc,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,MAAO,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE;YAC/B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,cAAc,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC;YACD,IAAI,OAAO,CAAC,aAAa,IAAI,IAAI,EAAE,CAAC;gBAClC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAE5B,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE;YACzB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC7D,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC7D,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,GAAG,YAAY,CAAC,CAAC,IAAI,EAAE,CAAC;YACrF,IAAI,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACvC,OAAO,CAAC,GAAG,CAAC,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;oBACrB,cAAc,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;gBAC7B,CAAC;gBACD,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,4BAA4B,IAAI,GAAG,CAAC,CAAC,CAAC;YAC9E,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AA2CD,MAAa,WAAW;IACf,MAAM,CAAC,WAAW,CAAC,OAAgD;QACxE,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/D,CAAC;IAED,YACmB,IAAY,EACZ,OAA8B;QAD9B,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAuB;IAAI,CAAC;IAE/C,KAAK,CAAC,KAAK,CAAC,OAAiB,EAAE,UAAiD,EAAE;QACvF,OAAO,KAAK,CAAC,OAAO,EAAE;YACpB,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;YACvB,GAAG,EAAE,IAAI,CAAC,IAAI;YACd,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;CACF;AAhBD,kCAgBC;AAED;;GAEG;AACH,SAAgB,MAAM,CAAC,MAAc;IACnC,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;QAEjD,IAAI,KAAK,EAAE,CAAC;YACV,KAAK,MAAM,IAAI,IAAI,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;YAClC,CAAC;YACD,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;aAAM,CAAC;YACN,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,yBAAyB;QACzB,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAAC,MAAM,CAAC,CAAC;QAAC,CAAC;IACvC,CAAC;AACH,CAAC;AAED,SAAgB,cAAc,CAAC,CAAS;IACtC,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IAEjD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QACvB,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACrC,CAAC","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { TestContext } from './integ-test';\nimport { TemporaryDirectoryContext } from './with-temporary-directory';\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  const outputs = new Set(options.outputs);\n  const writeToOutputs = (x: string) => {\n    for (const outputStream of outputs) {\n      outputStream.write(x);\n    }\n  };\n\n  // Always output the command\n  writeToOutputs(`💻 ${command.join(' ')}\\n`);\n  const show = options.show ?? 'always';\n\n  if (process.env.VERBOSE) {\n    outputs.add(process.stdout);\n  }\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk);\n      }\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk);\n      }\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      const stderrOutput = Buffer.concat(stderr).toString('utf-8');\n      const stdoutOutput = Buffer.concat(stdout).toString('utf-8');\n      const out = (options.onlyStderr ? stderrOutput : stdoutOutput + stderrOutput).trim();\n      if (code === 0 || options.allowErrExit) {\n        resolve(out);\n      } else {\n        if (show === 'error') {\n          writeToOutputs(`${out}\\n`);\n        }\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));\n      }\n    });\n  });\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  readonly modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  readonly allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  readonly captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  readonly outputs?: NodeJS.WritableStream[];\n\n  /**\n   * Only return stderr. For example, this is used to validate\n   * that when CI=true, all logs are sent to stdout.\n   *\n   * @default false\n   */\n  readonly onlyStderr?: boolean;\n\n  /**\n   * Don't log to stdout\n   *\n   * @default always\n   */\n  readonly show?: 'always' | 'never' | 'error';\n}\n\nexport class ShellHelper {\n  public static fromContext(context: TestContext & TemporaryDirectoryContext) {\n    return new ShellHelper(context.integTestDir, context.output);\n  }\n\n  constructor(\n    private readonly _cwd: string,\n    private readonly _output: NodeJS.WritableStream) { }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd' | 'outputs'> = {}): Promise<string> {\n    return shell(command, {\n      outputs: [this._output],\n      cwd: this._cwd,\n      ...options,\n    });\n  }\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e: any) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function addToShellPath(x: string) {\n  const parts = process.env.PATH?.split(':') ?? [];\n\n  if (!parts.includes(x)) {\n    parts.unshift(x);\n  }\n\n  process.env.PATH = parts.join(':');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell.js","sourceRoot":"","sources":["shell.ts"],"names":[],"mappings":";;;AAWA,sBAkEC;AAgED,wBAgBC;AAED,wCAQC;AAvKD,+CAA+C;AAC/C,yBAAyB;AACzB,6BAA6B;AAI7B;;;;GAIG;AACI,KAAK,UAAU,KAAK,CAAC,OAAiB,EAAE,UAAwB,EAAE;;IACvE,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC3D,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,MAAM,cAAc,GAAG,CAAC,CAAS,EAAE,EAAE;QACnC,KAAK,MAAM,YAAY,IAAI,OAAO,EAAE,CAAC;YACnC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC;IACH,CAAC,CAAC;IAEF,4BAA4B;IAC5B,cAAc,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,MAAA,OAAO,CAAC,IAAI,mCAAI,QAAQ,CAAC;IAEtC,IAAI,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACxB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,GAAG,GAAG,MAAA,OAAO,CAAC,GAAG,mCAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAElG,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;QAC9D,GAAG,OAAO;QACV,GAAG;QACH,yEAAyE;QACzE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC;KAClC,CAAC,CAAC;IAEH,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC7C,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QAEnC,KAAK,CAAC,MAAO,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE;YAC/B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,cAAc,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,MAAO,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE;;YAC/B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,cAAc,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC;YACD,IAAI,MAAA,OAAO,CAAC,aAAa,mCAAI,IAAI,EAAE,CAAC;gBAClC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAE5B,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE;YACzB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC7D,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC7D,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,GAAG,YAAY,CAAC,CAAC,IAAI,EAAE,CAAC;YACrF,IAAI,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACvC,OAAO,CAAC,GAAG,CAAC,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;oBACrB,cAAc,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;gBAC7B,CAAC;gBACD,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,4BAA4B,IAAI,GAAG,CAAC,CAAC,CAAC;YAC9E,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AA2CD,MAAa,WAAW;IACf,MAAM,CAAC,WAAW,CAAC,OAAgD;QACxE,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/D,CAAC;IAED,YACmB,IAAY,EACZ,OAA8B;QAD9B,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAuB;IAAI,CAAC;IAE/C,KAAK,CAAC,KAAK,CAAC,OAAiB,EAAE,UAAiD,EAAE;QACvF,OAAO,KAAK,CAAC,OAAO,EAAE;YACpB,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;YACvB,GAAG,EAAE,IAAI,CAAC,IAAI;YACd,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;CACF;AAhBD,kCAgBC;AAED;;GAEG;AACH,SAAgB,MAAM,CAAC,MAAc;IACnC,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;QAEjD,IAAI,KAAK,EAAE,CAAC;YACV,KAAK,MAAM,IAAI,IAAI,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;YAClC,CAAC;YACD,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;aAAM,CAAC;YACN,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,yBAAyB;QACzB,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAAC,MAAM,CAAC,CAAC;QAAC,CAAC;IACvC,CAAC;AACH,CAAC;AAED,SAAgB,cAAc,CAAC,CAAS;;IACtC,MAAM,KAAK,GAAG,MAAA,MAAA,OAAO,CAAC,GAAG,CAAC,IAAI,0CAAE,KAAK,CAAC,GAAG,CAAC,mCAAI,EAAE,CAAC;IAEjD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QACvB,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACrC,CAAC","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { TestContext } from './integ-test';\nimport { TemporaryDirectoryContext } from './with-temporary-directory';\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shell(command: string[], options: ShellOptions = {}): Promise<string> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  const outputs = new Set(options.outputs);\n  const writeToOutputs = (x: string) => {\n    for (const outputStream of outputs) {\n      outputStream.write(x);\n    }\n  };\n\n  // Always output the command\n  writeToOutputs(`💻 ${command.join(' ')}\\n`);\n  const show = options.show ?? 'always';\n\n  if (process.env.VERBOSE) {\n    outputs.add(process.stdout);\n  }\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    child.stdout!.on('data', chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk);\n      }\n      stdout.push(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk);\n      }\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      const stderrOutput = Buffer.concat(stderr).toString('utf-8');\n      const stdoutOutput = Buffer.concat(stdout).toString('utf-8');\n      const out = (options.onlyStderr ? stderrOutput : stdoutOutput + stderrOutput).trim();\n      if (code === 0 || options.allowErrExit) {\n        resolve(out);\n      } else {\n        if (show === 'error') {\n          writeToOutputs(`${out}\\n`);\n        }\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));\n      }\n    });\n  });\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  readonly modEnv?: Record<string, string>;\n\n  /**\n   * Don't fail when exiting with an error\n   *\n   * @default false\n   */\n  readonly allowErrExit?: boolean;\n\n  /**\n   * Whether to capture stderr\n   *\n   * @default true\n   */\n  readonly captureStderr?: boolean;\n\n  /**\n   * Pass output here\n   */\n  readonly outputs?: NodeJS.WritableStream[];\n\n  /**\n   * Only return stderr. For example, this is used to validate\n   * that when CI=true, all logs are sent to stdout.\n   *\n   * @default false\n   */\n  readonly onlyStderr?: boolean;\n\n  /**\n   * Don't log to stdout\n   *\n   * @default always\n   */\n  readonly show?: 'always' | 'never' | 'error';\n}\n\nexport class ShellHelper {\n  public static fromContext(context: TestContext & TemporaryDirectoryContext) {\n    return new ShellHelper(context.integTestDir, context.output);\n  }\n\n  constructor(\n    private readonly _cwd: string,\n    private readonly _output: NodeJS.WritableStream) { }\n\n  public async shell(command: string[], options: Omit<ShellOptions, 'cwd' | 'outputs'> = {}): Promise<string> {\n    return shell(command, {\n      outputs: [this._output],\n      cwd: this._cwd,\n      ...options,\n    });\n  }\n}\n\n/**\n * rm -rf reimplementation, don't want to depend on an NPM package for this\n */\nexport function rimraf(fsPath: string) {\n  try {\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n  } catch (e: any) {\n    // We will survive ENOENT\n    if (e.code !== 'ENOENT') { throw e; }\n  }\n}\n\nexport function addToShellPath(x: string) {\n  const parts = process.env.PATH?.split(':') ?? [];\n\n  if (!parts.includes(x)) {\n    parts.unshift(x);\n  }\n\n  process.env.PATH = parts.join(':');\n}\n"]}

package/lib/shell.ts

@@ -0,0 +1,168 @@
+import * as child_process from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { TestContext } from './integ-test';
+import { TemporaryDirectoryContext } from './with-temporary-directory';
+
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+export async function shell(command: string[], options: ShellOptions = {}): Promise<string> {
+  if (options.modEnv && options.env) {
+    throw new Error('Use either env or modEnv but not both');
+  }
+
+  const outputs = new Set(options.outputs);
+  const writeToOutputs = (x: string) => {
+    for (const outputStream of outputs) {
+      outputStream.write(x);
+    }
+  };
+
+  // Always output the command
+  writeToOutputs(`💻 ${command.join(' ')}\n`);
+  const show = options.show ?? 'always';
+
+  if (process.env.VERBOSE) {
+    outputs.add(process.stdout);
+  }
+
+  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);
+
+  const child = child_process.spawn(command[0], command.slice(1), {
+    ...options,
+    env,
+    // Need this for Windows where we want .cmd and .bat to be found as well.
+    shell: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  return new Promise<string>((resolve, reject) => {
+    const stdout = new Array<Buffer>();
+    const stderr = new Array<Buffer>();
+
+    child.stdout!.on('data', chunk => {
+      if (show === 'always') {
+        writeToOutputs(chunk);
+      }
+      stdout.push(chunk);
+    });
+
+    child.stderr!.on('data', chunk => {
+      if (show === 'always') {
+        writeToOutputs(chunk);
+      }
+      if (options.captureStderr ?? true) {
+        stderr.push(chunk);
+      }
+    });
+
+    child.once('error', reject);
+
+    child.once('close', code => {
+      const stderrOutput = Buffer.concat(stderr).toString('utf-8');
+      const stdoutOutput = Buffer.concat(stdout).toString('utf-8');
+      const out = (options.onlyStderr ? stderrOutput : stdoutOutput + stderrOutput).trim();
+      if (code === 0 || options.allowErrExit) {
+        resolve(out);
+      } else {
+        if (show === 'error') {
+          writeToOutputs(`${out}\n`);
+        }
+        reject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));
+      }
+    });
+  });
+}
+
+export interface ShellOptions extends child_process.SpawnOptions {
+  /**
+   * Properties to add to 'env'
+   */
+  readonly modEnv?: Record<string, string>;
+
+  /**
+   * Don't fail when exiting with an error
+   *
+   * @default false
+   */
+  readonly allowErrExit?: boolean;
+
+  /**
+   * Whether to capture stderr
+   *
+   * @default true
+   */
+  readonly captureStderr?: boolean;
+
+  /**
+   * Pass output here
+   */
+  readonly outputs?: NodeJS.WritableStream[];
+
+  /**
+   * Only return stderr. For example, this is used to validate
+   * that when CI=true, all logs are sent to stdout.
+   *
+   * @default false
+   */
+  readonly onlyStderr?: boolean;
+
+  /**
+   * Don't log to stdout
+   *
+   * @default always
+   */
+  readonly show?: 'always' | 'never' | 'error';
+}
+
+export class ShellHelper {
+  public static fromContext(context: TestContext & TemporaryDirectoryContext) {
+    return new ShellHelper(context.integTestDir, context.output);
+  }
+
+  constructor(
+    private readonly _cwd: string,
+    private readonly _output: NodeJS.WritableStream) { }
+
+  public async shell(command: string[], options: Omit<ShellOptions, 'cwd' | 'outputs'> = {}): Promise<string> {
+    return shell(command, {
+      outputs: [this._output],
+      cwd: this._cwd,
+      ...options,
+    });
+  }
+}
+
+/**
+ * rm -rf reimplementation, don't want to depend on an NPM package for this
+ */
+export function rimraf(fsPath: string) {
+  try {
+    const isDir = fs.lstatSync(fsPath).isDirectory();
+
+    if (isDir) {
+      for (const file of fs.readdirSync(fsPath)) {
+        rimraf(path.join(fsPath, file));
+      }
+      fs.rmdirSync(fsPath);
+    } else {
+      fs.unlinkSync(fsPath);
+    }
+  } catch (e: any) {
+    // We will survive ENOENT
+    if (e.code !== 'ENOENT') { throw e; }
+  }
+}
+
+export function addToShellPath(x: string) {
+  const parts = process.env.PATH?.split(':') ?? [];
+
+  if (!parts.includes(x)) {
+    parts.unshift(x);
+  }
+
+  process.env.PATH = parts.join(':');
+}