patchrelay 0.35.11 → 0.35.13

package/dist/github-app-token.js

@@ -57,6 +57,11 @@ fi
 exec /usr/bin/gh "$@"
 `;
     await writeFile(ghWrapper, script, { mode: 0o755 });
+    const currentPath = process.env.PATH ?? "";
+    const pathEntries = currentPath.split(path.delimiter).filter(Boolean);
+    if (!pathEntries.includes(binDir)) {
+        process.env.PATH = [binDir, ...pathEntries].join(path.delimiter);
+    }
     logger.debug({ path: ghWrapper }, "Wrote gh wrapper script");
 }
 /**
@@ -144,6 +149,8 @@ export function createGitHubAppTokenManager(credentials, logger) {
             await mkdir(path.dirname(tokenFile), { recursive: true });
             await writeFile(tokenFile, token, { mode: 0o600 });
             cachedToken = token;
+            process.env.GH_TOKEN = token;
+            process.env.GITHUB_TOKEN = token;
             logger.debug("Refreshed GitHub App installation token");
         }
         catch (error) {

package/dist/github-failure-context.js

@@ -33,7 +33,14 @@ export function createGitHubFailureContextResolver() {
                 const annotations = failedCheck?.id
                     ? await resolveAnnotations(repoFullName, failedCheck.id)
                     : undefined;
-                const summary = firstNonEmpty(annotations?.[0], failedCheck?.outputTitle, failedCheck?.outputSummary, event.checkOutputTitle, event.checkOutputSummary, workflowJob?.stepName ? `Failed step: ${workflowJob.stepName}` : undefined);
+                const summary = pickFailureSummary({
+                    annotations,
+                    failedCheckOutputTitle: failedCheck?.outputTitle,
+                    failedCheckOutputSummary: failedCheck?.outputSummary,
+                    eventCheckOutputTitle: event.checkOutputTitle,
+                    eventCheckOutputSummary: event.checkOutputSummary,
+                    workflowStepName: workflowJob?.stepName,
+                });
                 const checkName = firstNonEmpty(failedCheck?.name, event.checkName);
                 const checkUrl = firstNonEmpty(failedCheck?.htmlUrl, event.checkUrl);
                 const checkDetailsUrl = firstNonEmpty(failedCheck?.detailsUrl, event.checkDetailsUrl);
@@ -105,6 +112,12 @@ export function summarizeGitHubFailureContext(context) {
     const step = context.stepName ? `${lead ?? "CI"} -> ${context.stepName}` : lead;
     return firstNonEmpty(step && context.summary ? `${step}: ${context.summary}` : undefined, step, context.summary);
 }
+export function pickFailureSummary(params) {
+    const preferredAnnotation = pickPreferredFailureAnnotation(params.annotations);
+    const structuredSummary = firstNonEmpty(params.failedCheckOutputTitle, params.failedCheckOutputSummary, params.eventCheckOutputTitle, params.eventCheckOutputSummary);
+    const failedStepSummary = params.workflowStepName ? `Failed step: ${params.workflowStepName}` : undefined;
+    return firstNonEmpty(preferredAnnotation, structuredSummary, failedStepSummary, params.annotations?.[0]);
+}
 function buildFallbackFailureContext(source, repoFullName, event) {
     const summary = firstNonEmpty(event.checkOutputTitle, event.checkOutputSummary, event.checkOutputText ? sanitizeDiagnosticText(event.checkOutputText, 240) : undefined);
     return {
@@ -119,6 +132,36 @@ function buildFallbackFailureContext(source, repoFullName, event) {
         ...(summary ? { summary } : {}),
     };
 }
+export function pickPreferredFailureAnnotation(annotations) {
+    if (!Array.isArray(annotations) || annotations.length === 0)
+        return undefined;
+    const ranked = annotations
+        .map((annotation) => ({ annotation, score: scoreFailureAnnotation(annotation) }))
+        .filter((entry) => entry.score > 0)
+        .sort((left, right) => right.score - left.score);
+    return ranked[0]?.annotation;
+}
+function scoreFailureAnnotation(annotation) {
+    const text = annotation.trim();
+    if (!text)
+        return 0;
+    const lower = text.toLowerCase();
+    if (lower.startsWith("process completed with exit code"))
+        return 0;
+    if (lower.includes("actions target node.js 20 but are being forced to run on node.js 24"))
+        return 0;
+    let score = 1;
+    if (!lower.includes("(.github)")) {
+        score += 2;
+    }
+    if (lower.includes("assertionerror") || lower.includes("expected values to be strictly equal")) {
+        score += 2;
+    }
+    if (lower.includes("error") || lower.includes("exception") || lower.includes("failed")) {
+        score += 1;
+    }
+    return score;
+}
 async function resolveFailedCheckRun(repoFullName, event) {
     if (!event.headSha)
         return undefined;

package/dist/github-rollup.js

@@ -0,0 +1,47 @@
+const FAILED_CONCLUSIONS = new Set([
+    "action_required",
+    "cancelled",
+    "failure",
+    "stale",
+    "startup_failure",
+    "timed_out",
+]);
+function normalizeGateStatus(entry) {
+    const status = entry.status?.trim().toLowerCase();
+    if (status === "queued" || status === "in_progress" || status === "requested" || status === "waiting" || status === "pending") {
+        return "pending";
+    }
+    const conclusion = entry.conclusion?.trim().toLowerCase();
+    if (conclusion === "success" || conclusion === "neutral" || conclusion === "skipped") {
+        return "success";
+    }
+    if (conclusion && FAILED_CONCLUSIONS.has(conclusion)) {
+        return "failure";
+    }
+    return status === "completed" ? "failure" : "pending";
+}
+export function deriveGateCheckStatusFromRollup(statusCheckRollup, gateCheckNames) {
+    if (!Array.isArray(statusCheckRollup) || statusCheckRollup.length === 0) {
+        return undefined;
+    }
+    const expectedNames = gateCheckNames
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean);
+    if (expectedNames.length === 0) {
+        return undefined;
+    }
+    const matches = statusCheckRollup.filter((entry) => {
+        if (typeof entry?.name !== "string" || !entry.name.trim())
+            return false;
+        return expectedNames.includes(entry.name.trim().toLowerCase());
+    });
+    if (matches.length === 0) {
+        return undefined;
+    }
+    const normalized = matches.map((entry) => normalizeGateStatus(entry));
+    if (normalized.some((status) => status === "pending"))
+        return "pending";
+    if (normalized.some((status) => status === "failure"))
+        return "failure";
+    return "success";
+}