pr-shepherd 0.44.0 → 0.44.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pr-shepherd",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
-  "version": "0.44.0",
+  "version": "0.44.1",
   "author": {
     "name": "Jonathan Ong",
     "email": "jonathanrichardong@gmail.com"

package/bin/exit-codes.d.mts

@@ -35,7 +35,7 @@ export declare const EXIT: Readonly<{
     readonly UNAVAILABLE: 69;
     /** Unexpected/unclassified internal error — the fallback. */
     readonly SOFTWARE: 70;
-    /** Retryable GitHub failure: 429, 5xx, rate limit exhausted, `Retry-After` present. */
+    /** Retryable GitHub failure: 429, 5xx, rate limit exhausted, Retry-After, GraphQL INTERNAL. */
     readonly TEMPFAIL: 75;
     /** GitHub 401/403 — missing token or insufficient PAT scopes. */
     readonly NOPERM: 77;

package/bin/exit-codes.mjs

@@ -34,7 +34,7 @@ export const EXIT = Object.freeze({
     UNAVAILABLE: 69,
     /** Unexpected/unclassified internal error — the fallback. */
     SOFTWARE: 70,
-    /** Retryable GitHub failure: 429, 5xx, rate limit exhausted, `Retry-After` present. */
+    /** Retryable GitHub failure: 429, 5xx, rate limit exhausted, Retry-After, GraphQL INTERNAL. */
     TEMPFAIL: 75,
     /** GitHub 401/403 — missing token or insufficient PAT scopes. */
     NOPERM: 77,

package/bin/github/errors.d.mts

@@ -3,7 +3,13 @@ import type { RateLimitInfo } from "./http.mts";
 export interface GitHubGraphQlError {
     message: string;
     path?: unknown;
+    /** GitHub's GraphQL `type` field — `INTERNAL` on engine crashes. */
+    type?: string;
+    /** GraphQL `extensions`; GitHub often sets `{ code: "INTERNAL" }`. */
+    extensions?: unknown;
 }
+/** GitHub GraphQL engine crash: HTTP 200, `data: null`, INTERNAL type/code or message. */
+export declare function isRetryableGraphQlInternal(graphqlErrors?: GitHubGraphQlError[]): boolean;
 export declare class GitHubRequestError extends ShepherdError {
     readonly status: number;
     readonly rateLimit?: RateLimitInfo;

package/bin/github/errors.mjs

@@ -5,16 +5,42 @@ import { EXIT, ShepherdError } from "../exit-codes.mjs";
 // be resolved. Status alone can't see this, so classification must also inspect the
 // GraphQL error messages themselves.
 const GRAPHQL_PERMISSION_ERROR = /resource not accessible/i;
+const GRAPHQL_INTERNAL_MESSAGE = /something went wrong while executing your query/i;
+function isInternalToken(value) {
+    return typeof value === "string" && value.toUpperCase() === "INTERNAL";
+}
+function extensionsCode(extensions) {
+    if (typeof extensions !== "object" || extensions === null || Array.isArray(extensions)) {
+        return undefined;
+    }
+    return extensions["code"];
+}
 function hasPermissionError(graphqlErrors) {
     return graphqlErrors?.some((e) => GRAPHQL_PERMISSION_ERROR.test(e.message)) ?? false;
 }
+/** GitHub GraphQL engine crash: HTTP 200, `data: null`, INTERNAL type/code or message. */
+export function isRetryableGraphQlInternal(graphqlErrors) {
+    if (!graphqlErrors?.length)
+        return false;
+    return graphqlErrors.some((error) => {
+        if (isInternalToken(error.type))
+            return true;
+        if (isInternalToken(extensionsCode(error.extensions)))
+            return true;
+        return GRAPHQL_INTERNAL_MESSAGE.test(error.message);
+    });
+}
 function classifyStatus(status, rateLimit, retryAfterSeconds, graphqlErrors) {
     // Retry signals take priority over everything else: GitHub's secondary rate limit
     // returns 403 with a Retry-After header, which is a transient throttle — not the
     // permission-denied 403 a bad/missing token produces. Treat any retry signal as
     // TEMPFAIL first so it isn't shadowed by the checks below.
     const rateLimitExhausted = rateLimit !== undefined && rateLimit.remaining <= 0;
-    if (status === 429 || status >= 500 || retryAfterSeconds !== undefined || rateLimitExhausted) {
+    if (status === 429 ||
+        status >= 500 ||
+        retryAfterSeconds !== undefined ||
+        rateLimitExhausted ||
+        isRetryableGraphQlInternal(graphqlErrors)) {
         return EXIT.TEMPFAIL;
     }
     if (status === 401 || status === 403 || hasPermissionError(graphqlErrors))

package/bin/github/graphql-http.mjs

@@ -1,6 +1,7 @@
 import { appendEntry, nextEntry } from "../log/log-file.mjs";
 import { formatRequestEntry, formatResponseEntry } from "../log/session.mjs";
 import { GitHubRequestError } from "./errors.mjs";
+import { withGraphQlInternalRetry } from "./graphql-internal-retry.mjs";
 import { formatGraphQlErrors, parseGraphQlPayload } from "./graphql-response.mjs";
 import { makeHeaders } from "./http-auth.mjs";
 import { requestWithTokenRetry } from "./http-request.mjs";
@@ -96,10 +97,10 @@ async function graphqlInner(query, vars, opts) {
     return { data: payload.data, rateLimit, retryAfterSeconds, errors: payload.errors };
 }
 export async function graphql(query, vars = {}, opts = {}) {
-    const { data, errors } = await graphqlInner(query, vars, opts);
+    const { data, errors } = await withGraphQlInternalRetry(query, () => graphqlInner(query, vars, opts));
     return { data, errors };
 }
 export async function graphqlWithRateLimit(query, vars = {}, opts = {}) {
-    const { data, rateLimit, retryAfterSeconds, errors } = await graphqlInner(query, vars, opts);
+    const { data, rateLimit, retryAfterSeconds, errors } = await withGraphQlInternalRetry(query, () => graphqlInner(query, vars, opts));
     return { data, rateLimit: rateLimit ?? undefined, retryAfterSeconds, errors };
 }

package/bin/github/graphql-internal-retry.d.mts

@@ -0,0 +1,2 @@
+/** Retry GitHub GraphQL engine crashes (HTTP 200, data: null, INTERNAL) on reads. */
+export declare function withGraphQlInternalRetry<T>(document: string, run: () => Promise<T>): Promise<T>;

package/bin/github/graphql-internal-retry.mjs

@@ -0,0 +1,50 @@
+import { sleep } from "../util/sleep.mjs";
+import { GitHubRequestError, isRetryableGraphQlInternal } from "./errors.mjs";
+const GRAPHQL_INTERNAL_RETRY_DELAYS = [500, 1500];
+/** True when the root operation is a mutation. Anonymous `{...}` is a query. */
+function isGraphQlMutationDocument(document) {
+    let rest = document;
+    for (;;) {
+        rest = rest.replace(/^\s+/, "");
+        if (rest.startsWith("#")) {
+            const nl = rest.indexOf("\n");
+            rest = nl === -1 ? "" : rest.slice(nl + 1);
+            continue;
+        }
+        if (rest.startsWith('"""')) {
+            const end = rest.indexOf('"""', 3);
+            rest = end === -1 ? "" : rest.slice(end + 3);
+            continue;
+        }
+        break;
+    }
+    return /^mutation\b/i.test(rest);
+}
+function hasServerBackoff(err) {
+    if (err.retryAfterSeconds !== undefined)
+        return true;
+    return err.rateLimit !== undefined && err.rateLimit.remaining <= 0;
+}
+/** Retry GitHub GraphQL engine crashes (HTTP 200, data: null, INTERNAL) on reads. */
+export async function withGraphQlInternalRetry(document, run) {
+    let lastErr;
+    for (let attempt = 1; attempt <= GRAPHQL_INTERNAL_RETRY_DELAYS.length + 1; attempt++) {
+        try {
+            return await run();
+        }
+        catch (err) {
+            if (!(err instanceof GitHubRequestError) ||
+                !isRetryableGraphQlInternal(err.graphqlErrors) ||
+                isGraphQlMutationDocument(document) ||
+                hasServerBackoff(err)) {
+                throw err;
+            }
+            lastErr = err;
+            const delay = GRAPHQL_INTERNAL_RETRY_DELAYS[attempt - 1];
+            if (delay === undefined)
+                break;
+            await sleep(delay);
+        }
+    }
+    throw lastErr;
+}

package/bin/github/graphql-response.mjs

@@ -13,7 +13,7 @@ export function parseGraphQlPayload(parsed, status, rateLimit, retryAfterSeconds
                 typeof error["message"] === "string")) {
             throw malformedGraphQlResponse("errors field is not an array of GraphQL errors", status, rateLimit, retryAfterSeconds);
         }
-        errors = record["errors"];
+        errors = record["errors"].map((error) => parseGraphQlError(error));
     }
     if (!("data" in record)) {
         if (errors?.length)
@@ -26,6 +26,16 @@ export function parseGraphQlPayload(parsed, status, rateLimit, retryAfterSeconds
     }
     return { data: record["data"] ?? null, errors };
 }
+function parseGraphQlError(error) {
+    const parsed = { message: error["message"] };
+    if ("path" in error)
+        parsed.path = error["path"];
+    if (typeof error["type"] === "string")
+        parsed.type = error["type"];
+    if (error["extensions"] !== undefined)
+        parsed.extensions = error["extensions"];
+    return parsed;
+}
 export function formatGraphQlErrors(errors) {
     return (errors ?? [])
         .map((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "0.44.0",
+  "version": "0.44.1",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
   "keywords": [
     "automation",

package/plugins/pr-shepherd/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "0.44.0",
+  "version": "0.44.1",
   "description": "Autonomous PR CI monitor and review-comment resolver for Codex.",
   "author": {
     "name": "Jonathan Ong",

package/plugins/pr-shepherd/.codex.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "pr-shepherd": {
       "command": "npx",
-      "args": ["--yes", "--package", "pr-shepherd@0.44.0", "pr-shepherd-mcp"]
+      "args": ["--yes", "--package", "pr-shepherd@0.44.1", "pr-shepherd-mcp"]
     }
   }
 }

package/plugins/pr-shepherd/.mcp.json

@@ -1,6 +1,6 @@
 {
   "pr-shepherd": {
     "command": "npx",
-    "args": ["--yes", "--package", "pr-shepherd@0.44.0", "pr-shepherd-mcp"]
+    "args": ["--yes", "--package", "pr-shepherd@0.44.1", "pr-shepherd-mcp"]
   }
 }