├── .gitignore
├── .github
    └── dependabot.yml
├── .circleci
    └── config.yml
├── lib
    ├── util.js
    ├── git.js
    ├── update.js
    ├── common.js
    ├── merge.js
    └── api.js
├── action.yml
├── test
    ├── update.test.js
    ├── util.test.js
    ├── common.js
    ├── api.test.js
    ├── git.test.js
    ├── common.test.js
    └── merge.test.js
├── eslint.config.mjs
├── it
    └── it.js
├── LICENSE
├── package.json
├── bin
    └── automerge.js
├── README.md
└── dist
    └── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | .env
3 | node_modules/
4 | 


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 |   - package-ecosystem: "npm"
4 |     directory: "/"
5 |     schedule:
6 |       interval: "weekly"
7 | 


--------------------------------------------------------------------------------
/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | jobs:
 3 |   build:
 4 |     docker:
 5 |       - image: cimg/node:20.10.0
 6 |     steps:
 7 |       - checkout
 8 |       - run:
 9 |           name: yarn
10 |           command: yarn
11 | 


--------------------------------------------------------------------------------
/lib/util.js:
--------------------------------------------------------------------------------
1 | function branchName(ref) {
2 |   const branchPrefix = "refs/heads/";
3 |   if (ref.startsWith(branchPrefix)) {
4 |     return ref.substr(branchPrefix.length);
5 |   }
6 | }
7 | 
8 | module.exports = { branchName };
9 | 


--------------------------------------------------------------------------------
/action.yml:
--------------------------------------------------------------------------------
1 | name: "Merge pull requests (automerge-action)"
2 | description: "Automatically merge pull requests that are ready"
3 | runs:
4 |   using: "node20"
5 |   main: "dist/index.js"
6 | branding:
7 |   icon: "git-pull-request"
8 |   color: "blue"
9 | 


--------------------------------------------------------------------------------
/test/update.test.js:
--------------------------------------------------------------------------------
 1 | const { update } = require("../lib/update");
 2 | const { createConfig } = require("../lib/common");
 3 | const { pullRequest } = require("./common");
 4 | 
 5 | test("update will only run when the label matches", async () => {
 6 |   const pr = pullRequest();
 7 |   const config = createConfig({ UPDATE_LABELS: "none" });
 8 |   expect(await update({ config }, pr)).toEqual(false);
 9 | });
10 | 


--------------------------------------------------------------------------------
/test/util.test.js:
--------------------------------------------------------------------------------
 1 | const { branchName } = require("../lib/util");
 2 | 
 3 | describe("branchName", () => {
 4 |   it("returns the branch name from a reference referring to a branch", async () => {
 5 |     expect(branchName("refs/heads/main")).toEqual("main");
 6 |     expect(branchName("refs/heads/features/branch_with_slashes")).toEqual(
 7 |       "features/branch_with_slashes"
 8 |     );
 9 |   });
10 | 
11 |   it("is falsey for other kinds of git references", async () => {
12 |     expect(branchName("refs/tags/v1.0")).toBeUndefined();
13 |     expect(branchName("refs/remotes/origin/main")).toBeUndefined();
14 |   });
15 | });
16 | 


--------------------------------------------------------------------------------
/eslint.config.mjs:
--------------------------------------------------------------------------------
 1 | import js from "@eslint/js";
 2 | import jest from "eslint-plugin-jest";
 3 | import globals from "globals";
 4 | 
 5 | export default [
 6 |   js.configs.recommended,
 7 |   {
 8 |     languageOptions: {
 9 |       parserOptions: {
10 |         ecmaVersion: 2017,
11 |         sourceType: "module"
12 |       },
13 |       globals: {
14 |         ...globals.node,
15 |         ...globals.es2015,
16 |         ...globals.jest
17 |       }
18 |     },
19 |     plugins: { jest },
20 |     rules: {
21 |       semi: "error",
22 |       "no-tabs": "error",
23 |       "no-console": "off"
24 |     }
25 |   },
26 |   {
27 |     ignores: ["eslint.config.mjs", "dist/*"]
28 |   }
29 | ];
30 | 


--------------------------------------------------------------------------------
/test/common.js:
--------------------------------------------------------------------------------
 1 | function pullRequest() {
 2 |   return {
 3 |     number: 1,
 4 |     title: "Update README",
 5 |     body: "This PR updates the README",
 6 |     state: "open",
 7 |     locked: false,
 8 |     merged: false,
 9 |     mergeable: true,
10 |     rebaseable: true,
11 |     mergeable_state: "clean",
12 |     commits: 2,
13 |     labels: [{ name: "automerge" }],
14 |     head: {
15 |       ref: "patch-1",
16 |       sha: "2c3b4d5",
17 |       user: { login: "username" },
18 |       repo: {
19 |         name: "repository",
20 |         full_name: "username/repository",
21 |         owner: { login: "username" }
22 |       }
23 |     },
24 |     base: {
25 |       ref: "master",
26 |       sha: "45600fe",
27 |       user: { login: "username" },
28 |       repo: {
29 |         name: "repository",
30 |         full_name: "username/repository",
31 |         owner: { login: "username" }
32 |       }
33 |     }
34 |   };
35 | }
36 | 
37 | module.exports = { pullRequest };
38 | 


--------------------------------------------------------------------------------
/it/it.js:
--------------------------------------------------------------------------------
 1 | const { Octokit } = require("@octokit/rest");
 2 | 
 3 | const { executeLocally } = require("../lib/api");
 4 | const { createConfig } = require("../lib/common");
 5 | 
 6 | async function main() {
 7 |   require("dotenv").config();
 8 | 
 9 |   const token = process.env.GITHUB_TOKEN;
10 | 
11 |   const octokit = new Octokit({
12 |     baseUrl: "https://api.github.com",
13 |     auth: `token ${token}`,
14 |     userAgent: "pascalgn/automerge-action-it"
15 |   });
16 | 
17 |   const config = createConfig({
18 |     UPDATE_LABELS: "it-update",
19 |     MERGE_LABELS: "it-merge",
20 |     MERGE_REQUIRED_APPROVALS: "0",
21 |     MERGE_REMOVE_LABELS: "it-merge",
22 |     MERGE_RETRIES: "3",
23 |     MERGE_RETRY_SLEEP: "2000",
24 |     MERGE_ERROR_FAIL: "true"
25 |   });
26 | 
27 |   const context = { token, octokit, config };
28 | 
29 |   await executeLocally(context, process.env.URL);
30 | }
31 | 
32 | main().catch(e => {
33 |   process.exitCode = 1;
34 |   console.error(e);
35 | });
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright 2019 Pascal
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "automerge-action",
 3 |   "version": "0.16.3",
 4 |   "description": "GitHub action to automatically merge pull requests",
 5 |   "main": "lib/api.js",
 6 |   "author": "Pascal",
 7 |   "license": "MIT",
 8 |   "private": true,
 9 |   "bin": {
10 |     "automerge-action": "./bin/automerge.js"
11 |   },
12 |   "scripts": {
13 |     "test": "jest",
14 |     "it": "node it/it.js",
15 |     "lint": "prettier -l lib/** test/** && eslint .",
16 |     "compile": "ncc build bin/automerge.js --license LICENSE -o dist",
17 |     "prepublish": "yarn lint && yarn test && yarn compile"
18 |   },
19 |   "dependencies": {
20 |     "@actions/core": "^1.10.1",
21 |     "@octokit/rest": "^20.1.0",
22 |     "argparse": "^2.0.1",
23 |     "fs-extra": "^11.2.0",
24 |     "object-resolve-path": "^1.1.1",
25 |     "tmp": "^0.2.3"
26 |   },
27 |   "devDependencies": {
28 |     "@vercel/ncc": "^0.38.1",
29 |     "dotenv": "^16.4.5",
30 |     "eslint": "^9.0.0",
31 |     "eslint-plugin-jest": "^28.2.0",
32 |     "globals": "^15.0.0",
33 |     "jest": "^29.7.0",
34 |     "prettier": "^3.2.5"
35 |   },
36 |   "prettier": {
37 |     "trailingComma": "none",
38 |     "arrowParens": "avoid"
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/test/api.test.js:
--------------------------------------------------------------------------------
 1 | const api = require("../lib/api");
 2 | const { createConfig } = require("../lib/common");
 3 | const { pullRequest } = require("./common");
 4 | 
 5 | let octokit;
 6 | 
 7 | test("forked PR check_suite/check_run updates are handled", async () => {
 8 |   // GIVEN
 9 |   const head_sha = "1234abcd";
10 |   const pr = pullRequest();
11 |   pr.labels = [{ name: "automerge" }];
12 |   pr.head.sha = head_sha;
13 | 
14 |   const config = createConfig({});
15 | 
16 |   let merged = false;
17 |   octokit = {
18 |     pulls: {
19 |       list: jest.fn(() => ({ data: [pr] })),
20 |       merge: jest.fn(() => (merged = true)),
21 |       listReviews: jest.fn(() => ({ data: [] }))
22 |     }
23 |   };
24 | 
25 |   const event = {
26 |     action: "completed",
27 |     repository: { owner: { login: "other-username" }, name: "repository" },
28 |     check_suite: { conclusion: "success", head_sha, pull_requests: [] }
29 |   };
30 | 
31 |   // WHEN
32 |   await api.executeGitHubAction({ config, octokit }, "check_suite", event);
33 |   expect(merged).toEqual(true);
34 | });
35 | 
36 | test("only merge PRs with required approvals", async () => {
37 |   // GIVEN
38 |   const head_sha = "1234abcd";
39 |   const pr = pullRequest();
40 |   pr.labels = [{ name: "automerge" }];
41 |   pr.head.sha = head_sha;
42 | 
43 |   const config = createConfig({});
44 |   config.mergeRequiredApprovals = 2; // let's only merge, if there are two independent approvals
45 | 
46 |   let merged = false;
47 |   octokit = {
48 |     pulls: {
49 |       list: jest.fn(() => ({ data: [pr] })),
50 |       merge: jest.fn(() => (merged = true)),
51 |       listReviews: Symbol("listReviews")
52 |     },
53 |     paginate: jest.fn(() => [])
54 |   };
55 | 
56 |   const event = {
57 |     action: "completed",
58 |     repository: { owner: { login: "other-username" }, name: "repository" },
59 |     check_suite: { conclusion: "success", head_sha, pull_requests: [] }
60 |   };
61 | 
62 |   // WHEN
63 |   await api.executeGitHubAction({ config, octokit }, "check_suite", event);
64 |   expect(merged).toEqual(false); // if there's no approval, it should fail
65 | 
66 |   merged = false;
67 |   octokit.paginate.mockReturnValueOnce([
68 |     { state: "APPROVED", user: { login: "approval_user" } },
69 |     { state: "APPROVED", user: { login: "approval_user2" } }
70 |   ]);
71 | 
72 |   // WHEN
73 |   await api.executeGitHubAction({ config, octokit }, "check_suite", event);
74 |   expect(merged).toEqual(true); // if there are two approvals, it should succeed
75 | 
76 |   merged = false;
77 |   octokit.paginate.mockReturnValueOnce([
78 |     { state: "APPROVED", user: { login: "approval_user" } },
79 |     { state: "APPROVED", user: { login: "approval_user" } }
80 |   ]);
81 | 
82 |   // WHEN a user has given
83 |   await api.executeGitHubAction({ config, octokit }, "check_suite", event);
84 |   expect(merged).toEqual(false); // if there are only two approvals from the same user, it should fail
85 | });
86 | 


--------------------------------------------------------------------------------
/bin/automerge.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | const process = require("process");
  4 | 
  5 | const fse = require("fs-extra");
  6 | const { ArgumentParser } = require("argparse");
  7 | const { Octokit } = require("@octokit/rest");
  8 | 
  9 | const { ClientError, logger, createConfig } = require("../lib/common");
 10 | const { executeLocally, executeGitHubAction } = require("../lib/api");
 11 | 
 12 | const pkg = require("../package.json");
 13 | 
 14 | const OLD_CONFIG = [
 15 |   "MERGE_LABEL",
 16 |   "UPDATE_LABEL",
 17 |   "LABELS",
 18 |   "AUTOMERGE",
 19 |   "AUTOREBASE",
 20 |   "COMMIT_MESSAGE_TEMPLATE",
 21 |   "TOKEN"
 22 | ];
 23 | 
 24 | const GITHUB_API_URL = process.env.GITHUB_API_URL || "https://api.github.com";
 25 | 
 26 | async function main() {
 27 |   const parser = new ArgumentParser({
 28 |     prog: pkg.name,
 29 |     add_help: true,
 30 |     description: pkg.description
 31 |   });
 32 |   parser.add_argument("-v", "--version", {
 33 |     action: "version",
 34 |     version: pkg.version,
 35 |     help: "Show version number and exit"
 36 |   });
 37 |   parser.add_argument("url", {
 38 |     metavar: "<url>",
 39 |     nargs: "?",
 40 |     help: "GitHub URL to process instead of environment variables"
 41 |   });
 42 | 
 43 |   const args = parser.parse_args();
 44 | 
 45 |   if (process.env.LOG === "TRACE") {
 46 |     logger.level = "trace";
 47 |   } else if (process.env.LOG === "DEBUG") {
 48 |     logger.level = "debug";
 49 |   } else if (process.env.LOG && process.env.LOG.length > 0) {
 50 |     logger.error("Invalid log level:", process.env.LOG);
 51 |   }
 52 | 
 53 |   checkOldConfig();
 54 | 
 55 |   const token = env("GITHUB_TOKEN");
 56 | 
 57 |   const octokit = new Octokit({
 58 |     baseUrl: GITHUB_API_URL,
 59 |     auth: `token ${token}`,
 60 |     userAgent: "pascalgn/automerge-action"
 61 |   });
 62 | 
 63 |   const config = createConfig(process.env);
 64 |   logger.debug("Configuration:", config);
 65 | 
 66 |   const context = { token, octokit, config };
 67 | 
 68 |   if (args.url) {
 69 |     await executeLocally(context, args.url);
 70 |   } else {
 71 |     const eventPath = env("GITHUB_EVENT_PATH");
 72 |     const eventName = env("GITHUB_EVENT_NAME");
 73 | 
 74 |     const eventDataStr = await fse.readFile(eventPath, "utf8");
 75 |     const eventData = JSON.parse(eventDataStr);
 76 | 
 77 |     await executeGitHubAction(context, eventName, eventData);
 78 |   }
 79 | }
 80 | 
 81 | function checkOldConfig() {
 82 |   let error = false;
 83 |   for (const old of OLD_CONFIG) {
 84 |     if (process.env[old] != null) {
 85 |       logger.error("Old configuration option present:", old);
 86 |       error = true;
 87 |     }
 88 |   }
 89 |   if (error) {
 90 |     logger.error(
 91 |       "You have passed configuration options that were used by an old " +
 92 |         "version of this action. Please see " +
 93 |         "https://github.com/pascalgn/automerge-action for the latest " +
 94 |         "documentation of the configuration options!"
 95 |     );
 96 |     throw new Error(`old configuration present!`);
 97 |   }
 98 | }
 99 | 
100 | function env(name) {
101 |   const val = process.env[name];
102 |   if (!val || !val.length) {
103 |     throw new ClientError(`environment variable ${name} not set!`);
104 |   }
105 |   return val;
106 | }
107 | 
108 | if (require.main === module) {
109 |   main().catch(e => {
110 |     if (e instanceof ClientError) {
111 |       process.exitCode = 2;
112 |       logger.error(e);
113 |     } else {
114 |       process.exitCode = 1;
115 |       logger.error(e);
116 |     }
117 |   });
118 | }
119 | 


--------------------------------------------------------------------------------
/test/git.test.js:
--------------------------------------------------------------------------------
  1 | const fse = require("fs-extra");
  2 | 
  3 | const git = require("../lib/git");
  4 | const { tmpdir } = require("../lib/common");
  5 | 
  6 | async function init(dir) {
  7 |   await fse.mkdirs(dir);
  8 |   await git.git(dir, "init");
  9 |   await git.git(dir, "checkout", "-b", "main");
 10 | }
 11 | 
 12 | async function commit(dir, message = "C%d", count = 1) {
 13 |   for (let i = 1; i <= count; i++) {
 14 |     await git.git(
 15 |       dir,
 16 |       "commit",
 17 |       "--allow-empty",
 18 |       "-m",
 19 |       message.replace(/%d/g, i)
 20 |     );
 21 |   }
 22 | }
 23 | 
 24 | test("clone creates the target directory", async () => {
 25 |   await tmpdir(async path => {
 26 |     await init(`${path}/origin`);
 27 |     await commit(`${path}/origin`);
 28 |     await git.clone(`${path}/origin`, `${path}/ws`, "main", 1);
 29 |     expect(await fse.exists(`${path}/ws`)).toBe(true);
 30 |   });
 31 | });
 32 | 
 33 | test("fetchUntilMergeBase finds the correct merge base", async () => {
 34 |   await tmpdir(async path => {
 35 |     const origin = `${path}/origin`;
 36 |     await init(origin);
 37 |     await commit(origin, "base %d", 10);
 38 |     const base = await git.head(origin);
 39 |     await git.git(origin, "checkout", "-b", "br1");
 40 |     await commit(origin, "br1 %d", 20);
 41 |     await git.git(origin, "checkout", "main");
 42 |     await commit(origin, "main %d", 20);
 43 | 
 44 |     const ws = `${path}/ws`;
 45 |     await git.clone(`${path}/origin`, ws, "br1");
 46 |     await git.fetch(ws, "main");
 47 |     expect(await git.fetchUntilMergeBase(ws, "main", 10000)).toBe(base);
 48 |   });
 49 | }, 15000);
 50 | 
 51 | test("fetchUntilMergeBase finds the earliest merge base 1", async () => {
 52 |   await tmpdir(async path => {
 53 |     const origin = `${path}/origin`;
 54 |     await init(origin);
 55 |     await commit(origin, "base %d", 10);
 56 |     const base = await git.head(origin);
 57 |     await git.git(origin, "branch", "br1");
 58 |     await commit(origin, "main %d", 10);
 59 |     await git.git(origin, "checkout", "br1");
 60 |     await commit(origin, "br1 before merge %d", 5);
 61 |     await git.git(origin, "merge", "--no-ff", "main");
 62 |     await commit(origin, "br1 after merge %d", 10);
 63 |     await git.git(origin, "checkout", "main");
 64 |     await commit(origin, "main after merge %d", 10);
 65 | 
 66 |     const ws = `${path}/ws`;
 67 |     await git.clone(`${path}/origin`, ws, "br1");
 68 |     await git.fetch(ws, "main");
 69 |     expect(await git.fetchUntilMergeBase(ws, "main", 10000)).toBe(base);
 70 |   });
 71 | }, 15000);
 72 | 
 73 | test("fetchUntilMergeBase finds the earliest merge base 2", async () => {
 74 |   await tmpdir(async path => {
 75 |     const origin = `${path}/origin`;
 76 |     await init(origin);
 77 |     await commit(origin, "base a%d", 5);
 78 |     const base = await git.head(origin);
 79 |     await commit(origin, "base b%d", 5);
 80 |     await git.git(origin, "branch", "br1");
 81 |     await commit(origin, "main %d", 10);
 82 |     await git.git(origin, "checkout", "br1");
 83 |     await commit(origin, "br1 before merge %d", 5);
 84 |     await git.git(origin, "merge", "--no-ff", "main");
 85 |     await commit(origin, "br1 after merge %d", 10);
 86 |     await git.git(origin, "checkout", "main");
 87 |     await commit(origin, "main after merge %d", 10);
 88 |     await git.git(origin, "checkout", "-b", "br2", base);
 89 |     await commit(origin, "br2");
 90 |     await git.git(origin, "checkout", "br1");
 91 |     await git.git(origin, "merge", "--no-ff", "br2");
 92 | 
 93 |     const ws = `${path}/ws`;
 94 |     await git.clone(`${path}/origin`, ws, "br1");
 95 |     await git.fetch(ws, "main");
 96 |     expect(await git.fetchUntilMergeBase(ws, "main", 10000)).toBe(base);
 97 |   });
 98 | }, 15000);
 99 | 
100 | test("mergeCommits returns the correct commits", async () => {
101 |   await tmpdir(async path => {
102 |     await init(path);
103 |     await commit(path, "main %d", 2);
104 |     const head1 = await git.head(path);
105 |     await git.git(path, "checkout", "-b", "branch", "HEAD^");
106 |     const head2 = await git.head(path);
107 |     await git.git(path, "merge", "--no-ff", "main");
108 | 
109 |     const commits = await git.mergeCommits(path, "HEAD^");
110 |     expect(commits).toHaveLength(1);
111 |     expect(commits[0][0]).toBe(head2);
112 |     expect(commits[0][1]).toBe(head1);
113 |   });
114 | });
115 | 


--------------------------------------------------------------------------------
/lib/git.js:
--------------------------------------------------------------------------------
  1 | const { spawn } = require("child_process");
  2 | 
  3 | const { TimeoutError, logger } = require("./common");
  4 | 
  5 | class ExitError extends Error {
  6 |   constructor(message, code) {
  7 |     super(message);
  8 |     this.code = code;
  9 |   }
 10 | }
 11 | 
 12 | const FETCH_DEPTH = 10;
 13 | 
 14 | const COMMON_ARGS = [
 15 |   "-c",
 16 |   "user.name=GitHub",
 17 |   "-c",
 18 |   "user.email=noreply@github.com"
 19 | ];
 20 | 
 21 | function git(cwd, ...args) {
 22 |   const stdio = [
 23 |     "ignore",
 24 |     "pipe",
 25 |     logger.level === "trace" || logger.level === "debug" ? "inherit" : "ignore"
 26 |   ];
 27 |   // the URL passed to the clone command could contain a password!
 28 |   const command = args.includes("clone")
 29 |     ? "git clone"
 30 |     : `git ${args.join(" ")}`;
 31 |   logger.debug("Executing", command);
 32 |   return new Promise((resolve, reject) => {
 33 |     const proc = spawn(
 34 |       "git",
 35 |       COMMON_ARGS.concat(args.filter(a => a !== null)),
 36 |       { cwd, stdio }
 37 |     );
 38 |     const buffers = [];
 39 |     proc.stdout.on("data", data => buffers.push(data));
 40 |     proc.on("error", () => {
 41 |       reject(new Error(`command failed: ${command}`));
 42 |     });
 43 |     proc.on("exit", code => {
 44 |       if (code === 0) {
 45 |         const data = Buffer.concat(buffers);
 46 |         resolve(data.toString("utf8").trim());
 47 |       } else {
 48 |         reject(
 49 |           new ExitError(`command failed with code ${code}: ${command}`, code)
 50 |         );
 51 |       }
 52 |     });
 53 |   });
 54 | }
 55 | 
 56 | async function clone(from, to, branch) {
 57 |   await git(
 58 |     ".",
 59 |     "clone",
 60 |     "--quiet",
 61 |     "--shallow-submodules",
 62 |     "--branch",
 63 |     branch,
 64 |     "--depth",
 65 |     FETCH_DEPTH,
 66 |     from,
 67 |     to
 68 |   );
 69 | }
 70 | 
 71 | async function fetch(dir, branch) {
 72 |   await git(
 73 |     dir,
 74 |     "fetch",
 75 |     "--quiet",
 76 |     "--depth",
 77 |     FETCH_DEPTH,
 78 |     "origin",
 79 |     `${branch}:refs/remotes/origin/${branch}`
 80 |   );
 81 | }
 82 | 
 83 | async function fetchUntilMergeBase(dir, branch, timeout) {
 84 |   const maxTime = new Date().getTime() + timeout;
 85 |   const ref = `refs/remotes/origin/${branch}`;
 86 |   while (new Date().getTime() < maxTime) {
 87 |     const base = await mergeBase(dir, "HEAD", ref);
 88 |     if (base) {
 89 |       const bases = [base];
 90 |       const parents = await mergeCommits(dir, ref);
 91 |       let fetchMore = false;
 92 |       for (const parent of parents.flat()) {
 93 |         const b = await mergeBase(dir, parent, ref);
 94 |         if (b) {
 95 |           if (!bases.includes(b)) {
 96 |             bases.push(b);
 97 |           }
 98 |         } else {
 99 |           // we found a commit which does not have a common ancestor with
100 |           // the branch we want to merge, so we need to fetch more
101 |           fetchMore = true;
102 |           break;
103 |         }
104 |       }
105 |       if (!fetchMore) {
106 |         const commonBase = await mergeBase(dir, ...bases);
107 |         if (!commonBase) {
108 |           throw new Error(`failed to find common base for ${bases}`);
109 |         }
110 |         return commonBase;
111 |       }
112 |     }
113 |     await fetchDeepen(dir);
114 |   }
115 |   throw new TimeoutError();
116 | }
117 | 
118 | async function fetchDeepen(dir) {
119 |   await git(dir, "fetch", "--quiet", "--deepen", FETCH_DEPTH);
120 | }
121 | 
122 | async function mergeBase(dir, ...refs) {
123 |   if (refs.length === 1) {
124 |     return refs[0];
125 |   } else if (refs.length < 1) {
126 |     throw new Error("empty refs!");
127 |   }
128 |   let todo = refs;
129 |   try {
130 |     while (todo.length > 1) {
131 |       const base = await git(dir, "merge-base", todo[0], todo[1]);
132 |       todo = [base].concat(todo.slice(2));
133 |     }
134 |     return todo[0];
135 |   } catch (e) {
136 |     if (e instanceof ExitError && e.code === 1) {
137 |       return null;
138 |     } else {
139 |       throw e;
140 |     }
141 |   }
142 | }
143 | 
144 | async function mergeCommits(dir, ref) {
145 |   return (await git(dir, "rev-list", "--parents", `${ref}..HEAD`))
146 |     .split(/\n/g)
147 |     .map(line => line.split(/ /g).slice(1))
148 |     .filter(commit => commit.length > 1);
149 | }
150 | 
151 | async function head(dir) {
152 |   return await git(dir, "show-ref", "--head", "-s", "/HEAD");
153 | }
154 | 
155 | async function sha(dir, branch) {
156 |   return await git(dir, "show-ref", "-s", `refs/remotes/origin/${branch}`);
157 | }
158 | 
159 | async function rebase(dir, branch) {
160 |   return await git(dir, "rebase", "--quiet", "--autosquash", branch);
161 | }
162 | 
163 | async function push(dir, force, branch) {
164 |   return await git(
165 |     dir,
166 |     "push",
167 |     "--quiet",
168 |     force ? "--force-with-lease" : null,
169 |     "origin",
170 |     branch
171 |   );
172 | }
173 | 
174 | module.exports = {
175 |   ExitError,
176 |   git,
177 |   clone,
178 |   fetch,
179 |   fetchUntilMergeBase,
180 |   fetchDeepen,
181 |   mergeBase,
182 |   mergeCommits,
183 |   head,
184 |   sha,
185 |   rebase,
186 |   push
187 | };
188 | 


--------------------------------------------------------------------------------
/test/common.test.js:
--------------------------------------------------------------------------------
  1 | const { createConfig } = require("../lib/common");
  2 | 
  3 | test("createConfig", () => {
  4 |   const config = createConfig({
  5 |     UPDATE_LABELS: " required1,! block1, ! ,required2, !block2 ",
  6 |     MERGE_LABELS: "",
  7 |     MERGE_RETRIES: "3",
  8 |     BASE_BRANCHES: "dev,main"
  9 |   });
 10 |   const expected = {
 11 |     mergeMethod: "merge",
 12 |     mergeFilterAuthor: "",
 13 |     mergeLabels: {
 14 |       blocking: [],
 15 |       required: []
 16 |     },
 17 |     mergeMethodLabels: [],
 18 |     mergeMethodLabelRequired: false,
 19 |     mergeForks: true,
 20 |     mergeCommitMessage: "automatic",
 21 |     mergeCommitMessageRegex: "",
 22 |     mergeDeleteBranch: false,
 23 |     mergeDeleteBranchFilter: [],
 24 |     mergeErrorFail: false,
 25 |     mergeReadyState: ["clean", "has_hooks", "unknown", "unstable"],
 26 |     mergeRetries: 3,
 27 |     mergeRetrySleep: 5000,
 28 |     mergeRequiredApprovals: 0,
 29 |     mergeRemoveLabels: [],
 30 |     updateMethod: "merge",
 31 |     updateLabels: {
 32 |       blocking: ["block1", "block2"],
 33 |       required: ["required1", "required2"]
 34 |     },
 35 |     updateRetries: 1,
 36 |     updateRetrySleep: 5000,
 37 |     baseBranches: ["dev", "main"],
 38 |     pullRequest: null
 39 |   };
 40 |   expect(config).toEqual(expected);
 41 | });
 42 | 
 43 | test("createConfig with arbitrary pull request (as string)", () => {
 44 |   const config = createConfig({
 45 |     UPDATE_LABELS: " required1,! block1, ! ,required2, !block2 ",
 46 |     MERGE_LABELS: "",
 47 |     MERGE_RETRIES: "3",
 48 |     PULL_REQUEST: "144"
 49 |   });
 50 |   const expected = {
 51 |     mergeMethod: "merge",
 52 |     mergeFilterAuthor: "",
 53 |     mergeLabels: {
 54 |       blocking: [],
 55 |       required: []
 56 |     },
 57 |     mergeMethodLabels: [],
 58 |     mergeMethodLabelRequired: false,
 59 |     mergeForks: true,
 60 |     mergeCommitMessage: "automatic",
 61 |     mergeCommitMessageRegex: "",
 62 |     mergeDeleteBranch: false,
 63 |     mergeDeleteBranchFilter: [],
 64 |     mergeErrorFail: false,
 65 |     mergeReadyState: ["clean", "has_hooks", "unknown", "unstable"],
 66 |     mergeRetries: 3,
 67 |     mergeRetrySleep: 5000,
 68 |     mergeRequiredApprovals: 0,
 69 |     mergeRemoveLabels: [],
 70 |     updateMethod: "merge",
 71 |     updateLabels: {
 72 |       blocking: ["block1", "block2"],
 73 |       required: ["required1", "required2"]
 74 |     },
 75 |     updateRetries: 1,
 76 |     updateRetrySleep: 5000,
 77 |     baseBranches: [],
 78 |     pullRequest: {
 79 |       pullRequestNumber: 144
 80 |     }
 81 |   };
 82 |   expect(config).toEqual(expected);
 83 | });
 84 | 
 85 | test("createConfig with arbitrary pull request (as number)", () => {
 86 |   const config = createConfig({
 87 |     UPDATE_LABELS: " required1,! block1, ! ,required2, !block2 ",
 88 |     MERGE_LABELS: "",
 89 |     MERGE_RETRIES: "3",
 90 |     PULL_REQUEST: 144
 91 |   });
 92 |   const expected = {
 93 |     mergeMethod: "merge",
 94 |     mergeFilterAuthor: "",
 95 |     mergeLabels: {
 96 |       blocking: [],
 97 |       required: []
 98 |     },
 99 |     mergeMethodLabels: [],
100 |     mergeMethodLabelRequired: false,
101 |     mergeForks: true,
102 |     mergeCommitMessage: "automatic",
103 |     mergeCommitMessageRegex: "",
104 |     mergeDeleteBranch: false,
105 |     mergeDeleteBranchFilter: [],
106 |     mergeErrorFail: false,
107 |     mergeReadyState: ["clean", "has_hooks", "unknown", "unstable"],
108 |     mergeRetries: 3,
109 |     mergeRetrySleep: 5000,
110 |     mergeRequiredApprovals: 0,
111 |     mergeRemoveLabels: [],
112 |     updateMethod: "merge",
113 |     updateLabels: {
114 |       blocking: ["block1", "block2"],
115 |       required: ["required1", "required2"]
116 |     },
117 |     updateRetries: 1,
118 |     updateRetrySleep: 5000,
119 |     baseBranches: [],
120 |     pullRequest: {
121 |       pullRequestNumber: 144
122 |     }
123 |   };
124 |   expect(config).toEqual(expected);
125 | });
126 | 
127 | test("createConfig with arbitrary pull request in another repo", () => {
128 |   const config = createConfig({
129 |     UPDATE_LABELS: " required1,! block1, ! ,required2, !block2 ",
130 |     MERGE_LABELS: "",
131 |     MERGE_RETRIES: "3",
132 |     PULL_REQUEST: "pascalgn/automerge-action/144"
133 |   });
134 |   const expected = {
135 |     mergeMethod: "merge",
136 |     mergeFilterAuthor: "",
137 |     mergeLabels: {
138 |       blocking: [],
139 |       required: []
140 |     },
141 |     mergeMethodLabels: [],
142 |     mergeMethodLabelRequired: false,
143 |     mergeForks: true,
144 |     mergeCommitMessage: "automatic",
145 |     mergeCommitMessageRegex: "",
146 |     mergeDeleteBranch: false,
147 |     mergeDeleteBranchFilter: [],
148 |     mergeErrorFail: false,
149 |     mergeReadyState: ["clean", "has_hooks", "unknown", "unstable"],
150 |     mergeRetries: 3,
151 |     mergeRetrySleep: 5000,
152 |     mergeRequiredApprovals: 0,
153 |     mergeRemoveLabels: [],
154 |     updateMethod: "merge",
155 |     updateLabels: {
156 |       blocking: ["block1", "block2"],
157 |       required: ["required1", "required2"]
158 |     },
159 |     updateRetries: 1,
160 |     updateRetrySleep: 5000,
161 |     baseBranches: [],
162 |     pullRequest: {
163 |       repoOwner: "pascalgn",
164 |       repoName: "automerge-action",
165 |       pullRequestNumber: 144
166 |     }
167 |   };
168 |   expect(config).toEqual(expected);
169 | });
170 | 


--------------------------------------------------------------------------------
/lib/update.js:
--------------------------------------------------------------------------------
  1 | const { logger, tmpdir, sleep } = require("./common");
  2 | const git = require("./git");
  3 | 
  4 | const FETCH_TIMEOUT = 60000;
  5 | 
  6 | async function update(context, pullRequest) {
  7 |   if (skipPullRequest(context, pullRequest)) {
  8 |     return false;
  9 |   }
 10 | 
 11 |   logger.info(`Updating PR #${pullRequest.number} ${pullRequest.title}`);
 12 | 
 13 |   const { head } = pullRequest;
 14 | 
 15 |   const {
 16 |     token,
 17 |     octokit,
 18 |     config: { updateMethod, updateRetries, updateRetrySleep }
 19 |   } = context;
 20 | 
 21 |   let newSha;
 22 | 
 23 |   if (updateMethod === "merge") {
 24 |     newSha = await merge(octokit, updateRetries, updateRetrySleep, pullRequest);
 25 |   } else if (updateMethod === "rebase") {
 26 |     const { full_name } = head.repo;
 27 |     const url = `https://x-access-token:${token}@github.com/${full_name}.git`;
 28 |     newSha = await tmpdir(path => rebase(path, url, pullRequest));
 29 |   } else {
 30 |     throw new Error(`invalid update method: ${updateMethod}`);
 31 |   }
 32 | 
 33 |   if (newSha != null && newSha != head.sha) {
 34 |     head.sha = newSha;
 35 |     return true;
 36 |   } else {
 37 |     return false;
 38 |   }
 39 | }
 40 | 
 41 | function skipPullRequest(context, pullRequest) {
 42 |   const {
 43 |     config: { updateLabels }
 44 |   } = context;
 45 | 
 46 |   let skip = false;
 47 | 
 48 |   if (pullRequest.state !== "open") {
 49 |     logger.info("Skipping PR update, state is not open:", pullRequest.state);
 50 |     skip = true;
 51 |   }
 52 | 
 53 |   if (pullRequest.merged === true) {
 54 |     logger.info("Skipping PR update, already merged!");
 55 |     skip = true;
 56 |   }
 57 | 
 58 |   const labels = pullRequest.labels.map(label => label.name);
 59 | 
 60 |   for (const label of pullRequest.labels) {
 61 |     if (updateLabels.blocking.includes(label.name)) {
 62 |       logger.info("Skipping PR update, blocking label present:", label.name);
 63 |       skip = true;
 64 |     }
 65 |   }
 66 | 
 67 |   for (const required of updateLabels.required) {
 68 |     if (!labels.includes(required)) {
 69 |       logger.info("Skipping PR update, required label missing:", required);
 70 |       skip = true;
 71 |     }
 72 |   }
 73 | 
 74 |   return skip;
 75 | }
 76 | 
 77 | async function merge(octokit, updateRetries, updateRetrySleep, pullRequest) {
 78 |   const mergeableState = await pullRequestState(
 79 |     octokit,
 80 |     updateRetries,
 81 |     updateRetrySleep,
 82 |     pullRequest
 83 |   );
 84 |   if (mergeableState === "behind") {
 85 |     const headRef = pullRequest.head.ref;
 86 |     const baseRef = pullRequest.base.ref;
 87 | 
 88 |     logger.debug("Merging latest changes from", baseRef, "into", headRef);
 89 |     const { status, data } = await octokit.repos.merge({
 90 |       owner: pullRequest.base.repo.owner.login,
 91 |       repo: pullRequest.base.repo.name,
 92 |       base: headRef,
 93 |       head: baseRef
 94 |     });
 95 | 
 96 |     logger.trace("Merge result:", status, data);
 97 | 
 98 |     if (status === 204) {
 99 |       logger.info("No merge performed, branch is up to date!");
100 |       return pullRequest.head.sha;
101 |     } else {
102 |       logger.info("Merge succeeded, new HEAD:", headRef, data.sha);
103 |       return data.sha;
104 |     }
105 |   } else if (mergeableState === "clean" || mergeableState === "has_hooks") {
106 |     logger.info("No update necessary, mergeable_state:", mergeableState);
107 |     return pullRequest.head.sha;
108 |   } else {
109 |     logger.info("No update done due to PR mergeable_state", mergeableState);
110 |     return null;
111 |   }
112 | }
113 | 
114 | async function pullRequestState(
115 |   octokit,
116 |   updateRetries,
117 |   updateRetrySleep,
118 |   pullRequest
119 | ) {
120 |   if (pullRequest.mergeable_state != null) {
121 |     return pullRequest.mergeable_state;
122 |   } else {
123 |     logger.debug("Getting pull request info for", pullRequest.number, "...");
124 |     let { data: fullPullRequest } = await octokit.pulls.get({
125 |       owner: pullRequest.base.repo.owner.login,
126 |       repo: pullRequest.base.repo.name,
127 |       pull_number: pullRequest.number
128 |     });
129 | 
130 |     logger.trace("Full PR:", fullPullRequest);
131 | 
132 |     for (let run = 1; run <= updateRetries; run++) {
133 |       if (fullPullRequest.mergeable_state != null) {
134 |         break;
135 |       } else {
136 |         logger.info("Unknown PR state, mergeable_state: null");
137 |         logger.info(
138 |           `Retrying after ${updateRetrySleep} ms ... (${run}/${updateRetries})`
139 |         );
140 | 
141 |         await sleep(updateRetrySleep);
142 | 
143 |         const { data } = await octokit.pulls.get({
144 |           owner: pullRequest.base.repo.owner.login,
145 |           repo: pullRequest.base.repo.name,
146 |           pull_number: pullRequest.number,
147 |           headers: { "If-None-Match": "" }
148 |         });
149 |         fullPullRequest = data;
150 |       }
151 |     }
152 | 
153 |     return fullPullRequest.mergeable_state;
154 |   }
155 | }
156 | 
157 | async function rebase(dir, url, pullRequest) {
158 |   const headRef = pullRequest.head.ref;
159 |   const baseRef = pullRequest.base.ref;
160 | 
161 |   logger.debug("Cloning into", dir, `(${headRef})`);
162 |   await git.clone(url, dir, headRef);
163 | 
164 |   logger.debug("Fetching", baseRef, "...");
165 |   await git.fetch(dir, baseRef);
166 |   await git.fetchUntilMergeBase(dir, baseRef, FETCH_TIMEOUT);
167 | 
168 |   const head = await git.head(dir);
169 |   if (head !== pullRequest.head.sha) {
170 |     logger.info(`HEAD changed to ${head}, skipping`);
171 |     return null;
172 |   }
173 | 
174 |   logger.info(headRef, "HEAD:", head);
175 | 
176 |   const onto = await git.sha(dir, baseRef);
177 | 
178 |   logger.info("Rebasing onto", baseRef, onto);
179 |   await git.rebase(dir, onto);
180 | 
181 |   const newHead = await git.head(dir);
182 |   if (newHead === head) {
183 |     logger.info("Already up to date:", headRef, "->", baseRef, onto);
184 |   } else {
185 |     logger.debug("Pushing changes...");
186 |     await git.push(dir, true, headRef);
187 | 
188 |     logger.info("Updated:", headRef, head, "->", newHead);
189 |   }
190 | 
191 |   return newHead;
192 | }
193 | 
194 | module.exports = { update };
195 | 


--------------------------------------------------------------------------------
/lib/common.js:
--------------------------------------------------------------------------------
  1 | const util = require("util");
  2 | const process = require("process");
  3 | const fse = require("fs-extra");
  4 | const tmp = require("tmp");
  5 | 
  6 | const RESULT_SKIPPED = "skipped";
  7 | const RESULT_NOT_READY = "not_ready";
  8 | const RESULT_AUTHOR_FILTERED = "author_filtered";
  9 | const RESULT_MERGE_FAILED = "merge_failed";
 10 | const RESULT_MERGED = "merged";
 11 | 
 12 | class ClientError extends Error {}
 13 | 
 14 | class TimeoutError extends Error {}
 15 | 
 16 | function log(prefix, obj) {
 17 |   if (process.env.NODE_ENV !== "test") {
 18 |     const now = new Date().toISOString();
 19 |     const str = obj.map(o => (typeof o === "object" ? inspect(o) : o));
 20 |     if (prefix) {
 21 |       console.log.apply(console, [now, prefix, ...str]);
 22 |     } else {
 23 |       console.log.apply(console, [now, ...str]);
 24 |     }
 25 |   }
 26 | }
 27 | 
 28 | const logger = {
 29 |   level: "info",
 30 | 
 31 |   trace: (...str) => {
 32 |     if (logger.level === "trace") {
 33 |       log("TRACE", str);
 34 |     }
 35 |   },
 36 | 
 37 |   debug: (...str) => {
 38 |     if (logger.level === "trace" || logger.level === "debug") {
 39 |       log("DEBUG", str);
 40 |     }
 41 |   },
 42 | 
 43 |   info: (...str) => log("INFO ", str),
 44 | 
 45 |   error: (...str) => {
 46 |     if (str.length === 1 && str[0] instanceof Error) {
 47 |       if (logger.level === "trace" || logger.level === "debug") {
 48 |         log(null, [str[0].stack || str[0]]);
 49 |       } else {
 50 |         log("ERROR", [str[0].message || str[0]]);
 51 |       }
 52 |     } else {
 53 |       log("ERROR", str);
 54 |     }
 55 |   }
 56 | };
 57 | 
 58 | function inspect(obj) {
 59 |   return util.inspect(obj, false, null, true);
 60 | }
 61 | 
 62 | function createConfig(env = {}) {
 63 |   function parseMergeLabels(str, defaultValue) {
 64 |     const arr = (str == null ? defaultValue : str)
 65 |       .split(",")
 66 |       .map(s => s.trim());
 67 |     return {
 68 |       required: arr.filter(s => !s.startsWith("!") && s.length > 0),
 69 |       blocking: arr
 70 |         .filter(s => s.startsWith("!"))
 71 |         .map(s => s.substr(1).trim())
 72 |         .filter(s => s.length > 0)
 73 |     };
 74 |   }
 75 | 
 76 |   function parseLabelMethods(str) {
 77 |     return (str ? str.split(",") : []).map(lm => {
 78 |       const [label, method] = lm.split("=");
 79 |       if (!label || !method) {
 80 |         throw new Error(
 81 |           `Couldn't parse "${lm}" as "<label>=<method>" expression`
 82 |         );
 83 |       }
 84 |       return { label, method };
 85 |     });
 86 |   }
 87 | 
 88 |   function parseArray(str, defaultArray = []) {
 89 |     return str ? str.split(",") : defaultArray;
 90 |   }
 91 | 
 92 |   function parseBranches(str, defaultValue) {
 93 |     return (str == null ? defaultValue : str)
 94 |       .split(",")
 95 |       .map(s => s.trim())
 96 |       .filter(s => s);
 97 |   }
 98 | 
 99 |   function parsePositiveInt(name, defaultValue) {
100 |     const val = env[name];
101 |     if (val == null || val === "") {
102 |       return defaultValue;
103 |     } else {
104 |       const number = parseInt(val, 10);
105 |       if (isNaN(number) || number < 0) {
106 |         throw new ClientError(`Not a positive integer: ${val}`);
107 |       } else {
108 |         return number;
109 |       }
110 |     }
111 |   }
112 | 
113 |   function parsePullRequest(pullRequest) {
114 |     if (!pullRequest) {
115 |       return null;
116 |     }
117 | 
118 |     logger.info(`Parsing PULL_REQUEST input: ${pullRequest}`);
119 | 
120 |     const error = new ClientError(
121 |       `Invalid value provided for input PULL_REQUEST: ${pullRequest}. Must be a positive integer, optionally prefixed by a repo slug.`
122 |     );
123 | 
124 |     if (typeof pullRequest === "string") {
125 |       let repoOwner;
126 |       let repoName;
127 |       let pullRequestNumber;
128 | 
129 |       const destructuredPullRequest = pullRequest.split("/");
130 |       if (destructuredPullRequest.length === 3) {
131 |         [repoOwner, repoName, pullRequestNumber] = destructuredPullRequest;
132 |       } else if (destructuredPullRequest.length === 1) {
133 |         [pullRequestNumber] = destructuredPullRequest;
134 |       } else {
135 |         throw error;
136 |       }
137 | 
138 |       pullRequestNumber = parseInt(pullRequestNumber, 10);
139 |       if (isNaN(pullRequestNumber) || pullRequestNumber <= 0) {
140 |         throw error;
141 |       }
142 | 
143 |       return {
144 |         repoOwner,
145 |         repoName,
146 |         pullRequestNumber
147 |       };
148 |     }
149 | 
150 |     if (typeof pullRequest === "number" && pullRequest > 0) {
151 |       return { pullRequestNumber: pullRequest };
152 |     }
153 | 
154 |     throw error;
155 |   }
156 | 
157 |   const mergeLabels = parseMergeLabels(env.MERGE_LABELS, "automerge");
158 |   const mergeRemoveLabels = parseArray(env.MERGE_REMOVE_LABELS);
159 |   const mergeMethod = env.MERGE_METHOD || "merge";
160 |   const mergeForks = env.MERGE_FORKS !== "false";
161 |   const mergeCommitMessage = env.MERGE_COMMIT_MESSAGE || "automatic";
162 |   const mergeCommitMessageRegex = env.MERGE_COMMIT_MESSAGE_REGEX || "";
163 |   const mergeFilterAuthor = env.MERGE_FILTER_AUTHOR || "";
164 |   const mergeRetries = parsePositiveInt("MERGE_RETRIES", 6);
165 |   const mergeRetrySleep = parsePositiveInt("MERGE_RETRY_SLEEP", 5000);
166 |   const mergeRequiredApprovals = parsePositiveInt(
167 |     "MERGE_REQUIRED_APPROVALS",
168 |     0
169 |   );
170 |   const mergeDeleteBranch = env.MERGE_DELETE_BRANCH === "true";
171 |   const mergeDeleteBranchFilter = parseArray(env.MERGE_DELETE_BRANCH_FILTER);
172 |   const mergeMethodLabels = parseLabelMethods(env.MERGE_METHOD_LABELS);
173 |   const mergeMethodLabelRequired = env.MERGE_METHOD_LABEL_REQUIRED === "true";
174 |   const mergeErrorFail = env.MERGE_ERROR_FAIL === "true";
175 |   const mergeReadyState = parseArray(env.MERGE_READY_STATE, [
176 |     "clean",
177 |     "has_hooks",
178 |     "unknown",
179 |     "unstable"
180 |   ]);
181 | 
182 |   const updateLabels = parseMergeLabels(env.UPDATE_LABELS, "automerge");
183 |   const updateMethod = env.UPDATE_METHOD || "merge";
184 |   const updateRetries = parsePositiveInt("UPDATE_RETRIES", 1);
185 |   const updateRetrySleep = parsePositiveInt("UPDATE_RETRY_SLEEP", 5000);
186 | 
187 |   const baseBranches = parseBranches(env.BASE_BRANCHES, "");
188 | 
189 |   const pullRequest = parsePullRequest(env.PULL_REQUEST);
190 | 
191 |   return {
192 |     mergeLabels,
193 |     mergeRemoveLabels,
194 |     mergeMethod,
195 |     mergeMethodLabels,
196 |     mergeMethodLabelRequired,
197 |     mergeForks,
198 |     mergeCommitMessage,
199 |     mergeCommitMessageRegex,
200 |     mergeFilterAuthor,
201 |     mergeRetries,
202 |     mergeRetrySleep,
203 |     mergeRequiredApprovals,
204 |     mergeDeleteBranch,
205 |     mergeDeleteBranchFilter,
206 |     mergeErrorFail,
207 |     mergeReadyState,
208 |     updateLabels,
209 |     updateMethod,
210 |     updateRetries,
211 |     updateRetrySleep,
212 |     baseBranches,
213 |     pullRequest
214 |   };
215 | }
216 | 
217 | function tmpdir(callback) {
218 |   async function handle(path) {
219 |     try {
220 |       return await callback(path);
221 |     } finally {
222 |       await fse.remove(path);
223 |     }
224 |   }
225 | 
226 |   return new Promise((resolve, reject) => {
227 |     tmp.dir((err, path) => {
228 |       if (err) {
229 |         reject(err);
230 |       } else {
231 |         handle(path).then(resolve, reject);
232 |       }
233 |     });
234 |   });
235 | }
236 | 
237 | async function retry(retries, retrySleep, doInitial, doRetry, doFailed) {
238 |   const initialResult = await doInitial();
239 |   if (initialResult === "success") {
240 |     return true;
241 |   } else if (initialResult === "failure") {
242 |     return false;
243 |   } else if (initialResult !== "retry") {
244 |     throw new Error(`invalid return value: ${initialResult}`);
245 |   }
246 | 
247 |   for (let run = 1; run <= retries; run++) {
248 |     if (retrySleep === 0) {
249 |       logger.info(`Retrying ... (${run}/${retries})`);
250 |     } else {
251 |       logger.info(`Retrying after ${retrySleep} ms ... (${run}/${retries})`);
252 |       await sleep(retrySleep);
253 |     }
254 | 
255 |     const retryResult = await doRetry();
256 |     if (retryResult === "success") {
257 |       return true;
258 |     } else if (retryResult === "failure") {
259 |       return false;
260 |     } else if (retryResult !== "retry") {
261 |       throw new Error(`invalid return value: ${initialResult}`);
262 |     }
263 |   }
264 | 
265 |   await doFailed();
266 |   return false;
267 | }
268 | 
269 | function sleep(ms) {
270 |   return new Promise(resolve => setTimeout(resolve, ms));
271 | }
272 | 
273 | module.exports = {
274 |   ClientError,
275 |   TimeoutError,
276 |   logger,
277 |   createConfig,
278 |   tmpdir,
279 |   inspect,
280 |   retry,
281 |   sleep,
282 |   RESULT_SKIPPED,
283 |   RESULT_NOT_READY,
284 |   RESULT_AUTHOR_FILTERED,
285 |   RESULT_MERGE_FAILED,
286 |   RESULT_MERGED
287 | };
288 | 


--------------------------------------------------------------------------------
/test/merge.test.js:
--------------------------------------------------------------------------------
  1 | const { merge } = require("../lib/merge");
  2 | const { createConfig } = require("../lib/common");
  3 | const { pullRequest } = require("./common");
  4 | 
  5 | let octokit, mergeMethod;
  6 | 
  7 | beforeEach(() => {
  8 |   mergeMethod = undefined;
  9 |   octokit = {
 10 |     pulls: {
 11 |       merge: jest.fn(({ merge_method }) => (mergeMethod = merge_method)),
 12 |       get: () => {}
 13 |     }
 14 |   };
 15 | });
 16 | 
 17 | test("MERGE_COMMIT_MESSAGE with nested custom fields", async () => {
 18 |   // GIVEN
 19 |   const pr = pullRequest();
 20 |   pr.title = "This is the PR's title";
 21 |   pr.user = { login: "author" };
 22 | 
 23 |   const config = createConfig({
 24 |     MERGE_COMMIT_MESSAGE: "{pullRequest.title} @{pullRequest.user.login}"
 25 |   });
 26 | 
 27 |   // WHEN
 28 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
 29 | 
 30 |   // THEN
 31 |   expect(octokit.pulls.merge).toHaveBeenCalledWith(
 32 |     expect.objectContaining({
 33 |       commit_title: "This is the PR's title @author",
 34 |       commit_message: "",
 35 |       pull_number: 1,
 36 |       repo: "repository",
 37 |       sha: "2c3b4d5"
 38 |     })
 39 |   );
 40 | });
 41 | 
 42 | test("MERGE_COMMIT_MESSAGE_REGEX can be used to cut PR body", async () => {
 43 |   // GIVEN
 44 |   const pr = pullRequest();
 45 |   pr.body = [
 46 |     "PSA: This is the meaty part of the PR body.",
 47 |     "It also matches newlines.",
 48 |     "",
 49 |     "----",
 50 |     "",
 51 |     "Here is a silly license agreement."
 52 |   ].join("\n");
 53 | 
 54 |   const config = createConfig({
 55 |     MERGE_COMMIT_MESSAGE: "pull-request-title-and-description",
 56 |     MERGE_COMMIT_MESSAGE_REGEX: "PSA:(.*)^----"
 57 |   });
 58 | 
 59 |   // WHEN
 60 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
 61 | 
 62 |   // THEN
 63 |   expect(octokit.pulls.merge).toHaveBeenCalledWith(
 64 |     expect.objectContaining({
 65 |       commit_title:
 66 |         "Update README\n\nThis is the meaty part of the PR body.\nIt also matches newlines.",
 67 |       commit_message: "",
 68 |       pull_number: 1,
 69 |       repo: "repository",
 70 |       sha: "2c3b4d5"
 71 |     })
 72 |   );
 73 | });
 74 | 
 75 | test("Throw if MERGE_COMMIT_MESSAGE_REGEX is invalid", async () => {
 76 |   // GIVEN
 77 |   const pr = pullRequest();
 78 |   const config = createConfig({
 79 |     MERGE_COMMIT_MESSAGE: "pull-request-title-and-description",
 80 |     MERGE_COMMIT_MESSAGE_REGEX: ".*"
 81 |   });
 82 | 
 83 |   // WHEN
 84 |   expect(merge({ config, octokit }, pr, 0)).rejects.toThrow(
 85 |     "capturing subgroup"
 86 |   );
 87 | });
 88 | 
 89 | test("MERGE_FILTER_AUTHOR can be used to auto merge based on author", async () => {
 90 |   // GIVEN
 91 |   const pr = pullRequest();
 92 |   const author = "minime";
 93 |   const user = {
 94 |     login: author
 95 |   };
 96 |   pr.user = user;
 97 | 
 98 |   const config = createConfig({
 99 |     MERGE_COMMIT_MESSAGE: "pull-request-title-and-description",
100 |     MERGE_FILTER_AUTHOR: author
101 |   });
102 | 
103 |   // WHEN
104 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
105 | });
106 | 
107 | test("MERGE_FILTER_AUTHOR when not set should not affect anything", async () => {
108 |   // GIVEN
109 |   const pr = pullRequest();
110 |   const author = "minime";
111 |   const user = {
112 |     login: author
113 |   };
114 |   pr.user = user;
115 | 
116 |   const config = createConfig({
117 |     MERGE_COMMIT_MESSAGE: "pull-request-title-and-description"
118 |   });
119 | 
120 |   // WHEN
121 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
122 | });
123 | 
124 | test("MERGE_FILTER_AUTHOR when set but do not match current author should not merge", async () => {
125 |   // GIVEN
126 |   const pr = pullRequest();
127 |   const author = "notminime";
128 |   const user = {
129 |     login: author
130 |   };
131 |   pr.user = user;
132 | 
133 |   const config = createConfig({
134 |     MERGE_COMMIT_MESSAGE: "pull-request-title-and-description",
135 |     MERGE_FILTER_AUTHOR: "minime"
136 |   });
137 | 
138 |   // WHEN
139 |   expect(await merge({ config, octokit }, pr)).toEqual("author_filtered");
140 | });
141 | 
142 | test("Merge method can be set by env variable", async () => {
143 |   // GIVEN
144 |   const pr = pullRequest();
145 | 
146 |   const config = createConfig({
147 |     MERGE_METHOD: "rebase"
148 |   });
149 | 
150 |   // WHEN
151 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
152 |   expect(mergeMethod).toEqual("rebase");
153 | });
154 | 
155 | test("Merge method can be set by a merge method label", async () => {
156 |   // GIVEN
157 |   const pr = pullRequest();
158 |   pr.labels = [{ name: "autosquash" }, { name: "reallyautomerge" }];
159 | 
160 |   const config = createConfig({
161 |     MERGE_METHOD_LABELS: "automerge=merge,autosquash=squash,autorebase=rebase",
162 |     MERGE_METHOD: "merge",
163 |     MERGE_LABELS: "reallyautomerge"
164 |   });
165 | 
166 |   // WHEN
167 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
168 |   expect(mergeMethod).toEqual("squash");
169 | });
170 | 
171 | test("Merge method can be required", async () => {
172 |   // GIVEN
173 |   const pr = pullRequest();
174 |   pr.labels = [{ name: "autosquash" }];
175 | 
176 |   const config = createConfig({
177 |     MERGE_METHOD_LABELS: "automerge=merge,autosquash=squash,autorebase=rebase",
178 |     MERGE_METHOD_LABEL_REQUIRED: "true",
179 |     MERGE_METHOD: "merge",
180 |     MERGE_LABELS: ""
181 |   });
182 | 
183 |   // WHEN
184 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
185 |   expect(mergeMethod).toEqual("squash");
186 | });
187 | 
188 | test("Missing require merge method skips PR", async () => {
189 |   // GIVEN
190 |   const pr = pullRequest();
191 |   pr.labels = [{ name: "mergeme" }];
192 | 
193 |   const config = createConfig({
194 |     MERGE_METHOD_LABELS: "automerge=merge,autosquash=squash,autorebase=rebase",
195 |     MERGE_METHOD_LABEL_REQUIRED: "true",
196 |     MERGE_METHOD: "merge",
197 |     MERGE_LABELS: "mergeme"
198 |   });
199 | 
200 |   // WHEN
201 |   expect(await merge({ config, octokit }, pr)).toEqual("skipped");
202 | });
203 | 
204 | test("Merge method doesn't have to be required", async () => {
205 |   // GIVEN
206 |   const pr = pullRequest();
207 |   pr.labels = [{ name: "mergeme" }];
208 | 
209 |   const config = createConfig({
210 |     MERGE_METHOD_LABELS: "automerge=merge,autosquash=squash,autorebase=rebase",
211 |     MERGE_METHOD_LABEL_REQUIRED: "false",
212 |     MERGE_METHOD: "merge",
213 |     MERGE_LABELS: "mergeme"
214 |   });
215 | 
216 |   // WHEN
217 |   expect(await merge({ config, octokit }, pr)).toEqual("merged");
218 |   expect(mergeMethod).toEqual("merge");
219 | });
220 | 
221 | test("Multiple merge method labels throw an error", async () => {
222 |   // GIVEN
223 |   const pr = pullRequest();
224 |   pr.labels = [{ name: "automerge" }, { name: "autosquash" }];
225 | 
226 |   const config = createConfig({
227 |     MERGE_METHOD_LABELS: "automerge=merge,autosquash=squash,autorebase=rebase",
228 |     MERGE_METHOD_LABEL_REQUIRED: "true",
229 |     MERGE_METHOD: "merge"
230 |   });
231 | 
232 |   // WHEN
233 |   expect(merge({ config, octokit }, pr, 0)).rejects.toThrow(
234 |     "merge method labels"
235 |   );
236 | });
237 | 
238 | test("Base branch is listed then PR is merged", async () => {
239 |   // GIVEN
240 |   const pr = pullRequest();
241 |   pr.labels = [{ name: "mergeme" }];
242 | 
243 |   const config = createConfig({
244 |     MERGE_METHOD_LABELS: "automerge=merge,autosquash=squash,autorebase=rebase",
245 |     MERGE_METHOD_LABEL_REQUIRED: "false",
246 |     MERGE_METHOD: "merge",
247 |     MERGE_LABELS: "mergeme",
248 |     BASE_BRANCHES: "main,master,dev"
249 |   });
250 | 
251 |   // WHEN
252 |   expect(await merge({ config, octokit }, pr, 0)).toEqual("merged");
253 | });
254 | 
255 | test("Base branch not listed then PR is skipped", async () => {
256 |   // GIVEN
257 |   const pr = pullRequest();
258 |   pr.labels = [{ name: "mergeme" }];
259 | 
260 |   const config = createConfig({
261 |     MERGE_METHOD_LABELS: "automerge=merge,autosquash=squash,autorebase=rebase",
262 |     MERGE_METHOD_LABEL_REQUIRED: "false",
263 |     MERGE_METHOD: "merge",
264 |     MERGE_LABELS: "mergeme",
265 |     BASE_BRANCHES: "main,dev"
266 |   });
267 | 
268 |   // WHEN
269 |   expect(await merge({ config, octokit }, pr, 0)).toEqual("skipped");
270 | });
271 | 
272 | test("Unmergeable pull request fails action with non-zero exit code", async () => {
273 |   // GIVEN
274 |   const pr = pullRequest();
275 |   pr.mergeable_state = "blocked";
276 |   const config = createConfig({ MERGE_ERROR_FAIL: "true" });
277 |   octokit.pulls.get = async () => ({ data: pr });
278 | 
279 |   // Reduce retry wait period to 1ms to prevent test timeout
280 |   config.mergeRetrySleep = 1;
281 | 
282 |   // WHEN
283 |   const mockExit = jest
284 |     .spyOn(process, "exit")
285 |     .mockImplementationOnce(statusCode => {
286 |       throw new Error(
287 |         `process.exit was called with status code: ${statusCode}`
288 |       );
289 |     });
290 | 
291 |   try {
292 |     await merge({ config, octokit }, pr, 0);
293 |   } catch (e) {
294 |     expect(e).toEqual(new Error("process.exit was called with status code: 1"));
295 |     expect(mockExit).toHaveBeenCalledWith(1);
296 |     return;
297 |   }
298 | 
299 |   throw new Error("process.exit was not called!");
300 | });
301 | 


--------------------------------------------------------------------------------
/lib/merge.js:
--------------------------------------------------------------------------------
  1 | const resolvePath = require("object-resolve-path");
  2 | const {
  3 |   RESULT_MERGED,
  4 |   RESULT_MERGE_FAILED,
  5 |   RESULT_AUTHOR_FILTERED,
  6 |   RESULT_NOT_READY,
  7 |   RESULT_SKIPPED,
  8 |   logger,
  9 |   retry
 10 | } = require("./common");
 11 | 
 12 | const NOT_READY = ["dirty", "draft"];
 13 | 
 14 | const PR_PROPERTY = new RegExp("{pullRequest.([^}]+)}", "g");
 15 | 
 16 | async function merge(context, pullRequest, approvalCount) {
 17 |   if (skipPullRequest(context, pullRequest, approvalCount)) {
 18 |     return RESULT_SKIPPED;
 19 |   }
 20 | 
 21 |   logger.info(`Merging PR #${pullRequest.number} ${pullRequest.title}`);
 22 | 
 23 |   const {
 24 |     head: { sha }
 25 |   } = pullRequest;
 26 | 
 27 |   const {
 28 |     octokit,
 29 |     config: {
 30 |       mergeMethod: defaultMergeMethod,
 31 |       mergeMethodLabels,
 32 |       mergeCommitMessage,
 33 |       mergeCommitMessageRegex,
 34 |       mergeFilterAuthor,
 35 |       mergeRemoveLabels,
 36 |       mergeRetries,
 37 |       mergeRetrySleep,
 38 |       mergeErrorFail
 39 |     }
 40 |   } = context;
 41 | 
 42 |   const ready = await waitUntilReady(pullRequest, context);
 43 |   if (!ready) {
 44 |     return RESULT_NOT_READY;
 45 |   }
 46 | 
 47 |   if (mergeCommitMessageRegex) {
 48 |     // If we find the regex, use the first capturing subgroup as new body (discarding whitespace).
 49 |     const m = new RegExp(mergeCommitMessageRegex, "sm").exec(pullRequest.body);
 50 |     if (m) {
 51 |       if (m[1] === undefined) {
 52 |         throw new Error(
 53 |           `MERGE_COMMIT_MESSAGE_REGEX must contain a capturing subgroup: '${mergeCommitMessageRegex}'`
 54 |         );
 55 |       }
 56 |       pullRequest.body = m[1].trim();
 57 |     }
 58 |   }
 59 | 
 60 |   if (mergeFilterAuthor && pullRequest.user.login !== mergeFilterAuthor) {
 61 |     logger.info(
 62 |       `PR author '${pullRequest.user.login}' does not match filter:`,
 63 |       mergeFilterAuthor
 64 |     );
 65 |     return RESULT_AUTHOR_FILTERED;
 66 |   }
 67 | 
 68 |   const commitMessage = getCommitMessage(mergeCommitMessage, pullRequest);
 69 |   const mergeMethod = getMergeMethod(
 70 |     defaultMergeMethod,
 71 |     mergeMethodLabels,
 72 |     pullRequest
 73 |   );
 74 |   const merged = await tryMerge(
 75 |     octokit,
 76 |     pullRequest,
 77 |     sha,
 78 |     mergeMethod,
 79 |     mergeRetries,
 80 |     mergeRetrySleep,
 81 |     mergeErrorFail,
 82 |     commitMessage
 83 |   );
 84 |   if (!merged) {
 85 |     return RESULT_MERGE_FAILED;
 86 |   }
 87 | 
 88 |   logger.info("PR successfully merged!");
 89 | 
 90 |   try {
 91 |     await removeLabels(octokit, pullRequest, mergeRemoveLabels);
 92 |   } catch (e) {
 93 |     logger.info("Failed to remove labels:", e.message);
 94 |   }
 95 | 
 96 |   if (context.config.mergeDeleteBranch) {
 97 |     try {
 98 |       await deleteBranch(
 99 |         octokit,
100 |         pullRequest,
101 |         context.config.mergeDeleteBranchFilter
102 |       );
103 |     } catch (e) {
104 |       logger.info("Failed to delete branch:", e.message);
105 |     }
106 |   }
107 | 
108 |   return RESULT_MERGED;
109 | }
110 | 
111 | async function removeLabels(octokit, pullRequest, mergeRemoveLabels) {
112 |   const labels = pullRequest.labels.filter(label =>
113 |     mergeRemoveLabels.includes(label.name)
114 |   );
115 | 
116 |   if (labels.length < 1) {
117 |     logger.debug("No labels to remove.");
118 |     return;
119 |   }
120 | 
121 |   const labelNames = labels.map(label => label.name);
122 | 
123 |   logger.debug("Removing labels:", labelNames);
124 | 
125 |   for (const name of labelNames) {
126 |     await octokit.issues.removeLabel({
127 |       owner: pullRequest.base.repo.owner.login,
128 |       repo: pullRequest.base.repo.name,
129 |       issue_number: pullRequest.number,
130 |       name
131 |     });
132 |   }
133 | 
134 |   logger.info("Removed labels:", labelNames);
135 | }
136 | 
137 | async function deleteBranch(octokit, pullRequest, mergeDeleteBranchFilter) {
138 |   if (pullRequest.head.repo.full_name !== pullRequest.base.repo.full_name) {
139 |     logger.info("Branch is from external repository, skipping delete");
140 |     return;
141 |   }
142 | 
143 |   const branchQuery = {
144 |     owner: pullRequest.head.repo.owner.login,
145 |     repo: pullRequest.head.repo.name,
146 |     branch: pullRequest.head.ref
147 |   };
148 | 
149 |   const { data: branch } = await octokit.repos.getBranch(branchQuery);
150 | 
151 |   logger.trace("Branch:", branch);
152 | 
153 |   if (branch.protected) {
154 |     const { data: protectionRules } =
155 |       await octokit.repos.getBranchProtection(branchQuery);
156 |     if (
157 |       protectionRules.allow_deletions &&
158 |       !protectionRules.allow_deletions.enabled
159 |     ) {
160 |       logger.info("Branch is protected and cannot be deleted:", branch.name);
161 |       return;
162 |     }
163 |   } else if (mergeDeleteBranchFilter.includes(branch.name)) {
164 |     logger.info(
165 |       "Branch is in filter list and will not be deleted:",
166 |       branch.name
167 |     );
168 |   } else {
169 |     logger.debug("Deleting branch", branch.name, "...");
170 |     await octokit.git.deleteRef({
171 |       owner: pullRequest.head.repo.owner.login,
172 |       repo: pullRequest.head.repo.name,
173 |       ref: `heads/${branch.name}`
174 |     });
175 |     logger.info("Merged branch has been deleted:", branch.name);
176 |   }
177 | }
178 | 
179 | function skipPullRequest(context, pullRequest, approvalCount) {
180 |   const {
181 |     config: {
182 |       mergeForks,
183 |       mergeLabels,
184 |       mergeRequiredApprovals,
185 |       mergeMethodLabelRequired,
186 |       mergeMethodLabels,
187 |       baseBranches
188 |     }
189 |   } = context;
190 | 
191 |   let skip = false;
192 | 
193 |   if (pullRequest.state !== "open") {
194 |     logger.info("Skipping PR merge, state is not open:", pullRequest.state);
195 |     skip = true;
196 |   }
197 | 
198 |   if (pullRequest.merged === true) {
199 |     logger.info("Skipping PR merge, already merged!");
200 |     skip = true;
201 |   }
202 | 
203 |   if (pullRequest.head.repo.full_name !== pullRequest.base.repo.full_name) {
204 |     if (!mergeForks) {
205 |       logger.info("PR is a fork and MERGE_FORKS is false, skipping merge");
206 |       skip = true;
207 |     }
208 |   }
209 | 
210 |   const labels = pullRequest.labels.map(label => label.name);
211 | 
212 |   for (const label of pullRequest.labels) {
213 |     if (mergeLabels.blocking.includes(label.name)) {
214 |       logger.info("Skipping PR merge, blocking label present:", label.name);
215 |       skip = true;
216 |     }
217 |   }
218 | 
219 |   for (const required of mergeLabels.required) {
220 |     if (!labels.includes(required)) {
221 |       logger.info("Skipping PR merge, required label missing:", required);
222 |       skip = true;
223 |     }
224 |   }
225 | 
226 |   if (approvalCount < mergeRequiredApprovals) {
227 |     logger.info(
228 |       `Skipping PR merge, missing ${
229 |         mergeRequiredApprovals - approvalCount
230 |       } approvals`
231 |     );
232 |     skip = true;
233 |   }
234 | 
235 |   const numberMethodLabelsFound = mergeMethodLabels
236 |     .map(lm => labels.includes(lm.label))
237 |     .filter(x => x).length;
238 |   if (mergeMethodLabelRequired && numberMethodLabelsFound === 0) {
239 |     logger.info("Skipping PR merge, required merge method label missing");
240 |     skip = true;
241 |   }
242 | 
243 |   if (
244 |     baseBranches &&
245 |     baseBranches.length &&
246 |     !baseBranches.some(branch => branch === pullRequest.base.ref)
247 |   ) {
248 |     logger.info(
249 |       "Skipping PR merge, base branch is not in the provided list:",
250 |       baseBranches
251 |     );
252 |     skip = true;
253 |   }
254 | 
255 |   return skip;
256 | }
257 | 
258 | function waitUntilReady(pullRequest, context) {
259 |   const {
260 |     octokit,
261 |     config: { mergeRetries, mergeRetrySleep, mergeErrorFail }
262 |   } = context;
263 | 
264 |   return retry(
265 |     mergeRetries,
266 |     mergeRetrySleep,
267 |     () => checkReady(pullRequest, context),
268 |     async () => {
269 |       const pr = await getPullRequest(octokit, pullRequest);
270 |       return checkReady(pr, context);
271 |     },
272 |     () => failOrInfo(mergeRetries, mergeErrorFail)
273 |   );
274 | }
275 | 
276 | function checkReady(pullRequest, context) {
277 |   if (skipPullRequest(context, pullRequest)) {
278 |     return "failure";
279 |   }
280 |   return mergeable(pullRequest, context);
281 | }
282 | 
283 | function mergeable(pullRequest, context) {
284 |   const { mergeable_state } = pullRequest;
285 |   const {
286 |     config: { mergeReadyState }
287 |   } = context;
288 |   if (mergeable_state == null || mergeReadyState.includes(mergeable_state)) {
289 |     logger.info("PR is probably ready: mergeable_state:", mergeable_state);
290 |     return "success";
291 |   } else if (NOT_READY.includes(mergeable_state)) {
292 |     logger.info("PR not ready: mergeable_state:", mergeable_state);
293 |     return "failure";
294 |   } else {
295 |     logger.info("Current PR status: mergeable_state:", mergeable_state);
296 |     return "retry";
297 |   }
298 | }
299 | 
300 | async function getPullRequest(octokit, pullRequest) {
301 |   logger.debug("Getting latest PR data...");
302 |   const { data: pr } = await octokit.pulls.get({
303 |     owner: pullRequest.base.repo.owner.login,
304 |     repo: pullRequest.base.repo.name,
305 |     pull_number: pullRequest.number,
306 |     headers: { "If-None-Match": "" }
307 |   });
308 | 
309 |   logger.trace("PR:", pr);
310 | 
311 |   return pr;
312 | }
313 | 
314 | function tryMerge(
315 |   octokit,
316 |   pullRequest,
317 |   head,
318 |   mergeMethod,
319 |   mergeRetries,
320 |   mergeRetrySleep,
321 |   mergeErrorFail,
322 |   commitMessage
323 | ) {
324 |   return retry(
325 |     mergeRetries,
326 |     mergeRetrySleep,
327 |     () =>
328 |       mergePullRequest(octokit, pullRequest, head, mergeMethod, commitMessage),
329 |     async () => {
330 |       const pr = await getPullRequest(octokit, pullRequest);
331 |       if (pr.merged === true) {
332 |         return "success";
333 |       }
334 |       return mergePullRequest(
335 |         octokit,
336 |         pullRequest,
337 |         head,
338 |         mergeMethod,
339 |         commitMessage
340 |       );
341 |     },
342 |     () => failOrInfo(mergeRetries, mergeErrorFail)
343 |   );
344 | }
345 | 
346 | function failOrInfo(mergeRetries, mergeErrorFail) {
347 |   const message = `PR not ready to be merged after ${mergeRetries} tries`;
348 |   if (mergeErrorFail) {
349 |     logger.error(message);
350 |     process.exit(1);
351 |   } else {
352 |     logger.info(message);
353 |   }
354 | }
355 | 
356 | function getMergeMethod(defaultMergeMethod, mergeMethodLabels, pullRequest) {
357 |   const foundMergeMethodLabels = pullRequest.labels.flatMap(l =>
358 |     mergeMethodLabels.filter(ml => ml.label === l.name)
359 |   );
360 |   if (foundMergeMethodLabels.length > 0) {
361 |     const first = foundMergeMethodLabels[0];
362 |     if (foundMergeMethodLabels.length > 1) {
363 |       throw new Error(
364 |         `Discovered multiple merge method labels, only one is permitted!`
365 |       );
366 |     } else {
367 |       logger.info(
368 |         `Discovered ${first.label}, will merge with method ${first.method}`
369 |       );
370 |     }
371 |     return first.method;
372 |   }
373 |   return defaultMergeMethod;
374 | }
375 | 
376 | function getCommitMessage(mergeCommitMessage, pullRequest) {
377 |   if (mergeCommitMessage === "automatic") {
378 |     return undefined;
379 |   } else if (mergeCommitMessage === "pull-request-title") {
380 |     return pullRequest.title;
381 |   } else if (mergeCommitMessage === "pull-request-description") {
382 |     return pullRequest.body;
383 |   } else if (mergeCommitMessage === "pull-request-title-and-description") {
384 |     return (
385 |       pullRequest.title + (pullRequest.body ? "\n\n" + pullRequest.body : "")
386 |     );
387 |   } else {
388 |     return mergeCommitMessage.replace(PR_PROPERTY, (_, prProp) =>
389 |       resolvePath(pullRequest, prProp)
390 |     );
391 |   }
392 | }
393 | 
394 | async function mergePullRequest(
395 |   octokit,
396 |   pullRequest,
397 |   head,
398 |   mergeMethod,
399 |   commitMessage
400 | ) {
401 |   try {
402 |     await octokit.pulls.merge({
403 |       owner: pullRequest.base.repo.owner.login,
404 |       repo: pullRequest.base.repo.name,
405 |       pull_number: pullRequest.number,
406 |       commit_title: commitMessage,
407 |       commit_message: "",
408 |       sha: head,
409 |       merge_method: mergeMethod
410 |     });
411 |     return "success";
412 |   } catch (e) {
413 |     return checkMergeError(e);
414 |   }
415 | }
416 | 
417 | function checkMergeError(e) {
418 |   const m = e ? e.message || "" : "";
419 |   if (
420 |     m.includes("review is required by reviewers with write access") ||
421 |     m.includes("reviews are required by reviewers with write access") ||
422 |     m.includes("API rate limit exceeded")
423 |   ) {
424 |     logger.info("Cannot merge PR:", m);
425 |     return "failure";
426 |   } else {
427 |     logger.info("Failed to merge PR:", m);
428 |     return "retry";
429 |   }
430 | }
431 | 
432 | module.exports = { merge };
433 | 


--------------------------------------------------------------------------------
/lib/api.js:
--------------------------------------------------------------------------------
  1 | const process = require("process");
  2 | 
  3 | const { setOutput } = require("@actions/core");
  4 | 
  5 | const {
  6 |   ClientError,
  7 |   logger,
  8 |   RESULT_NOT_READY,
  9 |   RESULT_SKIPPED
 10 | } = require("./common");
 11 | const { update } = require("./update");
 12 | const { merge } = require("./merge");
 13 | const { branchName } = require("./util");
 14 | 
 15 | const GITHUB_SERVER_URL = process.env.GITHUB_SERVER_URL || "https://github.com";
 16 | 
 17 | const URL_REGEXP = new RegExp(
 18 |   `^${GITHUB_SERVER_URL}/([^/]+)/([^/]+)/(pull|tree)/([^ ]+)$`
 19 | );
 20 | 
 21 | const RELEVANT_ACTIONS = [
 22 |   "labeled",
 23 |   "unlabeled",
 24 |   "synchronize",
 25 |   "opened",
 26 |   "edited",
 27 |   "ready_for_review",
 28 |   "reopened",
 29 |   "unlocked"
 30 | ];
 31 | 
 32 | // we'll only update a few PRs at once:
 33 | const MAX_PR_COUNT = process.env.MAX_PR_COUNT || 10;
 34 | 
 35 | async function executeLocally(context, url) {
 36 |   const { octokit } = context;
 37 | 
 38 |   const m = url.match(URL_REGEXP);
 39 |   if (m && m[3] === "pull") {
 40 |     logger.debug("Getting PR data...");
 41 |     const { data: pull_request } = await octokit.pulls.get({
 42 |       owner: m[1],
 43 |       repo: m[2],
 44 |       pull_number: m[4],
 45 |       headers: { "If-None-Match": "" }
 46 |     });
 47 | 
 48 |     const event = {
 49 |       action: "opened",
 50 |       pull_request
 51 |     };
 52 | 
 53 |     return executeGitHubAction(context, "pull_request", event);
 54 |   } else if (m && m[3] === "tree") {
 55 |     const event = {
 56 |       ref: `refs/heads/${m[4]}`,
 57 |       repository: {
 58 |         name: m[2],
 59 |         owner: {
 60 |           name: m[1]
 61 |         }
 62 |       }
 63 |     };
 64 | 
 65 |     return executeGitHubAction(context, "push", event);
 66 |   } else {
 67 |     throw new ClientError(`invalid URL: ${url}`);
 68 |   }
 69 | }
 70 | 
 71 | async function executeGitHubAction(context, eventName, eventData) {
 72 |   const result = await executeGitHubActionImpl(context, eventName, eventData);
 73 |   logger.info("Action result:", result);
 74 | 
 75 |   let singleResult;
 76 |   if (Array.isArray(result)) {
 77 |     logger.info("More than one result, using  first result for action output");
 78 |     singleResult = result[0];
 79 |   } else if (result != null) {
 80 |     singleResult = result;
 81 |   } else {
 82 |     throw new Error("invalid result!");
 83 |   }
 84 | 
 85 |   const { mergeResult, pullRequestNumber } = singleResult || {};
 86 |   setOutput("mergeResult", mergeResult || RESULT_SKIPPED);
 87 |   setOutput("pullRequestNumber", pullRequestNumber || 0);
 88 | }
 89 | 
 90 | async function executeGitHubActionImpl(context, eventName, eventData) {
 91 |   logger.info("Event name:", eventName);
 92 |   logger.trace("Event data:", eventData);
 93 | 
 94 |   if (context.config.pullRequest != null) {
 95 |     return await handleArbitraryPullRequestUpdate(context, eventData);
 96 |   } else if (["push"].includes(eventName)) {
 97 |     await handleBaseBranchUpdate(context, eventName, eventData);
 98 |   } else if (["status"].includes(eventName)) {
 99 |     return await handleStatusUpdate(context, eventName, eventData);
100 |   } else if (["pull_request", "pull_request_target"].includes(eventName)) {
101 |     return await handlePullRequestUpdate(context, eventName, eventData);
102 |   } else if (["check_suite", "check_run", "workflow_run"].includes(eventName)) {
103 |     return await handleCheckOrWorkflowUpdate(context, eventName, eventData);
104 |   } else if (["pull_request_review"].includes(eventName)) {
105 |     return await handlePullRequestReviewUpdate(context, eventName, eventData);
106 |   } else if (["schedule", "repository_dispatch"].includes(eventName)) {
107 |     return await handleScheduleTriggerOrRepositoryDispatch(context);
108 |   } else if (["issue_comment"].includes(eventName)) {
109 |     return await handleIssueComment(context, eventName, eventData);
110 |   } else if (["workflow_dispatch"].includes(eventName)) {
111 |     return await handleWorkflowDispatch(context, eventName, eventData);
112 |   } else {
113 |     throw new ClientError(`invalid event type: ${eventName}`);
114 |   }
115 | }
116 | 
117 | async function handlePullRequestUpdate(context, eventName, event) {
118 |   const { action } = event;
119 |   if (!RELEVANT_ACTIONS.includes(action)) {
120 |     logger.info("Action ignored:", eventName, action);
121 |     return { mergeResult: RESULT_SKIPPED };
122 |   }
123 | 
124 |   const pullRequest = await fetchPullRequest(
125 |     context,
126 |     event.pull_request.base.repo,
127 |     event.pull_request
128 |   );
129 | 
130 |   return updateAndMerge(context, pullRequest);
131 | }
132 | 
133 | async function handleArbitraryPullRequestUpdate(context, eventData) {
134 |   const { config, octokit } = context;
135 | 
136 |   const repoOwner =
137 |     config.pullRequest.repoOwner || eventData.repository.owner.login;
138 |   const repoName = config.pullRequest.repoName || eventData.repository.name;
139 |   const { pullRequestNumber } = config.pullRequest;
140 | 
141 |   logger.info(`Looking for pull request #${pullRequestNumber}...`);
142 | 
143 |   try {
144 |     const { data: pullRequest } = await octokit.pulls.get({
145 |       owner: repoOwner,
146 |       repo: repoName,
147 |       pull_number: pullRequestNumber,
148 |       headers: { "If-None-Match": "" }
149 |     });
150 |     logger.trace("Full PR:", pullRequest);
151 | 
152 |     return updateAndMerge(context, pullRequest);
153 |   } catch (e) {
154 |     logger.error(
155 |       `Error fetching pull request: ${repoOwner}/${repoName}/${pullRequestNumber}`
156 |     );
157 |     throw e;
158 |   }
159 | }
160 | 
161 | async function handleCheckOrWorkflowUpdate(context, eventName, event) {
162 |   const { action } = event;
163 |   const eventType = eventName === "workflow_run" ? "workflow" : "status check";
164 |   if (action !== "completed") {
165 |     logger.info(`A ${eventType} is not yet complete:`, eventName);
166 |     return { mergeResult: RESULT_NOT_READY };
167 |   }
168 | 
169 |   const payload = event[eventName];
170 |   if (!payload) {
171 |     throw new Error(`failed to find payload for event type: ${eventName}`);
172 |   }
173 |   if (payload.conclusion !== "success") {
174 |     logger.info(`A ${eventType} completed unsuccessfully:`, eventName);
175 |     return { mergeResult: RESULT_NOT_READY };
176 |   }
177 | 
178 |   logger.info(`${eventType} completed successfully`);
179 | 
180 |   const eventPullRequest = payload.pull_requests[0];
181 |   if (eventPullRequest != null) {
182 |     const { octokit } = context;
183 |     const { data: pullRequest } = await octokit.request(eventPullRequest.url);
184 |     logger.trace("PR:", pullRequest);
185 | 
186 |     return updateAndMerge(context, pullRequest);
187 |   } else {
188 |     const branchName = payload.head_branch;
189 |     if (branchName != null) {
190 |       return await checkPullRequestsForBranches(context, event, branchName);
191 |     } else {
192 |       return await checkPullRequestsForHeadSha(
193 |         context,
194 |         event.repository,
195 |         payload.head_sha
196 |       );
197 |     }
198 |   }
199 | }
200 | 
201 | async function handlePullRequestReviewUpdate(context, eventName, event) {
202 |   const { action, review } = event;
203 |   if (action === "submitted") {
204 |     if (review.state === "approved") {
205 |       const pullRequest = await fetchPullRequest(
206 |         context,
207 |         event.pull_request.base.repo,
208 |         event.pull_request
209 |       );
210 |       return updateAndMerge(context, pullRequest);
211 |     } else {
212 |       logger.info("Review state is not approved:", review.state);
213 |       logger.info("Action ignored:", eventName, action);
214 |     }
215 |   } else {
216 |     logger.info("Action ignored:", eventName, action);
217 |   }
218 |   return { mergeResult: RESULT_SKIPPED };
219 | }
220 | 
221 | async function handleStatusUpdate(context, eventName, event) {
222 |   const { state, branches } = event;
223 |   if (state !== "success") {
224 |     logger.info("Event state ignored:", eventName, state);
225 |     return [];
226 |   }
227 | 
228 |   if (!branches || branches.length === 0) {
229 |     logger.info("No branches have been referenced:", eventName);
230 |     return [];
231 |   }
232 | 
233 |   let results = [];
234 |   for (const branch of branches) {
235 |     results = results.concat(
236 |       await checkPullRequestsForBranches(context, event, branch.name)
237 |     );
238 |   }
239 |   return results;
240 | }
241 | 
242 | async function checkPullRequestsForBranches(context, event, branchName) {
243 |   const { octokit } = context;
244 |   logger.debug("Listing pull requests for", branchName, "...");
245 |   const { data: pullRequests } = await octokit.pulls.list({
246 |     owner: event.repository.owner.login,
247 |     repo: event.repository.name,
248 |     state: "open",
249 |     head: `${event.repository.owner.login}:${branchName}`,
250 |     sort: "updated",
251 |     direction: "desc",
252 |     per_page: MAX_PR_COUNT
253 |   });
254 | 
255 |   logger.trace("PR list:", pullRequests);
256 | 
257 |   let updated = 0;
258 |   let results = [];
259 |   for (const pullRequest of pullRequests) {
260 |     try {
261 |       const result = await updateAndMerge(context, pullRequest);
262 |       results.push(result);
263 |       ++updated;
264 |     } catch (e) {
265 |       logger.error(e);
266 |     }
267 |   }
268 | 
269 |   if (updated === 0) {
270 |     logger.info("No PRs have been updated/merged");
271 |   }
272 |   return results;
273 | }
274 | 
275 | async function checkPullRequestsForHeadSha(context, repo, head_sha) {
276 |   const { octokit } = context;
277 |   logger.debug("Listing pull requests to look for", head_sha, "...");
278 |   const { data: pullRequests } = await octokit.pulls.list({
279 |     owner: repo.owner.login,
280 |     repo: repo.name,
281 |     state: "open",
282 |     sort: "updated",
283 |     direction: "desc",
284 |     per_page: MAX_PR_COUNT
285 |   });
286 | 
287 |   let updated = 0;
288 |   let foundPR = false;
289 |   let results = [];
290 |   for (const pullRequest of pullRequests) {
291 |     if (pullRequest.head.sha !== head_sha) {
292 |       continue;
293 |     }
294 |     foundPR = true;
295 |     try {
296 |       const result = await updateAndMerge(context, pullRequest);
297 |       results.push(result);
298 |       ++updated;
299 |     } catch (e) {
300 |       logger.error(e);
301 |     }
302 |   }
303 | 
304 |   if (updated === 0) {
305 |     logger.info("No PRs have been updated/merged");
306 |   }
307 |   if (!foundPR) {
308 |     logger.info(
309 |       "Could not find branch name in this status check result" +
310 |         " or corresponding PR from a forked repository"
311 |     );
312 |   }
313 |   return results;
314 | }
315 | 
316 | async function handleBaseBranchUpdate(context, eventName, event) {
317 |   const { ref } = event;
318 |   const branch = branchName(ref);
319 |   if (!branch) {
320 |     logger.info("Push does not reference a branch:", ref);
321 |     return;
322 |   }
323 | 
324 |   logger.debug("Updated branch:", branch);
325 | 
326 |   const { octokit } = context;
327 | 
328 |   logger.debug("Listing pull requests...");
329 |   const { data: pullRequests } = await octokit.pulls.list({
330 |     owner: event.repository.owner.login,
331 |     repo: event.repository.name,
332 |     state: "open",
333 |     base: branch,
334 |     sort: "updated",
335 |     direction: "desc",
336 |     per_page: MAX_PR_COUNT
337 |   });
338 | 
339 |   logger.trace("PR list:", pullRequests);
340 | 
341 |   if (pullRequests.length > 0) {
342 |     logger.info("Open PRs:", pullRequests.length);
343 |   } else {
344 |     logger.info("No open PRs for", branch);
345 |     return;
346 |   }
347 | 
348 |   let updated = 0;
349 |   for (const pullRequest of pullRequests) {
350 |     try {
351 |       await update(context, pullRequest);
352 |       updated++;
353 |     } catch (e) {
354 |       logger.error(e);
355 |     }
356 |   }
357 | 
358 |   if (updated > 0) {
359 |     logger.info(updated, "PRs based on", branch, "have been updated");
360 |   } else {
361 |     logger.info("No PRs based on", branch, "have been updated");
362 |   }
363 | }
364 | 
365 | async function handleWorkflowDispatch(context, eventName, event) {
366 |   const { ref } = event;
367 |   const branch = branchName(ref);
368 |   if (!branch) {
369 |     logger.info("Dispatch does not reference a branch:", ref);
370 |     return { mergeResult: RESULT_SKIPPED };
371 |   }
372 | 
373 |   return await checkPullRequestsForBranches(context, event, branch);
374 | }
375 | 
376 | async function handleScheduleTriggerOrRepositoryDispatch(context) {
377 |   const { octokit } = context;
378 | 
379 |   const { GITHUB_REPOSITORY } = process.env;
380 |   const [owner, repo] = (GITHUB_REPOSITORY || "").split("/", 2);
381 | 
382 |   if (!owner || !repo) {
383 |     throw new Error(`invalid GITHUB_REPOSITORY value: ${GITHUB_REPOSITORY}`);
384 |   }
385 | 
386 |   logger.debug("Listing pull requests ...");
387 |   const { data: pullRequests } = await octokit.pulls.list({
388 |     owner,
389 |     repo,
390 |     state: "open",
391 |     sort: "updated",
392 |     direction: "desc",
393 |     per_page: MAX_PR_COUNT
394 |   });
395 | 
396 |   logger.trace("PR list:", pullRequests);
397 | 
398 |   let updated = 0;
399 |   let results = [];
400 |   for (const pullRequest of pullRequests) {
401 |     try {
402 |       const result = await updateAndMerge(context, pullRequest);
403 |       results.push(result);
404 |       ++updated;
405 |     } catch (e) {
406 |       logger.error(e);
407 |     }
408 |   }
409 | 
410 |   if (updated === 0) {
411 |     logger.info("No PRs have been updated/merged");
412 |   }
413 |   return results;
414 | }
415 | 
416 | async function handleIssueComment(context, eventName, event) {
417 |   const { action, issue, repository } = event;
418 |   if (action === "created") {
419 |     if (issue.pull_request == null) {
420 |       logger.info("Comment not on a PR, skipping");
421 |     } else {
422 |       const pullRequest = await fetchPullRequest(context, repository, issue);
423 |       return updateAndMerge(context, pullRequest);
424 |     }
425 |   } else {
426 |     logger.info("Action ignored:", eventName, action);
427 |   }
428 |   return { mergeResult: RESULT_SKIPPED };
429 | }
430 | 
431 | async function fetchPullRequest(context, repository, issue) {
432 |   const { octokit } = context;
433 |   const { number } = issue;
434 | 
435 |   logger.debug("Getting pull request info for", number, "...");
436 |   let { data: pullRequest } = await octokit.pulls.get({
437 |     owner: repository.owner.login,
438 |     repo: repository.name,
439 |     pull_number: number,
440 |     headers: { "If-None-Match": "" }
441 |   });
442 | 
443 |   logger.trace("Full PR:", pullRequest);
444 |   return pullRequest;
445 | }
446 | 
447 | async function updateAndMerge(context, pullRequest) {
448 |   const approvalCount = await fetchApprovalReviewCount(context, pullRequest);
449 |   await update(context, pullRequest);
450 |   const mergeResult = await merge(context, pullRequest, approvalCount);
451 |   return { mergeResult, pullRequestNumber: pullRequest.number };
452 | }
453 | 
454 | async function fetchApprovalReviewCount(context, pullRequest) {
455 |   const {
456 |     octokit,
457 |     config: { mergeRequiredApprovals }
458 |   } = context;
459 |   const { number } = pullRequest;
460 | 
461 |   if (mergeRequiredApprovals === 0) {
462 |     // If we don't care about review approvals, let's short circuit.
463 |     return 0;
464 |   }
465 | 
466 |   logger.debug("Getting reviews for", number, "...");
467 |   const reviews = await octokit.paginate(octokit.pulls.listReviews, {
468 |     owner: pullRequest.base.repo.owner.login,
469 |     repo: pullRequest.base.repo.name,
470 |     pull_number: number
471 |   });
472 | 
473 |   const approvingReviewers = reviews
474 |     .filter(review => review.state === "APPROVED")
475 |     .map(review => review.user.login);
476 |   const uniqueApprovingReviewers = [...new Set(approvingReviewers)];
477 | 
478 |   logger.trace("Approval reviewers:", uniqueApprovingReviewers);
479 |   return uniqueApprovingReviewers.length;
480 | }
481 | 
482 | module.exports = { executeLocally, executeGitHubAction };
483 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # automerge-action
  2 | 
  3 | GitHub action to automatically merge pull requests when they are ready.
  4 | 
  5 | <img src="https://pascalgn.github.io/automerge-action/screenshot.svg" width="100%">
  6 | 
  7 | When added, this action will run the following tasks on pull requests with the
  8 | `automerge` label:
  9 | 
 10 | - Changes from the base branch will automatically be merged into the pull
 11 |   request (only when "Require branches to be up to date before merging"
 12 |   is enabled in the branch protection rules)
 13 | - When the pull request is ready, it will automatically be merged. The action
 14 |   will only wait for status checks that are marked as required in the branch
 15 |   protection rules
 16 | - Pull requests without any configured labels will be ignored
 17 | 
 18 | Labels, merge and update strategies are configurable, see [Configuration](#configuration).
 19 | 
 20 | A pull request is considered ready when:
 21 | 
 22 | 1. the required number of review approvals has been given (if enabled in the
 23 |    branch protection rules) and
 24 | 2. the required checks have passed (if enabled in the branch protection rules)
 25 |    and
 26 | 3. the pull request is up to date (if enabled in the branch protection rules)
 27 | 
 28 | After the pull request has been merged successfully, the branch will _not_ be
 29 | deleted. To delete branches after they are merged,
 30 | see [automatic deletion of branches](https://help.github.com/en/articles/managing-the-automatic-deletion-of-branches).
 31 | 
 32 | ----
 33 | 
 34 | **This functionality is now available directly in GitHub as [auto-merge](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/automatically-merging-a-pull-request).** Note that GitHub does not currently support auto-rebasing pull requests. The automerge-action project will still be maintained, but users are encouraged to switch to auto-merge for simple workflows, as it offers a faster and more stable experience.
 35 | 
 36 | ## Usage
 37 | 
 38 | Create a new `.github/workflows/automerge.yml` file:
 39 | 
 40 | ```yaml
 41 | name: automerge
 42 | on:
 43 |   pull_request:
 44 |     types:
 45 |       - labeled
 46 |       - unlabeled
 47 |       - synchronize
 48 |       - opened
 49 |       - edited
 50 |       - ready_for_review
 51 |       - reopened
 52 |       - unlocked
 53 |   pull_request_review:
 54 |     types:
 55 |       - submitted
 56 |   check_suite:
 57 |     types:
 58 |       - completed
 59 |   status: {}
 60 | jobs:
 61 |   automerge:
 62 |     runs-on: ubuntu-latest
 63 |     permissions:
 64 |       contents: write
 65 |       pull-requests: write
 66 |     steps:
 67 |       - id: automerge
 68 |         name: automerge
 69 |         uses: "pascalgn/automerge-action@v0.16.4"
 70 |         env:
 71 |           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
 72 | ```
 73 | 
 74 | For the latest version, see the [list of releases](https://github.com/pascalgn/automerge-action/releases).
 75 | 
 76 | ## Configuration
 77 | 
 78 | The following merge options are supported:
 79 | 
 80 | - `MERGE_LABELS`: The labels that need to be present for a pull request to be
 81 |   merged (using `MERGE_METHOD`). The default value is `automerge`.
 82 | 
 83 |   This option can be a comma-separated list of labels that will be checked. All
 84 |   labels in the list need to be present, otherwise the pull request will be
 85 |   skipped (until all labels are present). Labels prefixed with an exclamation
 86 |   mark (`!`) will block a pull request from being merged, when present.
 87 | 
 88 |   For example, when `automerge,!wip,!work in progress` is given,
 89 |   any pull requests with the labels `wip` or `work in progress` and any pull
 90 |   requests _without_ the label `automerge` will not be merged.
 91 |   Blocking labels take precedence, so if a pull request has both labels
 92 |   `wip` and `automerge`, it will not be merged.
 93 | 
 94 |   When an empty string (`""`) is given, all pull requests will be merged.
 95 | 
 96 | - `MERGE_REMOVE_LABELS`: The labels to automatically remove from a pull request
 97 |   once it has been merged by the action. The default value is `""`.
 98 | 
 99 |   This option can be a comma-separated list of labels that will be removed.
100 | 
101 |   When an empty string (`""`) is given, no labels will be removed.
102 | 
103 | - `MERGE_METHOD`: Which method to use when merging the pull request into
104 |   the base branch. Possible values are
105 |   [`merge`](https://help.github.com/en/articles/about-pull-request-merges) (create a merge commit),
106 |   [`rebase`](https://help.github.com/en/articles/about-pull-request-merges#rebase-and-merge-your-pull-request-commits)
107 |   (rebase all commits of the branch onto the base branch)
108 |   or [`squash`](https://help.github.com/en/articles/about-pull-request-merges#squash-and-merge-your-pull-request-commits)
109 |   (squash all commits into a single commit). The default option is `merge`.
110 | 
111 | - `MERGE_METHOD_LABELS`: Set to allow labels to determine the merge method
112 |   (see `MERGE_METHOD` for possible values).
113 |   For example, `automerge=merge,autosquash=squash`. If no such label is present,
114 |   the method set by `MERGE_METHOD` will be used. The default value is `""`.
115 | 
116 | - `MERGE_METHOD_LABEL_REQUIRED`: Set to `"true"` to require one of the
117 |   `MERGE_METHOD_LABELS` to be set. The default value is `"false"`.
118 | 
119 | - `MERGE_COMMIT_MESSAGE`: The commit message to use when merging the pull
120 |   request into the base branch. Possible values are `automatic` (use GitHub's
121 |   default message), `pull-request-title` (use the pull request's title),
122 |   `pull-request-description` (use the pull request's description),
123 |   `pull-request-title-and-description` or a literal
124 |   value with optional placeholders (for example `Auto merge {pullRequest.number}`).
125 |   The default value is `automatic`.
126 | 
127 | - `MERGE_COMMIT_MESSAGE_REGEX`: When using a commit message containing the
128 |   PR's body, use the first capturing subgroup from this regex as the commit
129 |   message. Can be used to separate content that should go with the commit into
130 |   the code base's history from boilerplate associated with the PR (licensing
131 |   notices, check lists, etc). For example, `(.*)^---` would keep everything up
132 |   until the first 3-dash line (horizontal rule in MarkDown) from the commit
133 |   message. The default value is empty, which disables this feature.
134 | 
135 | - `MERGE_FILTER_AUTHOR`: When set, only pull requests raised by this author
136 |   will be merged automatically.
137 | 
138 | - `MERGE_FORKS`: Whether merging from external repositories is enabled
139 |   or not. By default, pull requests with branches from forked repositories will
140 |   be merged the same way as pull requests with branches from the main
141 |   repository. Set this option to `"false"` to disable merging of pull requests
142 |   from forked repositories. The default value is `"true"`.
143 | 
144 | - `MERGE_RETRIES` and `MERGE_RETRY_SLEEP`: Sometimes, the pull request check
145 |   runs haven't finished yet, so the action will retry the merge after some time.
146 |   The number of retries can be set with `MERGE_RETRIES`.
147 |   The default number of retries is `6` and setting it to `0` disables the retry logic.
148 |   `MERGE_RETRY_SLEEP` sets the time to sleep between retries, in milliseconds.
149 |   The default is `5000` (5 seconds) and setting it to `0` disables sleeping
150 |   between retries.
151 | 
152 | - `MERGE_REQUIRED_APPROVALS`: Count of required approvals. The default is `0`.
153 | 
154 | - `MERGE_DELETE_BRANCH`: Automatic deletion of branches does not work for all
155 |   repositories. Set this option to `"true"` to automatically delete branches
156 |   after they have been merged. The default value is `"false"`.
157 | 
158 | - `MERGE_DELETE_BRANCH_FILTER`: A comma-separated list of branches that will not
159 |   be deleted. This is not the list of GitHub's protected branches, which are never
160 |   deleted, but an additional list of branches to protect. The default value is `""`.
161 | 
162 | - `MERGE_ERROR_FAIL`: Set this to `"true"` to have the action exit with error code `1`
163 |   when the pull request could not be merged successfully during a run.
164 | 
165 | - `MERGE_READY_STATE`: The state(s) of a pull request for which to attempt a
166 |   merge. This option can be a comma-separated list of states that will be considered mergeable.
167 |   The default value is `clean,has_hooks,unknown,unstable`.
168 | 
169 | The following update options are supported:
170 | 
171 | - `UPDATE_LABELS`: The labels that need to be present for a pull request to be
172 |   updated (using `UPDATE_METHOD`). The default value is `automerge`.
173 | 
174 |   Note that updating will only happen when the option "Require branches to be
175 |   up to date before merging" is enabled in the branch protection rules.
176 | 
177 |   This option can be a comma-separated list of labels, see the `MERGE_LABELS`
178 |   option for more information.
179 | 
180 | - `UPDATE_METHOD`: Which method to use when updating the pull request
181 |   to the base branch. Possible values are `merge` (create a merge commit) or
182 |   `rebase` (rebase the branch onto the head of the base branch). The default
183 |   option is `merge`.
184 | 
185 |   When the option is `rebase` and the [rebasing](https://git-scm.com/book/en/v2/Git-Branching-Rebasing)
186 |   failed, the action will exit with error code 1. This will also be visible
187 |   in the pull request page, with a message like "this branch has conflicts
188 |   that must be resolved" and a list of conflicting files.
189 | 
190 | - `UPDATE_RETRIES` and `UPDATE_RETRY_SLEEP`: Sometimes, the pull request check
191 |   runs haven't finished yet and the action doesn't know if an update is
192 |   necessary. To query the pull request state multiple times, the number of
193 |   retries can be set with `UPDATE_RETRIES`. The default number of retries is `1`
194 |   and setting it to `0` disables the retry logic.
195 |   `UPDATE_RETRY_SLEEP` sets the time to sleep between retries, in milliseconds.
196 |   The default is `5000` (5 seconds) and setting it to `0` disables sleeping
197 |   between retries.
198 | 
199 | Also, the following general options are supported:
200 | 
201 | - `GITHUB_TOKEN`: This should always be `"${{ secrets.GITHUB_TOKEN }}"`.
202 |   However, in some cases it can be useful to run this action as a certain user
203 |   (by default, it will run as `github-actions`). This can be useful if you want
204 |   to use the "Restrict who can push to matching branches" option in the branch
205 |   protection rules, for example.
206 | 
207 |   To use this setting for manually providing a token, you need to create a
208 |   [personal access token](https://help.github.com/en/articles/creating-a-personal-access-token-for-the-command-line)
209 |   for the user (make sure to check `public_repo` when it's a public repository
210 |   or `repo` when it's a private repository). All API requests (merge/rebase)
211 |   will then be executed as the specified user. The token should be kept secret,
212 |   so make sure to add it as secret, not as environment variable, in the GitHub
213 |   workflow file!
214 | 
215 | - `PULL_REQUEST`: If provided, this action will attempt to merge the specified pull request. By default, it will attempt to use the pull request specified in the GitHub context. If a pull request number is provided via this input, this action will search in the current repo for the provided pull request number. If you want to merge a pull request in another repo, just provide the repo slug before the pull request number, like `Some-Org/Some-Repo/1234`
216 | 
217 | - `BASE_BRANCHES`: If provided, the action will be restricted in terms of base branches. Can be comma-separated list of simple branch names (i.e `main,dev`).
218 | 
219 | - `MAX_PR_COUNT`: If provided, will control how many GitHub pull requests are considered in a single run. The default is `10`.
220 | 
221 | You can configure the environment variables in the workflow file like this:
222 | 
223 | ```yaml
224 |         env:
225 |           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
226 |           MERGE_LABELS: "automerge,!work in progress"
227 |           MERGE_REMOVE_LABELS: "automerge"
228 |           MERGE_METHOD: "squash"
229 |           MERGE_COMMIT_MESSAGE: "pull-request-description"
230 |           MERGE_FORKS: "false"
231 |           MERGE_RETRIES: "6"
232 |           MERGE_RETRY_SLEEP: "10000"
233 |           MERGE_REQUIRED_APPROVALS: "0"
234 |           UPDATE_LABELS: ""
235 |           UPDATE_METHOD: "rebase"
236 |           PULL_REQUEST: "1234"
237 |           MAX_PR_COUNT: "25"
238 | ```
239 | 
240 | ## Supported Events
241 | 
242 | Automerge can be configured to run for these events:
243 | 
244 | * `check_run`
245 | * `check_suite`
246 | * `issue_comment`
247 | * `pull_request_review`
248 | * `pull_request_target`
249 | * `pull_request`
250 | * `push`
251 | * `repository_dispatch`
252 | * `schedule`
253 | * `status`
254 | * `workflow_dispatch`
255 | * `workflow_run`
256 | 
257 | For more information on when these occur, see the Github documentation on [events that trigger workflows](https://docs.github.com/en/actions/reference/events-that-trigger-workflows) and [their payloads](https://docs.github.com/en/developers/webhooks-and-events/webhook-events-and-payloads).
258 | 
259 | ## Outputs
260 | 
261 | The action will provide two [outputs](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idoutputs):
262 | 
263 | * `mergeResult` - The result from the action run, one of `skipped`, `not_ready`, `author_filtered`, `merge_failed`, `merged`
264 | * `pullRequestNumber` - The pull request number (or `0`, if no pull request was affected)
265 | 
266 | Please note:
267 | 
268 | 1. When there are multiple pull requests affected, only the first one will be available in the output
269 | 2. To access these outputs, your workflow configuration must define an `id` for the automerge-action step
270 | 3. Unless a personal access token is used, this action will not trigger other actions, see [Limitations](#limitations)
271 | 
272 | Example usage:
273 | 
274 | ```yaml
275 |     steps:
276 |       - id: automerge
277 |         name: automerge
278 |         uses: "pascalgn/automerge-action@v0.15.6"
279 |         env:
280 |           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
281 |       - name: feedback
282 |         if: ${{ steps.automerge.outputs.mergeResult == 'merged' }}
283 |         run: |
284 |           echo "Pull request ${{ steps.automerge.outputs.pullRequestNumber }} merged!"
285 | ```
286 | 
287 | ## Limitations
288 | 
289 | - When a pull request is merged by this action, the merge will not trigger other GitHub workflows.
290 |   Similarly, when another GitHub workflow creates a pull request, this action will not be triggered.
291 |   This is because [an action in a workflow run can't trigger a new workflow run](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/events-that-trigger-workflows). However, the [`workflow_run`](https://docs.github.com/en/free-pro-team@latest/actions/reference/events-that-trigger-workflows#workflow_run) event is triggered as expected.
292 | - When [using a personal access token (PAT) to work around the above limitation](https://help.github.com/en/actions/reference/events-that-trigger-workflows#triggering-new-workflows-using-a-personal-access-token), note that when the user issuing the PAT is an administrator and [branch restrictions do not include administrators](https://help.github.com/en/github/administering-a-repository/enabling-branch-restrictions), pull requests may be merged even if they are not mergeable for non-administrators (see [#65](https://github.com/pascalgn/automerge-action/issues/65)).
293 | - Currently, there is no way to trigger workflows when the pull request branch
294 |   becomes out of date with the base branch. There is a request in the
295 |   [GitHub community forum](https://github.community/t5/GitHub-Actions/New-Trigger-is-mergable-state/m-p/36908).
296 | 
297 | ## Debugging
298 | 
299 | To run the action with full debug logging, update your workflow file as follows:
300 | 
301 | ```yaml
302 |       - name: automerge
303 |         uses: pascalgn/automerge-action@...
304 |         env:
305 |           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
306 |           LOG: "TRACE"  # or "DEBUG"
307 | ```
308 | 
309 | If you need to further debug the action, you can run it locally.
310 | 
311 | You will need a [personal access token](https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line).
312 | 
313 | Then clone this repository, create a file `.env` in the repository, such as:
314 | 
315 | ```
316 | GITHUB_TOKEN="123abc..."
317 | URL="https://github.com/pascalgn/repository-name/pull/123"
318 | ```
319 | 
320 | Install dependencies with `yarn`, and finally run `yarn it` (or `npm run it`).
321 | 
322 | ## License
323 | 
324 | [MIT](./LICENSE)
325 | 


--------------------------------------------------------------------------------
/dist/LICENSE:
--------------------------------------------------------------------------------
  1 | @actions/core
  2 | MIT
  3 | The MIT License (MIT)
  4 | 
  5 | Copyright 2019 GitHub
  6 | 
  7 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  8 | 
  9 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 10 | 
 11 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 12 | 
 13 | @actions/http-client
 14 | MIT
 15 | Actions Http Client for Node.js
 16 | 
 17 | Copyright (c) GitHub, Inc.
 18 | 
 19 | All rights reserved.
 20 | 
 21 | MIT License
 22 | 
 23 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
 24 | associated documentation files (the "Software"), to deal in the Software without restriction,
 25 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
 26 | and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
 27 | subject to the following conditions:
 28 | 
 29 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 30 | 
 31 | THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 32 | LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
 33 | NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 34 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 35 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 36 | 
 37 | 
 38 | @fastify/busboy
 39 | MIT
 40 | Copyright Brian White. All rights reserved.
 41 | 
 42 | Permission is hereby granted, free of charge, to any person obtaining a copy
 43 | of this software and associated documentation files (the "Software"), to
 44 | deal in the Software without restriction, including without limitation the
 45 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 46 | sell copies of the Software, and to permit persons to whom the Software is
 47 | furnished to do so, subject to the following conditions:
 48 | 
 49 | The above copyright notice and this permission notice shall be included in
 50 | all copies or substantial portions of the Software.
 51 | 
 52 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 53 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 54 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 55 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 56 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 57 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 58 | IN THE SOFTWARE.
 59 | 
 60 | @octokit/auth-token
 61 | MIT
 62 | The MIT License
 63 | 
 64 | Copyright (c) 2019 Octokit contributors
 65 | 
 66 | Permission is hereby granted, free of charge, to any person obtaining a copy
 67 | of this software and associated documentation files (the "Software"), to deal
 68 | in the Software without restriction, including without limitation the rights
 69 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 70 | copies of the Software, and to permit persons to whom the Software is
 71 | furnished to do so, subject to the following conditions:
 72 | 
 73 | The above copyright notice and this permission notice shall be included in
 74 | all copies or substantial portions of the Software.
 75 | 
 76 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 77 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 78 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 79 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 80 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 81 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 82 | THE SOFTWARE.
 83 | 
 84 | 
 85 | @octokit/core
 86 | MIT
 87 | The MIT License
 88 | 
 89 | Copyright (c) 2019 Octokit contributors
 90 | 
 91 | Permission is hereby granted, free of charge, to any person obtaining a copy
 92 | of this software and associated documentation files (the "Software"), to deal
 93 | in the Software without restriction, including without limitation the rights
 94 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 95 | copies of the Software, and to permit persons to whom the Software is
 96 | furnished to do so, subject to the following conditions:
 97 | 
 98 | The above copyright notice and this permission notice shall be included in
 99 | all copies or substantial portions of the Software.
100 | 
101 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
102 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
103 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
104 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
105 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
106 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
107 | THE SOFTWARE.
108 | 
109 | 
110 | @octokit/endpoint
111 | MIT
112 | The MIT License
113 | 
114 | Copyright (c) 2018 Octokit contributors
115 | 
116 | Permission is hereby granted, free of charge, to any person obtaining a copy
117 | of this software and associated documentation files (the "Software"), to deal
118 | in the Software without restriction, including without limitation the rights
119 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
120 | copies of the Software, and to permit persons to whom the Software is
121 | furnished to do so, subject to the following conditions:
122 | 
123 | The above copyright notice and this permission notice shall be included in
124 | all copies or substantial portions of the Software.
125 | 
126 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
127 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
128 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
129 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
130 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
131 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
132 | THE SOFTWARE.
133 | 
134 | 
135 | @octokit/graphql
136 | MIT
137 | The MIT License
138 | 
139 | Copyright (c) 2018 Octokit contributors
140 | 
141 | Permission is hereby granted, free of charge, to any person obtaining a copy
142 | of this software and associated documentation files (the "Software"), to deal
143 | in the Software without restriction, including without limitation the rights
144 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
145 | copies of the Software, and to permit persons to whom the Software is
146 | furnished to do so, subject to the following conditions:
147 | 
148 | The above copyright notice and this permission notice shall be included in
149 | all copies or substantial portions of the Software.
150 | 
151 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
152 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
153 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
154 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
155 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
156 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
157 | THE SOFTWARE.
158 | 
159 | 
160 | @octokit/plugin-paginate-rest
161 | MIT
162 | MIT License Copyright (c) 2019 Octokit contributors
163 | 
164 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
165 | 
166 | The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
167 | 
168 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
169 | 
170 | 
171 | @octokit/plugin-request-log
172 | MIT
173 | MIT License Copyright (c) 2020 Octokit contributors
174 | 
175 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
176 | 
177 | The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
178 | 
179 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
180 | 
181 | 
182 | @octokit/plugin-rest-endpoint-methods
183 | MIT
184 | MIT License Copyright (c) 2019 Octokit contributors
185 | 
186 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
187 | 
188 | The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
189 | 
190 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
191 | 
192 | 
193 | @octokit/request
194 | MIT
195 | The MIT License
196 | 
197 | Copyright (c) 2018 Octokit contributors
198 | 
199 | Permission is hereby granted, free of charge, to any person obtaining a copy
200 | of this software and associated documentation files (the "Software"), to deal
201 | in the Software without restriction, including without limitation the rights
202 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
203 | copies of the Software, and to permit persons to whom the Software is
204 | furnished to do so, subject to the following conditions:
205 | 
206 | The above copyright notice and this permission notice shall be included in
207 | all copies or substantial portions of the Software.
208 | 
209 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
210 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
211 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
212 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
213 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
214 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
215 | THE SOFTWARE.
216 | 
217 | 
218 | @octokit/request-error
219 | MIT
220 | The MIT License
221 | 
222 | Copyright (c) 2019 Octokit contributors
223 | 
224 | Permission is hereby granted, free of charge, to any person obtaining a copy
225 | of this software and associated documentation files (the "Software"), to deal
226 | in the Software without restriction, including without limitation the rights
227 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
228 | copies of the Software, and to permit persons to whom the Software is
229 | furnished to do so, subject to the following conditions:
230 | 
231 | The above copyright notice and this permission notice shall be included in
232 | all copies or substantial portions of the Software.
233 | 
234 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
235 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
236 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
237 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
238 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
239 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
240 | THE SOFTWARE.
241 | 
242 | 
243 | @octokit/rest
244 | MIT
245 | The MIT License
246 | 
247 | Copyright (c) 2012 Cloud9 IDE, Inc. (Mike de Boer)
248 | Copyright (c) 2017-2018 Octokit contributors
249 | 
250 | Permission is hereby granted, free of charge, to any person obtaining a copy
251 | of this software and associated documentation files (the "Software"), to deal
252 | in the Software without restriction, including without limitation the rights
253 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
254 | copies of the Software, and to permit persons to whom the Software is
255 | furnished to do so, subject to the following conditions:
256 | 
257 | The above copyright notice and this permission notice shall be included in
258 | all copies or substantial portions of the Software.
259 | 
260 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
261 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
262 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
263 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
264 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
265 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
266 | THE SOFTWARE.
267 | 
268 | 
269 | argparse
270 | Python-2.0
271 | A. HISTORY OF THE SOFTWARE
272 | ==========================
273 | 
274 | Python was created in the early 1990s by Guido van Rossum at Stichting
275 | Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
276 | as a successor of a language called ABC.  Guido remains Python's
277 | principal author, although it includes many contributions from others.
278 | 
279 | In 1995, Guido continued his work on Python at the Corporation for
280 | National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
281 | in Reston, Virginia where he released several versions of the
282 | software.
283 | 
284 | In May 2000, Guido and the Python core development team moved to
285 | BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
286 | year, the PythonLabs team moved to Digital Creations, which became
287 | Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
288 | https://www.python.org/psf/) was formed, a non-profit organization
289 | created specifically to own Python-related Intellectual Property.
290 | Zope Corporation was a sponsoring member of the PSF.
291 | 
292 | All Python releases are Open Source (see http://www.opensource.org for
293 | the Open Source Definition).  Historically, most, but not all, Python
294 | releases have also been GPL-compatible; the table below summarizes
295 | the various releases.
296 | 
297 |     Release         Derived     Year        Owner       GPL-
298 |                     from                                compatible? (1)
299 | 
300 |     0.9.0 thru 1.2              1991-1995   CWI         yes
301 |     1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
302 |     1.6             1.5.2       2000        CNRI        no
303 |     2.0             1.6         2000        BeOpen.com  no
304 |     1.6.1           1.6         2001        CNRI        yes (2)
305 |     2.1             2.0+1.6.1   2001        PSF         no
306 |     2.0.1           2.0+1.6.1   2001        PSF         yes
307 |     2.1.1           2.1+2.0.1   2001        PSF         yes
308 |     2.1.2           2.1.1       2002        PSF         yes
309 |     2.1.3           2.1.2       2002        PSF         yes
310 |     2.2 and above   2.1.1       2001-now    PSF         yes
311 | 
312 | Footnotes:
313 | 
314 | (1) GPL-compatible doesn't mean that we're distributing Python under
315 |     the GPL.  All Python licenses, unlike the GPL, let you distribute
316 |     a modified version without making your changes open source.  The
317 |     GPL-compatible licenses make it possible to combine Python with
318 |     other software that is released under the GPL; the others don't.
319 | 
320 | (2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
321 |     because its license has a choice of law clause.  According to
322 |     CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
323 |     is "not incompatible" with the GPL.
324 | 
325 | Thanks to the many outside volunteers who have worked under Guido's
326 | direction to make these releases possible.
327 | 
328 | 
329 | B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
330 | ===============================================================
331 | 
332 | PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
333 | --------------------------------------------
334 | 
335 | 1. This LICENSE AGREEMENT is between the Python Software Foundation
336 | ("PSF"), and the Individual or Organization ("Licensee") accessing and
337 | otherwise using this software ("Python") in source or binary form and
338 | its associated documentation.
339 | 
340 | 2. Subject to the terms and conditions of this License Agreement, PSF hereby
341 | grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
342 | analyze, test, perform and/or display publicly, prepare derivative works,
343 | distribute, and otherwise use Python alone or in any derivative version,
344 | provided, however, that PSF's License Agreement and PSF's notice of copyright,
345 | i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
346 | 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Python Software Foundation;
347 | All Rights Reserved" are retained in Python alone or in any derivative version
348 | prepared by Licensee.
349 | 
350 | 3. In the event Licensee prepares a derivative work that is based on
351 | or incorporates Python or any part thereof, and wants to make
352 | the derivative work available to others as provided herein, then
353 | Licensee hereby agrees to include in any such work a brief summary of
354 | the changes made to Python.
355 | 
356 | 4. PSF is making Python available to Licensee on an "AS IS"
357 | basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
358 | IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
359 | DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
360 | FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
361 | INFRINGE ANY THIRD PARTY RIGHTS.
362 | 
363 | 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
364 | FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
365 | A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
366 | OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
367 | 
368 | 6. This License Agreement will automatically terminate upon a material
369 | breach of its terms and conditions.
370 | 
371 | 7. Nothing in this License Agreement shall be deemed to create any
372 | relationship of agency, partnership, or joint venture between PSF and
373 | Licensee.  This License Agreement does not grant permission to use PSF
374 | trademarks or trade name in a trademark sense to endorse or promote
375 | products or services of Licensee, or any third party.
376 | 
377 | 8. By copying, installing or otherwise using Python, Licensee
378 | agrees to be bound by the terms and conditions of this License
379 | Agreement.
380 | 
381 | 
382 | BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
383 | -------------------------------------------
384 | 
385 | BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
386 | 
387 | 1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
388 | office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
389 | Individual or Organization ("Licensee") accessing and otherwise using
390 | this software in source or binary form and its associated
391 | documentation ("the Software").
392 | 
393 | 2. Subject to the terms and conditions of this BeOpen Python License
394 | Agreement, BeOpen hereby grants Licensee a non-exclusive,
395 | royalty-free, world-wide license to reproduce, analyze, test, perform
396 | and/or display publicly, prepare derivative works, distribute, and
397 | otherwise use the Software alone or in any derivative version,
398 | provided, however, that the BeOpen Python License is retained in the
399 | Software, alone or in any derivative version prepared by Licensee.
400 | 
401 | 3. BeOpen is making the Software available to Licensee on an "AS IS"
402 | basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
403 | IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
404 | DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
405 | FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
406 | INFRINGE ANY THIRD PARTY RIGHTS.
407 | 
408 | 4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
409 | SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
410 | AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
411 | DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
412 | 
413 | 5. This License Agreement will automatically terminate upon a material
414 | breach of its terms and conditions.
415 | 
416 | 6. This License Agreement shall be governed by and interpreted in all
417 | respects by the law of the State of California, excluding conflict of
418 | law provisions.  Nothing in this License Agreement shall be deemed to
419 | create any relationship of agency, partnership, or joint venture
420 | between BeOpen and Licensee.  This License Agreement does not grant
421 | permission to use BeOpen trademarks or trade names in a trademark
422 | sense to endorse or promote products or services of Licensee, or any
423 | third party.  As an exception, the "BeOpen Python" logos available at
424 | http://www.pythonlabs.com/logos.html may be used according to the
425 | permissions granted on that web page.
426 | 
427 | 7. By copying, installing or otherwise using the software, Licensee
428 | agrees to be bound by the terms and conditions of this License
429 | Agreement.
430 | 
431 | 
432 | CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
433 | ---------------------------------------
434 | 
435 | 1. This LICENSE AGREEMENT is between the Corporation for National
436 | Research Initiatives, having an office at 1895 Preston White Drive,
437 | Reston, VA 20191 ("CNRI"), and the Individual or Organization
438 | ("Licensee") accessing and otherwise using Python 1.6.1 software in
439 | source or binary form and its associated documentation.
440 | 
441 | 2. Subject to the terms and conditions of this License Agreement, CNRI
442 | hereby grants Licensee a nonexclusive, royalty-free, world-wide
443 | license to reproduce, analyze, test, perform and/or display publicly,
444 | prepare derivative works, distribute, and otherwise use Python 1.6.1
445 | alone or in any derivative version, provided, however, that CNRI's
446 | License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
447 | 1995-2001 Corporation for National Research Initiatives; All Rights
448 | Reserved" are retained in Python 1.6.1 alone or in any derivative
449 | version prepared by Licensee.  Alternately, in lieu of CNRI's License
450 | Agreement, Licensee may substitute the following text (omitting the
451 | quotes): "Python 1.6.1 is made available subject to the terms and
452 | conditions in CNRI's License Agreement.  This Agreement together with
453 | Python 1.6.1 may be located on the Internet using the following
454 | unique, persistent identifier (known as a handle): 1895.22/1013.  This
455 | Agreement may also be obtained from a proxy server on the Internet
456 | using the following URL: http://hdl.handle.net/1895.22/1013".
457 | 
458 | 3. In the event Licensee prepares a derivative work that is based on
459 | or incorporates Python 1.6.1 or any part thereof, and wants to make
460 | the derivative work available to others as provided herein, then
461 | Licensee hereby agrees to include in any such work a brief summary of
462 | the changes made to Python 1.6.1.
463 | 
464 | 4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
465 | basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
466 | IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
467 | DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
468 | FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
469 | INFRINGE ANY THIRD PARTY RIGHTS.
470 | 
471 | 5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
472 | 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
473 | A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
474 | OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
475 | 
476 | 6. This License Agreement will automatically terminate upon a material
477 | breach of its terms and conditions.
478 | 
479 | 7. This License Agreement shall be governed by the federal
480 | intellectual property law of the United States, including without
481 | limitation the federal copyright law, and, to the extent such
482 | U.S. federal law does not apply, by the law of the Commonwealth of
483 | Virginia, excluding Virginia's conflict of law provisions.
484 | Notwithstanding the foregoing, with regard to derivative works based
485 | on Python 1.6.1 that incorporate non-separable material that was
486 | previously distributed under the GNU General Public License (GPL), the
487 | law of the Commonwealth of Virginia shall govern this License
488 | Agreement only as to issues arising under or with respect to
489 | Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
490 | License Agreement shall be deemed to create any relationship of
491 | agency, partnership, or joint venture between CNRI and Licensee.  This
492 | License Agreement does not grant permission to use CNRI trademarks or
493 | trade name in a trademark sense to endorse or promote products or
494 | services of Licensee, or any third party.
495 | 
496 | 8. By clicking on the "ACCEPT" button where indicated, or by copying,
497 | installing or otherwise using Python 1.6.1, Licensee agrees to be
498 | bound by the terms and conditions of this License Agreement.
499 | 
500 |         ACCEPT
501 | 
502 | 
503 | CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
504 | --------------------------------------------------
505 | 
506 | Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
507 | The Netherlands.  All rights reserved.
508 | 
509 | Permission to use, copy, modify, and distribute this software and its
510 | documentation for any purpose and without fee is hereby granted,
511 | provided that the above copyright notice appear in all copies and that
512 | both that copyright notice and this permission notice appear in
513 | supporting documentation, and that the name of Stichting Mathematisch
514 | Centrum or CWI not be used in advertising or publicity pertaining to
515 | distribution of the software without specific, written prior
516 | permission.
517 | 
518 | STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
519 | THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
520 | FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
521 | FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
522 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
523 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
524 | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
525 | 
526 | 
527 | before-after-hook
528 | Apache-2.0
529 |                                  Apache License
530 |                            Version 2.0, January 2004
531 |                         http://www.apache.org/licenses/
532 | 
533 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
534 | 
535 |    1. Definitions.
536 | 
537 |       "License" shall mean the terms and conditions for use, reproduction,
538 |       and distribution as defined by Sections 1 through 9 of this document.
539 | 
540 |       "Licensor" shall mean the copyright owner or entity authorized by
541 |       the copyright owner that is granting the License.
542 | 
543 |       "Legal Entity" shall mean the union of the acting entity and all
544 |       other entities that control, are controlled by, or are under common
545 |       control with that entity. For the purposes of this definition,
546 |       "control" means (i) the power, direct or indirect, to cause the
547 |       direction or management of such entity, whether by contract or
548 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
549 |       outstanding shares, or (iii) beneficial ownership of such entity.
550 | 
551 |       "You" (or "Your") shall mean an individual or Legal Entity
552 |       exercising permissions granted by this License.
553 | 
554 |       "Source" form shall mean the preferred form for making modifications,
555 |       including but not limited to software source code, documentation
556 |       source, and configuration files.
557 | 
558 |       "Object" form shall mean any form resulting from mechanical
559 |       transformation or translation of a Source form, including but
560 |       not limited to compiled object code, generated documentation,
561 |       and conversions to other media types.
562 | 
563 |       "Work" shall mean the work of authorship, whether in Source or
564 |       Object form, made available under the License, as indicated by a
565 |       copyright notice that is included in or attached to the work
566 |       (an example is provided in the Appendix below).
567 | 
568 |       "Derivative Works" shall mean any work, whether in Source or Object
569 |       form, that is based on (or derived from) the Work and for which the
570 |       editorial revisions, annotations, elaborations, or other modifications
571 |       represent, as a whole, an original work of authorship. For the purposes
572 |       of this License, Derivative Works shall not include works that remain
573 |       separable from, or merely link (or bind by name) to the interfaces of,
574 |       the Work and Derivative Works thereof.
575 | 
576 |       "Contribution" shall mean any work of authorship, including
577 |       the original version of the Work and any modifications or additions
578 |       to that Work or Derivative Works thereof, that is intentionally
579 |       submitted to Licensor for inclusion in the Work by the copyright owner
580 |       or by an individual or Legal Entity authorized to submit on behalf of
581 |       the copyright owner. For the purposes of this definition, "submitted"
582 |       means any form of electronic, verbal, or written communication sent
583 |       to the Licensor or its representatives, including but not limited to
584 |       communication on electronic mailing lists, source code control systems,
585 |       and issue tracking systems that are managed by, or on behalf of, the
586 |       Licensor for the purpose of discussing and improving the Work, but
587 |       excluding communication that is conspicuously marked or otherwise
588 |       designated in writing by the copyright owner as "Not a Contribution."
589 | 
590 |       "Contributor" shall mean Licensor and any individual or Legal Entity
591 |       on behalf of whom a Contribution has been received by Licensor and
592 |       subsequently incorporated within the Work.
593 | 
594 |    2. Grant of Copyright License. Subject to the terms and conditions of
595 |       this License, each Contributor hereby grants to You a perpetual,
596 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
597 |       copyright license to reproduce, prepare Derivative Works of,
598 |       publicly display, publicly perform, sublicense, and distribute the
599 |       Work and such Derivative Works in Source or Object form.
600 | 
601 |    3. Grant of Patent License. Subject to the terms and conditions of
602 |       this License, each Contributor hereby grants to You a perpetual,
603 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
604 |       (except as stated in this section) patent license to make, have made,
605 |       use, offer to sell, sell, import, and otherwise transfer the Work,
606 |       where such license applies only to those patent claims licensable
607 |       by such Contributor that are necessarily infringed by their
608 |       Contribution(s) alone or by combination of their Contribution(s)
609 |       with the Work to which such Contribution(s) was submitted. If You
610 |       institute patent litigation against any entity (including a
611 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
612 |       or a Contribution incorporated within the Work constitutes direct
613 |       or contributory patent infringement, then any patent licenses
614 |       granted to You under this License for that Work shall terminate
615 |       as of the date such litigation is filed.
616 | 
617 |    4. Redistribution. You may reproduce and distribute copies of the
618 |       Work or Derivative Works thereof in any medium, with or without
619 |       modifications, and in Source or Object form, provided that You
620 |       meet the following conditions:
621 | 
622 |       (a) You must give any other recipients of the Work or
623 |           Derivative Works a copy of this License; and
624 | 
625 |       (b) You must cause any modified files to carry prominent notices
626 |           stating that You changed the files; and
627 | 
628 |       (c) You must retain, in the Source form of any Derivative Works
629 |           that You distribute, all copyright, patent, trademark, and
630 |           attribution notices from the Source form of the Work,
631 |           excluding those notices that do not pertain to any part of
632 |           the Derivative Works; and
633 | 
634 |       (d) If the Work includes a "NOTICE" text file as part of its
635 |           distribution, then any Derivative Works that You distribute must
636 |           include a readable copy of the attribution notices contained
637 |           within such NOTICE file, excluding those notices that do not
638 |           pertain to any part of the Derivative Works, in at least one
639 |           of the following places: within a NOTICE text file distributed
640 |           as part of the Derivative Works; within the Source form or
641 |           documentation, if provided along with the Derivative Works; or,
642 |           within a display generated by the Derivative Works, if and
643 |           wherever such third-party notices normally appear. The contents
644 |           of the NOTICE file are for informational purposes only and
645 |           do not modify the License. You may add Your own attribution
646 |           notices within Derivative Works that You distribute, alongside
647 |           or as an addendum to the NOTICE text from the Work, provided
648 |           that such additional attribution notices cannot be construed
649 |           as modifying the License.
650 | 
651 |       You may add Your own copyright statement to Your modifications and
652 |       may provide additional or different license terms and conditions
653 |       for use, reproduction, or distribution of Your modifications, or
654 |       for any such Derivative Works as a whole, provided Your use,
655 |       reproduction, and distribution of the Work otherwise complies with
656 |       the conditions stated in this License.
657 | 
658 |    5. Submission of Contributions. Unless You explicitly state otherwise,
659 |       any Contribution intentionally submitted for inclusion in the Work
660 |       by You to the Licensor shall be under the terms and conditions of
661 |       this License, without any additional terms or conditions.
662 |       Notwithstanding the above, nothing herein shall supersede or modify
663 |       the terms of any separate license agreement you may have executed
664 |       with Licensor regarding such Contributions.
665 | 
666 |    6. Trademarks. This License does not grant permission to use the trade
667 |       names, trademarks, service marks, or product names of the Licensor,
668 |       except as required for reasonable and customary use in describing the
669 |       origin of the Work and reproducing the content of the NOTICE file.
670 | 
671 |    7. Disclaimer of Warranty. Unless required by applicable law or
672 |       agreed to in writing, Licensor provides the Work (and each
673 |       Contributor provides its Contributions) on an "AS IS" BASIS,
674 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
675 |       implied, including, without limitation, any warranties or conditions
676 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
677 |       PARTICULAR PURPOSE. You are solely responsible for determining the
678 |       appropriateness of using or redistributing the Work and assume any
679 |       risks associated with Your exercise of permissions under this License.
680 | 
681 |    8. Limitation of Liability. In no event and under no legal theory,
682 |       whether in tort (including negligence), contract, or otherwise,
683 |       unless required by applicable law (such as deliberate and grossly
684 |       negligent acts) or agreed to in writing, shall any Contributor be
685 |       liable to You for damages, including any direct, indirect, special,
686 |       incidental, or consequential damages of any character arising as a
687 |       result of this License or out of the use or inability to use the
688 |       Work (including but not limited to damages for loss of goodwill,
689 |       work stoppage, computer failure or malfunction, or any and all
690 |       other commercial damages or losses), even if such Contributor
691 |       has been advised of the possibility of such damages.
692 | 
693 |    9. Accepting Warranty or Additional Liability. While redistributing
694 |       the Work or Derivative Works thereof, You may choose to offer,
695 |       and charge a fee for, acceptance of support, warranty, indemnity,
696 |       or other liability obligations and/or rights consistent with this
697 |       License. However, in accepting such obligations, You may act only
698 |       on Your own behalf and on Your sole responsibility, not on behalf
699 |       of any other Contributor, and only if You agree to indemnify,
700 |       defend, and hold each Contributor harmless for any liability
701 |       incurred by, or claims asserted against, such Contributor by reason
702 |       of your accepting any such warranty or additional liability.
703 | 
704 |    END OF TERMS AND CONDITIONS
705 | 
706 |    APPENDIX: How to apply the Apache License to your work.
707 | 
708 |       To apply the Apache License to your work, attach the following
709 |       boilerplate notice, with the fields enclosed by brackets "{}"
710 |       replaced with your own identifying information. (Don't include
711 |       the brackets!)  The text should be enclosed in the appropriate
712 |       comment syntax for the file format. We also recommend that a
713 |       file or class name and description of purpose be included on the
714 |       same "printed page" as the copyright notice for easier
715 |       identification within third-party archives.
716 | 
717 |    Copyright 2018 Gregor Martynus and other contributors.
718 | 
719 |    Licensed under the Apache License, Version 2.0 (the "License");
720 |    you may not use this file except in compliance with the License.
721 |    You may obtain a copy of the License at
722 | 
723 |        http://www.apache.org/licenses/LICENSE-2.0
724 | 
725 |    Unless required by applicable law or agreed to in writing, software
726 |    distributed under the License is distributed on an "AS IS" BASIS,
727 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
728 |    See the License for the specific language governing permissions and
729 |    limitations under the License.
730 | 
731 | 
732 | deprecation
733 | ISC
734 | The ISC License
735 | 
736 | Copyright (c) Gregor Martynus and contributors
737 | 
738 | Permission to use, copy, modify, and/or distribute this software for any
739 | purpose with or without fee is hereby granted, provided that the above
740 | copyright notice and this permission notice appear in all copies.
741 | 
742 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
743 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
744 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
745 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
746 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
747 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
748 | IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
749 | 
750 | 
751 | fs-extra
752 | MIT
753 | (The MIT License)
754 | 
755 | Copyright (c) 2011-2017 JP Richardson
756 | 
757 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
758 | (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,
759 |  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
760 |  furnished to do so, subject to the following conditions:
761 | 
762 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
763 | 
764 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
765 | WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
766 | OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
767 |  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
768 | 
769 | 
770 | graceful-fs
771 | ISC
772 | The ISC License
773 | 
774 | Copyright (c) 2011-2022 Isaac Z. Schlueter, Ben Noordhuis, and Contributors
775 | 
776 | Permission to use, copy, modify, and/or distribute this software for any
777 | purpose with or without fee is hereby granted, provided that the above
778 | copyright notice and this permission notice appear in all copies.
779 | 
780 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
781 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
782 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
783 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
784 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
785 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
786 | IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
787 | 
788 | 
789 | jsonfile
790 | MIT
791 | (The MIT License)
792 | 
793 | Copyright (c) 2012-2015, JP Richardson <jprichardson@gmail.com>
794 | 
795 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
796 | (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,
797 |  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
798 |  furnished to do so, subject to the following conditions:
799 | 
800 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
801 | 
802 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
803 | WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
804 | OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
805 |  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
806 | 
807 | 
808 | object-resolve-path
809 | MIT
810 | The MIT License (MIT)
811 | 
812 | Copyright (c) 2015 Jiri Spac
813 | 
814 | Permission is hereby granted, free of charge, to any person obtaining a copy
815 | of this software and associated documentation files (the "Software"), to deal
816 | in the Software without restriction, including without limitation the rights
817 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
818 | copies of the Software, and to permit persons to whom the Software is
819 | furnished to do so, subject to the following conditions:
820 | 
821 | The above copyright notice and this permission notice shall be included in all
822 | copies or substantial portions of the Software.
823 | 
824 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
825 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
826 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
827 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
828 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
829 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
830 | SOFTWARE.
831 | 
832 | 
833 | 
834 | once
835 | ISC
836 | The ISC License
837 | 
838 | Copyright (c) Isaac Z. Schlueter and Contributors
839 | 
840 | Permission to use, copy, modify, and/or distribute this software for any
841 | purpose with or without fee is hereby granted, provided that the above
842 | copyright notice and this permission notice appear in all copies.
843 | 
844 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
845 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
846 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
847 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
848 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
849 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
850 | IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
851 | 
852 | 
853 | tmp
854 | MIT
855 | The MIT License (MIT)
856 | 
857 | Copyright (c) 2014 KARASZI István
858 | 
859 | Permission is hereby granted, free of charge, to any person obtaining a copy
860 | of this software and associated documentation files (the "Software"), to deal
861 | in the Software without restriction, including without limitation the rights
862 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
863 | copies of the Software, and to permit persons to whom the Software is
864 | furnished to do so, subject to the following conditions:
865 | 
866 | The above copyright notice and this permission notice shall be included in all
867 | copies or substantial portions of the Software.
868 | 
869 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
870 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
871 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
872 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
873 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
874 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
875 | SOFTWARE.
876 | 
877 | 
878 | tunnel
879 | MIT
880 | The MIT License (MIT)
881 | 
882 | Copyright (c) 2012 Koichi Kobayashi
883 | 
884 | Permission is hereby granted, free of charge, to any person obtaining a copy
885 | of this software and associated documentation files (the "Software"), to deal
886 | in the Software without restriction, including without limitation the rights
887 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
888 | copies of the Software, and to permit persons to whom the Software is
889 | furnished to do so, subject to the following conditions:
890 | 
891 | The above copyright notice and this permission notice shall be included in
892 | all copies or substantial portions of the Software.
893 | 
894 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
895 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
896 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
897 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
898 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
899 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
900 | THE SOFTWARE.
901 | 
902 | 
903 | undici
904 | MIT
905 | MIT License
906 | 
907 | Copyright (c) Matteo Collina and Undici contributors
908 | 
909 | Permission is hereby granted, free of charge, to any person obtaining a copy
910 | of this software and associated documentation files (the "Software"), to deal
911 | in the Software without restriction, including without limitation the rights
912 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
913 | copies of the Software, and to permit persons to whom the Software is
914 | furnished to do so, subject to the following conditions:
915 | 
916 | The above copyright notice and this permission notice shall be included in all
917 | copies or substantial portions of the Software.
918 | 
919 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
920 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
921 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
922 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
923 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
924 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
925 | SOFTWARE.
926 | 
927 | 
928 | universal-user-agent
929 | ISC
930 | # [ISC License](https://spdx.org/licenses/ISC)
931 | 
932 | Copyright (c) 2018, Gregor Martynus (https://github.com/gr2m)
933 | 
934 | Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
935 | 
936 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
937 | 
938 | 
939 | universalify
940 | MIT
941 | (The MIT License)
942 | 
943 | Copyright (c) 2017, Ryan Zimmerman <opensrc@ryanzim.com>
944 | 
945 | Permission is hereby granted, free of charge, to any person obtaining a copy of
946 | this software and associated documentation files (the 'Software'), to deal in
947 | the Software without restriction, including without limitation the rights to
948 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
949 | the Software, and to permit persons to whom the Software is furnished to do so,
950 | subject to the following conditions:
951 | 
952 | The above copyright notice and this permission notice shall be included in all
953 | copies or substantial portions of the Software.
954 | 
955 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
956 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
957 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
958 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
959 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
960 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
961 | 
962 | 
963 | uuid
964 | MIT
965 | The MIT License (MIT)
966 | 
967 | Copyright (c) 2010-2020 Robert Kieffer and other contributors
968 | 
969 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
970 | 
971 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
972 | 
973 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
974 | 
975 | 
976 | wrappy
977 | ISC
978 | The ISC License
979 | 
980 | Copyright (c) Isaac Z. Schlueter and Contributors
981 | 
982 | Permission to use, copy, modify, and/or distribute this software for any
983 | purpose with or without fee is hereby granted, provided that the above
984 | copyright notice and this permission notice appear in all copies.
985 | 
986 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
987 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
988 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
989 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
990 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
991 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
992 | IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
993 | 


--------------------------------------------------------------------------------