@intentius/chant 0.124.6 → 0.124.8

package/src/op/activities/lexicon-upgrade.test.ts

@@ -739,3 +739,61 @@ describe("a lexicon with several pins (#3288)", () => {
     expect(upgradePrTitle("sql", "17.11", "17.12", "postgres-17")).toBe("feat(sql): upgrade postgres-17 17.11 to 17.12");
   });
 });
+
+// ── Forgejo and GitLab open the PR over REST (#3798) ──────────────────
+
+describe("lexiconUpgrade pull request over REST", () => {
+  const pin = {
+    file: "src/pin.ts",
+    pattern: /V = "(.+)"/,
+    replace: (v: string) => `V = "${v}"`,
+    upstream: { owner: "o", repo: "r", kind: "releases" as const },
+  };
+
+  function fakeForge(open?: { number: number; url: string; body: string }) {
+    const calls: string[] = [];
+    const forge = {
+      findPullRequest: vi.fn(async (head: string) => (calls.push(`find ${head}`), open ? { ...open, title: "t", head } : undefined)),
+      openPullRequest: vi.fn(async (spec: { head: string; base?: string }) => (calls.push(`open ${spec.head} -> ${spec.base}`), { number: 5, url: "https://forge/pulls/5", title: "t", body: "b", head: spec.head })),
+      editPullRequest: vi.fn(async (n: number) => (calls.push(`edit ${n}`), undefined)),
+      addLabels: vi.fn(async (n: number, labels: readonly string[]) => void calls.push(`label ${n} ${labels.join(",")}`)),
+    };
+    return { forge: forge as unknown as import("../../pr-forge").PrForge, calls };
+  }
+
+  async function run(forge: import("../../pr-forge").PrForge) {
+    const { gh, calls } = recordingGh();
+    const dir = join(tmpdir(), `chant-3798-${process.pid}`);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ version: "0.1.0" }));
+    const r = await lexiconUpgrade({
+      lexicon: "k3s",
+      lexiconDir: dir,
+      mode: "pull-request",
+      _loadPin: async () => pin,
+      _checkPinned: vi.fn(async () => pinnedResult()),
+      _applyBump: vi.fn(async () => ({ filePath: "/x/src/pin.ts" })),
+      _bumpPackageVersion: vi.fn(),
+      _gh: gh,
+      _forge: forge,
+    });
+    return { r, ghCalls: calls };
+  }
+
+  test("opens the pull request and labels it through the forge, with no gh pr call", async () => {
+    const { forge, calls } = fakeForge();
+    const { r, ghCalls } = await run(forge);
+    expect(r.prUrl).toBe("https://forge/pulls/5");
+    expect(calls.filter((c) => c.startsWith("open"))).toEqual([`open ${upgradeBranchName("k3s")} -> main`]);
+    expect(calls.some((c) => c.startsWith("label"))).toBe(r.semverLabel !== undefined && r.semverLabel !== null);
+    expect(ghCalls.filter((c) => c.startsWith("gh "))).toEqual([]);
+  });
+
+  test("edits the open pull request in place of opening another", async () => {
+    const { forge, calls } = fakeForge({ number: 9, url: "https://forge/pulls/9", body: "old" });
+    const { r } = await run(forge);
+    expect(r.prUrl).toBe("https://forge/pulls/9");
+    expect(calls).toContain("edit 9");
+    expect(calls.some((c) => c.startsWith("open"))).toBe(false);
+  });
+});

package/src/op/activities/lexicon-upgrade.ts

@@ -31,6 +31,8 @@ import type { UpgradeCheckResult, LexiconId, UpstreamPin } from "../../codegen/p
 import type { RollingUpgradeResult, RollingLexicon } from "../../codegen/rolling-upgrade";
 import { bumpForSeverity, bumpPackageJsonVersion } from "../../codegen/version-bump";
 import { ghHostEnv } from "./gh-host";
+import { restPullRequestForge } from "./forge-pull-request";
+import type { PrForge } from "../../pr-forge";
 import { postOrUpdateGithubIssue } from "./reconcile";
 
 export { bumpPackageJsonVersion };
@@ -99,6 +101,12 @@ export interface LexiconUpgradeArgs {
    * Defaults to bumpPackageJsonVersion.
    */
   _bumpPackageVersion?: BumpPackageVersionFn;
+  /**
+   * The REST client the pull request is found, opened and labelled through,
+   * or null for `gh`. Default: one on a Forgejo or GitLab job, `gh`
+   * elsewhere (#3798). For tests.
+   */
+  _forge?: PrForge | null;
 }
 
 export interface LexiconUpgradeResult {
@@ -416,7 +424,8 @@ async function postLexiconIssue(
  * Check whether an open PR exists for the given branch.
  * Returns the PR URL, or null if none.
  */
-async function openPrUrl(branch: string, gh: GhRunner): Promise<string | null> {
+async function openPrUrl(branch: string, gh: GhRunner, forge?: PrForge): Promise<string | null> {
+  if (forge) return (await forge.findPullRequest(branch))?.url ?? null;
   try {
     const { stdout } = await gh(
       `gh pr view ${shellQuote(branch)} --json url,state --jq 'select(.state=="OPEN") | .url'`,
@@ -432,7 +441,8 @@ async function openPrUrl(branch: string, gh: GhRunner): Promise<string | null> {
  * Read the body of the open PR for `branch`, if any.
  * Returns null when there is no open PR or gh is unavailable.
  */
-async function currentPrBody(branch: string, gh: GhRunner): Promise<string | null> {
+async function currentPrBody(branch: string, gh: GhRunner, forge?: PrForge): Promise<string | null> {
+  if (forge) return (await forge.findPullRequest(branch))?.body.trim() || null;
   try {
     const { stdout } = await gh(
       `gh pr view ${shellQuote(branch)} --json body,state --jq 'select(.state=="OPEN") | .body'`,
@@ -750,9 +760,12 @@ export async function lexiconUpgrade(args: LexiconUpgradeArgs): Promise<LexiconU
 
   // Idempotency check: if the open PR already has this summary, nothing changed.
   // Compare trimmed — gh/git round-trips can alter trailing whitespace.
-  const existingPrBody = await currentPrBody(branch, gh);
+  // `gh pr` speaks GraphQL, which Forgejo does not serve: a Forgejo or
+  // GitLab job finds, opens and labels the pull request over REST (#3798).
+  const forge = args._forge !== undefined ? (args._forge ?? undefined) : await restPullRequestForge(process.env);
+  const existingPrBody = await currentPrBody(branch, gh, forge);
   if (existingPrBody !== null && existingPrBody.trim() === summary.trim()) {
-    const existingUrl = await openPrUrl(branch, gh);
+    const existingUrl = await openPrUrl(branch, gh, forge);
     return {
       lexicon,
       mode,
@@ -825,10 +838,23 @@ export async function lexiconUpgrade(args: LexiconUpgradeArgs): Promise<LexiconU
     });
 
     // Open or update the PR.
-    const existingUrl = await openPrUrl(branch, gh);
     let prUrl: string;
-
-    if (existingUrl) {
+    const open = forge ? await forge.findPullRequest(branch) : undefined;
+    const existingUrl = forge ? null : await openPrUrl(branch, gh);
+
+    if (forge) {
+      let pr = open;
+      if (pr) {
+        const edited = await forge.editPullRequest(pr.number, { title, body: summary });
+        prUrl = edited?.url ?? pr.url ?? "";
+      } else {
+        pr = await forge.openPullRequest({ head: branch, base: "main", title, body: summary });
+        prUrl = pr.url ?? "";
+      }
+      // Best-effort, as below. Forgejo adds only a label the repository
+      // already has; GitHub and GitLab make one.
+      if (semverLabel) await forge.addLabels(pr.number, [semverLabel]).catch(() => {/* best-effort */});
+    } else if (existingUrl) {
       await gh(`gh pr edit ${shellQuote(branch)} --title ${shellQuote(title)} --body ${shellQuote(summary)}`);
       prUrl = existingUrl;
     } else {
@@ -838,7 +864,7 @@ export async function lexiconUpgrade(args: LexiconUpgradeArgs): Promise<LexiconU
       prUrl = stdout.trim();
     }
 
-    if (semverLabel) {
+    if (semverLabel && !forge) {
       await ensureLabelOnPr(branch, semverLabel, gh);
     }
 

package/src/op/activities/propose-upgrade.ts

@@ -27,6 +27,8 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import type { StagedUpgrade } from "../../workspace/lineage-upgrade";
 import { ghHostEnv } from "./gh-host";
+import { restPullRequestForge, upsertPullRequest } from "./forge-pull-request";
+import type { PrForge } from "../../pr-forge";
 
 const execFileAsync = promisify(execFile);
 
@@ -52,6 +54,11 @@ export interface ProposeWorkspaceUpgradeArgs {
   cwd?: string;
   /** Replaces the git and gh child processes. For tests. */
   _run?: CommandRunner;
+  /**
+   * The REST client the pull request is opened through, or null for `gh`.
+   * Default: one on a Forgejo or GitLab job, `gh` elsewhere (#3798). For tests.
+   */
+  _forge?: PrForge | null;
   /** Replaces build and lint in the worktree. For tests. */
   _runChant?: import("../../workspace/lineage-upgrade").ChantRunner;
 }
@@ -198,6 +205,12 @@ export async function proposeWorkspaceUpgrade(args: ProposeWorkspaceUpgradeArgs)
     if (!hasRemote) throw new Error(`proposeWorkspaceUpgrade: no remote "${remote}" to open a pull request on`);
 
     const text = body(staged, lines);
+    // `gh pr` speaks GraphQL, which Forgejo does not serve (#3798).
+    const forge = args._forge !== undefined ? args._forge : await restPullRequestForge(process.env, { cwd: staged.repo, remote });
+    if (forge) {
+      result.prUrl = (await upsertPullRequest(forge, { head: branch, base: base!, title, body: text })).pr.url;
+      return result;
+    }
     const existing = (await run("gh", ["pr", "list", "--head", branch, "--state", "open", "--json", "url", "--jq", ".[0].url // empty"], staged.repo)).trim();
     if (existing) {
       await run("gh", ["pr", "edit", existing, "--title", title, "--body", text], staged.repo);

package/src/op/activities/reconcile.ts

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { ForgeApiError, forgejoForge, githubForge, type ForgeFetch, type GithubShapedForge } from "../../pr-forge";
 import { ghHostEnv } from "./gh-host";
+import { restPullRequestForge } from "./forge-pull-request";
 
 const execAsync = promisify(exec);
 
@@ -1363,8 +1364,15 @@ export async function reconcilePr(args: ReconcilePrArgs, signal?: AbortSignal):
   await execAsync(`git add ${shellQuote(output)}`, { signal });
   await execAsync(`git commit -m ${shellQuote(title)}`, { signal });
   await execAsync(`git push -u origin ${shellQuote(branch)}`, { signal });
-  // `gh pr create` names no host, so on GitHub Enterprise Server or Forgejo
-  // it is told the job's own (#3780). See `./gh-host.ts`.
+  // `gh pr` speaks GraphQL, which Forgejo does not serve, and GitLab has no
+  // `gh`: a Forgejo or GitLab job opens the pull request over REST (#3798).
+  const forge = await restPullRequestForge(process.env, { fetch: (url, init) => globalThis.fetch(url, { ...init, ...(signal ? { signal } : {}) }) });
+  if (forge) {
+    const pr = await forge.openPullRequest({ head: branch, title, body: summary });
+    return { mode, branch, summary, entries, prUrl: pr.url ?? "" };
+  }
+  // `gh pr create` names no host, so on GitHub Enterprise Server it is told
+  // the job's own (#3780). See `./gh-host.ts`.
   const { stdout } = await execAsync(
     `gh pr create --title ${shellQuote(title)} --body ${shellQuote(summary)} --head ${shellQuote(branch)}`,
     { signal, env: await ghHostEnv(process.env) },

package/src/pr-forge-bundle.test.ts

@@ -34,7 +34,7 @@ describe("the pr-forge bundle", () => {
       expect(inputs.filter((i) => pattern.test(i)), String(pattern)).toEqual([]);
     }
     expect(inputs.map((i) => i.replace(/^.*?packages\//, "packages/")).sort()).toEqual(["packages/core/src/pr-forge.ts"]);
-    // About 20 KB today.
+    // About 27 KB today.
     expect(result.outputFiles.reduce((n, f) => n + f.contents.byteLength, 0)).toBeLessThan(32 * 1024);
   });
 });

package/src/pr-forge.test.ts

@@ -14,9 +14,12 @@ import {
   forgeTargetFromEnv,
   forgejoForge,
   forgePrincipalOf,
+  FORGE_STATUS_STATES,
   githubForge,
   gitlabForge,
+  statusStateFor,
   type ForgeFetch,
+  type ForgeStatusState,
 } from "./pr-forge";
 import { forgePrincipal, parseForgeIdentity } from "./workspace/identity";
 
@@ -675,3 +678,212 @@ describe("addComment and findIssue (#3818)", () => {
     expect(fj.calls[0].headers.Authorization).toBeUndefined();
   });
 });
+
+describe("status states and author lists (#3834)", () => {
+  const gh = { apiBase: "https://api.github.com", repo: "acme/infra", token: "t0k" };
+
+  test("each state goes to each forge as its nearest state", () => {
+    const table = Object.fromEntries(FORGE_STATUS_STATES.map((s) => [s, [statusStateFor("github", s), statusStateFor("forgejo", s), statusStateFor("gitlab", s)]]));
+    expect(table).toEqual({
+      pending: ["pending", "pending", "pending"],
+      running: ["pending", "pending", "running"],
+      success: ["success", "success", "success"],
+      failed: ["failure", "failure", "failed"],
+      failure: ["failure", "failure", "failed"],
+      canceled: ["error", "error", "canceled"],
+      error: ["error", "error", "failed"],
+    });
+    expect(() => statusStateFor("gitlab", "skipped" as ForgeStatusState)).toThrow(/one of pending, running/);
+  });
+
+  test("a running status is running on GitLab and pending on GitHub and Forgejo", async () => {
+    const gl = fakeFetch({ [`POST /api/v4/projects/42/statuses/${SHA}`]: {} });
+    await gitlabForge({ apiBase: "https://gl/api/v4", project: "42", token: "t", fetch: gl.fetch }).setStatus(SHA, { context: "terragucci/plan", state: "running", description: "planning" });
+    await gitlabForge({ apiBase: "https://gl/api/v4", project: "42", token: "t", fetch: gl.fetch }).setStatus(SHA, { context: "terragucci/plan", state: "canceled", description: "stopped" });
+    expect(gl.calls.map((c) => (c.body as { state: string }).state)).toEqual(["running", "canceled"]);
+    const g = fakeFetch({ [`POST /repos/acme/infra/statuses/${SHA}`]: {} });
+    await githubForge({ ...gh, fetch: g.fetch }).setStatus(SHA, { context: "terragucci/plan", state: "running", description: "planning" });
+    await githubForge({ ...gh, fetch: g.fetch }).setStatus(SHA, { context: "terragucci/plan", state: "failed", description: "no" });
+    expect(g.calls.map((c) => (c.body as { state: string }).state)).toEqual(["pending", "failure"]);
+    const fj = fakeFetch({ [`POST /api/v1/repos/acme/infra/statuses/${SHA}`]: {} });
+    await forgejoForge({ ...gh, apiBase: "https://codeberg.org/api/v1", host: "codeberg.org", fetch: fj.fetch }).setStatus(SHA, { context: "c", state: "running", description: "d" });
+    expect(fj.calls[0].body).toMatchObject({ state: "pending" });
+  });
+
+  const BOTS = ["github-actions[bot]", "gitea-actions", "forgejo-actions"];
+
+  test("a comment by any of several logins is the caller's own, without case", async () => {
+    const { fetch, calls } = fakeFetch({
+      "GET /api/v1/repos/acme/infra/issues/4/comments": [
+        { id: 1, body: "<!-- tg -->\nplanted", user: { login: "mallory" } },
+        { id: 2, body: "<!-- tg -->\nold", user: { login: "Forgejo-Actions" } },
+      ],
+      "PATCH /api/v1/repos/acme/infra/issues/comments/2": { id: 2, html_url: "https://cb/2" },
+    });
+    const forge = forgejoForge({ ...gh, apiBase: "https://codeberg.org/api/v1", host: "codeberg.org", fetch });
+    expect(await forge.findComment(4, "<!-- tg -->", { author: BOTS })).toEqual({ id: 2, body: "<!-- tg -->\nold" });
+    expect(await forge.upsertComment(4, "<!-- tg -->", "<!-- tg -->\nnew", { author: BOTS })).toEqual({ action: "updated", id: 2, url: "https://cb/2" });
+    expect(calls.at(-1)?.url).toBe("https://codeberg.org/api/v1/repos/acme/infra/issues/comments/2");
+    expect(await forge.findComment(4, "<!-- tg -->", { author: [] })).toBeUndefined();
+    expect((await forge.findComment(4, "<!-- tg -->", { author: "mallory" }))?.id).toBe(1);
+  });
+
+  test("an issue by any of several logins, for findIssue and trackIssue", async () => {
+    const { fetch, calls } = fakeFetch({
+      "GET /repos/acme/infra/issues": [
+        { number: 3, title: "Drift", body: "<!-- d -->\nplanted", user: { login: "mallory" } },
+        { number: 4, title: "Drift", body: "<!-- d -->\nold", user: { login: "github-actions[bot]" } },
+      ],
+      "PATCH /repos/acme/infra/issues/4": { number: 4 },
+    });
+    const forge = githubForge({ ...gh, fetch });
+    expect((await forge.findIssue("<!-- d -->", { author: BOTS }))?.number).toBe(4);
+    expect(await forge.trackIssue("<!-- d -->", { title: "Drift", body: "<!-- d -->\nnew" }, { author: BOTS })).toMatchObject({ action: "updated", number: 4 });
+    expect(calls.at(-1)).toMatchObject({ method: "PATCH", url: "https://api.github.com/repos/acme/infra/issues/4" });
+  });
+});
+
+describe("pull requests over REST (#3798)", () => {
+  const gh = { apiBase: "https://api.github.com", repo: "acme/infra", token: "t0k" };
+  const fjOpts = { ...gh, apiBase: "https://forge.example/api/v1", host: "forge.example" };
+  const gl = { apiBase: "https://gl/api/v4", project: "group/infra", token: "t" };
+
+  test("Forgejo opens a pull request into the default branch read from the repository", async () => {
+    const { fetch, calls } = fakeFetch({
+      "GET /api/v1/repos/acme/infra": { default_branch: "trunk" },
+      "POST /api/v1/repos/acme/infra/pulls": (c: Call) => ({ number: 9, html_url: "https://forge.example/acme/infra/pulls/9", title: (c.body as { title: string }).title, body: "b", head: { ref: "chant/x" }, base: { ref: "trunk" } }),
+    });
+    const pr = await forgejoForge({ ...fjOpts, fetch }).openPullRequest({ head: "chant/x", title: "t", body: "b" });
+    expect(pr).toEqual({ number: 9, url: "https://forge.example/acme/infra/pulls/9", title: "t", body: "b", head: "chant/x", base: "trunk" });
+    expect(calls.map((c) => `${c.method} ${c.url}`)).toEqual(["GET https://forge.example/api/v1/repos/acme/infra", "POST https://forge.example/api/v1/repos/acme/infra/pulls"]);
+    expect(calls[1].body).toEqual({ title: "t", body: "b", head: "chant/x", base: "trunk" });
+    expect(calls[1].headers.Authorization).toBe("token t0k");
+  });
+
+  test("a draft is GitHub's draft field, Forgejo's WIP: and GitLab's Draft: prefix", async () => {
+    const g = fakeFetch({ "POST /repos/acme/infra/pulls": { number: 1 } });
+    await githubForge({ ...gh, fetch: g.fetch }).openPullRequest({ head: "h", base: "main", title: "t", body: "b", draft: true });
+    expect(g.calls[0].body).toEqual({ title: "t", body: "b", head: "h", base: "main", draft: true });
+    const f = fakeFetch({ "POST /api/v1/repos/acme/infra/pulls": { number: 1 } });
+    await forgejoForge({ ...fjOpts, fetch: f.fetch }).openPullRequest({ head: "h", base: "main", title: "t", body: "b", draft: true });
+    expect(f.calls[0].body).toEqual({ title: "WIP: t", body: "b", head: "h", base: "main" });
+    const l = fakeFetch({ "POST /api/v4/projects/group%2Finfra/merge_requests": { iid: 4, web_url: "https://gl/mr/4", source_branch: "h", target_branch: "main", title: "Draft: t", description: "b" } });
+    const mr = await gitlabForge({ ...gl, fetch: l.fetch }).openPullRequest({ head: "h", base: "main", title: "t", body: "b", draft: true });
+    expect(l.calls[0].body).toEqual({ source_branch: "h", target_branch: "main", title: "Draft: t", description: "b" });
+    expect(mr).toEqual({ number: 4, url: "https://gl/mr/4", title: "Draft: t", body: "b", head: "h", base: "main" });
+  });
+
+  test("GitLab reads the default branch off the project", async () => {
+    const { fetch, calls } = fakeFetch({
+      "GET /api/v4/projects/group%2Finfra": { default_branch: "main" },
+      "POST /api/v4/projects/group%2Finfra/merge_requests": { iid: 2 },
+    });
+    await gitlabForge({ ...gl, fetch }).openPullRequest({ head: "h", title: "t", body: "b" });
+    expect((calls[1].body as { target_branch: string }).target_branch).toBe("main");
+  });
+
+  test("findPullRequest takes the oldest open one from this repository, not a fork's", async () => {
+    const f = fakeFetch({
+      "GET /api/v1/repos/acme/infra/pulls": [
+        { number: 12, title: "fork", body: "", head: { ref: "chant/x", repo: { full_name: "mallory/infra" } } },
+        { number: 11, title: "newer", body: "", head: { ref: "chant/x", repo: { full_name: "acme/infra" } } },
+        { number: 10, title: "mine", body: "b", head: { ref: "chant/x", repo: { full_name: "acme/infra" } }, base: { ref: "main" }, html_url: "https://forge.example/acme/infra/pulls/10" },
+        { number: 3, title: "other", body: "", head: { ref: "other", repo: { full_name: "acme/infra" } } },
+      ],
+    });
+    const forge = forgejoForge({ ...fjOpts, fetch: f.fetch });
+    expect(await forge.findPullRequest("chant/x")).toEqual({ number: 10, title: "mine", body: "b", head: "chant/x", base: "main", url: "https://forge.example/acme/infra/pulls/10" });
+    expect(f.calls[0].url).toBe("https://forge.example/api/v1/repos/acme/infra/pulls?state=open&limit=50&page=1");
+    expect(await forge.findPullRequest("none")).toBeUndefined();
+
+    const g = fakeFetch({ "GET /repos/acme/infra/pulls": [] });
+    expect(await githubForge({ ...gh, fetch: g.fetch }).findPullRequest("chant/x")).toBeUndefined();
+    expect(g.calls[0].url).toBe("https://api.github.com/repos/acme/infra/pulls?state=open&head=acme%3Achant%2Fx&per_page=100&page=1");
+
+    const l = fakeFetch({
+      "GET /api/v4/projects/group%2Finfra/merge_requests": [
+        { iid: 8, source_branch: "chant/x", project_id: 1, source_project_id: 2, title: "fork", description: "" },
+        { iid: 7, source_branch: "chant/x", project_id: 1, source_project_id: 1, title: "mine", description: "d", target_branch: "main" },
+      ],
+    });
+    expect(await gitlabForge({ ...gl, fetch: l.fetch }).findPullRequest("chant/x")).toEqual({ number: 7, title: "mine", body: "d", head: "chant/x", base: "main" });
+    expect(l.calls[0].url).toBe("https://gl/api/v4/projects/group%2Finfra/merge_requests?state=opened&source_branch=chant%2Fx&per_page=100&page=1");
+  });
+
+  test("editPullRequest and addLabels on each forge", async () => {
+    const f = fakeFetch({ "PATCH /api/v1/repos/acme/infra/pulls/10": { number: 10, title: "t2" }, "POST /api/v1/repos/acme/infra/issues/10/labels": [] });
+    const forge = forgejoForge({ ...fjOpts, fetch: f.fetch });
+    expect((await forge.editPullRequest(10, { title: "t2", body: "b2" }))?.title).toBe("t2");
+    await forge.addLabels(10, ["minor"]);
+    await forge.addLabels(10, []);
+    expect(f.calls.map((c) => [c.method, c.body])).toEqual([["PATCH", { title: "t2", body: "b2" }], ["POST", { labels: ["minor"] }]]);
+    const l = fakeFetch({ "PUT /api/v4/projects/group%2Finfra/merge_requests/7": { iid: 7 } });
+    const g = gitlabForge({ ...gl, fetch: l.fetch });
+    await g.editPullRequest(7, { body: "d" });
+    await g.addLabels(7, ["minor", "breaking"]);
+    expect(l.calls.map((c) => c.body)).toEqual([{ description: "d" }, { add_labels: "minor,breaking" }]);
+  });
+
+  test("Forgejo's 404 on the pull list of a just-pushed empty repository is no pull request (#3845)", async () => {
+    const empty = fakeFetch({ "GET /api/v1/repos/acme/infra": { default_branch: "main" } });
+    expect(await forgejoForge({ ...fjOpts, fetch: empty.fetch }).findPullRequest("chant/x")).toBeUndefined();
+    // A repository that is really missing 404s on its own read, and that still throws.
+    const gone = fakeFetch({});
+    await expect(forgejoForge({ ...fjOpts, fetch: gone.fetch }).findPullRequest("chant/x")).rejects.toThrow(/404/);
+    // GitHub's list 404 stays an error.
+    await expect(githubForge({ ...gh, fetch: fakeFetch({}).fetch }).findPullRequest("chant/x")).rejects.toThrow(/404/);
+  });
+
+  const answering = (status: number, body: unknown, calls: Call[] = []): ForgeFetch => async (url, init) => {
+    calls.push({ method: init.method, url, headers: init.headers, ...(init.body ? { body: JSON.parse(init.body) } : {}) });
+    return { ok: status < 400, status, text: async () => (body === undefined ? "" : JSON.stringify(body)) };
+  };
+
+  test("mergePullRequest merges only at the reviewed sha on GitHub", async () => {
+    const f = fakeFetch({
+      "PUT /repos/acme/infra/pulls/5/merge": { merged: true, sha: "m1" },
+      "GET /repos/acme/infra/pulls/5": { number: 5, head: { ref: "chant/x", repo: { full_name: "acme/infra" } } },
+      "DELETE /repos/acme/infra/git/refs/heads/chant/x": null,
+    });
+    const r = await githubForge({ ...gh, fetch: f.fetch }).mergePullRequest(5, { sha: SHA, method: "squash", title: "t", message: "m", deleteBranch: true });
+    expect(r).toEqual({ merged: true, sha: "m1" });
+    expect(f.calls[0].body).toEqual({ sha: SHA, merge_method: "squash", commit_title: "t", commit_message: "m" });
+    expect(f.calls.map((c) => c.method)).toEqual(["PUT", "GET", "DELETE"]);
+    const calls: Call[] = [];
+    const moved = await githubForge({ ...gh, fetch: answering(409, { message: "Head branch was modified. Review and try the merge again." }, calls) }).mergePullRequest(5, { sha: SHA });
+    expect(moved).toEqual({ merged: false, reason: "Head branch was modified. Review and try the merge again." });
+    expect(calls[0].body).toEqual({ sha: SHA, merge_method: "merge" });
+    const blocked = await githubForge({ ...gh, fetch: answering(405, { message: "Required status check is expected." }) }).mergePullRequest(5, { sha: SHA });
+    expect(blocked.merged).toBe(false);
+    await expect(githubForge({ ...gh, fetch: answering(401, { message: "Bad credentials" }) }).mergePullRequest(5, { sha: SHA })).rejects.toThrow(/401/);
+  });
+
+  test("mergePullRequest on Forgejo sends head_commit_id and reads the merge commit back", async () => {
+    const f = fakeFetch({
+      "POST /api/v1/repos/acme/infra/pulls/5/merge": null,
+      "GET /api/v1/repos/acme/infra/pulls/5": { number: 5, merge_commit_sha: "m2" },
+    });
+    const r = await forgejoForge({ ...fjOpts, fetch: f.fetch }).mergePullRequest(5, { sha: SHA, method: "rebase", title: "t", message: "m", deleteBranch: true });
+    expect(r).toEqual({ merged: true, sha: "m2" });
+    expect(f.calls[0].body).toEqual({ Do: "rebase", head_commit_id: SHA, MergeTitleField: "t", MergeMessageField: "m", delete_branch_after_merge: true });
+    const moved = await forgejoForge({ ...fjOpts, fetch: answering(409, { message: "head commit id does not match" }) }).mergePullRequest(5, { sha: SHA });
+    expect(moved).toEqual({ merged: false, reason: "head commit id does not match" });
+    expect((await forgejoForge({ ...fjOpts, fetch: answering(405, undefined) }).mergePullRequest(5, { sha: SHA })).merged).toBe(false);
+  });
+
+  test("mergePullRequest on GitLab passes sha and squash, and refuses rebase", async () => {
+    const f = fakeFetch({ "PUT /api/v4/projects/group%2Finfra/merge_requests/7/merge": { state: "merged", merge_commit_sha: "m3" } });
+    const g = gitlabForge({ ...gl, fetch: f.fetch });
+    expect(await g.mergePullRequest(7, { sha: SHA, method: "squash", title: "t", message: "m", deleteBranch: true })).toEqual({ merged: true, sha: "m3" });
+    expect(f.calls[0].body).toEqual({ sha: SHA, squash: true, squash_commit_message: "t\n\nm", merge_commit_message: "t\n\nm", should_remove_source_branch: true });
+    const moved = await gitlabForge({ ...gl, fetch: answering(409, { message: "SHA does not match HEAD of source branch" }) }).mergePullRequest(7, { sha: SHA });
+    expect(moved).toEqual({ merged: false, reason: "SHA does not match HEAD of source branch" });
+    expect((await gitlabForge({ ...gl, fetch: answering(405, { message: "Branch cannot be merged" }) }).mergePullRequest(7, { sha: SHA })).merged).toBe(false);
+    await expect(g.mergePullRequest(7, { sha: SHA, method: "rebase" })).rejects.toThrow(/rebase/);
+  });
+
+  test("a repository with no default branch is refused by name", async () => {
+    const { fetch } = fakeFetch({ "GET /api/v1/repos/acme/infra": {} });
+    await expect(forgejoForge({ ...fjOpts, fetch }).openPullRequest({ head: "h", title: "t", body: "b" })).rejects.toThrow(/no default branch.*pass base/);
+  });
+});