projen 0.99.80 → 0.100.1

package/lib/cli/task-runtime.js

@@ -0,0 +1,482 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRuntime = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const chalk_1 = require("chalk");
+const dax_1 = require("dax");
+const common_1 = require("../common");
+const logging = __importStar(require("../logging"));
+// avoids a (false positive) esbuild warning about incorrect imports.
+// `?.default ?? module` keeps this working both as a plain CommonJS require and
+// when the dependency is interop-wrapped inside the bundled run-task.cjs (where
+// `require(...)` may yield `{ default: fn }` instead of the function). See
+// projen#4407 ("parseConflictJSON is not a function" after eject).
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const parseConflictJSONModule = require("parse-conflict-json");
+const parseConflictJSON = parseConflictJSONModule?.default ?? parseConflictJSONModule;
+const ENV_TRIM_LEN = 20;
+const ARGS_MARKER = "$@";
+const QUOTED_ARGS_MARKER = `"${ARGS_MARKER}"`;
+/**
+ * The runtime component of the tasks engine.
+ */
+class TaskRuntime {
+    /**
+     * The project-relative path of the tasks manifest file.
+     */
+    static MANIFEST_FILE = path.posix.join(common_1.PROJEN_DIR, "tasks.json");
+    /**
+     * One-shot entrypoint for the standalone task runner.
+     *
+     * Creates a runtime rooted at the current working directory, runs the named
+     * task, and converts any failure into a non-zero process exit code. This is
+     * the single line invoked by the bundled `scripts/run-task.cjs` that
+     * "projen eject" emits, which keeps the generated bundle footer trivial.
+     *
+     * @param name The name of the task to run. Defaults to `process.argv[2]`.
+     */
+    static async main(name = process.argv[2]) {
+        try {
+            await new TaskRuntime(".").runTask(name);
+        }
+        catch (e) {
+            console.error(e?.stack ?? String(e));
+            process.exit(1);
+        }
+    }
+    /**
+     * The contents of tasks.json
+     */
+    _manifest = { tasks: {} };
+    /**
+     * The raw contents of the currently loaded manifest, used to detect changes
+     * on disk so the runtime can reload a regenerated manifest mid-run.
+     */
+    _identity;
+    /**
+     * The root directory of the project and the cwd for executing tasks.
+     */
+    workdir;
+    constructor(workdir) {
+        this.workdir = (0, path_1.resolve)(workdir);
+        // Perform the initial load. This also verifies the manifest's schema
+        // version.
+        this.reloadManifestIfChanged();
+    }
+    /**
+     * The contents of tasks.json
+     */
+    get manifest() {
+        return this._manifest;
+    }
+    /**
+     * The absolute path of the tasks manifest file.
+     */
+    get manifestPath() {
+        return (0, path_1.join)(this.workdir, TaskRuntime.MANIFEST_FILE);
+    }
+    /**
+     * The tasks in this project.
+     */
+    get tasks() {
+        return Object.values(this.manifest.tasks ?? {});
+    }
+    /**
+     * Find a task by name, or `undefined` if not found.
+     */
+    tryFindTask(name) {
+        if (!this.manifest.tasks) {
+            return undefined;
+        }
+        return this.manifest.tasks[name];
+    }
+    /**
+     * Runs the task.
+     * @param name The task name.
+     */
+    async runTask(name, parents = [], args = [], env = {}) {
+        // A previously executed task (most importantly the "default"/synth task,
+        // which `build` spawns first) may have regenerated `.projen/tasks.json`.
+        // Pick up any such changes before resolving and running this task so we
+        // never execute a stale, in-memory definition.
+        this.reloadManifestIfChanged();
+        const task = this.tryFindTask(name);
+        if (!task) {
+            throw new Error(`cannot find command ${name}`);
+        }
+        await new RunTask(this, task, parents, args, env).run();
+    }
+    /**
+     * Re-reads the tasks manifest from disk if its contents changed since it was
+     * last loaded, verifying its schema version along the way.
+     *
+     * Change detection compares the raw file contents, so an unchanged manifest
+     * is not re-verified or re-adopted.
+     */
+    reloadManifestIfChanged() {
+        if (!(0, fs_1.existsSync)(this.manifestPath)) {
+            // No manifest on disk: treat as an empty project (legacy behavior).
+            this._manifest = { tasks: {} };
+            this._identity = undefined;
+            return;
+        }
+        const raw = (0, fs_1.readFileSync)(this.manifestPath, "utf-8");
+        if (raw === this._identity) {
+            return; // unchanged since the last load
+        }
+        const manifest = parseConflictJSON(raw, undefined, "theirs");
+        // A previously loaded manifest means this is a *reload* (e.g. the
+        // "default"/synth task regenerated the file mid-run), as opposed to the
+        // initial load performed by the constructor.
+        const isReload = this._identity !== undefined;
+        this.verifyManifest(manifest);
+        this._manifest = manifest;
+        this._identity = raw;
+        if (isReload) {
+            logging.debug(`${TaskRuntime.MANIFEST_FILE} changed on disk; successfully loaded the new tasks manifest.`);
+        }
+    }
+    /**
+     * Validates a freshly read manifest:
+     *
+     * - Legacy manifests (no `manifestVersion`) are accepted as-is for backwards
+     *   compatibility.
+     * - Manifests from a newer projen (a higher `manifestVersion`) are accepted
+     *   with a warning, since this runtime may not understand the schema.
+     */
+    verifyManifest(manifest) {
+        // Backwards compatibility: manifests generated before versioning carry no
+        // version.
+        if (manifest.manifestVersion === undefined) {
+            return;
+        }
+        if (manifest.manifestVersion > common_1.TASKS_MANIFEST_VERSION) {
+            logging.warn(`${TaskRuntime.MANIFEST_FILE} was generated by a newer version of projen ` +
+                `(manifest version ${manifest.manifestVersion}, this projen supports up to ${common_1.TASKS_MANIFEST_VERSION}). ` +
+                `Some tasks may not behave as expected; consider upgrading projen.`);
+        }
+    }
+}
+exports.TaskRuntime = TaskRuntime;
+class RunTask {
+    runtime;
+    task;
+    args;
+    envParam;
+    env = {};
+    parents;
+    workdir;
+    constructor(runtime, task, parents = [], args = [], envParam = {}) {
+        this.runtime = runtime;
+        this.task = task;
+        this.args = args;
+        this.envParam = envParam;
+        this.workdir = task.cwd ?? this.runtime.workdir;
+        this.parents = parents;
+    }
+    /**
+     * Executes the task. This was previously done in the constructor, but is now
+     * an async method since shell execution is asynchronous (e.g. dax on
+     * Windows).
+     */
+    async run() {
+        const { task, args, parents } = this;
+        if (!task.steps || task.steps.length === 0) {
+            this.logDebug((0, chalk_1.gray)("No actions have been specified for this task."));
+            return;
+        }
+        this.env = await this.resolveEnvironment(this.envParam, parents);
+        const envlogs = [];
+        for (const [k, v] of Object.entries(this.env)) {
+            const vv = v ?? "";
+            const trimmed = vv.length > ENV_TRIM_LEN ? vv.substring(0, ENV_TRIM_LEN) + "..." : vv;
+            envlogs.push(`${k}=${trimmed}`);
+        }
+        if (envlogs.length) {
+            this.logDebug((0, chalk_1.gray)(`${(0, chalk_1.underline)("env")}: ${envlogs.join(" ")}`));
+        }
+        // evaluate condition
+        if (!(await this.evalCondition(task))) {
+            this.log("condition exited with non-zero - skipping");
+            return;
+        }
+        // verify we required environment variables are defined
+        const merged = { ...process.env, ...this.env };
+        const missing = new Array();
+        for (const name of task.requiredEnv ?? []) {
+            if (!(name in merged)) {
+                missing.push(name);
+            }
+        }
+        if (missing.length > 0) {
+            throw new Error(`missing required environment variables: ${missing.join(",")}`);
+        }
+        for (const step of task.steps) {
+            // evaluate step condition
+            if (!(await this.evalCondition(step))) {
+                this.log("condition exited with non-zero - skipping");
+                continue;
+            }
+            const argsList = [
+                ...(step.args || []),
+                ...(step.receiveArgs ? args : []),
+            ].map((a) => a.toString());
+            if (step.say) {
+                logging.info(this.fmtLog(step.say));
+            }
+            if (step.spawn) {
+                await this.runtime.runTask(step.spawn, [...this.parents, this.task.name], argsList, step.env);
+            }
+            const execs = step.exec ? [step.exec] : [];
+            // Parse step-specific environment variables
+            const env = await this.evalEnvironment(step.env ?? {});
+            if (step.builtin) {
+                execs.push(this.renderBuiltin(step.builtin));
+            }
+            for (const exec of execs) {
+                let hasError = false;
+                let command = exec;
+                if (command.includes(QUOTED_ARGS_MARKER)) {
+                    // Poorly imitate bash quoted variable expansion. If "$@" is encountered in bash, elements of the arg array
+                    // that contain whitespace will be single quoted ('arg'). This preserves whitespace in things like filenames.
+                    // Imitate that behavior here by single quoting every element of the arg array when a quoted arg marker ("$@")
+                    // is encountered.
+                    command = command.replace(QUOTED_ARGS_MARKER, argsList.map((arg) => `'${arg}'`).join(" "));
+                }
+                else if (command.includes(ARGS_MARKER)) {
+                    command = command.replace(ARGS_MARKER, argsList.join(" "));
+                }
+                else {
+                    command = [command, ...argsList].join(" ");
+                }
+                const cwd = step.cwd;
+                try {
+                    const result = await this.shell({
+                        command,
+                        cwd,
+                        extraEnv: env,
+                    });
+                    hasError = result.status !== 0;
+                }
+                catch (e) {
+                    // a non-zero exit code is reported via `result.status` above; this
+                    // catch handles errors thrown while attempting to spawn the command.
+                    if (e?.message?.startsWith("non-zero exit code:")) {
+                        hasError = true;
+                    }
+                    throw e;
+                }
+                if (hasError) {
+                    throw new Error(`Task "${this.fullname}" failed when executing "${command}" (cwd: ${(0, path_1.resolve)(cwd ?? this.workdir)})`);
+                }
+            }
+        }
+    }
+    /**
+     * Determines if a task should be executed based on "condition".
+     *
+     * @returns true if the task should be executed or false if the condition
+     * evaluates to false (exits with non-zero), indicating that the task should
+     * be skipped.
+     */
+    async evalCondition(taskOrStep) {
+        // no condition, carry on
+        if (!taskOrStep.condition) {
+            return true;
+        }
+        this.log((0, chalk_1.gray)(`${(0, chalk_1.underline)("condition")}: ${taskOrStep.condition}`));
+        const result = await this.shell({
+            command: taskOrStep.condition,
+            logprefix: "condition: ",
+            quiet: true,
+        });
+        if (result.status === 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Evaluates environment variables from shell commands (e.g. `$(xx)`)
+     */
+    async evalEnvironment(env) {
+        const output = {};
+        for (const [key, value] of Object.entries(env ?? {})) {
+            if (String(value).startsWith("$(") && String(value).endsWith(")")) {
+                const query = value.substring(2, value.length - 1);
+                const result = await this.shellEval({ command: query });
+                if (result.status !== 0) {
+                    const error = result.error
+                        ? result.error.stack
+                        : result.stderr?.toString().trim() ||
+                            result.stdout?.toString().trim() ||
+                            `command exited with code ${result.status}`;
+                    logging.warn(this.fmtLog(`${(0, chalk_1.underline)(key)}: unable to evaluate "${query}". Environment variable will be skipped. Check that the command exists and runs successfully.`));
+                    logging.warn(this.fmtLog(`${(0, chalk_1.underline)(key)}: ${error}`));
+                }
+                else {
+                    output[key] = result.stdout?.toString("utf-8").trim() ?? "";
+                }
+            }
+            else {
+                output[key] = value;
+            }
+        }
+        return output;
+    }
+    /**
+     * Renders the runtime environment for a task. Namely, it supports this syntax
+     * `$(xx)` for allowing environment to be evaluated by executing a shell
+     * command and obtaining its result.
+     */
+    async resolveEnvironment(envParam, parents) {
+        let env = this.runtime.manifest.env ?? {};
+        // add env from all parent tasks one by one
+        for (const parent of parents) {
+            env = {
+                ...env,
+                ...(this.runtime.tryFindTask(parent)?.env ?? {}),
+            };
+        }
+        // apply task environment, then the specific env last
+        env = {
+            ...env,
+            ...(this.task.env ?? {}),
+            ...envParam,
+        };
+        return this.evalEnvironment(env ?? {});
+    }
+    /**
+     * Returns the "full name" of the task which includes all it's parent task names concatenated by chevrons.
+     */
+    get fullname() {
+        return [...this.parents, this.task.name].join(" » ");
+    }
+    log(...args) {
+        logging.verbose(this.fmtLog(...args));
+    }
+    logDebug(...args) {
+        logging.debug(this.fmtLog(...args));
+    }
+    fmtLog(...args) {
+        return (0, util_1.format)(`${(0, chalk_1.underline)(this.fullname)} |`, ...args);
+    }
+    async shell(options) {
+        const quiet = options.quiet ?? false;
+        if (!quiet) {
+            const log = new Array();
+            if (options.logprefix) {
+                log.push(options.logprefix);
+            }
+            log.push(options.command);
+            if (options.cwd) {
+                log.push(`(cwd: ${options.cwd})`);
+            }
+            this.log(log.join(" "));
+        }
+        const cwd = options.cwd ?? this.workdir;
+        if (!(0, fs_1.existsSync)(cwd) || !(0, fs_1.statSync)(cwd).isDirectory()) {
+            throw new Error(`invalid workdir (cwd): ${cwd} must be an existing directory`);
+        }
+        const env = {
+            ...process.env,
+            ...this.env,
+            ...options.extraEnv,
+        };
+        // On Windows the default shell (cmd.exe) does not understand the POSIX-style
+        // commands projen tasks are written in (`cat`, `cp`, `mkdir -p`, `rm -rf`,
+        // `&&` chains, `$VAR`, ...). Run the command through dax's cross-platform
+        // shell instead, which ships built-in implementations of the common
+        // commands. Now that the task runtime is asynchronous we can drive dax's
+        // `$` API directly instead of spawning a synchronous child node process.
+        if (process.platform === "win32") {
+            // stdout/stderr are only captured when a caller pipes them (e.g.
+            // `shellEval`); otherwise inherit so output is streamed to the terminal.
+            const capture = Array.isArray(options.spawnOptions?.stdio);
+            const result = await dax_1.$.raw `${options.command}`
+                .cwd(cwd)
+                .env(env)
+                .stdout(capture ? "piped" : "inherit")
+                .stderr(capture ? "piped" : "inherit")
+                .noThrow();
+            return {
+                status: result.code,
+                stdout: capture ? Buffer.from(result.stdoutBytes) : null,
+                stderr: capture ? Buffer.from(result.stderrBytes) : null,
+            };
+        }
+        return (0, child_process_1.spawnSync)(options.command, {
+            ...options,
+            cwd,
+            shell: true,
+            stdio: "inherit",
+            env,
+            ...options.spawnOptions,
+        });
+    }
+    async shellEval(options) {
+        return this.shell({
+            quiet: true,
+            ...options,
+            spawnOptions: {
+                stdio: ["inherit", "pipe", "pipe"],
+            },
+        });
+    }
+    renderBuiltin(builtin) {
+        // Locate projen's package root by walking up from this module's directory
+        // until we find a package.json. This works whether the code runs from the
+        // compiled file (lib/cli/task-runtime.js) or from the bundled run-task.cjs
+        // (lib/run-task.cjs), which live at different depths - so a hard-coded
+        // relative path to package.json would be wrong in one of the two cases.
+        let moduleRoot = __dirname;
+        while (!(0, fs_1.existsSync)((0, path_1.join)(moduleRoot, "package.json"))) {
+            const parent = (0, path_1.dirname)(moduleRoot);
+            if (parent === moduleRoot) {
+                throw new Error("unable to locate the projen package root");
+            }
+            moduleRoot = parent;
+        }
+        const program = require.resolve((0, path_1.join)(moduleRoot, "lib", `${builtin}.task.js`));
+        return `"${process.execPath}" "${program}"`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-runtime.js","sourceRoot":"","sources":["../../src/cli/task-runtime.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,iDAA0C;AAC1C,2BAAwD;AACxD,+BAA8C;AAC9C,2CAA6B;AAC7B,+BAA8B;AAC9B,iCAAwC;AACxC,6BAAwB;AACxB,sCAA+D;AAC/D,oDAAsC;AAGtC,qEAAqE;AACrE,gFAAgF;AAChF,gFAAgF;AAChF,2EAA2E;AAC3E,mEAAmE;AACnE,iEAAiE;AACjE,MAAM,uBAAuB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAC/D,MAAM,iBAAiB,GACrB,uBAAuB,EAAE,OAAO,IAAI,uBAAuB,CAAC;AAE9D,MAAM,YAAY,GAAG,EAAE,CAAC;AACxB,MAAM,WAAW,GAAG,IAAI,CAAC;AACzB,MAAM,kBAAkB,GAAG,IAAI,WAAW,GAAG,CAAC;AAkC9C;;GAEG;AACH,MAAa,WAAW;IACtB;;OAEG;IACI,MAAM,CAAU,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CACpD,mBAAU,EACV,YAAY,CACb,CAAC;IAEF;;;;;;;;;OASG;IACI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAe,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QACrD,IAAI,CAAC;YACH,MAAM,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YACrC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IAED;;OAEG;IACK,SAAS,GAAkB,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IAEjD;;;OAGG;IACK,SAAS,CAAU;IAE3B;;OAEG;IACa,OAAO,CAAS;IAEhC,YAAY,OAAe;QACzB,IAAI,CAAC,OAAO,GAAG,IAAA,cAAO,EAAC,OAAO,CAAC,CAAC;QAChC,qEAAqE;QACrE,WAAW;QACX,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,IAAY,YAAY;QACtB,OAAO,IAAA,WAAI,EAAC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC;IAED;;OAEG;IACH,IAAW,KAAK;QACd,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,IAAY;QAC7B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACzB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,OAAO,CAClB,IAAY,EACZ,UAAoB,EAAE,EACtB,OAA+B,EAAE,EACjC,MAAkC,EAAE;QAEpC,yEAAyE;QACzE,yEAAyE;QACzE,wEAAwE;QACxE,+CAA+C;QAC/C,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAE/B,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC,CAAC;QACjD,CAAC;QAED,MAAM,IAAI,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;IAC1D,CAAC;IAED;;;;;;OAMG;IACK,uBAAuB;QAC7B,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;YACnC,oEAAoE;YACpE,IAAI,CAAC,SAAS,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;YAC/B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3B,OAAO;QACT,CAAC;QAED,MAAM,GAAG,GAAG,IAAA,iBAAY,EAAC,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QACrD,IAAI,GAAG,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YAC3B,OAAO,CAAC,gCAAgC;QAC1C,CAAC;QAED,MAAM,QAAQ,GAAkB,iBAAiB,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;QAE5E,kEAAkE;QAClE,wEAAwE;QACxE,6CAA6C;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC;QAE9C,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC;QAErB,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CACX,GAAG,WAAW,CAAC,aAAa,+DAA+D,CAC5F,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACK,cAAc,CAAC,QAAuB;QAC5C,0EAA0E;QAC1E,WAAW;QACX,IAAI,QAAQ,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;YAC3C,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,CAAC,eAAe,GAAG,+BAAsB,EAAE,CAAC;YACtD,OAAO,CAAC,IAAI,CACV,GAAG,WAAW,CAAC,aAAa,8CAA8C;gBACxE,qBAAqB,QAAQ,CAAC,eAAe,gCAAgC,+BAAsB,KAAK;gBACxG,mEAAmE,CACtE,CAAC;QACJ,CAAC;IACH,CAAC;;AAtKH,kCAuKC;AAED,MAAM,OAAO;IAOQ;IACA;IAEA;IACA;IAVX,GAAG,GAA2C,EAAE,CAAC;IACxC,OAAO,CAAW;IAElB,OAAO,CAAS;IAEjC,YACmB,OAAoB,EACpB,IAAc,EAC/B,UAAoB,EAAE,EACL,OAA+B,EAAE,EACjC,WAAuC,EAAE;QAJzC,YAAO,GAAP,OAAO,CAAa;QACpB,SAAI,GAAJ,IAAI,CAAU;QAEd,SAAI,GAAJ,IAAI,CAA6B;QACjC,aAAQ,GAAR,QAAQ,CAAiC;QAE1D,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;QAChD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,GAAG;QACd,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;QAErC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3C,IAAI,CAAC,QAAQ,CAAC,IAAA,YAAI,EAAC,+CAA+C,CAAC,CAAC,CAAC;YACrE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,GAAG,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAEjE,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9C,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC;YACnB,MAAM,OAAO,GACX,EAAE,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACxE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC;QAClC,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,IAAA,YAAI,EAAC,GAAG,IAAA,iBAAS,EAAC,KAAK,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACnE,CAAC;QAED,qBAAqB;QACrB,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YACtC,IAAI,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAC;YACtD,OAAO;QACT,CAAC;QAED,uDAAuD;QACvD,MAAM,MAAM,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC/C,MAAM,OAAO,GAAG,IAAI,KAAK,EAAU,CAAC;QACpC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;YAC1C,IAAI,CAAC,CAAC,IAAI,IAAI,MAAM,CAAC,EAAE,CAAC;gBACtB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CACb,2CAA2C,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAC/D,CAAC;QACJ,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,0BAA0B;YAC1B,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;gBACtC,IAAI,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAC;gBACtD,SAAS;YACX,CAAC;YAED,MAAM,QAAQ,GAAa;gBACzB,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;gBACpB,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;aAClC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;YAE3B,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACtC,CAAC;YAED,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CACxB,IAAI,CAAC,KAAK,EACV,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EACjC,QAAQ,EACR,IAAI,CAAC,GAAG,CACT,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAE3C,4CAA4C;YAC5C,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;YAEvD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAC/C,CAAC;YAED,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,IAAI,QAAQ,GAAG,KAAK,CAAC;gBAErB,IAAI,OAAO,GAAG,IAAI,CAAC;gBAEnB,IAAI,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;oBACzC,2GAA2G;oBAC3G,6GAA6G;oBAC7G,8GAA8G;oBAC9G,kBAAkB;oBAClB,OAAO,GAAG,OAAO,CAAC,OAAO,CACvB,kBAAkB,EAClB,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAC5C,CAAC;gBACJ,CAAC;qBAAM,IAAI,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;oBACzC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC7D,CAAC;qBAAM,CAAC;oBACN,OAAO,GAAG,CAAC,OAAO,EAAE,GAAG,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC7C,CAAC;gBAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;gBACrB,IAAI,CAAC;oBACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC;wBAC9B,OAAO;wBACP,GAAG;wBACH,QAAQ,EAAE,GAAG;qBACd,CAAC,CAAC;oBACH,QAAQ,GAAG,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;gBACjC,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,mEAAmE;oBACnE,qEAAqE;oBACrE,IAAK,CAAS,EAAE,OAAO,EAAE,UAAU,CAAC,qBAAqB,CAAC,EAAE,CAAC;wBAC3D,QAAQ,GAAG,IAAI,CAAC;oBAClB,CAAC;oBACD,MAAM,CAAC,CAAC;gBACV,CAAC;gBACD,IAAI,QAAQ,EAAE,CAAC;oBACb,MAAM,IAAI,KAAK,CACb,SACE,IAAI,CAAC,QACP,4BAA4B,OAAO,WAAW,IAAA,cAAO,EACnD,GAAG,IAAI,IAAI,CAAC,OAAO,CACpB,GAAG,CACL,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,KAAK,CAAC,aAAa,CAAC,UAA+B;QACzD,yBAAyB;QACzB,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,IAAA,YAAI,EAAC,GAAG,IAAA,iBAAS,EAAC,WAAW,CAAC,KAAK,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QACrE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC;YAC9B,OAAO,EAAE,UAAU,CAAC,SAAS;YAC7B,SAAS,EAAE,aAAa;YACxB,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,CAAC;YACN,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe,CAAC,GAA+B;QAC3D,MAAM,MAAM,GAA2C,EAAE,CAAC;QAE1D,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC;YACrD,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBAClE,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;gBACxD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACxB,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK;wBACxB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK;wBACpB,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE;4BAChC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE;4BAChC,4BAA4B,MAAM,CAAC,MAAM,EAAE,CAAC;oBAEhD,OAAO,CAAC,IAAI,CACV,IAAI,CAAC,MAAM,CACT,GAAG,IAAA,iBAAS,EAAC,GAAG,CAAC,yBAAyB,KAAK,+FAA+F,CAC/I,CACF,CAAC;oBACF,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAA,iBAAS,EAAC,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC;gBAC3D,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;gBAC9D,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YACtB,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,kBAAkB,CAC9B,QAAoC,EACpC,OAAiB;QAEjB,IAAI,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,EAAE,CAAC;QAE1C,2CAA2C;QAC3C,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,GAAG,GAAG;gBACJ,GAAG,GAAG;gBACN,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC;aACjD,CAAC;QACJ,CAAC;QAED,qDAAqD;QACrD,GAAG,GAAG;YACJ,GAAG,GAAG;YACN,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC;YACxB,GAAG,QAAQ;SACZ,CAAC;QAEF,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,IAAY,QAAQ;QAClB,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvD,CAAC;IAEO,GAAG,CAAC,GAAG,IAAW;QACxB,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACxC,CAAC;IAEO,QAAQ,CAAC,GAAG,IAAW;QAC7B,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACtC,CAAC;IAEO,MAAM,CAAC,GAAG,IAAW;QAC3B,OAAO,IAAA,aAAM,EAAC,GAAG,IAAA,iBAAS,EAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;IAC1D,CAAC;IAEO,KAAK,CAAC,KAAK,CAAC,OAAqB;QACvC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC;QACrC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,GAAG,GAAG,IAAI,KAAK,EAAU,CAAC;YAEhC,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBACtB,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAC9B,CAAC;YAED,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAE1B,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;gBAChB,GAAG,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC;YACpC,CAAC;YAED,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1B,CAAC;QAED,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC;QACxC,IAAI,CAAC,IAAA,eAAU,EAAC,GAAG,CAAC,IAAI,CAAC,IAAA,aAAQ,EAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACrD,MAAM,IAAI,KAAK,CACb,0BAA0B,GAAG,gCAAgC,CAC9D,CAAC;QACJ,CAAC;QAED,MAAM,GAAG,GAAG;YACV,GAAG,OAAO,CAAC,GAAG;YACd,GAAG,IAAI,CAAC,GAAG;YACX,GAAG,OAAO,CAAC,QAAQ;SACpB,CAAC;QAEF,6EAA6E;QAC7E,2EAA2E;QAC3E,0EAA0E;QAC1E,oEAAoE;QACpE,yEAAyE;QACzE,yEAAyE;QACzE,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YACjC,iEAAiE;YACjE,yEAAyE;YACzE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;YAE3D,MAAM,MAAM,GAAG,MAAM,OAAC,CAAC,GAAG,CAAA,GAAG,OAAO,CAAC,OAAO,EAAE;iBAC3C,GAAG,CAAC,GAAG,CAAC;iBACR,GAAG,CAAC,GAAG,CAAC;iBACR,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;iBACrC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;iBACrC,OAAO,EAAE,CAAC;YAEb,OAAO;gBACL,MAAM,EAAE,MAAM,CAAC,IAAI;gBACnB,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI;gBACxD,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI;aACzD,CAAC;QACJ,CAAC;QAED,OAAO,IAAA,yBAAS,EAAC,OAAO,CAAC,OAAO,EAAE;YAChC,GAAG,OAAO;YACV,GAAG;YACH,KAAK,EAAE,IAAI;YACX,KAAK,EAAE,SAAS;YAChB,GAAG;YACH,GAAG,OAAO,CAAC,YAAY;SACxB,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,OAAqB;QAC3C,OAAO,IAAI,CAAC,KAAK,CAAC;YAChB,KAAK,EAAE,IAAI;YACX,GAAG,OAAO;YACV,YAAY,EAAE;gBACZ,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC;aACnC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,aAAa,CAAC,OAAe;QACnC,0EAA0E;QAC1E,0EAA0E;QAC1E,2EAA2E;QAC3E,uEAAuE;QACvE,wEAAwE;QACxE,IAAI,UAAU,GAAG,SAAS,CAAC;QAC3B,OAAO,CAAC,IAAA,eAAU,EAAC,IAAA,WAAI,EAAC,UAAU,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC;YACrD,MAAM,MAAM,GAAG,IAAA,cAAO,EAAC,UAAU,CAAC,CAAC;YACnC,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;gBAC1B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;YAC9D,CAAC;YACD,UAAU,GAAG,MAAM,CAAC;QACtB,CAAC;QACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAC7B,IAAA,WAAI,EAAC,UAAU,EAAE,KAAK,EAAE,GAAG,OAAO,UAAU,CAAC,CAC9C,CAAC;QACF,OAAO,IAAI,OAAO,CAAC,QAAQ,MAAM,OAAO,GAAG,CAAC;IAC9C,CAAC;CACF","sourcesContent":["import type { SpawnOptions } from \"child_process\";\nimport { spawnSync } from \"child_process\";\nimport { existsSync, readFileSync, statSync } from \"fs\";\nimport { dirname, join, resolve } from \"path\";\nimport * as path from \"path\";\nimport { format } from \"util\";\nimport { gray, underline } from \"chalk\";\nimport { $ } from \"dax\";\nimport { PROJEN_DIR, TASKS_MANIFEST_VERSION } from \"../common\";\nimport * as logging from \"../logging\";\nimport type { TasksManifest, TaskSpec, TaskStep } from \"../task-model\";\n\n// avoids a (false positive) esbuild warning about incorrect imports.\n// `?.default ?? module` keeps this working both as a plain CommonJS require and\n// when the dependency is interop-wrapped inside the bundled run-task.cjs (where\n// `require(...)` may yield `{ default: fn }` instead of the function). See\n// projen#4407 (\"parseConflictJSON is not a function\" after eject).\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst parseConflictJSONModule = require(\"parse-conflict-json\");\nconst parseConflictJSON =\n  parseConflictJSONModule?.default ?? parseConflictJSONModule;\n\nconst ENV_TRIM_LEN = 20;\nconst ARGS_MARKER = \"$@\";\nconst QUOTED_ARGS_MARKER = `\"${ARGS_MARKER}\"`;\n\n/**\n * The result of executing a shell command.\n *\n * This is a normalized subset of node's `SpawnSyncReturns` so that the\n * synchronous (`spawnSync`) and asynchronous (`dax`) execution paths can return\n * a compatible shape.\n */\ninterface ShellResult {\n  /**\n   * The exit code of the command, or `null` if the process was terminated by a\n   * signal or never spawned.\n   */\n  readonly status: number | null;\n\n  /**\n   * Captured stdout. Only populated when stdout is piped (e.g. when evaluating\n   * environment variables); `null`/`undefined` when stdio is inherited.\n   */\n  readonly stdout?: Buffer | null;\n\n  /**\n   * Captured stderr. See `stdout`.\n   */\n  readonly stderr?: Buffer | null;\n\n  /**\n   * An error raised while attempting to spawn the command (not a non-zero exit\n   * code, which is reported via `status`).\n   */\n  readonly error?: Error;\n}\n\n/**\n * The runtime component of the tasks engine.\n */\nexport class TaskRuntime {\n  /**\n   * The project-relative path of the tasks manifest file.\n   */\n  public static readonly MANIFEST_FILE = path.posix.join(\n    PROJEN_DIR,\n    \"tasks.json\",\n  );\n\n  /**\n   * One-shot entrypoint for the standalone task runner.\n   *\n   * Creates a runtime rooted at the current working directory, runs the named\n   * task, and converts any failure into a non-zero process exit code. This is\n   * the single line invoked by the bundled `scripts/run-task.cjs` that\n   * \"projen eject\" emits, which keeps the generated bundle footer trivial.\n   *\n   * @param name The name of the task to run. Defaults to `process.argv[2]`.\n   */\n  public static async main(name: string = process.argv[2]): Promise<void> {\n    try {\n      await new TaskRuntime(\".\").runTask(name);\n    } catch (e: any) {\n      console.error(e?.stack ?? String(e));\n      process.exit(1);\n    }\n  }\n\n  /**\n   * The contents of tasks.json\n   */\n  private _manifest: TasksManifest = { tasks: {} };\n\n  /**\n   * The raw contents of the currently loaded manifest, used to detect changes\n   * on disk so the runtime can reload a regenerated manifest mid-run.\n   */\n  private _identity?: string;\n\n  /**\n   * The root directory of the project and the cwd for executing tasks.\n   */\n  public readonly workdir: string;\n\n  constructor(workdir: string) {\n    this.workdir = resolve(workdir);\n    // Perform the initial load. This also verifies the manifest's schema\n    // version.\n    this.reloadManifestIfChanged();\n  }\n\n  /**\n   * The contents of tasks.json\n   */\n  public get manifest(): TasksManifest {\n    return this._manifest;\n  }\n\n  /**\n   * The absolute path of the tasks manifest file.\n   */\n  private get manifestPath(): string {\n    return join(this.workdir, TaskRuntime.MANIFEST_FILE);\n  }\n\n  /**\n   * The tasks in this project.\n   */\n  public get tasks(): TaskSpec[] {\n    return Object.values(this.manifest.tasks ?? {});\n  }\n\n  /**\n   * Find a task by name, or `undefined` if not found.\n   */\n  public tryFindTask(name: string): TaskSpec | undefined {\n    if (!this.manifest.tasks) {\n      return undefined;\n    }\n    return this.manifest.tasks[name];\n  }\n\n  /**\n   * Runs the task.\n   * @param name The task name.\n   */\n  public async runTask(\n    name: string,\n    parents: string[] = [],\n    args: Array<string | number> = [],\n    env: { [name: string]: string } = {},\n  ): Promise<void> {\n    // A previously executed task (most importantly the \"default\"/synth task,\n    // which `build` spawns first) may have regenerated `.projen/tasks.json`.\n    // Pick up any such changes before resolving and running this task so we\n    // never execute a stale, in-memory definition.\n    this.reloadManifestIfChanged();\n\n    const task = this.tryFindTask(name);\n    if (!task) {\n      throw new Error(`cannot find command ${name}`);\n    }\n\n    await new RunTask(this, task, parents, args, env).run();\n  }\n\n  /**\n   * Re-reads the tasks manifest from disk if its contents changed since it was\n   * last loaded, verifying its schema version along the way.\n   *\n   * Change detection compares the raw file contents, so an unchanged manifest\n   * is not re-verified or re-adopted.\n   */\n  private reloadManifestIfChanged(): void {\n    if (!existsSync(this.manifestPath)) {\n      // No manifest on disk: treat as an empty project (legacy behavior).\n      this._manifest = { tasks: {} };\n      this._identity = undefined;\n      return;\n    }\n\n    const raw = readFileSync(this.manifestPath, \"utf-8\");\n    if (raw === this._identity) {\n      return; // unchanged since the last load\n    }\n\n    const manifest: TasksManifest = parseConflictJSON(raw, undefined, \"theirs\");\n\n    // A previously loaded manifest means this is a *reload* (e.g. the\n    // \"default\"/synth task regenerated the file mid-run), as opposed to the\n    // initial load performed by the constructor.\n    const isReload = this._identity !== undefined;\n\n    this.verifyManifest(manifest);\n    this._manifest = manifest;\n    this._identity = raw;\n\n    if (isReload) {\n      logging.debug(\n        `${TaskRuntime.MANIFEST_FILE} changed on disk; successfully loaded the new tasks manifest.`,\n      );\n    }\n  }\n\n  /**\n   * Validates a freshly read manifest:\n   *\n   * - Legacy manifests (no `manifestVersion`) are accepted as-is for backwards\n   *   compatibility.\n   * - Manifests from a newer projen (a higher `manifestVersion`) are accepted\n   *   with a warning, since this runtime may not understand the schema.\n   */\n  private verifyManifest(manifest: TasksManifest): void {\n    // Backwards compatibility: manifests generated before versioning carry no\n    // version.\n    if (manifest.manifestVersion === undefined) {\n      return;\n    }\n\n    if (manifest.manifestVersion > TASKS_MANIFEST_VERSION) {\n      logging.warn(\n        `${TaskRuntime.MANIFEST_FILE} was generated by a newer version of projen ` +\n          `(manifest version ${manifest.manifestVersion}, this projen supports up to ${TASKS_MANIFEST_VERSION}). ` +\n          `Some tasks may not behave as expected; consider upgrading projen.`,\n      );\n    }\n  }\n}\n\nclass RunTask {\n  private env: { [name: string]: string | undefined } = {};\n  private readonly parents: string[];\n\n  private readonly workdir: string;\n\n  constructor(\n    private readonly runtime: TaskRuntime,\n    private readonly task: TaskSpec,\n    parents: string[] = [],\n    private readonly args: Array<string | number> = [],\n    private readonly envParam: { [name: string]: string } = {},\n  ) {\n    this.workdir = task.cwd ?? this.runtime.workdir;\n    this.parents = parents;\n  }\n\n  /**\n   * Executes the task. This was previously done in the constructor, but is now\n   * an async method since shell execution is asynchronous (e.g. dax on\n   * Windows).\n   */\n  public async run(): Promise<void> {\n    const { task, args, parents } = this;\n\n    if (!task.steps || task.steps.length === 0) {\n      this.logDebug(gray(\"No actions have been specified for this task.\"));\n      return;\n    }\n\n    this.env = await this.resolveEnvironment(this.envParam, parents);\n\n    const envlogs = [];\n    for (const [k, v] of Object.entries(this.env)) {\n      const vv = v ?? \"\";\n      const trimmed =\n        vv.length > ENV_TRIM_LEN ? vv.substring(0, ENV_TRIM_LEN) + \"...\" : vv;\n      envlogs.push(`${k}=${trimmed}`);\n    }\n\n    if (envlogs.length) {\n      this.logDebug(gray(`${underline(\"env\")}: ${envlogs.join(\" \")}`));\n    }\n\n    // evaluate condition\n    if (!(await this.evalCondition(task))) {\n      this.log(\"condition exited with non-zero - skipping\");\n      return;\n    }\n\n    // verify we required environment variables are defined\n    const merged = { ...process.env, ...this.env };\n    const missing = new Array<string>();\n    for (const name of task.requiredEnv ?? []) {\n      if (!(name in merged)) {\n        missing.push(name);\n      }\n    }\n\n    if (missing.length > 0) {\n      throw new Error(\n        `missing required environment variables: ${missing.join(\",\")}`,\n      );\n    }\n\n    for (const step of task.steps) {\n      // evaluate step condition\n      if (!(await this.evalCondition(step))) {\n        this.log(\"condition exited with non-zero - skipping\");\n        continue;\n      }\n\n      const argsList: string[] = [\n        ...(step.args || []),\n        ...(step.receiveArgs ? args : []),\n      ].map((a) => a.toString());\n\n      if (step.say) {\n        logging.info(this.fmtLog(step.say));\n      }\n\n      if (step.spawn) {\n        await this.runtime.runTask(\n          step.spawn,\n          [...this.parents, this.task.name],\n          argsList,\n          step.env,\n        );\n      }\n\n      const execs = step.exec ? [step.exec] : [];\n\n      // Parse step-specific environment variables\n      const env = await this.evalEnvironment(step.env ?? {});\n\n      if (step.builtin) {\n        execs.push(this.renderBuiltin(step.builtin));\n      }\n\n      for (const exec of execs) {\n        let hasError = false;\n\n        let command = exec;\n\n        if (command.includes(QUOTED_ARGS_MARKER)) {\n          // Poorly imitate bash quoted variable expansion. If \"$@\" is encountered in bash, elements of the arg array\n          // that contain whitespace will be single quoted ('arg'). This preserves whitespace in things like filenames.\n          // Imitate that behavior here by single quoting every element of the arg array when a quoted arg marker (\"$@\")\n          // is encountered.\n          command = command.replace(\n            QUOTED_ARGS_MARKER,\n            argsList.map((arg) => `'${arg}'`).join(\" \"),\n          );\n        } else if (command.includes(ARGS_MARKER)) {\n          command = command.replace(ARGS_MARKER, argsList.join(\" \"));\n        } else {\n          command = [command, ...argsList].join(\" \");\n        }\n\n        const cwd = step.cwd;\n        try {\n          const result = await this.shell({\n            command,\n            cwd,\n            extraEnv: env,\n          });\n          hasError = result.status !== 0;\n        } catch (e) {\n          // a non-zero exit code is reported via `result.status` above; this\n          // catch handles errors thrown while attempting to spawn the command.\n          if ((e as any)?.message?.startsWith(\"non-zero exit code:\")) {\n            hasError = true;\n          }\n          throw e;\n        }\n        if (hasError) {\n          throw new Error(\n            `Task \"${\n              this.fullname\n            }\" failed when executing \"${command}\" (cwd: ${resolve(\n              cwd ?? this.workdir,\n            )})`,\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Determines if a task should be executed based on \"condition\".\n   *\n   * @returns true if the task should be executed or false if the condition\n   * evaluates to false (exits with non-zero), indicating that the task should\n   * be skipped.\n   */\n  private async evalCondition(taskOrStep: TaskSpec | TaskStep) {\n    // no condition, carry on\n    if (!taskOrStep.condition) {\n      return true;\n    }\n\n    this.log(gray(`${underline(\"condition\")}: ${taskOrStep.condition}`));\n    const result = await this.shell({\n      command: taskOrStep.condition,\n      logprefix: \"condition: \",\n      quiet: true,\n    });\n    if (result.status === 0) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Evaluates environment variables from shell commands (e.g. `$(xx)`)\n   */\n  private async evalEnvironment(env: { [name: string]: string }) {\n    const output: { [name: string]: string | undefined } = {};\n\n    for (const [key, value] of Object.entries(env ?? {})) {\n      if (String(value).startsWith(\"$(\") && String(value).endsWith(\")\")) {\n        const query = value.substring(2, value.length - 1);\n        const result = await this.shellEval({ command: query });\n        if (result.status !== 0) {\n          const error = result.error\n            ? result.error.stack\n            : result.stderr?.toString().trim() ||\n              result.stdout?.toString().trim() ||\n              `command exited with code ${result.status}`;\n\n          logging.warn(\n            this.fmtLog(\n              `${underline(key)}: unable to evaluate \"${query}\". Environment variable will be skipped. Check that the command exists and runs successfully.`,\n            ),\n          );\n          logging.warn(this.fmtLog(`${underline(key)}: ${error}`));\n        } else {\n          output[key] = result.stdout?.toString(\"utf-8\").trim() ?? \"\";\n        }\n      } else {\n        output[key] = value;\n      }\n    }\n    return output;\n  }\n\n  /**\n   * Renders the runtime environment for a task. Namely, it supports this syntax\n   * `$(xx)` for allowing environment to be evaluated by executing a shell\n   * command and obtaining its result.\n   */\n  private async resolveEnvironment(\n    envParam: { [name: string]: string },\n    parents: string[],\n  ) {\n    let env = this.runtime.manifest.env ?? {};\n\n    // add env from all parent tasks one by one\n    for (const parent of parents) {\n      env = {\n        ...env,\n        ...(this.runtime.tryFindTask(parent)?.env ?? {}),\n      };\n    }\n\n    // apply task environment, then the specific env last\n    env = {\n      ...env,\n      ...(this.task.env ?? {}),\n      ...envParam,\n    };\n\n    return this.evalEnvironment(env ?? {});\n  }\n\n  /**\n   * Returns the \"full name\" of the task which includes all it's parent task names concatenated by chevrons.\n   */\n  private get fullname() {\n    return [...this.parents, this.task.name].join(\" » \");\n  }\n\n  private log(...args: any[]) {\n    logging.verbose(this.fmtLog(...args));\n  }\n\n  private logDebug(...args: any[]) {\n    logging.debug(this.fmtLog(...args));\n  }\n\n  private fmtLog(...args: any[]) {\n    return format(`${underline(this.fullname)} |`, ...args);\n  }\n\n  private async shell(options: ShellOptions): Promise<ShellResult> {\n    const quiet = options.quiet ?? false;\n    if (!quiet) {\n      const log = new Array<string>();\n\n      if (options.logprefix) {\n        log.push(options.logprefix);\n      }\n\n      log.push(options.command);\n\n      if (options.cwd) {\n        log.push(`(cwd: ${options.cwd})`);\n      }\n\n      this.log(log.join(\" \"));\n    }\n\n    const cwd = options.cwd ?? this.workdir;\n    if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {\n      throw new Error(\n        `invalid workdir (cwd): ${cwd} must be an existing directory`,\n      );\n    }\n\n    const env = {\n      ...process.env,\n      ...this.env,\n      ...options.extraEnv,\n    };\n\n    // On Windows the default shell (cmd.exe) does not understand the POSIX-style\n    // commands projen tasks are written in (`cat`, `cp`, `mkdir -p`, `rm -rf`,\n    // `&&` chains, `$VAR`, ...). Run the command through dax's cross-platform\n    // shell instead, which ships built-in implementations of the common\n    // commands. Now that the task runtime is asynchronous we can drive dax's\n    // `$` API directly instead of spawning a synchronous child node process.\n    if (process.platform === \"win32\") {\n      // stdout/stderr are only captured when a caller pipes them (e.g.\n      // `shellEval`); otherwise inherit so output is streamed to the terminal.\n      const capture = Array.isArray(options.spawnOptions?.stdio);\n\n      const result = await $.raw`${options.command}`\n        .cwd(cwd)\n        .env(env)\n        .stdout(capture ? \"piped\" : \"inherit\")\n        .stderr(capture ? \"piped\" : \"inherit\")\n        .noThrow();\n\n      return {\n        status: result.code,\n        stdout: capture ? Buffer.from(result.stdoutBytes) : null,\n        stderr: capture ? Buffer.from(result.stderrBytes) : null,\n      };\n    }\n\n    return spawnSync(options.command, {\n      ...options,\n      cwd,\n      shell: true,\n      stdio: \"inherit\",\n      env,\n      ...options.spawnOptions,\n    });\n  }\n\n  private async shellEval(options: ShellOptions): Promise<ShellResult> {\n    return this.shell({\n      quiet: true,\n      ...options,\n      spawnOptions: {\n        stdio: [\"inherit\", \"pipe\", \"pipe\"],\n      },\n    });\n  }\n\n  private renderBuiltin(builtin: string) {\n    // Locate projen's package root by walking up from this module's directory\n    // until we find a package.json. This works whether the code runs from the\n    // compiled file (lib/cli/task-runtime.js) or from the bundled run-task.cjs\n    // (lib/run-task.cjs), which live at different depths - so a hard-coded\n    // relative path to package.json would be wrong in one of the two cases.\n    let moduleRoot = __dirname;\n    while (!existsSync(join(moduleRoot, \"package.json\"))) {\n      const parent = dirname(moduleRoot);\n      if (parent === moduleRoot) {\n        throw new Error(\"unable to locate the projen package root\");\n      }\n      moduleRoot = parent;\n    }\n    const program = require.resolve(\n      join(moduleRoot, \"lib\", `${builtin}.task.js`),\n    );\n    return `\"${process.execPath}\" \"${program}\"`;\n  }\n}\n\ninterface ShellOptions {\n  readonly command: string;\n  /**\n   * @default - project dir\n   */\n  readonly cwd?: string;\n  readonly logprefix?: string;\n  readonly spawnOptions?: SpawnOptions;\n  /** @default false */\n  readonly quiet?: boolean;\n  readonly extraEnv?: { [name: string]: string | undefined };\n}\n"]}

package/lib/cli/util.js

@@ -1,12 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliError = void 0;
 exports.installPackage = installPackage;
 exports.renderInstallCommand = renderInstallCommand;
 exports.findJsiiFilePath = findJsiiFilePath;
-const fs = require("fs");
-const path = require("path");
-const logging = require("../logging");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logging = __importStar(require("../logging"));
 const util_1 = require("../util");
 /**
  * Installs the npm module (through `npm install`) to node_modules under `projectDir`.
@@ -79,4 +112,4 @@ class CliError extends Error {
     }
 }
 exports.CliError = CliError;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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