Merge branch 'main' into add-draft-mode-support

src/__snapshots__/run.test.ts.snap

@@ -1,6 +1,6 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`version creates simple PR 1`] = `
+exports[`version > creates simple PR 1`] = `
 [
   {
     "base": "some-branch",
@@ -33,7 +33,7 @@ exports[`version creates simple PR 1`] = `
 ]
 `;
 
-exports[`version does not include any release information if a message with simplified release info exceeds size limit 1`] = `
+exports[`version > does not include any release information if a message with simplified release info exceeds size limit 1`] = `
 [
   {
     "base": "some-branch",
@@ -51,7 +51,7 @@ exports[`version does not include any release information if a message with simp
 ]
 `;
 
-exports[`version does not include changelog entries if full message exceeds size limit 1`] = `
+exports[`version > does not include changelog entries if full message exceeds size limit 1`] = `
 [
   {
     "base": "some-branch",
@@ -73,7 +73,7 @@ exports[`version does not include changelog entries if full message exceeds size
 ]
 `;
 
-exports[`version doesn't include ignored package that got a dependency update in the PR body 1`] = `
+exports[`version > doesn't include ignored package that got a dependency update in the PR body 1`] = `
 [
   {
     "base": "some-branch",
@@ -95,7 +95,7 @@ exports[`version doesn't include ignored package that got a dependency update in
 ]
 `;
 
-exports[`version only includes bumped packages in the PR body 1`] = `
+exports[`version > only includes bumped packages in the PR body 1`] = `
 [
   {
     "base": "some-branch",

src/__snapshots__/utils.test.ts.snap

@@ -1,4 +1,4 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`it sorts the things right 1`] = `
 [

src/git.ts

@@ -0,0 +1,129 @@
+import * as core from "@actions/core";
+import { exec, getExecOutput } from "@actions/exec";
+import * as github from "@actions/github";
+import { commitChangesFromRepo } from "@changesets/ghcommit/git";
+import type { Octokit } from "./octokit.ts";
+
+type GitOptions = {
+  cwd: string;
+};
+
+const push = async (branch: string, options: GitOptions) => {
+  await exec("git", ["push", "origin", `HEAD:${branch}`, "--force"], options);
+};
+
+const switchToMaybeExistingBranch = async (
+  branch: string,
+  options: GitOptions
+) => {
+  let { stderr } = await getExecOutput("git", ["checkout", branch], {
+    ignoreReturnCode: true,
+    ...options,
+  });
+  let isCreatingBranch = !stderr
+    .toString()
+    .includes(`Switched to a new branch '${branch}'`);
+  if (isCreatingBranch) {
+    await exec("git", ["checkout", "-b", branch], options);
+  }
+};
+
+const reset = async (pathSpec: string, options: GitOptions) => {
+  await exec("git", ["reset", `--hard`, pathSpec], options);
+};
+
+const commitAll = async (message: string, options: GitOptions) => {
+  await exec("git", ["add", "."], options);
+  await exec("git", ["commit", "-m", message], options);
+};
+
+const checkIfClean = async (options: GitOptions): Promise<boolean> => {
+  const { stdout } = await getExecOutput(
+    "git",
+    ["status", "--porcelain"],
+    options
+  );
+  return !stdout.length;
+};
+
+export class Git {
+  readonly octokit: Octokit | null;
+  readonly cwd: string;
+
+  constructor(args: { octokit?: Octokit; cwd: string }) {
+    this.octokit = args.octokit ?? null;
+    this.cwd = args.cwd;
+  }
+
+  async setupUser() {
+    if (this.octokit) {
+      return;
+    }
+    await exec("git", ["config", "user.name", `"github-actions[bot]"`], {
+      cwd: this.cwd,
+    });
+    await exec(
+      "git",
+      [
+        "config",
+        "user.email",
+        `"41898282+github-actions[bot]@users.noreply.github.com"`,
+      ],
+      {
+        cwd: this.cwd,
+      }
+    );
+  }
+
+  async pushTag(tag: string) {
+    if (this.octokit) {
+      return this.octokit.rest.git
+        .createRef({
+          ...github.context.repo,
+          ref: `refs/tags/${tag}`,
+          sha: github.context.sha,
+        })
+        .catch((err) => {
+          // Assuming tag was manually pushed in custom publish script
+          core.warning(`Failed to create tag ${tag}: ${err.message}`);
+        });
+    }
+    await exec("git", ["push", "origin", tag], { cwd: this.cwd });
+  }
+
+  async prepareBranch(branch: string) {
+    if (this.octokit) {
+      // Preparing a new local branch is not necessary when using the API
+      return;
+    }
+    await switchToMaybeExistingBranch(branch, { cwd: this.cwd });
+    await reset(github.context.sha, { cwd: this.cwd });
+  }
+
+  async pushChanges({ branch, message }: { branch: string; message: string }) {
+    if (this.octokit) {
+      /**
+       * Only add files form the current working directory
+       *
+       * This will emulate the behavior of `git add .`,
+       * used in {@link commitAll}.
+       */
+      const addFromDirectory = this.cwd;
+      return commitChangesFromRepo({
+        octokit: this.octokit,
+        ...github.context.repo,
+        branch,
+        message,
+        base: {
+          commit: github.context.sha,
+        },
+        cwd: this.cwd,
+        force: true,
+      });
+    }
+    if (!(await checkIfClean({ cwd: this.cwd }))) {
+      await commitAll(message, { cwd: this.cwd });
+    }
+    await push(branch, { cwd: this.cwd });
+  }
+}

src/gitUtils.ts

@@ -1,63 +0,0 @@
-import { exec, getExecOutput } from "@actions/exec";
-
-export const setupUser = async () => {
-  await exec("git", [
-    "config",
-    "user.name",
-    `"github-actions[bot]"`,
-  ]);
-  await exec("git", [
-    "config",
-    "user.email",
-    `"github-actions[bot]@users.noreply.github.com"`,
-  ]);
-};
-
-export const pullBranch = async (branch: string) => {
-  await exec("git", ["pull", "origin", branch]);
-};
-
-export const push = async (
-  branch: string,
-  { force }: { force?: boolean } = {}
-) => {
-  await exec(
-    "git",
-    ["push", "origin", `HEAD:${branch}`, force && "--force"].filter<string>(
-      Boolean as any
-    )
-  );
-};
-
-export const pushTags = async () => {
-  await exec("git", ["push", "origin", "--tags"]);
-};
-
-export const switchToMaybeExistingBranch = async (branch: string) => {
-  let { stderr } = await getExecOutput("git", ["checkout", branch], {
-    ignoreReturnCode: true,
-  });
-  let isCreatingBranch = !stderr
-    .toString()
-    .includes(`Switched to a new branch '${branch}'`);
-  if (isCreatingBranch) {
-    await exec("git", ["checkout", "-b", branch]);
-  }
-};
-
-export const reset = async (
-  pathSpec: string,
-  mode: "hard" | "soft" | "mixed" = "hard"
-) => {
-  await exec("git", ["reset", `--${mode}`, pathSpec]);
-};
-
-export const commitAll = async (message: string) => {
-  await exec("git", ["add", "."]);
-  await exec("git", ["commit", "-m", message]);
-};
-
-export const checkIfClean = async (): Promise<boolean> => {
-  const { stdout } = await getExecOutput("git", ["status", "--porcelain"]);
-  return !stdout.length;
-};

src/index.ts

@@ -1,30 +1,42 @@
 import * as core from "@actions/core";
-import fs from "fs-extra";
-import * as gitUtils from "./gitUtils";
-import { runPublish, runVersion } from "./run";
-import readChangesetState from "./readChangesetState";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Git } from "./git.ts";
+import { setupOctokit } from "./octokit.ts";
+import readChangesetState from "./readChangesetState.ts";
+import { runPublish, runVersion } from "./run.ts";
+import { fileExists } from "./utils.ts";
 
 const getOptionalInput = (name: string) => core.getInput(name) || undefined;
 
 (async () => {
-  let githubToken = process.env.GITHUB_TOKEN;
+  // to maintain compatibility with workflows created before github-token input was introduced
+  // it's important to prefer the explicitly set GITHUB_TOKEN over the default token coming from github.token
+  let githubToken = process.env.GITHUB_TOKEN || core.getInput("github-token");
 
   if (!githubToken) {
     core.setFailed("Please add the GITHUB_TOKEN to the changesets action");
     return;
   }
 
-  const inputCwd = core.getInput("cwd");
-  if (inputCwd) {
-    core.info("changing directory to the one given as the input");
-    process.chdir(inputCwd);
+  const cwd = path.resolve(getOptionalInput("cwd") ?? "");
+
+  const octokit = setupOctokit(githubToken);
+  const commitMode = getOptionalInput("commitMode") ?? "git-cli";
+  if (commitMode !== "git-cli" && commitMode !== "github-api") {
+    core.setFailed(`Invalid commit mode: ${commitMode}`);
+    return;
   }
+  const git = new Git({
+    octokit: commitMode === "github-api" ? octokit : undefined,
+    cwd,
+  });
 
   let setupGitUser = core.getBooleanInput("setupGitUser");
 
   if (setupGitUser) {
     core.info("setting git user");
-    await gitUtils.setupUser();
+    await git.setupUser();
   }
 
   core.info("setting GitHub credentials");
@@ -48,46 +60,67 @@ const getOptionalInput = (name: string) => core.getInput(name) || undefined;
 
   switch (true) {
     case !hasChangesets && !hasPublishScript:
-      core.info("No changesets found");
+      core.info(
+        "No changesets present or were removed by merging release PR. Not publishing because no publish script found."
+      );
       return;
     case !hasChangesets && hasPublishScript: {
       core.info(
-        "No changesets found, attempting to publish any unpublished packages to npm"
+        "No changesets found. Attempting to publish any unpublished packages to npm"
       );
 
-      let userNpmrcPath = `${process.env.HOME}/.npmrc`;
-      if (fs.existsSync(userNpmrcPath)) {
-        core.info("Found existing user .npmrc file");
-        const userNpmrcContent = await fs.readFile(userNpmrcPath, "utf8");
-        const authLine = userNpmrcContent.split("\n").find((line) => {
-          // check based on https://github.com/npm/cli/blob/8f8f71e4dd5ee66b3b17888faad5a7bf6c657eed/test/lib/adduser.js#L103-L105
-          return /^\s*\/\/registry\.npmjs\.org\/:[_-]authToken=/i.test(line);
-        });
-        if (authLine) {
-          core.info(
-            "Found existing auth token for the npm registry in the user .npmrc file"
-          );
+      if (process.env.NPM_TOKEN) {
+        const userNpmrcPath = `${process.env.HOME}/.npmrc`;
+
+        if (await fileExists(userNpmrcPath)) {
+          core.info("Found existing user .npmrc file");
+          const userNpmrcContent = await fs.readFile(userNpmrcPath, "utf8");
+          const authLine = userNpmrcContent.split("\n").find((line) => {
+            // check based on https://github.com/npm/cli/blob/8f8f71e4dd5ee66b3b17888faad5a7bf6c657eed/test/lib/adduser.js#L103-L105
+            return /^\s*\/\/registry\.npmjs\.org\/:[_-]authToken=/i.test(line);
+          });
+          if (authLine) {
+            core.info(
+              "Found existing auth token for the npm registry in the user .npmrc file"
+            );
+          } else {
+            core.info(
+              "Didn't find existing auth token for the npm registry in the user .npmrc file, creating one"
+            );
+            await fs.appendFile(
+              userNpmrcPath,
+              `\n//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}\n`
+            );
+          }
         } else {
           core.info(
-            "Didn't find existing auth token for the npm registry in the user .npmrc file, creating one"
+            "No user .npmrc file found, creating one with NPM_TOKEN used as auth token"
           );
-          fs.appendFileSync(
+          await fs.writeFile(
             userNpmrcPath,
-            `\n//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}\n`
+            `//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}\n`
           );
         }
+      } else if (
+        process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN &&
+        process.env.ACTIONS_ID_TOKEN_REQUEST_URL
+      ) {
+        core.info(
+          "No NPM_TOKEN found, but OIDC is available - using npm trusted publishing"
+        );
       } else {
-        core.info("No user .npmrc file found, creating one");
-        fs.writeFileSync(
-          userNpmrcPath,
-          `//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}\n`
+        core.info(
+          "No NPM_TOKEN or OIDC available - assuming npm is already authenticated"
         );
       }
 
       const result = await runPublish({
         script: publishScript,
         githubToken,
+        git,
+        octokit,
         createGithubReleases: core.getBooleanInput("createGithubReleases"),
+        cwd,
       });
 
       if (result.published) {
@@ -102,10 +135,13 @@ const getOptionalInput = (name: string) => core.getInput(name) || undefined;
     case hasChangesets && !hasNonEmptyChangesets:
       core.info("All changesets are empty; not creating PR");
       return;
-    case hasChangesets:
+    case hasChangesets: {
+      const octokit = setupOctokit(githubToken);
       const { pullRequestNumber } = await runVersion({
         script: getOptionalInput("version"),
         githubToken,
+        git,
+        octokit,
         prTitle: getOptionalInput("title"),
         commitMessage: getOptionalInput("commit"),
         hasPublishScript,
@@ -116,6 +152,7 @@ const getOptionalInput = (name: string) => core.getInput(name) || undefined;
       core.setOutput("pullRequestNumber", String(pullRequestNumber));
 
       return;
+    }
   }
 })().catch((err) => {
   core.error(err);

src/octokit.ts

@@ -0,0 +1,41 @@
+import * as core from "@actions/core";
+import { getOctokit } from "@actions/github";
+import { throttling } from "@octokit/plugin-throttling";
+
+export const setupOctokit = (githubToken: string) => {
+  return getOctokit(
+    githubToken,
+    {
+      throttle: {
+        onRateLimit: (retryAfter, options: any, octokit, retryCount) => {
+          core.warning(
+            `Request quota exhausted for request ${options.method} ${options.url}`
+          );
+
+          if (retryCount <= 2) {
+            core.info(`Retrying after ${retryAfter} seconds!`);
+            return true;
+          }
+        },
+        onSecondaryRateLimit: (
+          retryAfter,
+          options: any,
+          octokit,
+          retryCount
+        ) => {
+          core.warning(
+            `SecondaryRateLimit detected for request ${options.method} ${options.url}`
+          );
+
+          if (retryCount <= 2) {
+            core.info(`Retrying after ${retryAfter} seconds!`);
+            return true;
+          }
+        },
+      },
+    },
+    throttling
+  );
+};
+
+export type Octokit = ReturnType<typeof setupOctokit>;

src/readChangesetState.ts

@@ -1,4 +1,4 @@
-import { PreState, NewChangeset } from "@changesets/types";
+import type { PreState, NewChangeset } from "@changesets/types";
 import { readPreState } from "@changesets/pre";
 import readChangesets from "@changesets/read";
 

src/run.test.ts

@@ -1,13 +1,14 @@
-import fixturez from "fixturez";
-import * as github from "@actions/github";
-import * as githubUtils from "@actions/github/lib/utils";
-import fs from "fs-extra";
-import path from "path";
+import type { Changeset } from "@changesets/types";
 import writeChangeset from "@changesets/write";
-import { Changeset } from "@changesets/types";
-import { runVersion } from "./run";
+import fixturez from "fixturez";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Git } from "./git.ts";
+import { setupOctokit } from "./octokit.ts";
+import { runVersion } from "./run.ts";
 
-jest.mock("@actions/github", () => ({
+vi.mock("@actions/github", () => ({
   context: {
     repo: {
       owner: "changesets",
@@ -16,39 +17,28 @@ jest.mock("@actions/github", () => ({
     ref: "refs/heads/some-branch",
     sha: "xeac7",
   },
+  getOctokit: () => ({
+    rest: mockedGithubMethods,
+  }),
 }));
-jest.mock("@actions/github/lib/utils", () => ({
-    GitHub: {
-        plugin: () => {
-            // function necessary to be used as constructor
-            return function() {
-                return {
-                    rest: mockedGithubMethods,
-                }
-            }
-        },
-    },
-    getOctokitOptions: jest.fn(),
-}));
-jest.mock("./gitUtils");
+vi.mock("./git.ts");
+vi.mock("@changesets/ghcommit/git");
 
 let mockedGithubMethods = {
-  search: {
-    issuesAndPullRequests: jest.fn(),
-  },
   pulls: {
-    create: jest.fn(),
+    create: vi.fn(),
+    list: vi.fn(),
   },
   repos: {
-    createRelease: jest.fn(),
+    createRelease: vi.fn(),
   },
 };
 
-let f = fixturez(__dirname);
+let f = fixturez(import.meta.dirname);
 
 const linkNodeModules = async (cwd: string) => {
   await fs.symlink(
-    path.join(__dirname, "..", "node_modules"),
+    path.join(import.meta.dirname, "..", "node_modules"),
     path.join(cwd, "node_modules")
   );
 };
@@ -57,17 +47,15 @@ const writeChangesets = (changesets: Changeset[], cwd: string) => {
 };
 
 beforeEach(() => {
-  jest.clearAllMocks();
+  vi.clearAllMocks();
 });
 
 describe("version", () => {
   it("creates simple PR", async () => {
     let cwd = f.copy("simple-project");
-    linkNodeModules(cwd);
+    await linkNodeModules(cwd);
 
-    mockedGithubMethods.search.issuesAndPullRequests.mockImplementationOnce(
-      () => ({ data: { items: [] } })
-    );
+    mockedGithubMethods.pulls.list.mockImplementationOnce(() => ({ data: [] }));
 
     mockedGithubMethods.pulls.create.mockImplementationOnce(() => ({
       data: { number: 123 },
@@ -93,7 +81,9 @@ describe("version", () => {
     );
 
     await runVersion({
+      octokit: setupOctokit("@@GITHUB_TOKEN"),
       githubToken: "@@GITHUB_TOKEN",
+      git: new Git({ cwd }),
       cwd,
     });
 
@@ -102,11 +92,9 @@ describe("version", () => {
 
   it("only includes bumped packages in the PR body", async () => {
     let cwd = f.copy("simple-project");
-    linkNodeModules(cwd);
+    await linkNodeModules(cwd);
 
-    mockedGithubMethods.search.issuesAndPullRequests.mockImplementationOnce(
-      () => ({ data: { items: [] } })
-    );
+    mockedGithubMethods.pulls.list.mockImplementationOnce(() => ({ data: [] }));
 
     mockedGithubMethods.pulls.create.mockImplementationOnce(() => ({
       data: { number: 123 },
@@ -128,7 +116,9 @@ describe("version", () => {
     );
 
     await runVersion({
+      octokit: setupOctokit("@@GITHUB_TOKEN"),
       githubToken: "@@GITHUB_TOKEN",
+      git: new Git({ cwd }),
       cwd,
     });
 
@@ -137,11 +127,9 @@ describe("version", () => {
 
   it("doesn't include ignored package that got a dependency update in the PR body", async () => {
     let cwd = f.copy("ignored-package");
-    linkNodeModules(cwd);
+    await linkNodeModules(cwd);
 
-    mockedGithubMethods.search.issuesAndPullRequests.mockImplementationOnce(
-      () => ({ data: { items: [] } })
-    );
+    mockedGithubMethods.pulls.list.mockImplementationOnce(() => ({ data: [] }));
 
     mockedGithubMethods.pulls.create.mockImplementationOnce(() => ({
       data: { number: 123 },
@@ -163,7 +151,9 @@ describe("version", () => {
     );
 
     await runVersion({
+      octokit: setupOctokit("@@GITHUB_TOKEN"),
       githubToken: "@@GITHUB_TOKEN",
+      git: new Git({ cwd }),
       cwd,
     });
 
@@ -172,11 +162,9 @@ describe("version", () => {
 
   it("does not include changelog entries if full message exceeds size limit", async () => {
     let cwd = f.copy("simple-project");
-    linkNodeModules(cwd);
+    await linkNodeModules(cwd);
 
-    mockedGithubMethods.search.issuesAndPullRequests.mockImplementationOnce(
-      () => ({ data: { items: [] } })
-    );
+    mockedGithubMethods.pulls.list.mockImplementationOnce(() => ({ data: [] }));
 
     mockedGithubMethods.pulls.create.mockImplementationOnce(() => ({
       data: { number: 123 },
@@ -218,7 +206,9 @@ fluminis divesque vulnere aquis parce lapsis rabie si visa fulmineis.
     );
 
     await runVersion({
+      octokit: setupOctokit("@@GITHUB_TOKEN"),
       githubToken: "@@GITHUB_TOKEN",
+      git: new Git({ cwd }),
       cwd,
       prBodyMaxCharacters: 1000,
     });
@@ -231,11 +221,9 @@ fluminis divesque vulnere aquis parce lapsis rabie si visa fulmineis.
 
   it("does not include any release information if a message with simplified release info exceeds size limit", async () => {
     let cwd = f.copy("simple-project");
-    linkNodeModules(cwd);
+    await linkNodeModules(cwd);
 
-    mockedGithubMethods.search.issuesAndPullRequests.mockImplementationOnce(
-      () => ({ data: { items: [] } })
-    );
+    mockedGithubMethods.pulls.list.mockImplementationOnce(() => ({ data: [] }));
 
     mockedGithubMethods.pulls.create.mockImplementationOnce(() => ({
       data: { number: 123 },
@@ -277,7 +265,9 @@ fluminis divesque vulnere aquis parce lapsis rabie si visa fulmineis.
     );
 
     await runVersion({
+      octokit: setupOctokit("@@GITHUB_TOKEN"),
       githubToken: "@@GITHUB_TOKEN",
+      git: new Git({ cwd }),
       cwd,
       prBodyMaxCharacters: 500,
     });

src/run.ts

@@ -1,22 +1,24 @@
-import { exec, getExecOutput } from "@actions/exec";
-import { GitHub, getOctokitOptions } from "@actions/github/lib/utils";
-import * as github from "@actions/github";
 import * as core from "@actions/core";
-import fs from "fs-extra";
-import { getPackages, Package } from "@manypkg/get-packages";
-import path from "path";
-import * as semver from "semver";
-import { PreState } from "@changesets/types";
+import { exec, getExecOutput } from "@actions/exec";
+import * as github from "@actions/github";
+import type { PreState } from "@changesets/types";
+import { type Package, getPackages } from "@manypkg/get-packages";
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import semverLt from "semver/functions/lt.js";
+import { Git } from "./git.ts";
+import type { Octokit } from "./octokit.ts";
+import readChangesetState from "./readChangesetState.ts";
 import {
-  getChangelogEntry,
   getChangedPackages,
-  sortTheThings,
+  getChangelogEntry,
   getVersionsByDirectory,
-} from "./utils";
-import * as gitUtils from "./gitUtils";
-import readChangesetState from "./readChangesetState";
-import resolveFrom from "resolve-from";
-import { throttling } from "@octokit/plugin-throttling";
+  isErrorWithCode,
+  sortTheThings,
+} from "./utils.ts";
+
+const require = createRequire(import.meta.url);
 
 // GitHub Issues/PRs messages have a max size limit on the
 // message body payload.
@@ -24,83 +26,45 @@ import { throttling } from "@octokit/plugin-throttling";
 // To avoid that, we ensure to cap the message to 60k chars.
 const MAX_CHARACTERS_PER_MESSAGE = 60000;
 
-const setupOctokit = (githubToken: string) => {
-  return new (GitHub.plugin(throttling))(
-    getOctokitOptions(githubToken, {
-      throttle: {
-        onRateLimit: (retryAfter, options: any, octokit, retryCount) => {
-          core.warning(
-            `Request quota exhausted for request ${options.method} ${options.url}`
-          );
-
-          if (retryCount <= 2) {
-            core.info(`Retrying after ${retryAfter} seconds!`);
-            return true;
-          }
-        },
-        onSecondaryRateLimit: (
-          retryAfter,
-          options: any,
-          octokit,
-          retryCount
-        ) => {
-          core.warning(
-            `SecondaryRateLimit detected for request ${options.method} ${options.url}`
-          );
-
-          if (retryCount <= 2) {
-            core.info(`Retrying after ${retryAfter} seconds!`);
-            return true;
-          }
-        },
-      },
-    })
-  );
-};
-
 const createRelease = async (
-  octokit: ReturnType<typeof setupOctokit>,
-  { pkg, tagName }: { pkg: Package; tagName: string }
+  octokit: Octokit,
+  { pkg, tagName }: { pkg: Package; tagName: string },
 ) => {
+  let changelog;
   try {
-    let changelogFileName = path.join(pkg.dir, "CHANGELOG.md");
-
-    let changelog = await fs.readFile(changelogFileName, "utf8");
-
-    let changelogEntry = getChangelogEntry(changelog, pkg.packageJson.version);
-    if (!changelogEntry) {
-      // we can find a changelog but not the entry for this version
-      // if this is true, something has probably gone wrong
-      throw new Error(
-        `Could not find changelog entry for ${pkg.packageJson.name}@${pkg.packageJson.version}`
-      );
-    }
-
-    await octokit.rest.repos.createRelease({
-      name: tagName,
-      tag_name: tagName,
-      body: changelogEntry.content,
-      prerelease: pkg.packageJson.version.includes("-"),
-      ...github.context.repo,
-    });
+    changelog = await fs.readFile(path.join(pkg.dir, "CHANGELOG.md"), "utf8");
   } catch (err) {
-    // if we can't find a changelog, the user has probably disabled changelogs
-    if (
-      err &&
-      typeof err === "object" &&
-      "code" in err &&
-      err.code !== "ENOENT"
-    ) {
-      throw err;
+    if (isErrorWithCode(err, "ENOENT")) {
+      // if we can't find a changelog, the user has probably disabled changelogs
+      return;
     }
+    throw err;
   }
+  let changelogEntry = getChangelogEntry(changelog, pkg.packageJson.version);
+  if (!changelogEntry) {
+    // we can find a changelog but not the entry for this version
+    // if this is true, something has probably gone wrong
+    throw new Error(
+      `Could not find changelog entry for ${pkg.packageJson.name}@${pkg.packageJson.version}`,
+    );
+  }
+
+  await octokit.rest.repos.createRelease({
+    name: tagName,
+    tag_name: tagName,
+    body: changelogEntry.content,
+    prerelease: pkg.packageJson.version.includes("-"),
+    ...github.context.repo,
+  });
 };
 
 type PublishOptions = {
   script: string;
   githubToken: string;
+  octokit: Octokit;
   createGithubReleases: boolean;
-  cwd?: string;
+  git: Git;
+  cwd: string;
 };
 
 type PublishedPackage = { name: string; version: string };
@@ -117,21 +81,19 @@ type PublishResult =
 export async function runPublish({
   script,
   githubToken,
+  git,
+  octokit,
   createGithubReleases,
-  cwd = process.cwd(),
+  cwd,
 }: PublishOptions): Promise<PublishResult> {
-  const octokit = setupOctokit(githubToken);
-
   let [publishCommand, ...publishArgs] = script.split(/\s+/);
 
   let changesetPublishOutput = await getExecOutput(
     publishCommand,
     publishArgs,
-    { cwd }
+    { cwd, env: { ...process.env, GITHUB_TOKEN: githubToken } },
   );
 
-  await gitUtils.pushTags();
-
   let { packages, tool } = await getPackages(cwd);
   let releasedPackages: Package[] = [];
 
@@ -149,7 +111,7 @@ export async function runPublish({
       if (pkg === undefined) {
         throw new Error(
           `Package "${pkgName}" not found.` +
-            "This is probably a bug in the action, please open an issue"
+            "This is probably a bug in the action, please open an issue",
         );
       }
       releasedPackages.push(pkg);
@@ -157,19 +119,18 @@ export async function runPublish({
 
     if (createGithubReleases) {
       await Promise.all(
-        releasedPackages.map((pkg) =>
-          createRelease(octokit, {
-            pkg,
-            tagName: `${pkg.packageJson.name}@${pkg.packageJson.version}`,
-          })
-        )
+        releasedPackages.map(async (pkg) => {
+          const tagName = `${pkg.packageJson.name}@${pkg.packageJson.version}`;
+          await git.pushTag(tagName);
+          await createRelease(octokit, { pkg, tagName });
+        }),
       );
     }
   } else {
     if (packages.length === 0) {
       throw new Error(
         `No package found.` +
-          "This is probably a bug in the action, please open an issue"
+          "This is probably a bug in the action, please open an issue",
       );
     }
     let pkg = packages[0];
@@ -181,10 +142,9 @@ export async function runPublish({
       if (match) {
         releasedPackages.push(pkg);
         if (createGithubReleases) {
-          await createRelease(octokit, {
-            pkg,
-            tagName: `v${pkg.packageJson.version}`,
-          });
+          const tagName = `v${pkg.packageJson.version}`;
+          await git.pushTag(tagName);
+          await createRelease(octokit, { pkg, tagName });
         }
         break;
       }
@@ -206,16 +166,16 @@ export async function runPublish({
 
 const requireChangesetsCliPkgJson = (cwd: string) => {
   try {
-    return require(resolveFrom(cwd, "@changesets/cli/package.json"));
+    return require(
+      require.resolve("@changesets/cli/package.json", {
+        paths: [cwd],
+      }),
+    );
   } catch (err) {
-    if (
-      err &&
-      typeof err === "object" &&
-      "code" in err &&
-      err.code === "MODULE_NOT_FOUND"
-    ) {
+    if (isErrorWithCode(err, "MODULE_NOT_FOUND")) {
       throw new Error(
-        `Have you forgotten to install \`@changesets/cli\` in "${cwd}"?`
+        `Have you forgotten to install \`@changesets/cli\` in "${cwd}"?`,
+        { cause: err },
       );
     }
     throw err;
@@ -294,6 +254,8 @@ export async function getVersionPrBody({
 type VersionOptions = {
   script?: string;
   githubToken: string;
+  git: Git;
+  octokit: Octokit;
   cwd?: string;
   prTitle?: string;
   commitMessage?: string;
@@ -310,50 +272,55 @@ type RunVersionResult = {
 export async function runVersion({
   script,
   githubToken,
+  git,
+  octokit,
   cwd = process.cwd(),
   prTitle = "Version Packages",
   commitMessage = "Version Packages",
   hasPublishScript = false,
   prBodyMaxCharacters = MAX_CHARACTERS_PER_MESSAGE,
-  createPrAsDraft = false,
   branch,
+  createPrAsDraft = false,
 }: VersionOptions): Promise<RunVersionResult> {
-  const octokit = setupOctokit(githubToken);
-
-  let repo = `${github.context.repo.owner}/${github.context.repo.repo}`;
-  branch = branch ?? github.context.ref.replace("refs/heads/", "");
   let versionBranch = `changeset-release/${branch}`;
 
   let { preState } = await readChangesetState(cwd);
 
-  await gitUtils.switchToMaybeExistingBranch(versionBranch);
-  await gitUtils.reset(github.context.sha);
+  await git.prepareBranch(versionBranch);
 
   let versionsByDirectory = await getVersionsByDirectory(cwd);
 
+  const env = { ...process.env, GITHUB_TOKEN: githubToken };
+
   if (script) {
     let [versionCommand, ...versionArgs] = script.split(/\s+/);
-    await exec(versionCommand, versionArgs, { cwd });
+    await exec(versionCommand, versionArgs, { cwd, env });
   } else {
     let changesetsCliPkgJson = requireChangesetsCliPkgJson(cwd);
-    let cmd = semver.lt(changesetsCliPkgJson.version, "2.0.0")
+    let cmd = semverLt(changesetsCliPkgJson.version, "2.0.0")
       ? "bump"
       : "version";
-    await exec("node", [resolveFrom(cwd, "@changesets/cli/bin.js"), cmd], {
-      cwd,
-    });
+    await exec(
+      "node",
+      [
+        require.resolve("@changesets/cli/bin.js", {
+          paths: [cwd],
+        }),
+        cmd,
+      ],
+      {
+        cwd,
+        env,
+      },
+    );
   }
 
-  let searchQuery = `repo:${repo}+state:open+head:${versionBranch}+base:${branch}+is:pull-request`;
-  let searchResultPromise = octokit.rest.search.issuesAndPullRequests({
-    q: searchQuery,
-  });
   let changedPackages = await getChangedPackages(cwd, versionsByDirectory);
   let changedPackagesInfoPromises = Promise.all(
     changedPackages.map(async (pkg) => {
       let changelogContents = await fs.readFile(
         path.join(pkg.dir, "CHANGELOG.md"),
-        "utf8"
+        "utf8",
       );
 
       let entry = getChangelogEntry(changelogContents, pkg.packageJson.version);
@@ -363,23 +330,36 @@ export async function runVersion({
         content: entry.content,
         header: `## ${pkg.packageJson.name}@${pkg.packageJson.version}`,
       };
-    })
+    }),
   );
 
   const finalPrTitle = `${prTitle}${!!preState ? ` (${preState.tag})` : ""}`;
+  const finalCommitMessage = `${commitMessage}${
+    !!preState ? ` (${preState.tag})` : ""
+  }`;
 
-  // project with `commit: true` setting could have already committed files
-  if (!(await gitUtils.checkIfClean())) {
-    const finalCommitMessage = `${commitMessage}${
-      !!preState ? ` (${preState.tag})` : ""
-    }`;
-    await gitUtils.commitAll(finalCommitMessage);
-  }
+  /**
+   * Fetch any existing pull requests that are open against the branch,
+   * before we push any changes that may inadvertently close the existing PRs.
+   *
+   * (`@changesets/ghcommit` has to reset the branch to the same commit as the base,
+   * which GitHub will then react to by closing the PRs)
+   */
+  const existingPullRequests = await octokit.rest.pulls.list({
+    ...github.context.repo,
+    state: "open",
+    head: `${github.context.repo.owner}:${versionBranch}`,
+    base: branch,
+  });
+  core.info(
+    `Existing pull requests: ${JSON.stringify(
+      existingPullRequests.data,
+      null,
+      2,
+    )}`,
+  );
 
-  await gitUtils.push(versionBranch, { force: true });
-
-  let searchResult = await searchResultPromise;
-  core.info(JSON.stringify(searchResult.data, null, 2));
+  await git.pushChanges({ branch: versionBranch, message: finalCommitMessage });
 
   const changedPackagesInfo = (await changedPackagesInfoPromises)
     .filter((x) => x)
@@ -393,7 +373,7 @@ export async function runVersion({
     prBodyMaxCharacters,
   });
 
-  if (searchResult.data.items.length === 0) {
+  if (existingPullRequests.data.length === 0) {
     core.info("creating pull request");
     const { data: newPullRequest } = await octokit.rest.pulls.create({
       base: branch,
@@ -408,7 +388,7 @@ export async function runVersion({
       pullRequestNumber: newPullRequest.number,
     };
   } else {
-    const [pullRequest] = searchResult.data.items;
+    const [pullRequest] = existingPullRequests.data;
 
     core.info(`updating found pull request #${pullRequest.number}`);
     await octokit.rest.pulls.update({
@@ -416,6 +396,7 @@ export async function runVersion({
       title: finalPrTitle,
       body: prBody,
       ...github.context.repo,
+      state: "open",
     });
 
     return {

src/utils.test.ts

@@ -1,4 +1,5 @@
-import { getChangelogEntry, BumpLevels, sortTheThings } from "./utils";
+import { expect, test } from "vitest";
+import { BumpLevels, getChangelogEntry, sortTheThings } from "./utils.ts";
 
 let changelog = `# @keystone-alpha/email
 

src/utils.ts

@@ -1,9 +1,11 @@
 import unified from "unified";
 import remarkParse from "remark-parse";
 import remarkStringify from "remark-stringify";
+import fs from "node:fs/promises";
+import type { Root } from "mdast";
 // @ts-ignore
 import mdastToString from "mdast-util-to-string";
-import { getPackages, Package } from "@manypkg/get-packages";
+import { getPackages, type Package } from "@manypkg/get-packages";
 
 export const BumpLevels = {
   dep: 0,
@@ -35,11 +37,11 @@ export async function getChangedPackages(
 }
 
 export function getChangelogEntry(changelog: string, version: string) {
-  let ast = unified().use(remarkParse).parse(changelog);
+  let ast = unified().use(remarkParse).parse(changelog) as Root;
 
   let highestLevel: number = BumpLevels.dep;
 
-  let nodes = ast.children as Array<any>;
+  let nodes = ast.children;
   let headingStartInfo:
     | {
         index: number;
@@ -75,10 +77,7 @@ export function getChangelogEntry(changelog: string, version: string) {
     }
   }
   if (headingStartInfo) {
-    ast.children = (ast.children as any).slice(
-      headingStartInfo.index + 1,
-      endIndex
-    );
+    ast.children = ast.children.slice(headingStartInfo.index + 1, endIndex);
   }
   return {
     content: unified().use(remarkStringify).stringify(ast),
@@ -98,3 +97,19 @@ export function sortTheThings(
   }
   return -1;
 }
+
+export function isErrorWithCode(err: unknown, code: string) {
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    "code" in err &&
+    err.code === code
+  );
+}
+
+export function fileExists(filePath: string) {
+  return fs.access(filePath, fs.constants.F_OK).then(
+    () => true,
+    () => false
+  );
+}