@aws-cdk-testing/cli-integ 0.0.0

package/lib/staging/npm.ts

@@ -0,0 +1,62 @@
+/* eslint-disable no-console */
+import * as path from 'path';
+import { LoginInformation } from './codeartifact';
+import { parallelShell } from './parallel-shell';
+import { UsageDir } from './usage-dir';
+import { updateIniKey, loadLines, writeLines } from '../files';
+import { shell } from '../shell';
+
+export async function npmLogin(login: LoginInformation, usageDir: UsageDir) {
+  // Creating an ~/.npmrc that references an envvar is what you're supposed to do. (https://docs.npmjs.com/private-modules/ci-server-config)
+  await writeNpmLoginToken(usageDir, login.npmEndpoint, '${NPM_TOKEN}');
+
+  // Add variables to env file
+  await usageDir.addToEnv(npmEnv(usageDir, login));
+}
+
+function npmEnv(usageDir: UsageDir, login: LoginInformation) {
+  return {
+    npm_config_userconfig: path.join(usageDir.directory, '.npmrc'),
+    npm_config_registry: login.npmEndpoint,
+    npm_config_always_auth: 'true', // Necessary for NPM 6, otherwise it will sometimes not pass the token
+    NPM_TOKEN: login.authToken,
+  };
+}
+
+export async function uploadNpmPackages(packages: string[], login: LoginInformation, usageDir: UsageDir) {
+  await parallelShell(packages, async (pkg, output) => {
+    console.log(`⏳ ${pkg}`);
+
+    // path.resolve() is required -- if the filename ends up looking like `js/bla.tgz` then NPM thinks it's a short form GitHub name.
+    await shell(['node', require.resolve('npm'), 'publish', path.resolve(pkg)], {
+      modEnv: npmEnv(usageDir, login),
+      show: 'error',
+      outputs: [output],
+    });
+
+    console.log(`✅ ${pkg}`);
+  }, (pkg, output) => {
+    if (output.toString().includes('code EPUBLISHCONFLICT')) {
+      console.log(`❌ ${pkg}: already exists. Skipped.`);
+      return 'skip';
+    }
+    if (output.toString().includes('code EPRIVATE')) {
+      console.log(`❌ ${pkg}: is private. Skipped.`);
+      return 'skip';
+    }
+    return 'fail';
+  });
+}
+
+async function writeNpmLoginToken(usageDir: UsageDir, endpoint: string, token: string) {
+  const rcFile = path.join(usageDir.directory, '.npmrc');
+  const lines = await loadLines(rcFile);
+
+  const key = `${endpoint.replace(/^https:/, '')}:_authToken`;
+  updateIniKey(lines, key, token);
+
+  await writeLines(rcFile, lines);
+  return rcFile;
+}
+
+// Environment variable, .npmrc in same directory as package.json or in home dir

package/lib/staging/nuget.d.ts

@@ -0,0 +1,4 @@
+import { LoginInformation } from './codeartifact';
+import { UsageDir } from './usage-dir';
+export declare function nugetLogin(login: LoginInformation, usageDir: UsageDir): Promise<void>;
+export declare function uploadDotnetPackages(packages: string[], usageDir: UsageDir): Promise<void>;

package/lib/staging/nuget.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nugetLogin = nugetLogin;
+exports.uploadDotnetPackages = uploadDotnetPackages;
+const parallel_shell_1 = require("./parallel-shell");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+async function nugetLogin(login, usageDir) {
+    // NuGet.Config MUST live in the current directory or in the home directory, and there is no environment
+    // variable to configure its location.
+    await writeNuGetConfigFile(usageDir.cwdFile('NuGet.Config'), login);
+}
+async function uploadDotnetPackages(packages, usageDir) {
+    await usageDir.copyCwdFileHere('NuGet.Config');
+    await (0, parallel_shell_1.parallelShell)(packages, async (pkg, output) => {
+        console.log(`⏳ ${pkg}`);
+        await (0, shell_1.shell)(['dotnet', 'nuget', 'push',
+            pkg,
+            '--source', 'CodeArtifact',
+            '--no-symbols',
+            '--force-english-output',
+            '--disable-buffering',
+            '--timeout', '600',
+            '--skip-duplicate'], {
+            outputs: [output],
+        });
+        console.log(`✅ ${pkg}`);
+    }, (pkg, output) => {
+        if (output.toString().includes('Conflict')) {
+            console.log(`❌ ${pkg}: already exists. Skipped.`);
+            return 'skip';
+        }
+        if (output.includes('System.Threading.AbandonedMutexException')) {
+            console.log(`♻️ ${pkg}: AbandonedMutexException. Probably a sign of throttling, retrying.`);
+            return 'retry';
+        }
+        if (output.includes('Too Many Requests')) {
+            console.log(`♻️ ${pkg}: Too many requests. Retrying.`);
+            return 'retry';
+        }
+        if (output.includes('System.IO.IOException: The system cannot open the device or file specified.')) {
+            console.log(`♻️ ${pkg}: Some error that we've seen before as a result of throttling. Retrying.`);
+            return 'retry';
+        }
+        return 'fail';
+    });
+}
+async function writeNuGetConfigFile(filename, login) {
+    // `dotnet nuget push` has an `--api-key` parameter, but CodeArtifact
+    // does not support that. We must authenticate with Basic auth.
+    await (0, files_1.writeFile)(filename, `<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+    <add key="CodeArtifact" value="${login.nugetEndpoint}v3/index.json" />
+  </packageSources>
+  <activePackageSource>
+    <add key="CodeArtifact" value="${login.nugetEndpoint}v3/index.json" />
+  </activePackageSource>
+  <packageSourceCredentials>
+    <CodeArtifact>
+        <add key="Username" value="aws" />
+        <add key="ClearTextPassword" value="${login.authToken}" />
+      </CodeArtifact>
+  </packageSourceCredentials>
+</configuration>`);
+}
+// NuGet.Config in current directory
+//# sourceMappingURL=data:application/json;base64,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

package/lib/staging/nuget.ts

@@ -0,0 +1,75 @@
+/* eslint-disable no-console */
+import { LoginInformation } from './codeartifact';
+import { parallelShell } from './parallel-shell';
+import { UsageDir } from './usage-dir';
+import { writeFile } from '../files';
+import { shell } from '../shell';
+
+export async function nugetLogin(login: LoginInformation, usageDir: UsageDir) {
+  // NuGet.Config MUST live in the current directory or in the home directory, and there is no environment
+  // variable to configure its location.
+  await writeNuGetConfigFile(usageDir.cwdFile('NuGet.Config'), login);
+}
+
+export async function uploadDotnetPackages(packages: string[], usageDir: UsageDir) {
+  await usageDir.copyCwdFileHere('NuGet.Config');
+
+  await parallelShell(packages, async (pkg, output) => {
+    console.log(`⏳ ${pkg}`);
+
+    await shell(['dotnet', 'nuget', 'push',
+      pkg,
+      '--source', 'CodeArtifact',
+      '--no-symbols',
+      '--force-english-output',
+      '--disable-buffering',
+      '--timeout', '600',
+      '--skip-duplicate'], {
+      outputs: [output],
+    });
+
+    console.log(`✅ ${pkg}`);
+  },
+  (pkg, output) => {
+    if (output.toString().includes('Conflict')) {
+      console.log(`❌ ${pkg}: already exists. Skipped.`);
+      return 'skip';
+    }
+    if (output.includes('System.Threading.AbandonedMutexException')) {
+      console.log(`♻️ ${pkg}: AbandonedMutexException. Probably a sign of throttling, retrying.`);
+      return 'retry';
+    }
+    if (output.includes('Too Many Requests')) {
+      console.log(`♻️ ${pkg}: Too many requests. Retrying.`);
+      return 'retry';
+    }
+    if (output.includes('System.IO.IOException: The system cannot open the device or file specified.')) {
+      console.log(`♻️ ${pkg}: Some error that we've seen before as a result of throttling. Retrying.`);
+      return 'retry';
+    }
+    return 'fail';
+  });
+}
+
+async function writeNuGetConfigFile(filename: string, login: LoginInformation) {
+  // `dotnet nuget push` has an `--api-key` parameter, but CodeArtifact
+  // does not support that. We must authenticate with Basic auth.
+  await writeFile(filename, `<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+    <add key="CodeArtifact" value="${login.nugetEndpoint}v3/index.json" />
+  </packageSources>
+  <activePackageSource>
+    <add key="CodeArtifact" value="${login.nugetEndpoint}v3/index.json" />
+  </activePackageSource>
+  <packageSourceCredentials>
+    <CodeArtifact>
+        <add key="Username" value="aws" />
+        <add key="ClearTextPassword" value="${login.authToken}" />
+      </CodeArtifact>
+  </packageSourceCredentials>
+</configuration>`);
+}
+
+// NuGet.Config in current directory

package/lib/staging/parallel-shell.d.ts

@@ -0,0 +1,5 @@
+export type ErrorResponse = 'fail' | 'skip' | 'retry';
+/**
+ * Run a function in parallel with cached output
+ */
+export declare function parallelShell<A>(inputs: A[], block: (x: A, output: NodeJS.WritableStream) => Promise<void>, swallowError?: (x: A, output: string) => ErrorResponse): Promise<void>;

package/lib/staging/parallel-shell.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelShell = parallelShell;
+const p_queue_1 = require("p-queue");
+const aws_1 = require("../aws");
+const corking_1 = require("../corking");
+/**
+ * Run a function in parallel with cached output
+ */
+async function parallelShell(inputs, block, swallowError) {
+    // Limit to 10 for now, too many instances of Maven exhaust the CodeBuild instance memory
+    const q = new p_queue_1.default({ concurrency: Number(process.env.CONCURRENCY) || 10 });
+    await q.addAll(inputs.map(input => async () => {
+        let attempts = 10;
+        let sleepMs = 500;
+        while (true) {
+            const output = new corking_1.MemoryStream();
+            try {
+                await block(input, output);
+                return;
+            }
+            catch (e) {
+                switch (swallowError === null || swallowError === void 0 ? void 0 : swallowError(input, output.toString())) {
+                    case 'skip':
+                        return;
+                    case 'retry':
+                        if (--attempts > 0) {
+                            await (0, aws_1.sleep)(Math.floor(Math.random() * sleepMs));
+                            sleepMs *= 2;
+                            continue;
+                        }
+                        break;
+                    case 'fail':
+                    case undefined:
+                        break;
+                }
+                // eslint-disable-next-line no-console
+                console.error(output.toString());
+                throw e;
+            }
+        }
+    }));
+    await q.onEmpty();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/staging/parallel-shell.ts

@@ -0,0 +1,51 @@
+import PQueue from 'p-queue';
+import { sleep } from '../aws';
+import { MemoryStream } from '../corking';
+
+export type ErrorResponse = 'fail' | 'skip' | 'retry';
+
+/**
+ * Run a function in parallel with cached output
+ */
+export async function parallelShell<A>(
+  inputs: A[],
+  block: (x: A, output: NodeJS.WritableStream) => Promise<void>,
+  swallowError?: (x: A, output: string) => ErrorResponse,
+) {
+  // Limit to 10 for now, too many instances of Maven exhaust the CodeBuild instance memory
+  const q = new PQueue({ concurrency: Number(process.env.CONCURRENCY) || 10 });
+  await q.addAll(inputs.map(input => async () => {
+    let attempts = 10;
+    let sleepMs = 500;
+    while (true) {
+      const output = new MemoryStream();
+      try {
+        await block(input, output);
+        return;
+      } catch (e) {
+        switch (swallowError?.(input, output.toString())) {
+          case 'skip':
+            return;
+
+          case 'retry':
+            if (--attempts > 0) {
+              await sleep(Math.floor(Math.random() * sleepMs));
+              sleepMs *= 2;
+              continue;
+            }
+            break;
+
+          case 'fail':
+          case undefined:
+            break;
+        }
+
+        // eslint-disable-next-line no-console
+        console.error(output.toString());
+        throw e;
+      }
+    }
+  }));
+
+  await q.onEmpty();
+}

package/lib/staging/pypi.d.ts

@@ -0,0 +1,4 @@
+import { LoginInformation } from './codeartifact';
+import { UsageDir } from './usage-dir';
+export declare function pypiLogin(login: LoginInformation, usageDir: UsageDir): Promise<void>;
+export declare function uploadPythonPackages(packages: string[], login: LoginInformation): Promise<void>;

package/lib/staging/pypi.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pypiLogin = pypiLogin;
+exports.uploadPythonPackages = uploadPythonPackages;
+/* eslint-disable no-console */
+const path = require("path");
+const parallel_shell_1 = require("./parallel-shell");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+async function pypiLogin(login, usageDir) {
+    // Write pip config file and set environment var
+    await (0, files_1.writeFile)(path.join(usageDir.directory, 'pip.conf'), [
+        '[global]',
+        `index-url = https://aws:${login.authToken}@${login.pypiEndpoint.replace(/^https:\/\//, '')}simple/`,
+    ].join('\n'));
+    await usageDir.addToEnv({
+        PIP_CONFIG_FILE: `${usageDir.directory}/pip.conf`,
+    });
+}
+async function uploadPythonPackages(packages, login) {
+    await (0, shell_1.shell)(['pip', 'install', 'twine'], { show: 'error' });
+    // Even though twine supports uploading all packages in one go, we have to upload them
+    // individually since CodeArtifact does not support Twine's `--skip-existing`. Fun beans.
+    await (0, parallel_shell_1.parallelShell)(packages, async (pkg, output) => {
+        console.log(`⏳ ${pkg}`);
+        await (0, shell_1.shell)(['twine', 'upload', '--verbose', pkg], {
+            modEnv: {
+                TWINE_USERNAME: 'aws',
+                TWINE_PASSWORD: login.authToken,
+                TWINE_REPOSITORY_URL: login.pypiEndpoint,
+            },
+            show: 'error',
+            outputs: [output],
+        });
+        console.log(`✅ ${pkg}`);
+    }, (pkg, output) => {
+        if (output.toString().includes('This package is configured to block new versions') || output.toString().includes('409 Conflict')) {
+            console.log(`❌ ${pkg}: already exists. Skipped.`);
+            return 'skip';
+        }
+        if (output.includes('429 Too Many Requests ')) {
+            console.log(`♻️ ${pkg}: 429 Too Many Requests. Retrying.`);
+            return 'retry';
+        }
+        return 'fail';
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/staging/pypi.ts

@@ -0,0 +1,50 @@
+/* eslint-disable no-console */
+import * as path from 'path';
+import { LoginInformation } from './codeartifact';
+import { parallelShell } from './parallel-shell';
+import { UsageDir } from './usage-dir';
+import { writeFile } from '../files';
+import { shell } from '../shell';
+
+export async function pypiLogin(login: LoginInformation, usageDir: UsageDir) {
+  // Write pip config file and set environment var
+  await writeFile(path.join(usageDir.directory, 'pip.conf'), [
+    '[global]',
+    `index-url = https://aws:${login.authToken}@${login.pypiEndpoint.replace(/^https:\/\//, '')}simple/`,
+  ].join('\n'));
+  await usageDir.addToEnv({
+    PIP_CONFIG_FILE: `${usageDir.directory}/pip.conf`,
+  });
+}
+
+export async function uploadPythonPackages(packages: string[], login: LoginInformation) {
+  await shell(['pip', 'install', 'twine'], { show: 'error' });
+
+  // Even though twine supports uploading all packages in one go, we have to upload them
+  // individually since CodeArtifact does not support Twine's `--skip-existing`. Fun beans.
+  await parallelShell(packages, async (pkg, output) => {
+    console.log(`⏳ ${pkg}`);
+
+    await shell(['twine', 'upload', '--verbose', pkg], {
+      modEnv: {
+        TWINE_USERNAME: 'aws',
+        TWINE_PASSWORD: login.authToken,
+        TWINE_REPOSITORY_URL: login.pypiEndpoint,
+      },
+      show: 'error',
+      outputs: [output],
+    });
+
+    console.log(`✅ ${pkg}`);
+  }, (pkg, output) => {
+    if (output.toString().includes('This package is configured to block new versions') || output.toString().includes('409 Conflict')) {
+      console.log(`❌ ${pkg}: already exists. Skipped.`);
+      return 'skip';
+    }
+    if (output.includes('429 Too Many Requests ')) {
+      console.log(`♻️ ${pkg}: 429 Too Many Requests. Retrying.`);
+      return 'retry';
+    }
+    return 'fail';
+  });
+}

package/lib/staging/usage-dir.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_USAGE_DIR: string;
+/**
+ * The usage directory is where we write per-session config files to access the CodeArtifact repository.
+ *
+ * Some config files may be written in a system-global location, but they will not be active unless the
+ * contents of this directory have been sourced/copied into the current terminal.
+ *
+ * CONTRACT
+ *
+ * There are two special entries:
+ *
+ * - `env`, a file with `key=value` entries for environment variables to  set.
+ * - `cwd/`, a directory with files that need to be copied into the current directory before each command.
+ *
+ * Other than these, code may write tempfiles to this directory if it wants, but there is no meaning
+ * implied for other files.
+ */
+export declare class UsageDir {
+    readonly directory: string;
+    static default(): UsageDir;
+    readonly envFile: string;
+    readonly cwdDir: string;
+    private constructor();
+    clean(): Promise<void>;
+    addToEnv(settings: Record<string, string>): Promise<void>;
+    currentEnv(): Promise<Record<string, string>>;
+    cwdFile(filename: string): string;
+    activateInCurrentProcess(): Promise<void>;
+    copyCwdFileHere(...filenames: string[]): Promise<void>;
+    advertise(): void;
+}

package/lib/staging/usage-dir.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageDir = exports.DEFAULT_USAGE_DIR = void 0;
+const path = require("path");
+const fs = require("fs-extra");
+const files_1 = require("../files");
+exports.DEFAULT_USAGE_DIR = path.join((0, files_1.homeDir)(), '.codeartifact/usage');
+/**
+ * The usage directory is where we write per-session config files to access the CodeArtifact repository.
+ *
+ * Some config files may be written in a system-global location, but they will not be active unless the
+ * contents of this directory have been sourced/copied into the current terminal.
+ *
+ * CONTRACT
+ *
+ * There are two special entries:
+ *
+ * - `env`, a file with `key=value` entries for environment variables to  set.
+ * - `cwd/`, a directory with files that need to be copied into the current directory before each command.
+ *
+ * Other than these, code may write tempfiles to this directory if it wants, but there is no meaning
+ * implied for other files.
+ */
+class UsageDir {
+    static default() {
+        return new UsageDir(exports.DEFAULT_USAGE_DIR);
+    }
+    constructor(directory) {
+        this.directory = directory;
+        this.envFile = path.join(this.directory, 'env');
+        this.cwdDir = path.join(this.directory, 'cwd');
+    }
+    async clean() {
+        await fs.rm(this.directory, { recursive: true, force: true });
+        await fs.mkdirp(path.join(this.directory, 'cwd'));
+        await fs.writeFile(path.join(this.directory, 'env'), '', { encoding: 'utf-8' });
+        await this.addToEnv({
+            CWD_FILES_DIR: path.join(this.directory, 'cwd'),
+        });
+        // Write a bash helper to load these settings
+        await fs.writeFile(path.join(this.directory, 'activate.bash'), [
+            `while read -u10 line; do [[ -z $line ]] || export "$line"; done 10<${this.directory}/env`,
+            'cp -R $CWD_FILES_DIR/ .', // Copy files from directory even if it is empty
+        ].join('\n'), { encoding: 'utf-8' });
+    }
+    async addToEnv(settings) {
+        const lines = await (0, files_1.loadLines)(this.envFile);
+        for (const [k, v] of Object.entries(settings)) {
+            (0, files_1.updateIniKey)(lines, k, v);
+        }
+        await (0, files_1.writeLines)(this.envFile, lines);
+    }
+    async currentEnv() {
+        const lines = await (0, files_1.loadLines)(this.envFile);
+        const splitter = /^([a-zA-Z0-9_-]+)\s*=\s*(.*)$/;
+        const ret = {};
+        for (const line of lines) {
+            const m = line.match(splitter);
+            if (m) {
+                ret[m[1]] = m[2];
+            }
+        }
+        return ret;
+    }
+    cwdFile(filename) {
+        return path.join(this.cwdDir, filename);
+    }
+    async activateInCurrentProcess() {
+        for (const [k, v] of Object.entries(await this.currentEnv())) {
+            process.env[k] = v;
+        }
+        await (0, files_1.copyDirectoryContents)(this.cwdDir, '.');
+    }
+    async copyCwdFileHere(...filenames) {
+        for (const file of filenames) {
+            await fs.copyFile(path.join(this.cwdDir, file), file);
+        }
+    }
+    advertise() {
+        // eslint-disable-next-line no-console
+        console.log('To activate these settings in the current terminal:');
+        // eslint-disable-next-line no-console
+        console.log(`    source ${this.directory}/activate.bash`);
+    }
+}
+exports.UsageDir = UsageDir;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"usage-dir.js","sourceRoot":"","sources":["usage-dir.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { copyDirectoryContents, homeDir, loadLines, updateIniKey, writeLines } from '../files';\n\nexport const DEFAULT_USAGE_DIR = path.join(homeDir(), '.codeartifact/usage');\n\n/**\n * The usage directory is where we write per-session config files to access the CodeArtifact repository.\n *\n * Some config files may be written in a system-global location, but they will not be active unless the\n * contents of this directory have been sourced/copied into the current terminal.\n *\n * CONTRACT\n *\n * There are two special entries:\n *\n * - `env`, a file with `key=value` entries for environment variables to  set.\n * - `cwd/`, a directory with files that need to be copied into the current directory before each command.\n *\n * Other than these, code may write tempfiles to this directory if it wants, but there is no meaning\n * implied for other files.\n */\nexport class UsageDir {\n  public static default() {\n    return new UsageDir(DEFAULT_USAGE_DIR);\n  }\n\n  public readonly envFile: string;\n  public readonly cwdDir: string;\n\n  private constructor(public readonly directory: string) {\n    this.envFile = path.join(this.directory, 'env');\n    this.cwdDir = path.join(this.directory, 'cwd');\n  }\n\n  public async clean() {\n    await fs.rm(this.directory, { recursive: true, force: true });\n    await fs.mkdirp(path.join(this.directory, 'cwd'));\n    await fs.writeFile(path.join(this.directory, 'env'), '', { encoding: 'utf-8' });\n\n    await this.addToEnv({\n      CWD_FILES_DIR: path.join(this.directory, 'cwd'),\n    });\n\n    // Write a bash helper to load these settings\n    await fs.writeFile(path.join(this.directory, 'activate.bash'), [\n      `while read -u10 line; do [[ -z $line ]] || export \"$line\"; done 10<${this.directory}/env`,\n      'cp -R $CWD_FILES_DIR/ .', // Copy files from directory even if it is empty\n    ].join('\\n'), { encoding: 'utf-8' });\n  }\n\n  public async addToEnv(settings: Record<string, string>) {\n    const lines = await loadLines(this.envFile);\n    for (const [k, v] of Object.entries(settings)) {\n      updateIniKey(lines, k, v);\n    }\n    await writeLines(this.envFile, lines);\n  }\n\n  public async currentEnv(): Promise<Record<string, string>> {\n    const lines = await loadLines(this.envFile);\n\n    const splitter = /^([a-zA-Z0-9_-]+)\\s*=\\s*(.*)$/;\n\n    const ret: Record<string, string> = {};\n    for (const line of lines) {\n      const m = line.match(splitter);\n      if (m) {\n        ret[m[1]] = m[2];\n      }\n    }\n    return ret;\n  }\n\n  public cwdFile(filename: string) {\n    return path.join(this.cwdDir, filename);\n  }\n\n  public async activateInCurrentProcess() {\n    for (const [k, v] of Object.entries(await this.currentEnv())) {\n      process.env[k] = v;\n    }\n\n    await copyDirectoryContents(this.cwdDir, '.');\n  }\n\n  public async copyCwdFileHere(...filenames: string[]) {\n    for (const file of filenames) {\n      await fs.copyFile(path.join(this.cwdDir, file), file);\n    }\n  }\n\n  public advertise() {\n    // eslint-disable-next-line no-console\n    console.log('To activate these settings in the current terminal:');\n    // eslint-disable-next-line no-console\n    console.log(`    source ${this.directory}/activate.bash`);\n  }\n}\n"]}