@invarn/cibuild 1.3.16 → 1.3.17

package/dist/src/commands/edit.d.ts

@@ -0,0 +1,3 @@
+import '../yaml/steps/index.js';
+export declare function handleEditCommand(pipelinePath: string, workflowName?: string): Promise<void>;
+//# sourceMappingURL=edit.d.ts.map

package/dist/src/commands/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../src/commands/edit.ts"],"names":[],"mappings":"AAUA,OAAO,wBAAwB,CAAC;AAkYhC,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CA+Sf"}

package/dist/src/commands/edit.js

@@ -0,0 +1,651 @@
+import * as fs from 'node:fs';
+import * as readline from 'node:readline';
+import { resolve, basename } from 'node:path';
+import * as yaml from 'js-yaml';
+import prompts from 'prompts';
+import { loadYAMLPipeline } from '../yaml/parser.js';
+import { SecretsManager } from '../yaml/secrets-manager.js';
+import { getAvailableSteps, getStepMetadata } from '../yaml/steps/registry.js';
+// Ensure the step registry is populated
+import '../yaml/steps/index.js';
+function getStepKey(step) {
+    return Object.keys(step)[0];
+}
+function getStepDisplayName(stepKey, step) {
+    const config = step[stepKey];
+    const baseName = stepKey.split('@')[0];
+    return config?.title ? `${baseName} (${config.title})` : baseName;
+}
+function formatValueForDisplay(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (Array.isArray(value))
+        return value.map(String).join(', ');
+    const str = String(value);
+    const firstLine = str.split('\n')[0];
+    return str.includes('\n') ? `${firstLine}...` : firstLine;
+}
+function formatValueForEdit(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (Array.isArray(value))
+        return value.map(String).join(', ');
+    return String(value);
+}
+function parseEditedValue(edited, originalValue) {
+    if (Array.isArray(originalValue)) {
+        return edited.split(/,\s*|\n/).map((s) => s.trim()).filter(Boolean);
+    }
+    if (typeof originalValue === 'number') {
+        const num = Number(edited);
+        return isNaN(num) ? edited : num;
+    }
+    return edited;
+}
+/** Returns all $VAR / ${VAR} names referenced in a value (recursively for arrays). */
+function extractEnvRefs(value) {
+    if (Array.isArray(value))
+        return value.flatMap(extractEnvRefs);
+    if (typeof value !== 'string')
+        return [];
+    const refs = [];
+    const regex = /\$\{?([A-Z_][A-Z0-9_]*)\}?/g;
+    let match;
+    while ((match = regex.exec(value)) !== null) {
+        refs.push(match[1]);
+    }
+    return refs;
+}
+/** Returns true if varName is resolvable from pipeline envs or the secrets store. */
+function isVarDefined(varName, pipeline, workflowName, secretsManager) {
+    const appEnvKeys = (pipeline.app?.envs ?? []).flatMap(Object.keys);
+    if (appEnvKeys.includes(varName))
+        return true;
+    const workflowEnvKeys = (pipeline.workflows[workflowName]?.envs ?? []).flatMap(Object.keys);
+    if (workflowEnvKeys.includes(varName))
+        return true;
+    return secretsManager.hasSecret(varName, workflowName);
+}
+function printPipelineSummary(fileName, selectedWorkflow, steps) {
+    console.log(`\nPipeline: ${fileName}`);
+    console.log('─'.repeat(50));
+    console.log(`Workflow: ${selectedWorkflow}`);
+    console.log('  Steps:');
+    steps.forEach((step, i) => {
+        const stepKey = getStepKey(step);
+        const config = step[stepKey];
+        const displayName = getStepDisplayName(stepKey, step);
+        console.log(`    ${i + 1}. ${displayName}`);
+        if (config?.inputs && Object.keys(config.inputs).length > 0) {
+            for (const [key, value] of Object.entries(config.inputs)) {
+                const displayValue = formatValueForDisplay(value);
+                console.log(`         ${key}: ${displayValue}`);
+            }
+        }
+    });
+    console.log();
+}
+// ---------------------------------------------------------------------------
+// Add step helpers
+// ---------------------------------------------------------------------------
+function suggestFromTransform(value, transform) {
+    if (transform === 'filename-to-env-var') {
+        return basename(value).replace(/[^a-zA-Z0-9]/g, '_').toUpperCase();
+    }
+    return value;
+}
+/**
+ * Collects multiline content from the user via readline, bypassing the
+ * prompts library's paste-detection dialog which causes spurious auto-advances.
+ * The user terminates input by typing .done on its own line.
+ */
+function readMultilineContent(label) {
+    return new Promise((resolve) => {
+        console.log(`\n  ${label}`);
+        console.log('  Paste content, then type .done on its own line and press Enter:\n');
+        if (process.stdin.isTTY) {
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { /* ignore */ }
+        }
+        process.stdin.resume();
+        const rl = readline.createInterface({ input: process.stdin, terminal: false });
+        const lines = [];
+        rl.on('line', (line) => {
+            if (line.trim() === '.done') {
+                rl.close();
+                return;
+            }
+            lines.push(line);
+        });
+        rl.once('close', () => {
+            process.stdin.pause();
+            resolve(lines.length > 0 ? lines.join('\n') : undefined);
+        });
+        rl.on('SIGINT', () => { rl.close(); resolve(undefined); });
+    });
+}
+async function handleAddRegisteredStep(pipelinePath, workflowName, _pipeline, stepName, secretsManager) {
+    const meta = getStepMetadata(stepName);
+    if (!meta?.inputs) {
+        console.log(`\n⚠️  No input metadata for '${stepName}'. Add the step manually in the YAML.`);
+        return;
+    }
+    const yamlInputs = {};
+    // --- collect non-secret inputs first (in declaration order) ---
+    for (const [key, inputMeta] of Object.entries(meta.inputs)) {
+        if (inputMeta.isSetupSecret)
+            continue;
+        // Compute auto-suggestion if declared
+        let initial = inputMeta.default !== undefined ? String(inputMeta.default) : '';
+        if (inputMeta.deriveFrom && inputMeta.deriveTransform) {
+            const sourceVal = yamlInputs[inputMeta.deriveFrom];
+            if (typeof sourceVal === 'string' && sourceVal) {
+                initial = suggestFromTransform(sourceVal, inputMeta.deriveTransform);
+            }
+        }
+        const isMultiline = inputMeta.inputType === 'multiline';
+        const isPassword = inputMeta.inputType === 'password';
+        const label = inputMeta.required
+            ? `${key} (${inputMeta.description})`
+            : `${key} (${inputMeta.description}) [optional, default: ${inputMeta.default ?? 'none'}]`;
+        if (isMultiline) {
+            const value = await readMultilineContent(label);
+            if (value === undefined) {
+                console.log('\nCancelled.');
+                return;
+            }
+            if (inputMeta.required && !value && !inputMeta.default)
+                continue;
+            if (value)
+                yamlInputs[key] = value;
+            else if (inputMeta.default !== undefined)
+                yamlInputs[key] = inputMeta.default;
+        }
+        else {
+            const { value } = await prompts({
+                type: isPassword ? 'password' : 'text',
+                name: 'value',
+                message: label,
+                initial,
+                validate: inputMeta.required ? (v) => v.trim() !== '' || 'Required' : undefined,
+            });
+            if (value === undefined) {
+                console.log('\nCancelled.');
+                return;
+            }
+            if (value !== '') {
+                yamlInputs[key] = inputMeta.inputType === 'path' || inputMeta.inputType === 'text' || !inputMeta.inputType
+                    ? value
+                    : value;
+            }
+            else if (inputMeta.default !== undefined) {
+                yamlInputs[key] = inputMeta.default;
+            }
+        }
+    }
+    // --- collect setup-secret inputs ---
+    for (const [key, inputMeta] of Object.entries(meta.inputs)) {
+        if (!inputMeta.isSetupSecret)
+            continue;
+        const varName = inputMeta.secretKeyField ? String(yamlInputs[inputMeta.secretKeyField] ?? '') : key.toUpperCase();
+        if (!varName) {
+            console.log(`\n⚠️  Could not determine secret variable name for input '${key}'. Skipping.`);
+            continue;
+        }
+        const { secretInputMethod } = await prompts({
+            type: 'select',
+            name: 'secretInputMethod',
+            message: `How would you like to provide ${inputMeta.description}?`,
+            choices: [
+                { title: 'Enter file path', value: 'path' },
+                { title: 'Add content manually', value: 'manual' },
+            ],
+        });
+        if (!secretInputMethod) {
+            console.log('\nCancelled.');
+            return;
+        }
+        let content;
+        if (secretInputMethod === 'path') {
+            const { filePath } = await prompts({
+                type: 'text',
+                name: 'filePath',
+                message: `Enter absolute path to file:`,
+            });
+            if (!filePath?.trim()) {
+                console.log('\nCancelled.');
+                return;
+            }
+            const expandedPath = filePath.trim().replace(/^~/, process.env.HOME ?? '~');
+            try {
+                content = fs.readFileSync(expandedPath, 'utf-8');
+            }
+            catch {
+                console.log(`\n   Could not read ${expandedPath} — check the path and try again.`);
+                return;
+            }
+        }
+        else {
+            content = await readMultilineContent(`${inputMeta.description} → will be stored as secret $${varName}`);
+            if (!content) {
+                console.log('\nCancelled.');
+                return;
+            }
+        }
+        secretsManager.storeSecret(varName, content, workflowName);
+        // Add placeholder to workflow.envs (skip if already in app.envs)
+        const rawDoc = yaml.load(fs.readFileSync(pipelinePath, 'utf-8'));
+        const appEnvKeys = (rawDoc?.app?.envs ?? []).flatMap(Object.keys);
+        if (!appEnvKeys.includes(varName)) {
+            rawDoc.workflows[workflowName].envs ??= [];
+            const wfEnvKeys = rawDoc.workflows[workflowName].envs.flatMap(Object.keys);
+            if (!wfEnvKeys.includes(varName)) {
+                rawDoc.workflows[workflowName].envs.push({ [varName]: '' });
+            }
+            fs.writeFileSync(pipelinePath, yaml.dump(rawDoc, { indent: 2, lineWidth: -1, noRefs: true }), 'utf-8');
+        }
+        console.log(`   ✅ Stored ${varName} in .cibuild-secrets.json`);
+    }
+    // --- position selector ---
+    const rawDoc = yaml.load(fs.readFileSync(pipelinePath, 'utf-8'));
+    const steps = rawDoc.workflows[workflowName].steps ?? [];
+    const positionChoices = [
+        { title: '0. [top of workflow]', value: -1 },
+        ...steps.map((s, i) => {
+            const key = Object.keys(s)[0];
+            const title = s[key]?.title ? `${i + 1}. ${key.split('@')[0]} (${s[key].title})` : `${i + 1}. ${key.split('@')[0]}`;
+            return { title, value: i };
+        }),
+    ];
+    const { insertAfter } = await prompts({
+        type: 'select',
+        name: 'insertAfter',
+        message: 'Insert after step:',
+        choices: positionChoices,
+    });
+    if (insertAfter === undefined) {
+        console.log('\nCancelled.');
+        return;
+    }
+    // --- build and insert the YAML step ---
+    const stepObj = {
+        [`${stepName}@1.0.0`]: {
+            is_skippable: true,
+            inputs: Object.keys(yamlInputs).length > 0 ? yamlInputs : undefined,
+        },
+    };
+    steps.splice(insertAfter + 1, 0, stepObj);
+    fs.writeFileSync(pipelinePath, yaml.dump(rawDoc, { indent: 2, lineWidth: -1, noRefs: true }), 'utf-8');
+    const insertedAfterLabel = insertAfter === -1
+        ? 'top of workflow'
+        : positionChoices.find((c) => c.value === insertAfter)?.title ?? String(insertAfter + 1);
+    console.log(`\n✅ Inserted ${stepName}@1.0.0 after ${insertedAfterLabel}`);
+}
+/**
+ * Detects the target platform of a workflow.
+ * Checks (in order):
+ *   1. meta.cibuild.io.platform — explicit declaration, most reliable
+ *   2. Existing steps in the workflow — fallback
+ * Returns 'ios' or 'android', or null if platform cannot be determined.
+ */
+function detectWorkflowPlatform(pipeline, workflowName) {
+    // 1. Explicit platform declaration in meta
+    const metaPlatform = pipeline.meta?.['cibuild.io']?.platform;
+    if (metaPlatform === 'ios' || metaPlatform === 'android')
+        return metaPlatform;
+    // 2. Scan existing steps as fallback
+    const workflow = pipeline.workflows[workflowName];
+    if (!workflow)
+        return null;
+    for (const yamlStep of workflow.steps) {
+        const stepKey = Object.keys(yamlStep)[0];
+        const stepName = stepKey.split('@')[0];
+        const m = getStepMetadata(stepName);
+        if (m?.platform === 'ios')
+            return 'ios';
+        if (m?.platform === 'android')
+            return 'android';
+    }
+    return null;
+}
+async function handleAddStep(pipelinePath, workflowName, pipeline, secretsManager) {
+    const workflowPlatform = detectWorkflowPlatform(pipeline, workflowName);
+    const stepNames = getAvailableSteps().filter((name) => {
+        const platform = getStepMetadata(name)?.platform ?? 'all';
+        if (platform === 'all')
+            return true;
+        if (workflowPlatform === null)
+            return true; // no platform established yet — show all
+        return platform === workflowPlatform;
+    });
+    if (workflowPlatform) {
+        console.log(`\nℹ️  Showing ${workflowPlatform} and platform-agnostic steps (workflow targets ${workflowPlatform})\n`);
+    }
+    const choices = stepNames.map((name) => {
+        const m = getStepMetadata(name);
+        return { title: `${name}${m ? `  — ${m.description}` : ''}`, value: name };
+    });
+    const { selectionMode } = await prompts({
+        type: 'select',
+        name: 'selectionMode',
+        message: 'How would you like to find a step?',
+        choices: [
+            { title: 'Search  — type to filter', value: 'search' },
+            { title: 'Browse  — scroll through list', value: 'browse' },
+        ],
+    });
+    if (!selectionMode) {
+        console.log('\nCancelled.');
+        return;
+    }
+    let stepName;
+    if (selectionMode === 'search') {
+        const result = await prompts({
+            type: 'autocomplete',
+            name: 'stepName',
+            message: 'Search step:',
+            choices,
+            suggest: async (input, _) => {
+                const q = input.toLowerCase();
+                return choices.filter((c) => c.title.toLowerCase().includes(q));
+            },
+        });
+        stepName = result.stepName;
+    }
+    else {
+        const result = await prompts({
+            type: 'select',
+            name: 'stepName',
+            message: 'Select step type:',
+            choices,
+        });
+        stepName = result.stepName;
+    }
+    if (!stepName) {
+        console.log('\nCancelled.');
+        return;
+    }
+    await handleAddRegisteredStep(pipelinePath, workflowName, pipeline, stepName, secretsManager);
+}
+// ---------------------------------------------------------------------------
+export async function handleEditCommand(pipelinePath, workflowName) {
+    const absolutePath = resolve(pipelinePath);
+    const fileName = basename(absolutePath);
+    // Load and validate the pipeline
+    let pipeline;
+    try {
+        pipeline = loadYAMLPipeline(absolutePath);
+    }
+    catch (err) {
+        console.error(`\n✗ ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    const workflowNames = Object.keys(pipeline.workflows);
+    // Select workflow
+    let selectedWorkflow = workflowName;
+    if (!selectedWorkflow) {
+        if (workflowNames.length === 1) {
+            selectedWorkflow = workflowNames[0];
+        }
+        else {
+            const { workflow } = await prompts({
+                type: 'select',
+                name: 'workflow',
+                message: 'Select a workflow:',
+                choices: workflowNames.map((name) => ({ title: name, value: name })),
+                initial: 0,
+            });
+            if (!workflow) {
+                console.log('\nCancelled.');
+                return;
+            }
+            selectedWorkflow = workflow;
+        }
+    }
+    // Narrowed to string — selection logic above guarantees this
+    const chosenWorkflow = selectedWorkflow;
+    const workflowDef = pipeline.workflows[chosenWorkflow];
+    if (!workflowDef) {
+        console.error(`\n✗ Workflow '${chosenWorkflow}' not found.`);
+        process.exit(1);
+    }
+    // Show pipeline summary
+    printPipelineSummary(fileName, chosenWorkflow, workflowDef.steps);
+    // Top-level action
+    const { action } = await prompts({
+        type: 'select',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+            { title: "Edit a step's inputs", value: 'edit' },
+            { title: 'Add step', value: 'add' },
+            { title: 'Remove step', value: 'remove' },
+            { title: 'Exit', value: 'exit' },
+        ],
+    });
+    if (!action || action === 'exit') {
+        return;
+    }
+    if (action === 'add') {
+        const secretsManager = new SecretsManager();
+        await handleAddStep(absolutePath, chosenWorkflow, pipeline, secretsManager);
+        return;
+    }
+    if (action === 'remove') {
+        const rawDoc = yaml.load(fs.readFileSync(absolutePath, 'utf-8'));
+        const steps = rawDoc.workflows[chosenWorkflow].steps ?? [];
+        if (steps.length === 0) {
+            console.log('\nNo steps to remove.\n');
+            return;
+        }
+        const { stepIndex } = await prompts({
+            type: 'select',
+            name: 'stepIndex',
+            message: 'Select step to remove:',
+            choices: steps.map((s, i) => {
+                const key = Object.keys(s)[0];
+                const title = s[key]?.title
+                    ? `${i + 1}. ${key.split('@')[0]} (${s[key].title})`
+                    : `${i + 1}. ${key.split('@')[0]}`;
+                return { title, value: i };
+            }),
+        });
+        if (stepIndex === undefined) {
+            console.log('\nCancelled.');
+            return;
+        }
+        const removedKey = Object.keys(steps[stepIndex])[0];
+        const { confirmed } = await prompts({
+            type: 'confirm',
+            name: 'confirmed',
+            message: `Remove '${removedKey.split('@')[0]}'?`,
+            initial: false,
+        });
+        if (!confirmed) {
+            console.log('\nCancelled.');
+            return;
+        }
+        steps.splice(stepIndex, 1);
+        fs.writeFileSync(absolutePath, yaml.dump(rawDoc, { indent: 2, lineWidth: -1, noRefs: true }), 'utf-8');
+        console.log(`\n✅ Removed ${removedKey.split('@')[0]} from ${fileName}`);
+        return;
+    }
+    // Load raw YAML for write-back (preserves structure we don't touch)
+    const rawContent = fs.readFileSync(absolutePath, 'utf-8');
+    const doc = yaml.load(rawContent);
+    let madeChanges = false;
+    let continueEditing = true;
+    while (continueEditing) {
+        // Select step
+        const { stepIndex } = await prompts({
+            type: 'select',
+            name: 'stepIndex',
+            message: 'Select a step to edit:',
+            choices: workflowDef.steps.map((step, i) => {
+                const stepKey = getStepKey(step);
+                const config = step[stepKey];
+                const displayName = getStepDisplayName(stepKey, step);
+                const inputCount = config?.inputs ? Object.keys(config.inputs).length : 0;
+                return {
+                    title: inputCount > 0
+                        ? `${displayName}  (${inputCount} inputs)`
+                        : `${displayName}  (no inputs)`,
+                    value: i,
+                };
+            }),
+            initial: 0,
+        });
+        if (stepIndex === undefined) {
+            console.log('\nCancelled.');
+            break;
+        }
+        const selectedStep = workflowDef.steps[stepIndex];
+        const stepKey = getStepKey(selectedStep);
+        const stepConfig = selectedStep[stepKey];
+        const inputs = stepConfig?.inputs;
+        // Look up all available inputs from step metadata
+        const stepId = stepKey.split('@')[0];
+        const metadata = getStepMetadata(stepId);
+        const metadataInputs = metadata?.inputs ?? {};
+        // Merge: currently-set YAML inputs first, then unset metadata inputs
+        const setKeys = new Set(Object.keys(inputs ?? {}));
+        const allInputKeys = [
+            ...Object.keys(inputs ?? {}),
+            ...Object.keys(metadataInputs).filter(k => !setKeys.has(k)),
+        ];
+        if (allInputKeys.length === 0) {
+            console.log('\nThis step has no inputs to edit.\n');
+        }
+        else {
+            console.log(`\nEditing: ${getStepDisplayName(stepKey, selectedStep)}`);
+            console.log('(Press Enter to keep current value, enter - to remove an input)\n');
+            const changes = {};
+            const deletions = new Set();
+            for (const key of allInputKeys) {
+                const isCurrentlySet = inputs != null && key in inputs;
+                const currentValue = isCurrentlySet ? inputs[key] : undefined;
+                const metaDefault = metadataInputs[key]?.default;
+                const displayCurrent = isCurrentlySet
+                    ? formatValueForDisplay(currentValue)
+                    : metaDefault !== undefined
+                        ? `not set  (default: ${metaDefault})`
+                        : 'not set';
+                const isMultiline = typeof currentValue === 'string' && currentValue.includes('\n');
+                const editInitial = isCurrentlySet && !isMultiline ? formatValueForEdit(currentValue) : '';
+                const { newValue } = await prompts({
+                    type: 'text',
+                    name: 'newValue',
+                    message: `${key} [${displayCurrent}]:`,
+                    initial: editInitial,
+                });
+                if (newValue === undefined) {
+                    console.log('\nCancelled.');
+                    process.exit(0);
+                }
+                if (newValue === '-') {
+                    if (isCurrentlySet)
+                        deletions.add(key);
+                }
+                else if (newValue !== '' && newValue !== editInitial) {
+                    changes[key] = parseEditedValue(newValue, currentValue ?? '');
+                }
+            }
+            if (Object.keys(changes).length === 0 && deletions.size === 0) {
+                console.log('\nNo changes made.\n');
+            }
+            else {
+                console.log('\nChanges:');
+                for (const [key, newVal] of Object.entries(changes)) {
+                    const oldDisplay = inputs && key in inputs ? formatValueForDisplay(inputs[key]) : 'not set';
+                    const newDisplay = formatValueForDisplay(newVal);
+                    console.log(`  ${key}: ${oldDisplay}  →  ${newDisplay}`);
+                }
+                for (const key of deletions) {
+                    console.log(`  ${key}: ${formatValueForDisplay(inputs[key])}  →  (removed)`);
+                }
+                const { confirmSave } = await prompts({
+                    type: 'confirm',
+                    name: 'confirmSave',
+                    message: 'Save changes?',
+                    initial: true,
+                });
+                if (confirmSave) {
+                    // Apply to the raw doc for write-back
+                    const docStepConfig = doc.workflows[chosenWorkflow].steps[stepIndex][stepKey];
+                    if (!docStepConfig.inputs)
+                        docStepConfig.inputs = {};
+                    for (const [key, val] of Object.entries(changes)) {
+                        docStepConfig.inputs[key] = val;
+                        if (!stepConfig.inputs)
+                            stepConfig.inputs = {};
+                        stepConfig.inputs[key] = val;
+                    }
+                    for (const key of deletions) {
+                        delete docStepConfig.inputs[key];
+                        if (inputs)
+                            delete inputs[key];
+                    }
+                    const updatedYaml = yaml.dump(doc, {
+                        indent: 2,
+                        lineWidth: -1,
+                        noRefs: true,
+                    });
+                    fs.writeFileSync(absolutePath, updatedYaml, 'utf-8');
+                    madeChanges = true;
+                    console.log(`\n✅ Saved to ${fileName}`);
+                    // Guardrail: check for $VAR references in saved values that have no stored value
+                    const secretsManager = new SecretsManager();
+                    const unresolvedVars = new Set();
+                    for (const val of Object.values(changes)) {
+                        for (const ref of extractEnvRefs(val)) {
+                            if (!isVarDefined(ref, pipeline, chosenWorkflow, secretsManager)) {
+                                unresolvedVars.add(ref);
+                            }
+                        }
+                    }
+                    for (const varName of unresolvedVars) {
+                        console.log(`\n⚠️  $${varName} is referenced but has no stored value.`);
+                        const { storeNow } = await prompts({
+                            type: 'confirm',
+                            name: 'storeNow',
+                            message: `Store a value for ${varName} in .cibuild-secrets.json?`,
+                            initial: true,
+                        });
+                        if (storeNow) {
+                            const { secretValue } = await prompts({
+                                type: 'password',
+                                name: 'secretValue',
+                                message: `Value for ${varName}:`,
+                                validate: (v) => v.trim() === '' ? 'Value cannot be empty' : true,
+                            });
+                            if (secretValue) {
+                                secretsManager.storeSecret(varName, secretValue, chosenWorkflow);
+                                console.log(`✅ Stored ${varName} (workflow: ${chosenWorkflow})`);
+                            }
+                        }
+                        else {
+                            console.log(`   You can add it later with: ci secrets add ${varName} ${pipelinePath} -w ${chosenWorkflow}`);
+                        }
+                    }
+                }
+            }
+        }
+        console.log();
+        const { again } = await prompts({
+            type: 'confirm',
+            name: 'again',
+            message: 'Edit another step?',
+            initial: false,
+        });
+        continueEditing = !!again;
+    }
+    if (madeChanges) {
+        console.log(`Next steps:`);
+        console.log(`  ci validate ${pipelinePath}`);
+        console.log(`  ci run ${pipelinePath} -w ${chosenWorkflow}`);
+        console.log();
+    }
+}
+//# sourceMappingURL=edit.js.map