@invarn/cibuild 2.9.4 → 2.9.7

package/dist/src/yaml/cache-key-missing-file.test.js

@@ -1,116 +0,0 @@
-/**
- * A cache key that cannot be computed costs a cache, not a pipeline.
- *
- * `cache_key: pods-{{checksum "Podfile.lock"}}` in a repository with no
- * Podfile.lock used to abort conversion, so the build died at `cache-pull`
- * before compiling a single file — including in repositories that use Swift
- * Package Manager and have no reason to own a CocoaPods lockfile at all.
- * Every other step keeps the hard failure: a checksum in a real input is a
- * value that step needs.
- */
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { convertYAMLToPipelineDef } from './converter.js';
-import { clearRegistry, registerStep } from './steps/registry.js';
-import { ScriptStepExecutor } from './steps/script.js';
-import { CachePullStepExecutor, CachePushStepExecutor } from './steps/cache.js';
-const 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',
-    },
-};
-let workdir;
-let previousCwd;
-beforeEach(() => {
-    clearRegistry();
-    registerStep('script', new ScriptStepExecutor());
-    registerStep('cache-pull', new CachePullStepExecutor());
-    registerStep('cache-push', new CachePushStepExecutor());
-    previousCwd = process.cwd();
-    workdir = mkdtempSync(join(tmpdir(), 'cibuild-checksum-'));
-    process.chdir(workdir);
-});
-afterEach(() => {
-    process.chdir(previousCwd);
-    rmSync(workdir, { recursive: true, force: true });
-    clearRegistry();
-});
-function pipelineWithPodsCache() {
-    return {
-        format_version: '1',
-        workflows: {
-            primary: {
-                steps: [
-                    {
-                        'cache-pull': {
-                            inputs: {
-                                cache_key: 'pods-{{checksum "Podfile.lock"}}',
-                                cache_paths: ['Pods'],
-                            },
-                        },
-                    },
-                    {
-                        script: {
-                            title: 'Build',
-                            inputs: { content: 'echo building' },
-                        },
-                    },
-                    {
-                        'cache-push': {
-                            inputs: {
-                                cache_key: 'pods-{{checksum "Podfile.lock"}}',
-                                cache_paths: ['Pods'],
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-    };
-}
-describe('a cache key naming a file this repository does not have', () => {
-    test('skips the cache steps and keeps the build', async () => {
-        const result = await convertYAMLToPipelineDef(pipelineWithPodsCache(), mockConfig, 'primary');
-        expect(result.skippedSteps).toBe(2);
-        expect(Object.keys(result.pipeline.steps ?? {})).toHaveLength(1);
-        expect(result.warnings.join('\n')).toContain('Podfile.lock');
-        expect(result.warnings.join('\n')).toContain('uncached');
-    });
-    test('keeps the cache steps once the file is there', async () => {
-        writeFileSync(join(workdir, 'Podfile.lock'), 'PODFILE CHECKSUM: abc\n');
-        const result = await convertYAMLToPipelineDef(pipelineWithPodsCache(), mockConfig, 'primary');
-        expect(result.skippedSteps).toBe(0);
-        expect(Object.keys(result.pipeline.steps ?? {})).toHaveLength(3);
-    });
-    test('still fails a non-cache step whose checksum names a missing file', async () => {
-        const pipeline = {
-            format_version: '1',
-            workflows: {
-                primary: {
-                    steps: [
-                        {
-                            script: {
-                                title: 'Build',
-                                inputs: { content: 'echo {{checksum "Podfile.lock"}}' },
-                            },
-                        },
-                    ],
-                },
-            },
-        };
-        await expect(convertYAMLToPipelineDef(pipeline, mockConfig, 'primary')).rejects.toThrow('Podfile.lock');
-    });
-});
-//# sourceMappingURL=cache-key-missing-file.test.js.map

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

@@ -1,103 +0,0 @@
-/**
- * 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
- */
-/**
- * What was on disk when the pipeline was converted — the only thing that can
- * say which commit a build actually compiled.
- *
- * A dashboard's sha is the one that was *dispatched*. Between dispatch and
- * checkout a branch can move, a tag can be re-pointed, and a shared checkout
- * can be pushed over. Until now the sole in-log evidence was `git-clone`'s
- * own echo, which is optional and on its way out of the templates.
- */
-export interface CheckoutWitness {
-    /** Full SHA of HEAD. */
-    commit: string;
-    /** `Name <email>` of the commit's author, empty when unknown. */
-    author: string;
-    /** First line of the commit message, empty when unknown. */
-    subject: string;
-}
-export interface ConversionResult {
-    pipeline: PipelineDef;
-    warnings: string[];
-    skippedSteps: number;
-    /**
-     * Absent only when the working directory is not a git checkout — a local
-     * `ci run` in a plain directory, never a runner.
-     */
-    checkout?: CheckoutWitness;
-}
-/**
- * A credential a `file@` step writes, and where it goes.
- */
-export interface CredentialTarget {
-    targetPath: string;
-    varName: string;
-}
-/** A cache step's declared paths, and which step declared them. */
-export interface CachePathDeclaration {
-    stepName: string;
-    cachePaths: string[];
-}
-export interface SwallowedCredential {
-    stepName: string;
-    cachePath: string;
-    targetPath: string;
-    varName: string;
-}
-/**
- * True when caching `cachePath` would sweep up the file at `targetPath`.
- *
- * Only a project-relative entry can: `cache.ts` classifies a `~`- or
- * `/`-rooted entry as absolute and stores it from the filesystem root, so it
- * is somewhere the checkout is not. An entry naming the checkout itself (`.`,
- * `./`) contains everything.
- */
-export declare function cacheEntryContains(cachePath: string, targetPath: string): boolean;
-/**
- * Every credential a workflow's cache steps would archive.
- *
- * `cache-push` uploads whatever `cache_paths` names, and that archive is
- * stored where the *next* build pulls it from — so a credential swept into it
- * outlives the build that received it. Everything else about a credential's
- * life is bounded: the runner pushes the checkout and the guest root onto
- * `cleanupPaths` and removes them in a `finally`, the guest gets
- * `rm -rf`, and `tart delete` reclaims the VM. The cache store is the one
- * place a file can survive all of that, which makes this the single hole in
- * "nothing survives a build".
- *
- * No pipeline in play trips it — every one of them caches `~/.gradle/caches`,
- * `~/.gradle/wrapper` and `.gradle`, and none of those contains a credential —
- * so this is a guard on a mistake that is easy to make and impossible to see:
- * adding `.` to `cache_paths` is a plausible way to speed up a build, and it
- * would publish the keystore.
- */
-export declare function credentialsSwallowedByCache(credentials: readonly CredentialTarget[], caches: readonly CachePathDeclaration[]): SwallowedCredential[];
-/** The refusal text for one swallowed credential. */
-export declare function swallowedCredentialMessage(workflowName: string, swallowed: SwallowedCredential): string;
-/**
- * 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

@@ -1 +0,0 @@
-{"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;AAMzE,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAaD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,mEAAmE;AACnE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAaD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CASjF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,SAAS,gBAAgB,EAAE,EACxC,MAAM,EAAE,SAAS,oBAAoB,EAAE,GACtC,mBAAmB,EAAE,CAgBvB;AAED,qDAAqD;AACrD,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,mBAAmB,GAC7B,MAAM,CAaR;AA6DD;;;;;;;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,CA0M3B;AAwGD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,EAAE,CAEtE"}

package/dist/src/yaml/converter.js

@@ -1,420 +0,0 @@
-/**
- * Converts YAML pipeline workflows to PipelineDef format
- * This bridges the YAML configuration with the existing runner engine
- */
-import { getInvarnMeta } from './meta-helpers.js';
-import { detectPlatformInfo } from './platform-detector.js';
-import { EnvResolver, ChecksumFileMissingError } from './env-resolver.js';
-import { getStepExecutor, UnrecognizedStepError } from './steps/registry.js';
-export class YAMLConversionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'YAMLConversionError';
-    }
-}
-/**
- * The steps whose whole job is to make a build faster. Nothing they do is
- * required for the build to be correct, so an input they cannot resolve
- * costs a cache, not a pipeline.
- */
-const CACHE_STEPS = new Set(['cache-pull', 'cache-push']);
-function isCacheStep(stepName) {
-    return CACHE_STEPS.has(stepName);
-}
-/**
- * Trailing slashes and a leading `./` off, backslashes forward. `.` and the
- * empty string both mean "the whole checkout".
- */
-function normalizeCheckoutPath(path) {
-    const forward = path.trim().replace(/\\/g, '/');
-    const withoutLead = forward.replace(/^\.\//, '');
-    const withoutTrail = withoutLead.replace(/\/+$/, '');
-    return withoutTrail === '.' ? '' : withoutTrail;
-}
-/**
- * True when caching `cachePath` would sweep up the file at `targetPath`.
- *
- * Only a project-relative entry can: `cache.ts` classifies a `~`- or
- * `/`-rooted entry as absolute and stores it from the filesystem root, so it
- * is somewhere the checkout is not. An entry naming the checkout itself (`.`,
- * `./`) contains everything.
- */
-export function cacheEntryContains(cachePath, targetPath) {
-    const raw = cachePath.trim();
-    if (raw.startsWith('~') || raw.startsWith('/'))
-        return false;
-    const cache = normalizeCheckoutPath(raw);
-    const target = normalizeCheckoutPath(targetPath);
-    if (target === '')
-        return false;
-    if (cache === '')
-        return true;
-    return target === cache || target.startsWith(`${cache}/`);
-}
-/**
- * Every credential a workflow's cache steps would archive.
- *
- * `cache-push` uploads whatever `cache_paths` names, and that archive is
- * stored where the *next* build pulls it from — so a credential swept into it
- * outlives the build that received it. Everything else about a credential's
- * life is bounded: the runner pushes the checkout and the guest root onto
- * `cleanupPaths` and removes them in a `finally`, the guest gets
- * `rm -rf`, and `tart delete` reclaims the VM. The cache store is the one
- * place a file can survive all of that, which makes this the single hole in
- * "nothing survives a build".
- *
- * No pipeline in play trips it — every one of them caches `~/.gradle/caches`,
- * `~/.gradle/wrapper` and `.gradle`, and none of those contains a credential —
- * so this is a guard on a mistake that is easy to make and impossible to see:
- * adding `.` to `cache_paths` is a plausible way to speed up a build, and it
- * would publish the keystore.
- */
-export function credentialsSwallowedByCache(credentials, caches) {
-    const found = [];
-    for (const cache of caches) {
-        for (const cachePath of cache.cachePaths) {
-            for (const credential of credentials) {
-                if (!cacheEntryContains(cachePath, credential.targetPath))
-                    continue;
-                found.push({
-                    stepName: cache.stepName,
-                    cachePath: cachePath.trim(),
-                    targetPath: credential.targetPath,
-                    varName: credential.varName,
-                });
-            }
-        }
-    }
-    return found;
-}
-/** The refusal text for one swallowed credential. */
-export function swallowedCredentialMessage(workflowName, swallowed) {
-    return [
-        `Workflow "${workflowName}" would cache a credential.`,
-        ``,
-        `  The ${swallowed.stepName} step lists "${swallowed.cachePath}" in cache_paths, and that`,
-        `  contains "${swallowed.targetPath}" — the file written from the ${swallowed.varName} secret.`,
-        ``,
-        `  A cached credential outlives the build. The archive is stored where the next`,
-        `  build pulls it from, and nothing removes it when the sandbox is destroyed.`,
-        ``,
-        `  Narrow the cache_paths entry to the directories the build needs cached, or`,
-        `  write the credential somewhere outside them.`,
-    ].join('\n');
-}
-/**
- * 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',
-};
-/**
- * Reads the checkout's identity back out of the resolver, which computed it
- * from the very working directory the build is about to run in.
- *
- * Read through `getAll()` rather than `get()`: the latter records every name
- * it is asked for in `referencedVars`, and a pipeline is refused when a
- * referenced name has no value. Nothing here is a variable the pipeline
- * referenced.
- *
- * `EnvResolver` falls back to the literal string `HEAD` when `git rev-parse`
- * fails, so the shape of the hash — not a second question to git — is what
- * tells a real checkout from a plain directory.
- */
-function checkoutWitnessFrom(env) {
-    const commit = env['CIBUILD_GIT_COMMIT'] ?? '';
-    if (!/^[0-9a-f]{7,40}$/.test(commit))
-        return undefined;
-    const name = env['GIT_CLONE_COMMIT_AUTHOR_NAME'] ?? '';
-    const email = env['GIT_CLONE_COMMIT_AUTHOR_EMAIL'] ?? '';
-    return {
-        commit,
-        author: name && email ? `${name} <${email}>` : name || email,
-        subject: env['GIT_CLONE_COMMIT_MESSAGE_SUBJECT'] ?? '',
-    };
-}
-/**
- * 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 3.5: Auto-inject cache steps if cachedBuild is enabled
-    const invarnMeta = getInvarnMeta(pipeline);
-    const cachedBuild = invarnMeta?.cachedBuild === true;
-    let workflowSteps = [...selectedWorkflow.steps];
-    if (cachedBuild && invarnMeta?.platform) {
-        const platformToCacheTechnology = {
-            ios: 'ios',
-            android: 'gradle',
-            kmm: 'kmm',
-        };
-        const technology = platformToCacheTechnology[invarnMeta.platform];
-        if (technology) {
-            // Remove any manually written cache-pull/cache-push steps
-            workflowSteps = workflowSteps.filter(step => {
-                const stepKey = Object.keys(step)[0];
-                const stepName = stepKey.split('@')[0];
-                return stepName !== 'cache-pull' && stepName !== 'cache-push';
-            });
-            const cachePullStep = { 'cache-pull@1.0.0': { inputs: { technology } } };
-            const cachePushStep = { 'cache-push@1.0.0': { inputs: { technology } } };
-            workflowSteps.unshift(cachePullStep);
-            workflowSteps.push(cachePushStep);
-        }
-    }
-    // Step 4: Parse and convert steps
-    const steps = [];
-    const stepsOrder = [];
-    let stepCounter = 0;
-    // Collected as the steps are converted, checked once at the end: a cache
-    // step can be declared before the `file@` step whose target it would
-    // swallow, so neither one alone can answer the question.
-    const credentialTargets = [];
-    const cacheDeclarations = [];
-    for (const yamlStep of workflowSteps) {
-        // 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
-        //
-        // A cache step whose key cannot be computed is not a broken pipeline. The
-        // key is usually `{{checksum "<lockfile>"}}`, and a repository without
-        // that lockfile has nothing to key a cache on — so there is no cache, and
-        // the build runs cold. Letting the error through instead killed five iOS
-        // builds in a thirty-repository study at `cache-pull`, before a single
-        // file compiled, on a CocoaPods lockfile that two of them had no reason
-        // to have. Every other step keeps the hard failure: a checksum in a real
-        // input is a value the step needs.
-        let interpolatedInputs;
-        try {
-            interpolatedInputs = envResolver.interpolateObject(parsedStep.inputs, parsedStep.title || parsedStep.name);
-        }
-        catch (error) {
-            if (error instanceof ChecksumFileMissingError && isCacheStep(resolvedStepName)) {
-                warnings.push(`⚠️  ${resolvedStepName}: no ${error.filePath} in this repository, so there is ` +
-                    `nothing to key the cache on (skipping — the build runs uncached)`);
-                skippedSteps++;
-                continue;
-            }
-            throw error;
-        }
-        // Both halves of the cache-swallows-a-credential question, read off the
-        // interpolated inputs so `$PROJECT_LOCATION` and friends are already the
-        // paths they will be at runtime.
-        if (resolvedStepName === 'file') {
-            const targetPath = interpolatedInputs?.target_path;
-            const varName = interpolatedInputs?.var_name;
-            if (typeof targetPath === 'string' && typeof varName === 'string') {
-                credentialTargets.push({ targetPath, varName });
-            }
-        }
-        if (isCacheStep(resolvedStepName)) {
-            const declared = interpolatedInputs?.cache_paths;
-            const cachePaths = Array.isArray(declared)
-                ? declared.filter((p) => typeof p === 'string')
-                : typeof declared === 'string'
-                    ? [declared]
-                    : [];
-            if (cachePaths.length > 0) {
-                cacheDeclarations.push({ stepName: resolvedStepName, cachePaths });
-            }
-        }
-        // 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 4b: refuse a pipeline that would archive a credential.
-    //
-    // Thrown at generation time for the same reason issue 03's missing-credential
-    // refusal is: it is the only place that can see the whole workflow, and the
-    // alternative is a build that succeeds while publishing a key. A pipeline
-    // configuration error, and the author is the one who can fix it.
-    const swallowed = credentialsSwallowedByCache(credentialTargets, cacheDeclarations);
-    if (swallowed.length > 0) {
-        throw new YAMLConversionError(swallowed.map((s) => swallowedCredentialMessage(selectedWorkflowName, s)).join('\n\n'));
-    }
-    // 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,
-        checkout: checkoutWitnessFrom(envResolver.getAll()),
-    };
-}
-/**
- * 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

@@ -1,5 +0,0 @@
-/**
- * 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

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