Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
#!/usr/bin/env node
// Refuse a pull request that targets its own head branch.
//
// WHY: PR #8912 has head == base == release/v3.8.50 — a PR from a branch to itself. It has no
// diff, it can never merge, and GitHub keeps it in the queue forever with a full check board
// attached. It survived because nothing looks wrong: the checks are green (there is nothing to
// check), the mergeability just reads "unknown", and it quietly costs review attention and CI
// minutes on every push to that branch.
//
// The check is one field comparison, which is the point — it is cheaper than the confusion.
//
// Usage (in CI, inside a pull_request job):
// HEAD_REF="$GITHUB_HEAD_REF" BASE_REF="$GITHUB_BASE_REF" \
// HEAD_SHA=... BASE_SHA=... node scripts/check/check-pr-self-target.mjs
// Exit: 0 when the PR is well-formed or there is no PR context, 1 when it targets itself.
import fs from "node:fs";
import { fileURLToPath } from "node:url";
/**
* Classify a PR's head/base pair.
*
* Both signals are checked because either alone can be absent: `*_REF` is empty for
* cross-fork events in some contexts, and the SHAs coincide on a freshly branched PR that is
* NOT self-targeting (branch cut, nothing pushed yet) — so an equal-SHA alone must not fail.
* Only an equal REF is conclusive; equal SHAs are reported as a warning.
*/
export function classifyPrTarget({ headRef, baseRef, headSha, baseSha } = {}) {
const hr = String(headRef ?? "").trim();
const br = String(baseRef ?? "").trim();
const hs = String(headSha ?? "").trim();
const bs = String(baseSha ?? "").trim();
if (!hr && !br) return { verdict: "no-pr-context" };
if (hr && br && hr === br) {
return {
verdict: "self-targeting",
reason: `head and base are the same branch (${hr}) — this PR has no diff and can never merge`,
};
}
if (hs && bs && hs === bs) {
// Legitimate right after cutting a branch: the tip has not moved yet. Not a failure.
return {
verdict: "empty-diff",
reason: `head and base point at the same commit (${hs.slice(0, 10)}) — nothing to review yet`,
};
}
return { verdict: "ok" };
}
function main() {
const r = classifyPrTarget({
headRef: process.env.HEAD_REF,
baseRef: process.env.BASE_REF,
headSha: process.env.HEAD_SHA,
baseSha: process.env.BASE_SHA,
});
if (r.verdict === "self-targeting") {
process.stderr.write(
`::error::PR targets its own branch — ${r.reason}.\n` +
`Close it, or repoint the base at the branch you actually want to merge into ` +
`(gh pr edit <N> --base <branch>, then VERIFY with gh pr view <N> --json baseRefName — ` +
`the edit fails silently).\n`
);
return 1;
}
if (r.verdict === "empty-diff") {
process.stdout.write(`::warning::${r.reason}.\n`);
return 0;
}
process.stdout.write(
r.verdict === "no-pr-context"
? "[pr-self-target] no PR context — skipping.\n"
: "[pr-self-target] OK — head and base differ.\n"
);
return 0;
}
if (
process.argv[1] &&
fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url))
) {
process.exit(main());
}