@aws-cdk-testing/cli-integ 3.2.3 → 3.3.0

package/lib/process.d.ts

@@ -0,0 +1,45 @@
+import * as child from 'child_process';
+import * as pty from 'node-pty';
+/**
+ * IProcess provides an interface to work with a subprocess.
+ */
+export interface IProcess {
+    /**
+     * Register a callback to be invoked when a chunk is written to stdout.
+     */
+    onStdout(callback: (chunk: Buffer) => void): void;
+    /**
+     * Register a callback to be invoked when a chunk is written to stderr.
+     */
+    onStderr(callback: (chunk: Buffer) => void): void;
+    /**
+     * Register a callback to be invoked when the process exists.
+     */
+    onExit(callback: (exitCode: number) => void): void;
+    /**
+     * Register a callback to be invoked if the process failed to start.
+     */
+    onError(callback: (error: Error) => void): void;
+    /**
+     * Write the process stdin stream.
+     */
+    writeStdin(data: string): void;
+    /**
+     * Singal that no more data will be written to stdin. In non tty process you must
+     * call this method to make sure the process exits.
+     *
+     * @param delay - optional delay in milliseconds before the signal is sent.
+     *
+     */
+    endStdin(delay?: number): void;
+}
+export declare class Process {
+    /**
+     * Spawn a process with a TTY attached.
+     */
+    static spawnTTY(command: string, args: string[], options?: pty.IPtyForkOptions | pty.IWindowsPtyForkOptions): IProcess;
+    /**
+     * Spawn a process without a forcing a TTY.
+     */
+    static spawn(command: string, args: string[], options?: child.SpawnOptions): IProcess;
+}

package/lib/process.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Process = void 0;
+const child = require("child_process");
+const pty = require("node-pty");
+;
+class Process {
+    /**
+     * Spawn a process with a TTY attached.
+     */
+    static spawnTTY(command, args, options = {}) {
+        const process = pty.spawn(command, args, {
+            name: 'xterm-color',
+            ...options,
+        });
+        return new PtyProcess(process);
+    }
+    /**
+     * Spawn a process without a forcing a TTY.
+     */
+    static spawn(command, args, options = {}) {
+        const process = child.spawn(command, args, {
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            ...options,
+        });
+        return new NonPtyProcess(process);
+    }
+}
+exports.Process = Process;
+class PtyProcess {
+    constructor(process) {
+        this.process = process;
+    }
+    endStdin(_) {
+        // not needed because all streams are the same in tty.
+    }
+    onError(_) {
+        // not needed because the pty.spawn will simply fail in this case.
+    }
+    onStdout(callback) {
+        this.process.onData((e) => callback(Buffer.from(e)));
+    }
+    onStderr(callback) {
+        // in a pty all streams are the same
+        return this.onStdout(callback);
+    }
+    onExit(callback) {
+        this.process.onExit((e) => { callback(e.exitCode); });
+    }
+    writeStdin(data) {
+        // in a pty all streams are the same
+        this.process.write(data);
+    }
+}
+;
+class NonPtyProcess {
+    constructor(process) {
+        this.process = process;
+    }
+    onError(callback) {
+        this.process.once('error', callback);
+    }
+    onStdout(callback) {
+        this.assertDefined('stdout', this.process.stdout);
+        this.process.stdout.on('data', callback);
+    }
+    onStderr(callback) {
+        this.assertDefined('stderr', this.process.stderr);
+        this.process.stderr.on('data', callback);
+    }
+    onExit(callback) {
+        this.process.on('close', callback);
+    }
+    writeStdin(content) {
+        this.assertDefined('stdin', this.process.stdin);
+        this.process.stdin.write(content);
+    }
+    endStdin(delay) {
+        if (this.process.stdin == null) {
+            throw new Error('No stdin defined for process');
+        }
+        if (delay) {
+            setTimeout(() => this.process.stdin.end(), delay);
+        }
+        else {
+            this.process.stdin.end();
+        }
+    }
+    assertDefined(name, stream) {
+        if (stream == null) {
+            throw new Error(`No ${name} defined for child process`);
+        }
+    }
+}
+;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process.js","sourceRoot":"","sources":["process.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child from 'child_process';\nimport { Readable, Writable } from 'stream';\nimport * as pty from 'node-pty';\n\n/**\n * IProcess provides an interface to work with a subprocess.\n */\nexport interface IProcess {\n\n  /**\n   * Register a callback to be invoked when a chunk is written to stdout.\n   */\n  onStdout(callback: (chunk: Buffer) => void): void;\n\n  /**\n   * Register a callback to be invoked when a chunk is written to stderr.\n   */\n  onStderr(callback: (chunk: Buffer) => void): void;\n\n  /**\n   * Register a callback to be invoked when the process exists.\n   */\n  onExit(callback: (exitCode: number) => void): void;\n\n  /**\n   * Register a callback to be invoked if the process failed to start.\n   */\n  onError(callback: (error: Error) => void): void;\n\n  /**\n   * Write the process stdin stream.\n   */\n  writeStdin(data: string): void;\n\n  /**\n   * Singal that no more data will be written to stdin. In non tty process you must\n   * call this method to make sure the process exits.\n   *\n   * @param delay - optional delay in milliseconds before the signal is sent.\n   *\n   */\n  endStdin(delay?: number): void;\n\n};\n\nexport class Process {\n\n  /**\n   * Spawn a process with a TTY attached.\n   */\n  public static spawnTTY(command: string, args: string[], options: pty.IPtyForkOptions | pty.IWindowsPtyForkOptions = {}): IProcess {\n\n    const process = pty.spawn(command, args, {\n      name: 'xterm-color',\n      ...options,\n    })\n    return new PtyProcess(process);\n\n  }\n\n  /**\n   * Spawn a process without a forcing a TTY.\n   */\n  public static spawn(command: string, args: string[], options: child.SpawnOptions = {}): IProcess {\n\n    const process = child.spawn(command, args, {\n      shell: true,\n      stdio: ['ignore', 'pipe', 'pipe'],\n      ...options,\n    });\n    return new NonPtyProcess(process);\n\n  }\n\n}\n\nclass PtyProcess implements IProcess {\n\n  public constructor(private readonly process: pty.IPty) {}\n\n  public endStdin(_?: number): void {\n    // not needed because all streams are the same in tty.\n  }\n\n  public onError(_: (error: Error) => void): void {\n    // not needed because the pty.spawn will simply fail in this case.\n  }\n\n  public onStdout(callback: (chunk: Buffer) => void): void {\n    this.process.onData((e) => callback(Buffer.from(e)));\n  }\n\n  public onStderr(callback: (chunk: Buffer) => void): void {\n    // in a pty all streams are the same\n    return this.onStdout(callback);\n  }\n\n  public onExit(callback: (exitCode: number) => void): void {\n    this.process.onExit((e) => { callback(e.exitCode) });\n  }\n\n\n  public writeStdin(data: string): void {\n    // in a pty all streams are the same\n    this.process.write(data)\n  }\n\n};\n\nclass NonPtyProcess implements IProcess {\n\n  public constructor(private readonly process: child.ChildProcess) {}\n\n  public onError(callback: (error: Error) => void): void {\n    this.process.once('error', callback);\n  }\n\n  public onStdout(callback: (chunk: Buffer) => void): void {\n    this.assertDefined('stdout', this.process.stdout);\n    this.process.stdout.on('data', callback);\n  }\n\n  public onStderr(callback: (chunk: Buffer) => void): void {\n    this.assertDefined('stderr', this.process.stderr);\n    this.process.stderr.on('data', callback);\n  }\n\n  public onExit(callback: (exitCode: number) => void): void {\n    this.process.on('close', callback);\n  }\n\n  public writeStdin(content: string): void {\n    this.assertDefined('stdin', this.process.stdin);\n    this.process.stdin.write(content);\n  }\n\n  public endStdin(delay?: number): void {\n    if (this.process.stdin == null) {\n      throw new Error('No stdin defined for process');\n    }\n    if (delay) {\n      setTimeout(() => this.process.stdin!.end(), delay);\n    } else {\n      this.process.stdin!.end();\n    }\n  }\n\n  public assertDefined(name: 'stdin' | 'stdout' | 'stderr', stream?: Readable | Writable | undefined | null): asserts stream {\n    if (stream == null) {\n      throw new Error(`No ${name} defined for child process`);\n    }\n  }\n\n};"]}

package/lib/process.ts

@@ -0,0 +1,154 @@
+import * as child from 'child_process';
+import { Readable, Writable } from 'stream';
+import * as pty from 'node-pty';
+
+/**
+ * IProcess provides an interface to work with a subprocess.
+ */
+export interface IProcess {
+
+  /**
+   * Register a callback to be invoked when a chunk is written to stdout.
+   */
+  onStdout(callback: (chunk: Buffer) => void): void;
+
+  /**
+   * Register a callback to be invoked when a chunk is written to stderr.
+   */
+  onStderr(callback: (chunk: Buffer) => void): void;
+
+  /**
+   * Register a callback to be invoked when the process exists.
+   */
+  onExit(callback: (exitCode: number) => void): void;
+
+  /**
+   * Register a callback to be invoked if the process failed to start.
+   */
+  onError(callback: (error: Error) => void): void;
+
+  /**
+   * Write the process stdin stream.
+   */
+  writeStdin(data: string): void;
+
+  /**
+   * Singal that no more data will be written to stdin. In non tty process you must
+   * call this method to make sure the process exits.
+   *
+   * @param delay - optional delay in milliseconds before the signal is sent.
+   *
+   */
+  endStdin(delay?: number): void;
+
+};
+
+export class Process {
+
+  /**
+   * Spawn a process with a TTY attached.
+   */
+  public static spawnTTY(command: string, args: string[], options: pty.IPtyForkOptions | pty.IWindowsPtyForkOptions = {}): IProcess {
+
+    const process = pty.spawn(command, args, {
+      name: 'xterm-color',
+      ...options,
+    })
+    return new PtyProcess(process);
+
+  }
+
+  /**
+   * Spawn a process without a forcing a TTY.
+   */
+  public static spawn(command: string, args: string[], options: child.SpawnOptions = {}): IProcess {
+
+    const process = child.spawn(command, args, {
+      shell: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      ...options,
+    });
+    return new NonPtyProcess(process);
+
+  }
+
+}
+
+class PtyProcess implements IProcess {
+
+  public constructor(private readonly process: pty.IPty) {}
+
+  public endStdin(_?: number): void {
+    // not needed because all streams are the same in tty.
+  }
+
+  public onError(_: (error: Error) => void): void {
+    // not needed because the pty.spawn will simply fail in this case.
+  }
+
+  public onStdout(callback: (chunk: Buffer) => void): void {
+    this.process.onData((e) => callback(Buffer.from(e)));
+  }
+
+  public onStderr(callback: (chunk: Buffer) => void): void {
+    // in a pty all streams are the same
+    return this.onStdout(callback);
+  }
+
+  public onExit(callback: (exitCode: number) => void): void {
+    this.process.onExit((e) => { callback(e.exitCode) });
+  }
+
+
+  public writeStdin(data: string): void {
+    // in a pty all streams are the same
+    this.process.write(data)
+  }
+
+};
+
+class NonPtyProcess implements IProcess {
+
+  public constructor(private readonly process: child.ChildProcess) {}
+
+  public onError(callback: (error: Error) => void): void {
+    this.process.once('error', callback);
+  }
+
+  public onStdout(callback: (chunk: Buffer) => void): void {
+    this.assertDefined('stdout', this.process.stdout);
+    this.process.stdout.on('data', callback);
+  }
+
+  public onStderr(callback: (chunk: Buffer) => void): void {
+    this.assertDefined('stderr', this.process.stderr);
+    this.process.stderr.on('data', callback);
+  }
+
+  public onExit(callback: (exitCode: number) => void): void {
+    this.process.on('close', callback);
+  }
+
+  public writeStdin(content: string): void {
+    this.assertDefined('stdin', this.process.stdin);
+    this.process.stdin.write(content);
+  }
+
+  public endStdin(delay?: number): void {
+    if (this.process.stdin == null) {
+      throw new Error('No stdin defined for process');
+    }
+    if (delay) {
+      setTimeout(() => this.process.stdin!.end(), delay);
+    } else {
+      this.process.stdin!.end();
+    }
+  }
+
+  public assertDefined(name: 'stdin' | 'stdout' | 'stderr', stream?: Readable | Writable | undefined | null): asserts stream {
+    if (stream == null) {
+      throw new Error(`No ${name} defined for child process`);
+    }
+  }
+
+};

package/lib/shell.d.ts

@@ -7,6 +7,51 @@ import { TemporaryDirectoryContext } from './with-temporary-directory';
  * Is platform-aware, handles errors nicely.
  */
 export declare function shell(command: string[], options?: ShellOptions): Promise<string>;
+/**
+ * Models a single user interaction with the shell.
+ */
+export interface UserInteraction {
+    /**
+     * The prompt to expect. Regex matched against the last line in
+     * the output before the prompt is displayed.
+     *
+     * Most commonly this would be a simple string to match for inclusion.
+     *
+     * Examples:
+     *
+     * - Process Output: "Hey there! Are you sure?"
+     *   Prompt: /Are you sure?/
+     *   Match (Yes/No): Yes
+     *   Reason: "Hey there! Are you sure?" ~ /Are you sure?/
+     *
+     * - Process Output: "Hey there!\nAre you sure?"
+     *   Prompt: /Are you sure?/
+     *   Match (Yes/No): Yes
+     *   Reason: "Are you sure?" ~ /Are you sure?/
+     *
+     * - Process Output: "Are you sure?\n(remember this is destructive)"
+     *   Prompt: /Are you sure?/
+     *   Match (Yes/No): No
+     *   Reason: "(remember this is destructive)" ≄ /Are you sure?/
+     *
+     * - Process Output: "Are you sure?\n(remember this is destructive)"
+     *   Prompt: /remember this is destructive/
+     *   Match (Yes/No): Yes
+     *   Reason: "(remember this is destructive)" ~ /remember this is destructive/
+     *
+     */
+    readonly prompt: RegExp;
+    /**
+     * The input to provide.
+     */
+    readonly input: string;
+    /**
+     * The string to signal the end of input.
+     *
+     * @default os.EOL
+     */
+    readonly end?: string;
+}
 export interface ShellOptions extends child_process.SpawnOptions {
     /**
      * Properties to add to 'env'
@@ -41,6 +86,12 @@ export interface ShellOptions extends child_process.SpawnOptions {
      * @default always
      */
     readonly show?: 'always' | 'never' | 'error';
+    /**
+     * Provide user interaction to respond to shell prompts.
+     *
+     * Order and count should correspond to the expected prompts issued by the subprocess.
+     */
+    readonly interact?: UserInteraction[];
 }
 export declare class ShellHelper {
     private readonly _cwd;

package/lib/shell.js

@@ -4,16 +4,17 @@ exports.ShellHelper = void 0;
 exports.shell = shell;
 exports.rimraf = rimraf;
 exports.addToShellPath = addToShellPath;
-const child_process = require("child_process");
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
+const process_1 = require("./process");
 /**
  * A shell command that does what you want
  *
  * Is platform-aware, handles errors nicely.
  */
 async function shell(command, options = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     if (options.modEnv && options.env) {
         throw new Error('Use either env or modEnv but not both');
     }
@@ -27,44 +28,68 @@ async function shell(command, options = {}) {
     writeToOutputs(`💻 ${command.join(' ')}\n`);
     const show = (_a = options.show) !== null && _a !== void 0 ? _a : 'always';
     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,
-        // Need this for Windows where we want .cmd and .bat to be found as well.
-        shell: true,
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    const tty = options.interact && options.interact.length > 0;
+    // Coerce to `any` because `ShellOptions` contains custom properties
+    // that don't exist in the underlying interfaces. We could either rebuild each options map,
+    // or just pass through and let the underlying implemenation ignore what it doesn't know about.
+    // We choose the lazy one.
+    const spawnOptions = { ...options, env };
+    const child = tty
+        ? process_1.Process.spawnTTY(command[0], command.slice(1), spawnOptions)
+        : process_1.Process.spawn(command[0], command.slice(1), spawnOptions);
+    // copy because we will be shifting it
+    const remainingInteractions = [...((_c = options.interact) !== null && _c !== void 0 ? _c : [])];
     return new Promise((resolve, reject) => {
         const stdout = new Array();
         const stderr = new Array();
-        child.stdout.on('data', chunk => {
+        const lastLine = new LastLine();
+        child.onStdout(chunk => {
+            var _a;
             if (show === 'always') {
-                writeToOutputs(chunk);
+                writeToOutputs(chunk.toString('utf-8'));
             }
             stdout.push(chunk);
+            lastLine.append(chunk.toString('utf-8'));
+            const interaction = remainingInteractions[0];
+            if (interaction) {
+                if (interaction.prompt.test(lastLine.get())) {
+                    // subprocess expects a user input now
+                    child.writeStdin(interaction.input + ((_a = interaction.end) !== null && _a !== void 0 ? _a : os.EOL));
+                    remainingInteractions.shift();
+                }
+            }
         });
-        child.stderr.on('data', chunk => {
+        child.onStderr(chunk => {
             var _a;
             if (show === 'always') {
-                writeToOutputs(chunk);
+                writeToOutputs(chunk.toString('utf-8'));
             }
             if ((_a = options.captureStderr) !== null && _a !== void 0 ? _a : true) {
                 stderr.push(chunk);
             }
         });
-        child.once('error', reject);
-        child.once('close', code => {
+        child.onError(reject);
+        child.onExit(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();
+            const logAndreject = (error) => {
+                if (show === 'error') {
+                    writeToOutputs(`${out}\n`);
+                }
+                reject(error);
+            };
+            if (remainingInteractions.length !== 0) {
+                // regardless of the exit code, if we didn't consume all expected interactions we probably
+                // did somethiing wrong.
+                logAndreject(new Error(`Expected more user interactions but subprocess exited with ${code}`));
+                return;
+            }
             if (code === 0 || options.allowErrExit) {
                 resolve(out);
             }
             else {
-                if (show === 'error') {
-                    writeToOutputs(`${out}\n`);
-                }
-                reject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));
+                logAndreject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));
             }
         });
     });
@@ -128,4 +153,40 @@ function addToShellPath(x) {
     }
     process.env.PATH = parts.join(':');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell.js","sourceRoot":"","sources":["shell.ts"],"names":[],"mappings":"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","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  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 | undefined>;\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 *\n * Returns `true` if everything got deleted, or `false` if some files could\n * not be deleted due to permissions issues.\n */\nexport function rimraf(fsPath: string): boolean {\n  try {\n    let success = true;\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        success &&= rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n    return success;\n  } catch (e: any) {\n    // Can happen if some files got generated inside a Docker container and are now inadvertently owned by `root`.\n    // We can't ever clean those up anymore, but since it only happens inside GitHub Actions containers we also don't care too much.\n    if (e.code === 'EACCES' || e.code === 'ENOTEMPTY') { return false; }\n\n    // Already gone\n    if (e.code === 'ENOENT') { return true; }\n\n    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"]}
+/**
+ * Accumulate text since the last line break (or beginning of string) it has seen in the chunks.
+ *
+ * Examples:
+ *
+ * - Chunks: ['one\n', 'two\n', three']
+ * - Last Line: 'three'
+ *
+ * - Chunks: ['one', 'two', '\nthree']
+ * - Last Line: 'three'
+ *
+ * - Chunks: ['one', 'two']
+ * - Last Line: 'onetwo'
+ *
+ * - Chunks: ['one', 'two', '\nthree', 'four']
+ * - Last Line: 'threefour'
+ */
+class LastLine {
+    constructor() {
+        this.lastLine = '';
+    }
+    append(chunk) {
+        const lines = chunk.split(os.EOL);
+        if (lines.length === 1) {
+            // chunk doesn't contain a new line so just append
+            this.lastLine += lines[0];
+        }
+        else {
+            // chunk contains multiple lines so just override with the last one
+            this.lastLine = lines[lines.length - 1];
+        }
+    }
+    get() {
+        return this.lastLine;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell.js","sourceRoot":"","sources":["shell.ts"],"names":[],"mappings":";;;AAaA,sBA+FC;AA0HD,wBAwBC;AAED,wCAQC;AAvQD,yBAAyB;AACzB,yBAAyB;AACzB,6BAA6B;AAE7B,uCAAoC;AAGpC;;;;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,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;IAClG,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAE5D,oEAAoE;IACpE,2FAA2F;IAC3F,+FAA+F;IAC/F,0BAA0B;IAC1B,MAAM,YAAY,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,EAAS,CAAC;IAEhD,MAAM,KAAK,GAAG,GAAG;QACf,CAAC,CAAC,iBAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC;QAC9D,CAAC,CAAC,iBAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAA;IAE7D,sCAAsC;IACtC,MAAM,qBAAqB,GAAG,CAAC,GAAG,CAAC,MAAA,OAAO,CAAC,QAAQ,mCAAI,EAAE,CAAC,CAAC,CAAC;IAE5D,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,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;QAEhC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;;YACrB,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAC1C,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAEzC,MAAM,WAAW,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC;YAC7C,IAAI,WAAW,EAAE,CAAC;gBAEhB,IAAI,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC;oBAC5C,sCAAsC;oBACtC,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,MAAA,WAAW,CAAC,GAAG,mCAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;oBAClE,qBAAqB,CAAC,KAAK,EAAE,CAAC;gBAChC,CAAC;YAEH,CAAC;QAEH,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;;YACrB,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAC1C,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,OAAO,CAAC,MAAM,CAAC,CAAC;QAEtB,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAClB,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;YAErF,MAAM,YAAY,GAAG,CAAC,KAAY,EAAE,EAAE;gBACpC,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;oBACrB,cAAc,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;gBAC7B,CAAC;gBACD,MAAM,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC,CAAA;YAED,IAAI,qBAAqB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACvC,0FAA0F;gBAC1F,wBAAwB;gBACxB,YAAY,CAAC,IAAI,KAAK,CAAC,8DAA8D,IAAI,EAAE,CAAC,CAAC,CAAC;gBAC9F,OAAO;YACT,CAAC;YAED,IAAI,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACvC,OAAO,CAAC,GAAG,CAAC,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,YAAY,CAAC,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,4BAA4B,IAAI,GAAG,CAAC,CAAC,CAAC;YACpF,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAkGD,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;;;;;GAKG;AACH,SAAgB,MAAM,CAAC,MAAc;IACnC,IAAI,CAAC;QACH,IAAI,OAAO,GAAG,IAAI,CAAC;QACnB,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,OAAO,KAAP,OAAO,GAAK,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAAC;YAC9C,CAAC;YACD,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;aAAM,CAAC;YACN,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,8GAA8G;QAC9G,gIAAgI;QAChI,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAAC,OAAO,KAAK,CAAC;QAAC,CAAC;QAEpE,eAAe;QACf,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAAC,OAAO,IAAI,CAAC;QAAC,CAAC;QAEzC,MAAM,CAAC,CAAC;IACV,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;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,QAAQ;IAAd;QAEU,aAAQ,GAAW,EAAE,CAAC;IAgBhC,CAAC;IAdQ,MAAM,CAAC,KAAa;QACzB,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,kDAAkD;YAClD,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,CAAC;aAAM,CAAC;YACN,mEAAmE;YACnE,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IAEM,GAAG;QACR,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { TestContext } from './integ-test';\nimport { Process } from './process';\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  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : process.env);\n  const tty = options.interact && options.interact.length > 0;\n\n  // Coerce to `any` because `ShellOptions` contains custom properties\n  // that don't exist in the underlying interfaces. We could either rebuild each options map,\n  // or just pass through and let the underlying implemenation ignore what it doesn't know about.\n  // We choose the lazy one.\n  const spawnOptions = { ...options, env } as any;\n\n  const child = tty\n    ? Process.spawnTTY(command[0], command.slice(1), spawnOptions)\n    : Process.spawn(command[0], command.slice(1), spawnOptions)\n\n  // copy because we will be shifting it\n  const remainingInteractions = [...(options.interact ?? [])];\n\n  return new Promise<string>((resolve, reject) => {\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n\n    const lastLine = new LastLine();\n\n    child.onStdout(chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk.toString('utf-8'));\n      }\n      stdout.push(chunk);\n      lastLine.append(chunk.toString('utf-8'));\n\n      const interaction = remainingInteractions[0];\n      if (interaction) {\n\n        if (interaction.prompt.test(lastLine.get())) {\n          // subprocess expects a user input now\n          child.writeStdin(interaction.input + (interaction.end ?? os.EOL));\n          remainingInteractions.shift();\n        }\n\n      }\n\n    });\n\n    child.onStderr(chunk => {\n      if (show === 'always') {\n        writeToOutputs(chunk.toString('utf-8'));\n      }\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n    });\n\n    child.onError(reject);\n\n    child.onExit(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\n      const logAndreject = (error: Error) => {\n        if (show === 'error') {\n          writeToOutputs(`${out}\\n`);\n        }\n        reject(error);\n      }\n\n      if (remainingInteractions.length !== 0) {\n        // regardless of the exit code, if we didn't consume all expected interactions we probably\n        // did somethiing wrong.\n        logAndreject(new Error(`Expected more user interactions but subprocess exited with ${code}`));\n        return;\n      }\n\n      if (code === 0 || options.allowErrExit) {\n        resolve(out);\n      } else {\n        logAndreject(new Error(`'${command.join(' ')}' exited with error code ${code}.`));\n      }\n    });\n  });\n}\n\n/**\n * Models a single user interaction with the shell.\n */\nexport interface UserInteraction {\n  /**\n   * The prompt to expect. Regex matched against the last line in\n   * the output before the prompt is displayed.\n   *\n   * Most commonly this would be a simple string to match for inclusion.\n   *\n   * Examples:\n   *\n   * - Process Output: \"Hey there! Are you sure?\"\n   *   Prompt: /Are you sure?/\n   *   Match (Yes/No): Yes\n   *   Reason: \"Hey there! Are you sure?\" ~ /Are you sure?/\n   *\n   * - Process Output: \"Hey there!\\nAre you sure?\"\n   *   Prompt: /Are you sure?/\n   *   Match (Yes/No): Yes\n   *   Reason: \"Are you sure?\" ~ /Are you sure?/\n   *\n   * - Process Output: \"Are you sure?\\n(remember this is destructive)\"\n   *   Prompt: /Are you sure?/\n   *   Match (Yes/No): No\n   *   Reason: \"(remember this is destructive)\" ≄ /Are you sure?/\n   *\n   * - Process Output: \"Are you sure?\\n(remember this is destructive)\"\n   *   Prompt: /remember this is destructive/\n   *   Match (Yes/No): Yes\n   *   Reason: \"(remember this is destructive)\" ~ /remember this is destructive/\n   *\n   */\n  readonly prompt: RegExp;\n  /**\n   * The input to provide.\n   */\n  readonly input: string;\n\n  /**\n   * The string to signal the end of input.\n   *\n   * @default os.EOL\n   */\n  readonly end?: string;\n}\n\nexport interface ShellOptions extends child_process.SpawnOptions {\n  /**\n   * Properties to add to 'env'\n   */\n  readonly modEnv?: Record<string, string | undefined>;\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  /**\n   * Provide user interaction to respond to shell prompts.\n   *\n   * Order and count should correspond to the expected prompts issued by the subprocess.\n   */\n  readonly interact?: UserInteraction[];\n\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 *\n * Returns `true` if everything got deleted, or `false` if some files could\n * not be deleted due to permissions issues.\n */\nexport function rimraf(fsPath: string): boolean {\n  try {\n    let success = true;\n    const isDir = fs.lstatSync(fsPath).isDirectory();\n\n    if (isDir) {\n      for (const file of fs.readdirSync(fsPath)) {\n        success &&= rimraf(path.join(fsPath, file));\n      }\n      fs.rmdirSync(fsPath);\n    } else {\n      fs.unlinkSync(fsPath);\n    }\n    return success;\n  } catch (e: any) {\n    // Can happen if some files got generated inside a Docker container and are now inadvertently owned by `root`.\n    // We can't ever clean those up anymore, but since it only happens inside GitHub Actions containers we also don't care too much.\n    if (e.code === 'EACCES' || e.code === 'ENOTEMPTY') { return false; }\n\n    // Already gone\n    if (e.code === 'ENOENT') { return true; }\n\n    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\n/**\n * Accumulate text since the last line break (or beginning of string) it has seen in the chunks.\n *\n * Examples:\n *\n * - Chunks: ['one\\n', 'two\\n', three']\n * - Last Line: 'three'\n *\n * - Chunks: ['one', 'two', '\\nthree']\n * - Last Line: 'three'\n *\n * - Chunks: ['one', 'two']\n * - Last Line: 'onetwo'\n *\n * - Chunks: ['one', 'two', '\\nthree', 'four']\n * - Last Line: 'threefour'\n */\nclass LastLine {\n\n  private lastLine: string = '';\n\n  public append(chunk: string): void {\n    const lines = chunk.split(os.EOL);\n    if (lines.length === 1) {\n      // chunk doesn't contain a new line so just append\n      this.lastLine += lines[0];\n    } else {\n      // chunk contains multiple lines so just override with the last one\n      this.lastLine = lines[lines.length - 1];\n    }\n  }\n\n  public get(): string {\n    return this.lastLine;\n  }\n}"]}