p-dev-harness 0.3.0

package/dist/setup/target-workflow-finalization.js

@@ -0,0 +1,690 @@
+import { DEFAULT_MERGE_METHOD } from "../config/defaults.js";
+import { loadHarnessConfig } from "../config/load-config.js";
+import { GitHubApiError } from "../github/client.js";
+import { assertPrBaseBranchMatches } from "../github/base-branch.js";
+import { evaluateChecksForMerge } from "../github/check-policy.js";
+import { classifyMergeError, isAlreadyMergedError, } from "../github/merge-result.js";
+import { inspectPullRequestForMerge, } from "../github/pr-inspector.js";
+import { parsePrUrl } from "../github/pr-url.js";
+import { redactSecretsString } from "../artifacts/redact.js";
+import { formatHarnessDispatchRepo, resolveHarnessDispatchRepo, } from "./harness-dispatch-repo.js";
+import { targetRepoSlugFromUrl } from "./harness-secret-setup.js";
+import { TARGET_WORKFLOW_PATH, } from "./remote-actions.js";
+import { buildTargetWorkflowBranchName, buildTargetWorkflowPrTitle, compareTargetWorkflowContent, previewTargetWorkflowSetup, } from "./target-workflow-setup.js";
+import { blockedCategoryMessage, classifyWorkflowInstallMergeRejection, } from "./workflow-install-merge-errors.js";
+import { buildFinalizationLockKey, withTargetWorkflowFinalizationLock, } from "./target-workflow-finalization-lock.js";
+import { WORKFLOW_INSTALL_CHECK_POLL_TIMEOUT_MS, WORKFLOW_INSTALL_VERIFICATION_TIMEOUT_MS, } from "./target-workflow-finalization-types.js";
+const sessions = new Map();
+function sessionKey(targetRepoSlug, repoConfigId) {
+    return `${targetRepoSlug}:${repoConfigId}`;
+}
+function blockedResult(input) {
+    return {
+        repoConfigId: input.repoConfigId,
+        targetRepo: input.targetRepo,
+        targetRepoSlug: input.targetRepoSlug,
+        productionBranch: input.productionBranch,
+        branchName: input.branchName,
+        lifecycle: "blocked",
+        blockedCategory: input.category,
+        message: input.customMessage ?? blockedCategoryMessage(input.category),
+        prUrl: input.prUrl,
+        prNumber: input.prNumber,
+        validatedHeadSha: input.validatedHeadSha,
+        workflowStatus: input.workflowStatus,
+        canRetry: input.category === "verification-failed",
+        requiresGitHubIntervention: ![
+            "checks-pending",
+            "mergeability-pending",
+            "branch-behind",
+            "verification-failed",
+        ].includes(input.category),
+        advancedThisRequest: input.advancedThisRequest,
+        lockContended: input.lockContended,
+    };
+}
+function progressResult(input) {
+    return {
+        repoConfigId: input.repoConfigId,
+        targetRepo: input.targetRepo,
+        targetRepoSlug: input.targetRepoSlug,
+        productionBranch: input.productionBranch,
+        branchName: input.branchName,
+        lifecycle: input.lifecycle,
+        blockedCategory: input.blockedCategory,
+        message: input.message,
+        prUrl: input.prUrl,
+        prNumber: input.prNumber,
+        validatedHeadSha: input.validatedHeadSha,
+        workflowStatus: input.workflowStatus,
+        canRetry: input.canRetry ?? false,
+        requiresGitHubIntervention: input.requiresGitHubIntervention ?? false,
+        advancedThisRequest: input.advancedThisRequest,
+        lockContended: input.lockContended,
+    };
+}
+function completeResult(input) {
+    sessions.delete(sessionKey(input.targetRepoSlug, input.repoConfigId));
+    return progressResult({
+        ...input,
+        lifecycle: "complete",
+        workflowStatus: "present",
+        message: "Workflow installed on the production branch.",
+        advancedThisRequest: input.advancedThisRequest,
+        lockContended: input.lockContended,
+    });
+}
+async function readWorkflowAtRef(client, targetRepoSlug, workflowPath, ref) {
+    const [owner, repo] = targetRepoSlug.split("/");
+    const content = await client.getRepositoryContent(owner, repo, workflowPath, ref);
+    return content ? client.decodeRepositoryContent(content) : null;
+}
+async function findOpenInstallPullRequest(client, input) {
+    const [owner, repo] = input.targetRepoSlug.split("/");
+    const pulls = await client.listPullRequests(owner, repo, {
+        state: "open",
+        base: input.productionBranch,
+        head: `${owner}:${input.branchName}`,
+    });
+    const first = pulls[0];
+    if (!first) {
+        return null;
+    }
+    return {
+        number: first.number,
+        html_url: first.html_url,
+        headSha: first.head.sha,
+    };
+}
+function validatePullRequestFiles(files, workflowPath) {
+    if (files.length !== 1) {
+        return false;
+    }
+    return files[0]?.path === workflowPath;
+}
+export async function advanceTargetWorkflowFinalizationStep(options) {
+    const { input, provider, client, lockContended = false } = options;
+    const targetRepoSlug = targetRepoSlugFromUrl(input.targetRepo);
+    if (!targetRepoSlug) {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug: "<invalid>",
+            productionBranch: input.productionBranch,
+            branchName: buildTargetWorkflowBranchName(input.repoConfigId),
+            category: "unexpected-pr-content",
+            workflowStatus: "unknown",
+            advancedThisRequest: true,
+            lockContended,
+            customMessage: `Invalid target repo URL: ${input.targetRepo}`,
+        });
+    }
+    const branchName = input.branchName ?? buildTargetWorkflowBranchName(input.repoConfigId);
+    const harnessDispatchRepo = await resolveHarnessDispatchRepo({
+        cwd: options.cwd,
+        manualRepo: input.manualHarnessDispatchRepo,
+    });
+    const preview = previewTargetWorkflowSetup({
+        repoConfigId: input.repoConfigId,
+        targetRepo: input.targetRepo,
+        productionBranch: input.productionBranch,
+        harnessDispatchRepo,
+    });
+    const intendedWorkflowContent = preview.workflowContent;
+    const harnessDispatchRepoSlug = formatHarnessDispatchRepo(harnessDispatchRepo);
+    const productionStatus = await provider.checkTargetWorkflowStatus({
+        targetRepoSlug,
+        workflowPath: TARGET_WORKFLOW_PATH,
+        intendedWorkflowContent,
+        productionBranch: input.productionBranch,
+    });
+    if (productionStatus.workflowStatus === "present") {
+        return completeResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    const session = sessions.get(sessionKey(targetRepoSlug, input.repoConfigId)) ?? {};
+    let prUrl = input.prUrl;
+    let prNumber;
+    let validatedHeadSha;
+    if (prUrl) {
+        const parsed = parsePrUrl(prUrl);
+        if (parsed) {
+            prNumber = parsed.pullNumber;
+        }
+    }
+    if (!prUrl) {
+        const discovered = await findOpenInstallPullRequest(client, {
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+        });
+        if (discovered) {
+            prUrl = discovered.html_url;
+            prNumber = discovered.number;
+            validatedHeadSha = discovered.headSha;
+        }
+    }
+    if (!prUrl || !prNumber) {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "unexpected-pr-content",
+            workflowStatus: productionStatus.workflowStatus,
+            advancedThisRequest: true,
+            lockContended,
+            customMessage: "No open workflow install PR was found for the deterministic install branch.",
+        });
+    }
+    const parsedPr = parsePrUrl(prUrl);
+    if (!parsedPr) {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "unexpected-pr-content",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    let inspection = await inspectPullRequestForMerge(client, parsedPr, input.targetRepo);
+    if (inspection.merged) {
+        const reverified = await provider.checkTargetWorkflowStatus({
+            targetRepoSlug,
+            workflowPath: TARGET_WORKFLOW_PATH,
+            intendedWorkflowContent,
+            productionBranch: input.productionBranch,
+        });
+        if (reverified.workflowStatus === "present") {
+            return completeResult({
+                repoConfigId: input.repoConfigId,
+                targetRepo: input.targetRepo,
+                targetRepoSlug,
+                productionBranch: input.productionBranch,
+                branchName,
+                prUrl,
+                prNumber,
+                advancedThisRequest: true,
+                lockContended,
+            });
+        }
+        session.verificationStartedAt ??= Date.now();
+        if (Date.now() - session.verificationStartedAt >
+            WORKFLOW_INSTALL_VERIFICATION_TIMEOUT_MS) {
+            sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+            return blockedResult({
+                repoConfigId: input.repoConfigId,
+                targetRepo: input.targetRepo,
+                targetRepoSlug,
+                productionBranch: input.productionBranch,
+                branchName,
+                category: "verification-failed",
+                workflowStatus: reverified.workflowStatus,
+                prUrl,
+                prNumber,
+                advancedThisRequest: true,
+                lockContended,
+            });
+        }
+        sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+        return progressResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            lifecycle: "verifying",
+            workflowStatus: reverified.workflowStatus,
+            message: "Verifying workflow on the production branch.",
+            prUrl,
+            prNumber,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    if (inspection.branch !== branchName) {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "unexpected-pr-content",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    try {
+        assertPrBaseBranchMatches({
+            prUrl,
+            actualBaseBranch: inspection.baseBranch,
+            expectedBaseBranch: input.productionBranch,
+        });
+    }
+    catch {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "unexpected-pr-content",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    if (inspection.isDraft) {
+        await client.markPullRequestReadyForReview(parsedPr.owner, parsedPr.repo, parsedPr.pullNumber);
+        inspection = await inspectPullRequestForMerge(client, parsedPr, input.targetRepo);
+    }
+    validatedHeadSha = inspection.headSha;
+    session.lastValidatedHeadSha = validatedHeadSha;
+    if (!validatePullRequestFiles(inspection.changedFiles, TARGET_WORKFLOW_PATH)) {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "unexpected-pr-content",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    const headWorkflowContent = await readWorkflowAtRef(client, targetRepoSlug, TARGET_WORKFLOW_PATH, inspection.headSha);
+    if (compareTargetWorkflowContent(headWorkflowContent, intendedWorkflowContent) !==
+        "present") {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "unexpected-pr-content",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+            customMessage: "Workflow install PR content does not match the harness-generated workflow.",
+        });
+    }
+    if (!intendedWorkflowContent.includes(harnessDispatchRepoSlug) ||
+        !intendedWorkflowContent.includes(`--arg repo ${input.repoConfigId}`)) {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "unexpected-pr-content",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    const loadedConfig = await loadHarnessConfig({ baseDir: options.cwd });
+    const mergeMethod = loadedConfig.config.merge?.mergeMethod ?? DEFAULT_MERGE_METHOD;
+    const checkPolicy = evaluateChecksForMerge(inspection.checks, loadedConfig.config);
+    if (checkPolicy.decision === "block") {
+        if (checkPolicy.classification === "checks_failing") {
+            return blockedResult({
+                repoConfigId: input.repoConfigId,
+                targetRepo: input.targetRepo,
+                targetRepoSlug,
+                productionBranch: input.productionBranch,
+                branchName,
+                category: "checks-failing",
+                workflowStatus: productionStatus.workflowStatus,
+                prUrl,
+                prNumber,
+                validatedHeadSha,
+                advancedThisRequest: true,
+                lockContended,
+                customMessage: redactSecretsString(checkPolicy.reason),
+            });
+        }
+        session.checksPendingSince ??= Date.now();
+        if (Date.now() - session.checksPendingSince >
+            WORKFLOW_INSTALL_CHECK_POLL_TIMEOUT_MS) {
+            sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+            return blockedResult({
+                repoConfigId: input.repoConfigId,
+                targetRepo: input.targetRepo,
+                targetRepoSlug,
+                productionBranch: input.productionBranch,
+                branchName,
+                category: "checks-pending",
+                workflowStatus: productionStatus.workflowStatus,
+                prUrl,
+                prNumber,
+                validatedHeadSha,
+                advancedThisRequest: true,
+                lockContended,
+                customMessage: "Timed out waiting for GitHub checks on the workflow install PR.",
+            });
+        }
+        sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+        return progressResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            lifecycle: "waiting-for-checks",
+            workflowStatus: productionStatus.workflowStatus,
+            message: "Waiting for GitHub checks on the workflow install PR.",
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+            blockedCategory: "checks-pending",
+        });
+    }
+    const mergeableState = inspection.mergeableState?.toLowerCase() ?? null;
+    if (mergeableState === "unknown" || inspection.mergeable === null) {
+        sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+        return progressResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            lifecycle: "waiting-for-checks",
+            workflowStatus: productionStatus.workflowStatus,
+            message: "Waiting for GitHub mergeability on the workflow install PR.",
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+            blockedCategory: "mergeability-pending",
+        });
+    }
+    if (mergeableState === "behind") {
+        if (session.branchUpdateAttemptedForHeadSha !== validatedHeadSha) {
+            try {
+                await client.updatePullRequestBranch(parsedPr.owner, parsedPr.repo, parsedPr.pullNumber, { expectedHeadSha: validatedHeadSha });
+                session.branchUpdateAttemptedForHeadSha = validatedHeadSha;
+                sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+                return progressResult({
+                    repoConfigId: input.repoConfigId,
+                    targetRepo: input.targetRepo,
+                    targetRepoSlug,
+                    productionBranch: input.productionBranch,
+                    branchName,
+                    lifecycle: "updating-branch",
+                    workflowStatus: productionStatus.workflowStatus,
+                    message: "Updating the workflow install branch.",
+                    prUrl,
+                    prNumber,
+                    validatedHeadSha,
+                    advancedThisRequest: true,
+                    lockContended,
+                });
+            }
+            catch (error) {
+                const classified = classifyWorkflowInstallMergeRejection({ error });
+                return blockedResult({
+                    repoConfigId: input.repoConfigId,
+                    targetRepo: input.targetRepo,
+                    targetRepoSlug,
+                    productionBranch: input.productionBranch,
+                    branchName,
+                    category: classified.category,
+                    workflowStatus: productionStatus.workflowStatus,
+                    prUrl,
+                    prNumber,
+                    validatedHeadSha,
+                    advancedThisRequest: true,
+                    lockContended,
+                    customMessage: classified.message,
+                });
+            }
+        }
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "branch-behind",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    if (mergeableState === "dirty" || mergeableState === "blocked") {
+        const category = mergeableState === "blocked" ? "review-required" : "merge-conflict";
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category,
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    if (inspection.mergeable === false) {
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "merge-conflict",
+            workflowStatus: productionStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    if (session.mergeAttemptedForHeadSha === validatedHeadSha) {
+        sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+        return progressResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            lifecycle: "merging",
+            workflowStatus: productionStatus.workflowStatus,
+            message: "Waiting for workflow install PR merge to complete.",
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: false,
+            lockContended,
+        });
+    }
+    try {
+        await client.mergePullRequest(parsedPr.owner, parsedPr.repo, parsedPr.pullNumber, {
+            mergeMethod: mergeMethod,
+            commitTitle: buildTargetWorkflowPrTitle(),
+            expectedHeadSha: validatedHeadSha,
+        });
+        session.mergeAttemptedForHeadSha = validatedHeadSha;
+        session.verificationStartedAt = Date.now();
+        sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+    }
+    catch (error) {
+        if (isAlreadyMergedError(error)) {
+            session.verificationStartedAt ??= Date.now();
+            sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+        }
+        else {
+            const classified = classifyWorkflowInstallMergeRejection({
+                error,
+                mergeableState: inspection.mergeableState,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            if (classified.waiting) {
+                sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+                return progressResult({
+                    repoConfigId: input.repoConfigId,
+                    targetRepo: input.targetRepo,
+                    targetRepoSlug,
+                    productionBranch: input.productionBranch,
+                    branchName,
+                    lifecycle: classified.category === "checks-pending"
+                        ? "waiting-for-checks"
+                        : "merging",
+                    workflowStatus: productionStatus.workflowStatus,
+                    message: classified.message,
+                    prUrl,
+                    prNumber,
+                    validatedHeadSha,
+                    advancedThisRequest: true,
+                    lockContended,
+                    blockedCategory: classified.category,
+                });
+            }
+            if (error instanceof GitHubApiError && classifyMergeError(error) === "github_auth_failure") {
+                return blockedResult({
+                    repoConfigId: input.repoConfigId,
+                    targetRepo: input.targetRepo,
+                    targetRepoSlug,
+                    productionBranch: input.productionBranch,
+                    branchName,
+                    category: "permission-denied",
+                    workflowStatus: productionStatus.workflowStatus,
+                    prUrl,
+                    prNumber,
+                    validatedHeadSha,
+                    advancedThisRequest: true,
+                    lockContended,
+                });
+            }
+            return blockedResult({
+                repoConfigId: input.repoConfigId,
+                targetRepo: input.targetRepo,
+                targetRepoSlug,
+                productionBranch: input.productionBranch,
+                branchName,
+                category: classified.category,
+                workflowStatus: productionStatus.workflowStatus,
+                prUrl,
+                prNumber,
+                validatedHeadSha,
+                advancedThisRequest: true,
+                lockContended,
+                customMessage: classified.message,
+            });
+        }
+    }
+    const postMergeStatus = await provider.checkTargetWorkflowStatus({
+        targetRepoSlug,
+        workflowPath: TARGET_WORKFLOW_PATH,
+        intendedWorkflowContent,
+        productionBranch: input.productionBranch,
+    });
+    if (postMergeStatus.workflowStatus === "present") {
+        return completeResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+        });
+    }
+    session.verificationStartedAt ??= Date.now();
+    if (Date.now() - session.verificationStartedAt >
+        WORKFLOW_INSTALL_VERIFICATION_TIMEOUT_MS) {
+        sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+        return blockedResult({
+            repoConfigId: input.repoConfigId,
+            targetRepo: input.targetRepo,
+            targetRepoSlug,
+            productionBranch: input.productionBranch,
+            branchName,
+            category: "verification-failed",
+            workflowStatus: postMergeStatus.workflowStatus,
+            prUrl,
+            prNumber,
+            validatedHeadSha,
+            advancedThisRequest: true,
+            lockContended,
+            customMessage: "Workflow install PR merged, but production verification timed out.",
+        });
+    }
+    sessions.set(sessionKey(targetRepoSlug, input.repoConfigId), session);
+    return progressResult({
+        repoConfigId: input.repoConfigId,
+        targetRepo: input.targetRepo,
+        targetRepoSlug,
+        productionBranch: input.productionBranch,
+        branchName,
+        lifecycle: "verifying",
+        workflowStatus: postMergeStatus.workflowStatus,
+        message: "Verifying workflow on the production branch.",
+        prUrl,
+        prNumber,
+        validatedHeadSha,
+        advancedThisRequest: true,
+        lockContended,
+        canRetry: true,
+    });
+}
+export async function finalizeTargetWorkflowRemote(options) {
+    const targetRepoSlug = targetRepoSlugFromUrl(options.input.targetRepo);
+    const lockKey = buildFinalizationLockKey(targetRepoSlug ?? options.input.targetRepo, options.input.repoConfigId);
+    const { result, lockContended } = await withTargetWorkflowFinalizationLock(lockKey, async () => advanceTargetWorkflowFinalizationStep({
+        cwd: options.cwd,
+        input: options.input,
+        provider: options.provider,
+        client: options.client,
+        lockContended: false,
+    }));
+    return {
+        ...result,
+        lockContended: lockContended || result.lockContended,
+    };
+}
+export function resetTargetWorkflowFinalizationSessionsForTests() {
+    sessions.clear();
+}
+//# sourceMappingURL=target-workflow-finalization.js.map