specrails-desktop 2.55.0 → 2.56.0

package/server/dist/modules/delivery/adapters/decisions/publish.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPublish = runPublish;
+exports.runPollMerge = runPollMerge;
+exports.runReopen = runReopen;
+const pr_lifecycle_1 = require("../../runtime/pr-lifecycle");
+const observations_1 = require("./observations");
+const transitions_1 = require("./transitions");
+async function runPublish(deps, row) {
+    if (!row.delivery_sha || !row.branch) {
+        return (0, observations_1.persistMovedPrHead)(deps, row, 'the draft PR has no immutable delivery SHA/head identity; refusing to mutate unverifiable review state');
+    }
+    const beforePublish = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!beforePublish.ok) {
+        return { status: 502, body: { error: 'gh_failed', detail: beforePublish.detail } };
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(beforePublish, row.branch, row.base_branch)) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, `the recorded PR is ${beforePublish.state.toLowerCase()} but no longer matches its original head/base identity`, beforePublish.includesExpectedSha === true);
+    }
+    if (beforePublish.state === 'MERGED') {
+        return beforePublish.includesExpectedSha === true
+            ? (0, observations_1.settleMergedPr)(deps, row)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, (0, observations_1.mergedEvidenceDetail)(beforePublish), false);
+    }
+    if (beforePublish.state === 'CLOSED') {
+        return beforePublish.includesExpectedSha === true
+            ? (0, observations_1.settleObservedClosedPr)(deps, row, beforePublish)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, 'the draft PR closed without the verified implementation commit', false);
+    }
+    if (beforePublish.includesExpectedSha !== true) {
+        return (0, observations_1.persistRetryablePrObservationFailure)(deps, row, 'the draft PR no longer exposes the verified implementation commit; Retry push is available and will use the preserved exact SHA');
+    }
+    if (beforePublish.isDraft === false) {
+        return (0, observations_1.settleObservedExistingPr)(deps, row, beforePublish, false);
+    }
+    let r;
+    try {
+        r = await deps.exec.run('gh', ['pr', 'ready', row.pr_url], deps.project.path);
+    }
+    catch (err) {
+        r = { code: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) };
+    }
+    // `gh pr ready` is externally mutating and may return an ambiguous error.
+    // Re-observe exact remote truth in every case before changing the ledger.
+    const afterPublish = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!afterPublish.ok) {
+        if (r.code !== 0)
+            return (0, transitions_1.ghFailed)(r);
+        return { status: 502, body: { error: 'gh_failed', detail: `PR readiness could not be verified: ${afterPublish.detail}` } };
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(afterPublish, row.branch, row.base_branch)) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, `the PR identity changed while publishing it for review (${afterPublish.state.toLowerCase()})`, afterPublish.includesExpectedSha === true);
+    }
+    if (afterPublish.state === 'MERGED') {
+        return afterPublish.includesExpectedSha === true
+            ? (0, observations_1.settleMergedPr)(deps, row)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, (0, observations_1.mergedEvidenceDetail)(afterPublish), false);
+    }
+    if (afterPublish.state === 'CLOSED') {
+        return afterPublish.includesExpectedSha === true
+            ? (0, observations_1.settleObservedClosedPr)(deps, row, afterPublish)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, 'the PR closed without the verified implementation commit while being published', false);
+    }
+    if (afterPublish.includesExpectedSha !== true) {
+        return (0, observations_1.persistRetryablePrObservationFailure)(deps, row, 'the PR no longer exposes the verified implementation commit after publishing; Retry push is available');
+    }
+    if (afterPublish.isDraft) {
+        if (r.code !== 0)
+            return (0, transitions_1.ghFailed)(r);
+        return { status: 502, body: { error: 'gh_failed', detail: 'PR remained a draft after publishing' } };
+    }
+    return (0, observations_1.settleObservedExistingPr)(deps, row, afterPublish, false);
+}
+async function runPollMerge(deps, row) {
+    const observed = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!observed.ok)
+        return { status: 502, body: { error: 'gh_failed', detail: observed.detail } };
+    const { state, isDraft } = observed;
+    if (!row.branch) {
+        return (0, observations_1.persistMovedPrHead)(deps, row, `the ${state.toLowerCase()} PR has no recorded delivery branch; refusing to infer recoverable work`);
+    }
+    if (!row.delivery_sha) {
+        // A legacy OPEN row cannot be retried without an immutable object. Once the
+        // attached PR is terminal, however, keeping that stale URL would strand the
+        // only recorded branch behind Discard. Detach it so Create PR can perform
+        // the existing one-time legacy ref capture, without claiming any delivery.
+        if (state === 'CLOSED' || state === 'MERGED') {
+            return (0, observations_1.rerouteFromStalePr)(deps, row, `the previous PR is ${state.toLowerCase()} and this legacy delivery has no persisted verified SHA`, false);
+        }
+        return (0, observations_1.persistMovedPrHead)(deps, row, 'the open PR has no persisted verified delivery SHA; refusing to infer delivery from a mutable branch');
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(observed, row.branch, row.base_branch)) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, `the recorded PR is ${state.toLowerCase()} but no longer matches its original head/base identity`, observed.includesExpectedSha === true);
+    }
+    if (state === 'CLOSED') {
+        if (observed.includesExpectedSha !== true) {
+            return (0, observations_1.rerouteFromStalePr)(deps, row, 'the previous PR closed without the verified implementation commit', false);
+        }
+        return (0, observations_1.settleObservedClosedPr)(deps, row, observed);
+    }
+    if (state === 'OPEN') {
+        if (observed.includesExpectedSha !== true) {
+            const detail = 'the open PR no longer exposes the verified implementation commit; Retry push is available and will use the preserved exact SHA';
+            const result = (0, observations_1.persistRetryablePrObservationFailure)(deps, row, detail);
+            return {
+                ...result,
+                body: {
+                    ...result.body,
+                    deliveryVerified: false,
+                    verifiedSha: row.delivery_sha,
+                    remoteHeadSha: observed.headRefOid,
+                },
+            };
+        }
+        // A successful reopen can be observed even if the explicit action lost its
+        // follow-up `gh view` response. Polling heals pr_closed from remote truth.
+        if (row.decision === 'pr_closed') {
+            const next = isDraft ? 'pr_draft' : 'pr_ready';
+            const conflict = (0, transitions_1.casTransition)(deps, row, next, {
+                deliveryOutcome: 'delivered', statusCode: isDraft ? 'pr_draft_ready' : 'pr_ready',
+            });
+            if (conflict)
+                return conflict;
+            (0, transitions_1.finalizeTransition)(deps, row.id);
+            return {
+                status: 200,
+                body: {
+                    ok: true,
+                    decision: next,
+                    merged: false,
+                    reopened: true,
+                    prUrl: row.pr_url,
+                    deliveryVerified: true,
+                    verifiedSha: row.delivery_sha,
+                    remoteHeadSha: observed.headRefOid,
+                    pushed: false,
+                },
+            };
+        }
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                decision: row.decision,
+                merged: false,
+                deliveryVerified: true,
+                verifiedSha: row.delivery_sha,
+                remoteHeadSha: observed.headRefOid,
+                pushed: false,
+            },
+        };
+    }
+    if (state !== 'MERGED') {
+        return { status: 502, body: { error: 'gh_failed', detail: `unexpected PR state: ${state}` } };
+    }
+    // A PR can merge just before a continuation push; GitHub may then accept a
+    // later update to the head branch even though that object was never part of
+    // the merge. Never move tickets to Done from state=MERGED alone.
+    if (observed.includesExpectedSha !== true) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, (0, observations_1.mergedEvidenceDetail)(observed), false);
+    }
+    return (0, observations_1.settleMergedPr)(deps, row);
+}
+async function runReopen(deps, row) {
+    if (!row.delivery_sha || !row.branch) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, 'the closed PR cannot be reopened safely because its immutable delivery SHA/head identity is unavailable', false);
+    }
+    const beforeReopen = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!beforeReopen.ok) {
+        return { status: 502, body: { error: 'gh_failed', detail: beforeReopen.detail } };
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(beforeReopen, row.branch, row.base_branch) ||
+        beforeReopen.includesExpectedSha !== true) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, 'the closed PR no longer proves the recorded head/base and verified implementation commit', false);
+    }
+    if (beforeReopen.state === 'MERGED')
+        return (0, observations_1.settleMergedPr)(deps, row);
+    if (beforeReopen.state === 'OPEN') {
+        const next = beforeReopen.isDraft ? 'pr_draft' : 'pr_ready';
+        const conflict = (0, transitions_1.casTransition)(deps, row, next, {
+            deliveryOutcome: 'delivered', statusCode: beforeReopen.isDraft ? 'pr_draft_ready' : 'pr_ready',
+            statusDetail: null,
+        });
+        if (conflict)
+            return conflict;
+        (0, transitions_1.finalizeTransition)(deps, row.id);
+        return {
+            status: 200,
+            body: {
+                ok: true, decision: next, reopened: true, prUrl: row.pr_url,
+                deliveryVerified: true, verifiedSha: row.delivery_sha,
+                remoteHeadSha: beforeReopen.headRefOid, pushed: false,
+            },
+        };
+    }
+    let reopened;
+    try {
+        reopened = await deps.exec.run('gh', ['pr', 'reopen', row.pr_url], deps.project.path);
+    }
+    catch (err) {
+        reopened = { code: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) };
+    }
+    const observed = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!observed.ok) {
+        if (reopened.code !== 0)
+            return (0, transitions_1.ghFailed)(reopened);
+        return { status: 502, body: { error: 'gh_failed', detail: observed.detail } };
+    }
+    const identityMatches = (0, pr_lifecycle_1.matchesRecordedPrIdentity)(observed, row.branch, row.base_branch);
+    if (observed.state === 'MERGED') {
+        if (identityMatches && observed.includesExpectedSha === true)
+            return (0, observations_1.settleMergedPr)(deps, row);
+        return (0, observations_1.rerouteFromStalePr)(deps, row, identityMatches ? (0, observations_1.mergedEvidenceDetail)(observed) : 'the PR identity changed while it was being reopened', false);
+    }
+    if (observed.state === 'CLOSED') {
+        if (!identityMatches || observed.includesExpectedSha !== true) {
+            return (0, observations_1.rerouteFromStalePr)(deps, row, 'the PR remained closed without proving the recorded head/base and verified implementation commit', false);
+        }
+        if (reopened.code !== 0)
+            return (0, transitions_1.ghFailed)(reopened);
+        return { status: 502, body: { error: 'gh_failed', detail: 'PR remained closed after reopen' } };
+    }
+    if (!identityMatches || observed.includesExpectedSha !== true) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, 'the reopened PR no longer proves the recorded head/base and verified implementation commit', true);
+    }
+    const next = observed.isDraft ? 'pr_draft' : 'pr_ready';
+    const conflict = (0, transitions_1.casTransition)(deps, row, next, {
+        deliveryOutcome: 'delivered', statusCode: observed.isDraft ? 'pr_draft_ready' : 'pr_ready',
+        statusDetail: null,
+    });
+    if (conflict)
+        return conflict;
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true, decision: next, reopened: true, prUrl: row.pr_url,
+            deliveryVerified: true, verifiedSha: row.delivery_sha,
+            remoteHeadSha: observed.headRefOid, pushed: false,
+        },
+    };
+}