@invarn/cibuild 1.3.16 → 1.3.18

package/dist/src/yaml/platform-detector.test.js

@@ -0,0 +1,414 @@
+/**
+ * Unit tests for platform detection
+ */
+import { describe, test, expect } from '@jest/globals';
+import { PlatformDetector, detectPlatform, detectPlatformInfo, PlatformDetectionError } from './platform-detector.js';
+describe('PlatformDetector', () => {
+    describe('Priority 1: Extract from meta.cibuild.io.stack', () => {
+        test('should detect macOS from stack', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'cibuild.io': {
+                        stack: 'macos-ventura-xcode-15.1',
+                        machine_type: 'performance',
+                    },
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: { content: 'echo "test"' } } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('macos');
+            expect(detector.getStack()).toBe('macos-ventura-xcode-15.1');
+            expect(detector.getMachineType()).toBe('performance');
+        });
+        test('should detect linux from stack', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'cibuild.io': {
+                        stack: 'linux-docker-android-22.04',
+                        machine_type: 'standard',
+                    },
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: { content: 'echo "test"' } } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+            expect(detector.getStack()).toBe('linux-docker-android-22.04');
+            expect(detector.getMachineType()).toBe('standard');
+        });
+        test('should detect windows from stack', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'cibuild.io': {
+                        stack: 'windows-server-2022',
+                    },
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: { content: 'echo "test"' } } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('windows');
+            expect(detector.getStack()).toBe('windows-server-2022');
+            expect(detector.getMachineType()).toBeNull();
+        });
+    });
+    describe('Priority 2: Use meta.platform field', () => {
+        test('should use meta.platform when stack not specified', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    platform: 'macos',
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: { content: 'echo "test"' } } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('macos');
+            expect(detector.getStack()).toBeNull();
+            expect(detector.getMachineType()).toBeNull();
+        });
+        test('should use meta.platform: linux', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    platform: 'linux',
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: { content: 'echo "test"' } } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+        });
+    });
+    describe('Priority 3: Auto-detect from workflow steps', () => {
+        test('should detect macOS from xcodebuild step', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'git-clone@4.0.17': { inputs: {} } },
+                            { 'xcodebuild@5.0.0': { inputs: { project_path: './MyApp.xcodeproj' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('macos');
+        });
+        test('should detect macOS from xcode-test step', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'xcode-test@2.0.0': { inputs: { project_path: './MyApp.xcodeproj' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('macos');
+        });
+        test('should detect linux from gradle-build step', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'git-clone@4.0.17': { inputs: {} } },
+                            { 'gradle-build@1.0.0': { inputs: { project_location: './android' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+        });
+        test('should detect linux from android-lint step', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'android-lint@1.0.0': { inputs: { project_location: './android' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+        });
+        test('should detect linux from android-unit-test step', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'android-unit-test@1.0.0': { inputs: { project_location: './android' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+        });
+        test('should detect linux from set-java-version step', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'set-java-version@1.0.0': { inputs: { java_version: '17' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+        });
+        test('should default to linux for platform-agnostic steps', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'git-clone@4.0.17': { inputs: {} } },
+                            { 'script@1.0.0': { inputs: { content: 'npm install' } } },
+                            { 'cache-push@2.0.0': { inputs: { cache_paths: 'node_modules' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+        });
+    });
+    describe('Mixed platform detection (FR-37)', () => {
+        test('should throw error for mixed macOS and Linux steps', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'xcodebuild@5.0.0': { inputs: { project_path: './ios' } } },
+                            { 'gradle-build@1.0.0': { inputs: { project_location: './android' } } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(() => detector.getPlatform()).toThrow(PlatformDetectionError);
+            expect(() => detector.getPlatform()).toThrow(/contains steps for multiple platforms/);
+            expect(() => detector.getPlatform()).toThrow(/xcodebuild/);
+            expect(() => detector.getPlatform()).toThrow(/gradle-build/);
+        });
+        test('should throw error listing all mixed platform steps', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'xcodebuild@5.0.0': { inputs: {} } },
+                            { 'xcode-test@2.0.0': { inputs: {} } },
+                            { 'gradle-build@1.0.0': { inputs: {} } },
+                            { 'android-lint@1.0.0': { inputs: {} } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(() => detector.getPlatform()).toThrow(/xcodebuild.*xcode-test/);
+            expect(() => detector.getPlatform()).toThrow(/gradle-build.*android-lint/);
+        });
+    });
+    describe('Step name parsing', () => {
+        test('should parse step name with version', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { 'xcodebuild@5.0.0': { inputs: {} } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('macos');
+        });
+        test('should parse step name without version', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            { xcodebuild: { inputs: {} } },
+                        ],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('macos');
+        });
+    });
+    describe('getPlatformInfo()', () => {
+        test('should return complete platform info with all fields', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'cibuild.io': {
+                        stack: 'macos-ventura-xcode-15.1',
+                        machine_type: 'performance',
+                    },
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: {} } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            const info = detector.getPlatformInfo();
+            expect(info.platform).toBe('macos');
+            expect(info.stack).toBe('macos-ventura-xcode-15.1');
+            expect(info.machineType).toBe('performance');
+        });
+        test('should return platform info with only platform field', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [{ 'xcodebuild@5.0.0': { inputs: {} } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            const info = detector.getPlatformInfo();
+            expect(info.platform).toBe('macos');
+            expect(info.stack).toBeUndefined();
+            expect(info.machineType).toBeUndefined();
+        });
+    });
+    describe('Helper functions', () => {
+        test('detectPlatform() should work', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [{ 'xcodebuild@5.0.0': { inputs: {} } }],
+                    },
+                },
+            };
+            const platform = detectPlatform(pipeline, 'primary');
+            expect(platform).toBe('macos');
+        });
+        test('detectPlatform() should throw for non-existent workflow', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [{ 'xcodebuild@5.0.0': { inputs: {} } }],
+                    },
+                },
+            };
+            expect(() => detectPlatform(pipeline, 'nonexistent')).toThrow(/not found/);
+        });
+        test('detectPlatformInfo() should work', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'cibuild.io': {
+                        stack: 'linux-docker-android-22.04',
+                    },
+                },
+                workflows: {
+                    build: {
+                        steps: [{ 'gradle-build@1.0.0': { inputs: {} } }],
+                    },
+                },
+            };
+            const info = detectPlatformInfo(pipeline, 'build');
+            expect(info.platform).toBe('linux');
+            expect(info.stack).toBe('linux-docker-android-22.04');
+        });
+        test('detectPlatformInfo() should throw for non-existent workflow', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: {} } }],
+                    },
+                },
+            };
+            expect(() => detectPlatformInfo(pipeline, 'missing')).toThrow(/not found/);
+        });
+    });
+    describe('Edge cases', () => {
+        test('should handle empty steps array (defaults to linux)', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux');
+        });
+        test('should handle stack with priority over platform field', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'cibuild.io': {
+                        stack: 'macos-ventura-xcode-15.1',
+                    },
+                    platform: 'linux', // This should be ignored
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'script@1.0.0': { inputs: {} } }],
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('macos'); // Stack takes priority
+        });
+        test('should handle platform field with priority over step detection', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    platform: 'linux',
+                },
+                workflows: {
+                    primary: {
+                        steps: [{ 'xcodebuild@5.0.0': { inputs: {} } }], // Would auto-detect as macOS
+                    },
+                },
+            };
+            const detector = new PlatformDetector(pipeline, pipeline.workflows.primary, 'primary');
+            expect(detector.getPlatform()).toBe('linux'); // Explicit platform takes priority
+        });
+    });
+});
+//# sourceMappingURL=platform-detector.test.js.map

package/dist/src/yaml/preflight-validation.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pre-flight validation for mandatory workflow requirements
+ * Validates repository access before workflow execution begins
+ */
+import { MissingEnvironmentVariableError } from './env-resolver.js';
+import type { SecretsManager } from './secrets-manager.js';
+import type { YAMLWorkflow } from './types.js';
+/**
+ * Pre-flight validation results
+ */
+export interface PreFlightResult {
+    success: boolean;
+    error?: MissingEnvironmentVariableError;
+}
+/**
+ * Validates that required environment variables exist and repository is accessible
+ * This runs before any workflow steps execute
+ */
+export declare class PreFlightValidator {
+    /**
+     * Check if workflow has activate-ssh-key step before git-clone
+     * @param workflow The workflow to check
+     * @returns True if SSH key setup is in the workflow
+     */
+    private hasSSHKeySetup;
+    /**
+     * Validates CIBUILD_GIT_REPOSITORY_URL exists and is accessible
+     * @param env Environment variables
+     * @param secretsManager Secrets manager to check for stored secrets
+     * @param workflow The workflow to check for SSH key setup
+     * @returns Validation result
+     */
+    validateRepositoryAccess(env: Record<string, string>, secretsManager?: SecretsManager, workflow?: YAMLWorkflow): Promise<PreFlightResult>;
+    /**
+     * Run all pre-flight validations
+     * git-clone now uses the local checkout — no remote URL or connectivity check needed.
+     */
+    validate(_env: Record<string, string>, _secretsManager?: SecretsManager, _workflow?: YAMLWorkflow): Promise<PreFlightResult>;
+}
+//# sourceMappingURL=preflight-validation.d.ts.map

package/dist/src/yaml/preflight-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight-validation.d.ts","sourceRoot":"","sources":["../../../src/yaml/preflight-validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,+BAA+B,CAAC;CACzC;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B;;;;OAIG;IACH,OAAO,CAAC,cAAc;IA0BtB;;;;;;OAMG;IACG,wBAAwB,CAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,cAAc,CAAC,EAAE,cAAc,EAC/B,QAAQ,CAAC,EAAE,YAAY,GACtB,OAAO,CAAC,eAAe,CAAC;IA2H3B;;;OAGG;IACG,QAAQ,CACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,eAAe,CAAC,EAAE,cAAc,EAChC,SAAS,CAAC,EAAE,YAAY,GACvB,OAAO,CAAC,eAAe,CAAC;CAG5B"}

package/dist/src/yaml/preflight-validation.js

@@ -0,0 +1,152 @@
+/**
+ * Pre-flight validation for mandatory workflow requirements
+ * Validates repository access before workflow execution begins
+ */
+import { execSync } from 'child_process';
+import { MissingEnvironmentVariableError } from './env-resolver.js';
+/**
+ * Validates that required environment variables exist and repository is accessible
+ * This runs before any workflow steps execute
+ */
+export class PreFlightValidator {
+    /**
+     * Check if workflow has activate-ssh-key step before git-clone
+     * @param workflow The workflow to check
+     * @returns True if SSH key setup is in the workflow
+     */
+    hasSSHKeySetup(workflow) {
+        if (!workflow.steps || workflow.steps.length === 0) {
+            return false;
+        }
+        let foundSSHKeyStep = false;
+        for (const step of workflow.steps) {
+            // Step can be an object with step name as key
+            const stepName = typeof step === 'string' ? step : Object.keys(step)[0];
+            // Check for git-clone step first - if we hit it before finding SSH key, return false
+            if (stepName.startsWith('git-clone')) {
+                return foundSSHKeyStep; // Return true only if we found SSH key before this
+            }
+            // Check for activate-ssh-key step
+            if (stepName.startsWith('activate-ssh-key')) {
+                foundSSHKeyStep = true;
+            }
+        }
+        // If we got here, no git-clone step was found, so return if SSH key exists
+        return foundSSHKeyStep;
+    }
+    /**
+     * Validates CIBUILD_GIT_REPOSITORY_URL exists and is accessible
+     * @param env Environment variables
+     * @param secretsManager Secrets manager to check for stored secrets
+     * @param workflow The workflow to check for SSH key setup
+     * @returns Validation result
+     */
+    async validateRepositoryAccess(env, secretsManager, workflow) {
+        // Check environment variables first, then secrets manager
+        let repoUrl = env.CIBUILD_GIT_REPOSITORY_URL || env.GIT_REPOSITORY_URL || '';
+        // If not in env, check secrets manager
+        if ((!repoUrl || repoUrl.trim() === '') && secretsManager) {
+            const secretId = secretsManager.getSecretIdByName('CIBUILD_GIT_REPOSITORY_URL');
+            if (secretId) {
+                repoUrl = secretsManager.getSecret(secretId) || '';
+            }
+        }
+        // Check if repository URL is provided
+        if (!repoUrl || repoUrl.trim() === '') {
+            return {
+                success: false,
+                error: new MissingEnvironmentVariableError('CIBUILD_GIT_REPOSITORY_URL', 'preflight-validation', 'Git repository URL for cloning source code in CI/CD builds.\n\n' +
+                    'Expected format:\n' +
+                    '  ┌────────────────────────────────────────────────────────┐\n' +
+                    '  │ https://github.com/username/repository.git             │\n' +
+                    '  │ git@github.com:username/repository.git                 │\n' +
+                    '  │ https://gitlab.com/username/repository.git             │\n' +
+                    '  └────────────────────────────────────────────────────────┘\n\n' +
+                    'How to set it:\n' +
+                    '  • Environment variable: GIT_REPOSITORY_URL=<your-repo-url>\n' +
+                    '  • In YAML inputs: repository: <your-repo-url>\n' +
+                    '  • CI platform automatically provides this in most cases'),
+            };
+        }
+        // If the workflow uses activate-ssh-key, skip connectivity test entirely.
+        // SSH authentication isn't available pre-execution, so any network test would fail
+        // for private repos regardless of whether the URL is SSH or HTTPS format.
+        const hasSSHKeyInWorkflow = workflow ? this.hasSSHKeySetup(workflow) : false;
+        if (hasSSHKeyInWorkflow) {
+            console.log('🔍 Pre-flight: Validating repository URL...');
+            console.log(`   Repository: ${repoUrl}`);
+            console.log('   SSH authentication will be configured by activate-ssh-key step');
+            console.log('✅ Pre-flight: Repository URL validated (connectivity test skipped)\n');
+            return { success: true };
+        }
+        // Test repository connectivity using git ls-remote
+        try {
+            console.log('🔍 Pre-flight: Validating repository access...');
+            console.log(`   Repository: ${repoUrl}`);
+            // Execute git ls-remote to check if repository is accessible
+            // This command lists remote references without cloning
+            // Timeout after 10 seconds to prevent hanging
+            execSync(`git ls-remote "${repoUrl}" HEAD`, {
+                stdio: 'pipe',
+                timeout: 10000,
+                encoding: 'utf-8',
+            });
+            console.log('✅ Pre-flight: Repository is accessible\n');
+            return { success: true };
+        }
+        catch (error) {
+            // Repository is not accessible - analyze the error
+            const errorMessage = error.message || String(error);
+            console.log(`❌ Pre-flight: Repository access failed`);
+            console.log(`   Error: ${errorMessage}\n`);
+            // Check if this is an SSH authentication error
+            const isSSHAuthError = errorMessage.includes('Permission denied') &&
+                errorMessage.includes('publickey');
+            const isSSHUrl = repoUrl.startsWith('git@') || repoUrl.includes('ssh://');
+            if (isSSHAuthError || (isSSHUrl && errorMessage.includes('Could not read from remote'))) {
+                // SSH authentication is the issue, not the repository URL
+                console.log('⚠️  Repository URL is valid, but SSH authentication is required.\n');
+                console.log('Please ensure:');
+                console.log('  1. SSH key is configured in your workflow (activate-ssh-key step)');
+                console.log('  2. SSH key has access to this repository');
+                console.log('  3. SSH key is added to your GitHub/GitLab account\n');
+                throw new Error('Pre-flight validation failed: SSH authentication required.\n\n' +
+                    `Repository: ${repoUrl}\n\n` +
+                    'The repository URL is valid but requires SSH authentication.\n' +
+                    'Make sure your workflow includes an "activate-ssh-key" step before "git-clone".\n\n' +
+                    'Example workflow:\n' +
+                    '  steps:\n' +
+                    '    - activate-ssh-key@4:  # Add SSH key first\n' +
+                    '        inputs:\n' +
+                    '          ssh_key_save_path: $HOME/.ssh/bitrise_rsa\n' +
+                    '    - git-clone@6:         # Then clone\n\n' +
+                    `Error details: ${errorMessage}`);
+            }
+            // For other errors (invalid URL, network issues, etc.), return error
+            return {
+                success: false,
+                error: new MissingEnvironmentVariableError('CIBUILD_GIT_REPOSITORY_URL', 'preflight-validation', 'Git repository URL validation failed. The repository is not accessible.\n\n' +
+                    'Expected format:\n' +
+                    '  ┌────────────────────────────────────────────────────────┐\n' +
+                    '  │ https://github.com/username/repository.git             │\n' +
+                    '  │ git@github.com:username/repository.git                 │\n' +
+                    '  │ https://gitlab.com/username/repository.git             │\n' +
+                    '  └────────────────────────────────────────────────────────┘\n\n' +
+                    'Common issues:\n' +
+                    '  • Invalid repository URL\n' +
+                    '  • Network connectivity issues\n' +
+                    '  • Repository does not exist or is private\n' +
+                    '  • Wrong URL format (check for typos)\n\n' +
+                    `Error details: ${errorMessage}`),
+            };
+        }
+    }
+    /**
+     * Run all pre-flight validations
+     * git-clone now uses the local checkout — no remote URL or connectivity check needed.
+     */
+    async validate(_env, _secretsManager, _workflow) {
+        return { success: true };
+    }
+}
+//# sourceMappingURL=preflight-validation.js.map