@invarn/cibuild 1.3.15 → 1.3.17

package/dist/src/yaml/bitrise-compat.js

@@ -0,0 +1,206 @@
+/**
+ * Bitrise YAML Compatibility Layer
+ *
+ * This module provides compatibility functions to convert Bitrise YAML pipelines
+ * to CI Build format, including metadata conversion and environment variable mapping.
+ */
+/**
+ * Map of Bitrise environment variables to CI Build equivalents
+ * Used for automatic variable substitution (FR-9.2)
+ */
+export const BITRISE_ENV_MAP = {
+    // Build information
+    BITRISE_BUILD_NUMBER: 'CIBUILD_BUILD_NUMBER',
+    BITRISE_BUILD_URL: 'CIBUILD_BUILD_URL',
+    BITRISE_APP_TITLE: 'CIBUILD_APP_TITLE',
+    // Git information
+    BITRISE_GIT_BRANCH: 'CIBUILD_GIT_BRANCH',
+    BITRISE_GIT_REPOSITORY_URL: 'CIBUILD_GIT_REPOSITORY_URL',
+    BITRISE_GIT_COMMIT: 'CIBUILD_GIT_COMMIT',
+    BITRISE_SOURCE_DIR: 'CIBUILD_SOURCE_DIR',
+    BITRISE_TRIGGERED_WORKFLOW_ID: 'CIBUILD_TRIGGERED_WORKFLOW_ID',
+    // Xcode-specific
+    BITRISE_XCODE_VERSION: 'CIBUILD_XCODE_VERSION',
+    BITRISE_SCHEME: 'CIBUILD_SCHEME',
+    // Gradle-specific
+    BITRISE_GRADLE_VERSION: 'CIBUILD_GRADLE_VERSION',
+};
+/**
+ * Bitrise environment variables that require user input
+ * These cannot be automatically mapped and must be provided by the user (FR-9.3)
+ */
+export const BITRISE_USER_REQUIRED_VARS = [
+    'CIBUILD_PUBLIC_INSTALL_PAGE_URL',
+    'CIBUILD_PUBLIC_INSTALL_PAGE_QR_CODE_IMAGE_URL',
+    'CIBUILD_PULL_REQUEST',
+    'CIBUILD_GIT_TAG',
+];
+/**
+ * Error class for Bitrise-specific environment variable issues
+ * Provides detailed information about missing variables (FR-9.3, FR-9.4, FR-9.5)
+ */
+export class BitriseEnvironmentError extends Error {
+    missingVariables;
+    constructor(missingVariables) {
+        const message = formatBitriseEnvironmentError(missingVariables);
+        super(message);
+        this.name = 'BitriseEnvironmentError';
+        this.missingVariables = missingVariables;
+    }
+}
+/**
+ * Converts Bitrise metadata to CI Build format
+ * Transforms meta.bitrise.io to meta.cibuild.io (FR-1.1, FR-1.2, FR-1.3)
+ *
+ * @param pipeline YAML pipeline object (mutated in place)
+ */
+export function convertBitriseMetadata(pipeline) {
+    // Check if Bitrise metadata exists
+    if (!pipeline.meta || !pipeline.meta['bitrise.io']) {
+        return;
+    }
+    const bitriseMeta = pipeline.meta['bitrise.io'];
+    // If cibuild.io metadata already exists, prefer it (FR-11.3)
+    if (pipeline.meta['cibuild.io']) {
+        // Keep both for reference, but CI Build metadata takes precedence
+        return;
+    }
+    // Convert Bitrise metadata to CI Build format
+    pipeline.meta['cibuild.io'] = {
+        stack: bitriseMeta.stack || 'linux-ubuntu-22.04',
+        machine_type: bitriseMeta.machine_type || 'standard',
+    };
+    // Optionally preserve original Bitrise metadata for reference
+    // (can be removed in production if not needed)
+}
+/**
+ * Detects Bitrise-specific environment variables in step inputs
+ * Scans recursively through objects and arrays (FR-9.1)
+ *
+ * @param inputs Step inputs object
+ * @param stepName Name of the step (for error reporting)
+ * @returns Array of detected Bitrise variable information
+ */
+export function detectBitriseEnvironmentVariables(inputs, stepName) {
+    const detected = [];
+    // Recursively scan inputs for Bitrise variables
+    scanForBitriseVars(inputs, stepName, '', detected);
+    return detected;
+}
+/**
+ * Recursively scans an object/array for Bitrise environment variables
+ *
+ * @param obj Object to scan
+ * @param stepName Step name for error reporting
+ * @param path Current path in object (for input field tracking)
+ * @param detected Array to accumulate detected variables
+ */
+function scanForBitriseVars(obj, stepName, path, detected) {
+    if (typeof obj === 'string') {
+        // Check for Bitrise variables in string
+        const bitriseVars = extractBitriseVariables(obj);
+        for (const varName of bitriseVars) {
+            // Check if this is a user-required variable (needs explicit configuration)
+            if (BITRISE_USER_REQUIRED_VARS.includes(varName)) {
+                detected.push({
+                    name: varName,
+                    stepName,
+                    inputField: path || 'unknown',
+                    suggestedAction: `Set this environment variable with your value:\nexport ${varName}="your-value-here"`,
+                });
+            }
+            // Check if this variable has a CI Build equivalent
+            else if (varName in BITRISE_ENV_MAP && BITRISE_ENV_MAP[varName] !== varName) {
+                const cibuildVar = BITRISE_ENV_MAP[varName];
+                detected.push({
+                    name: varName,
+                    stepName,
+                    inputField: path || 'unknown',
+                    cibuildEquivalent: cibuildVar,
+                    suggestedAction: `Auto-mapped to ${cibuildVar}. You can also set:\nexport ${varName}="$${cibuildVar}"`,
+                });
+            }
+        }
+    }
+    else if (Array.isArray(obj)) {
+        // Scan array elements
+        obj.forEach((item, index) => {
+            scanForBitriseVars(item, stepName, `${path}[${index}]`, detected);
+        });
+    }
+    else if (obj && typeof obj === 'object') {
+        // Scan object properties
+        for (const [key, value] of Object.entries(obj)) {
+            const newPath = path ? `${path}.${key}` : key;
+            scanForBitriseVars(value, stepName, newPath, detected);
+        }
+    }
+}
+/**
+ * Extracts Bitrise variable names from a string
+ * Supports formats: $VAR, ${VAR}, {{getenv "VAR"}}
+ *
+ * @param str String to search
+ * @returns Array of unique Bitrise variable names
+ */
+function extractBitriseVariables(str) {
+    const vars = new Set();
+    // Pattern 1: {{getenv "BITRISE_*"}}
+    const getenvPattern = /\{\{getenv "(BITRISE_[A-Z0-9_]+)"\}\}/g;
+    let match;
+    while ((match = getenvPattern.exec(str)) !== null) {
+        vars.add(match[1]);
+    }
+    // Pattern 2: ${BITRISE_*}
+    const bracesPattern = /\$\{(BITRISE_[A-Z0-9_]+)\}/g;
+    while ((match = bracesPattern.exec(str)) !== null) {
+        vars.add(match[1]);
+    }
+    // Pattern 3: $BITRISE_* (not followed by alphanumeric or underscore)
+    const dollarPattern = /\$(BITRISE_[A-Z0-9_]+)(?![A-Z0-9_])/g;
+    while ((match = dollarPattern.exec(str)) !== null) {
+        vars.add(match[1]);
+    }
+    return Array.from(vars);
+}
+/**
+ * Formats a detailed error message for missing Bitrise environment variables
+ * (FR-9.3, FR-9.4, FR-9.5)
+ *
+ * @param missingVars Array of missing variable information
+ * @returns Formatted error message
+ */
+function formatBitriseEnvironmentError(missingVars) {
+    const lines = [
+        '❌ Bitrise-specific environment variables detected:',
+        '',
+    ];
+    for (const varInfo of missingVars) {
+        lines.push('┌─────────────────────────────────────────────────────────────────────────────');
+        lines.push(`│ Variable: $${varInfo.name}`);
+        lines.push(`│ Used in:  ${varInfo.stepName}`);
+        lines.push(`│ Input:    ${varInfo.inputField}`);
+        if (varInfo.cibuildEquivalent) {
+            lines.push(`│ CI Build: Use $${varInfo.cibuildEquivalent} instead, or set:`);
+            lines.push(`│           export ${varInfo.name}="$${varInfo.cibuildEquivalent}"`);
+        }
+        else {
+            lines.push(`│ Action:   ${varInfo.suggestedAction.replace(/\n/g, '\n│           ')}`);
+        }
+        lines.push('└─────────────────────────────────────────────────────────────────────────────');
+        lines.push('');
+    }
+    lines.push(`Please configure these ${missingVars.length} variable${missingVars.length > 1 ? 's' : ''} and try again.`);
+    return lines.join('\n');
+}
+/**
+ * Checks if a variable should trigger a warning vs error
+ * Mapped variables generate info logs, unmapped variables generate errors
+ *
+ * @param varName Bitrise variable name
+ * @returns True if variable needs user configuration (error), false if auto-mapped (info)
+ */
+export function requiresUserConfiguration(varName) {
+    return BITRISE_USER_REQUIRED_VARS.includes(varName);
+}
+//# sourceMappingURL=bitrise-compat.js.map

package/dist/src/yaml/bitrise-compat.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for Bitrise YAML Compatibility Layer
+ */
+export {};
+//# sourceMappingURL=bitrise-compat.test.d.ts.map

package/dist/src/yaml/bitrise-compat.test.d.ts.map

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

package/dist/src/yaml/bitrise-compat.test.js

@@ -0,0 +1,347 @@
+/**
+ * Unit tests for Bitrise YAML Compatibility Layer
+ */
+import { describe, test, expect } from '@jest/globals';
+import { BITRISE_ENV_MAP, BITRISE_USER_REQUIRED_VARS, BitriseEnvironmentError, convertBitriseMetadata, detectBitriseEnvironmentVariables, requiresUserConfiguration, } from './bitrise-compat.js';
+describe('Bitrise Compatibility Layer', () => {
+    describe('BITRISE_ENV_MAP', () => {
+        test('should map BITRISE_BUILD_NUMBER to CIBUILD_BUILD_NUMBER', () => {
+            expect(BITRISE_ENV_MAP.BITRISE_BUILD_NUMBER).toBe('CIBUILD_BUILD_NUMBER');
+        });
+        test('should map BITRISE_BUILD_URL to CIBUILD_BUILD_URL', () => {
+            expect(BITRISE_ENV_MAP.BITRISE_BUILD_URL).toBe('CIBUILD_BUILD_URL');
+        });
+        test('should map BITRISE_APP_TITLE to CIBUILD_APP_TITLE', () => {
+            expect(BITRISE_ENV_MAP.BITRISE_APP_TITLE).toBe('CIBUILD_APP_TITLE');
+        });
+        test('should map git variables to CIBUILD equivalents', () => {
+            expect(BITRISE_ENV_MAP.BITRISE_GIT_BRANCH).toBe('CIBUILD_GIT_BRANCH');
+            expect(BITRISE_ENV_MAP.BITRISE_GIT_REPOSITORY_URL).toBe('CIBUILD_GIT_REPOSITORY_URL');
+            expect(BITRISE_ENV_MAP.BITRISE_GIT_COMMIT).toBe('CIBUILD_GIT_COMMIT');
+            expect(BITRISE_ENV_MAP.BITRISE_SOURCE_DIR).toBe('CIBUILD_SOURCE_DIR');
+        });
+    });
+    describe('BITRISE_USER_REQUIRED_VARS', () => {
+        test('should include CIBUILD_PUBLIC_INSTALL_PAGE_URL', () => {
+            expect(BITRISE_USER_REQUIRED_VARS).toContain('CIBUILD_PUBLIC_INSTALL_PAGE_URL');
+        });
+        test('should include CIBUILD_PUBLIC_INSTALL_PAGE_QR_CODE_IMAGE_URL', () => {
+            expect(BITRISE_USER_REQUIRED_VARS).toContain('CIBUILD_PUBLIC_INSTALL_PAGE_QR_CODE_IMAGE_URL');
+        });
+        test('should include CIBUILD_PULL_REQUEST', () => {
+            expect(BITRISE_USER_REQUIRED_VARS).toContain('CIBUILD_PULL_REQUEST');
+        });
+    });
+    describe('convertBitriseMetadata', () => {
+        test('should convert meta.bitrise.io to meta.cibuild.io', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'bitrise.io': {
+                        stack: 'linux-docker-android-22.04',
+                        machine_type: 'performance',
+                    },
+                },
+                workflows: {},
+            };
+            convertBitriseMetadata(pipeline);
+            expect(pipeline.meta?.['cibuild.io']).toBeDefined();
+            expect(pipeline.meta?.['cibuild.io']?.stack).toBe('linux-docker-android-22.04');
+            expect(pipeline.meta?.['cibuild.io']?.machine_type).toBe('performance');
+        });
+        test('should use default values if Bitrise metadata is incomplete', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'bitrise.io': {},
+                },
+                workflows: {},
+            };
+            convertBitriseMetadata(pipeline);
+            expect(pipeline.meta?.['cibuild.io']).toBeDefined();
+            expect(pipeline.meta?.['cibuild.io']?.stack).toBe('linux-ubuntu-22.04');
+            expect(pipeline.meta?.['cibuild.io']?.machine_type).toBe('standard');
+        });
+        test('should not modify pipeline if no Bitrise metadata exists', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {},
+                workflows: {},
+            };
+            convertBitriseMetadata(pipeline);
+            expect(pipeline.meta?.['cibuild.io']).toBeUndefined();
+        });
+        test('should not override existing cibuild.io metadata (FR-11.3)', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'bitrise.io': {
+                        stack: 'linux-docker-android-22.04',
+                        machine_type: 'performance',
+                    },
+                    'cibuild.io': {
+                        stack: 'macos-ventura-xcode-15.1',
+                        machine_type: 'standard',
+                    },
+                },
+                workflows: {},
+            };
+            convertBitriseMetadata(pipeline);
+            // CI Build metadata should remain unchanged
+            expect(pipeline.meta?.['cibuild.io']?.stack).toBe('macos-ventura-xcode-15.1');
+            expect(pipeline.meta?.['cibuild.io']?.machine_type).toBe('standard');
+        });
+        test('should preserve all other YAML structure (FR-1.3)', () => {
+            const pipeline = {
+                format_version: '4',
+                meta: {
+                    'bitrise.io': {
+                        stack: 'linux-docker-android-22.04',
+                    },
+                },
+                app: {
+                    envs: [{ PROJECT_NAME: 'MyApp' }],
+                },
+                workflows: {
+                    primary: {
+                        steps: [],
+                    },
+                },
+            };
+            convertBitriseMetadata(pipeline);
+            // All original structure should be preserved
+            expect(pipeline.format_version).toBe('4');
+            expect(pipeline.app).toBeDefined();
+            expect(pipeline.app?.envs).toHaveLength(1);
+            expect(pipeline.workflows.primary).toBeDefined();
+        });
+    });
+    describe('detectBitriseEnvironmentVariables', () => {
+        test('should detect $VAR format', () => {
+            const inputs = {
+                message: 'Build $BITRISE_BUILD_NUMBER completed',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].name).toBe('BITRISE_BUILD_NUMBER');
+            expect(detected[0].stepName).toBe('test-step');
+            expect(detected[0].cibuildEquivalent).toBe('CIBUILD_BUILD_NUMBER');
+        });
+        test('should detect ${VAR} format', () => {
+            const inputs = {
+                url: 'https://example.com/build/${BITRISE_BUILD_URL}',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].name).toBe('BITRISE_BUILD_URL');
+            expect(detected[0].cibuildEquivalent).toBe('CIBUILD_BUILD_URL');
+        });
+        test('should detect {{getenv "VAR"}} format', () => {
+            const inputs = {
+                content: 'Build: {{getenv "BITRISE_BUILD_NUMBER"}}',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].name).toBe('BITRISE_BUILD_NUMBER');
+            expect(detected[0].cibuildEquivalent).toBe('CIBUILD_BUILD_NUMBER');
+        });
+        test('should detect multiple variables in same string', () => {
+            const inputs = {
+                message: 'Build $BITRISE_BUILD_NUMBER and URL: ${BITRISE_PUBLIC_INSTALL_PAGE_URL}',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected.length).toBeGreaterThanOrEqual(2);
+            const varNames = detected.map((v) => v.name);
+            expect(varNames).toContain('BITRISE_BUILD_NUMBER');
+            expect(varNames).toContain('BITRISE_PUBLIC_INSTALL_PAGE_URL');
+        });
+        test('should detect variables in nested objects', () => {
+            const inputs = {
+                slack: {
+                    webhook: 'https://hooks.slack.com',
+                    message: {
+                        text: 'Build $BITRISE_BUILD_URL',
+                        fields: ['QR Code: $BITRISE_PUBLIC_INSTALL_PAGE_QR_CODE_IMAGE_URL'],
+                    },
+                },
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'slack-step');
+            expect(detected.length).toBeGreaterThanOrEqual(1);
+            const varNames = detected.map((v) => v.name);
+            // BITRISE_BUILD_URL has CI Build equivalent, BITRISE_PUBLIC_INSTALL_PAGE_QR_CODE_IMAGE_URL needs user input
+            expect(varNames.length).toBeGreaterThan(0);
+        });
+        test('should detect variables in arrays', () => {
+            const inputs = {
+                paths: ['Install: $BITRISE_PUBLIC_INSTALL_PAGE_URL', 'Build: $BITRISE_BUILD_NUMBER'],
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected.length).toBeGreaterThanOrEqual(2);
+            const varNames = detected.map((v) => v.name);
+            expect(varNames).toContain('BITRISE_PUBLIC_INSTALL_PAGE_URL');
+            expect(varNames).toContain('BITRISE_BUILD_NUMBER');
+        });
+        test('should identify user-required variables', () => {
+            const inputs = {
+                url: '$BITRISE_PUBLIC_INSTALL_PAGE_URL',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'deploy-step');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].name).toBe('BITRISE_PUBLIC_INSTALL_PAGE_URL');
+            expect(detected[0].cibuildEquivalent).toBeUndefined();
+            expect(detected[0].suggestedAction).toContain('Set this environment variable');
+        });
+        test('should include input field path in detection', () => {
+            const inputs = {
+                slack: {
+                    buttons: 'Install|$BITRISE_PUBLIC_INSTALL_PAGE_URL',
+                },
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'slack@3');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].inputField).toBe('slack.buttons');
+        });
+        test('should handle empty inputs', () => {
+            const detected = detectBitriseEnvironmentVariables({}, 'test-step');
+            expect(detected).toHaveLength(0);
+        });
+        test('should handle inputs with no Bitrise variables', () => {
+            const inputs = {
+                message: 'Hello world',
+                count: 42,
+                enabled: true,
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(0);
+        });
+    });
+    describe('BitriseEnvironmentError', () => {
+        test('should format error message for single variable', () => {
+            const missingVars = [
+                {
+                    name: 'BITRISE_PUBLIC_INSTALL_PAGE_URL',
+                    stepName: 'slack@3',
+                    inputField: 'buttons',
+                    suggestedAction: 'Set this environment variable with your install page URL',
+                },
+            ];
+            const error = new BitriseEnvironmentError(missingVars);
+            expect(error.message).toContain('❌ Bitrise-specific environment variables detected');
+            expect(error.message).toContain('Variable: $BITRISE_PUBLIC_INSTALL_PAGE_URL');
+            expect(error.message).toContain('Used in:  slack@3');
+            expect(error.message).toContain('Input:    buttons');
+            expect(error.message).toContain('configure these 1 variable');
+        });
+        test('should format error message for multiple variables', () => {
+            const missingVars = [
+                {
+                    name: 'BITRISE_PUBLIC_INSTALL_PAGE_URL',
+                    stepName: 'slack@3',
+                    inputField: 'buttons',
+                    suggestedAction: 'Set this variable',
+                },
+                {
+                    name: 'BITRISE_BUILD_URL',
+                    stepName: 'slack@3',
+                    inputField: 'buttons',
+                    cibuildEquivalent: 'CIBUILD_BUILD_URL',
+                    suggestedAction: 'Use CI Build equivalent',
+                },
+            ];
+            const error = new BitriseEnvironmentError(missingVars);
+            expect(error.message).toContain('BITRISE_PUBLIC_INSTALL_PAGE_URL');
+            expect(error.message).toContain('BITRISE_BUILD_URL');
+            expect(error.message).toContain('configure these 2 variables');
+        });
+        test('should show CI Build equivalent when available', () => {
+            const missingVars = [
+                {
+                    name: 'BITRISE_BUILD_NUMBER',
+                    stepName: 'script@1',
+                    inputField: 'content',
+                    cibuildEquivalent: 'CIBUILD_BUILD_NUMBER',
+                    suggestedAction: 'Use CI Build equivalent',
+                },
+            ];
+            const error = new BitriseEnvironmentError(missingVars);
+            expect(error.message).toContain('CI Build: Use $CIBUILD_BUILD_NUMBER instead');
+            expect(error.message).toContain('export BITRISE_BUILD_NUMBER="$CIBUILD_BUILD_NUMBER"');
+        });
+        test('should include box drawing characters for formatting', () => {
+            const missingVars = [
+                {
+                    name: 'BITRISE_PUBLIC_INSTALL_PAGE_URL',
+                    stepName: 'test',
+                    inputField: 'url',
+                    suggestedAction: 'Set this',
+                },
+            ];
+            const error = new BitriseEnvironmentError(missingVars);
+            expect(error.message).toContain('┌─────');
+            expect(error.message).toContain('│ Variable:');
+            expect(error.message).toContain('└─────');
+        });
+        test('should store missing variables in error object', () => {
+            const missingVars = [
+                {
+                    name: 'BITRISE_PUBLIC_INSTALL_PAGE_URL',
+                    stepName: 'slack@3',
+                    inputField: 'buttons',
+                    suggestedAction: 'Set this variable',
+                },
+            ];
+            const error = new BitriseEnvironmentError(missingVars);
+            expect(error.missingVariables).toEqual(missingVars);
+            expect(error.name).toBe('BitriseEnvironmentError');
+        });
+    });
+    describe('requiresUserConfiguration', () => {
+        test('should return true for user-required variables', () => {
+            expect(requiresUserConfiguration('BITRISE_PUBLIC_INSTALL_PAGE_URL')).toBe(true);
+            expect(requiresUserConfiguration('BITRISE_PUBLIC_INSTALL_PAGE_QR_CODE_IMAGE_URL')).toBe(true);
+            expect(requiresUserConfiguration('BITRISE_PULL_REQUEST')).toBe(true);
+        });
+        test('should return false for auto-mapped variables', () => {
+            expect(requiresUserConfiguration('BITRISE_BUILD_NUMBER')).toBe(false);
+            expect(requiresUserConfiguration('BITRISE_BUILD_URL')).toBe(false);
+            expect(requiresUserConfiguration('BITRISE_GIT_BRANCH')).toBe(false);
+        });
+        test('should return false for unknown variables', () => {
+            expect(requiresUserConfiguration('UNKNOWN_VARIABLE')).toBe(false);
+        });
+    });
+    describe('Edge cases', () => {
+        test('should not detect non-BITRISE variables', () => {
+            const inputs = {
+                message: 'Build $BUILD_NUMBER on ${GIT_BRANCH}',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(0);
+        });
+        test('should handle variables at string boundaries', () => {
+            const inputs = {
+                message: '$BITRISE_BUILD_NUMBER',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].name).toBe('BITRISE_BUILD_NUMBER');
+        });
+        test('should not detect variables in the middle of words', () => {
+            const inputs = {
+                message: 'NOTBITRISE_BUILD_NUMBER',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(0);
+        });
+        test('should handle null and undefined values gracefully', () => {
+            const inputs = {
+                nullValue: null,
+                undefinedValue: undefined,
+                message: 'test',
+            };
+            const detected = detectBitriseEnvironmentVariables(inputs, 'test-step');
+            expect(detected).toHaveLength(0);
+        });
+    });
+});
+//# sourceMappingURL=bitrise-compat.test.js.map

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

@@ -0,0 +1,33 @@
+/**
+ * Converts YAML pipeline workflows to PipelineDef format
+ * This bridges the YAML configuration with the existing runner engine
+ */
+import type { PipelineDef, CIConfig } from '../types.js';
+import type { YAMLPipeline } from './types.js';
+export declare class YAMLConversionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Result of YAML to PipelineDef conversion
+ */
+export interface ConversionResult {
+    pipeline: PipelineDef;
+    warnings: string[];
+    skippedSteps: number;
+}
+/**
+ * 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 declare function convertYAMLToPipelineDef(pipeline: YAMLPipeline, config: CIConfig, workflowName?: string, yamlFilePath?: string): Promise<ConversionResult>;
+/**
+ * Helper function to get available workflow names from a pipeline
+ * @param pipeline Parsed YAML pipeline
+ * @returns Array of workflow names
+ */
+export declare function getAvailableWorkflows(pipeline: YAMLPipeline): string[];
+//# sourceMappingURL=converter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../src/yaml/converter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAW,QAAQ,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAA4B,MAAM,YAAY,CAAC;AAKzE,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAkCD;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,QAAQ,EAChB,YAAY,CAAC,EAAE,MAAM,EACrB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,CAAC,CAgH3B;AAwGD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,EAAE,CAEtE"}