@laurence79/wireit 0.14.13-shared-cache.0

package/lib/cli-options.js

@@ -0,0 +1,495 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as os from 'os';
+import * as pathlib from 'path';
+import { SimpleLogger } from './logging/simple-logger.js';
+import { Console } from './logging/logger.js';
+import { MetricsLogger } from './logging/metrics-logger.js';
+import { QuietCiLogger, QuietLogger } from './logging/quiet-logger.js';
+import * as fs from './util/fs.js';
+import { unreachable } from './util/unreachable.js';
+export const packageDir = await (async () => {
+    // Recent versions of npm, and node --run, set environment variables to tell
+    // us the current package.json.
+    const packageJsonPath = process.env.npm_package_json ?? process.env.NODE_RUN_PACKAGE_JSON_PATH;
+    if (packageJsonPath) {
+        return pathlib.dirname(packageJsonPath);
+    }
+    // Older versions of npm, as well as yarn and pnpm, don't set this variable,
+    // so we have to find the nearest package.json by walking up the filesystem.
+    let maybePackageDir = process.cwd();
+    while (true) {
+        try {
+            await fs.stat(pathlib.join(maybePackageDir, 'package.json'));
+            return maybePackageDir;
+        }
+        catch (error) {
+            const { code } = error;
+            if (code !== 'ENOENT') {
+                throw code;
+            }
+        }
+        const parent = pathlib.dirname(maybePackageDir);
+        if (parent === maybePackageDir) {
+            // Reached the root of the filesystem, no package.json.
+            return undefined;
+        }
+        maybePackageDir = parent;
+    }
+})();
+export const getOptions = async () => {
+    // This environment variable is set by npm, yarn, and pnpm, and tells us which
+    // script is running.
+    const scriptName = process.env.npm_lifecycle_event ?? process.env['NODE_RUN_SCRIPT_NAME'];
+    // We need to handle "npx wireit" as a special case, because it sets
+    // "npm_lifecycle_event" to "npx". The "npm_execpath" will be "npx-cli.js",
+    // though, so we use that combination to detect this special case.
+    const launchedWithNpx = scriptName === 'npx' && process.env.npm_command === 'exec';
+    if (!packageDir || !scriptName || launchedWithNpx) {
+        const detail = [];
+        if (!packageDir) {
+            detail.push('Wireit could not find a package.json.');
+        }
+        if (!scriptName) {
+            detail.push('Wireit could not identify the script to run.');
+        }
+        if (launchedWithNpx) {
+            detail.push('Launching Wireit with npx is not supported.');
+        }
+        return {
+            ok: false,
+            error: {
+                type: 'failure',
+                reason: 'launched-incorrectly',
+                script: { packageDir: packageDir ?? process.cwd() },
+                detail: detail.join(' '),
+            },
+        };
+    }
+    const script = { packageDir, name: scriptName };
+    const numWorkersResult = (() => {
+        const workerString = process.env['WIREIT_PARALLEL'] ?? '';
+        // Many scripts will be IO blocked rather than CPU blocked, so running
+        // multiple scripts per CPU will help keep things moving.
+        const defaultValue = os.cpus().length * 2;
+        if (workerString.match(/^infinity$/i)) {
+            return { ok: true, value: Infinity };
+        }
+        if (workerString == null || workerString === '') {
+            return { ok: true, value: defaultValue };
+        }
+        const parsedInt = parseInt(workerString, 10);
+        if (Number.isNaN(parsedInt) || parsedInt <= 0) {
+            return {
+                ok: false,
+                error: {
+                    reason: 'invalid-usage',
+                    message: `Expected the WIREIT_PARALLEL env variable to be ` +
+                        `a positive integer, got ${JSON.stringify(workerString)}`,
+                    script,
+                    type: 'failure',
+                },
+            };
+        }
+        return { ok: true, value: parsedInt };
+    })();
+    if (!numWorkersResult.ok) {
+        return numWorkersResult;
+    }
+    const cacheResult = (() => {
+        // All shared-cache config is namespaced WIREIT_CACHE_SHARED_* so it can't be
+        // read as applying to other backends.
+        const sharedDirRaw = process.env['WIREIT_CACHE_SHARED_DIR'];
+        const sharedReadonlyRaw = process.env['WIREIT_CACHE_SHARED_READONLY'];
+        const sharedVarsSet = sharedDirRaw !== undefined || sharedReadonlyRaw !== undefined;
+        const str = process.env['WIREIT_CACHE'];
+        let mode;
+        if (str === undefined) {
+            // The CI variable is a convention that is automatically set by GitHub
+            // Actions [0], Travis [1], and other CI (continuous integration)
+            // providers.
+            //
+            // [0] https://docs.github.com/en/actions/learn-github-actions/environment-variables#default-environment-variables
+            // [1] https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
+            //
+            // If we're on CI, we don't want "local" caching, because anything we
+            // store locally will be lost when the VM shuts down.
+            //
+            // We also don't want "github", because (even if we also detected that
+            // we're specifically on GitHub) we should be cautious about using up
+            // storage quota, and instead require opt-in via WIREIT_CACHE=github.
+            const ci = process.env['CI'] === 'true';
+            mode = ci ? 'none' : 'local';
+        }
+        else if (str === 'local' ||
+            str === 'github' ||
+            str === 'none' ||
+            str === 'shared') {
+            mode = str;
+        }
+        else {
+            return {
+                ok: false,
+                error: {
+                    reason: 'invalid-usage',
+                    message: `Expected the WIREIT_CACHE env variable to be ` +
+                        `"local", "github", "shared", or "none", got ${JSON.stringify(str)}`,
+                    script,
+                    type: 'failure',
+                },
+            };
+        }
+        if (mode !== 'shared') {
+            // A WIREIT_CACHE_SHARED_* variable set while the shared cache isn't
+            // selected is unambiguous misuse (the namespaced name makes that clear),
+            // so we error rather than silently ignoring it.
+            if (sharedVarsSet) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: 'invalid-usage',
+                        message: `The WIREIT_CACHE_SHARED_* environment variables only apply ` +
+                            `when WIREIT_CACHE=shared, but WIREIT_CACHE is ${str === undefined ? 'unset' : JSON.stringify(str)}.`,
+                        script,
+                        type: 'failure',
+                    },
+                };
+            }
+            return { ok: true, value: { mode } };
+        }
+        let readonly = false;
+        if (sharedReadonlyRaw !== undefined) {
+            // Accept exactly "true"/"false"; error on anything else.
+            if (sharedReadonlyRaw === 'true') {
+                readonly = true;
+            }
+            else if (sharedReadonlyRaw === 'false') {
+                readonly = false;
+            }
+            else {
+                return {
+                    ok: false,
+                    error: {
+                        reason: 'invalid-usage',
+                        message: `Expected the WIREIT_CACHE_SHARED_READONLY env variable to be ` +
+                            `"true" or "false", got ${JSON.stringify(sharedReadonlyRaw)}`,
+                        script,
+                        type: 'failure',
+                    },
+                };
+            }
+        }
+        const dir = sharedDirRaw !== undefined && sharedDirRaw !== ''
+            ? sharedDirRaw
+            : pathlib.join(os.homedir(), '.wireit', 'cache');
+        return { ok: true, value: { mode, shared: { dir, readonly } } };
+    })();
+    if (!cacheResult.ok) {
+        return cacheResult;
+    }
+    const failureModeResult = (() => {
+        const str = process.env['WIREIT_FAILURES'];
+        if (!str) {
+            return { ok: true, value: 'no-new' };
+        }
+        if (str === 'no-new' || str === 'continue' || str === 'kill') {
+            return { ok: true, value: str };
+        }
+        return {
+            ok: false,
+            error: {
+                reason: 'invalid-usage',
+                message: `Expected the WIREIT_FAILURES env variable to be ` +
+                    `"no-new", "continue", or "kill", got ${JSON.stringify(str)}`,
+                script,
+                type: 'failure',
+            },
+        };
+    })();
+    if (!failureModeResult.ok) {
+        return failureModeResult;
+    }
+    const agent = getNpmUserAgent();
+    const console = new Console(process.stdout, process.stderr);
+    const packageRoot = packageDir ?? process.cwd();
+    const loggerResult = (() => {
+        const str = process.env['WIREIT_LOGGER'];
+        if (!str) {
+            if (process.env.CI || !process.stdout.isTTY) {
+                return { ok: true, value: new QuietCiLogger(packageRoot, console) };
+            }
+            return { ok: true, value: new QuietLogger(packageRoot, console) };
+        }
+        if (str === 'quiet') {
+            return { ok: true, value: new QuietLogger(packageRoot, console) };
+        }
+        if (str === 'quiet-ci') {
+            return { ok: true, value: new QuietCiLogger(packageRoot, console) };
+        }
+        if (str === 'simple') {
+            return { ok: true, value: new SimpleLogger(packageRoot, console) };
+        }
+        if (str === 'metrics') {
+            return { ok: true, value: new MetricsLogger(packageRoot, console) };
+        }
+        return {
+            ok: false,
+            error: {
+                reason: 'invalid-usage',
+                message: `Expected the WIREIT_LOGGER env variable to be ` +
+                    `"quiet", "simple", or "metrics", got ${JSON.stringify(str)}`,
+                script,
+                type: 'failure',
+            },
+        };
+    })();
+    if (!loggerResult.ok) {
+        return loggerResult;
+    }
+    let logger = loggerResult.value;
+    if (process.env['WIREIT_DEBUG_LOG_FILE']) {
+        const [{ DebugLogger }, { CombinationLogger }] = await Promise.all([
+            import('./logging/debug-logger.js'),
+            import('./logging/combination-logger.js'),
+        ]);
+        const debugLogStream = await fs.createWriteStream(process.env['WIREIT_DEBUG_LOG_FILE']);
+        const debugLogConsole = new Console(debugLogStream, debugLogStream, true);
+        logger = new CombinationLogger([logger, new DebugLogger(packageRoot, debugLogConsole)], console);
+    }
+    return {
+        ok: true,
+        value: {
+            script,
+            numWorkers: numWorkersResult.value,
+            cache: cacheResult.value.mode,
+            sharedCache: cacheResult.value.shared,
+            failureMode: failureModeResult.value,
+            agent,
+            logger,
+            ...getArgvOptions(script, agent),
+        },
+    };
+};
+/**
+ * Get options that are set as command-line arguments.
+ */
+function getArgvOptions(script, agent) {
+    // The way command-line arguments are handled in npm, yarn, and pnpm are all
+    // different. Our goal here is for `<agent> --watch -- --extra` to behave the
+    // same in all agents.
+    switch (agent) {
+        case 'npm': {
+            // npm 6.14.17
+            //   - Arguments before the "--" in "--flag" style turn into "npm_config_<flag>"
+            //     environment variables.
+            //   - Arguments before the "--" in "plain" style go to argv.
+            //   - Arguments after "--" go to argv.
+            //   - The "npm_config_argv" environment variable contains full details as JSON.
+            //
+            // npm 8.11.0
+            //   - Like npm 6, except there is no "npm_config_argv" environment variable.
+            //
+            // npm 12 (https://github.com/npm/cli/pull/8071)
+            //   - "npm run build --watch" is rejected as an unrecognized npm argument
+            //     instead of being silently turned into "npm_config_watch", so we also
+            //     accept WIREIT_WATCH=true as an escape hatch (see #1346).
+            return {
+                watch: process.env['npm_config_watch'] !== undefined
+                    ? readWatchConfigFromEnv()
+                    : readWatchConfigFromWireitWatchEnv(),
+                extraArgs: process.argv.slice(2),
+            };
+        }
+        case 'nodeRun': {
+            return parseRemainingArgs(process.argv.slice(2));
+        }
+        case 'yarnClassic': {
+            // yarn 1.22.18
+            //   - If there is no "--", all arguments go to argv.
+            //   - If there is a "--", arguments in "--flag" style before it are eaten,
+            //     arguments in "plain" style before it go to argv, and all arguments after
+            //     it go to argv. Also a warning is emitted saying "In a future version, any
+            //     explicit "--" will be forwarded as-is to the scripts."
+            //   - The "npm_config_argv" environment variable contains full details as JSON,
+            //     but unlike npm 6, it reflects the first script in a chain of scripts, instead
+            //     of the last.
+            return parseRemainingArgs(findRemainingArgsFromNpmConfigArgv(script, agent));
+        }
+        case 'yarnBerry':
+        case 'pnpm': {
+            // yarn 3.2.1
+            //   - Arguments before the script name are yarn arguments and error if unknown.
+            //   - Arguments after the script name go to argv.
+            // pnpm 7.1.7
+            //   - Arguments before the script name are pnpm arguments and error if unknown.
+            //   - Arguments after the script name go to argv.
+            return parseRemainingArgs(process.argv.slice(2));
+        }
+        default: {
+            throw new Error(`Unhandled npm agent: ${unreachable(agent)}`);
+        }
+    }
+}
+/**
+ * Try to find the npm user agent being used. If we can't detect it, assume npm.
+ */
+function getNpmUserAgent() {
+    if (process.env['NODE_RUN_SCRIPT_NAME'] !== undefined) {
+        return 'nodeRun';
+    }
+    const userAgent = process.env['npm_config_user_agent'];
+    if (userAgent !== undefined) {
+        const match = userAgent.match(/^(npm|yarn|pnpm)\//);
+        if (match !== null) {
+            if (match[1] === 'yarn') {
+                return /^yarn\/[01]\./.test(userAgent) ? 'yarnClassic' : 'yarnBerry';
+            }
+            return match[1];
+        }
+    }
+    console.error('⚠️ Wireit could not identify the npm user agent, ' +
+        'assuming it behaves like npm. ' +
+        'Arguments may not be interpreted correctly.');
+    return 'npm';
+}
+/**
+ * Parses the `npm_config_argv` environment variable to find the command-line
+ * arguments that follow the main arguments. For example, given the result of
+ * `"yarn run build --watch -- --extra"`, return `["--watch", "--", "--extra"]`.
+ */
+function findRemainingArgsFromNpmConfigArgv(script, agent) {
+    const configArgvStr = process.env['npm_config_argv'];
+    if (!configArgvStr) {
+        console.error('⚠️ The "npm_config_argv" environment variable was not set. ' +
+            'Arguments may not be interpreted correctly.');
+        return [];
+    }
+    let configArgv;
+    try {
+        configArgv = JSON.parse(configArgvStr);
+    }
+    catch {
+        console.error('⚠️ Wireit could not parse the "npm_config_argv" ' +
+            'environment variable as JSON. ' +
+            'Arguments may not be interpreted correctly.');
+        return [];
+    }
+    // Since the "remain" and "cooked" arrays are unreliable in Yarn, the only
+    // reliable way to find the remaining args is to look for where the script
+    // name first appeared in the "original" array.
+    const scriptNameIdx = configArgv.original.indexOf(script.name);
+    if (scriptNameIdx === -1) {
+        // We're probably dealing with a recursive situation where one yarn 1.x
+        // script is calling another, such as `"watch": "yarn run build --watch"`.
+        //
+        // Usually we would handle this situation by looking at the original raw
+        // arguments provided by the "npm_config_argv" environment variable, but in
+        // the recursive case we can't do that, because due to
+        // https://github.com/yarnpkg/yarn/issues/8905 that variable reflects the
+        // first script in the chain, instead of the current script (unlike npm 6.x
+        // which does it correctly).
+        //
+        // So instead, we'll log a warning and at least handle the case where there
+        // is no "--" argument. If there is no "--" argument, then argv will contain
+        // all arguments. However, if there was a "--" argument, then all arguments
+        // before the "--" are lost, and argv only contains the arguments after the
+        // "--" (e.g. `yarn run build --watch` works fine, but `yarn run build
+        // --watch -- --extra` loses the `--watch`).
+        console.error('⚠️ Wireit could not find the script name in ' +
+            'the "npm_config_argv" environment variable. ' +
+            'Arguments may not be interpreted correctly. ' +
+            (agent === 'yarnClassic'
+                ? `See https://github.com/yarnpkg/yarn/issues/8905, ` +
+                    `and please consider upgrading to yarn 3.x or switching to npm.`
+                : ''));
+        return process.argv.slice(2);
+    }
+    return configArgv.original.slice(scriptNameIdx + 1);
+}
+/**
+ * Given a list of remaining command-line arguments (the arguments after e.g.
+ * "yarn run build"), parse out the arguments that are Wireit options, warn
+ * about any unrecognized options, and return everything after a `"--"` argument
+ * as `extraArgs` to be passed down to the script.
+ */
+function parseRemainingArgs(args) {
+    let watch = false;
+    let extraArgs = [];
+    const unrecognized = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--') {
+            extraArgs = args.slice(i + 1);
+            break;
+        }
+        else if (arg === '--watch') {
+            watch = readWatchConfigFromEnv();
+        }
+        else {
+            unrecognized.push(arg);
+        }
+    }
+    if (unrecognized.length > 0) {
+        console.error(`⚠️ Unrecognized Wireit argument(s): ` +
+            unrecognized.map((arg) => JSON.stringify(arg)).join(', ') +
+            `. To pass arguments to the script, use a double-dash, ` +
+            `e.g. "npm run build -- --extra".`);
+    }
+    // Also accept WIREIT_WATCH as an escape hatch (matches the npm branch behavior,
+    // useful for yarn/pnpm/node --run wrappers that scrub --watch from argv).
+    if (!watch) {
+        watch = readWatchConfigFromWireitWatchEnv();
+    }
+    return {
+        watch,
+        extraArgs,
+    };
+}
+const DEFAULT_WATCH_STRATEGY = { strategy: 'event' };
+const DEFAULT_WATCH_INTERVAL = 500;
+function readWatchConfigFromWireitWatchEnv() {
+    return process.env['WIREIT_WATCH']?.toLowerCase() === 'true'
+        ? readWatchConfigFromEnv()
+        : false;
+}
+/**
+ * Interpret the WIREIT_WATCH_* environment variables.
+ */
+function readWatchConfigFromEnv() {
+    switch (process.env['WIREIT_WATCH_STRATEGY']) {
+        case 'event':
+        case '':
+        case undefined: {
+            return DEFAULT_WATCH_STRATEGY;
+        }
+        case 'poll': {
+            let interval = DEFAULT_WATCH_INTERVAL;
+            const intervalStr = process.env['WIREIT_WATCH_POLL_MS'];
+            if (intervalStr) {
+                const parsed = Number(intervalStr);
+                if (Number.isNaN(parsed) || parsed <= 0) {
+                    console.error(`⚠️ Expected WIREIT_WATCH_POLL_MS to be a positive integer, ` +
+                        `got ${JSON.stringify(intervalStr)}. Using default interval of ` +
+                        `${DEFAULT_WATCH_INTERVAL}ms.`);
+                }
+                else {
+                    interval = parsed;
+                }
+            }
+            return {
+                strategy: 'poll',
+                interval,
+            };
+        }
+        default: {
+            console.error(`⚠️ Unrecognized WIREIT_WATCH_STRATEGY: ` +
+                `${JSON.stringify(process.env['WIREIT_WATCH_STRATEGY'])}. ` +
+                `Using default strategy of ${DEFAULT_WATCH_STRATEGY.strategy}.`);
+            return DEFAULT_WATCH_STRATEGY;
+        }
+    }
+}
+//# sourceMappingURL=cli-options.js.map

package/lib/cli.js

@@ -0,0 +1,177 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { Analyzer } from './analyzer.js';
+import { getOptions, packageDir } from './cli-options.js';
+import { Executor } from './executor.js';
+import { SimpleLogger } from './logging/simple-logger.js';
+import { Console } from './logging/logger.js';
+import { unreachable } from './util/unreachable.js';
+import { WorkerPool } from './util/worker-pool.js';
+const run = async (options) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const logger = __addDisposableResource(env_1, options.logger, false);
+        const workerPool = new WorkerPool(options.numWorkers);
+        let cache;
+        switch (options.cache) {
+            case 'local': {
+                // Import dynamically so that we import fewer unnecessary modules.
+                const { LocalCache } = await import('./caching/local-cache.js');
+                cache = new LocalCache();
+                break;
+            }
+            case 'github': {
+                const { GitHubActionsCache } = await import('./caching/github-actions-cache.js');
+                const cacheResult = await GitHubActionsCache.create(logger);
+                if (cacheResult.ok) {
+                    cache = cacheResult.value;
+                }
+                else {
+                    cache = undefined;
+                    console.warn('⚠️ Error initializing GitHub cache. Caching is disabled for this run');
+                    logger.log({
+                        script: options.script,
+                        ...cacheResult.error,
+                    });
+                }
+                break;
+            }
+            case 'shared': {
+                const { SharedCache } = await import('./caching/shared-cache.js');
+                // cli-options guarantees sharedCache is set whenever the mode is 'shared'.
+                const sharedConfig = options.sharedCache;
+                // create() emits its own startup health line and returns undefined if the
+                // cache is unavailable (in which case caching is disabled, but the build
+                // still proceeds).
+                cache = await SharedCache.create(sharedConfig.dir, { readonly: sharedConfig.readonly }, logger);
+                break;
+            }
+            case 'none': {
+                cache = undefined;
+                break;
+            }
+            default: {
+                throw new Error(`Unhandled cache: ${unreachable(options.cache)}`);
+            }
+        }
+        if (options.watch) {
+            const { Watcher } = await import('./watcher.js');
+            const watcher = new Watcher(options.script, options.extraArgs, logger, workerPool, cache, options.failureMode, options.agent, options.watch);
+            process.on('SIGINT', () => {
+                watcher.abort();
+            });
+            process.on('SIGTERM', () => {
+                watcher.abort();
+            });
+            await watcher.watch();
+            return { ok: true, value: undefined };
+        }
+        else {
+            const analyzer = new Analyzer(options.agent, logger);
+            const { config } = await analyzer.analyze(options.script, options.extraArgs);
+            if (!config.ok) {
+                return config;
+            }
+            const executor = new Executor(config.value, logger, workerPool, cache, options.failureMode, undefined, false);
+            process.on('SIGINT', () => {
+                executor.abort();
+            });
+            process.on('SIGTERM', () => {
+                executor.abort();
+            });
+            const { persistentServices, errors } = await executor.execute();
+            if (persistentServices.size > 0) {
+                for (const service of persistentServices.values()) {
+                    const result = await service.terminated;
+                    if (!result.ok) {
+                        errors.push(result.error);
+                    }
+                }
+            }
+            logger.printMetrics();
+            return errors.length === 0
+                ? { ok: true, value: undefined }
+                : { ok: false, error: errors };
+        }
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+};
+const optionsResult = await getOptions();
+if (!optionsResult.ok) {
+    // if we can't figure out our options, we can't figure out what logger
+    // we should use here, so just use the default logger.
+    const console = new Console(process.stderr, process.stderr);
+    const logger = new SimpleLogger(packageDir ?? process.cwd(), console);
+    logger.log(optionsResult.error);
+    process.exit(1);
+}
+const options = optionsResult.value;
+const result = await run(options);
+if (!result.ok) {
+    for (const failure of result.error) {
+        options.logger.log(failure);
+    }
+    process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map

package/lib/config.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Convert a {@link ScriptReference} to a string that can be used as a key in a
+ * Set, Map, etc.
+ */
+export const scriptReferenceToString = ({ packageDir, name, }) => JSON.stringify([packageDir, name]);
+/**
+ * Inverse of {@link scriptReferenceToString}.
+ */
+export const stringToScriptReference = (str) => {
+    const [packageDir, name] = JSON.parse(str);
+    return { packageDir, name };
+};
+//# sourceMappingURL=config.js.map