@invarn/cibuild 1.3.16 → 1.3.17

package/dist/src/yaml/e2e.test.js

@@ -0,0 +1,446 @@
+/**
+ * End-to-end integration tests for YAML pipelines
+ * Tests complete YAML pipeline loading and execution through CLI components
+ */
+import { describe, test, expect } from '@jest/globals';
+import { loadYAMLPipeline } from './parser.js';
+import { convertYAMLToPipelineDef } from './converter.js';
+import { detectPlatformInfo } from './platform-detector.js';
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import * as jsYaml from 'js-yaml';
+import './steps/index.js'; // Initialize step registry
+// Test helper for default config
+const testConfig = {
+    artifactsDir: './artifacts',
+    interpreters: {
+        python: 'python3',
+        ruby: 'ruby',
+        node: 'node',
+        bash: '/bin/bash',
+    },
+    maxConcurrentJobs: 1,
+    paths: {
+        buildsDir: '.ci-builds',
+        cacheDir: '.ci-cache',
+        derivedDataDir: '~/Library/Developer/Xcode/DerivedData',
+    },
+};
+describe('YAML Pipeline End-to-End Tests', () => {
+    const examplesDir = resolve(process.cwd(), 'examples');
+    describe('iOS Build Pipeline', () => {
+        const pipelinePath = resolve(examplesDir, 'ios-build.yml');
+        test('should load and parse iOS pipeline file', () => {
+            expect(existsSync(pipelinePath)).toBe(true);
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            expect(yamlPipeline.format_version).toBe('4');
+            expect(yamlPipeline.workflows).toBeDefined();
+            expect(yamlPipeline.workflows.primary).toBeDefined();
+            expect(yamlPipeline.workflows.debug).toBeDefined();
+        });
+        test('should convert primary workflow to PipelineDef', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            expect(result.pipeline.name).toBe('primary (YAML)');
+            expect(result.pipeline.steps).toBeDefined();
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            // Verify step IDs are generated
+            const stepIds = result.pipeline.steps.map(s => s.id);
+            expect(stepIds).toContain('step_1');
+            expect(stepIds).toContain('step_2');
+        });
+        test('should detect macOS platform for iOS workflow', () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const platformInfo = detectPlatformInfo(yamlPipeline, 'primary');
+            expect(platformInfo.platform).toBe('macos');
+            expect(platformInfo.stack).toBe('macos-ventura-xcode-15.1');
+            expect(platformInfo.machineType).toBe('performance');
+        });
+        test('should convert debug workflow to PipelineDef', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'debug');
+            expect(result.pipeline.name).toBe('debug (YAML)');
+            expect(result.pipeline.steps).toBeDefined();
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+        });
+        test('should include all expected iOS steps', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            const stepNames = result.pipeline.steps.map(s => s.name);
+            expect(stepNames).toContain('git-clone');
+            expect(stepNames).toContain('cache-pull');
+            expect(stepNames).toContain('cache-push');
+            // xcodebuild and xcode-test steps should exist (titles may vary)
+            expect(result.pipeline.steps.length).toBeGreaterThanOrEqual(5);
+        });
+        test('should include environment-dependent step scripts', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            // Check that steps have generated scripts (environment variables resolved during conversion)
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            // Check that all steps have valid scripts
+            for (const step of result.pipeline.steps) {
+                expect(step.script).toBeDefined();
+                expect(typeof step.script).toBe('string');
+                expect(step.script.length).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe('Android Build Pipeline', () => {
+        const pipelinePath = resolve(examplesDir, 'android-build.yml');
+        test('should load and parse Android pipeline file', () => {
+            expect(existsSync(pipelinePath)).toBe(true);
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            expect(yamlPipeline.format_version).toBe('4');
+            expect(yamlPipeline.workflows).toBeDefined();
+            expect(yamlPipeline.workflows.primary).toBeDefined();
+            expect(yamlPipeline.workflows.debug).toBeDefined();
+            expect(yamlPipeline.workflows.qa).toBeDefined();
+        });
+        test('should convert primary workflow to PipelineDef', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            expect(result.pipeline.name).toBe('primary (YAML)');
+            expect(result.pipeline.steps).toBeDefined();
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+        });
+        test('should detect Linux platform for Android workflow', () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const platformInfo = detectPlatformInfo(yamlPipeline, 'primary');
+            expect(platformInfo.platform).toBe('linux');
+            expect(platformInfo.stack).toBe('linux-docker-android-22.04');
+            expect(platformInfo.machineType).toBe('standard');
+        });
+        test('should include all expected Android steps', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            const stepNames = result.pipeline.steps.map(s => s.name);
+            expect(stepNames).toContain('git-clone');
+            expect(stepNames).toContain('cache-pull');
+            expect(stepNames).toContain('cache-push');
+            // Android build steps should exist (8 total in primary workflow)
+            expect(result.pipeline.steps.length).toBe(8);
+        });
+        test('should convert qa workflow with test filters', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'qa');
+            expect(result.pipeline.name).toBe('qa (YAML)');
+            expect(result.pipeline.steps).toBeDefined();
+            // QA workflow should have test steps with generated scripts
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            for (const step of result.pipeline.steps) {
+                expect(step.kind).toBe('script');
+                expect(step.script).toBeDefined();
+            }
+        });
+        test('should generate scripts with environment variables', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            // Check that all steps have generated scripts
+            for (const step of result.pipeline.steps) {
+                expect(step.script).toBeDefined();
+                expect(step.script.length).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe('Multi-Platform Pipeline', () => {
+        const pipelinePath = resolve(examplesDir, 'multi-platform.yml');
+        test('should load and parse multi-platform pipeline file', () => {
+            expect(existsSync(pipelinePath)).toBe(true);
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            expect(yamlPipeline.format_version).toBe('4');
+            expect(yamlPipeline.workflows).toBeDefined();
+            expect(Object.keys(yamlPipeline.workflows)).toHaveLength(4);
+        });
+        test('should have iOS and Android workflows', () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            expect(yamlPipeline.workflows['ios-build']).toBeDefined();
+            expect(yamlPipeline.workflows['android-build']).toBeDefined();
+            expect(yamlPipeline.workflows['ios-debug']).toBeDefined();
+            expect(yamlPipeline.workflows['android-debug']).toBeDefined();
+        });
+        test('should detect macOS platform for ios-build workflow', () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const platformInfo = detectPlatformInfo(yamlPipeline, 'ios-build');
+            expect(platformInfo.platform).toBe('macos');
+            expect(platformInfo.machineType).toBe('standard');
+        });
+        test('should detect Linux platform for android-build workflow', () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const platformInfo = detectPlatformInfo(yamlPipeline, 'android-build');
+            expect(platformInfo.platform).toBe('linux');
+            expect(platformInfo.machineType).toBe('standard');
+        });
+        test('should convert ios-build workflow to PipelineDef', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'ios-build');
+            expect(result.pipeline.name).toBe('ios-build (YAML)');
+            expect(result.pipeline.steps).toBeDefined();
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            // Verify all steps have scripts
+            for (const step of result.pipeline.steps) {
+                expect(step.script).toBeDefined();
+            }
+        });
+        test('should convert android-build workflow to PipelineDef', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'android-build');
+            expect(result.pipeline.name).toBe('android-build (YAML)');
+            expect(result.pipeline.steps).toBeDefined();
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            // Verify all steps have scripts
+            for (const step of result.pipeline.steps) {
+                expect(step.script).toBeDefined();
+            }
+        });
+        test('should process global and workflow-specific environment variables into scripts', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'ios-build');
+            // Verify steps were generated
+            expect(result.pipeline.steps).toBeDefined();
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            // All steps should have generated scripts
+            for (const step of result.pipeline.steps) {
+                expect(step.script).toBeDefined();
+                expect(step.script.length).toBeGreaterThan(0);
+            }
+        });
+        test('should use first workflow when no workflow specified', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig);
+            // Should default to first workflow in the object
+            expect(result.pipeline.name).toContain('(YAML)');
+            expect(result.pipeline.steps).toBeDefined();
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Workflow Selection', () => {
+        const pipelinePath = resolve(examplesDir, 'multi-platform.yml');
+        test('should throw error for non-existent workflow', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            await expect(async () => {
+                await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'non-existent-workflow');
+            }).rejects.toThrow();
+        });
+        test('should successfully select each workflow by name', async () => {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const workflowNames = ['ios-build', 'android-build', 'ios-debug', 'android-debug'];
+            for (const workflowName of workflowNames) {
+                const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, workflowName);
+                expect(result.pipeline.name).toBe(`${workflowName} (YAML)`);
+            }
+        });
+    });
+    describe('Step Script Generation', () => {
+        test('should generate valid bash scripts for all steps', async () => {
+            const pipelinePath = resolve(examplesDir, 'ios-build.yml');
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            for (const step of result.pipeline.steps) {
+                expect(step.kind).toBe('script');
+                expect(step.script).toBeDefined();
+                expect(typeof step.script).toBe('string');
+                expect(step.script.length).toBeGreaterThan(0);
+                // Scripts should be valid bash (start with shebang)
+                expect(step.script).toMatch(/^#!/);
+            }
+        });
+        test('should generate unique step IDs', async () => {
+            const pipelinePath = resolve(examplesDir, 'ios-build.yml');
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            const stepIds = result.pipeline.steps.map(s => s.id);
+            const uniqueIds = new Set(stepIds);
+            // All step IDs should be unique
+            expect(stepIds.length).toBe(uniqueIds.size);
+        });
+    });
+    describe('Environment Variable Resolution', () => {
+        test('should generate scripts with resolved variables', async () => {
+            const pipelinePath = resolve(examplesDir, 'android-build.yml');
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'primary');
+            // Scripts should be generated with resolved variable values
+            expect(result.pipeline.steps.length).toBe(8);
+            for (const step of result.pipeline.steps) {
+                expect(step.kind).toBe('script');
+                expect(step.script).toBeDefined();
+                expect(step.script.length).toBeGreaterThan(0);
+            }
+        });
+        test('should process app-level and workflow-level environment variables', async () => {
+            const pipelinePath = resolve(examplesDir, 'multi-platform.yml');
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'android-build');
+            // Verify all steps have valid scripts
+            expect(result.pipeline.steps.length).toBeGreaterThan(0);
+            for (const step of result.pipeline.steps) {
+                expect(step.script).toBeDefined();
+            }
+        });
+    });
+    describe('Platform Detection', () => {
+        test('should auto-detect platform from xcodebuild step', () => {
+            const pipelinePath = resolve(examplesDir, 'multi-platform.yml');
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const platformInfo = detectPlatformInfo(yamlPipeline, 'ios-build');
+            expect(platformInfo.platform).toBe('macos');
+        });
+        test('should auto-detect platform from gradle-build step', () => {
+            const pipelinePath = resolve(examplesDir, 'multi-platform.yml');
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const platformInfo = detectPlatformInfo(yamlPipeline, 'android-build');
+            expect(platformInfo.platform).toBe('linux');
+        });
+        test('should use stack metadata when available', () => {
+            const pipelinePath = resolve(examplesDir, 'ios-build.yml');
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            const platformInfo = detectPlatformInfo(yamlPipeline, 'primary');
+            expect(platformInfo.stack).toBe('macos-ventura-xcode-15.1');
+            expect(platformInfo.platform).toBe('macos');
+        });
+    });
+    describe('Unsupported Steps Integration', () => {
+        test('should handle YAML with mixed supported and unsupported steps', async () => {
+            // Create a temporary YAML in memory with mixed steps
+            const yamlContent = `format_version: '4'
+
+workflows:
+  test-warnings:
+    steps:
+      - script@1.0.0:
+          title: Valid script step
+          inputs:
+            content: |
+              echo "This step is supported"
+      - unsupported-bitrise-step@1.0.0:
+          title: This step does not exist
+          inputs:
+            some_input: value
+      - npm@1.0.0:
+          title: NPM step (should suggest script alternative)
+          inputs:
+            command: install
+      - script@1.0.0:
+          title: Another valid step
+          inputs:
+            content: |
+              echo "This step is also supported"
+      - cocoapods-install@2.0.0:
+          title: CocoaPods (should suggest script alternative)
+      - completely-unknown-step@3.0.0:
+          title: Unknown step (no suggestion)
+`;
+            // Parse YAML manually
+            // Use js-yaml for parsing
+            const yamlPipeline = jsYaml.load(yamlContent);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'test-warnings');
+            // Verify warnings were collected
+            expect(result.warnings).toBeDefined();
+            expect(result.warnings.length).toBe(3); // 3 unsupported steps (cocoapods-install is now supported)
+            // Verify skipped steps count
+            expect(result.skippedSteps).toBe(3);
+            // Verify supported steps were processed (script x2 + cocoapods-install)
+            expect(result.pipeline.steps.length).toBe(3);
+            expect(result.pipeline.steps[0].name).toBe('Valid script step');
+            expect(result.pipeline.steps[1].name).toBe('Another valid step');
+            expect(result.pipeline.steps[2].name).toBe('CocoaPods (should suggest script alternative)');
+            // Verify warning messages contain step names
+            expect(result.warnings[0]).toContain('unsupported-bitrise-step@1.0.0');
+            expect(result.warnings[1]).toContain('npm@1.0.0');
+            expect(result.warnings[2]).toContain('completely-unknown-step@3.0.0');
+            // Verify suggestions are included for known steps
+            expect(result.warnings[1]).toContain('💡 Suggestion');
+            expect(result.warnings[1]).toContain('script step with npm commands');
+            // Verify no suggestion for unknown step
+            expect(result.warnings[2]).not.toContain('💡 Suggestion');
+        });
+        test('should handle YAML with all unsupported steps', async () => {
+            const yamlContent = `format_version: '4'
+
+workflows:
+  all-unsupported:
+    steps:
+      - unsupported-1@1.0.0:
+          inputs: {}
+      - unsupported-2@2.0.0:
+          inputs: {}
+      - unsupported-3@3.0.0:
+          inputs: {}
+`;
+            // Use js-yaml for parsing
+            const yamlPipeline = jsYaml.load(yamlContent);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'all-unsupported');
+            // All steps should be skipped
+            expect(result.warnings.length).toBe(3);
+            expect(result.skippedSteps).toBe(3);
+            expect(result.pipeline.steps.length).toBe(0);
+            // Pipeline should still be valid
+            expect(result.pipeline.name).toBe('all-unsupported (YAML)');
+            expect(result.pipeline.stepsOrder.length).toBe(0);
+        });
+        test('should preserve step order after filtering unsupported steps', async () => {
+            const yamlContent = `format_version: '4'
+
+workflows:
+  order-test:
+    steps:
+      - script@1.0.0:
+          title: Step 1
+          inputs:
+            content: echo "1"
+      - unsupported-step@1.0.0:
+          inputs: {}
+      - script@1.0.0:
+          title: Step 2
+          inputs:
+            content: echo "2"
+      - another-unsupported@1.0.0:
+          inputs: {}
+      - script@1.0.0:
+          title: Step 3
+          inputs:
+            content: echo "3"
+`;
+            // Use js-yaml for parsing
+            const yamlPipeline = jsYaml.load(yamlContent);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'order-test');
+            // Verify order is preserved
+            expect(result.pipeline.steps.length).toBe(3);
+            expect(result.pipeline.steps[0].name).toBe('Step 1');
+            expect(result.pipeline.steps[1].name).toBe('Step 2');
+            expect(result.pipeline.steps[2].name).toBe('Step 3');
+            // Verify stepsOrder matches
+            expect(result.pipeline.stepsOrder.length).toBe(3);
+        });
+        test('should handle multiple versions of same unsupported step', async () => {
+            const yamlContent = `format_version: '4'
+
+workflows:
+  version-test:
+    steps:
+      - npm@1.0.0:
+          inputs: {}
+      - npm@2.0.0:
+          inputs: {}
+      - npm@3.5.0:
+          inputs: {}
+`;
+            // Use js-yaml for parsing
+            const yamlPipeline = jsYaml.load(yamlContent);
+            const result = await convertYAMLToPipelineDef(yamlPipeline, testConfig, 'version-test');
+            // Should warn about each version separately
+            expect(result.warnings.length).toBe(3);
+            expect(result.warnings[0]).toContain('npm@1.0.0');
+            expect(result.warnings[1]).toContain('npm@2.0.0');
+            expect(result.warnings[2]).toContain('npm@3.5.0');
+            // All should have the same suggestion
+            result.warnings.forEach(warning => {
+                expect(warning).toContain('💡 Suggestion');
+                expect(warning).toContain('script step with npm commands');
+            });
+        });
+    });
+});
+//# sourceMappingURL=e2e.test.js.map

package/dist/src/yaml/env-resolver.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Environment variable resolution and interpolation
+ * Merges global and workflow-level environment variables
+ * Supports variable interpolation in multiple formats
+ */
+import type { YAMLPipeline, YAMLWorkflow, Platform } from './types.js';
+export declare class MissingEnvironmentVariableError extends Error {
+    readonly variableName: string;
+    readonly stepName?: string | undefined;
+    readonly hint?: string | undefined;
+    constructor(variableName: string, stepName?: string | undefined, hint?: string | undefined);
+}
+/**
+ * EnvResolver handles environment variable merging and interpolation
+ */
+export declare class EnvResolver {
+    private envVars;
+    private referencedVars;
+    private secretsManager;
+    constructor(pipeline: YAMLPipeline, workflow: YAMLWorkflow, workflowName: string, platform: Platform, stack?: string, yamlFilePath?: string);
+    /**
+     * Gets the value of an environment variable
+     * @param name Variable name
+     * @returns Variable value or undefined if not found
+     */
+    get(name: string): string | undefined;
+    /**
+     * Checks if an environment variable is defined
+     * @param name Variable name
+     * @returns True if variable exists
+     */
+    has(name: string): boolean;
+    /**
+     * Registers a variable as a step output passthrough.
+     * When this variable appears in a later step's inputs it will be kept as
+     * the literal shell reference "$NAME" so the shell resolves it at runtime.
+     */
+    registerStepOutput(name: string): void;
+    /**
+     * Gets all environment variables as a plain object
+     * @returns Object with all environment variables
+     */
+    getAll(): Record<string, string>;
+    /**
+     * Interpolates environment variables in a string
+     * Supports four formats:
+     * - $VAR
+     * - ${VAR}
+     * - {{getenv "VAR"}}
+     * - {{checksum "path/to/file"}}
+     *
+     * @param str String to interpolate
+     * @param stepName Optional step name for error messages
+     * @returns Interpolated string
+     * @throws MissingEnvironmentVariableError if referenced variable not found
+     */
+    interpolate(str: string, stepName?: string): string;
+    /**
+     * Interpolates environment variables in an object recursively
+     * @param obj Object to interpolate
+     * @param stepName Optional step name for error messages
+     * @returns Interpolated object
+     */
+    interpolateObject(obj: any, stepName?: string): any;
+    /**
+     * Validates that all referenced variables are defined
+     * @throws MissingEnvironmentVariableError if any referenced variable is missing
+     */
+    validateReferencedVars(): void;
+    /**
+     * Resolves a single variable reference
+     * @param varName Variable name
+     * @param stepName Optional step name for error messages
+     * @returns Variable value
+     * @throws MissingEnvironmentVariableError if variable not found
+     */
+    private resolveVar;
+    /**
+     * Computes MD5 checksum of a file
+     * @param filePath Path to file (relative to current working directory)
+     * @returns MD5 hash of file contents
+     * @throws Error if file does not exist or cannot be read
+     */
+    private computeChecksum;
+    /**
+     * Adds built-in environment variables
+     * @param workflowName Name of the current workflow
+     * @param platform Detected platform
+     * @param stack Optional stack identifier
+     */
+    private addBuiltInVars;
+    /**
+     * Merges environment variables from YAML array format
+     * @param envArray Array of environment variable objects
+     */
+    private mergeEnvVars;
+    /**
+     * Resolves $SECRET{secret_id} references to actual secret values
+     * @param value Value that may contain a secret reference
+     * @returns Resolved value with secret content, or empty string if secret not found
+     */
+    private resolveSecretReference;
+    /**
+     * Interpolates environment variable value during initial setup
+     * This allows env vars to reference other env vars
+     * @param value Raw value
+     * @returns Interpolated value or original if interpolation fails
+     */
+    private interpolateEnvValue;
+}
+/**
+ * Helper function to create an EnvResolver for a workflow
+ * @param pipeline Parsed YAML pipeline
+ * @param workflowName Name of the workflow
+ * @param platform Detected platform
+ * @param stack Optional stack identifier
+ * @returns EnvResolver instance
+ */
+export declare function createEnvResolver(pipeline: YAMLPipeline, workflowName: string, platform: Platform, stack?: string): EnvResolver;
+//# sourceMappingURL=env-resolver.d.ts.map

package/dist/src/yaml/env-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-resolver.d.ts","sourceRoot":"","sources":["../../../src/yaml/env-resolver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAc,QAAQ,EAAE,MAAM,YAAY,CAAC;AAgEnF,qBAAa,+BAAgC,SAAQ,KAAK;aAEtC,YAAY,EAAE,MAAM;aACpB,QAAQ,CAAC,EAAE,MAAM;aACjB,IAAI,CAAC,EAAE,MAAM;gBAFb,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,IAAI,CAAC,EAAE,MAAM,YAAA;CAUhC;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,cAAc,CAAiB;gBAGrC,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,YAAY,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,CAAC,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,MAAM;IA0BvB;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKrC;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;;;OAIG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAMtC;;;OAGG;IACH,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQhC;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IA0BnD;;;;;OAKG;IACH,iBAAiB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,GAAG;IAoBnD;;;OAGG;IACH,sBAAsB,IAAI,IAAI;IAQ9B;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAalB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAwBvB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAmFtB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAkBpB;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAuB9B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;CAS5B;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,YAAY,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,CAAC,EAAE,MAAM,GACb,WAAW,CAOb"}