#!/usr/bin/env npx tsx

/**
 * Creates a release preparation branch and opens a PR to merge changes from a
 * source branch into a target release branch.
 *
 * For primary releases this merges `main` into the latest `releases/vN` branch.
 * For backports this merges a newer release branch into an older one, handling
 * version number and changelog migration automatically.
 *
 * Usage:
 *   update-release-branch.ts \
 *     --repository-nwo github/codeql-action \
 *     --source-branch main \
 *     --target-branch releases/v4 \
 *     --conductor username \
 *     [--is-primary-release] \
 *     [--dry-run]
 */

import { execFileSync, type ExecFileSyncOptions } from "node:child_process";
import { parseArgs } from "node:util";

import { type ApiClient, getApiClient } from "./api-client";
import * as changelog from "./changelog";
import { DryRunOption, REPO_ROOT } from "./config";
import {
  getCurrentVersion,
  replaceVersionInPackageJson,
  withPackageJson,
} from "./versions";

/**
 * NB: This exact commit message is used to find commits for reverting during backports.
 *  Changing it requires a transition period where both old and new versions are supported.
 */
export const BACKPORT_COMMIT_MESSAGE = "Update version and changelog for v";

/**
 * Commit message used for rebuild commits, both those produced by this script and those produced
 *  by the `Rebuild Action` workflow (`.github/workflows/rebuild.yml`).
 */
export const REBUILD_COMMIT_MESSAGE = "Rebuild";

/** The name of the git remote. */
const ORIGIN = "origin";

/** Environment variables checked (in order) for a GitHub API token. */
const TOKEN_ENVIRONMENT_VARIABLES = ["GH_TOKEN", "GITHUB_TOKEN"] as const;

/** The expected prefix for release branch names. */
const RELEASE_BRANCH_PREFIX = "releases/v";

/**
 * Gets a GitHub API token from one of the supported environment variables.
 * @throws If none of the supported environment variables is set.
 */
export function getGitHubToken(): string {
  for (const name of TOKEN_ENVIRONMENT_VARIABLES) {
    const token = process.env[name]?.trim();
    if (token) {
      return token;
    }
  }
  throw new Error("Missing GitHub token. Set GITHUB_TOKEN or GH_TOKEN.");
}

/** Options for {@link runCommand}. */
export interface RunCommandOptions extends DryRunOption {
  /** Options for `execFileSync`. */
  execOptions?: ExecFileSyncOptions;
}

/**
 * Runs a command, streaming output to the console by default.
 *
 * @param command The name of the command to run.
 * @param args The arguments for the command.
 * @throws When the process exits with a non-zero exit code.
 * @param options How to run the command.
 */
export function runCommand(
  command: string,
  args: string[],
  options?: RunCommandOptions,
) {
  if (!options?.dryRun) {
    console.log(`Running \`${command} ${args.join(" ")}\`.`);
    return execFileSync(command, args, {
      stdio: "inherit",
      cwd: REPO_ROOT,
      ...options?.execOptions,
    });
  } else {
    console.info(
      `[DRY RUN] Would have executed '${command} ${args.join(" ")}'`,
    );
    return "";
  }
}

/** Options for {@link runGit}. */
export interface RunGitOptions extends DryRunOption {
  /** When true, non-zero exit codes will not throw. */
  allowNonZeroExitCode?: boolean;
}

/**
 * Runs `git` with the given `args` and returns the stdout.
 *
 * @param args - Arguments to pass to `git`.
 * @param options - Optional settings.
 * @throws If `git` does not exit successfully, unless
 *         `options.allowNonZeroExitCode` is `true`.
 * @returns The trimmed stdout output.
 */
export function runGit(args: string[], options?: RunGitOptions): string {
  const execOptions: ExecFileSyncOptions = {
    encoding: "utf8",
    stdio: ["pipe", "pipe", "pipe"],
  };

  try {
    const result = runCommand("git", args, {
      dryRun: options?.dryRun,
      execOptions,
    }) as string;
    return result.trimEnd();
  } catch (error: unknown) {
    if (options?.allowNonZeroExitCode) {
      // execFileSync throws an object with `stdout` when the process exits
      // with a non-zero code.
      const execError = error as { stdout?: Buffer | string };
      if (typeof execError.stdout === "string") {
        return execError.stdout.trimEnd();
      }
      if (Buffer.isBuffer(execError.stdout)) {
        return execError.stdout.toString("utf8").trimEnd();
      }
      return "";
    }
    throw error;
  }
}

/** Returns true if the given branch exists on the origin remote. */
export function branchExistsOnRemote(branchName: string): boolean {
  const result = runGit(["ls-remote", "--heads", ORIGIN, branchName]);
  return result !== "";
}

/** Represents commits returned by the GitHub API (relevant fields only). */
export interface GitHubCommit {
  sha: string;
  commit: { message: string; author: { date?: string } | null };
  author: { login: string } | null;
  committer: { login: string } | null;
  parents: Array<{ sha: string }>;
}

/** Returns true if the commit is an automatic PR merge commit made by GitHub. */
export function isPrMergeCommit(commit: GitHubCommit): boolean {
  return commit.committer?.login === "web-flow" && commit.parents.length > 1;
}

/**
 * Gets a list of commits on the source branch that are not on the target branch,
 * excluding automatic PR merge commits. This will not include any commits that
 * exist on the target branch that aren't on the source branch.
 *
 * Uses `git log` to find the SHAs, then fetches each commit from the GitHub API
 * to obtain full metadata (author, parents, associated PRs, etc.).
 *
 * @param client - An authenticated GitHub API client.
 * @param owner - The repository owner.
 * @param repo - The repository name.
 * @param sourceBranch - The source branch name (without `origin/` prefix).
 * @param targetBranch - The target branch name (without `origin/` prefix).
 * @returns The list of non-merge commits unique to the source branch.
 */
export async function getCommitDifference(
  client: ApiClient,
  owner: string,
  repo: string,
  sourceBranch: string,
  targetBranch: string,
): Promise<GitHubCommit[]> {
  const logOutput = runGit([
    "log",
    "--pretty=format:%H",
    `${ORIGIN}/${targetBranch}..${ORIGIN}/${sourceBranch}`,
  ]);

  // An empty log output means no commits to merge.
  if (logOutput === "") {
    return [];
  }

  const shas = logOutput.split("\n");

  // Fetch full commit objects from the API.
  console.info(
    `Fetching information about ${shas.length} commits from the API...`,
  );

  const commits: GitHubCommit[] = [];
  for (const sha of shas) {
    const { data } = await client.rest.repos.getCommit({
      owner,
      repo,
      ref: sha,
    });
    commits.push(data as GitHubCommit);
  }

  // Filter out automatic PR merge commits.
  return commits.filter((c) => !isPrMergeCommit(c));
}

/** Truncates a commit message for display. */
export function getTruncatedCommitMessage(message: string): string {
  const firstLine = message.split("\n")[0];
  if (firstLine.length > 60) {
    return `${firstLine.slice(0, 57)}...`;
  }
  return firstLine;
}

/** Represents pull requests associated with a commit (relevant fields only). */
export interface AssociatedPullRequest {
  number: number;
  user: { login: string; site_admin: boolean } | null;
  merge_commit_sha: string | null;
}

/**
 * Gets the pull request that introduced a commit to the source branch.
 * Returns the earliest PR by number if multiple are associated.
 */
export async function getPrForCommit(
  client: ApiClient,
  owner: string,
  repo: string,
  commit: GitHubCommit,
): Promise<AssociatedPullRequest | undefined> {
  const prs = await client.paginate(
    client.rest.repos.listPullRequestsAssociatedWithCommit,
    {
      owner,
      repo,
      commit_sha: commit.sha,
    },
  );

  if (prs.length === 0) {
    return undefined;
  }

  // Return the earliest PR by number.
  const sorted = [...prs].sort((a, b) => a.number - b.number);
  return sorted[0];
}

/**
 * Get the login of the person who merged a pull request.
 * Falls back to the commit author of the merge commit.
 * For most cases this will be the same as the author, but for PRs opened
 * by external contributors getting the merger will get us the GitHub
 * employee who reviewed and merged the PR.
 */
export async function getMergerOfPr(
  client: ApiClient,
  owner: string,
  repo: string,
  pr: AssociatedPullRequest,
): Promise<string> {
  if (!pr.merge_commit_sha) {
    return "unknown";
  }
  const { data: commit } = await client.rest.repos.getCommit({
    owner,
    repo,
    ref: pr.merge_commit_sha,
  });
  return commit.author?.login ?? "unknown";
}

/**
 * Returns the PR author's login if they are GitHub staff (site_admin),
 * otherwise undefined.
 */
export function getPrAuthorIfStaff(
  pr: AssociatedPullRequest,
): string | undefined {
  if (pr.user?.site_admin) {
    return pr.user.login;
  }
  return undefined;
}

/** Parameters for {@link openPr}. */
interface OpenPrParams {
  client: ApiClient;
  owner: string;
  repo: string;
  commits: GitHubCommit[];
  sourceBranchShortSha: string;
  newBranchName: string;
  sourceBranch: string;
  targetBranch: string;
  conductor: string;
  isPrimaryRelease: boolean;
  conflictedFiles: string[];
  dryRun: boolean;
}

/**
 * Opens a pull request from the new branch to the target branch and assigns
 * the conductor.
 */
export async function openPr(params: OpenPrParams): Promise<void> {
  const {
    client,
    owner,
    repo,
    commits,
    sourceBranchShortSha,
    newBranchName,
    sourceBranch,
    targetBranch,
    conductor,
    isPrimaryRelease,
    conflictedFiles,
    dryRun,
  } = params;

  // Sort the commits into those with and without associated PRs.
  const pullRequests: AssociatedPullRequest[] = [];
  const commitsWithoutPrs: GitHubCommit[] = [];

  console.info(`Finding PRs for ${commits.length} commits...`);

  for (const commit of commits) {
    const pr = await getPrForCommit(client, owner, repo, commit);
    if (!pr) {
      commitsWithoutPrs.push(commit);
    } else if (!pullRequests.some((p) => p.number === pr.number)) {
      pullRequests.push(pr);
    }
  }

  console.log(`Found ${pullRequests.length} pull requests.`);
  console.log(
    `Found ${commitsWithoutPrs.length} commits not in a pull request.`,
  );

  // Sort PRs by number (ascending) and commits by date.
  pullRequests.sort((a, b) => a.number - b.number);
  commitsWithoutPrs.sort((a, b) => {
    const dateA = a.commit.author?.date ?? "";
    const dateB = b.commit.author?.date ?? "";
    return dateA.localeCompare(dateB);
  });

  // Build the PR body.
  const body: string[] = [];
  body.push(`Merging ${sourceBranchShortSha} into \`${targetBranch}\`.`);
  body.push("");
  body.push(`Conductor for this PR is @${conductor}.`);

  if (pullRequests.length > 0) {
    body.push("");
    body.push("Contains the following pull requests:");
    for (const pr of pullRequests) {
      const displayUser =
        getPrAuthorIfStaff(pr) ??
        (await getMergerOfPr(client, owner, repo, pr));
      body.push(`- #${pr.number} (@${displayUser})`);
    }
  }

  if (commitsWithoutPrs.length > 0) {
    body.push("");
    body.push("Contains the following commits not from a pull request:");
    for (const commit of commitsWithoutPrs) {
      const authorDesc = commit.author ? ` (@${commit.author.login})` : "";
      body.push(
        `- ${commit.sha} - ${getTruncatedCommitMessage(commit.commit.message)}${authorDesc}`,
      );
    }
  }

  body.push("");
  body.push("Please do the following:");
  if (conflictedFiles.length > 0) {
    body.push(
      " - [ ] Ensure `package.json` file contains the correct version.",
    );
    body.push(
      " - [ ] Add a commit to this branch to resolve the merge conflicts in the following files:",
    );
    for (const file of conflictedFiles) {
      body.push(`    - \`${file}\``);
    }
    body.push(
      ` - [ ] Rebuild the Action locally (\`npm run build\`) and push any changes to the built output in \`lib\` as a separate commit named exactly \`${REBUILD_COMMIT_MESSAGE}\`.`,
    );
    body.push(
      " - [ ] Ensure another maintainer has reviewed the additional commits you added to this branch to resolve the merge conflicts.",
    );
  }
  body.push(
    " - [ ] Ensure the CHANGELOG displays the correct version and date.",
  );
  body.push(
    " - [ ] Ensure the CHANGELOG includes all relevant, user-facing changes since the last release.",
  );
  body.push(
    ` - [ ] Check that there are not any unexpected commits being merged into the \`${targetBranch}\` branch.`,
  );
  body.push(
    " - [ ] Ensure the docs team is aware of any documentation changes that need to be released.",
  );
  body.push(
    " - [ ] Approve running the full set of PR checks if you have not pushed any changes.",
  );
  body.push(
    " - [ ] Approve and merge this PR. Make sure `Create a merge commit` is selected rather than `Squash and merge` or `Rebase and merge`.",
  );

  if (isPrimaryRelease) {
    body.push(
      " - [ ] Merge the mergeback PR that will automatically be created once this PR is merged.",
    );
    body.push(
      " - [ ] Merge all backport PRs to older release branches, that will automatically be created once this PR is merged.",
    );
  }

  const title = `Merge ${sourceBranch} into ${targetBranch}`;

  if (dryRun) {
    console.info(`[DRY RUN] Would create PR: "${title}" with body:`);

    for (const line of body) {
      console.info(`[DRY RUN] > ${line}`);
    }

    console.info(`[DRY RUN] and assign it to @${conductor}`);

    return;
  }

  // Create the pull request.
  const { data: pr } = await client.rest.pulls.create({
    owner,
    repo,
    title,
    body: body.join("\n"),
    head: newBranchName,
    base: targetBranch,
  });
  console.log(`Created PR #${pr.number}`);

  // Assign the conductor.
  await client.rest.issues.addAssignees({
    owner,
    repo,
    issue_number: pr.number,
    assignees: [conductor],
  });
  console.log(`Assigned PR to ${conductor}`);
}

interface MainOptions {
  dryRun: boolean;
  repositoryNwo: string;
  sourceBranch: string;
  targetBranch: string;
  isPrimaryRelease: boolean;
  conductor: string;
}

function parseCliOptions(): MainOptions {
  const { values } = parseArgs({
    options: {
      "dry-run": { type: "boolean", default: false },
      "repository-nwo": { type: "string" },
      "source-branch": { type: "string" },
      "target-branch": { type: "string" },
      "is-primary-release": { type: "boolean", default: false },
      conductor: { type: "string" },
    },
    strict: true,
  });

  if (!values["repository-nwo"]) {
    throw new Error("--repository-nwo is required");
  }
  if (!values["source-branch"]) {
    throw new Error("--source-branch is required");
  }
  if (!values["target-branch"]) {
    throw new Error("--target-branch is required");
  }
  if (!values["conductor"]) {
    throw new Error("--conductor is required");
  }

  return {
    dryRun: values["dry-run"],
    repositoryNwo: values["repository-nwo"],
    sourceBranch: values["source-branch"],
    targetBranch: values["target-branch"],
    isPrimaryRelease: values["is-primary-release"] ?? false,
    conductor: values["conductor"],
  };
}

/**
 * Rebuilds the action (npm ci + npm run build) and commits any changes.
 */
export function rebuildAction(options: MainOptions): void {
  // For backports, the only source-level change vs the source branch is the new version number,
  // so we just need to refresh the version embedded in `lib/`.
  runCommand("npm", ["ci"]);
  runCommand("npm", ["run", "build"]);

  runGit(["add", "--all"], { dryRun: options.dryRun });

  // `git diff --cached --quiet` exits 0 if there are no staged changes.
  try {
    execFileSync("git", ["diff", "--cached", "--quiet"]);
    console.log("Rebuild produced no changes; skipping Rebuild commit.");
  } catch {
    runGit(["commit", "-m", REBUILD_COMMIT_MESSAGE], {
      dryRun: options.dryRun,
    });
    console.log("Created Rebuild commit.");
  }
}

/**
 * Prepares the new update/backport branch.
 *
 * @param options The options we are running with.
 * @param newBranchName The name of the new branch to create.
 * @param targetBranchMajorVersion The target branch's major version.
 * @param version The target version.
 */
export async function prepareNewBranch(
  options: MainOptions,
  newBranchName: string,
  targetBranchMajorVersion: string,
  version: string,
): Promise<string[]> {
  // The process of creating the v{Older} release can run into merge conflicts. We commit the unresolved
  // conflicts so a maintainer can easily resolve them (vs erroring and requiring maintainers to
  // reconstruct the release manually)
  let conflictedFiles: string[] = [];

  if (!options.isPrimaryRelease) {
    // For backports, the source branch is also a release branch.
    const sourceBranchMajorVersion = options.sourceBranch.replace(
      RELEASE_BRANCH_PREFIX,
      "",
    );

    // Start from the target branch.
    console.log(
      `Creating ${newBranchName} from the ${ORIGIN}/${options.targetBranch} branch`,
    );

    runGit(
      ["checkout", "-b", newBranchName, `${ORIGIN}/${options.targetBranch}`],
      { dryRun: options.dryRun },
    );

    // Revert the commit that we made as part of the last release that updated the version number and
    // changelog to refer to {older}.x.x variants. This avoids merge conflicts in the changelog and
    // package.json files when we merge in the v{latest} branch.
    // This commit will not exist the first time we release the v{N-1} branch from the v{N} branch, so we
    // use `git log --grep` to conditionally revert the commit.
    console.log(
      "Reverting the version number and changelog updates from the last release to avoid conflicts",
    );
    const vOlderUpdateCommits = runGit([
      "log",
      "--grep",
      `^${BACKPORT_COMMIT_MESSAGE}`,
      "--format=%H",
    ])
      .split("\n")
      .filter((s) => s !== "");

    if (vOlderUpdateCommits.length > 0) {
      // Only revert the newest commit as older ones will already have been
      // reverted in previous releases.
      console.log(`  Reverting ${vOlderUpdateCommits[0]}`);
      runGit(["revert", vOlderUpdateCommits[0], "--no-edit"], {
        dryRun: options.dryRun,
      });

      // Also revert the "Rebuild" commit, whether created by this script or
      // by the `Rebuild Action` workflow.
      const rebuildCommits = runGit([
        "log",
        "--grep",
        `^${REBUILD_COMMIT_MESSAGE}$`,
        "--format=%H",
      ])
        .split("\n")
        .filter((s) => s !== "");
      const rebuildCommit = rebuildCommits[0];
      console.log(`  Reverting ${rebuildCommit}`);
      runGit(["revert", rebuildCommit, "--no-edit"], {
        dryRun: options.dryRun,
      });
    } else {
      console.log("  Nothing to revert.");
    }

    // Merge the source branch into the release prep branch.
    console.log(
      `Merging ${ORIGIN}/${options.sourceBranch} into the release prep branch`,
    );
    runGit(["merge", `${ORIGIN}/${options.sourceBranch}`], {
      allowNonZeroExitCode: true,
      dryRun: options.dryRun,
    });
    conflictedFiles = runGit(["diff", "--name-only", "--diff-filter", "U"])
      .split("\n")
      .filter((s) => s !== "");
    if (conflictedFiles.length > 0) {
      runGit(["add", "."], {
        dryRun: options.dryRun,
      });
      runGit(["commit", "--no-edit"], {
        dryRun: options.dryRun,
      });
    }

    // Migrate the package version number.
    console.log(`Setting version number to '${version}' in package.json`);
    withPackageJson((content) => {
      const currentPkgVersion = getCurrentVersion(content);
      if (currentPkgVersion) {
        return {
          content: replaceVersionInPackageJson(
            currentPkgVersion,
            version,
            content,
          ),
          value: currentPkgVersion,
        };
      }
      return { value: currentPkgVersion };
    }, options);
    runGit(["add", "package.json"], {
      dryRun: options.dryRun,
    });

    // Migrate the changelog notes from the source major version to the target.
    console.log(
      `Migrating changelog notes from v${sourceBranchMajorVersion} to v${targetBranchMajorVersion}`,
    );
    changelog.withChangelog(
      (contents) =>
        changelog.processChangelogForBackports(
          sourceBranchMajorVersion,
          targetBranchMajorVersion,
          contents,
        ),
      options,
    );

    runGit(["add", "CHANGELOG.md"], {
      dryRun: options.dryRun,
    });
    runGit(["commit", "-m", `${BACKPORT_COMMIT_MESSAGE}${version}`], {
      dryRun: options.dryRun,
    });
  } else {
    // For a standard (primary) release, there won't be new commits on the
    // target branch that aren't already on the source branch, so we can just
    // start from the source branch.
    runGit(
      ["checkout", "-b", newBranchName, `${ORIGIN}/${options.sourceBranch}`],
      {
        dryRun: options.dryRun,
      },
    );

    console.log("Updating changelog");
    changelog.withChangelog(
      (contents) => changelog.setVersionAndDate(version, contents),
      { ...options, initChangelog: true },
    );

    runGit(["add", "CHANGELOG.md"], {
      dryRun: options.dryRun,
    });
    runGit(["commit", "-m", `Update changelog for v${version}`], {
      dryRun: options.dryRun,
    });
  }

  // For backports, rebuild the action unless there were merge conflicts.
  if (!options.isPrimaryRelease) {
    if (conflictedFiles.length === 0) {
      console.log("Rebuilding the Action.");
      rebuildAction(options);
    } else {
      console.log(
        `Skipping automatic rebuild because the merge produced conflicts in: ${conflictedFiles.join(", ")}`,
      );
    }
  }

  return conflictedFiles;
}

async function main(): Promise<void> {
  const options = parseCliOptions();
  const token = getGitHubToken();
  const client = getApiClient(token);

  if (!options.targetBranch.startsWith(RELEASE_BRANCH_PREFIX)) {
    throw new Error(
      `Expected target branch to start with '${RELEASE_BRANCH_PREFIX}', but got '${options.targetBranch}'.`,
    );
  }
  if (
    !options.isPrimaryRelease &&
    !options.sourceBranch.startsWith(RELEASE_BRANCH_PREFIX)
  ) {
    throw new Error(
      `Expected source branch to start with '${RELEASE_BRANCH_PREFIX}' for backports, but got '${options.sourceBranch}'.`,
    );
  }
  if (!options.repositoryNwo.includes("/")) {
    throw new Error(
      `Expected repository name with owner in 'owner/repo' format, but got '${options.repositoryNwo}'`,
    );
  }

  const targetBranchMajorVersion = options.targetBranch.replace(
    RELEASE_BRANCH_PREFIX,
    "",
  );

  const currentVersion = withPackageJson((content) => {
    return { value: getCurrentVersion(content) };
  }, options);

  if (!currentVersion) {
    throw new Error("Failed to read current version from package.json");
  }

  const [, vMinor, vPatch] = currentVersion.split(".");
  const version = `${targetBranchMajorVersion}.${vMinor}.${vPatch}`;

  console.log(
    `Considering difference between ${options.sourceBranch} and ${options.targetBranch}...`,
  );

  const sourceBranchShortSha = runGit([
    "rev-parse",
    "--short",
    `${ORIGIN}/${options.sourceBranch}`,
  ]);
  console.log(
    `Current head of ${options.sourceBranch} is ${sourceBranchShortSha}.`,
  );

  const [owner, repo] = options.repositoryNwo.split("/");
  const commits = await getCommitDifference(
    client,
    owner,
    repo,
    options.sourceBranch,
    options.targetBranch,
  );

  if (commits.length === 0) {
    console.log(
      `No commits to merge from ${options.sourceBranch} to ${options.targetBranch}.`,
    );
    return;
  }

  // Use a distinct branch prefix to support specific PR checks on backports.
  const branchPrefix = options.isPrimaryRelease ? "update" : "backport";

  // The branch name is based on the target version and the SHA of the source
  // branch head. If the branch already exists we can assume this script has
  // already run for this combination.
  const newBranchName = `${branchPrefix}-v${version}-${sourceBranchShortSha}`;
  console.log(`Branch name is '${newBranchName}'.`);

  // Check if the branch already exists. If so we can abort as this script
  // has already run on this combination of branches.
  if (branchExistsOnRemote(newBranchName)) {
    console.log(`Branch '${newBranchName}' already exists. Nothing to do.`);
    return;
  }

  // Prepare the update/backport branch.
  const conflictedFiles = await prepareNewBranch(
    options,
    newBranchName,
    targetBranchMajorVersion,
    version,
  );

  // Push the new branch to the remote.
  console.log(`Creating branch ${newBranchName}.`);
  runGit(["push", ORIGIN, newBranchName], { dryRun: options.dryRun });

  // Open a PR to merge the new branch into the target branch.
  await openPr({
    client,
    owner,
    repo,
    commits,
    sourceBranchShortSha,
    newBranchName,
    sourceBranch: options.sourceBranch,
    targetBranch: options.targetBranch,
    conductor: options.conductor,
    isPrimaryRelease: options.isPrimaryRelease,
    conflictedFiles,
    dryRun: options.dryRun,
  });
}

// Only call `main` if this script was run directly.
if (require.main === module) {
  void main();
}