@cdktn/commons 0.24.0-pre.26 → 0.24.0-pre.28

package/build/util.d.ts

@@ -2,11 +2,42 @@
 /// <reference types="node/child_process" />
 import { SpawnOptions } from "child_process";
 import { IManifest } from "cdktn";
+/**
+ * Spawn a child process and mirror its stdout to the parent's console.
+ *
+ * Thin wrapper over {@link exec} for callers that want stdout chunks echoed via `console.log` as they arrive. Stderr is
+ * captured silently and surfaced on the thrown Error's `.stderr` / `toString()` if the process exits non-zero.
+ *
+ * @param program the executable to spawn
+ * @param args arguments passed to the executable
+ * @param options spawn options; `noColor: true` strips ANSI escapes from captured output
+ * @returns the full concatenated stdout as a string on success
+ * @throws an Error with `.stderr` and `.stdout` properties (see {@link attachProcessOutput}) on non-zero exit
+ */
 export declare function shell(program: string, args?: string[], options?: SpawnOptions & {
     noColor?: boolean;
 }): Promise<string>;
 export declare function withTempDir(dirname: string, closure: () => Promise<void>): Promise<void>;
 export declare function mkdtemp(closure: (dir: string) => Promise<void>): Promise<void>;
+/**
+ * Spawn a child process and resolve with its stdout, or reject with a decorated Error on non-zero exit.
+ *
+ * Captured stdout and stderr are always tee'd to `processLoggerDebug` / `processLoggerError`. The optional `stdout` and
+ * `stderr` callbacks receive each sanitized chunk as it arrives — useful for streaming output to the terminal.
+ * Passing a `stderr` callback (even a no-op) suppresses the default pass-through to `process.stderr` for that stream.
+ *
+ * On non-zero exit, rejects with an {@link ExecError} carrying `.stderr` / `.stdout` and a `toString()` that includes
+ * the captured body (see {@link attachProcessOutput}); `.message` itself stays as the headline.
+ *
+ * @param command the executable to spawn
+ * @param args arguments passed to the executable
+ * @param options spawn options; `noColor: true` strips ANSI escapes from captured output (auto-detected from CLI flags
+ *  / `FORCE_COLOR=0` when omitted)
+ * @param stdout optional per-chunk callback for sanitized stdout
+ * @param stderr optional per-chunk callback for sanitized stderr; passing a callback suppresses default terminal echo
+ * @param sendToStderr when false, suppresses both the stderr callback invocation and the default terminal echo
+ * @returns the full concatenated stdout as a string on success
+ */
 export declare const exec: (command: string, args: string[], options: SpawnOptions & {
     noColor?: boolean;
 }, stdout?: (chunk: string) => any, stderr?: (chunk: string | Uint8Array) => any, sendToStderr?: boolean) => Promise<string>;

package/build/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAO7C,OAAO,EAAE,SAAS,EAAY,MAAM,OAAO,CAAC;AAI5C,wBAAsB,KAAK,CACzB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,MAAM,EAAO,EACnB,OAAO,GAAE,YAAY,GAAG;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,mBAsCnD;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,iBAa7B;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,iBAOpE;AAED,eAAO,MAAM,IAAI,YACN,MAAM,QACT,MAAM,EAAE,WACL,YAAY,GAAG;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,WACpC,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,WACtB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,GAAG,6BAE3C,QAAQ,MAAM,CA8DhB,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASzE;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,SAAS,CAAC,CAI5D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED,qBAAa,SAAU,SAAQ,KAAK;IAGzB,UAAU,CAAC;gBADlB,OAAO,CAAC,EAAE,MAAM,EACT,UAAU,CAAC,oBAAQ;CAM7B;AAED,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED;;;;;GAKG;AACH,wBAAsB,8BAA8B,CAClD,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EACf,QAAQ,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,EAAE,iBAUvC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAO7C,OAAO,EAAE,SAAS,EAAY,MAAM,OAAO,CAAC;AAmC5C;;;;;;;;;;;GAWG;AACH,wBAAsB,KAAK,CACzB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,MAAM,EAAO,EACnB,OAAO,GAAE,YAAY,GAAG;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,mBAkBnD;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,iBAa7B;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,iBAOpE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,YACN,MAAM,QACT,MAAM,EAAE,WACL,YAAY,GAAG;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,WACpC,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,WACtB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,GAAG,6BAE3C,QAAQ,MAAM,CAgEhB,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASzE;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,SAAS,CAAC,CAI5D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED,qBAAa,SAAU,SAAQ,KAAK;IAGzB,UAAU,CAAC;gBADlB,OAAO,CAAC,EAAE,MAAM,EACT,UAAU,CAAC,oBAAQ;CAM7B;AAED,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED;;;;;GAKG;AACH,wBAAsB,8BAA8B,CAClD,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EACf,QAAQ,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,EAAE,iBAUvC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C"}

package/build/util.js

@@ -36,39 +36,54 @@ const logging_1 = require("./logging");
 const cdktn_1 = require("cdktn");
 const config = __importStar(require("./config"));
 const strip_ansi_1 = __importDefault(require("strip-ansi"));
-async function shell(program, args = [], options = {}) {
-    const stderr = new Array();
-    const stdout = new Array();
-    try {
-        return await (0, exports.exec)(program, args, options, (chunk) => {
-            const sanitizedChunk = options.noColor
-                ? (0, strip_ansi_1.default)(chunk.toLocaleString())
-                : chunk.toLocaleString();
-            stdout.push(sanitizedChunk);
-            console.log(sanitizedChunk);
-        }, (chunk) => {
-            const sanitizedChunk = options.noColor
-                ? (0, strip_ansi_1.default)(chunk.toLocaleString())
-                : chunk.toLocaleString();
-            stderr.push(sanitizedChunk);
-        });
-    }
-    catch (e) {
-        if (stderr.length > 0) {
-            e.stderr = stderr.map((chunk) => chunk.toString()).join("");
-            if (options.noColor) {
-                e.stderr = (0, strip_ansi_1.default)(e.stderr);
-            }
-        }
-        if (stdout.length > 0) {
-            e.stdout = stdout.join("");
-            if (options.noColor) {
-                e.stdout = (0, strip_ansi_1.default)(e.stdout);
-            }
-        }
-        throw e;
+/**
+ * Attach captured stderr/stdout to a process-failure Error.
+ *
+ * The body text is exposed two ways:
+ * - `.stderr` and `.stdout` properties, for callers that render the streams separately (e.g. synth-stack's chalk
+ *   formatting).
+ * - A `toString()` override that appends the body after the headline, so callers using `${e}` interpolation surface the
+ *   underlying tool output without double-printing for the property-reading callers.
+ *
+ * The Error's `.message` is left untouched as the headline only.
+ *
+ * @param error the Error to decorate (its `.message` becomes the toString headline)
+ * @param stderrText captured stderr, may be empty
+ * @param stdoutText captured stdout, may be empty
+ */
+function attachProcessOutput(error, stderrText, stdoutText) {
+    error.stderr = stderrText;
+    error.stdout = stdoutText;
+    const body = [stderrText, stdoutText].filter(Boolean).join("\n");
+    if (body) {
+        const headline = error.message;
+        error.toString = () => `Error: ${headline}\n${body}`;
     }
 }
+/**
+ * Spawn a child process and mirror its stdout to the parent's console.
+ *
+ * Thin wrapper over {@link exec} for callers that want stdout chunks echoed via `console.log` as they arrive. Stderr is
+ * captured silently and surfaced on the thrown Error's `.stderr` / `toString()` if the process exits non-zero.
+ *
+ * @param program the executable to spawn
+ * @param args arguments passed to the executable
+ * @param options spawn options; `noColor: true` strips ANSI escapes from captured output
+ * @returns the full concatenated stdout as a string on success
+ * @throws an Error with `.stderr` and `.stdout` properties (see {@link attachProcessOutput}) on non-zero exit
+ */
+async function shell(program, args = [], options = {}) {
+    return (0, exports.exec)(program, args, options, (chunk) => {
+        const sanitizedChunk = options.noColor
+            ? (0, strip_ansi_1.default)(chunk.toLocaleString())
+            : chunk.toLocaleString();
+        console.log(sanitizedChunk);
+    }, () => {
+        // No-op: passing a callback (vs. undefined) suppresses exec()'s default
+        // pass-through to process.stderr; inner exec() still collects it for
+        // the thrown error's .stderr field.
+    });
+}
 exports.shell = shell;
 async function withTempDir(dirname, closure) {
     const prevdir = process.cwd();
@@ -95,6 +110,25 @@ async function mkdtemp(closure) {
     }
 }
 exports.mkdtemp = mkdtemp;
+/**
+ * Spawn a child process and resolve with its stdout, or reject with a decorated Error on non-zero exit.
+ *
+ * Captured stdout and stderr are always tee'd to `processLoggerDebug` / `processLoggerError`. The optional `stdout` and
+ * `stderr` callbacks receive each sanitized chunk as it arrives — useful for streaming output to the terminal.
+ * Passing a `stderr` callback (even a no-op) suppresses the default pass-through to `process.stderr` for that stream.
+ *
+ * On non-zero exit, rejects with an {@link ExecError} carrying `.stderr` / `.stdout` and a `toString()` that includes
+ * the captured body (see {@link attachProcessOutput}); `.message` itself stays as the headline.
+ *
+ * @param command the executable to spawn
+ * @param args arguments passed to the executable
+ * @param options spawn options; `noColor: true` strips ANSI escapes from captured output (auto-detected from CLI flags
+ *  / `FORCE_COLOR=0` when omitted)
+ * @param stdout optional per-chunk callback for sanitized stdout
+ * @param stderr optional per-chunk callback for sanitized stderr; passing a callback suppresses default terminal echo
+ * @param sendToStderr when false, suppresses both the stderr callback invocation and the default terminal echo
+ * @returns the full concatenated stdout as a string on success
+ */
 const exec = async (command, args, options, stdout, stderr, sendToStderr = true) => {
     // if options.noColor is not set, checking the flags & environment if it should be set
     // This is required for collectDebugInformation() which does not have knowledge about flags
@@ -152,8 +186,8 @@ const exec = async (command, args, options, stdout, stderr, sendToStderr = true)
         child.once("error", (err) => ko(err));
         child.once("close", (code) => {
             if (code !== 0) {
-                const error = new Error(`non-zero exit code ${code}`);
-                error.stderr = err.map((chunk) => chunk.toString()).join("");
+                const error = new Error(`${command} ${args.join(" ")} exited with code ${code}`);
+                attachProcessOutput(error, err.join(""), out.join(""));
                 return ko(error);
             }
             return ok(out.join(""));
@@ -259,4 +293,4 @@ function hasFlag(flag) {
     return (position !== -1 &&
         (terminatorPosition === -1 || position < terminatorPosition));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,6CAAoC;AACpC,6CAA+B;AAC/B,uDAA+C;AAC/C,uCAAyB;AACzB,2CAA6B;AAC7B,uCAAmE;AACnE,iCAA4C;AAC5C,iDAAmC;AACnC,4DAAmC;AAE5B,KAAK,UAAU,KAAK,CACzB,OAAe,EACf,OAAiB,EAAE,EACnB,UAAgD,EAAE;IAElD,MAAM,MAAM,GAAG,IAAI,KAAK,EAAuB,CAAC;IAChD,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;IACnC,IAAI,CAAC;QACH,OAAO,MAAM,IAAA,YAAI,EACf,OAAO,EACP,IAAI,EACJ,OAAO,EACP,CAAC,KAAa,EAAE,EAAE;YAChB,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO;gBACpC,CAAC,CAAC,IAAA,oBAAS,EAAC,KAAK,CAAC,cAAc,EAAE,CAAC;gBACnC,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAC5B,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC9B,CAAC,EACD,CAAC,KAA0B,EAAE,EAAE;YAC7B,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO;gBACpC,CAAC,CAAC,IAAA,oBAAS,EAAC,KAAK,CAAC,cAAc,EAAE,CAAC;gBACnC,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC9B,CAAC,CACF,CAAC;IACJ,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC5D,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;gBACpB,CAAC,CAAC,MAAM,GAAG,IAAA,oBAAS,EAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC3B,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;gBACpB,CAAC,CAAC,MAAM,GAAG,IAAA,oBAAS,EAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QACD,MAAM,CAAC,CAAC;IACV,CAAC;AACH,CAAC;AAzCD,sBAyCC;AAEM,KAAK,UAAU,WAAW,CAC/B,OAAe,EACf,OAA4B;IAE5B,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAC9B,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,MAAM,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzB,IAAI,CAAC;QACH,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvB,MAAM,OAAO,EAAE,CAAC;IAClB,CAAC;YAAS,CAAC;QACT,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvB,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;AACH,CAAC;AAfD,kCAeC;AAEM,KAAK,UAAU,OAAO,CAAC,OAAuC;IACnE,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;IACnE,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;YAAS,CAAC;QACT,MAAM,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;AACH,CAAC;AAPD,0BAOC;AAEM,MAAM,IAAI,GAAG,KAAK,EACvB,OAAe,EACf,IAAc,EACd,OAA6C,EAC7C,MAA+B,EAC/B,MAA4C,EAC5C,YAAY,GAAG,IAAI,EACF,EAAE;IACnB,sFAAsF;IACtF,2FAA2F;IAC3F,IAAI,OAAO,OAAO,CAAC,OAAO,KAAK,SAAS,IAAI,mBAAmB,EAAE,EAAE,CAAC;QAClE,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IACzB,CAAC;IAED,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;;QAC5B,MAAM,KAAK,GAAG,IAAA,mBAAK,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC5C,MAAM,GAAG,GAAG,IAAI,KAAK,EAAU,CAAC;QAChC,MAAM,GAAG,GAAG,IAAI,KAAK,EAAU,CAAC;QAChC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAA,KAAK,CAAC,MAAM,0CAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE;gBACzC,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO;oBACpC,CAAC,CAAC,IAAA,oBAAS,EAAC,KAAK,CAAC,cAAc,EAAE,CAAC;oBACnC,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;gBAC3B,IAAA,4BAAkB,EAAC,cAAc,CAAC,CAAC;gBACnC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBACzB,MAAM,CAAC,cAAc,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAA,KAAK,CAAC,MAAM,0CAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE;gBACzC,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO;oBACpC,CAAC,CAAC,IAAA,oBAAS,EAAC,KAAK,CAAC,cAAc,EAAE,CAAC;oBACnC,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;gBAC3B,IAAA,4BAAkB,EAAC,cAAc,CAAC,CAAC;gBACnC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAC3B,CAAC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAA,KAAK,CAAC,MAAM,0CAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAA0B,EAAE,EAAE;gBACtD,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO;oBACpC,CAAC,CAAC,IAAA,oBAAS,EAAC,KAAK,CAAC,cAAc,EAAE,CAAC;oBACnC,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;gBAC3B,IAAA,4BAAkB,EAAC,cAAc,CAAC,CAAC;gBACnC,IAAI,YAAY,EAAE,CAAC;oBACjB,MAAM,CAAC,cAAc,CAAC,CAAC;gBACzB,CAAC;gBACD,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAC3B,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAA,KAAK,CAAC,MAAM,0CAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAA0B,EAAE,EAAE;gBACtD,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO;oBACpC,CAAC,CAAC,IAAA,oBAAS,EAAC,KAAK,CAAC,cAAc,EAAE,CAAC;oBACnC,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;gBAC3B,IAAA,4BAAkB,EAAC,cAAc,CAAC,CAAC;gBACnC,IAAI,YAAY,EAAE,CAAC;oBACjB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;gBACvC,CAAC;gBACD,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAC3B,CAAC,CAAC,CAAC;QACL,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAQ,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3C,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,IAAY,EAAE,EAAE;YACnC,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;gBACf,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,sBAAsB,IAAI,EAAE,CAAC,CAAC;gBACrD,KAAa,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBACtE,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC;YACD,OAAO,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AArEW,QAAA,IAAI,QAqEf;AAEK,KAAK,UAAU,gBAAgB,CAAC,SAAiB;IACtD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;IACvD,IAAI,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAC9B,MAAM,UAAU,GAAG,EAAE,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QACvD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;IACrC,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC;AATD,4CASC;AAEM,KAAK,UAAU,iBAAiB;IACrC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,cAAc,EAAE,CAAC;IAC3C,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACrE,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAc,CAAC;AAClD,CAAC;AAJD,8CAIC;AAED;;;;GAIG;AACH,SAAgB,aAAa,CAAC,GAAW;IACvC,IAAI,GAAG,KAAK,EAAE,EAAE,CAAC;QACf,OAAO,GAAG,CAAC;IACb,CAAC;IACD,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACxD,CAAC;AALD,sCAKC;AAED,MAAa,SAAU,SAAQ,KAAK;IAClC,YACE,OAAgB,EACT,UAAmB;QAE1B,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,sCAAsC;QAF/C,eAAU,GAAV,UAAU,CAAS;QAG1B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,0BAA0B;QAC7E,4GAA4G;IAC9G,CAAC;CACF;AATD,8BASC;AAEM,KAAK,UAAU,YAAY,CAChC,GAAW,EACX,cAAsB;IAEtB,4EAA4E;IAC5E,uEAAuE;IACvE,kEAAkE;IAClE,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,uBAAI,CAAC,CAAC,CAAC,wBAAK,CAAgB,CAAC;IACzE,MAAM,IAAI,GAAG,EAAE,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAClD,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;QAC5B,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,EAAE;YAC3C,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAChC,EAAE,CACA,IAAI,SAAS,CACX,kBAAkB,GAAG,MAAM,QAAQ,CAAC,UAAU,GAAG,EACjD,QAAQ,CAAC,UAAU,CACpB,CACF,CAAC;gBACF,OAAO;YACT,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAE9B,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAU,EAAE,EAAE;YACjC,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;YACvB,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,GAAG,EAAE,CAAC;IAChB,CAAC,CAAC,CAAC;AACL,CAAC;AAnCD,oCAmCC;AAED;;;;;GAKG;AACI,KAAK,UAAU,8BAA8B,CAClD,CAAe,EACf,QAAsC;IAEtC,IAAI,CAAC;QACH,MAAM,CAAC,CAAC;IACV,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,0EAA0E;QAC1E,0EAA0E;QAC1E,MAAM,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QACnC,MAAM,CAAC,CAAC;IACV,CAAC;AACH,CAAC;AAZD,wEAYC;AAED;;;;GAIG;AACH,SAAgB,mBAAmB;IACjC,OAAO,OAAO,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,KAAK,GAAG,CAAC;AAChE,CAAC;AAFD,kDAEC;AAED,oEAAoE;AACpE,4CAA4C;AAC5C,SAAS,OAAO,CAAC,IAAY;IAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1E,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrD,MAAM,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,OAAO,CACL,QAAQ,KAAK,CAAC,CAAC;QACf,CAAC,kBAAkB,KAAK,CAAC,CAAC,IAAI,QAAQ,GAAG,kBAAkB,CAAC,CAC7D,CAAC;AACJ,CAAC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { SpawnOptions } from \"child_process\";\nimport { spawn } from \"cross-spawn\";\nimport * as fs from \"fs-extra\";\nimport { https, http } from \"follow-redirects\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport { processLoggerError, processLoggerDebug } from \"./logging\";\nimport { IManifest, Manifest } from \"cdktn\";\nimport * as config from \"./config\";\nimport stripAnsi from \"strip-ansi\";\n\nexport async function shell(\n  program: string,\n  args: string[] = [],\n  options: SpawnOptions & { noColor?: boolean } = {},\n) {\n  const stderr = new Array<string | Uint8Array>();\n  const stdout = new Array<string>();\n  try {\n    return await exec(\n      program,\n      args,\n      options,\n      (chunk: string) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        stdout.push(sanitizedChunk);\n        console.log(sanitizedChunk);\n      },\n      (chunk: string | Uint8Array) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        stderr.push(sanitizedChunk);\n      },\n    );\n  } catch (e: any) {\n    if (stderr.length > 0) {\n      e.stderr = stderr.map((chunk) => chunk.toString()).join(\"\");\n      if (options.noColor) {\n        e.stderr = stripAnsi(e.stderr);\n      }\n    }\n    if (stdout.length > 0) {\n      e.stdout = stdout.join(\"\");\n      if (options.noColor) {\n        e.stdout = stripAnsi(e.stdout);\n      }\n    }\n    throw e;\n  }\n}\n\nexport async function withTempDir(\n  dirname: string,\n  closure: () => Promise<void>,\n) {\n  const prevdir = process.cwd();\n  const parent = await fs.mkdtemp(path.join(os.tmpdir(), \"cdktf.\"));\n  const workdir = path.join(parent, dirname);\n  await fs.mkdirp(workdir);\n  try {\n    process.chdir(workdir);\n    await closure();\n  } finally {\n    process.chdir(prevdir);\n    await fs.remove(parent);\n  }\n}\n\nexport async function mkdtemp(closure: (dir: string) => Promise<void>) {\n  const workdir = await fs.mkdtemp(path.join(os.tmpdir(), \"cdktf.\"));\n  try {\n    await closure(workdir);\n  } finally {\n    await fs.remove(workdir);\n  }\n}\n\nexport const exec = async (\n  command: string,\n  args: string[],\n  options: SpawnOptions & { noColor?: boolean },\n  stdout?: (chunk: string) => any,\n  stderr?: (chunk: string | Uint8Array) => any,\n  sendToStderr = true,\n): Promise<string> => {\n  // if options.noColor is not set, checking the flags & environment if it should be set\n  // This is required for collectDebugInformation() which does not have knowledge about flags\n  if (typeof options.noColor !== \"boolean\" && hasNoColorFlagOrEnv()) {\n    options.noColor = true;\n  }\n\n  return new Promise((ok, ko) => {\n    const child = spawn(command, args, options);\n    const out = new Array<string>();\n    const err = new Array<string>();\n    if (stdout !== undefined) {\n      child.stdout?.on(\"data\", (chunk: Buffer) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerDebug(sanitizedChunk);\n        out.push(sanitizedChunk);\n        stdout(sanitizedChunk);\n      });\n    } else {\n      child.stdout?.on(\"data\", (chunk: Buffer) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerDebug(sanitizedChunk);\n        out.push(sanitizedChunk);\n      });\n    }\n    if (stderr !== undefined) {\n      child.stderr?.on(\"data\", (chunk: string | Uint8Array) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerError(sanitizedChunk);\n        if (sendToStderr) {\n          stderr(sanitizedChunk);\n        }\n        err.push(sanitizedChunk);\n      });\n    } else {\n      child.stderr?.on(\"data\", (chunk: string | Uint8Array) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerError(sanitizedChunk);\n        if (sendToStderr) {\n          process.stderr.write(sanitizedChunk);\n        }\n        err.push(sanitizedChunk);\n      });\n    }\n    child.once(\"error\", (err: any) => ko(err));\n    child.once(\"close\", (code: number) => {\n      if (code !== 0) {\n        const error = new Error(`non-zero exit code ${code}`);\n        (error as any).stderr = err.map((chunk) => chunk.toString()).join(\"\");\n        return ko(error);\n      }\n      return ok(out.join(\"\"));\n    });\n  });\n};\n\nexport async function readCDKTFVersion(outputDir: string): Promise<string> {\n  const outputFile = path.join(outputDir, \"cdk.tf.json\");\n  if (fs.existsSync(outputFile)) {\n    const outputJSON = fs.readFileSync(outputFile, \"utf8\");\n    const data = JSON.parse(outputJSON);\n    return data[\"//\"].metadata.version;\n  }\n\n  return \"\";\n}\n\nexport async function readCDKTFManifest(): Promise<IManifest> {\n  const { output } = config.readConfigSync();\n  const json = await fs.readFile(path.join(output, Manifest.fileName));\n  return JSON.parse(json.toString()) as IManifest;\n}\n\n/**\n * Downcase the first character in a string.\n *\n * @param str the string to be processed.\n */\nexport function downcaseFirst(str: string): string {\n  if (str === \"\") {\n    return str;\n  }\n  return `${str[0].toLocaleLowerCase()}${str.slice(1)}`;\n}\n\nexport class HttpError extends Error {\n  constructor(\n    message?: string,\n    public statusCode?: number,\n  ) {\n    super(message); // 'Error' breaks prototype chain here\n    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain\n    // see: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget\n  }\n}\n\nexport async function downloadFile(\n  url: string,\n  targetFilename: string,\n): Promise<void> {\n  // if the type is inferred to be \"http|https\" calling .get() is not possible\n  // because the options parameter (which we don't use anyway) for get is\n  // not compatible between http and https -> so we treat it as http\n  const client = (url.startsWith(\"http://\") ? http : https) as typeof http;\n  const file = fs.createWriteStream(targetFilename);\n  return new Promise((ok, ko) => {\n    const request = client.get(url, (response) => {\n      if (response.statusCode !== 200) {\n        ko(\n          new HttpError(\n            `Failed to get '${url}' (${response.statusCode})`,\n            response.statusCode,\n          ),\n        );\n        return;\n      }\n      response.pipe(file);\n    });\n\n    file.on(\"finish\", () => ok());\n\n    request.on(\"error\", (err: Error) => {\n      fs.unlink(targetFilename, () => ko(err));\n    });\n\n    file.on(\"error\", (err) => {\n      fs.unlink(targetFilename, () => ko(err));\n    });\n\n    request.end();\n  });\n}\n\n/**\n * Awaits a promise and makes sure it's error (if any) is only thrown after all other promises are settled\n * if the promise does not throw an error, the other promises won't be awaited\n * @param p promise to await\n * @param promises promises to await to be all settled if p failed before throwing error that p failed with\n */\nexport async function ensureAllSettledBeforeThrowing(\n  p: Promise<any>,\n  promises: (Promise<any> | undefined)[],\n) {\n  try {\n    await p;\n  } catch (e) {\n    // if an error happened, we still need to wait for all other promises that\n    // are currently in progress to complete to allow them to properly wrap up\n    await Promise.allSettled(promises);\n    throw e;\n  }\n}\n\n/**\n * returns true if --no-color is passed as CLI flag or the env var FORCE_COLOR is set to \"0\"\n * Used for cases where we can't pass down the noColor flag (e.g. when collecting debug information from the environment)\n * This is the same behavior as the `chalk` lib we use for coloring output\n */\nexport function hasNoColorFlagOrEnv(): boolean {\n  return hasFlag(\"no-color\") || process.env.FORCE_COLOR === \"0\";\n}\n\n// From: https://github.com/sindresorhus/has-flag/blob/main/index.js\n// as used in https://github.com/chalk/chalk\nfunction hasFlag(flag: string) {\n  const prefix = flag.startsWith(\"-\") ? \"\" : flag.length === 1 ? \"-\" : \"--\";\n  const position = process.argv.indexOf(prefix + flag);\n  const terminatorPosition = process.argv.indexOf(\"--\");\n  return (\n    position !== -1 &&\n    (terminatorPosition === -1 || position < terminatorPosition)\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { SpawnOptions } from \"child_process\";\nimport { spawn } from \"cross-spawn\";\nimport * as fs from \"fs-extra\";\nimport { https, http } from \"follow-redirects\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport { processLoggerError, processLoggerDebug } from \"./logging\";\nimport { IManifest, Manifest } from \"cdktn\";\nimport * as config from \"./config\";\nimport stripAnsi from \"strip-ansi\";\n\ntype ExecError = Error & { stderr: string; stdout: string };\n\n/**\n * Attach captured stderr/stdout to a process-failure Error.\n *\n * The body text is exposed two ways:\n * - `.stderr` and `.stdout` properties, for callers that render the streams separately (e.g. synth-stack's chalk\n *   formatting).\n * - A `toString()` override that appends the body after the headline, so callers using `${e}` interpolation surface the\n *   underlying tool output without double-printing for the property-reading callers.\n *\n * The Error's `.message` is left untouched as the headline only.\n *\n * @param error the Error to decorate (its `.message` becomes the toString headline)\n * @param stderrText captured stderr, may be empty\n * @param stdoutText captured stdout, may be empty\n */\nfunction attachProcessOutput(\n  error: Error,\n  stderrText: string,\n  stdoutText: string,\n): asserts error is ExecError {\n  (error as ExecError).stderr = stderrText;\n  (error as ExecError).stdout = stdoutText;\n  const body = [stderrText, stdoutText].filter(Boolean).join(\"\\n\");\n  if (body) {\n    const headline = error.message;\n    error.toString = () => `Error: ${headline}\\n${body}`;\n  }\n}\n\n/**\n * Spawn a child process and mirror its stdout to the parent's console.\n *\n * Thin wrapper over {@link exec} for callers that want stdout chunks echoed via `console.log` as they arrive. Stderr is\n * captured silently and surfaced on the thrown Error's `.stderr` / `toString()` if the process exits non-zero.\n *\n * @param program the executable to spawn\n * @param args arguments passed to the executable\n * @param options spawn options; `noColor: true` strips ANSI escapes from captured output\n * @returns the full concatenated stdout as a string on success\n * @throws an Error with `.stderr` and `.stdout` properties (see {@link attachProcessOutput}) on non-zero exit\n */\nexport async function shell(\n  program: string,\n  args: string[] = [],\n  options: SpawnOptions & { noColor?: boolean } = {},\n) {\n  return exec(\n    program,\n    args,\n    options,\n    (chunk: string) => {\n      const sanitizedChunk = options.noColor\n        ? stripAnsi(chunk.toLocaleString())\n        : chunk.toLocaleString();\n      console.log(sanitizedChunk);\n    },\n    () => {\n      // No-op: passing a callback (vs. undefined) suppresses exec()'s default\n      // pass-through to process.stderr; inner exec() still collects it for\n      // the thrown error's .stderr field.\n    },\n  );\n}\n\nexport async function withTempDir(\n  dirname: string,\n  closure: () => Promise<void>,\n) {\n  const prevdir = process.cwd();\n  const parent = await fs.mkdtemp(path.join(os.tmpdir(), \"cdktf.\"));\n  const workdir = path.join(parent, dirname);\n  await fs.mkdirp(workdir);\n  try {\n    process.chdir(workdir);\n    await closure();\n  } finally {\n    process.chdir(prevdir);\n    await fs.remove(parent);\n  }\n}\n\nexport async function mkdtemp(closure: (dir: string) => Promise<void>) {\n  const workdir = await fs.mkdtemp(path.join(os.tmpdir(), \"cdktf.\"));\n  try {\n    await closure(workdir);\n  } finally {\n    await fs.remove(workdir);\n  }\n}\n\n/**\n * Spawn a child process and resolve with its stdout, or reject with a decorated Error on non-zero exit.\n *\n * Captured stdout and stderr are always tee'd to `processLoggerDebug` / `processLoggerError`. The optional `stdout` and\n * `stderr` callbacks receive each sanitized chunk as it arrives — useful for streaming output to the terminal.\n * Passing a `stderr` callback (even a no-op) suppresses the default pass-through to `process.stderr` for that stream.\n *\n * On non-zero exit, rejects with an {@link ExecError} carrying `.stderr` / `.stdout` and a `toString()` that includes\n * the captured body (see {@link attachProcessOutput}); `.message` itself stays as the headline.\n *\n * @param command the executable to spawn\n * @param args arguments passed to the executable\n * @param options spawn options; `noColor: true` strips ANSI escapes from captured output (auto-detected from CLI flags\n *  / `FORCE_COLOR=0` when omitted)\n * @param stdout optional per-chunk callback for sanitized stdout\n * @param stderr optional per-chunk callback for sanitized stderr; passing a callback suppresses default terminal echo\n * @param sendToStderr when false, suppresses both the stderr callback invocation and the default terminal echo\n * @returns the full concatenated stdout as a string on success\n */\nexport const exec = async (\n  command: string,\n  args: string[],\n  options: SpawnOptions & { noColor?: boolean },\n  stdout?: (chunk: string) => any,\n  stderr?: (chunk: string | Uint8Array) => any,\n  sendToStderr = true,\n): Promise<string> => {\n  // if options.noColor is not set, checking the flags & environment if it should be set\n  // This is required for collectDebugInformation() which does not have knowledge about flags\n  if (typeof options.noColor !== \"boolean\" && hasNoColorFlagOrEnv()) {\n    options.noColor = true;\n  }\n\n  return new Promise((ok, ko) => {\n    const child = spawn(command, args, options);\n    const out = new Array<string>();\n    const err = new Array<string>();\n    if (stdout !== undefined) {\n      child.stdout?.on(\"data\", (chunk: Buffer) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerDebug(sanitizedChunk);\n        out.push(sanitizedChunk);\n        stdout(sanitizedChunk);\n      });\n    } else {\n      child.stdout?.on(\"data\", (chunk: Buffer) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerDebug(sanitizedChunk);\n        out.push(sanitizedChunk);\n      });\n    }\n    if (stderr !== undefined) {\n      child.stderr?.on(\"data\", (chunk: string | Uint8Array) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerError(sanitizedChunk);\n        if (sendToStderr) {\n          stderr(sanitizedChunk);\n        }\n        err.push(sanitizedChunk);\n      });\n    } else {\n      child.stderr?.on(\"data\", (chunk: string | Uint8Array) => {\n        const sanitizedChunk = options.noColor\n          ? stripAnsi(chunk.toLocaleString())\n          : chunk.toLocaleString();\n        processLoggerError(sanitizedChunk);\n        if (sendToStderr) {\n          process.stderr.write(sanitizedChunk);\n        }\n        err.push(sanitizedChunk);\n      });\n    }\n    child.once(\"error\", (err: any) => ko(err));\n    child.once(\"close\", (code: number) => {\n      if (code !== 0) {\n        const error = new Error(\n          `${command} ${args.join(\" \")} exited with code ${code}`,\n        );\n        attachProcessOutput(error, err.join(\"\"), out.join(\"\"));\n        return ko(error);\n      }\n      return ok(out.join(\"\"));\n    });\n  });\n};\n\nexport async function readCDKTFVersion(outputDir: string): Promise<string> {\n  const outputFile = path.join(outputDir, \"cdk.tf.json\");\n  if (fs.existsSync(outputFile)) {\n    const outputJSON = fs.readFileSync(outputFile, \"utf8\");\n    const data = JSON.parse(outputJSON);\n    return data[\"//\"].metadata.version;\n  }\n\n  return \"\";\n}\n\nexport async function readCDKTFManifest(): Promise<IManifest> {\n  const { output } = config.readConfigSync();\n  const json = await fs.readFile(path.join(output, Manifest.fileName));\n  return JSON.parse(json.toString()) as IManifest;\n}\n\n/**\n * Downcase the first character in a string.\n *\n * @param str the string to be processed.\n */\nexport function downcaseFirst(str: string): string {\n  if (str === \"\") {\n    return str;\n  }\n  return `${str[0].toLocaleLowerCase()}${str.slice(1)}`;\n}\n\nexport class HttpError extends Error {\n  constructor(\n    message?: string,\n    public statusCode?: number,\n  ) {\n    super(message); // 'Error' breaks prototype chain here\n    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain\n    // see: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget\n  }\n}\n\nexport async function downloadFile(\n  url: string,\n  targetFilename: string,\n): Promise<void> {\n  // if the type is inferred to be \"http|https\" calling .get() is not possible\n  // because the options parameter (which we don't use anyway) for get is\n  // not compatible between http and https -> so we treat it as http\n  const client = (url.startsWith(\"http://\") ? http : https) as typeof http;\n  const file = fs.createWriteStream(targetFilename);\n  return new Promise((ok, ko) => {\n    const request = client.get(url, (response) => {\n      if (response.statusCode !== 200) {\n        ko(\n          new HttpError(\n            `Failed to get '${url}' (${response.statusCode})`,\n            response.statusCode,\n          ),\n        );\n        return;\n      }\n      response.pipe(file);\n    });\n\n    file.on(\"finish\", () => ok());\n\n    request.on(\"error\", (err: Error) => {\n      fs.unlink(targetFilename, () => ko(err));\n    });\n\n    file.on(\"error\", (err) => {\n      fs.unlink(targetFilename, () => ko(err));\n    });\n\n    request.end();\n  });\n}\n\n/**\n * Awaits a promise and makes sure it's error (if any) is only thrown after all other promises are settled\n * if the promise does not throw an error, the other promises won't be awaited\n * @param p promise to await\n * @param promises promises to await to be all settled if p failed before throwing error that p failed with\n */\nexport async function ensureAllSettledBeforeThrowing(\n  p: Promise<any>,\n  promises: (Promise<any> | undefined)[],\n) {\n  try {\n    await p;\n  } catch (e) {\n    // if an error happened, we still need to wait for all other promises that\n    // are currently in progress to complete to allow them to properly wrap up\n    await Promise.allSettled(promises);\n    throw e;\n  }\n}\n\n/**\n * returns true if --no-color is passed as CLI flag or the env var FORCE_COLOR is set to \"0\"\n * Used for cases where we can't pass down the noColor flag (e.g. when collecting debug information from the environment)\n * This is the same behavior as the `chalk` lib we use for coloring output\n */\nexport function hasNoColorFlagOrEnv(): boolean {\n  return hasFlag(\"no-color\") || process.env.FORCE_COLOR === \"0\";\n}\n\n// From: https://github.com/sindresorhus/has-flag/blob/main/index.js\n// as used in https://github.com/chalk/chalk\nfunction hasFlag(flag: string) {\n  const prefix = flag.startsWith(\"-\") ? \"\" : flag.length === 1 ? \"-\" : \"--\";\n  const position = process.argv.indexOf(prefix + flag);\n  const terminatorPosition = process.argv.indexOf(\"--\");\n  return (\n    position !== -1 &&\n    (terminatorPosition === -1 || position < terminatorPosition)\n  );\n}\n"]}

package/build/util.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=util.test.d.ts.map

package/build/util.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.test.d.ts","sourceRoot":"","sources":["../src/util.test.ts"],"names":[],"mappings":""}

package/build/util.test.js

@@ -0,0 +1,86 @@
+"use strict";
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+// Import via the package barrel so the util.ts ↔ logging.ts module-init cycle
+const index_1 = require("./index");
+const log4js_1 = require("log4js");
+// Silence log4js output so the test reporter shows only Jest's PASS/FAIL lines.
+beforeAll(() => {
+    (0, log4js_1.getLogger)().level = "OFF";
+});
+/**
+ * Spawn a failing child process and return the rejected Error.
+ *
+ * Using the running node binary keeps the failure surface portable across CI / dev machines (no shell builtins, no
+ * external binaries). The `stderr` / `stdout` payloads are hex-encoded inside the script so the captured bytes do not
+ * appear verbatim in the headline's `args.join(" ")` echo — that lets tests assert the headline does not include
+ * captured output.
+ *
+ * @param spec what the child should write to each stream and which exit code to use
+ * @returns the Error rejected by `exec`, narrowed to expose the attached `.stderr` / `.stdout`
+ * @throws if `exec` resolves rather than rejecting (the test setup is wrong)
+ */
+async function runFailing(spec) {
+    const parts = [];
+    if (spec.stderr !== undefined) {
+        const hex = Buffer.from(spec.stderr).toString("hex");
+        parts.push(`process.stderr.write(Buffer.from("${hex}","hex").toString())`);
+    }
+    if (spec.stdout !== undefined) {
+        const hex = Buffer.from(spec.stdout).toString("hex");
+        parts.push(`process.stdout.write(Buffer.from("${hex}","hex").toString())`);
+    }
+    parts.push(`process.exit(${spec.exitCode})`);
+    try {
+        await (0, index_1.exec)(process.execPath, ["-e", parts.join("; ")], {}, undefined, 
+        // No-op stderr callback suppresses exec()'s default pass-through to process.stderr.
+        () => { });
+        throw new Error("exec() resolved unexpectedly");
+    }
+    catch (e) {
+        return e;
+    }
+}
+const STDERR_PAYLOAD = "stderr-payload-marker";
+const STDOUT_PAYLOAD = "stdout-payload-marker";
+describe("exec() failure decoration", () => {
+    it("attaches both stderr and stdout and surfaces them via toString()", async () => {
+        const error = await runFailing({
+            stderr: STDERR_PAYLOAD,
+            stdout: STDOUT_PAYLOAD,
+            exitCode: 2,
+        });
+        expect(error.stderr).toBe(STDERR_PAYLOAD);
+        expect(error.stdout).toBe(STDOUT_PAYLOAD);
+        expect(error.message).toContain("exited with code 2");
+        expect(error.message).not.toContain(STDERR_PAYLOAD);
+        expect(error.message).not.toContain(STDOUT_PAYLOAD);
+        expect(String(error)).toBe(`Error: ${error.message}\n${STDERR_PAYLOAD}\n${STDOUT_PAYLOAD}`);
+    });
+    it("renders stderr-only failures without a trailing blank line for empty stdout", async () => {
+        const error = await runFailing({ stderr: STDERR_PAYLOAD, exitCode: 3 });
+        expect(error.stderr).toBe(STDERR_PAYLOAD);
+        expect(error.stdout).toBe("");
+        expect(String(error)).toBe(`Error: ${error.message}\n${STDERR_PAYLOAD}`);
+    });
+    it("renders stdout-only failures without a leading blank line for empty stderr", async () => {
+        const error = await runFailing({ stdout: STDOUT_PAYLOAD, exitCode: 4 });
+        expect(error.stderr).toBe("");
+        expect(error.stdout).toBe(STDOUT_PAYLOAD);
+        expect(String(error)).toBe(`Error: ${error.message}\n${STDOUT_PAYLOAD}`);
+    });
+    it("leaves toString() at the default headline when both streams are empty", async () => {
+        const error = await runFailing({ exitCode: 5 });
+        expect(error.stderr).toBe("");
+        expect(error.stdout).toBe("");
+        // No custom toString override → default Error.prototype.toString = "Error: <message>".
+        expect(String(error)).toBe(`Error: ${error.message}`);
+    });
+    it("surfaces stderr and the exit code through template-literal interpolation of the error", async () => {
+        const error = await runFailing({ stderr: STDERR_PAYLOAD, exitCode: 6 });
+        expect(`${error}`).toContain(STDERR_PAYLOAD);
+        expect(`${error}`).toContain("exited with code 6");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.test.js","sourceRoot":"","sources":["../src/util.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\n\n// Import via the package barrel so the util.ts ↔ logging.ts module-init cycle\nimport { exec } from \"./index\";\nimport { getLogger } from \"log4js\";\n\n// Silence log4js output so the test reporter shows only Jest's PASS/FAIL lines.\nbeforeAll(() => {\n  getLogger().level = \"OFF\";\n});\n\ntype DecoratedError = Error & { stderr?: string; stdout?: string };\n\n/**\n * Spawn a failing child process and return the rejected Error.\n *\n * Using the running node binary keeps the failure surface portable across CI / dev machines (no shell builtins, no\n * external binaries). The `stderr` / `stdout` payloads are hex-encoded inside the script so the captured bytes do not\n * appear verbatim in the headline's `args.join(\" \")` echo — that lets tests assert the headline does not include\n * captured output.\n *\n * @param spec what the child should write to each stream and which exit code to use\n * @returns the Error rejected by `exec`, narrowed to expose the attached `.stderr` / `.stdout`\n * @throws if `exec` resolves rather than rejecting (the test setup is wrong)\n */\nasync function runFailing(spec: {\n  stderr?: string;\n  stdout?: string;\n  exitCode: number;\n}): Promise<DecoratedError> {\n  const parts: string[] = [];\n  if (spec.stderr !== undefined) {\n    const hex = Buffer.from(spec.stderr).toString(\"hex\");\n    parts.push(`process.stderr.write(Buffer.from(\"${hex}\",\"hex\").toString())`);\n  }\n  if (spec.stdout !== undefined) {\n    const hex = Buffer.from(spec.stdout).toString(\"hex\");\n    parts.push(`process.stdout.write(Buffer.from(\"${hex}\",\"hex\").toString())`);\n  }\n  parts.push(`process.exit(${spec.exitCode})`);\n  try {\n    await exec(\n      process.execPath,\n      [\"-e\", parts.join(\"; \")],\n      {},\n      undefined,\n      // No-op stderr callback suppresses exec()'s default pass-through to process.stderr.\n      () => {},\n    );\n    throw new Error(\"exec() resolved unexpectedly\");\n  } catch (e: any) {\n    return e;\n  }\n}\n\nconst STDERR_PAYLOAD = \"stderr-payload-marker\";\nconst STDOUT_PAYLOAD = \"stdout-payload-marker\";\n\ndescribe(\"exec() failure decoration\", () => {\n  it(\"attaches both stderr and stdout and surfaces them via toString()\", async () => {\n    const error = await runFailing({\n      stderr: STDERR_PAYLOAD,\n      stdout: STDOUT_PAYLOAD,\n      exitCode: 2,\n    });\n\n    expect(error.stderr).toBe(STDERR_PAYLOAD);\n    expect(error.stdout).toBe(STDOUT_PAYLOAD);\n    expect(error.message).toContain(\"exited with code 2\");\n    expect(error.message).not.toContain(STDERR_PAYLOAD);\n    expect(error.message).not.toContain(STDOUT_PAYLOAD);\n    expect(String(error)).toBe(\n      `Error: ${error.message}\\n${STDERR_PAYLOAD}\\n${STDOUT_PAYLOAD}`,\n    );\n  });\n\n  it(\"renders stderr-only failures without a trailing blank line for empty stdout\", async () => {\n    const error = await runFailing({ stderr: STDERR_PAYLOAD, exitCode: 3 });\n\n    expect(error.stderr).toBe(STDERR_PAYLOAD);\n    expect(error.stdout).toBe(\"\");\n    expect(String(error)).toBe(`Error: ${error.message}\\n${STDERR_PAYLOAD}`);\n  });\n\n  it(\"renders stdout-only failures without a leading blank line for empty stderr\", async () => {\n    const error = await runFailing({ stdout: STDOUT_PAYLOAD, exitCode: 4 });\n\n    expect(error.stderr).toBe(\"\");\n    expect(error.stdout).toBe(STDOUT_PAYLOAD);\n    expect(String(error)).toBe(`Error: ${error.message}\\n${STDOUT_PAYLOAD}`);\n  });\n\n  it(\"leaves toString() at the default headline when both streams are empty\", async () => {\n    const error = await runFailing({ exitCode: 5 });\n\n    expect(error.stderr).toBe(\"\");\n    expect(error.stdout).toBe(\"\");\n    // No custom toString override → default Error.prototype.toString = \"Error: <message>\".\n    expect(String(error)).toBe(`Error: ${error.message}`);\n  });\n\n  it(\"surfaces stderr and the exit code through template-literal interpolation of the error\", async () => {\n    const error = await runFailing({ stderr: STDERR_PAYLOAD, exitCode: 6 });\n\n    expect(`${error}`).toContain(STDERR_PAYLOAD);\n    expect(`${error}`).toContain(\"exited with code 6\");\n  });\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cdktn/commons",
-  "version": "0.24.0-pre.26",
+  "version": "0.24.0-pre.28",
   "publishConfig": {
     "access": "public"
   },
@@ -39,7 +39,7 @@
   "license": "MPL-2.0",
   "dependencies": {
     "@sentry/node": "7.120.4",
-    "cdktn": "0.24.0-pre.26",
+    "cdktn": "0.24.0-pre.28",
     "ci-info": "3.9.0",
     "codemaker": "1.128.0",
     "cross-spawn": "7.0.6",