@flowscripter/dynamic-cli-framework 1.7.3 → 1.7.4

package/dist/src/terminal/PngDecoder.js

@@ -0,0 +1,115 @@
+// Minimal PNG-to-RGBA pixel extractor. Supports 8-bit RGB and RGBA only.
+import { inflateSync } from "node:zlib";
+function paethPredictor(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    if (pa <= pb && pa <= pc)
+        return a;
+    if (pb <= pc)
+        return b;
+    return c;
+}
+export function decodePngToRGBA(pngBytes) {
+    const sig = [137, 80, 78, 71, 13, 10, 26, 10];
+    for (let i = 0; i < 8; i++) {
+        if (pngBytes[i] !== sig[i])
+            throw new Error("Invalid PNG signature");
+    }
+    const view = new DataView(pngBytes.buffer, pngBytes.byteOffset, pngBytes.byteLength);
+    let offset = 8;
+    let width = 0;
+    let height = 0;
+    let bitDepth = 0;
+    let colorType = 0;
+    const idatChunks = [];
+    while (offset < pngBytes.length) {
+        const length = view.getUint32(offset);
+        const type = String.fromCharCode(pngBytes[offset + 4], pngBytes[offset + 5], pngBytes[offset + 6], pngBytes[offset + 7]);
+        const dataStart = offset + 8;
+        if (type === "IHDR") {
+            width = view.getUint32(dataStart);
+            height = view.getUint32(dataStart + 4);
+            bitDepth = pngBytes[dataStart + 8];
+            colorType = pngBytes[dataStart + 9];
+            const interlace = pngBytes[dataStart + 12];
+            if (bitDepth !== 8) {
+                throw new Error(`Unsupported bit depth: ${bitDepth} (only 8 supported)`);
+            }
+            if (colorType !== 2 && colorType !== 6) {
+                throw new Error(`Unsupported color type: ${colorType} (only RGB=2 and RGBA=6 supported)`);
+            }
+            if (interlace !== 0) {
+                throw new Error("Interlaced PNGs are not supported");
+            }
+        }
+        else if (type === "IDAT") {
+            idatChunks.push(pngBytes.subarray(dataStart, dataStart + length));
+        }
+        else if (type === "IEND") {
+            break;
+        }
+        offset = dataStart + length + 4; // +4 for CRC
+    }
+    if (width === 0 || height === 0)
+        throw new Error("Missing IHDR chunk");
+    if (idatChunks.length === 0)
+        throw new Error("Missing IDAT chunks");
+    const bpp = colorType === 6 ? 4 : 3;
+    const compressed = new Uint8Array(idatChunks.reduce((sum, c) => sum + c.length, 0));
+    let pos = 0;
+    for (const chunk of idatChunks) {
+        compressed.set(chunk, pos);
+        pos += chunk.length;
+    }
+    const raw = inflateSync(compressed);
+    const stride = bpp * width;
+    const pixels = new Uint8Array(width * height * 4);
+    const prevRow = new Uint8Array(stride);
+    const currRow = new Uint8Array(stride);
+    let rawOffset = 0;
+    for (let y = 0; y < height; y++) {
+        const filterType = raw[rawOffset++];
+        for (let x = 0; x < stride; x++) {
+            currRow[x] = raw[rawOffset++];
+        }
+        for (let x = 0; x < stride; x++) {
+            const left = x >= bpp ? currRow[x - bpp] : 0;
+            const up = prevRow[x];
+            const upperLeft = x >= bpp ? prevRow[x - bpp] : 0;
+            switch (filterType) {
+                case 0:
+                    break;
+                case 1:
+                    currRow[x] = (currRow[x] + left) & 0xff;
+                    break;
+                case 2:
+                    currRow[x] = (currRow[x] + up) & 0xff;
+                    break;
+                case 3:
+                    currRow[x] = (currRow[x] + ((left + up) >> 1)) & 0xff;
+                    break;
+                case 4:
+                    currRow[x] = (currRow[x] + paethPredictor(left, up, upperLeft)) & 0xff;
+                    break;
+                default:
+                    throw new Error(`Unknown filter type: ${filterType}`);
+            }
+        }
+        const rowStart = y * width * 4;
+        if (bpp === 4) {
+            pixels.set(currRow, rowStart);
+        }
+        else {
+            for (let x = 0; x < width; x++) {
+                pixels[rowStart + x * 4] = currRow[x * 3];
+                pixels[rowStart + x * 4 + 1] = currRow[x * 3 + 1];
+                pixels[rowStart + x * 4 + 2] = currRow[x * 3 + 2];
+                pixels[rowStart + x * 4 + 3] = 255;
+            }
+        }
+        prevRow.set(currRow);
+    }
+    return { width, height, pixels };
+}

package/dist/src/terminal/TtyKeyReader.js

@@ -0,0 +1,87 @@
+import { ReadStream } from "node:tty";
+import { Buffer } from "node:buffer";
+import { SpecialKey } from "./KeyReader.js";
+export default class TtyKeyReader {
+    #ttyReadStream;
+    constructor(ttyReadStream) {
+        if (ttyReadStream.isTTY === false) {
+            throw new Error("The provided ReadStream is not a TTY");
+        }
+        this.#ttyReadStream = ttyReadStream;
+    }
+    enableRawMode() {
+        this.#ttyReadStream.setRawMode(true);
+        this.#ttyReadStream.resume();
+    }
+    disableRawMode() {
+        this.#ttyReadStream.setRawMode(false);
+        this.#ttyReadStream.pause();
+    }
+    readKey() {
+        return new Promise((resolve) => {
+            const onData = (data) => {
+                this.#ttyReadStream.removeListener("data", onData);
+                // A lone 0x1b may be the start of a multi-byte escape sequence (e.g. arrow keys).
+                // Wait briefly for the rest of the sequence before decoding.
+                if (data.length === 1 && data[0] === 0x1b) {
+                    const timeout = setTimeout(() => {
+                        this.#ttyReadStream.removeListener("data", onMore);
+                        resolve(TtyKeyReader.#decodeKeyEvent(data));
+                    }, 20);
+                    const onMore = (more) => {
+                        clearTimeout(timeout);
+                        this.#ttyReadStream.removeListener("data", onMore);
+                        resolve(TtyKeyReader.#decodeKeyEvent(Buffer.concat([data, more])));
+                    };
+                    this.#ttyReadStream.once("data", onMore);
+                    return;
+                }
+                resolve(TtyKeyReader.#decodeKeyEvent(data));
+            };
+            this.#ttyReadStream.on("data", onData);
+        });
+    }
+    static #decodeKeyEvent(data) {
+        if (data.length === 0) {
+            return {};
+        }
+        // escape sequences
+        if (data[0] === 0x1b) {
+            if (data.length === 1) {
+                return { specialKey: SpecialKey.ESCAPE };
+            }
+            if (data.length >= 3 && data[1] === 0x5b) {
+                switch (data[2]) {
+                    case 0x41:
+                        return { specialKey: SpecialKey.UP };
+                    case 0x42:
+                        return { specialKey: SpecialKey.DOWN };
+                    case 0x43:
+                        return { specialKey: SpecialKey.RIGHT };
+                    case 0x44:
+                        return { specialKey: SpecialKey.LEFT };
+                }
+            }
+            return { specialKey: SpecialKey.ESCAPE };
+        }
+        // control characters
+        switch (data[0]) {
+            case 0x0d:
+                return { specialKey: SpecialKey.ENTER };
+            case 0x20:
+                return { specialKey: SpecialKey.SPACE };
+            case 0x7f:
+                return { specialKey: SpecialKey.BACKSPACE };
+            case 0x09:
+                return { specialKey: SpecialKey.TAB };
+            case 0x03:
+                return { specialKey: SpecialKey.INTERRUPT };
+        }
+        // printable characters
+        const str = data.toString("utf8");
+        if (str.length > 0) {
+            return { key: str };
+        }
+        return {};
+    }
+}

package/dist/src/terminal/TtyStyler.js

@@ -0,0 +1,55 @@
+import { BACKGROUND_COLOR_END, FOREGROUND_COLOR_END, HYPERLINK_END, hyperlinkStart, ITALIC_END, ITALIC_START, } from "./Ansi.js";
+export default class TtyStyler {
+    colorEnabled = true;
+    hyperlinksEnabled;
+    colorLevel;
+    /**
+     * The color level in use.
+     *
+     * 1 = 16 color
+     * 2 = 256 color
+     * 3 = 16 million color
+     */
+    constructor(colorLevel = 1, hyperlinksEnabled = true) {
+        this.colorLevel = colorLevel;
+        this.hyperlinksEnabled = hyperlinksEnabled;
+    }
+    colorText(text, colorValue) {
+        if (!this.colorEnabled) {
+            return text;
+        }
+        if (this.colorLevel === 3) {
+            return Bun.color(colorValue, "ansi-16m") + text + FOREGROUND_COLOR_END;
+        }
+        if (this.colorLevel === 2) {
+            return Bun.color(colorValue, "ansi-256") + text + FOREGROUND_COLOR_END;
+        }
+        return Bun.color(colorValue, "ansi-16") + text + FOREGROUND_COLOR_END;
+    }
+    backgroundColorText(text, colorValue) {
+        if (!this.colorEnabled) {
+            return text;
+        }
+        if (this.colorLevel === 3) {
+            const r = (colorValue >> 16) & 0xff;
+            const g = (colorValue >> 8) & 0xff;
+            const b = colorValue & 0xff;
+            return `\x1b[48;2;${r};${g};${b}m${text}${BACKGROUND_COLOR_END}`;
+        }
+        if (this.colorLevel === 2) {
+            return (Bun.color(colorValue, "ansi-256").replace("[38;", "[48;") + text + BACKGROUND_COLOR_END);
+        }
+        return (Bun.color(colorValue, "ansi-16").replace(/\[(\d+)m/, (_, n) => `[${Number(n) + 10}m`) +
+            text +
+            BACKGROUND_COLOR_END);
+    }
+    italicText(text) {
+        return ITALIC_START + text + ITALIC_END;
+    }
+    hyperlink(text, url) {
+        if (!this.hyperlinksEnabled) {
+            return `${text}: ${url}`;
+        }
+        return hyperlinkStart(url) + text + HYPERLINK_END;
+    }
+}

package/dist/src/terminal/TtyTerminal.js

@@ -0,0 +1,52 @@
+import { WriteStream } from "node:tty";
+import { CLEAR_LINE, CURSOR_LEFT, CURSOR_UP, HIDE_CURSOR, SHOW_CURSOR } from "./Ansi.js";
+export default class TtyTerminal {
+    #ttyWriteStream;
+    #encoder = new TextEncoder();
+    constructor(ttyWriteStream) {
+        if (ttyWriteStream.isTTY === false) {
+            throw new Error("The provided WriteStream is not a TTY");
+        }
+        this.#ttyWriteStream = ttyWriteStream;
+    }
+    #writeAll(message) {
+        const encoded = this.#encoder.encode(message);
+        this.#ttyWriteStream.write(encoded);
+    }
+    clearLine() {
+        this.#writeAll(CLEAR_LINE + CURSOR_LEFT);
+        return Promise.resolve();
+    }
+    clearUpLines(count) {
+        this.#writeAll((CURSOR_UP + CLEAR_LINE).repeat(count) + CLEAR_LINE + CURSOR_LEFT);
+        return Promise.resolve();
+    }
+    hideCursor() {
+        this.#writeAll(HIDE_CURSOR);
+        return Promise.resolve();
+    }
+    showCursor() {
+        this.#writeAll(SHOW_CURSOR);
+        return Promise.resolve();
+    }
+    write(text) {
+        this.#writeAll(text);
+        return Promise.resolve();
+    }
+    columns() {
+        try {
+            return this.#ttyWriteStream.columns || 80;
+        }
+        catch {
+            return 80;
+        }
+    }
+    rows() {
+        try {
+            return this.#ttyWriteStream.rows || 24;
+        }
+        catch {
+            return 24;
+        }
+    }
+}

package/dist/src/terminal/supportsHyperlinks.js

@@ -0,0 +1,95 @@
+import process from "node:process";
+function parseVersion(versionString = "") {
+    if (/^\d{3,4}$/.test(versionString)) {
+        const match = /(\d{1,2})(\d{2})/.exec(versionString) ?? [];
+        return {
+            major: 0,
+            minor: Number.parseInt(match[1] ?? "0", 10),
+            patch: Number.parseInt(match[2] ?? "0", 10),
+        };
+    }
+    const versions = (versionString ?? "").split(".").map((n) => Number.parseInt(n, 10));
+    return {
+        major: versions[0] ?? 0,
+        minor: versions[1] ?? 0,
+        patch: versions[2] ?? 0,
+    };
+}
+export default function supportsHyperlinks(stream) {
+    const { CI, CURSOR_TRACE_ID, FORCE_HYPERLINK, LC_TERMINAL, LC_TERMINAL_VERSION, TEAMCITY_VERSION, TERM_PROGRAM, TERM_PROGRAM_VERSION, VTE_VERSION, TERM, } = process.env;
+    if (FORCE_HYPERLINK) {
+        return !(FORCE_HYPERLINK.length > 0 && Number.parseInt(FORCE_HYPERLINK, 10) === 0);
+    }
+    if (stream && !stream.isTTY) {
+        return false;
+    }
+    if ("WT_SESSION" in process.env) {
+        return true;
+    }
+    if (CI) {
+        return false;
+    }
+    if (TEAMCITY_VERSION) {
+        return false;
+    }
+    if (TERM_PROGRAM) {
+        const version = parseVersion(TERM_PROGRAM_VERSION);
+        switch (TERM_PROGRAM) {
+            case "iTerm.app": {
+                if (version.major === 3) {
+                    return version.minor >= 1;
+                }
+                return version.major > 3;
+            }
+            case "WezTerm": {
+                if (/^0-unstable-\d{4}-\d{2}-\d{2}$/.test(TERM_PROGRAM_VERSION)) {
+                    const date = TERM_PROGRAM_VERSION.slice("0-unstable-".length);
+                    return date >= "2020-06-20";
+                }
+                return version.major >= 20200620;
+            }
+            case "vscode": {
+                if (CURSOR_TRACE_ID) {
+                    return true;
+                }
+                return version.major > 1 || (version.major === 1 && version.minor >= 72);
+            }
+            case "ghostty":
+                return true;
+            case "zed":
+                return true;
+        }
+    }
+    if (LC_TERMINAL) {
+        const version = parseVersion(LC_TERMINAL_VERSION);
+        switch (LC_TERMINAL) {
+            case "iTerm2": {
+                if (version.major === 3) {
+                    return version.minor >= 1;
+                }
+                return version.major > 3;
+            }
+            case "WezTerm": {
+                if (/^0-unstable-\d{4}-\d{2}-\d{2}$/.test(LC_TERMINAL_VERSION)) {
+                    const date = LC_TERMINAL_VERSION.slice("0-unstable-".length);
+                    return date >= "2020-06-20";
+                }
+                return version.major >= 20200620;
+            }
+        }
+    }
+    if (VTE_VERSION) {
+        if (VTE_VERSION === "0.50.0") {
+            return false;
+        }
+        const version = parseVersion(VTE_VERSION);
+        return version.major > 0 || version.minor >= 50;
+    }
+    switch (TERM) {
+        case "alacritty":
+            return true;
+        case "xterm-kitty":
+            return true;
+    }
+    return false;
+}

package/dist/src/util/configHelper.js

@@ -0,0 +1,61 @@
+function getKeySegment(segment, isCustom = false, isArray = false) {
+    let keySegment = segment;
+    if (!isCustom) {
+        keySegment = keySegment.replace("-", "_").toUpperCase();
+        if (keySegment[0].match(/[0-9]/)) {
+            keySegment = `_${keySegment}`;
+        }
+    }
+    if (isArray) {
+        return `${keySegment}[_<index>]`;
+    }
+    return keySegment;
+}
+/**
+ * Determine the configuration key for the specified {@link SubCommandArgument}.
+ *
+ * @param cliConfig the {@link CLIConfig} to use for determining the default configuration key.
+ * @param command the {@link Command} to use for determining the default configuration key.
+ * @param argumentAncestry a list of {@link SubCommandArgument} instances from the root command arguments to a leaf argument.
+ * Apart from {@link ComplexOption} instances this will always only have a single entry.
+ */
+export function getSubCommandArgumentConfigurationKey(cliConfig, command, argumentAncestry) {
+    if (command.enableConfiguration === undefined || command.enableConfiguration !== true) {
+        return undefined;
+    }
+    if (argumentAncestry.length === 0) {
+        return undefined;
+    }
+    const keySegments = [];
+    const firstArgument = argumentAncestry[0];
+    if (firstArgument.configurationKey === undefined) {
+        keySegments.push(getKeySegment(cliConfig.name));
+        keySegments.push(getKeySegment(command.name));
+    }
+    argumentAncestry.forEach((argument) => {
+        const isArray = argument.isArray || argument.isVarargMultiple;
+        keySegments.push(getKeySegment(argument.configurationKey || argument.name, argument.configurationKey !== undefined, isArray));
+    });
+    return keySegments.join("_");
+}
+/**
+ * Determine the configuration key for the specified {@link GlobalCommandArgument}.
+ *
+ * @param cliConfig the {@link CLIConfig} to use for determining the default configuration key.
+ * @param command the {@link Command} to use for determining the default configuration key.
+ * @param globalCommandArgument the {@link GlobalCommandArgument}.
+ */
+export function getGlobalCommandArgumentConfigurationKey(cliConfig, command, globalCommandArgument) {
+    if (command.enableConfiguration === undefined || command.enableConfiguration !== true) {
+        return undefined;
+    }
+    const keySegments = [];
+    if (globalCommandArgument.configurationKey === undefined) {
+        keySegments.push(getKeySegment(cliConfig.name));
+        keySegments.push(getKeySegment(command.name));
+    }
+    else {
+        keySegments.push(getKeySegment(globalCommandArgument.configurationKey));
+    }
+    return keySegments.join("_");
+}

package/dist/src/util/envVarHelper.js

@@ -0,0 +1,216 @@
+import process from "node:process";
+import { ArgumentValueTypeName, ComplexValueTypeName, } from "../api/argument/ArgumentValueTypes.js";
+import { MAXIMUM_ARGUMENT_ARRAY_SIZE } from "../api/argument/SubCommandArgument.js";
+function getKeySegment(segment) {
+    let keySegment = segment.replace("-", "_").toUpperCase();
+    if (keySegment[0].match(/[0-9]/)) {
+        keySegment = `_${keySegment}`;
+    }
+    return keySegment;
+}
+function getSubCommandArgumentKeyPrefix(cliConfig, command, subCommandArgument) {
+    if (subCommandArgument.configurationKey) {
+        return subCommandArgument.configurationKey;
+    }
+    return `${getKeySegment(cliConfig.name)}_${getKeySegment(command.name)}_${getKeySegment(subCommandArgument.name)}`;
+}
+function getGlobalArgumentKeyPrefix(cliConfig, command, globalCommandArgument) {
+    if (globalCommandArgument.configurationKey) {
+        return globalCommandArgument.configurationKey;
+    }
+    return `${getKeySegment(cliConfig.name)}_${getKeySegment(command.name)}`;
+}
+/**
+ * Get configured argument value for the specified {@link GlobalCommandArgument} from environment variables.
+ *
+ * @param cliConfig the {@link CLIConfig} to use for determining the default configuration key.
+ * @param command the {@link GlobalCommand} to use for determining the default configuration key and containing a
+ * {@link GlobalCommandArgument} instance to populate a value for.
+ */
+export function getGlobalCommandValueFromEnvVars(cliConfig, command) {
+    const { argument } = command;
+    if (argument === undefined) {
+        return undefined;
+    }
+    // simple check for a specific env var name
+    let envVarValue = process.env[getGlobalArgumentKeyPrefix(cliConfig, command, argument)];
+    if (envVarValue != undefined && argument.type === ArgumentValueTypeName.BOOLEAN) {
+        envVarValue = envVarValue.length > 0 ? "true" : "false";
+    }
+    return envVarValue;
+}
+function getOptionValuesFromEnvVars(envVarValues, potentialEnvVarNames, env, option, envVarNamePrefix) {
+    if (potentialEnvVarNames.length === 0) {
+        return;
+    }
+    if (option.name === "__proto__" || option.name === "constructor" || option.name === "prototype") {
+        throw new Error(`Unsafe key name in use: ${option.name}, CodeQL Rule ID: js/prototype-polluting-assignment`);
+    }
+    if (option.isArray) {
+        envVarNamePrefix = `${envVarNamePrefix}_`;
+        const matches = potentialEnvVarNames.filter((envVarName) => envVarName.startsWith(envVarNamePrefix));
+        matches.forEach((match) => {
+            const path = match.substring(envVarNamePrefix.length);
+            // either '1' or '1_property...' or 'something_invalid'....
+            let indexString = path;
+            let suffix = "";
+            const indexOf = path.indexOf("_");
+            if (indexOf > -1) {
+                indexString = path.substring(0, indexOf);
+                if (indexOf + 1 < path.length) {
+                    suffix = path.substring(indexOf + 1);
+                }
+            }
+            let index;
+            try {
+                index = parseInt(indexString);
+            }
+            catch {
+                throw new Error(`Unable to parse array index from env var: ${match}`);
+            }
+            if (index !== undefined) {
+                if (index > MAXIMUM_ARGUMENT_ARRAY_SIZE) {
+                    throw new Error(`Maximum array size exceeded: ${index} in env var: ${match}`);
+                }
+                if (envVarValues[option.name] === undefined) {
+                    envVarValues[option.name] = [];
+                }
+                if (suffix.length > 0) {
+                    if (option.type === ComplexValueTypeName.COMPLEX) {
+                        if (envVarValues[option.name][index] ===
+                            undefined) {
+                            envVarValues[option.name][index] = Object.create(null);
+                        }
+                        option.properties.forEach((property) => {
+                            const propertySegment = property.configurationKey || getKeySegment(property.name);
+                            getOptionValuesFromEnvVars(envVarValues[option.name][index], matches, env, property, `${envVarNamePrefix}${index}_${propertySegment}`);
+                        });
+                        if (Object.keys(envVarValues[option.name][index]).length === 0) {
+                            delete envVarValues[option.name][index];
+                        }
+                    }
+                    else {
+                        throw new Error(`Unidentified suffix ${suffix} in env var: ${match}`);
+                    }
+                }
+                else if (option.type === ComplexValueTypeName.COMPLEX) {
+                    throw new Error(`Incomplete argument path in env var: ${match}`);
+                }
+                else {
+                    // set primitive value
+                    let envVarValue = env[match];
+                    if (envVarValue != undefined && option.type === ArgumentValueTypeName.BOOLEAN) {
+                        envVarValue = envVarValue.length > 1 ? "true" : "false";
+                    }
+                    envVarValues[option.name][index] =
+                        envVarValue;
+                }
+                const elements = envVarValues[option.name];
+                for (let i = elements.length - 1; i > -1; i--) {
+                    if (elements[i] === undefined) {
+                        elements.length = i;
+                    }
+                }
+                if (elements.length === 0) {
+                    delete envVarValues[option.name];
+                }
+            }
+        });
+    }
+    else if (option.type === ComplexValueTypeName.COMPLEX) {
+        option.properties.forEach((property) => {
+            if (envVarValues[option.name] === undefined) {
+                envVarValues[option.name] = Object.create(null);
+            }
+            const propertySegment = property.configurationKey || getKeySegment(property.name);
+            getOptionValuesFromEnvVars(envVarValues[option.name], potentialEnvVarNames, env, property, `${envVarNamePrefix}_${propertySegment}`);
+            if (Object.keys(envVarValues[option.name]).length === 0) {
+                delete envVarValues[option.name];
+            }
+        });
+    }
+    else {
+        // simple check for a specific env var name
+        let value = process.env[envVarNamePrefix];
+        if (value === undefined) {
+            return undefined;
+        }
+        if (option.type === ArgumentValueTypeName.BOOLEAN) {
+            value = value.length > 1 ? "true" : "false";
+        }
+        // set primitive value
+        envVarValues[option.name] = value;
+    }
+}
+/**
+ * Get configured argument values for the specified {@link Option} from environment variables.
+ *
+ * @param cliConfig the {@link CLIConfig} to use for determining the default configuration key.
+ * @param command the {@link SubCommand} to use for determining the default configuration key and containing
+ * {@link Positional} and {@link Option} instances to populate values for.
+ */
+export function getSubCommandValuesFromEnvVars(cliConfig, command) {
+    const envVarValues = Object.create(null);
+    if (command.options) {
+        for (const option of command.options) {
+            const potentialEnvVarNames = Object.keys(process.env);
+            const optionPrefix = getSubCommandArgumentKeyPrefix(cliConfig, command, option);
+            getOptionValuesFromEnvVars(envVarValues, potentialEnvVarNames, process.env ?? {}, option, optionPrefix);
+        }
+    }
+    if (command.positionals) {
+        for (const positional of command.positionals) {
+            if (positional.name === "__proto__" ||
+                positional.name === "constructor" ||
+                positional.name === "prototype") {
+                throw new Error(`Unsafe key name in use: ${positional.name}, CodeQL Rule ID: js/prototype-polluting-assignment`);
+            }
+            let envVarNamePrefix = getSubCommandArgumentKeyPrefix(cliConfig, command, positional);
+            if (positional.isVarargMultiple) {
+                envVarNamePrefix = `${envVarNamePrefix}_`;
+                const matches = Object.keys(process.env).filter((envVarName) => envVarName.startsWith(envVarNamePrefix));
+                matches.forEach((match) => {
+                    let index;
+                    try {
+                        index = parseInt(match.substring(envVarNamePrefix.length));
+                    }
+                    catch {
+                        throw new Error(`Unable to parse array index from env var: ${match}`);
+                    }
+                    if (index !== undefined) {
+                        if (index > MAXIMUM_ARGUMENT_ARRAY_SIZE) {
+                            throw new Error(`Maximum array size exceeded: ${index} in env var: ${match}`);
+                        }
+                        if (envVarValues[positional.name] === undefined) {
+                            envVarValues[positional.name] = [];
+                        }
+                        // set primitive value
+                        let envVarValue = process.env[match];
+                        if (envVarValue != undefined && positional.type === ArgumentValueTypeName.BOOLEAN) {
+                            envVarValue = envVarValue.length > 1 ? "true" : "false";
+                        }
+                        envVarValues[positional.name][index] =
+                            envVarValue;
+                    }
+                });
+            }
+            else {
+                // simple check for a specific env var name
+                let value = process.env[envVarNamePrefix];
+                if (value === undefined) {
+                    return undefined;
+                }
+                if (positional.type === ArgumentValueTypeName.BOOLEAN) {
+                    value = value.length > 1 ? "true" : "false";
+                }
+                // set primitive value
+                envVarValues[positional.name] = value;
+            }
+        }
+    }
+    // Check if anything was actually populated
+    if (Object.keys(envVarValues).length === 0) {
+        return undefined;
+    }
+    return envVarValues;
+}