Extract environment variable parsing to testable function (#19)

* Initial plan

* Refactor environment variable parsing to a testable function

Co-authored-by: Mossaka <5447827+Mossaka@users.noreply.github.com>

* Address code review: eliminate regex duplication with better error handling

Co-authored-by: Mossaka <5447827+Mossaka@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Mossaka <5447827+Mossaka@users.noreply.github.com>
Co-authored-by: Jiaxiao Zhou <duibao55328@gmail.com>

Author: Copilot

src/cli.test.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { parseEnvironmentVariables } from './cli';
 import { redactSecrets } from './redact-secrets';
 import { parseDomains } from './cli';
 
@@ -38,61 +39,69 @@ describe('cli', () => {
   describe('environment variable parsing', () => {
     it('should parse KEY=VALUE format correctly', () => {
       const envVars = ['GITHUB_TOKEN=abc123', 'API_KEY=xyz789'];
-      const result: Record<string, string> = {};
-
-      for (const envVar of envVars) {
-        const match = envVar.match(/^([^=]+)=(.*)$/);
-        if (match) {
-          const [, key, value] = match;
-          result[key] = value;
-        }
+      const result = parseEnvironmentVariables(envVars);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.env).toEqual({
+          GITHUB_TOKEN: 'abc123',
+          API_KEY: 'xyz789',
+        });
       }
-
-      expect(result).toEqual({
-        GITHUB_TOKEN: 'abc123',
-        API_KEY: 'xyz789',
-      });
     });
 
     it('should handle empty values', () => {
       const envVars = ['EMPTY_VAR='];
-      const result: Record<string, string> = {};
-
-      for (const envVar of envVars) {
-        const match = envVar.match(/^([^=]+)=(.*)$/);
-        if (match) {
-          const [, key, value] = match;
-          result[key] = value;
-        }
-      }
+      const result = parseEnvironmentVariables(envVars);
 
-      expect(result).toEqual({
-        EMPTY_VAR: '',
-      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.env).toEqual({
+          EMPTY_VAR: '',
+        });
+      }
     });
 
     it('should handle values with equals signs', () => {
       const envVars = ['BASE64_VAR=abc=def=ghi'];
-      const result: Record<string, string> = {};
-
-      for (const envVar of envVars) {
-        const match = envVar.match(/^([^=]+)=(.*)$/);
-        if (match) {
-          const [, key, value] = match;
-          result[key] = value;
-        }
-      }
+      const result = parseEnvironmentVariables(envVars);
 
-      expect(result).toEqual({
-        BASE64_VAR: 'abc=def=ghi',
-      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.env).toEqual({
+          BASE64_VAR: 'abc=def=ghi',
+        });
+      }
     });
 
     it('should reject invalid format (no equals sign)', () => {
-      const envVar = 'INVALID_VAR';
-      const match = envVar.match(/^([^=]+)=(.*)$/);
+      const envVars = ['INVALID_VAR'];
+      const result = parseEnvironmentVariables(envVars);
 
-      expect(match).toBeNull();
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.invalidVar).toBe('INVALID_VAR');
+      }
+    });
+
+    it('should handle empty array', () => {
+      const envVars: string[] = [];
+      const result = parseEnvironmentVariables(envVars);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.env).toEqual({});
+      }
+    });
+
+    it('should return error on first invalid entry', () => {
+      const envVars = ['VALID_VAR=value', 'INVALID_VAR', 'ANOTHER_VALID=value2'];
+      const result = parseEnvironmentVariables(envVars);
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.invalidVar).toBe('INVALID_VAR');
+      }
     });
   });
 

src/cli.ts

@@ -48,6 +48,39 @@ function redactSecrets(command: string): string {
     .replace(/\b(gh[pousr]_[a-zA-Z0-9]{36,255})/g, '***REDACTED***');
 }
 
+/**
+ * Result of parsing environment variables
+ */
+export interface ParseEnvResult {
+  success: true;
+  env: Record<string, string>;
+}
+
+export interface ParseEnvError {
+  success: false;
+  invalidVar: string;
+}
+
+/**
+ * Parses environment variables from an array of KEY=VALUE strings
+ * @param envVars Array of environment variable strings in KEY=VALUE format
+ * @returns ParseEnvResult with parsed key-value pairs on success, or ParseEnvError with the invalid variable on failure
+ */
+export function parseEnvironmentVariables(envVars: string[]): ParseEnvResult | ParseEnvError {
+  const result: Record<string, string> = {};
+  
+  for (const envVar of envVars) {
+    const match = envVar.match(/^([^=]+)=(.*)$/);
+    if (!match) {
+      return { success: false, invalidVar: envVar };
+    }
+    const [, key, value] = match;
+    result[key] = value;
+  }
+  
+  return { success: true, env: result };
+}
+
 const program = new Command();
 
 program
@@ -118,17 +151,14 @@ program
     }
 
     // Parse additional environment variables from --env flags
-    const additionalEnv: Record<string, string> = {};
+    let additionalEnv: Record<string, string> = {};
     if (options.env && Array.isArray(options.env)) {
-      for (const envVar of options.env) {
-        const match = envVar.match(/^([^=]+)=(.*)$/);
-        if (!match) {
-          logger.error(`Invalid environment variable format: ${envVar} (expected KEY=VALUE)`);
-          process.exit(1);
-        }
-        const [, key, value] = match;
-        additionalEnv[key] = value;
+      const parsed = parseEnvironmentVariables(options.env);
+      if (!parsed.success) {
+        logger.error(`Invalid environment variable format: ${parsed.invalidVar} (expected KEY=VALUE)`);
+        process.exit(1);
       }
+      additionalEnv = parsed.env;
     }
 
     const config: WrapperConfig = {