@invarn/cibuild 1.3.16 → 1.3.17

package/dist/src/yaml/interactive-prompts.js

@@ -0,0 +1,258 @@
+/**
+ * Interactive prompts for missing environment variables
+ * Allows users to fill in missing values or cancel the build
+ */
+import prompts from 'prompts';
+/**
+ * Interactive prompt manager for collecting missing environment variables
+ */
+export class InteractivePrompts {
+    secretsManager;
+    workflow;
+    constructor(secretsManager, workflow) {
+        this.secretsManager = secretsManager;
+        this.workflow = workflow;
+    }
+    /**
+     * Prompt user for a missing environment variable
+     * @param varName Variable name
+     * @param stepName Optional step name that requires this variable
+     * @param hint Optional hint describing what the variable is for and expected format
+     * @returns Promise with the entered value or cancellation
+     */
+    async promptForVariable(varName, stepName, hint) {
+        console.log('\n╔═══════════════════════════════════════════════════════════════════╗');
+        console.log('║  MISSING REQUIRED ENVIRONMENT VARIABLE                            ║');
+        console.log('╚═══════════════════════════════════════════════════════════════════╝\n');
+        console.log(`Variable: ${varName}`);
+        if (stepName) {
+            console.log(`Required by: ${stepName} step`);
+        }
+        // Display hint if provided
+        if (hint) {
+            console.log('');
+            console.log('💡 Hint:');
+            // Process hint lines - preserve formatting, only wrap plain text
+            const hintLines = this.processHintText(hint, 67);
+            hintLines.forEach(line => console.log(line));
+        }
+        console.log('');
+        // Check if this variable is already in secrets (workflow-scoped first, then global)
+        const existingSecretId = this.secretsManager.getSecretIdByName(varName, this.workflow);
+        if (existingSecretId) {
+            const secretName = this.secretsManager.getSecretName(existingSecretId);
+            const workflowInfo = this.workflow ? ` (workflow: ${this.workflow})` : ' (global)';
+            console.log(`\nℹ️  This variable already exists in your secrets file${workflowInfo}.`);
+            const useExisting = await this.promptYesNo('Use existing value?');
+            if (useExisting) {
+                const value = this.secretsManager.getSecret(existingSecretId);
+                if (value) {
+                    return { value, cancelled: false };
+                }
+            }
+        }
+        console.log('');
+        // Show interactive menu
+        const menuResponse = await prompts({
+            type: 'select',
+            name: 'action',
+            message: 'What would you like to do?',
+            choices: [
+                { title: 'Enter value now (will be saved to secrets file)', value: 'enter' },
+                { title: 'Copy prompt for AI (get guidance from AI assistant)', value: 'ai' },
+                { title: 'Cancel build', value: 'cancel' }
+            ],
+            initial: 0,
+        });
+        if (!menuResponse.action || menuResponse.action === 'cancel') {
+            return { value: '', cancelled: true };
+        }
+        if (menuResponse.action === 'ai') {
+            // Copy AI prompt to clipboard
+            if (hint) {
+                const aiPrompt = this.generateAIPrompt(hint);
+                await this.copyToClipboard(aiPrompt);
+                console.log('\n✅ AI prompt copied to clipboard!');
+                console.log('📋 Paste it into your AI assistant to get guidance.\n');
+            }
+            else {
+                console.log('\n⚠️  No hint available for this variable.\n');
+            }
+            return { value: '', cancelled: true, copiedToAI: true };
+        }
+        // Prompt for value
+        const isSensitive = this.isSensitiveVariable(varName);
+        console.log('');
+        if (isSensitive) {
+            console.log('⚠️  This appears to be a sensitive value (input will be hidden)\n');
+        }
+        const valueResponse = await prompts({
+            type: isSensitive ? 'password' : 'text',
+            name: 'value',
+            message: `Enter value for ${varName}:`,
+            validate: value => value.trim() === '' ? 'Value cannot be empty' : true
+        });
+        if (!valueResponse.value || valueResponse.value.trim() === '') {
+            console.log('❌ Error: Value cannot be empty');
+            return { value: '', cancelled: true };
+        }
+        return { value: valueResponse.value, cancelled: false };
+    }
+    /**
+     * Determine if a variable name suggests it's sensitive
+     * @param varName Variable name
+     * @returns True if variable appears to be sensitive
+     */
+    isSensitiveVariable(varName) {
+        const sensitivePatterns = [
+            /KEY/i,
+            /SECRET/i,
+            /PASSWORD/i,
+            /TOKEN/i,
+            /API/i,
+            /WEBHOOK/i,
+            /PRIVATE/i,
+            /CREDENTIAL/i,
+        ];
+        return sensitivePatterns.some((pattern) => pattern.test(varName));
+    }
+    /**
+     * Prompt for yes/no confirmation
+     * @param message Prompt message
+     * @returns Promise with true for yes, false for no
+     */
+    async promptYesNo(message) {
+        const response = await prompts({
+            type: 'confirm',
+            name: 'value',
+            message,
+            initial: true,
+        });
+        return response.value ?? false;
+    }
+    /**
+     * Process hint text to preserve formatting while wrapping plain text
+     * @param hint Hint text (may contain newlines and formatted sections)
+     * @param maxWidth Maximum width for wrapping plain text lines
+     * @returns Array of processed lines ready for display
+     */
+    processHintText(hint, maxWidth) {
+        const lines = hint.split('\n');
+        const result = [];
+        for (const line of lines) {
+            // Check if this line is formatted (contains box chars, bullets, or is indented)
+            const isFormatted = line.includes('┌') || line.includes('┐') ||
+                line.includes('└') || line.includes('┘') ||
+                line.includes('│') || line.includes('─') ||
+                line.trimStart().startsWith('•') ||
+                (line.startsWith('  ') && line.trim().length > 0);
+            if (isFormatted || line.trim() === '') {
+                // Preserve formatted lines and empty lines as-is with indent
+                result.push(`   ${line}`);
+            }
+            else {
+                // Wrap plain text lines
+                const wrapped = this.wrapText(line, maxWidth);
+                wrapped.forEach(wrappedLine => result.push(`   ${wrappedLine}`));
+            }
+        }
+        return result;
+    }
+    /**
+     * Wrap text to fit within a specified width
+     * @param text Text to wrap
+     * @param maxWidth Maximum width per line
+     * @returns Array of wrapped lines
+     */
+    wrapText(text, maxWidth) {
+        const words = text.split(' ');
+        const lines = [];
+        let currentLine = '';
+        for (const word of words) {
+            const testLine = currentLine ? `${currentLine} ${word}` : word;
+            if (testLine.length <= maxWidth) {
+                currentLine = testLine;
+            }
+            else {
+                if (currentLine) {
+                    lines.push(currentLine);
+                }
+                currentLine = word;
+            }
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines.length > 0 ? lines : [''];
+    }
+    /**
+     * Generate AI prompt with hint for getting guidance
+     * @param hint Hint text from the step
+     * @returns Formatted AI prompt
+     */
+    generateAIPrompt(hint) {
+        return `This is a mobile CI/CD build step. Provide a brief, senior-level explanation of its purpose and when it is used. Do not execute anything.
+
+${hint}
+
+Instructions for the assistant:
+- Give a short purpose summary (what it enables in CI/CD).
+- List only the required setup/usage steps.
+- Include example commands if relevant (e.g., how to generate, retrieve, or configure the value).
+- Include key security handling notes (storage, scope, rotation).
+- Skip beginner explanations and background theory.
+- Do not request or expose real secret values.
+- Do not simulate execution.
+- Ask only the minimum clarification questions required to avoid provider-specific mistakes. If setup differs by CI system, Git provider, signing provider, artifact host, or mobile platform — ask first; otherwise answer directly.
+
+Finish with a short "Follow-up questions" numbered list only if clarification would change the setup guidance.`;
+    }
+    /**
+     * Copy text to system clipboard
+     * @param text Text to copy
+     */
+    async copyToClipboard(text) {
+        const { spawn } = await import('child_process');
+        return new Promise((resolve, reject) => {
+            // Detect platform and use appropriate clipboard command
+            const platform = process.platform;
+            let clipboardProcess;
+            if (platform === 'darwin') {
+                // macOS
+                clipboardProcess = spawn('pbcopy');
+            }
+            else if (platform === 'linux') {
+                // Linux - try xclip first, then xsel
+                clipboardProcess = spawn('xclip', ['-selection', 'clipboard']);
+            }
+            else if (platform === 'win32') {
+                // Windows
+                clipboardProcess = spawn('clip');
+            }
+            else {
+                reject(new Error(`Clipboard not supported on platform: ${platform}`));
+                return;
+            }
+            clipboardProcess.stdin.write(text);
+            clipboardProcess.stdin.end();
+            clipboardProcess.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Clipboard command failed with code ${code}`));
+                }
+            });
+            clipboardProcess.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Close the prompts interface (no-op with prompts library)
+     */
+    close() {
+        // No cleanup needed with prompts library
+    }
+}
+//# sourceMappingURL=interactive-prompts.js.map

package/dist/src/yaml/missing-env-handler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Handler for missing environment variables with interactive prompts
+ */
+import { SecretsManager } from './secrets-manager.js';
+import { MissingEnvironmentVariableError } from './env-resolver.js';
+/**
+ * Options for MissingEnvHandler
+ */
+export interface MissingEnvHandlerOptions {
+    interactive: boolean;
+    workflow?: string;
+    secretsManager?: SecretsManager;
+}
+/**
+ * Result of handling a missing environment variable
+ */
+export interface HandleResult {
+    value?: string;
+    cancelled: boolean;
+}
+/**
+ * Handler for missing environment variables
+ * Stores values in the universal secrets file — no YAML modification
+ */
+export declare class MissingEnvHandler {
+    private secretsManager;
+    private prompts;
+    private interactive;
+    private workflow?;
+    constructor(options: MissingEnvHandlerOptions);
+    /**
+     * Handle a missing environment variable error
+     * Prompts user for value and saves to the universal secrets file
+     */
+    handleMissingVariable(error: MissingEnvironmentVariableError): Promise<HandleResult>;
+    /**
+     * Close the prompts interface
+     */
+    close(): void;
+    /**
+     * Get the secrets manager instance
+     */
+    getSecretsManager(): SecretsManager;
+}
+//# sourceMappingURL=missing-env-handler.d.ts.map

package/dist/src/yaml/missing-env-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-env-handler.d.ts","sourceRoot":"","sources":["../../../src/yaml/missing-env-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAEd,OAAO,EAAE,wBAAwB;IAO7C;;;OAGG;IACG,qBAAqB,CAAC,KAAK,EAAE,+BAA+B,GAAG,OAAO,CAAC,YAAY,CAAC;IAgC1F;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,iBAAiB,IAAI,cAAc;CAGpC"}

package/dist/src/yaml/missing-env-handler.js

@@ -0,0 +1,64 @@
+/**
+ * Handler for missing environment variables with interactive prompts
+ */
+import { SecretsManager } from './secrets-manager.js';
+import { InteractivePrompts } from './interactive-prompts.js';
+/**
+ * Handler for missing environment variables
+ * Stores values in the universal secrets file — no YAML modification
+ */
+export class MissingEnvHandler {
+    secretsManager;
+    prompts;
+    interactive;
+    workflow;
+    constructor(options) {
+        this.secretsManager = options.secretsManager || new SecretsManager();
+        this.workflow = options.workflow;
+        this.prompts = new InteractivePrompts(this.secretsManager, this.workflow);
+        this.interactive = options.interactive;
+    }
+    /**
+     * Handle a missing environment variable error
+     * Prompts user for value and saves to the universal secrets file
+     */
+    async handleMissingVariable(error) {
+        const { variableName, stepName, hint } = error;
+        if (!this.interactive) {
+            return { cancelled: true };
+        }
+        const promptResult = await this.prompts.promptForVariable(variableName, stepName, hint);
+        if (promptResult.cancelled) {
+            if (promptResult.copiedToAI) {
+                console.log('💡 After getting guidance from AI, run the pipeline again to enter the value.');
+            }
+            else {
+                console.log('\n❌ Build cancelled by user');
+            }
+            return { cancelled: true };
+        }
+        // Store in secrets file (workflow-scoped if workflow is set) and inject into current process env
+        this.secretsManager.storeSecret(variableName, promptResult.value, this.workflow);
+        process.env[variableName] = promptResult.value;
+        console.log(`\n✅ Secret stored: ${variableName}`);
+        if (this.workflow) {
+            console.log(`   Workflow: ${this.workflow}`);
+        }
+        console.log(`   Location: ${this.secretsManager.getSecretsFilePath()}`);
+        console.log(`\n💡 Next time you run this pipeline, the value will be loaded automatically.\n`);
+        return { value: promptResult.value, cancelled: false };
+    }
+    /**
+     * Close the prompts interface
+     */
+    close() {
+        this.prompts.close();
+    }
+    /**
+     * Get the secrets manager instance
+     */
+    getSecretsManager() {
+        return this.secretsManager;
+    }
+}
+//# sourceMappingURL=missing-env-handler.js.map

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

@@ -0,0 +1,33 @@
+/**
+ * YAML pipeline parser - loads and validates YAML pipeline files
+ */
+import type { YAMLPipeline } from './types.js';
+export declare class YAMLParseError extends Error {
+    readonly filePath?: string | undefined;
+    constructor(message: string, filePath?: string | undefined);
+}
+export declare class YAMLValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Loads and parses a YAML pipeline file
+ * @param filePath Path to the YAML file
+ * @returns Parsed YAML pipeline object
+ * @throws YAMLParseError if file doesn't exist or YAML syntax is invalid
+ * @throws YAMLValidationError if YAML structure is invalid
+ */
+export declare function loadYAMLPipeline(filePath: string): YAMLPipeline;
+/**
+ * Gets the list of workflow names from a YAML pipeline
+ * @param pipeline Parsed YAML pipeline
+ * @returns Array of workflow names
+ */
+export declare function getWorkflowNames(pipeline: YAMLPipeline): string[];
+/**
+ * Checks if a specific workflow exists in the pipeline
+ * @param pipeline Parsed YAML pipeline
+ * @param workflowName Name of the workflow to check
+ * @returns True if workflow exists
+ */
+export declare function hasWorkflow(pipeline: YAMLPipeline, workflowName: string): boolean;
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/yaml/parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,qBAAa,cAAe,SAAQ,KAAK;aACM,QAAQ,CAAC,EAAE,MAAM;gBAAlD,OAAO,EAAE,MAAM,EAAkB,QAAQ,CAAC,EAAE,MAAM,YAAA;CAI/D;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,CA0C/D;AA8GD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,EAAE,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAEjF"}

package/dist/src/yaml/parser.js

@@ -0,0 +1,145 @@
+/**
+ * YAML pipeline parser - loads and validates YAML pipeline files
+ */
+import * as yaml from 'js-yaml';
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { convertBitriseMetadata } from './bitrise-compat.js';
+export class YAMLParseError extends Error {
+    filePath;
+    constructor(message, filePath) {
+        super(message);
+        this.filePath = filePath;
+        this.name = 'YAMLParseError';
+    }
+}
+export class YAMLValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'YAMLValidationError';
+    }
+}
+/**
+ * Loads and parses a YAML pipeline file
+ * @param filePath Path to the YAML file
+ * @returns Parsed YAML pipeline object
+ * @throws YAMLParseError if file doesn't exist or YAML syntax is invalid
+ * @throws YAMLValidationError if YAML structure is invalid
+ */
+export function loadYAMLPipeline(filePath) {
+    const absolutePath = resolve(filePath);
+    // Check if file exists
+    if (!existsSync(absolutePath)) {
+        throw new YAMLParseError(`YAML pipeline file not found: ${filePath}`, absolutePath);
+    }
+    let fileContent;
+    try {
+        fileContent = readFileSync(absolutePath, 'utf-8');
+    }
+    catch (err) {
+        throw new YAMLParseError(`Failed to read YAML file: ${filePath}\n${err.message}`, absolutePath);
+    }
+    // Parse YAML
+    let parsed;
+    try {
+        parsed = yaml.load(fileContent);
+    }
+    catch (err) {
+        const yamlError = err;
+        throw new YAMLParseError(`Failed to parse YAML file: ${filePath}\n${yamlError.name}: ${yamlError.message}`, absolutePath);
+    }
+    // Validate structure
+    validateYAMLPipeline(parsed, filePath);
+    const pipeline = parsed;
+    // Convert Bitrise metadata to CI Build format (FR-1.1, FR-1.2)
+    convertBitriseMetadata(pipeline);
+    return pipeline;
+}
+/**
+ * Validates the basic structure of a parsed YAML pipeline
+ * @param parsed Parsed YAML object
+ * @param filePath File path for error messages
+ * @throws YAMLValidationError if validation fails
+ */
+function validateYAMLPipeline(parsed, filePath) {
+    if (!parsed || typeof parsed !== 'object') {
+        throw new YAMLValidationError(`Invalid YAML structure in ${filePath}: Expected an object at root level`);
+    }
+    // Check required fields
+    if (!parsed.format_version) {
+        throw new YAMLValidationError(`Missing required field 'format_version' in ${filePath}`);
+    }
+    if (!parsed.workflows || typeof parsed.workflows !== 'object') {
+        throw new YAMLValidationError(`Missing or invalid 'workflows' section in ${filePath}`);
+    }
+    // Check that workflows is not empty
+    const workflowNames = Object.keys(parsed.workflows);
+    if (workflowNames.length === 0) {
+        throw new YAMLValidationError(`No workflows defined in ${filePath}. At least one workflow is required.`);
+    }
+    // Validate each workflow has required fields
+    for (const workflowName of workflowNames) {
+        const workflow = parsed.workflows[workflowName];
+        if (!workflow || typeof workflow !== 'object') {
+            throw new YAMLValidationError(`Invalid workflow '${workflowName}' in ${filePath}: Expected an object`);
+        }
+        if (!Array.isArray(workflow.steps)) {
+            throw new YAMLValidationError(`Missing or invalid 'steps' array in workflow '${workflowName}' in ${filePath}`);
+        }
+        if (workflow.steps.length === 0) {
+            throw new YAMLValidationError(`Workflow '${workflowName}' in ${filePath} has no steps defined`);
+        }
+    }
+    // Validate meta section if present
+    if (parsed.meta) {
+        if (typeof parsed.meta !== 'object') {
+            throw new YAMLValidationError(`Invalid 'meta' section in ${filePath}: Expected an object`);
+        }
+        // Validate platform if specified
+        if (parsed.meta.platform) {
+            const validPlatforms = ['macos', 'linux', 'windows'];
+            if (!validPlatforms.includes(parsed.meta.platform)) {
+                throw new YAMLValidationError(`Invalid platform '${parsed.meta.platform}' in ${filePath}. Must be one of: ${validPlatforms.join(', ')}`);
+            }
+        }
+        // Validate cibuild.io section if present
+        if (parsed.meta['cibuild.io']) {
+            const cibuildMeta = parsed.meta['cibuild.io'];
+            if (typeof cibuildMeta !== 'object') {
+                throw new YAMLValidationError(`Invalid 'meta.cibuild.io' section in ${filePath}: Expected an object`);
+            }
+            // Validate stack pattern if specified
+            if (cibuildMeta.stack && typeof cibuildMeta.stack === 'string') {
+                const stackPattern = /^(macos|linux|windows)-/;
+                if (cibuildMeta.stack !== 'local' && !stackPattern.test(cibuildMeta.stack)) {
+                    throw new YAMLValidationError(`Invalid stack '${cibuildMeta.stack}' in ${filePath}. Stack must be 'local' or start with 'macos-', 'linux-', or 'windows-'`);
+                }
+            }
+            // Validate machine_type if specified
+            if (cibuildMeta.machine_type) {
+                const validMachineTypes = ['standard', 'performance'];
+                if (!validMachineTypes.includes(cibuildMeta.machine_type)) {
+                    throw new YAMLValidationError(`Invalid machine_type '${cibuildMeta.machine_type}' in ${filePath}. Must be one of: ${validMachineTypes.join(', ')}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Gets the list of workflow names from a YAML pipeline
+ * @param pipeline Parsed YAML pipeline
+ * @returns Array of workflow names
+ */
+export function getWorkflowNames(pipeline) {
+    return Object.keys(pipeline.workflows);
+}
+/**
+ * Checks if a specific workflow exists in the pipeline
+ * @param pipeline Parsed YAML pipeline
+ * @param workflowName Name of the workflow to check
+ * @returns True if workflow exists
+ */
+export function hasWorkflow(pipeline, workflowName) {
+    return workflowName in pipeline.workflows;
+}
+//# sourceMappingURL=parser.js.map

package/dist/src/yaml/pipeline-with-secrets.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pipeline execution with secrets management integration
+ * Wraps converter and runner with interactive prompts for missing environment variables
+ */
+import { type ConversionResult } from './converter.js';
+import type { YAMLPipeline } from './types.js';
+import type { CIConfig } from '../types.js';
+/**
+ * Options for pipeline conversion with secrets
+ */
+export interface ConvertYAMLWithSecretsOptions {
+    yamlFilePath: string;
+    interactive: boolean;
+    config: CIConfig;
+    workflowName?: string;
+}
+/**
+ * Converts YAML pipeline with automatic secrets management
+ * Prompts user for missing environment variables and updates YAML file
+ * @param pipeline Parsed YAML pipeline
+ * @param options Execution options
+ * @returns ConversionResult with pipeline and warnings
+ */
+export declare function convertYAMLWithSecrets(pipeline: YAMLPipeline, options: ConvertYAMLWithSecretsOptions): Promise<ConversionResult>;
+//# sourceMappingURL=pipeline-with-secrets.d.ts.map

package/dist/src/yaml/pipeline-with-secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-with-secrets.d.ts","sourceRoot":"","sources":["../../../src/yaml/pipeline-with-secrets.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA4B,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAKjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,QAAQ,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,gBAAgB,CAAC,CAiF3B"}

package/dist/src/yaml/pipeline-with-secrets.js

@@ -0,0 +1,76 @@
+/**
+ * Pipeline execution with secrets management integration
+ * Wraps converter and runner with interactive prompts for missing environment variables
+ */
+import { convertYAMLToPipelineDef } from './converter.js';
+import { MissingEnvironmentVariableError } from './env-resolver.js';
+import { MissingEnvHandler } from './missing-env-handler.js';
+import { SecretsManager } from './secrets-manager.js';
+import { PreFlightValidator } from './preflight-validation.js';
+/**
+ * Converts YAML pipeline with automatic secrets management
+ * Prompts user for missing environment variables and updates YAML file
+ * @param pipeline Parsed YAML pipeline
+ * @param options Execution options
+ * @returns ConversionResult with pipeline and warnings
+ */
+export async function convertYAMLWithSecrets(pipeline, options) {
+    const secretsManager = new SecretsManager();
+    const missingEnvHandler = new MissingEnvHandler({
+        interactive: options.interactive,
+        workflow: options.workflowName,
+        secretsManager,
+    });
+    // Pre-flight validation: Check repository access before workflow execution
+    // Get the selected workflow for validation
+    const selectedWorkflowName = options.workflowName || Object.keys(pipeline.workflows)[0];
+    const selectedWorkflow = pipeline.workflows[selectedWorkflowName];
+    const preFlightValidator = new PreFlightValidator();
+    const preFlightResult = await preFlightValidator.validate(process.env, secretsManager, selectedWorkflow);
+    if (!preFlightResult.success && preFlightResult.error) {
+        console.log('\n'); // Add spacing before prompt
+        // Handle the missing or invalid repository URL
+        const handleResult = await missingEnvHandler.handleMissingVariable(preFlightResult.error);
+        missingEnvHandler.close();
+        if (handleResult.cancelled) {
+            throw new Error('Build cancelled: Repository validation failed');
+        }
+        // Retry validation after secret is stored
+        console.log('\n🔄 Retrying pre-flight validation with stored secret...\n');
+        // Import the parser to reload the YAML
+        const { loadYAMLPipeline } = await import('./parser.js');
+        const reloadedPipeline = loadYAMLPipeline(options.yamlFilePath);
+        // Retry conversion (which will re-run pre-flight)
+        return await convertYAMLWithSecrets(reloadedPipeline, options);
+    }
+    try {
+        // Attempt conversion
+        const result = await convertYAMLToPipelineDef(pipeline, options.config, options.workflowName);
+        missingEnvHandler.close();
+        return result;
+    }
+    catch (error) {
+        // Check if it's a missing environment variable error
+        if (error instanceof MissingEnvironmentVariableError) {
+            console.log('\n'); // Add spacing before prompt
+            // Handle the missing variable
+            const handleResult = await missingEnvHandler.handleMissingVariable(error);
+            missingEnvHandler.close();
+            if (handleResult.cancelled) {
+                throw new Error('Build cancelled: Missing required environment variable');
+            }
+            // Retry conversion after secret is stored
+            // The YAML file has been updated with the secret reference
+            // We need to reload and convert again
+            console.log('\n🔄 Retrying pipeline conversion with stored secret...\n');
+            // Import the parser to reload the YAML
+            const { loadYAMLPipeline } = await import('./parser.js');
+            const reloadedPipeline = loadYAMLPipeline(options.yamlFilePath);
+            // Retry conversion with the new secrets manager that has the value
+            return await convertYAMLWithSecrets(reloadedPipeline, options);
+        }
+        // Re-throw other errors
+        throw error;
+    }
+}
+//# sourceMappingURL=pipeline-with-secrets.js.map