@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.1

package/dist/lib/work-push.js

@@ -1,627 +1,25 @@
-import { CicdGateway, CicdGatewayError } from './cicd-gateway.js';
-import { appendCommandOutputLine, attachCapturedOutputLogs } from './command-output-buffer.js';
-import { DEFAULT_WORK_PUSH_RETRY_TIMEOUT_SECONDS, readLastBaseBranch, readLastDevOrgBranch, readLastFullMetadataSelected, readLastPermissionSelected, readLastWorkItem, readSkipNestedMetadataDetection, readWorkPushRetryTimeoutSeconds, } from './defaults-store.js';
-import { hasSalesforceDataDeploymentStep, normalizeDeploymentSteps, userStoryDeploymentStepsEndpoint, } from './deployment-step-types.js';
-import { checkoutBranch, commitAllowEmpty, commitAllTrackedChanges, countCommitsSince, fetchOriginBranch, getCommitsNameStatus, getCurrentBranch, getFileAtRef, getGitRepoRoot, getMergeBase, hasUnpushedCommits, listPendingChanges, mergeTheirsIgnoreSpaceChange, originBranchRef, pullOriginBranch, pushOriginBranch, restoreFeatureBranch, } from './git-worktree.js';
-import { detectNestedMetadataChanges, formatNestedMetadataSelection, listDeletableNestedChildren, listNestedParentCandidates, } from './nested-metadata-changes.js';
-import { buildVarReplacementEntries, runVarReplacement } from './var-replacement.js';
-import { resolveWorkItemId, WorkActiveResolutionError } from './work-active.js';
-import { parseCommaSeparatedList } from './work-local-commit.js';
-import { featureBranchName, formatWorkCommandMessage, parseNameStatusLog, workPushEndpoint, workPushLockEndpoint, } from './work-types.js';
-import { fetchWorkPushReplacementRules, runYamlReplacement, } from './yaml-replacement.js';
-export const WORK_PUSH_RETRY_DOUBLE_AFTER_SECONDS = 5 * 60;
-/** MCP callers: record progress in the command output buffer without printing. */
-export const capturingWorkPushHooks = {
-    display(render) {
-        render();
-    },
-    log(message) {
-        appendCommandOutputLine(message);
-    },
-    async withSpinner(message, action) {
-        appendCommandOutputLine(message);
-        return action();
-    },
-};
-export class WorkPushValidationError extends Error {
-    exit;
-    suggestions;
-    constructor(message, options = {}) {
-        super(message);
-        this.name = 'WorkPushValidationError';
-        this.exit = options.exit ?? 1;
-        this.suggestions = options.suggestions;
-    }
-}
-export async function resolveActiveFeatureWorkItem() {
-    const workItem = (await readLastWorkItem())?.trim();
-    if (workItem === undefined || workItem.length === 0) {
-        throw new WorkPushValidationError('No work item recorded. Run `agentia cicd work set <work-item>` first.');
-    }
-    const expectedBranch = featureBranchName(workItem);
-    const branch = await getCurrentBranch();
-    if (branch !== expectedBranch) {
-        throw new WorkPushValidationError(`Current branch '${branch}' must be '${expectedBranch}'.`, {
-            suggestions: [`Checkout ${expectedBranch} (from \`agentia cicd work set\`).`],
-        });
-    }
-    return { branch, workItem };
-}
-/** Resolve the recorded pipeline base branch used to detect feature commits. */
-export async function resolveRecordedBaseBranch() {
-    const baseBranch = (await readLastBaseBranch())?.trim();
-    if (baseBranch === undefined || baseBranch.length === 0) {
-        throw new WorkPushValidationError('No base branch recorded. Run `agentia cicd work set <work-item>` first.');
-    }
-    return baseBranch;
-}
-/** Fetch `origin/<baseBranch>` and return that remote-tracking ref. */
-async function fetchOriginBaseRef(baseBranch) {
-    await fetchOriginBranch(baseBranch);
-    return originBranchRef(baseBranch);
-}
-/**
- * Decide whether done/submit should push.
- *
- * Salesforce Data Set / Data Template steps only waive the empty-history error.
- * When HEAD has commits beyond origin/<lastBaseBranch>, those steps must not skip
- * push or any other git validation. The local base ref is ignored: a stale local
- * main must not count origin/base history as feature work.
- */
-export async function resolveWorkPushNeed(branch) {
-    const baseBranch = await resolveRecordedBaseBranch();
-    const originBase = await fetchOriginBaseRef(baseBranch);
-    const count = await countCommitsSince(originBase);
-    if (count > 0) {
-        return {
-            needsPush: await hasUnpushedCommits(branch),
-            skippedForDataSteps: false,
-        };
-    }
-    let workItemId;
-    try {
-        workItemId = await resolveWorkItemId();
-    }
-    catch (error) {
-        if (error instanceof WorkActiveResolutionError) {
-            throw new WorkPushValidationError(error.message);
-        }
-        throw error;
-    }
-    const steps = normalizeDeploymentSteps(await CicdGateway.call({
-        endpoint: userStoryDeploymentStepsEndpoint(workItemId),
-        method: 'GET',
-    }));
-    if (hasSalesforceDataDeploymentStep(steps)) {
-        return { needsPush: false, skippedForDataSteps: true };
-    }
-    throw new WorkPushValidationError(`No commits found between ${originBase} and HEAD.`, {
-        exit: 1,
-        suggestions: ['Make at least one commit on the feature branch.'],
-    });
-}
-/** Resolve lastWorkItem / branch / lastBaseBranch / lastDevOrgBranch for work publish. */
-export async function resolveWorkPushContext() {
-    const { branch, workItem } = await resolveActiveFeatureWorkItem();
-    const baseBranch = await resolveRecordedBaseBranch();
-    const devOrgBranch = (await readLastDevOrgBranch())?.trim();
-    if (devOrgBranch === undefined || devOrgBranch.length === 0) {
-        throw new WorkPushValidationError('No lastDevOrgBranch recorded in `.agentia/config.user.json`. Set it before publishing.');
-    }
-    let workItemId;
-    try {
-        workItemId = await resolveWorkItemId();
-    }
-    catch (error) {
-        if (error instanceof WorkActiveResolutionError) {
-            throw new WorkPushValidationError(error.message);
-        }
-        throw error;
-    }
-    return { baseBranch, branch, devOrgBranch, workItem, workItemId };
-}
-const defaultSleep = async (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
-let sleepFn = defaultSleep;
-// Test-only hook
-export function setSleepForTests(nextSleep) {
-    sleepFn = nextSleep;
-}
-// Test-only hook
-export function resetSleepForTests() {
-    sleepFn = defaultSleep;
-}
-export function listChangedFilesFromCommits(commits) {
-    const addedOrModified = new Set();
-    const deleted = new Set();
-    for (const commit of commits) {
-        for (const file of commit.added) {
-            addedOrModified.add(file);
-            deleted.delete(file);
-        }
-        for (const file of commit.modified) {
-            addedOrModified.add(file);
-            deleted.delete(file);
-        }
-        for (const file of commit.removed) {
-            deleted.add(file);
-            addedOrModified.delete(file);
-        }
-    }
-    return {
-        addedOrModified: [...addedOrModified].sort((a, b) => a.localeCompare(b)),
-        deleted: [...deleted].sort((a, b) => a.localeCompare(b)),
-    };
-}
-function listChangedFiles(commits) {
-    const { addedOrModified, deleted } = listChangedFilesFromCommits(commits);
-    return [...addedOrModified, ...deleted].sort((a, b) => a.localeCompare(b));
-}
-function assertReplacementSucceeded(kind, result) {
-    if (result.exitCode === 0) {
-        return;
-    }
-    const detail = result.stderr.trim() || result.stdout.trim();
-    throw new WorkPushValidationError(detail.length > 0
-        ? `Copado ${kind} replacement failed (exit ${result.exitCode ?? 'unknown'}): ${detail}`
-        : `Copado ${kind} replacement failed with exit code ${result.exitCode ?? 'unknown'}.`);
-}
-export function resolveWorkPushRetryDelaySeconds(retryAfterSeconds, waitedSeconds) {
-    if (waitedSeconds >= WORK_PUSH_RETRY_DOUBLE_AFTER_SECONDS) {
-        return retryAfterSeconds * 2;
-    }
-    return retryAfterSeconds;
-}
-export async function registerHeadlessPush(pushBody, hooks, timeoutSeconds = DEFAULT_WORK_PUSH_RETRY_TIMEOUT_SECONDS) {
-    let waitedSeconds = 0;
-    for (;;) {
-        try {
-            // eslint-disable-next-line no-await-in-loop -- sequential retries on 429
-            return await CicdGateway.call({
-                body: pushBody,
-                endpoint: workPushEndpoint(),
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                method: 'POST',
-            });
-        }
-        catch (error) {
-            if (!(error instanceof CicdGatewayError) || error.statusCode !== 429) {
-                throw error;
-            }
-            const { retryAfterSeconds } = error;
-            if (retryAfterSeconds === undefined) {
-                throw error;
-            }
-            const delaySeconds = resolveWorkPushRetryDelaySeconds(retryAfterSeconds, waitedSeconds);
-            if (waitedSeconds + delaySeconds > timeoutSeconds) {
-                throw new CicdGatewayError(`CICD Gateway rate limited the work publish request and the retry timeout of ${timeoutSeconds}s was exceeded.`, {
-                    categories: error.categories,
-                    code: error.code,
-                    jobId: error.jobId,
-                    request: {
-                        method: error.requestMethod,
-                        url: error.requestUrl,
-                    },
-                    retryAfterSeconds: error.retryAfterSeconds,
-                    statusCode: error.statusCode,
-                });
-            }
-            hooks.display(() => {
-                hooks.log(error.jobId === undefined
-                    ? `Rate limited (429). Retrying work publish in ${delaySeconds}s` +
-                        ` (${waitedSeconds + delaySeconds}s / ${timeoutSeconds}s waited).`
-                    : `waiting for job id ${error.jobId}, Retrying work publish in ${delaySeconds}s` +
-                        ` (${waitedSeconds + delaySeconds}s / ${timeoutSeconds}s waited).`);
-            });
-            // eslint-disable-next-line no-await-in-loop -- wait before the next retry
-            await sleepFn(delaySeconds * 1000);
-            waitedSeconds += delaySeconds;
-        }
-    }
-}
-/** Metadata recorded by `cicd work commit --permissions`, pushed as `RetrieveOnly` corrections. */
-export async function readWorkPushRetrieveOnly() {
-    const stored = await readLastPermissionSelected();
-    return stored === undefined ? [] : parseCommaSeparatedList(stored);
-}
-/** Metadata recorded by `cicd work commit --full-metadata`, pushed as `fullMetadata` corrections. */
-export async function readWorkPushFullMetadata() {
-    const stored = await readLastFullMetadataSelected();
-    return stored === undefined ? [] : parseCommaSeparatedList(stored);
-}
-/**
- * Selections recorded at commit time plus the ones passed to this publish, in that order and without
- * duplicates. `cicd work publish` never stores its own flag values, so a flag adds to the recorded
- * selection for the current invocation only.
- */
-export function mergeWorkPushSelections(storedSelections, requestedSelections) {
-    const merged = new Set(storedSelections);
-    for (const entry of requestedSelections) {
-        merged.add(entry);
-    }
-    return [...merged];
-}
-/**
- * Nested children of a Profile or PermissionSet are permissions the branch does not deploy on its
- * own, so they join the selected permissions as `RetrieveOnly` corrections. Selected entries keep
- * their order and detected duplicates are dropped.
- */
-export function mergeWorkPushRetrieveOnly(selectedPermissions, permissionNestedChildren) {
-    const merged = new Set(selectedPermissions);
-    for (const child of permissionNestedChildren) {
-        merged.add(formatNestedMetadataSelection(child));
-    }
-    return [...merged];
-}
-/**
- * The gateway derives metadata items from the committed files, so a parent whose XML changed only
- * in nested blocks would be registered as a whole component. The push request drops those parents
- * through `unchanged`, appends the nested children that exist at `HEAD` through `Add`, and
- * appends the ones the branch deleted through `Del` so the gateway registers them with the delete
- * action instead of adding a component that is gone.
- *
- * Profiles and permission sets are left out of every list. The parent stays in the change list so
- * the branch still deploys it, and its children travel as `RetrieveOnly` instead of `Add` or `Del`:
- * a revoked field permission does not delete the field it points at.
- */
-export function buildNestedMetadataItemChanges(nestedMetadata) {
-    if (nestedMetadata === undefined) {
-        return { addMetadataItems: [], deletedMetadataItems: [], removeMetadataItems: [] };
-    }
-    const permissionChildren = new Set(nestedMetadata.permissionNestedChildren.map((child) => formatNestedMetadataSelection(child)));
-    const deletedMetadataItems = listDeletableNestedChildren(nestedMetadata).map((child) => formatNestedMetadataSelection(child));
-    const deletedChildren = new Set(deletedMetadataItems);
-    return {
-        addMetadataItems: nestedMetadata.nestedChildren
-            .map((child) => formatNestedMetadataSelection(child))
-            .filter((entry) => !permissionChildren.has(entry) && !deletedChildren.has(entry)),
-        deletedMetadataItems,
-        removeMetadataItems: nestedMetadata.ignoredParents.map((parent) => formatNestedMetadataSelection(parent)),
-    };
-}
-/**
- * Action prefix of each `changeListUpdate` entry, in the order the gateway applies them: the
- * structural actions first, so a dropped parent can be replaced by its nested items before an item
- * is switched to Full or RetrieveOnly.
- */
-const WORK_PUSH_CHANGE_ACTIONS = [
-    ['removeMetadataItems', 'unchanged'],
-    ['addMetadataItems', 'Add'],
-    ['deletedMetadataItems', 'Del'],
-    ['retrieveOnly', 'RetrieveOnly'],
-    ['fullMetadata', 'fullMetadata'],
-];
-/** `Action:MetadataType:MetadataName` entries for the unified push `changeListUpdate` parameter. */
-export function buildWorkPushChangeListUpdate(lists) {
-    const entries = new Set();
-    for (const [list, action] of WORK_PUSH_CHANGE_ACTIONS) {
-        for (const selection of lists[list]) {
-            entries.add(`${action}:${selection}`);
-        }
-    }
-    return [...entries];
-}
-/**
- * The deprecated per-action lists that have entries. The gateway merges them with
- * `changeListUpdate`, so they stay in the request for gateways that predate it, while an empty list
- * never reaches the request.
- */
-function listDeprecatedMetadataLists(lists) {
-    return Object.fromEntries(Object.entries(lists).filter(([, entries]) => entries.length > 0));
-}
-async function applyCopadoReplacements(options) {
-    const { baseBranch, branch, commits, hooks, tipCommitId, workItem, workItemId } = options;
-    const { display, log, withSpinner } = hooks;
-    const { addedOrModified } = listChangedFilesFromCommits(commits);
-    if (addedOrModified.length === 0) {
-        // An empty `-c/--include` list makes both jars walk the whole working tree.
-        return { commits, tipCommitId };
-    }
-    display(() => {
-        log(`Added/modified files for replacements: ${addedOrModified.length}`);
-    });
-    const rules = await withSpinner('Fetching Copado replacements', () => fetchWorkPushReplacementRules(workItemId));
-    const environmentVariables = rules.environmentVariables ?? [];
-    const varReplacements = buildVarReplacementEntries(environmentVariables);
-    const replacementRulesYml = rules.replacementRulesYml?.trim() ?? '';
-    if (varReplacements.length === 0 && replacementRulesYml.length === 0) {
-        display(() => {
-            log('No Copado environment variables or yaml replacement rules linked to the work item.');
-        });
-        return { commits, tipCommitId };
-    }
-    const repoRoot = await getGitRepoRoot();
-    if (varReplacements.length > 0) {
-        const replacement = await withSpinner('Applying Copado environment variable replacements', () => runVarReplacement({
-            changedFiles: addedOrModified,
-            cwd: repoRoot,
-            environmentVariables,
-            targetFolder: repoRoot,
-        }));
-        assertReplacementSucceeded('environment variable', replacement);
-    }
-    else {
-        display(() => {
-            log('No Copado environment variables linked to the work item.');
-        });
-    }
-    if (replacementRulesYml.length > 0) {
-        const replacement = await withSpinner('Applying Copado yaml replacements', () => runYamlReplacement({
-            branchName: branch,
-            changedFiles: addedOrModified,
-            cwd: repoRoot,
-            replacementRulesYml,
-            targetFolder: repoRoot,
-        }));
-        assertReplacementSucceeded('yaml', replacement);
-    }
-    else {
-        display(() => {
-            log('No Copado yaml replacement rules linked to the work item pipeline.');
-        });
-    }
-    const pendingAfterReplacement = await listPendingChanges();
-    if (pendingAfterReplacement.length === 0) {
-        return { commits, tipCommitId };
-    }
-    const tipMessage = commits.at(-1)?.message;
-    if (tipMessage === undefined || tipMessage.length === 0) {
-        throw new WorkPushValidationError('Unable to determine tip commit message for replacement commit.');
-    }
-    // Env-var and yaml edits share one follow-up commit when either changed tracked files.
-    await withSpinner('Committing Copado replacements', () => commitAllTrackedChanges(`${tipMessage} copado replacements`));
-    const logStdout = await getCommitsNameStatus(baseBranch);
-    const refreshedCommits = parseNameStatusLog(logStdout, workItem);
-    const refreshedTipCommitId = refreshedCommits.at(-1)?.id;
-    if (refreshedTipCommitId === undefined) {
-        throw new WorkPushValidationError('Unable to determine tip commit id after Copado replacements.', {
-            exit: 1,
-        });
-    }
-    return { commits: refreshedCommits, tipCommitId: refreshedTipCommitId };
-}
-export const SKIP_NESTED_METADATA_DETECTION_CONFIG_MESSAGE = 'Nested metadata detection skipped (skipNestedMetadataDetection in .agentia/config.json or .agentia/config.user.json).';
-export const SKIP_NESTED_METADATA_DETECTION_REQUEST_MESSAGE = 'Nested metadata detection skipped by request.';
-/**
- * Nested metadata changed across every commit not in origin/<base>: the parent components whose
- * XML changed only in nested blocks, and the child components carrying the real change.
- *
- * Children of a Profile or PermissionSet parent are sent as `RetrieveOnly` and the parent itself is
- * sent as nothing at all, so it stays in the change list and deploys the permissions the
- * `RetrieveOnly` entries select. Every other child is sent as `Add`, or as `Del` when the branch
- * removed its block, and its parent as `unchanged`. Returns `undefined` when detection was skipped
- * by caller request or by configuration, so a misdetection never blocks a push.
- *
- * A parent named in `fullMetadata`, or a nested parent file that is brand new on the branch, is
- * deliberately committed as a complete file, so it is never decomposed: it keeps its own metadata
- * item and reports no nested children.
- */
-async function reportNestedMetadataChanges(options) {
-    const { baseBranch, commits, fullMetadata, hooks, skipRequested } = options;
-    const { display, log, withSpinner } = hooks;
-    const skippedByConfig = skipRequested === true ? false : await readSkipNestedMetadataDetection();
-    if (skipRequested === true || skippedByConfig) {
-        display(() => {
-            log(skipRequested === true
-                ? SKIP_NESTED_METADATA_DETECTION_REQUEST_MESSAGE
-                : SKIP_NESTED_METADATA_DETECTION_CONFIG_MESSAGE);
-        });
-        return undefined;
-    }
-    const { addedOrModified } = listChangedFilesFromCommits(commits);
-    const fullMetadataSelections = new Set(fullMetadata);
-    const allCandidates = listNestedParentCandidates(addedOrModified);
-    const candidates = allCandidates.filter((candidate) => !fullMetadataSelections.has(formatNestedMetadataSelection(candidate)));
-    const keptWhole = allCandidates
-        .filter((candidate) => fullMetadataSelections.has(formatNestedMetadataSelection(candidate)))
-        .map((candidate) => formatNestedMetadataSelection(candidate));
-    const changes = candidates.length === 0
-        ? {
-            deletedNestedChildren: [],
-            fullMetadataParents: [],
-            ignoredParents: [],
-            nestedChildren: [],
-            permissionNestedChildren: [],
-            permissionParents: [],
-        }
-        : await withSpinner('Detecting nested metadata changes', async () => {
-            const mergeBase = await getMergeBase(baseBranch);
-            return detectNestedMetadataChanges({
-                filePaths: candidates.map((candidate) => candidate.filePath),
-                readBase: (filePath) => getFileAtRef(mergeBase, filePath),
-                readHead: (filePath) => getFileAtRef('HEAD', filePath),
-            });
-        });
-    display(() => {
-        const notDecomposed = [
-            ...keptWhole,
-            ...changes.fullMetadataParents.map((parent) => formatNestedMetadataSelection(parent)),
-        ];
-        if (notDecomposed.length > 0) {
-            log(`Not decomposed (fullMetadata): ${notDecomposed.join(', ')}`);
-        }
-        if (changes.nestedChildren.length === 0) {
-            log('Nested metadata changes: none detected.');
-            return;
-        }
-        if (changes.ignoredParents.length > 0) {
-            log(`Nested parents: ${changes.ignoredParents
-                .map((parent) => formatNestedMetadataSelection(parent))
-                .join(', ')}`);
-        }
-        if (changes.permissionParents.length > 0) {
-            log(`Permission parents (kept in the change list): ${changes.permissionParents
-                .map((parent) => formatNestedMetadataSelection(parent))
-                .join(', ')}`);
-        }
-        log(`Nested metadata: ${changes.nestedChildren.map((child) => formatNestedMetadataSelection(child)).join(', ')}`);
-        // Only the children that can actually be registered as deletions, so the line never suggests
-        // Copado will delete a component behind a merely revoked permission.
-        const deletable = listDeletableNestedChildren(changes);
-        if (deletable.length > 0) {
-            log(`Nested metadata deleted: ${deletable
-                .map((child) => formatNestedMetadataSelection(child))
-                .join(', ')}`);
-        }
-    });
-    return changes;
-}
-async function syncDevOrgBranch(options) {
-    const { branch, devOrgBranch, hooks } = options;
-    const { withSpinner } = hooks;
-    await withSpinner(`Checking out ${devOrgBranch}`, () => checkoutBranch(devOrgBranch));
-    await withSpinner(`Pulling origin/${devOrgBranch}`, () => pullOriginBranch(devOrgBranch));
-    await withSpinner(`Merging ${branch} into ${devOrgBranch}`, () => mergeTheirsIgnoreSpaceChange(branch));
-    await withSpinner(`Pushing origin/${devOrgBranch}`, () => pushOriginBranch(devOrgBranch));
-    await withSpinner(`Checking out ${branch}`, () => checkoutBranch(branch));
-}
-/** Logs a selection list under a header, and nothing at all when the list is empty. */
-function logSelectionEntries(log, header, entries) {
-    if (entries.length === 0) {
-        return;
-    }
-    log(header);
-    for (const entry of entries) {
-        log(`  ${entry}`);
-    }
-}
-export async function performWorkPush(options) {
-    const { baseBranch, branch, devOrgBranch, hooks, workItem } = options;
-    const { display, log, withSpinner } = hooks;
-    const originBase = await withSpinner(`Fetching origin/${baseBranch}`, () => fetchOriginBaseRef(baseBranch));
-    let logStdout = await withSpinner(`Collecting commits since origin/${baseBranch}`, () => getCommitsNameStatus(originBase));
-    let commits = parseNameStatusLog(logStdout, workItem);
-    const hasSelectionFlags = options.fullMetadata !== undefined || options.permissions !== undefined;
-    const needsEmptyCommit = commits.length === 0 || !(await hasUnpushedCommits(branch));
-    if (needsEmptyCommit) {
-        if (!hasSelectionFlags) {
-            throw new WorkPushValidationError('No changes to publish.', {
-                exit: 1,
-                suggestions: [
-                    'Make at least one commit on the feature branch before publishing.',
-                    'Or pass --permissions and/or --full-metadata to publish selection corrections with an empty commit.',
-                ],
-            });
-        }
-        const emptyCommitMessage = `${workItem}: empty commit for work publish selections`;
-        await withSpinner('Creating empty commit for selection publish', () => commitAllowEmpty(emptyCommitMessage));
-        logStdout = await withSpinner(`Collecting commits since origin/${baseBranch}`, () => getCommitsNameStatus(originBase));
-        commits = parseNameStatusLog(logStdout, workItem);
-        if (commits.length === 0) {
-            throw new WorkPushValidationError('Unable to determine tip commit id after empty commit.', {
-                exit: 1,
-            });
-        }
-    }
-    const tipCommitId = commits.at(-1)?.id;
-    if (tipCommitId === undefined) {
-        throw new WorkPushValidationError('Unable to determine tip commit id.', { exit: 1 });
-    }
-    const changedFiles = listChangedFiles(commits);
-    display(() => {
-        log(`Commits to register in branch: ${commits.length}`);
-        log(`Tip commit: ${tipCommitId}`);
-        if (changedFiles.length > 0) {
-            log('Files changed in branch:');
-            for (const file of changedFiles) {
-                log(`  ${file}`);
-            }
-        }
-    });
-    let commitsToRegister = commits;
-    let tipCommitToLock = tipCommitId;
-    try {
-        const replacementResult = await applyCopadoReplacements({
-            baseBranch: originBase,
-            branch,
-            commits,
-            hooks: { display, log, withSpinner },
-            tipCommitId,
-            workItem,
-            workItemId: options.workItemId,
-        });
-        commitsToRegister = replacementResult.commits;
-        tipCommitToLock = replacementResult.tipCommitId;
-        const [storedRetrieveOnly, storedFullMetadata] = await Promise.all([
-            readWorkPushRetrieveOnly(),
-            readWorkPushFullMetadata(),
-        ]);
-        const selectedPermissions = mergeWorkPushSelections(storedRetrieveOnly, options.permissions === undefined ? [] : parseCommaSeparatedList(options.permissions));
-        const selectedFullMetadata = mergeWorkPushSelections(storedFullMetadata, options.fullMetadata === undefined ? [] : parseCommaSeparatedList(options.fullMetadata));
-        const nestedMetadata = await reportNestedMetadataChanges({
-            baseBranch: originBase,
-            commits: commitsToRegister,
-            fullMetadata: selectedFullMetadata,
-            hooks: { display, log, withSpinner },
-            skipRequested: options.skipNestedMetadataDetection,
-        });
-        const fullMetadata = mergeWorkPushSelections(selectedFullMetadata, (nestedMetadata?.fullMetadataParents ?? []).map((parent) => formatNestedMetadataSelection(parent)));
-        const lockBody = {
-            commitId: tipCommitToLock,
-            workItem,
-        };
-        const lock = await withSpinner('Notifying headless push', () => CicdGateway.call({
-            body: lockBody,
-            endpoint: workPushLockEndpoint(),
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            method: 'POST',
-        }));
-        await withSpinner(`Pushing origin/${branch}`, () => pushOriginBranch(branch));
-        const retrieveOnly = mergeWorkPushRetrieveOnly(selectedPermissions, nestedMetadata?.permissionNestedChildren ?? []);
-        const storedPermissionSet = new Set(storedRetrieveOnly);
-        const selectedPermissionSet = new Set(selectedPermissions);
-        const storedFullMetadataSet = new Set(storedFullMetadata);
-        const selectedFullMetadataSet = new Set(selectedFullMetadata);
-        display(() => {
-            logSelectionEntries(log, 'Retrieve only (lastPermissionSelected):', storedRetrieveOnly);
-            logSelectionEntries(log, 'Retrieve only (--permissions):', selectedPermissions.filter((entry) => !storedPermissionSet.has(entry)));
-            logSelectionEntries(log, 'Retrieve only (nested Profile and PermissionSet metadata):', retrieveOnly.filter((entry) => !selectedPermissionSet.has(entry)));
-            logSelectionEntries(log, 'Full metadata (lastFullMetadataSelected):', storedFullMetadata);
-            logSelectionEntries(log, 'Full metadata (--full-metadata):', selectedFullMetadata.filter((entry) => !storedFullMetadataSet.has(entry)));
-            logSelectionEntries(log, 'Full metadata (new nested parent file):', fullMetadata.filter((entry) => !selectedFullMetadataSet.has(entry)));
-        });
-        const metadataLists = {
-            ...buildNestedMetadataItemChanges(nestedMetadata),
-            fullMetadata,
-            retrieveOnly,
-        };
-        const changeListUpdate = buildWorkPushChangeListUpdate(metadataLists);
-        const pushBody = {
-            ...listDeprecatedMetadataLists(metadataLists),
-            ...(changeListUpdate.length === 0 ? {} : { changeListUpdate }),
-            commits: commitsToRegister,
-        };
-        const timeoutSeconds = await readWorkPushRetryTimeoutSeconds();
-        const push = await withSpinner('Registering headless push', () => registerHeadlessPush(attachCapturedOutputLogs(pushBody), { display, log }, timeoutSeconds));
-        display(() => {
-            log(formatWorkCommandMessage(push.message));
-        });
-        await syncDevOrgBranch({ branch, devOrgBranch, hooks });
-        return {
-            baseBranch,
-            branch,
-            ...(changeListUpdate.length === 0 ? {} : { changeListUpdate }),
-            commits: commitsToRegister,
-            devOrgBranch,
-            lock,
-            ...(nestedMetadata === undefined ? {} : { nestedMetadata }),
-            push,
-            workItem,
-        };
-    }
-    catch (error) {
-        try {
-            await restoreFeatureBranch(branch);
-        }
-        catch {
-            // Prefer the original failure; restoration is best-effort.
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=work-push.js.map
+import {modules} from './runtime.js';
+const SKIP_NESTED_METADATA_DETECTION_CONFIG_MESSAGE = modules["work-push.js"]["SKIP_NESTED_METADATA_DETECTION_CONFIG_MESSAGE"]
+const SKIP_NESTED_METADATA_DETECTION_REQUEST_MESSAGE = modules["work-push.js"]["SKIP_NESTED_METADATA_DETECTION_REQUEST_MESSAGE"]
+const WORK_PUSH_RETRY_DOUBLE_AFTER_SECONDS = modules["work-push.js"]["WORK_PUSH_RETRY_DOUBLE_AFTER_SECONDS"]
+const WorkPushValidationError = modules["work-push.js"]["WorkPushValidationError"]
+const buildNestedMetadataItemChanges = modules["work-push.js"]["buildNestedMetadataItemChanges"]
+const buildWorkPushChangeListUpdate = modules["work-push.js"]["buildWorkPushChangeListUpdate"]
+const capturingWorkPushHooks = modules["work-push.js"]["capturingWorkPushHooks"]
+const listChangedFilesFromCommits = modules["work-push.js"]["listChangedFilesFromCommits"]
+const mergeWorkPushRetrieveOnly = modules["work-push.js"]["mergeWorkPushRetrieveOnly"]
+const mergeWorkPushSelections = modules["work-push.js"]["mergeWorkPushSelections"]
+const parseFullMetadataSelections = modules["work-push.js"]["parseFullMetadataSelections"]
+const parsePermissionSelections = modules["work-push.js"]["parsePermissionSelections"]
+const performWorkPush = modules["work-push.js"]["performWorkPush"]
+const readWorkPushFullMetadata = modules["work-push.js"]["readWorkPushFullMetadata"]
+const readWorkPushRetrieveOnly = modules["work-push.js"]["readWorkPushRetrieveOnly"]
+const registerHeadlessPush = modules["work-push.js"]["registerHeadlessPush"]
+const resetSleepForTests = modules["work-push.js"]["resetSleepForTests"]
+const resolveActiveFeatureWorkItem = modules["work-push.js"]["resolveActiveFeatureWorkItem"]
+const resolveRecordedBaseBranch = modules["work-push.js"]["resolveRecordedBaseBranch"]
+const resolveWorkPushContext = modules["work-push.js"]["resolveWorkPushContext"]
+const resolveWorkPushNeed = modules["work-push.js"]["resolveWorkPushNeed"]
+const resolveWorkPushRetryDelaySeconds = modules["work-push.js"]["resolveWorkPushRetryDelaySeconds"]
+const setSleepForTests = modules["work-push.js"]["setSleepForTests"]
+export {SKIP_NESTED_METADATA_DETECTION_CONFIG_MESSAGE, SKIP_NESTED_METADATA_DETECTION_REQUEST_MESSAGE, WORK_PUSH_RETRY_DOUBLE_AFTER_SECONDS, WorkPushValidationError, buildNestedMetadataItemChanges, buildWorkPushChangeListUpdate, capturingWorkPushHooks, listChangedFilesFromCommits, mergeWorkPushRetrieveOnly, mergeWorkPushSelections, parseFullMetadataSelections, parsePermissionSelections, performWorkPush, readWorkPushFullMetadata, readWorkPushRetrieveOnly, registerHeadlessPush, resetSleepForTests, resolveActiveFeatureWorkItem, resolveRecordedBaseBranch, resolveWorkPushContext, resolveWorkPushNeed, resolveWorkPushRetryDelaySeconds, setSleepForTests};