@invarn/cibuild 1.3.16 → 1.3.17

package/dist/src/yaml/converter.js

@@ -0,0 +1,222 @@
+/**
+ * Converts YAML pipeline workflows to PipelineDef format
+ * This bridges the YAML configuration with the existing runner engine
+ */
+import { detectPlatformInfo } from './platform-detector.js';
+import { EnvResolver } from './env-resolver.js';
+import { getStepExecutor, UnrecognizedStepError } from './steps/registry.js';
+export class YAMLConversionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'YAMLConversionError';
+    }
+}
+/**
+ * Mapping of common unsupported steps to CI Build alternatives
+ */
+const STEP_SUGGESTIONS = {
+    'create-install-page-qr-code': 'Use script step with qrencode to generate QR codes',
+    'deploy-to-itunesconnect-deliver': 'Use script step with fastlane deliver or xcrun altool',
+    'deploy-to-itunesconnect-application-loader': 'Use script step with xcrun altool',
+    'amazon-s3-deploy': 'Use built-in S3 upload via upload-artifacts.sh script',
+    'deploy-to-bitrise-io': 'Use app-store-deploy (iOS) or google-play-deploy (Android) for store deployment, or a script step for generic S3 upload',
+    'generic-file-storage': 'Use a script step with upload-artifacts.sh for S3 upload',
+    'bitrise-step-install-from-source': 'Not supported - use native CI Build steps',
+    'npm': 'Use script step with npm commands',
+    'yarn': 'Use script step with yarn commands',
+    'danger': 'Use script step with danger commands',
+    'firebase-app-distribution': 'Use script step with Firebase CLI',
+    'firebase-test-lab': 'Use script step with gcloud firebase test',
+    'find-jira-issue': 'Use script step with JIRA REST API',
+    'comment-on-github-pull-request': 'Use script step with GitHub API or gh CLI',
+};
+/**
+ * Bitrise step names that differ from their cibuild equivalents.
+ * Most Bitrise steps keep the same name — only remaps are listed here.
+ * See steps/bitrise-map.yml for the full version-tracking map.
+ */
+const BITRISE_TO_CIBUILD = {
+    'gradle-runner': 'gradle-build',
+    'certificate-and-profile-installer': 'certificate-installer',
+    'android-detekt': 'detekt',
+    'bitrise-step-flutter-installer': 'flutter-installer',
+};
+/**
+ * Converts a YAML pipeline workflow to PipelineDef format
+ * @param pipeline Parsed YAML pipeline
+ * @param config CI configuration with path mappings
+ * @param workflowName Name of the workflow to convert (if not specified, uses first workflow)
+ * @param yamlFilePath Optional path to the YAML file (used for naming SSH keys, etc.)
+ * @returns ConversionResult with PipelineDef and warnings about unsupported steps
+ */
+export async function convertYAMLToPipelineDef(pipeline, config, workflowName, yamlFilePath) {
+    // Initialize warnings collection
+    const warnings = [];
+    let skippedSteps = 0;
+    // Step 1: Workflow selection (FR-22, sub-task 3.7)
+    const selectedWorkflow = selectWorkflow(pipeline, workflowName);
+    const selectedWorkflowName = workflowName || Object.keys(pipeline.workflows)[0];
+    // Step 2: Platform detection
+    const platformInfo = detectPlatformInfo(pipeline, selectedWorkflowName);
+    // Step 3: Environment variable resolution
+    const envResolver = new EnvResolver(pipeline, selectedWorkflow, selectedWorkflowName, platformInfo.platform, platformInfo.stack, yamlFilePath);
+    // Step 4: Parse and convert steps
+    const steps = [];
+    const stepsOrder = [];
+    let stepCounter = 0;
+    for (const yamlStep of selectedWorkflow.steps) {
+        // Parse step (sub-task 3.8)
+        const parsedStep = parseStep(yamlStep, stepCounter);
+        stepCounter++;
+        // Handle conditional execution (sub-task 3.9)
+        // Note: run_if, is_always_run, is_skippable will be implemented
+        // when we have the step registry
+        // Remap Bitrise step names that differ from cibuild names
+        const resolvedStepName = BITRISE_TO_CIBUILD[parsedStep.name] ?? parsedStep.name;
+        // Get step executor from registry - catch unrecognized steps
+        let stepExecutor;
+        try {
+            stepExecutor = getStepExecutor(resolvedStepName);
+        }
+        catch (error) {
+            if (error instanceof UnrecognizedStepError) {
+                // Add warning and skip this step
+                const stepIdentifier = parsedStep.version
+                    ? `${parsedStep.name}@${parsedStep.version}`
+                    : parsedStep.name;
+                // Check if there's a suggested alternative
+                const suggestion = STEP_SUGGESTIONS[parsedStep.name];
+                let warningMessage = `⚠️  Unsupported step: ${stepIdentifier} (skipping)`;
+                if (suggestion) {
+                    warningMessage += `\n   💡 Suggestion: ${suggestion}`;
+                }
+                warnings.push(warningMessage);
+                skippedSteps++;
+                continue; // Skip to next step
+            }
+            // Re-throw other errors
+            throw error;
+        }
+        // Interpolate step inputs
+        const interpolatedInputs = envResolver.interpolateObject(parsedStep.inputs, parsedStep.title || parsedStep.name);
+        // Execute step to get script
+        const stepDef = await stepExecutor.execute(interpolatedInputs, envResolver.getAll(), config);
+        // Generate unique step ID
+        const stepId = `step_${stepCounter}`;
+        stepDef.id = stepId;
+        stepDef.name = parsedStep.title || parsedStep.name;
+        // Cache steps are always skippable — they degrade gracefully and should
+        // never abort a pipeline.
+        const alwaysSkippableSteps = ['cache-pull', 'cache-push'];
+        stepDef.isSkippable = parsedStep.is_skippable || alwaysSkippableSteps.includes(resolvedStepName);
+        steps.push(stepDef);
+        stepsOrder.push(stepId);
+        // Register this step's outputs as passthrough shell references so that
+        // later steps can reference them without triggering a missing-var error.
+        if (stepExecutor.getOutputs) {
+            for (const output of stepExecutor.getOutputs()) {
+                envResolver.registerStepOutput(output.name);
+            }
+        }
+    }
+    // Step 5: Create PipelineDef
+    const pipelineDef = {
+        name: `${selectedWorkflowName} (YAML)`,
+        artifacts: [], // YAML pipelines don't define artifacts in the same way
+        steps,
+        stepsOrder,
+    };
+    return {
+        pipeline: pipelineDef,
+        warnings,
+        skippedSteps,
+    };
+}
+/**
+ * Selects a workflow from the pipeline
+ * If workflowName is not specified, returns the first workflow
+ * @param pipeline Parsed YAML pipeline
+ * @param workflowName Optional workflow name
+ * @returns Selected workflow
+ * @throws YAMLConversionError if workflow not found
+ */
+function selectWorkflow(pipeline, workflowName) {
+    // If no workflow specified, use the first one (FR-4)
+    if (!workflowName) {
+        const firstWorkflowName = Object.keys(pipeline.workflows)[0];
+        return pipeline.workflows[firstWorkflowName];
+    }
+    // Check if specified workflow exists
+    const workflow = pipeline.workflows[workflowName];
+    if (!workflow) {
+        const availableWorkflows = Object.keys(pipeline.workflows).join(', ');
+        throw new YAMLConversionError(`Workflow '${workflowName}' not found in pipeline.\n` +
+            `Available workflows: ${availableWorkflows}`);
+    }
+    return workflow;
+}
+/**
+ * Parses a YAML step object into a ParsedStep
+ * Handles the step-name@version format
+ * @param yamlStep YAML step object
+ * @param index Step index for error messages
+ * @returns ParsedStep with name, version, and inputs
+ */
+function parseStep(yamlStep, index) {
+    // Each YAML step is an object with one key: "step-name@version"
+    const stepKeys = Object.keys(yamlStep);
+    if (stepKeys.length === 0) {
+        throw new YAMLConversionError(`Step at index ${index} has no step name defined`);
+    }
+    const stepNameWithVersion = stepKeys[0];
+    const stepConfig = yamlStep[stepNameWithVersion];
+    // Parse step name and version (FR-8)
+    const { name, version } = parseStepNameAndVersion(stepNameWithVersion);
+    // Convert Bitrise array-style inputs to object format
+    let inputs = stepConfig.inputs || {};
+    if (Array.isArray(inputs)) {
+        // Bitrise format: inputs are an array of objects with single key-value pairs
+        const inputsObj = {};
+        for (const input of inputs) {
+            if (typeof input === 'object' && input !== null) {
+                Object.assign(inputsObj, input);
+            }
+        }
+        inputs = inputsObj;
+    }
+    // Extract step configuration
+    const parsedStep = {
+        name,
+        version,
+        title: stepConfig.title,
+        inputs,
+        run_if: stepConfig.run_if,
+        is_always_run: stepConfig.is_always_run,
+        is_skippable: stepConfig.is_skippable,
+    };
+    return parsedStep;
+}
+/**
+ * Parses step name and version from "step-name@version" format
+ * @param stepNameWithVersion Full step identifier
+ * @returns Object with name and optional version
+ */
+function parseStepNameAndVersion(stepNameWithVersion) {
+    const atIndex = stepNameWithVersion.indexOf('@');
+    if (atIndex === -1) {
+        // No version specified
+        return { name: stepNameWithVersion };
+    }
+    const name = stepNameWithVersion.substring(0, atIndex);
+    const version = stepNameWithVersion.substring(atIndex + 1);
+    return { name, version };
+}
+/**
+ * Helper function to get available workflow names from a pipeline
+ * @param pipeline Parsed YAML pipeline
+ * @returns Array of workflow names
+ */
+export function getAvailableWorkflows(pipeline) {
+    return Object.keys(pipeline.workflows);
+}
+//# sourceMappingURL=converter.js.map

package/dist/src/yaml/converter.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for YAML to PipelineDef conversion with warning system
+ */
+export {};
+//# sourceMappingURL=converter.test.d.ts.map

package/dist/src/yaml/converter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.test.d.ts","sourceRoot":"","sources":["../../../src/yaml/converter.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

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

@@ -0,0 +1,348 @@
+/**
+ * Unit tests for YAML to PipelineDef conversion with warning system
+ */
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { convertYAMLToPipelineDef, YAMLConversionError } from './converter.js';
+import { clearRegistry, registerStep } from './steps/registry.js';
+import { ScriptStepExecutor } from './steps/script.js';
+import { CocoapodsInstallStepExecutor } from './steps/ios-deps.js';
+describe('convertYAMLToPipelineDef - Warning System', () => {
+    let mockConfig;
+    beforeEach(() => {
+        // Clear registry before each test
+        clearRegistry();
+        // Register steps used in tests
+        registerStep('script', new ScriptStepExecutor());
+        registerStep('cocoapods-install', new CocoapodsInstallStepExecutor());
+        // Mock config
+        mockConfig = {
+            artifactsDir: '/test/artifacts',
+            maxConcurrentJobs: 1,
+            paths: {
+                buildsDir: '/test/builds',
+                cacheDir: '/test/cache',
+                derivedDataDir: '/test/derived-data',
+            },
+            interpreters: {
+                bash: '/bin/bash',
+                python: 'python3',
+                ruby: 'ruby',
+                node: 'node',
+            },
+        };
+    });
+    afterEach(() => {
+        // Clean up registry
+        clearRegistry();
+    });
+    describe('Unsupported step handling', () => {
+        test('should collect warnings for unsupported steps', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'script@1.0.0': {
+                                    title: 'Valid step',
+                                    inputs: { content: 'echo "test"' },
+                                },
+                            },
+                            {
+                                'unsupported-step@1.0.0': {
+                                    title: 'This step does not exist',
+                                    inputs: {},
+                                },
+                            },
+                            {
+                                'another-unsupported@2.0.0': {
+                                    inputs: {},
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            // Should have warnings
+            expect(result.warnings).toBeDefined();
+            expect(result.warnings.length).toBe(2);
+            // Should include step names with versions
+            expect(result.warnings[0]).toContain('unsupported-step@1.0.0');
+            expect(result.warnings[1]).toContain('another-unsupported@2.0.0');
+            // Should have warning symbol
+            expect(result.warnings[0]).toContain('⚠️');
+            expect(result.warnings[1]).toContain('⚠️');
+            // Should indicate skipping
+            expect(result.warnings[0]).toContain('skipping');
+            expect(result.warnings[1]).toContain('skipping');
+            // Should track skipped steps count
+            expect(result.skippedSteps).toBe(2);
+            // Pipeline should only contain the valid step
+            expect(result.pipeline.steps.length).toBe(1);
+            expect(result.pipeline.steps[0].name).toBe('Valid step');
+        });
+        test('should handle unsupported step without version', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'unknown-step': {
+                                    title: 'No version specified',
+                                    inputs: {},
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            expect(result.warnings.length).toBe(1);
+            expect(result.warnings[0]).toContain('unknown-step');
+            expect(result.warnings[0]).not.toContain('@');
+            expect(result.skippedSteps).toBe(1);
+            expect(result.pipeline.steps.length).toBe(0);
+        });
+        test('should return empty warnings for fully supported pipeline', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'script@1.0.0': {
+                                    title: 'Step 1',
+                                    inputs: { content: 'echo "1"' },
+                                },
+                            },
+                            {
+                                'script@1.0.0': {
+                                    title: 'Step 2',
+                                    inputs: { content: 'echo "2"' },
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            expect(result.warnings).toBeDefined();
+            expect(result.warnings.length).toBe(0);
+            expect(result.skippedSteps).toBe(0);
+            expect(result.pipeline.steps.length).toBe(2);
+        });
+    });
+    describe('Step suggestions', () => {
+        test('should include suggestions for known unsupported steps', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'npm@1.0.0': {
+                                    title: 'NPM step',
+                                    inputs: { command: 'install' },
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            expect(result.warnings.length).toBe(1);
+            expect(result.warnings[0]).toContain('npm@1.0.0');
+            expect(result.warnings[0]).toContain('💡 Suggestion');
+            expect(result.warnings[0]).toContain('script step with npm commands');
+        });
+        test('should convert cocoapods-install as a supported step', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'cocoapods-install@2.0.0': {
+                                    inputs: {},
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            expect(result.warnings.length).toBe(0);
+            expect(result.skippedSteps).toBe(0);
+            expect(result.pipeline.steps.length).toBe(1);
+        });
+        test('should not include suggestions for unknown steps', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'completely-unknown-step@1.0.0': {
+                                    inputs: {},
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            expect(result.warnings.length).toBe(1);
+            expect(result.warnings[0]).toContain('completely-unknown-step@1.0.0');
+            expect(result.warnings[0]).not.toContain('💡 Suggestion');
+        });
+    });
+    describe('Mixed supported and unsupported steps', () => {
+        test('should process supported steps and warn about unsupported ones', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'script@1.0.0': {
+                                    title: 'Step 1',
+                                    inputs: { content: 'echo "1"' },
+                                },
+                            },
+                            {
+                                'unsupported-1@1.0.0': {
+                                    title: 'Unsupported 1',
+                                    inputs: {},
+                                },
+                            },
+                            {
+                                'script@1.0.0': {
+                                    title: 'Step 2',
+                                    inputs: { content: 'echo "2"' },
+                                },
+                            },
+                            {
+                                'unsupported-2@2.0.0': {
+                                    title: 'Unsupported 2',
+                                    inputs: {},
+                                },
+                            },
+                            {
+                                'script@1.0.0': {
+                                    title: 'Step 3',
+                                    inputs: { content: 'echo "3"' },
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            // Should have 2 warnings
+            expect(result.warnings.length).toBe(2);
+            expect(result.skippedSteps).toBe(2);
+            // Should have 3 valid steps
+            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');
+            // Step order should be preserved
+            expect(result.pipeline.stepsOrder.length).toBe(3);
+        });
+        test('should handle all unsupported steps', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'unsupported-1@1.0.0': {
+                                    inputs: {},
+                                },
+                            },
+                            {
+                                'unsupported-2@1.0.0': {
+                                    inputs: {},
+                                },
+                            },
+                            {
+                                'unsupported-3@1.0.0': {
+                                    inputs: {},
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            expect(result.warnings.length).toBe(3);
+            expect(result.skippedSteps).toBe(3);
+            expect(result.pipeline.steps.length).toBe(0);
+        });
+    });
+    describe('ConversionResult structure', () => {
+        test('should return valid ConversionResult structure', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'script@1.0.0': {
+                                    inputs: { content: 'echo "test"' },
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            // Should have all required properties
+            expect(result).toHaveProperty('pipeline');
+            expect(result).toHaveProperty('warnings');
+            expect(result).toHaveProperty('skippedSteps');
+            // Types should be correct
+            expect(Array.isArray(result.warnings)).toBe(true);
+            expect(typeof result.skippedSteps).toBe('number');
+            expect(result.pipeline).toHaveProperty('name');
+            expect(result.pipeline).toHaveProperty('steps');
+            expect(result.pipeline).toHaveProperty('stepsOrder');
+        });
+    });
+    describe('Error handling', () => {
+        test('should throw YAMLConversionError for invalid workflow name', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [],
+                    },
+                },
+            };
+            await expect(convertYAMLToPipelineDef(pipeline, mockConfig, 'nonexistent')).rejects.toThrow(YAMLConversionError);
+        });
+        test('should not throw for unsupported steps (should warn instead)', async () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        steps: [
+                            {
+                                'unsupported-step@1.0.0': {
+                                    inputs: {},
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            // Should not throw, should return warnings instead
+            const result = await convertYAMLToPipelineDef(pipeline, mockConfig, 'primary');
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.skippedSteps).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=converter.test.js.map

package/dist/src/yaml/e2e.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * End-to-end integration tests for YAML pipelines
+ * Tests complete YAML pipeline loading and execution through CLI components
+ */
+import './steps/index.js';
+//# sourceMappingURL=e2e.test.d.ts.map

package/dist/src/yaml/e2e.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e.test.d.ts","sourceRoot":"","sources":["../../../src/yaml/e2e.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,kBAAkB,CAAC"}