@cloudsnorkel/cdk-github-runners
Version:
CDK construct to create GitHub Actions self-hosted runners. Creates ephemeral runners on demand. Easy to deploy and highly customizable.
1,464 lines (1,446 loc) • 162 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/universal-user-agent/index.js
function getUserAgent() {
if (typeof navigator === "object" && "userAgent" in navigator) {
return navigator.userAgent;
}
if (typeof process === "object" && process.version !== void 0) {
return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
}
return "<environment undetectable>";
}
var init_universal_user_agent = __esm({
"node_modules/universal-user-agent/index.js"() {
"use strict";
}
});
// node_modules/before-after-hook/lib/register.js
function register(state, name, method, options) {
if (typeof method !== "function") {
throw new Error("method for before hook must be a function");
}
if (!options) {
options = {};
}
if (Array.isArray(name)) {
return name.reverse().reduce((callback, name2) => {
return register.bind(null, state, name2, callback, options);
}, method)();
}
return Promise.resolve().then(() => {
if (!state.registry[name]) {
return method(options);
}
return state.registry[name].reduce((method2, registered) => {
return registered.hook.bind(null, method2, options);
}, method)();
});
}
var init_register = __esm({
"node_modules/before-after-hook/lib/register.js"() {
"use strict";
}
});
// node_modules/before-after-hook/lib/add.js
function addHook(state, kind, name, hook2) {
const orig = hook2;
if (!state.registry[name]) {
state.registry[name] = [];
}
if (kind === "before") {
hook2 = (method, options) => {
return Promise.resolve().then(orig.bind(null, options)).then(method.bind(null, options));
};
}
if (kind === "after") {
hook2 = (method, options) => {
let result;
return Promise.resolve().then(method.bind(null, options)).then((result_) => {
result = result_;
return orig(result, options);
}).then(() => {
return result;
});
};
}
if (kind === "error") {
hook2 = (method, options) => {
return Promise.resolve().then(method.bind(null, options)).catch((error) => {
return orig(error, options);
});
};
}
state.registry[name].push({
hook: hook2,
orig
});
}
var init_add = __esm({
"node_modules/before-after-hook/lib/add.js"() {
"use strict";
}
});
// node_modules/before-after-hook/lib/remove.js
function removeHook(state, name, method) {
if (!state.registry[name]) {
return;
}
const index = state.registry[name].map((registered) => {
return registered.orig;
}).indexOf(method);
if (index === -1) {
return;
}
state.registry[name].splice(index, 1);
}
var init_remove = __esm({
"node_modules/before-after-hook/lib/remove.js"() {
"use strict";
}
});
// node_modules/before-after-hook/index.js
function bindApi(hook2, state, name) {
const removeHookRef = bindable(removeHook, null).apply(
null,
name ? [state, name] : [state]
);
hook2.api = { remove: removeHookRef };
hook2.remove = removeHookRef;
["before", "error", "after", "wrap"].forEach((kind) => {
const args = name ? [state, kind, name] : [state, kind];
hook2[kind] = hook2.api[kind] = bindable(addHook, null).apply(null, args);
});
}
function Singular() {
const singularHookName = /* @__PURE__ */ Symbol("Singular");
const singularHookState = {
registry: {}
};
const singularHook = register.bind(null, singularHookState, singularHookName);
bindApi(singularHook, singularHookState, singularHookName);
return singularHook;
}
function Collection() {
const state = {
registry: {}
};
const hook2 = register.bind(null, state);
bindApi(hook2, state);
return hook2;
}
var bind, bindable, before_after_hook_default;
var init_before_after_hook = __esm({
"node_modules/before-after-hook/index.js"() {
"use strict";
init_register();
init_add();
init_remove();
bind = Function.bind;
bindable = bind.bind(bind);
before_after_hook_default = { Singular, Collection };
}
});
// node_modules/@octokit/endpoint/dist-bundle/index.js
function lowercaseKeys(object) {
if (!object) {
return {};
}
return Object.keys(object).reduce((newObj, key) => {
newObj[key.toLowerCase()] = object[key];
return newObj;
}, {});
}
function isPlainObject(value) {
if (typeof value !== "object" || value === null) return false;
if (Object.prototype.toString.call(value) !== "[object Object]") return false;
const proto = Object.getPrototypeOf(value);
if (proto === null) return true;
const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
}
function mergeDeep(defaults, options) {
const result = Object.assign({}, defaults);
Object.keys(options).forEach((key) => {
if (isPlainObject(options[key])) {
if (!(key in defaults)) Object.assign(result, { [key]: options[key] });
else result[key] = mergeDeep(defaults[key], options[key]);
} else {
Object.assign(result, { [key]: options[key] });
}
});
return result;
}
function removeUndefinedProperties(obj) {
for (const key in obj) {
if (obj[key] === void 0) {
delete obj[key];
}
}
return obj;
}
function merge(defaults, route, options) {
if (typeof route === "string") {
let [method, url] = route.split(" ");
options = Object.assign(url ? { method, url } : { url: method }, options);
} else {
options = Object.assign({}, route);
}
options.headers = lowercaseKeys(options.headers);
removeUndefinedProperties(options);
removeUndefinedProperties(options.headers);
const mergedOptions = mergeDeep(defaults || {}, options);
if (options.url === "/graphql") {
if (defaults && defaults.mediaType.previews?.length) {
mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(
(preview) => !mergedOptions.mediaType.previews.includes(preview)
).concat(mergedOptions.mediaType.previews);
}
mergedOptions.mediaType.previews = (mergedOptions.mediaType.previews || []).map((preview) => preview.replace(/-preview/, ""));
}
return mergedOptions;
}
function addQueryParameters(url, parameters) {
const separator = /\?/.test(url) ? "&" : "?";
const names = Object.keys(parameters);
if (names.length === 0) {
return url;
}
return url + separator + names.map((name) => {
if (name === "q") {
return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
}
return `${name}=${encodeURIComponent(parameters[name])}`;
}).join("&");
}
function removeNonChars(variableName) {
return variableName.replace(/(?:^\W+)|(?:(?<!\W)\W+$)/g, "").split(/,/);
}
function extractUrlVariableNames(url) {
const matches = url.match(urlVariableRegex);
if (!matches) {
return [];
}
return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
}
function omit(object, keysToOmit) {
const result = { __proto__: null };
for (const key of Object.keys(object)) {
if (keysToOmit.indexOf(key) === -1) {
result[key] = object[key];
}
}
return result;
}
function encodeReserved(str) {
return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
if (!/%[0-9A-Fa-f]/.test(part)) {
part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
}
return part;
}).join("");
}
function encodeUnreserved(str) {
return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
});
}
function encodeValue(operator, value, key) {
value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
if (key) {
return encodeUnreserved(key) + "=" + value;
} else {
return value;
}
}
function isDefined(value) {
return value !== void 0 && value !== null;
}
function isKeyOperator(operator) {
return operator === ";" || operator === "&" || operator === "?";
}
function getValues(context, operator, key, modifier) {
var value = context[key], result = [];
if (isDefined(value) && value !== "") {
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
value = value.toString();
if (modifier && modifier !== "*") {
value = value.substring(0, parseInt(modifier, 10));
}
result.push(
encodeValue(operator, value, isKeyOperator(operator) ? key : "")
);
} else {
if (modifier === "*") {
if (Array.isArray(value)) {
value.filter(isDefined).forEach(function(value2) {
result.push(
encodeValue(operator, value2, isKeyOperator(operator) ? key : "")
);
});
} else {
Object.keys(value).forEach(function(k) {
if (isDefined(value[k])) {
result.push(encodeValue(operator, value[k], k));
}
});
}
} else {
const tmp = [];
if (Array.isArray(value)) {
value.filter(isDefined).forEach(function(value2) {
tmp.push(encodeValue(operator, value2));
});
} else {
Object.keys(value).forEach(function(k) {
if (isDefined(value[k])) {
tmp.push(encodeUnreserved(k));
tmp.push(encodeValue(operator, value[k].toString()));
}
});
}
if (isKeyOperator(operator)) {
result.push(encodeUnreserved(key) + "=" + tmp.join(","));
} else if (tmp.length !== 0) {
result.push(tmp.join(","));
}
}
}
} else {
if (operator === ";") {
if (isDefined(value)) {
result.push(encodeUnreserved(key));
}
} else if (value === "" && (operator === "&" || operator === "?")) {
result.push(encodeUnreserved(key) + "=");
} else if (value === "") {
result.push("");
}
}
return result;
}
function parseUrl(template) {
return {
expand: expand.bind(null, template)
};
}
function expand(template, context) {
var operators = ["+", "#", ".", "/", ";", "?", "&"];
template = template.replace(
/\{([^\{\}]+)\}|([^\{\}]+)/g,
function(_, expression, literal) {
if (expression) {
let operator = "";
const values = [];
if (operators.indexOf(expression.charAt(0)) !== -1) {
operator = expression.charAt(0);
expression = expression.substr(1);
}
expression.split(/,/g).forEach(function(variable) {
var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
});
if (operator && operator !== "+") {
var separator = ",";
if (operator === "?") {
separator = "&";
} else if (operator !== "#") {
separator = operator;
}
return (values.length !== 0 ? operator : "") + values.join(separator);
} else {
return values.join(",");
}
} else {
return encodeReserved(literal);
}
}
);
if (template === "/") {
return template;
} else {
return template.replace(/\/$/, "");
}
}
function parse(options) {
let method = options.method.toUpperCase();
let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
let headers = Object.assign({}, options.headers);
let body;
let parameters = omit(options, [
"method",
"baseUrl",
"url",
"headers",
"request",
"mediaType"
]);
const urlVariableNames = extractUrlVariableNames(url);
url = parseUrl(url).expand(parameters);
if (!/^http/.test(url)) {
url = options.baseUrl + url;
}
const omittedParameters = Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl");
const remainingParameters = omit(parameters, omittedParameters);
const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
if (!isBinaryRequest) {
if (options.mediaType.format) {
headers.accept = headers.accept.split(/,/).map(
(format) => format.replace(
/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/,
`application/vnd$1$2.${options.mediaType.format}`
)
).join(",");
}
if (url.endsWith("/graphql")) {
if (options.mediaType.previews?.length) {
const previewsFromAcceptHeader = headers.accept.match(/(?<![\w-])[\w-]+(?=-preview)/g) || [];
headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map((preview) => {
const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
return `application/vnd.github.${preview}-preview${format}`;
}).join(",");
}
}
}
if (["GET", "HEAD"].includes(method)) {
url = addQueryParameters(url, remainingParameters);
} else {
if ("data" in remainingParameters) {
body = remainingParameters.data;
} else {
if (Object.keys(remainingParameters).length) {
body = remainingParameters;
}
}
}
if (!headers["content-type"] && typeof body !== "undefined") {
headers["content-type"] = "application/json; charset=utf-8";
}
if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
body = "";
}
return Object.assign(
{ method, url, headers },
typeof body !== "undefined" ? { body } : null,
options.request ? { request: options.request } : null
);
}
function endpointWithDefaults(defaults, route, options) {
return parse(merge(defaults, route, options));
}
function withDefaults(oldDefaults, newDefaults) {
const DEFAULTS2 = merge(oldDefaults, newDefaults);
const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2);
return Object.assign(endpoint2, {
DEFAULTS: DEFAULTS2,
defaults: withDefaults.bind(null, DEFAULTS2),
merge: merge.bind(null, DEFAULTS2),
parse
});
}
var VERSION, userAgent, DEFAULTS, urlVariableRegex, endpoint;
var init_dist_bundle = __esm({
"node_modules/@octokit/endpoint/dist-bundle/index.js"() {
"use strict";
init_universal_user_agent();
VERSION = "0.0.0-development";
userAgent = `octokit-endpoint.js/${VERSION} ${getUserAgent()}`;
DEFAULTS = {
method: "GET",
baseUrl: "https://api.github.com",
headers: {
accept: "application/vnd.github.v3+json",
"user-agent": userAgent
},
mediaType: {
format: ""
}
};
urlVariableRegex = /\{[^{}}]+\}/g;
endpoint = withDefaults(null, DEFAULTS);
}
});
// node_modules/fast-content-type-parse/index.js
var require_fast_content_type_parse = __commonJS({
"node_modules/fast-content-type-parse/index.js"(exports2, module2) {
"use strict";
var NullObject = function NullObject2() {
};
NullObject.prototype = /* @__PURE__ */ Object.create(null);
var paramRE = /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\v\u0020-\u00ff])*"|[!#$%&'*+.^\w`|~-]+) */gu;
var quotedPairRE = /\\([\v\u0020-\u00ff])/gu;
var mediaTypeRE = /^[!#$%&'*+.^\w|~-]+\/[!#$%&'*+.^\w|~-]+$/u;
var defaultContentType = { type: "", parameters: new NullObject() };
Object.freeze(defaultContentType.parameters);
Object.freeze(defaultContentType);
function parse2(header) {
if (typeof header !== "string") {
throw new TypeError("argument header is required and must be a string");
}
let index = header.indexOf(";");
const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
if (mediaTypeRE.test(type) === false) {
throw new TypeError("invalid media type");
}
const result = {
type: type.toLowerCase(),
parameters: new NullObject()
};
if (index === -1) {
return result;
}
let key;
let match;
let value;
paramRE.lastIndex = index;
while (match = paramRE.exec(header)) {
if (match.index !== index) {
throw new TypeError("invalid parameter format");
}
index += match[0].length;
key = match[1].toLowerCase();
value = match[2];
if (value[0] === '"') {
value = value.slice(1, value.length - 1);
quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1"));
}
result.parameters[key] = value;
}
if (index !== header.length) {
throw new TypeError("invalid parameter format");
}
return result;
}
function safeParse2(header) {
if (typeof header !== "string") {
return defaultContentType;
}
let index = header.indexOf(";");
const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
if (mediaTypeRE.test(type) === false) {
return defaultContentType;
}
const result = {
type: type.toLowerCase(),
parameters: new NullObject()
};
if (index === -1) {
return result;
}
let key;
let match;
let value;
paramRE.lastIndex = index;
while (match = paramRE.exec(header)) {
if (match.index !== index) {
return defaultContentType;
}
index += match[0].length;
key = match[1].toLowerCase();
value = match[2];
if (value[0] === '"') {
value = value.slice(1, value.length - 1);
quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1"));
}
result.parameters[key] = value;
}
if (index !== header.length) {
return defaultContentType;
}
return result;
}
module2.exports.default = { parse: parse2, safeParse: safeParse2 };
module2.exports.parse = parse2;
module2.exports.safeParse = safeParse2;
module2.exports.defaultContentType = defaultContentType;
}
});
// node_modules/@octokit/request-error/dist-src/index.js
var RequestError;
var init_dist_src = __esm({
"node_modules/@octokit/request-error/dist-src/index.js"() {
"use strict";
RequestError = class extends Error {
name;
/**
* http status code
*/
status;
/**
* Request options that lead to the error.
*/
request;
/**
* Response object if a response was received
*/
response;
constructor(message, statusCode, options) {
super(message, { cause: options.cause });
this.name = "HttpError";
this.status = Number.parseInt(statusCode);
if (Number.isNaN(this.status)) {
this.status = 0;
}
if ("response" in options) {
this.response = options.response;
}
const requestCopy = Object.assign({}, options.request);
if (options.request.headers.authorization) {
requestCopy.headers = Object.assign({}, options.request.headers, {
authorization: options.request.headers.authorization.replace(
/(?<! ) .*$/,
" [REDACTED]"
)
});
}
requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
this.request = requestCopy;
}
};
}
});
// node_modules/@octokit/request/dist-bundle/index.js
function isPlainObject2(value) {
if (typeof value !== "object" || value === null) return false;
if (Object.prototype.toString.call(value) !== "[object Object]") return false;
const proto = Object.getPrototypeOf(value);
if (proto === null) return true;
const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
}
async function fetchWrapper(requestOptions) {
const fetch = requestOptions.request?.fetch || globalThis.fetch;
if (!fetch) {
throw new Error(
"fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing"
);
}
const log = requestOptions.request?.log || console;
const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false;
const body = isPlainObject2(requestOptions.body) || Array.isArray(requestOptions.body) ? JSON.stringify(requestOptions.body) : requestOptions.body;
const requestHeaders = Object.fromEntries(
Object.entries(requestOptions.headers).map(([name, value]) => [
name,
String(value)
])
);
let fetchResponse;
try {
fetchResponse = await fetch(requestOptions.url, {
method: requestOptions.method,
body,
redirect: requestOptions.request?.redirect,
headers: requestHeaders,
signal: requestOptions.request?.signal,
// duplex must be set if request.body is ReadableStream or Async Iterables.
// See https://fetch.spec.whatwg.org/#dom-requestinit-duplex.
...requestOptions.body && { duplex: "half" }
});
} catch (error) {
let message = "Unknown Error";
if (error instanceof Error) {
if (error.name === "AbortError") {
error.status = 500;
throw error;
}
message = error.message;
if (error.name === "TypeError" && "cause" in error) {
if (error.cause instanceof Error) {
message = error.cause.message;
} else if (typeof error.cause === "string") {
message = error.cause;
}
}
}
const requestError = new RequestError(message, 500, {
request: requestOptions
});
requestError.cause = error;
throw requestError;
}
const status = fetchResponse.status;
const url = fetchResponse.url;
const responseHeaders = {};
for (const [key, value] of fetchResponse.headers) {
responseHeaders[key] = value;
}
const octokitResponse = {
url,
status,
headers: responseHeaders,
data: ""
};
if ("deprecation" in responseHeaders) {
const matches = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/);
const deprecationLink = matches && matches.pop();
log.warn(
`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`
);
}
if (status === 204 || status === 205) {
return octokitResponse;
}
if (requestOptions.method === "HEAD") {
if (status < 400) {
return octokitResponse;
}
throw new RequestError(fetchResponse.statusText, status, {
response: octokitResponse,
request: requestOptions
});
}
if (status === 304) {
octokitResponse.data = await getResponseData(fetchResponse);
throw new RequestError("Not modified", status, {
response: octokitResponse,
request: requestOptions
});
}
if (status >= 400) {
octokitResponse.data = await getResponseData(fetchResponse);
throw new RequestError(toErrorMessage(octokitResponse.data), status, {
response: octokitResponse,
request: requestOptions
});
}
octokitResponse.data = parseSuccessResponseBody ? await getResponseData(fetchResponse) : fetchResponse.body;
return octokitResponse;
}
async function getResponseData(response2) {
const contentType = response2.headers.get("content-type");
if (!contentType) {
return response2.text().catch(noop);
}
const mimetype = (0, import_fast_content_type_parse.safeParse)(contentType);
if (isJSONResponse(mimetype)) {
let text = "";
try {
text = await response2.text();
return JSON.parse(text);
} catch (err) {
return text;
}
} else if (mimetype.type.startsWith("text/") || mimetype.parameters.charset?.toLowerCase() === "utf-8") {
return response2.text().catch(noop);
} else {
return response2.arrayBuffer().catch(
/* v8 ignore next -- @preserve */
() => new ArrayBuffer(0)
);
}
}
function isJSONResponse(mimetype) {
return mimetype.type === "application/json" || mimetype.type === "application/scim+json";
}
function toErrorMessage(data) {
if (typeof data === "string") {
return data;
}
if (data instanceof ArrayBuffer) {
return "Unknown error";
}
if ("message" in data) {
const suffix = "documentation_url" in data ? ` - ${data.documentation_url}` : "";
return Array.isArray(data.errors) ? `${data.message}: ${data.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${data.message}${suffix}`;
}
return `Unknown error: ${JSON.stringify(data)}`;
}
function withDefaults2(oldEndpoint, newDefaults) {
const endpoint2 = oldEndpoint.defaults(newDefaults);
const newApi = function(route, parameters) {
const endpointOptions = endpoint2.merge(route, parameters);
if (!endpointOptions.request || !endpointOptions.request.hook) {
return fetchWrapper(endpoint2.parse(endpointOptions));
}
const request2 = (route2, parameters2) => {
return fetchWrapper(
endpoint2.parse(endpoint2.merge(route2, parameters2))
);
};
Object.assign(request2, {
endpoint: endpoint2,
defaults: withDefaults2.bind(null, endpoint2)
});
return endpointOptions.request.hook(request2, endpointOptions);
};
return Object.assign(newApi, {
endpoint: endpoint2,
defaults: withDefaults2.bind(null, endpoint2)
});
}
var import_fast_content_type_parse, VERSION2, defaults_default, noop, request;
var init_dist_bundle2 = __esm({
"node_modules/@octokit/request/dist-bundle/index.js"() {
"use strict";
init_dist_bundle();
init_universal_user_agent();
import_fast_content_type_parse = __toESM(require_fast_content_type_parse(), 1);
init_dist_src();
VERSION2 = "10.0.7";
defaults_default = {
headers: {
"user-agent": `octokit-request.js/${VERSION2} ${getUserAgent()}`
}
};
noop = () => "";
request = withDefaults2(endpoint, defaults_default);
}
});
// node_modules/@octokit/graphql/dist-bundle/index.js
function _buildMessageForResponseErrors(data) {
return `Request failed due to following response errors:
` + data.errors.map((e) => ` - ${e.message}`).join("\n");
}
function graphql(request2, query, options) {
if (options) {
if (typeof query === "string" && "query" in options) {
return Promise.reject(
new Error(`[@octokit/graphql] "query" cannot be used as variable name`)
);
}
for (const key in options) {
if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue;
return Promise.reject(
new Error(
`[@octokit/graphql] "${key}" cannot be used as variable name`
)
);
}
}
const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
const requestOptions = Object.keys(
parsedOptions
).reduce((result, key) => {
if (NON_VARIABLE_OPTIONS.includes(key)) {
result[key] = parsedOptions[key];
return result;
}
if (!result.variables) {
result.variables = {};
}
result.variables[key] = parsedOptions[key];
return result;
}, {});
const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl;
if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
}
return request2(requestOptions).then((response2) => {
if (response2.data.errors) {
const headers = {};
for (const key of Object.keys(response2.headers)) {
headers[key] = response2.headers[key];
}
throw new GraphqlResponseError(
requestOptions,
headers,
response2.data
);
}
return response2.data.data;
});
}
function withDefaults3(request2, newDefaults) {
const newRequest = request2.defaults(newDefaults);
const newApi = (query, options) => {
return graphql(newRequest, query, options);
};
return Object.assign(newApi, {
defaults: withDefaults3.bind(null, newRequest),
endpoint: newRequest.endpoint
});
}
function withCustomRequest(customRequest) {
return withDefaults3(customRequest, {
method: "POST",
url: "/graphql"
});
}
var VERSION3, GraphqlResponseError, NON_VARIABLE_OPTIONS, FORBIDDEN_VARIABLE_OPTIONS, GHES_V3_SUFFIX_REGEX, graphql2;
var init_dist_bundle3 = __esm({
"node_modules/@octokit/graphql/dist-bundle/index.js"() {
"use strict";
init_dist_bundle2();
init_universal_user_agent();
VERSION3 = "0.0.0-development";
GraphqlResponseError = class extends Error {
constructor(request2, headers, response2) {
super(_buildMessageForResponseErrors(response2));
this.request = request2;
this.headers = headers;
this.response = response2;
this.errors = response2.errors;
this.data = response2.data;
if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
}
}
name = "GraphqlResponseError";
errors;
data;
};
NON_VARIABLE_OPTIONS = [
"method",
"baseUrl",
"url",
"headers",
"request",
"query",
"mediaType",
"operationName"
];
FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
graphql2 = withDefaults3(request, {
headers: {
"user-agent": `octokit-graphql.js/${VERSION3} ${getUserAgent()}`
},
method: "POST",
url: "/graphql"
});
}
});
// node_modules/@octokit/auth-token/dist-bundle/index.js
async function auth(token) {
const isApp = isJWT(token);
const isInstallation = token.startsWith("v1.") || token.startsWith("ghs_");
const isUserToServer = token.startsWith("ghu_");
const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth";
return {
type: "token",
token,
tokenType
};
}
function withAuthorizationPrefix(token) {
if (token.split(/\./).length === 3) {
return `bearer ${token}`;
}
return `token ${token}`;
}
async function hook(token, request2, route, parameters) {
const endpoint2 = request2.endpoint.merge(
route,
parameters
);
endpoint2.headers.authorization = withAuthorizationPrefix(token);
return request2(endpoint2);
}
var b64url, sep, jwtRE, isJWT, createTokenAuth;
var init_dist_bundle4 = __esm({
"node_modules/@octokit/auth-token/dist-bundle/index.js"() {
"use strict";
b64url = "(?:[a-zA-Z0-9_-]+)";
sep = "\\.";
jwtRE = new RegExp(`^${b64url}${sep}${b64url}${sep}${b64url}$`);
isJWT = jwtRE.test.bind(jwtRE);
createTokenAuth = function createTokenAuth2(token) {
if (!token) {
throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
}
if (typeof token !== "string") {
throw new Error(
"[@octokit/auth-token] Token passed to createTokenAuth is not a string"
);
}
token = token.replace(/^(token|bearer) +/i, "");
return Object.assign(auth.bind(null, token), {
hook: hook.bind(null, token)
});
};
}
});
// node_modules/@octokit/core/dist-src/version.js
var VERSION4;
var init_version = __esm({
"node_modules/@octokit/core/dist-src/version.js"() {
"use strict";
VERSION4 = "7.0.6";
}
});
// node_modules/@octokit/core/dist-src/index.js
function createLogger(logger = {}) {
if (typeof logger.debug !== "function") {
logger.debug = noop2;
}
if (typeof logger.info !== "function") {
logger.info = noop2;
}
if (typeof logger.warn !== "function") {
logger.warn = consoleWarn;
}
if (typeof logger.error !== "function") {
logger.error = consoleError;
}
return logger;
}
var noop2, consoleWarn, consoleError, userAgentTrail, Octokit;
var init_dist_src2 = __esm({
"node_modules/@octokit/core/dist-src/index.js"() {
"use strict";
init_universal_user_agent();
init_before_after_hook();
init_dist_bundle2();
init_dist_bundle3();
init_dist_bundle4();
init_version();
noop2 = () => {
};
consoleWarn = console.warn.bind(console);
consoleError = console.error.bind(console);
userAgentTrail = `octokit-core.js/${VERSION4} ${getUserAgent()}`;
Octokit = class {
static VERSION = VERSION4;
static defaults(defaults) {
const OctokitWithDefaults = class extends this {
constructor(...args) {
const options = args[0] || {};
if (typeof defaults === "function") {
super(defaults(options));
return;
}
super(
Object.assign(
{},
defaults,
options,
options.userAgent && defaults.userAgent ? {
userAgent: `${options.userAgent} ${defaults.userAgent}`
} : null
)
);
}
};
return OctokitWithDefaults;
}
static plugins = [];
/**
* Attach a plugin (or many) to your Octokit instance.
*
* @example
* const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
*/
static plugin(...newPlugins) {
const currentPlugins = this.plugins;
const NewOctokit = class extends this {
static plugins = currentPlugins.concat(
newPlugins.filter((plugin) => !currentPlugins.includes(plugin))
);
};
return NewOctokit;
}
constructor(options = {}) {
const hook2 = new before_after_hook_default.Collection();
const requestDefaults = {
baseUrl: request.endpoint.DEFAULTS.baseUrl,
headers: {},
request: Object.assign({}, options.request, {
// @ts-ignore internal usage only, no need to type
hook: hook2.bind(null, "request")
}),
mediaType: {
previews: [],
format: ""
}
};
requestDefaults.headers["user-agent"] = options.userAgent ? `${options.userAgent} ${userAgentTrail}` : userAgentTrail;
if (options.baseUrl) {
requestDefaults.baseUrl = options.baseUrl;
}
if (options.previews) {
requestDefaults.mediaType.previews = options.previews;
}
if (options.timeZone) {
requestDefaults.headers["time-zone"] = options.timeZone;
}
this.request = request.defaults(requestDefaults);
this.graphql = withCustomRequest(this.request).defaults(requestDefaults);
this.log = createLogger(options.log);
this.hook = hook2;
if (!options.authStrategy) {
if (!options.auth) {
this.auth = async () => ({
type: "unauthenticated"
});
} else {
const auth2 = createTokenAuth(options.auth);
hook2.wrap("request", auth2.hook);
this.auth = auth2;
}
} else {
const { authStrategy, ...otherOptions } = options;
const auth2 = authStrategy(
Object.assign(
{
request: this.request,
log: this.log,
// we pass the current octokit instance as well as its constructor options
// to allow for authentication strategies that return a new octokit instance
// that shares the same internal state as the current one. The original
// requirement for this was the "event-octokit" authentication strategy
// of https://github.com/probot/octokit-auth-probot.
octokit: this,
octokitOptions: otherOptions
},
options.auth
)
);
hook2.wrap("request", auth2.hook);
this.auth = auth2;
}
const classConstructor = this.constructor;
for (let i = 0; i < classConstructor.plugins.length; ++i) {
Object.assign(this, classConstructor.plugins[i](this, options));
}
}
// assigned during constructor
request;
graphql;
log;
hook;
// TODO: type `octokit.auth` based on passed options.authStrategy
auth;
};
}
});
// node_modules/@octokit/plugin-request-log/dist-src/version.js
var VERSION5;
var init_version2 = __esm({
"node_modules/@octokit/plugin-request-log/dist-src/version.js"() {
"use strict";
VERSION5 = "6.0.0";
}
});
// node_modules/@octokit/plugin-request-log/dist-src/index.js
function requestLog(octokit) {
octokit.hook.wrap("request", (request2, options) => {
octokit.log.debug("request", options);
const start = Date.now();
const requestOptions = octokit.request.endpoint.parse(options);
const path = requestOptions.url.replace(options.baseUrl, "");
return request2(options).then((response2) => {
const requestId = response2.headers["x-github-request-id"];
octokit.log.info(
`${requestOptions.method} ${path} - ${response2.status} with id ${requestId} in ${Date.now() - start}ms`
);
return response2;
}).catch((error) => {
const requestId = error.response?.headers["x-github-request-id"] || "UNKNOWN";
octokit.log.error(
`${requestOptions.method} ${path} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
);
throw error;
});
});
}
var init_dist_src3 = __esm({
"node_modules/@octokit/plugin-request-log/dist-src/index.js"() {
"use strict";
init_version2();
requestLog.VERSION = VERSION5;
}
});
// node_modules/@octokit/plugin-paginate-rest/dist-bundle/index.js
function normalizePaginatedListResponse(response2) {
if (!response2.data) {
return {
...response2,
data: []
};
}
const responseNeedsNormalization = ("total_count" in response2.data || "total_commits" in response2.data) && !("url" in response2.data);
if (!responseNeedsNormalization) return response2;
const incompleteResults = response2.data.incomplete_results;
const repositorySelection = response2.data.repository_selection;
const totalCount = response2.data.total_count;
const totalCommits = response2.data.total_commits;
delete response2.data.incomplete_results;
delete response2.data.repository_selection;
delete response2.data.total_count;
delete response2.data.total_commits;
const namespaceKey = Object.keys(response2.data)[0];
const data = response2.data[namespaceKey];
response2.data = data;
if (typeof incompleteResults !== "undefined") {
response2.data.incomplete_results = incompleteResults;
}
if (typeof repositorySelection !== "undefined") {
response2.data.repository_selection = repositorySelection;
}
response2.data.total_count = totalCount;
response2.data.total_commits = totalCommits;
return response2;
}
function iterator(octokit, route, parameters) {
const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
const requestMethod = typeof route === "function" ? route : octokit.request;
const method = options.method;
const headers = options.headers;
let url = options.url;
return {
[Symbol.asyncIterator]: () => ({
async next() {
if (!url) return { done: true };
try {
const response2 = await requestMethod({ method, url, headers });
const normalizedResponse = normalizePaginatedListResponse(response2);
url = ((normalizedResponse.headers.link || "").match(
/<([^<>]+)>;\s*rel="next"/
) || [])[1];
if (!url && "total_commits" in normalizedResponse.data) {
const parsedUrl = new URL(normalizedResponse.url);
const params = parsedUrl.searchParams;
const page = parseInt(params.get("page") || "1", 10);
const per_page = parseInt(params.get("per_page") || "250", 10);
if (page * per_page < normalizedResponse.data.total_commits) {
params.set("page", String(page + 1));
url = parsedUrl.toString();
}
}
return { value: normalizedResponse };
} catch (error) {
if (error.status !== 409) throw error;
url = "";
return {
value: {
status: 200,
headers: {},
data: []
}
};
}
}
})
};
}
function paginate(octokit, route, parameters, mapFn) {
if (typeof parameters === "function") {
mapFn = parameters;
parameters = void 0;
}
return gather(
octokit,
[],
iterator(octokit, route, parameters)[Symbol.asyncIterator](),
mapFn
);
}
function gather(octokit, results, iterator2, mapFn) {
return iterator2.next().then((result) => {
if (result.done) {
return results;
}
let earlyExit = false;
function done() {
earlyExit = true;
}
results = results.concat(
mapFn ? mapFn(result.value, done) : result.value.data
);
if (earlyExit) {
return results;
}
return gather(octokit, results, iterator2, mapFn);
});
}
function paginateRest(octokit) {
return {
paginate: Object.assign(paginate.bind(null, octokit), {
iterator: iterator.bind(null, octokit)
})
};
}
var VERSION6, composePaginateRest;
var init_dist_bundle5 = __esm({
"node_modules/@octokit/plugin-paginate-rest/dist-bundle/index.js"() {
"use strict";
VERSION6 = "0.0.0-development";
composePaginateRest = Object.assign(paginate, {
iterator
});
paginateRest.VERSION = VERSION6;
}
});
// node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/version.js
var VERSION7;
var init_version3 = __esm({
"node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/version.js"() {
"use strict";
VERSION7 = "17.0.0";
}
});
// node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/generated/endpoints.js
var Endpoints, endpoints_default;
var init_endpoints = __esm({
"node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/generated/endpoints.js"() {
"use strict";
Endpoints = {
actions: {
addCustomLabelsToSelfHostedRunnerForOrg: [
"POST /orgs/{org}/actions/runners/{runner_id}/labels"
],
addCustomLabelsToSelfHostedRunnerForRepo: [
"POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
],
addRepoAccessToSelfHostedRunnerGroupInOrg: [
"PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}"
],
addSelectedRepoToOrgSecret: [
"PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"
],
addSelectedRepoToOrgVariable: [
"PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"
],
approveWorkflowRun: [
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"
],
cancelWorkflowRun: [
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"
],
createEnvironmentVariable: [
"POST /repos/{owner}/{repo}/environments/{environment_name}/variables"
],
createHostedRunnerForOrg: ["POST /orgs/{org}/actions/hosted-runners"],
createOrUpdateEnvironmentSecret: [
"PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
],
createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"],
createOrUpdateRepoSecret: [
"PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"
],
createOrgVariable: ["POST /orgs/{org}/actions/variables"],
createRegistrationTokenForOrg: [
"POST /orgs/{org}/actions/runners/registration-token"
],
createRegistrationTokenForRepo: [
"POST /repos/{owner}/{repo}/actions/runners/registration-token"
],
createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"],
createRemoveTokenForRepo: [
"POST /repos/{owner}/{repo}/actions/runners/remove-token"
],
createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"],
createWorkflowDispatch: [
"POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"
],
deleteActionsCacheById: [
"DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"
],
deleteActionsCacheByKey: [
"DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"
],
deleteArtifact: [
"DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"
],
deleteCustomImageFromOrg: [
"DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"
],
deleteCustomImageVersionFromOrg: [
"DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"
],
deleteEnvironmentSecret: [
"DELETE /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
],
deleteEnvironmentVariable: [
"DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"
],
deleteHostedRunnerForOrg: [
"DELETE /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"
],
deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"],
deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"],
deleteRepoSecret: [
"DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"
],
deleteRepoVariable: [
"DELETE /repos/{owner}/{repo}/actions/variables/{name}"
],
deleteSelfHostedRunnerFromOrg: [
"DELETE /orgs/{org}/actions/runners/{runner_id}"
],
deleteSelfHostedRunnerFromRepo: [
"DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"
],
deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],
deleteWorkflowRunLogs: [
"DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"
],
disableSelectedRepositoryGithubActionsOrganization: [
"DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"
],
disableWorkflow: [
"PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"
],
downloadArtifact: [
"GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"
],
downloadJobLogsForWorkflowRun: [
"GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"
],
downloadWorkflowRunAttemptLogs: [
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"
],
downloadWorkflowRunLogs: [
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"
],
enableSelectedRepositoryGithubActionsOrganization: [
"PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"
],
enableWorkflow: [
"PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"
],
forceCancelWorkflowRun: [
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel"
],
generateRunnerJitconfigForOrg: [
"POST /orgs/{org}/actions/runners/generate-jitconfig"
],
generateRunnerJitconfigForRepo: [
"POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig"
],
getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"],
getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"],
getActionsCacheUsageByRepoForOrg: [
"GET /orgs/{org}/actions/cache/usage-by-repository"
],
getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"],
getAllowedActionsOrganization: [
"GET /orgs/{org}/actions/permissions/selected-actions"
],
getAllowedActionsRepository: [
"GET /repos/{owner}/{repo}/actions/permissions/selected-actions"
],
getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
getCustomImage