refactor: replace yargs .env("GCL") with manual env var injection

Removes yargs .env("GCL") which blocked GCL_VARIABLE_* env vars via
strictOptions. Env vars are now derived from yargs option metadata, so
option names are defined once. Array options split on semicolons,
naturally supporting GCL_VARIABLE=A=1;B=2 bulk format.

Integration test now uses subprocess with isolated env instead of
mutating process.env.

Author: firecow

src/argv.ts

@@ -35,12 +35,50 @@ export function injectGclVariableEnvVars (argv: {variable?: string[]}, env: Reco
     }
 }
 
+interface YargsOptionsMeta {
+    "array": string[];
+    "boolean": string[];
+    "number": string[];
+    "default": Record<string, any>;
+    "key": Record<string, boolean>;
+}
+
+export function injectGclEnvVars (
+    argv: Record<string, any>,
+    yargsOptions: YargsOptionsMeta,
+    env: Record<string, string | undefined>,
+): void {
+    const arrays = new Set(yargsOptions.array.map(String));
+    const booleans = new Set(yargsOptions.boolean.map(String));
+    const numbers = new Set(yargsOptions.number.map(String));
+
+    for (const key of Object.keys(yargsOptions.key)) {
+        if (key.includes("-") || key === "_" || key === "$0") continue;
+
+        const envKey = `GCL_${key.replace(/[A-Z]/g, c => `_${c}`).toUpperCase()}`;
+        const envValue = env[envKey];
+        if (envValue == null) continue;
+
+        if (arrays.has(key)) {
+            const cliValues = Array.isArray(argv[key]) ? argv[key] : [];
+            argv[key] = [...envValue.split(";"), ...cliValues];
+            continue;
+        }
+
+        if (argv[key] !== undefined && argv[key] !== yargsOptions.default[key]) continue;
+
+        if (booleans.has(key)) argv[key] = envValue === "true" || envValue === "1";
+        else if (numbers.has(key)) argv[key] = Number(envValue);
+        else argv[key] = envValue;
+    }
+}
+
 export class Argv {
     static readonly default = {
         "variablesFile": ".gitlab-ci-local-variables.yml",
         "evaluateRuleChanges": true,
         "ignoreSchemaPaths": [],
-        "ignorePredefinedVars": "",
+        "ignorePredefinedVars": [] as string[],
     };
 
     map: Map<string, any> = new Map<string, any>();
@@ -56,7 +94,6 @@ export class Argv {
     }
 
     static async build (args: any, writeStreams?: WriteStreams) {
-        injectGclVariableEnvVars(args, process.env);
         const argv = new Argv(args, writeStreams);
         await argv.fallbackCwd(args);
 
@@ -177,7 +214,9 @@ export class Argv {
     }
 
     get ignorePredefinedVars (): string[] {
-        return this.map.get("ignorePredefinedVars") ?? Argv.default.ignorePredefinedVars;
+        const val = this.map.get("ignorePredefinedVars") ?? [];
+        if (!Array.isArray(val)) return val ? String(val).split(",") : [];
+        return val.flatMap((v: string) => v.split(","));
     }
 
     get pullPolicy (): string {

src/index.ts

@@ -6,7 +6,7 @@ import * as state from "./state.js";
 import {WriteStreamsProcess, WriteStreamsMock} from "./write-streams.js";
 import {handler} from "./handler.js";
 import {Executor} from "./executor.js";
-import {Argv} from "./argv.js";
+import {Argv, injectGclVariableEnvVars, injectGclEnvVars} from "./argv.js";
 import {AssertionError} from "assert";
 import {Job, cleanupJobResources} from "./job.js";
 import {GitlabRunnerPresetValues} from "./gitlab-preset.js";
@@ -41,6 +41,8 @@ process.on("SIGUSR2", async () => {
         .command({
             handler: async (argv) => {
                 try {
+                    injectGclVariableEnvVars(argv, process.env);
+                    injectGclEnvVars(argv, yparser.getOptions(), process.env);
                     await handler(argv, new WriteStreamsProcess(), jobs);
                     const failedJobs = Executor.getFailed(jobs);
                     process.exit(failedJobs.length > 0 ? 1 : 0);
@@ -74,7 +76,6 @@ process.on("SIGUSR2", async () => {
         })
         .usage("Find more information at https://github.com/firecow/gitlab-ci-local.\nNote: To negate an option use '--no-(option)'.")
         .strictOptions()
-        .env("GCL")
         .option("manual", {
             type: "array",
             description: "One or more manual jobs to run during a pipeline",
@@ -324,11 +325,10 @@ process.on("SIGUSR2", async () => {
             description: "The json schema paths that will be ignored",
         })
         .option("ignore-predefined-vars", {
-            type: "string",
-            coerce: (v) => v.split(","),
+            type: "array",
             requiresArg: false,
             default: Argv.default.ignorePredefinedVars,
-            describe: "Comma-seperated list of predefined pipeline variables for which warnings should be suppressed",
+            describe: "Predefined pipeline variables for which warnings should be suppressed",
         })
         .option("concurrency", {
             type: "number",

tests/test-cases/gcl-variable-env/integration.test.ts

@@ -1,13 +1,8 @@
-import {WriteStreamsMock} from "../../../src/write-streams.js";
-import {handler} from "../../../src/handler.js";
 import {injectGclVariableEnvVars} from "../../../src/argv.js";
-import chalk from "chalk-template";
-import {initSpawnSpy} from "../../mocks/utils.mock.js";
-import {WhenStatics} from "../../mocks/when-statics.js";
+import {execFile} from "child_process";
+import {promisify} from "util";
 
-beforeAll(() => {
-    initSpawnSpy(WhenStatics.all);
-});
+const execFileAsync = promisify(execFile);
 
 describe("injectGclVariableEnvVars unit tests", () => {
     test("injects single GCL_VARIABLE_ entry", () => {
@@ -80,27 +75,15 @@ describe("injectGclVariableEnvVars unit tests", () => {
     });
 });
 
-describe("injectGclVariableEnvVars integration via process.env", () => {
-    test.concurrent("GCL_VARIABLE_* env vars are injected into job output", async () => {
-        const envKeys = ["GCL_VARIABLE_MY_VAR", "GCL_VARIABLE_ANOTHER_VAR"];
-        process.env["GCL_VARIABLE_MY_VAR"] = "hello";
-        process.env["GCL_VARIABLE_ANOTHER_VAR"] = "world";
-        try {
-            const writeStreams = new WriteStreamsMock();
-            await handler({
-                cwd: "tests/test-cases/gcl-variable-env",
-                job: ["test-job"],
-            }, writeStreams);
-
-            const expected = [
-                chalk`{blueBright test-job} {greenBright >} hello`,
-                chalk`{blueBright test-job} {greenBright >} world`,
-            ];
-            expect(writeStreams.stdoutLines).toEqual(expect.arrayContaining(expected));
-        } finally {
-            for (const key of envKeys) {
-                delete process.env[key];
-            }
-        }
+test("GCL_VARIABLE_* env vars are injected into job output via CLI", async () => {
+    const {stdout} = await execFileAsync("bun", ["src/index.ts", "test-job", "--cwd", "tests/test-cases/gcl-variable-env"], {
+        env: {
+            ...process.env,
+            GCL_VARIABLE_MY_VAR: "hello",
+            GCL_VARIABLE_ANOTHER_VAR: "world",
+        },
     });
-});
+
+    expect(stdout).toContain("hello");
+    expect(stdout).toContain("world");
+}, 30_000);