| import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module"; |
| /******/ var __webpack_modules__ = ({ |
| |
| /***/ 351: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.issue = exports.issueCommand = void 0; |
| const os = __importStar(__nccwpck_require__(37)); |
| const utils_1 = __nccwpck_require__(278); |
| /** |
| * Commands |
| * |
| * Command Format: |
| * ::name key=value,key=value::message |
| * |
| * Examples: |
| * ::warning::This is the message |
| * ::set-env name=MY_VAR::some value |
| */ |
| function issueCommand(command, properties, message) { |
| const cmd = new Command(command, properties, message); |
| process.stdout.write(cmd.toString() + os.EOL); |
| } |
| exports.issueCommand = issueCommand; |
| function issue(name, message = '') { |
| issueCommand(name, {}, message); |
| } |
| exports.issue = issue; |
| const CMD_STRING = '::'; |
| class Command { |
| constructor(command, properties, message) { |
| if (!command) { |
| command = 'missing.command'; |
| } |
| this.command = command; |
| this.properties = properties; |
| this.message = message; |
| } |
| toString() { |
| let cmdStr = CMD_STRING + this.command; |
| if (this.properties && Object.keys(this.properties).length > 0) { |
| cmdStr += ' '; |
| let first = true; |
| for (const key in this.properties) { |
| if (this.properties.hasOwnProperty(key)) { |
| const val = this.properties[key]; |
| if (val) { |
| if (first) { |
| first = false; |
| } |
| else { |
| cmdStr += ','; |
| } |
| cmdStr += `${key}=${escapeProperty(val)}`; |
| } |
| } |
| } |
| } |
| cmdStr += `${CMD_STRING}${escapeData(this.message)}`; |
| return cmdStr; |
| } |
| } |
| function escapeData(s) { |
| return utils_1.toCommandValue(s) |
| .replace(/%/g, '%25') |
| .replace(/\r/g, '%0D') |
| .replace(/\n/g, '%0A'); |
| } |
| function escapeProperty(s) { |
| return utils_1.toCommandValue(s) |
| .replace(/%/g, '%25') |
| .replace(/\r/g, '%0D') |
| .replace(/\n/g, '%0A') |
| .replace(/:/g, '%3A') |
| .replace(/,/g, '%2C'); |
| } |
| //# sourceMappingURL=command.js.map |
| |
| /***/ }), |
| |
| /***/ 186: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; |
| const command_1 = __nccwpck_require__(351); |
| const file_command_1 = __nccwpck_require__(717); |
| const utils_1 = __nccwpck_require__(278); |
| const os = __importStar(__nccwpck_require__(37)); |
| const path = __importStar(__nccwpck_require__(17)); |
| const oidc_utils_1 = __nccwpck_require__(41); |
| /** |
| * The code to exit an action |
| */ |
| var ExitCode; |
| (function (ExitCode) { |
| /** |
| * A code indicating that the action was successful |
| */ |
| ExitCode[ExitCode["Success"] = 0] = "Success"; |
| /** |
| * A code indicating that the action was a failure |
| */ |
| ExitCode[ExitCode["Failure"] = 1] = "Failure"; |
| })(ExitCode = exports.ExitCode || (exports.ExitCode = {})); |
| //----------------------------------------------------------------------- |
| // Variables |
| //----------------------------------------------------------------------- |
| /** |
| * Sets env variable for this action and future actions in the job |
| * @param name the name of the variable to set |
| * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify |
| */ |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any |
| function exportVariable(name, val) { |
| const convertedVal = utils_1.toCommandValue(val); |
| process.env[name] = convertedVal; |
| const filePath = process.env['GITHUB_ENV'] || ''; |
| if (filePath) { |
| const delimiter = '_GitHubActionsFileCommandDelimeter_'; |
| const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`; |
| file_command_1.issueCommand('ENV', commandValue); |
| } |
| else { |
| command_1.issueCommand('set-env', { name }, convertedVal); |
| } |
| } |
| exports.exportVariable = exportVariable; |
| /** |
| * Registers a secret which will get masked from logs |
| * @param secret value of the secret |
| */ |
| function setSecret(secret) { |
| command_1.issueCommand('add-mask', {}, secret); |
| } |
| exports.setSecret = setSecret; |
| /** |
| * Prepends inputPath to the PATH (for this action and future actions) |
| * @param inputPath |
| */ |
| function addPath(inputPath) { |
| const filePath = process.env['GITHUB_PATH'] || ''; |
| if (filePath) { |
| file_command_1.issueCommand('PATH', inputPath); |
| } |
| else { |
| command_1.issueCommand('add-path', {}, inputPath); |
| } |
| process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; |
| } |
| exports.addPath = addPath; |
| /** |
| * Gets the value of an input. |
| * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed. |
| * Returns an empty string if the value is not defined. |
| * |
| * @param name name of the input to get |
| * @param options optional. See InputOptions. |
| * @returns string |
| */ |
| function getInput(name, options) { |
| const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; |
| if (options && options.required && !val) { |
| throw new Error(`Input required and not supplied: ${name}`); |
| } |
| if (options && options.trimWhitespace === false) { |
| return val; |
| } |
| return val.trim(); |
| } |
| exports.getInput = getInput; |
| /** |
| * Gets the values of an multiline input. Each value is also trimmed. |
| * |
| * @param name name of the input to get |
| * @param options optional. See InputOptions. |
| * @returns string[] |
| * |
| */ |
| function getMultilineInput(name, options) { |
| const inputs = getInput(name, options) |
| .split('\n') |
| .filter(x => x !== ''); |
| return inputs; |
| } |
| exports.getMultilineInput = getMultilineInput; |
| /** |
| * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification. |
| * Support boolean input list: `true | True | TRUE | false | False | FALSE` . |
| * The return value is also in boolean type. |
| * ref: https://yaml.org/spec/1.2/spec.html#id2804923 |
| * |
| * @param name name of the input to get |
| * @param options optional. See InputOptions. |
| * @returns boolean |
| */ |
| function getBooleanInput(name, options) { |
| const trueValue = ['true', 'True', 'TRUE']; |
| const falseValue = ['false', 'False', 'FALSE']; |
| const val = getInput(name, options); |
| if (trueValue.includes(val)) |
| return true; |
| if (falseValue.includes(val)) |
| return false; |
| throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + |
| `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); |
| } |
| exports.getBooleanInput = getBooleanInput; |
| /** |
| * Sets the value of an output. |
| * |
| * @param name name of the output to set |
| * @param value value to store. Non-string values will be converted to a string via JSON.stringify |
| */ |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any |
| function setOutput(name, value) { |
| process.stdout.write(os.EOL); |
| command_1.issueCommand('set-output', { name }, value); |
| } |
| exports.setOutput = setOutput; |
| /** |
| * Enables or disables the echoing of commands into stdout for the rest of the step. |
| * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. |
| * |
| */ |
| function setCommandEcho(enabled) { |
| command_1.issue('echo', enabled ? 'on' : 'off'); |
| } |
| exports.setCommandEcho = setCommandEcho; |
| //----------------------------------------------------------------------- |
| // Results |
| //----------------------------------------------------------------------- |
| /** |
| * Sets the action status to failed. |
| * When the action exits it will be with an exit code of 1 |
| * @param message add error issue message |
| */ |
| function setFailed(message) { |
| process.exitCode = ExitCode.Failure; |
| error(message); |
| } |
| exports.setFailed = setFailed; |
| //----------------------------------------------------------------------- |
| // Logging Commands |
| //----------------------------------------------------------------------- |
| /** |
| * Gets whether Actions Step Debug is on or not |
| */ |
| function isDebug() { |
| return process.env['RUNNER_DEBUG'] === '1'; |
| } |
| exports.isDebug = isDebug; |
| /** |
| * Writes debug message to user log |
| * @param message debug message |
| */ |
| function debug(message) { |
| command_1.issueCommand('debug', {}, message); |
| } |
| exports.debug = debug; |
| /** |
| * Adds an error issue |
| * @param message error issue message. Errors will be converted to string via toString() |
| * @param properties optional properties to add to the annotation. |
| */ |
| function error(message, properties = {}) { |
| command_1.issueCommand('error', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); |
| } |
| exports.error = error; |
| /** |
| * Adds a warning issue |
| * @param message warning issue message. Errors will be converted to string via toString() |
| * @param properties optional properties to add to the annotation. |
| */ |
| function warning(message, properties = {}) { |
| command_1.issueCommand('warning', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); |
| } |
| exports.warning = warning; |
| /** |
| * Adds a notice issue |
| * @param message notice issue message. Errors will be converted to string via toString() |
| * @param properties optional properties to add to the annotation. |
| */ |
| function notice(message, properties = {}) { |
| command_1.issueCommand('notice', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); |
| } |
| exports.notice = notice; |
| /** |
| * Writes info to log with console.log. |
| * @param message info message |
| */ |
| function info(message) { |
| process.stdout.write(message + os.EOL); |
| } |
| exports.info = info; |
| /** |
| * Begin an output group. |
| * |
| * Output until the next `groupEnd` will be foldable in this group |
| * |
| * @param name The name of the output group |
| */ |
| function startGroup(name) { |
| command_1.issue('group', name); |
| } |
| exports.startGroup = startGroup; |
| /** |
| * End an output group. |
| */ |
| function endGroup() { |
| command_1.issue('endgroup'); |
| } |
| exports.endGroup = endGroup; |
| /** |
| * Wrap an asynchronous function call in a group. |
| * |
| * Returns the same type as the function itself. |
| * |
| * @param name The name of the group |
| * @param fn The function to wrap in the group |
| */ |
| function group(name, fn) { |
| return __awaiter(this, void 0, void 0, function* () { |
| startGroup(name); |
| let result; |
| try { |
| result = yield fn(); |
| } |
| finally { |
| endGroup(); |
| } |
| return result; |
| }); |
| } |
| exports.group = group; |
| //----------------------------------------------------------------------- |
| // Wrapper action state |
| //----------------------------------------------------------------------- |
| /** |
| * Saves state for current action, the state can only be retrieved by this action's post job execution. |
| * |
| * @param name name of the state to store |
| * @param value value to store. Non-string values will be converted to a string via JSON.stringify |
| */ |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any |
| function saveState(name, value) { |
| command_1.issueCommand('save-state', { name }, value); |
| } |
| exports.saveState = saveState; |
| /** |
| * Gets the value of an state set by this action's main execution. |
| * |
| * @param name name of the state to get |
| * @returns string |
| */ |
| function getState(name) { |
| return process.env[`STATE_${name}`] || ''; |
| } |
| exports.getState = getState; |
| function getIDToken(aud) { |
| return __awaiter(this, void 0, void 0, function* () { |
| return yield oidc_utils_1.OidcClient.getIDToken(aud); |
| }); |
| } |
| exports.getIDToken = getIDToken; |
| //# sourceMappingURL=core.js.map |
| |
| /***/ }), |
| |
| /***/ 717: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| // For internal use, subject to change. |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.issueCommand = void 0; |
| // We use any as a valid input type |
| /* eslint-disable @typescript-eslint/no-explicit-any */ |
| const fs = __importStar(__nccwpck_require__(147)); |
| const os = __importStar(__nccwpck_require__(37)); |
| const utils_1 = __nccwpck_require__(278); |
| function issueCommand(command, message) { |
| const filePath = process.env[`GITHUB_${command}`]; |
| if (!filePath) { |
| throw new Error(`Unable to find environment variable for file command ${command}`); |
| } |
| if (!fs.existsSync(filePath)) { |
| throw new Error(`Missing file at path: ${filePath}`); |
| } |
| fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, { |
| encoding: 'utf8' |
| }); |
| } |
| exports.issueCommand = issueCommand; |
| //# sourceMappingURL=file-command.js.map |
| |
| /***/ }), |
| |
| /***/ 41: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.OidcClient = void 0; |
| const http_client_1 = __nccwpck_require__(925); |
| const auth_1 = __nccwpck_require__(702); |
| const core_1 = __nccwpck_require__(186); |
| class OidcClient { |
| static createHttpClient(allowRetry = true, maxRetry = 10) { |
| const requestOptions = { |
| allowRetries: allowRetry, |
| maxRetries: maxRetry |
| }; |
| return new http_client_1.HttpClient('actions/oidc-client', [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions); |
| } |
| static getRequestToken() { |
| const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN']; |
| if (!token) { |
| throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable'); |
| } |
| return token; |
| } |
| static getIDTokenUrl() { |
| const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL']; |
| if (!runtimeUrl) { |
| throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable'); |
| } |
| return runtimeUrl; |
| } |
| static getCall(id_token_url) { |
| var _a; |
| return __awaiter(this, void 0, void 0, function* () { |
| const httpclient = OidcClient.createHttpClient(); |
| const res = yield httpclient |
| .getJson(id_token_url) |
| .catch(error => { |
| throw new Error(`Failed to get ID Token. \n |
| Error Code : ${error.statusCode}\n |
| Error Message: ${error.result.message}`); |
| }); |
| const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value; |
| if (!id_token) { |
| throw new Error('Response json body do not have ID Token field'); |
| } |
| return id_token; |
| }); |
| } |
| static getIDToken(audience) { |
| return __awaiter(this, void 0, void 0, function* () { |
| try { |
| // New ID Token is requested from action service |
| let id_token_url = OidcClient.getIDTokenUrl(); |
| if (audience) { |
| const encodedAudience = encodeURIComponent(audience); |
| id_token_url = `${id_token_url}&audience=${encodedAudience}`; |
| } |
| core_1.debug(`ID token url is ${id_token_url}`); |
| const id_token = yield OidcClient.getCall(id_token_url); |
| core_1.setSecret(id_token); |
| return id_token; |
| } |
| catch (error) { |
| throw new Error(`Error message: ${error.message}`); |
| } |
| }); |
| } |
| } |
| exports.OidcClient = OidcClient; |
| //# sourceMappingURL=oidc-utils.js.map |
| |
| /***/ }), |
| |
| /***/ 278: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| |
| // We use any as a valid input type |
| /* eslint-disable @typescript-eslint/no-explicit-any */ |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.toCommandProperties = exports.toCommandValue = void 0; |
| /** |
| * Sanitizes an input into a string so it can be passed into issueCommand safely |
| * @param input input to sanitize into a string |
| */ |
| function toCommandValue(input) { |
| if (input === null || input === undefined) { |
| return ''; |
| } |
| else if (typeof input === 'string' || input instanceof String) { |
| return input; |
| } |
| return JSON.stringify(input); |
| } |
| exports.toCommandValue = toCommandValue; |
| /** |
| * |
| * @param annotationProperties |
| * @returns The command properties to send with the actual annotation command |
| * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646 |
| */ |
| function toCommandProperties(annotationProperties) { |
| if (!Object.keys(annotationProperties).length) { |
| return {}; |
| } |
| return { |
| title: annotationProperties.title, |
| file: annotationProperties.file, |
| line: annotationProperties.startLine, |
| endLine: annotationProperties.endLine, |
| col: annotationProperties.startColumn, |
| endColumn: annotationProperties.endColumn |
| }; |
| } |
| exports.toCommandProperties = toCommandProperties; |
| //# sourceMappingURL=utils.js.map |
| |
| /***/ }), |
| |
| /***/ 514: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getExecOutput = exports.exec = void 0; |
| const string_decoder_1 = __nccwpck_require__(576); |
| const tr = __importStar(__nccwpck_require__(159)); |
| /** |
| * Exec a command. |
| * Output will be streamed to the live console. |
| * Returns promise with return code |
| * |
| * @param commandLine command to execute (can include additional args). Must be correctly escaped. |
| * @param args optional arguments for tool. Escaping is handled by the lib. |
| * @param options optional exec options. See ExecOptions |
| * @returns Promise<number> exit code |
| */ |
| function exec(commandLine, args, options) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const commandArgs = tr.argStringToArray(commandLine); |
| if (commandArgs.length === 0) { |
| throw new Error(`Parameter 'commandLine' cannot be null or empty.`); |
| } |
| // Path to tool to execute should be first arg |
| const toolPath = commandArgs[0]; |
| args = commandArgs.slice(1).concat(args || []); |
| const runner = new tr.ToolRunner(toolPath, args, options); |
| return runner.exec(); |
| }); |
| } |
| exports.exec = exec; |
| /** |
| * Exec a command and get the output. |
| * Output will be streamed to the live console. |
| * Returns promise with the exit code and collected stdout and stderr |
| * |
| * @param commandLine command to execute (can include additional args). Must be correctly escaped. |
| * @param args optional arguments for tool. Escaping is handled by the lib. |
| * @param options optional exec options. See ExecOptions |
| * @returns Promise<ExecOutput> exit code, stdout, and stderr |
| */ |
| function getExecOutput(commandLine, args, options) { |
| var _a, _b; |
| return __awaiter(this, void 0, void 0, function* () { |
| let stdout = ''; |
| let stderr = ''; |
| //Using string decoder covers the case where a mult-byte character is split |
| const stdoutDecoder = new string_decoder_1.StringDecoder('utf8'); |
| const stderrDecoder = new string_decoder_1.StringDecoder('utf8'); |
| const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout; |
| const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr; |
| const stdErrListener = (data) => { |
| stderr += stderrDecoder.write(data); |
| if (originalStdErrListener) { |
| originalStdErrListener(data); |
| } |
| }; |
| const stdOutListener = (data) => { |
| stdout += stdoutDecoder.write(data); |
| if (originalStdoutListener) { |
| originalStdoutListener(data); |
| } |
| }; |
| const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener }); |
| const exitCode = yield exec(commandLine, args, Object.assign(Object.assign({}, options), { listeners })); |
| //flush any remaining characters |
| stdout += stdoutDecoder.end(); |
| stderr += stderrDecoder.end(); |
| return { |
| exitCode, |
| stdout, |
| stderr |
| }; |
| }); |
| } |
| exports.getExecOutput = getExecOutput; |
| //# sourceMappingURL=exec.js.map |
| |
| /***/ }), |
| |
| /***/ 159: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.argStringToArray = exports.ToolRunner = void 0; |
| const os = __importStar(__nccwpck_require__(37)); |
| const events = __importStar(__nccwpck_require__(361)); |
| const child = __importStar(__nccwpck_require__(81)); |
| const path = __importStar(__nccwpck_require__(17)); |
| const io = __importStar(__nccwpck_require__(436)); |
| const ioUtil = __importStar(__nccwpck_require__(962)); |
| const timers_1 = __nccwpck_require__(512); |
| /* eslint-disable @typescript-eslint/unbound-method */ |
| const IS_WINDOWS = process.platform === 'win32'; |
| /* |
| * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way. |
| */ |
| class ToolRunner extends events.EventEmitter { |
| constructor(toolPath, args, options) { |
| super(); |
| if (!toolPath) { |
| throw new Error("Parameter 'toolPath' cannot be null or empty."); |
| } |
| this.toolPath = toolPath; |
| this.args = args || []; |
| this.options = options || {}; |
| } |
| _debug(message) { |
| if (this.options.listeners && this.options.listeners.debug) { |
| this.options.listeners.debug(message); |
| } |
| } |
| _getCommandString(options, noPrefix) { |
| const toolPath = this._getSpawnFileName(); |
| const args = this._getSpawnArgs(options); |
| let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool |
| if (IS_WINDOWS) { |
| // Windows + cmd file |
| if (this._isCmdFile()) { |
| cmd += toolPath; |
| for (const a of args) { |
| cmd += ` ${a}`; |
| } |
| } |
| // Windows + verbatim |
| else if (options.windowsVerbatimArguments) { |
| cmd += `"${toolPath}"`; |
| for (const a of args) { |
| cmd += ` ${a}`; |
| } |
| } |
| // Windows (regular) |
| else { |
| cmd += this._windowsQuoteCmdArg(toolPath); |
| for (const a of args) { |
| cmd += ` ${this._windowsQuoteCmdArg(a)}`; |
| } |
| } |
| } |
| else { |
| // OSX/Linux - this can likely be improved with some form of quoting. |
| // creating processes on Unix is fundamentally different than Windows. |
| // on Unix, execvp() takes an arg array. |
| cmd += toolPath; |
| for (const a of args) { |
| cmd += ` ${a}`; |
| } |
| } |
| return cmd; |
| } |
| _processLineBuffer(data, strBuffer, onLine) { |
| try { |
| let s = strBuffer + data.toString(); |
| let n = s.indexOf(os.EOL); |
| while (n > -1) { |
| const line = s.substring(0, n); |
| onLine(line); |
| // the rest of the string ... |
| s = s.substring(n + os.EOL.length); |
| n = s.indexOf(os.EOL); |
| } |
| return s; |
| } |
| catch (err) { |
| // streaming lines to console is best effort. Don't fail a build. |
| this._debug(`error processing line. Failed with error ${err}`); |
| return ''; |
| } |
| } |
| _getSpawnFileName() { |
| if (IS_WINDOWS) { |
| if (this._isCmdFile()) { |
| return process.env['COMSPEC'] || 'cmd.exe'; |
| } |
| } |
| return this.toolPath; |
| } |
| _getSpawnArgs(options) { |
| if (IS_WINDOWS) { |
| if (this._isCmdFile()) { |
| let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; |
| for (const a of this.args) { |
| argline += ' '; |
| argline += options.windowsVerbatimArguments |
| ? a |
| : this._windowsQuoteCmdArg(a); |
| } |
| argline += '"'; |
| return [argline]; |
| } |
| } |
| return this.args; |
| } |
| _endsWith(str, end) { |
| return str.endsWith(end); |
| } |
| _isCmdFile() { |
| const upperToolPath = this.toolPath.toUpperCase(); |
| return (this._endsWith(upperToolPath, '.CMD') || |
| this._endsWith(upperToolPath, '.BAT')); |
| } |
| _windowsQuoteCmdArg(arg) { |
| // for .exe, apply the normal quoting rules that libuv applies |
| if (!this._isCmdFile()) { |
| return this._uvQuoteCmdArg(arg); |
| } |
| // otherwise apply quoting rules specific to the cmd.exe command line parser. |
| // the libuv rules are generic and are not designed specifically for cmd.exe |
| // command line parser. |
| // |
| // for a detailed description of the cmd.exe command line parser, refer to |
| // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912 |
| // need quotes for empty arg |
| if (!arg) { |
| return '""'; |
| } |
| // determine whether the arg needs to be quoted |
| const cmdSpecialChars = [ |
| ' ', |
| '\t', |
| '&', |
| '(', |
| ')', |
| '[', |
| ']', |
| '{', |
| '}', |
| '^', |
| '=', |
| ';', |
| '!', |
| "'", |
| '+', |
| ',', |
| '`', |
| '~', |
| '|', |
| '<', |
| '>', |
| '"' |
| ]; |
| let needsQuotes = false; |
| for (const char of arg) { |
| if (cmdSpecialChars.some(x => x === char)) { |
| needsQuotes = true; |
| break; |
| } |
| } |
| // short-circuit if quotes not needed |
| if (!needsQuotes) { |
| return arg; |
| } |
| // the following quoting rules are very similar to the rules that by libuv applies. |
| // |
| // 1) wrap the string in quotes |
| // |
| // 2) double-up quotes - i.e. " => "" |
| // |
| // this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately |
| // doesn't work well with a cmd.exe command line. |
| // |
| // note, replacing " with "" also works well if the arg is passed to a downstream .NET console app. |
| // for example, the command line: |
| // foo.exe "myarg:""my val""" |
| // is parsed by a .NET console app into an arg array: |
| // [ "myarg:\"my val\"" ] |
| // which is the same end result when applying libuv quoting rules. although the actual |
| // command line from libuv quoting rules would look like: |
| // foo.exe "myarg:\"my val\"" |
| // |
| // 3) double-up slashes that precede a quote, |
| // e.g. hello \world => "hello \world" |
| // hello\"world => "hello\\""world" |
| // hello\\"world => "hello\\\\""world" |
| // hello world\ => "hello world\\" |
| // |
| // technically this is not required for a cmd.exe command line, or the batch argument parser. |
| // the reasons for including this as a .cmd quoting rule are: |
| // |
| // a) this is optimized for the scenario where the argument is passed from the .cmd file to an |
| // external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule. |
| // |
| // b) it's what we've been doing previously (by deferring to node default behavior) and we |
| // haven't heard any complaints about that aspect. |
| // |
| // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be |
| // escaped when used on the command line directly - even though within a .cmd file % can be escaped |
| // by using %%. |
| // |
| // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts |
| // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing. |
| // |
| // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would |
| // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the |
| // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args |
| // to an external program. |
| // |
| // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file. |
| // % can be escaped within a .cmd file. |
| let reverse = '"'; |
| let quoteHit = true; |
| for (let i = arg.length; i > 0; i--) { |
| // walk the string in reverse |
| reverse += arg[i - 1]; |
| if (quoteHit && arg[i - 1] === '\\') { |
| reverse += '\\'; // double the slash |
| } |
| else if (arg[i - 1] === '"') { |
| quoteHit = true; |
| reverse += '"'; // double the quote |
| } |
| else { |
| quoteHit = false; |
| } |
| } |
| reverse += '"'; |
| return reverse |
| .split('') |
| .reverse() |
| .join(''); |
| } |
| _uvQuoteCmdArg(arg) { |
| // Tool runner wraps child_process.spawn() and needs to apply the same quoting as |
| // Node in certain cases where the undocumented spawn option windowsVerbatimArguments |
| // is used. |
| // |
| // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV, |
| // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details), |
| // pasting copyright notice from Node within this function: |
| // |
| // Copyright Joyent, Inc. and other Node contributors. All rights reserved. |
| // |
| // 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: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // 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. |
| if (!arg) { |
| // Need double quotation for empty argument |
| return '""'; |
| } |
| if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) { |
| // No quotation needed |
| return arg; |
| } |
| if (!arg.includes('"') && !arg.includes('\\')) { |
| // No embedded double quotes or backslashes, so I can just wrap |
| // quote marks around the whole thing. |
| return `"${arg}"`; |
| } |
| // Expected input/output: |
| // input : hello"world |
| // output: "hello\"world" |
| // input : hello""world |
| // output: "hello\"\"world" |
| // input : hello\world |
| // output: hello\world |
| // input : hello\\world |
| // output: hello\\world |
| // input : hello\"world |
| // output: "hello\\\"world" |
| // input : hello\\"world |
| // output: "hello\\\\\"world" |
| // input : hello world\ |
| // output: "hello world\\" - note the comment in libuv actually reads "hello world\" |
| // but it appears the comment is wrong, it should be "hello world\\" |
| let reverse = '"'; |
| let quoteHit = true; |
| for (let i = arg.length; i > 0; i--) { |
| // walk the string in reverse |
| reverse += arg[i - 1]; |
| if (quoteHit && arg[i - 1] === '\\') { |
| reverse += '\\'; |
| } |
| else if (arg[i - 1] === '"') { |
| quoteHit = true; |
| reverse += '\\'; |
| } |
| else { |
| quoteHit = false; |
| } |
| } |
| reverse += '"'; |
| return reverse |
| .split('') |
| .reverse() |
| .join(''); |
| } |
| _cloneExecOptions(options) { |
| options = options || {}; |
| const result = { |
| cwd: options.cwd || process.cwd(), |
| env: options.env || process.env, |
| silent: options.silent || false, |
| windowsVerbatimArguments: options.windowsVerbatimArguments || false, |
| failOnStdErr: options.failOnStdErr || false, |
| ignoreReturnCode: options.ignoreReturnCode || false, |
| delay: options.delay || 10000 |
| }; |
| result.outStream = options.outStream || process.stdout; |
| result.errStream = options.errStream || process.stderr; |
| return result; |
| } |
| _getSpawnOptions(options, toolPath) { |
| options = options || {}; |
| const result = {}; |
| result.cwd = options.cwd; |
| result.env = options.env; |
| result['windowsVerbatimArguments'] = |
| options.windowsVerbatimArguments || this._isCmdFile(); |
| if (options.windowsVerbatimArguments) { |
| result.argv0 = `"${toolPath}"`; |
| } |
| return result; |
| } |
| /** |
| * Exec a tool. |
| * Output will be streamed to the live console. |
| * Returns promise with return code |
| * |
| * @param tool path to tool to exec |
| * @param options optional exec options. See ExecOptions |
| * @returns number |
| */ |
| exec() { |
| return __awaiter(this, void 0, void 0, function* () { |
| // root the tool path if it is unrooted and contains relative pathing |
| if (!ioUtil.isRooted(this.toolPath) && |
| (this.toolPath.includes('/') || |
| (IS_WINDOWS && this.toolPath.includes('\\')))) { |
| // prefer options.cwd if it is specified, however options.cwd may also need to be rooted |
| this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); |
| } |
| // if the tool is only a file name, then resolve it from the PATH |
| // otherwise verify it exists (add extension on Windows if necessary) |
| this.toolPath = yield io.which(this.toolPath, true); |
| return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { |
| this._debug(`exec tool: ${this.toolPath}`); |
| this._debug('arguments:'); |
| for (const arg of this.args) { |
| this._debug(` ${arg}`); |
| } |
| const optionsNonNull = this._cloneExecOptions(this.options); |
| if (!optionsNonNull.silent && optionsNonNull.outStream) { |
| optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); |
| } |
| const state = new ExecState(optionsNonNull, this.toolPath); |
| state.on('debug', (message) => { |
| this._debug(message); |
| }); |
| if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) { |
| return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); |
| } |
| const fileName = this._getSpawnFileName(); |
| const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); |
| let stdbuffer = ''; |
| if (cp.stdout) { |
| cp.stdout.on('data', (data) => { |
| if (this.options.listeners && this.options.listeners.stdout) { |
| this.options.listeners.stdout(data); |
| } |
| if (!optionsNonNull.silent && optionsNonNull.outStream) { |
| optionsNonNull.outStream.write(data); |
| } |
| stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { |
| if (this.options.listeners && this.options.listeners.stdline) { |
| this.options.listeners.stdline(line); |
| } |
| }); |
| }); |
| } |
| let errbuffer = ''; |
| if (cp.stderr) { |
| cp.stderr.on('data', (data) => { |
| state.processStderr = true; |
| if (this.options.listeners && this.options.listeners.stderr) { |
| this.options.listeners.stderr(data); |
| } |
| if (!optionsNonNull.silent && |
| optionsNonNull.errStream && |
| optionsNonNull.outStream) { |
| const s = optionsNonNull.failOnStdErr |
| ? optionsNonNull.errStream |
| : optionsNonNull.outStream; |
| s.write(data); |
| } |
| errbuffer = this._processLineBuffer(data, errbuffer, (line) => { |
| if (this.options.listeners && this.options.listeners.errline) { |
| this.options.listeners.errline(line); |
| } |
| }); |
| }); |
| } |
| cp.on('error', (err) => { |
| state.processError = err.message; |
| state.processExited = true; |
| state.processClosed = true; |
| state.CheckComplete(); |
| }); |
| cp.on('exit', (code) => { |
| state.processExitCode = code; |
| state.processExited = true; |
| this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); |
| state.CheckComplete(); |
| }); |
| cp.on('close', (code) => { |
| state.processExitCode = code; |
| state.processExited = true; |
| state.processClosed = true; |
| this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); |
| state.CheckComplete(); |
| }); |
| state.on('done', (error, exitCode) => { |
| if (stdbuffer.length > 0) { |
| this.emit('stdline', stdbuffer); |
| } |
| if (errbuffer.length > 0) { |
| this.emit('errline', errbuffer); |
| } |
| cp.removeAllListeners(); |
| if (error) { |
| reject(error); |
| } |
| else { |
| resolve(exitCode); |
| } |
| }); |
| if (this.options.input) { |
| if (!cp.stdin) { |
| throw new Error('child process missing stdin'); |
| } |
| cp.stdin.end(this.options.input); |
| } |
| })); |
| }); |
| } |
| } |
| exports.ToolRunner = ToolRunner; |
| /** |
| * Convert an arg string to an array of args. Handles escaping |
| * |
| * @param argString string of arguments |
| * @returns string[] array of arguments |
| */ |
| function argStringToArray(argString) { |
| const args = []; |
| let inQuotes = false; |
| let escaped = false; |
| let arg = ''; |
| function append(c) { |
| // we only escape double quotes. |
| if (escaped && c !== '"') { |
| arg += '\\'; |
| } |
| arg += c; |
| escaped = false; |
| } |
| for (let i = 0; i < argString.length; i++) { |
| const c = argString.charAt(i); |
| if (c === '"') { |
| if (!escaped) { |
| inQuotes = !inQuotes; |
| } |
| else { |
| append(c); |
| } |
| continue; |
| } |
| if (c === '\\' && escaped) { |
| append(c); |
| continue; |
| } |
| if (c === '\\' && inQuotes) { |
| escaped = true; |
| continue; |
| } |
| if (c === ' ' && !inQuotes) { |
| if (arg.length > 0) { |
| args.push(arg); |
| arg = ''; |
| } |
| continue; |
| } |
| append(c); |
| } |
| if (arg.length > 0) { |
| args.push(arg.trim()); |
| } |
| return args; |
| } |
| exports.argStringToArray = argStringToArray; |
| class ExecState extends events.EventEmitter { |
| constructor(options, toolPath) { |
| super(); |
| this.processClosed = false; // tracks whether the process has exited and stdio is closed |
| this.processError = ''; |
| this.processExitCode = 0; |
| this.processExited = false; // tracks whether the process has exited |
| this.processStderr = false; // tracks whether stderr was written to |
| this.delay = 10000; // 10 seconds |
| this.done = false; |
| this.timeout = null; |
| if (!toolPath) { |
| throw new Error('toolPath must not be empty'); |
| } |
| this.options = options; |
| this.toolPath = toolPath; |
| if (options.delay) { |
| this.delay = options.delay; |
| } |
| } |
| CheckComplete() { |
| if (this.done) { |
| return; |
| } |
| if (this.processClosed) { |
| this._setResult(); |
| } |
| else if (this.processExited) { |
| this.timeout = timers_1.setTimeout(ExecState.HandleTimeout, this.delay, this); |
| } |
| } |
| _debug(message) { |
| this.emit('debug', message); |
| } |
| _setResult() { |
| // determine whether there is an error |
| let error; |
| if (this.processExited) { |
| if (this.processError) { |
| error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); |
| } |
| else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { |
| error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); |
| } |
| else if (this.processStderr && this.options.failOnStdErr) { |
| error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); |
| } |
| } |
| // clear the timeout |
| if (this.timeout) { |
| clearTimeout(this.timeout); |
| this.timeout = null; |
| } |
| this.done = true; |
| this.emit('done', error, this.processExitCode); |
| } |
| static HandleTimeout(state) { |
| if (state.done) { |
| return; |
| } |
| if (!state.processClosed && state.processExited) { |
| const message = `The STDIO streams did not close within ${state.delay / |
| 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; |
| state._debug(message); |
| } |
| state._setResult(); |
| } |
| } |
| //# sourceMappingURL=toolrunner.js.map |
| |
| /***/ }), |
| |
| /***/ 702: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| class BasicCredentialHandler { |
| constructor(username, password) { |
| this.username = username; |
| this.password = password; |
| } |
| prepareRequest(options) { |
| options.headers['Authorization'] = |
| 'Basic ' + |
| Buffer.from(this.username + ':' + this.password).toString('base64'); |
| } |
| // This handler cannot handle 401 |
| canHandleAuthentication(response) { |
| return false; |
| } |
| handleAuthentication(httpClient, requestInfo, objs) { |
| return null; |
| } |
| } |
| exports.BasicCredentialHandler = BasicCredentialHandler; |
| class BearerCredentialHandler { |
| constructor(token) { |
| this.token = token; |
| } |
| // currently implements pre-authorization |
| // TODO: support preAuth = false where it hooks on 401 |
| prepareRequest(options) { |
| options.headers['Authorization'] = 'Bearer ' + this.token; |
| } |
| // This handler cannot handle 401 |
| canHandleAuthentication(response) { |
| return false; |
| } |
| handleAuthentication(httpClient, requestInfo, objs) { |
| return null; |
| } |
| } |
| exports.BearerCredentialHandler = BearerCredentialHandler; |
| class PersonalAccessTokenCredentialHandler { |
| constructor(token) { |
| this.token = token; |
| } |
| // currently implements pre-authorization |
| // TODO: support preAuth = false where it hooks on 401 |
| prepareRequest(options) { |
| options.headers['Authorization'] = |
| 'Basic ' + Buffer.from('PAT:' + this.token).toString('base64'); |
| } |
| // This handler cannot handle 401 |
| canHandleAuthentication(response) { |
| return false; |
| } |
| handleAuthentication(httpClient, requestInfo, objs) { |
| return null; |
| } |
| } |
| exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; |
| |
| |
| /***/ }), |
| |
| /***/ 925: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const http = __nccwpck_require__(685); |
| const https = __nccwpck_require__(687); |
| const pm = __nccwpck_require__(443); |
| let tunnel; |
| var HttpCodes; |
| (function (HttpCodes) { |
| HttpCodes[HttpCodes["OK"] = 200] = "OK"; |
| HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; |
| HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; |
| HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; |
| HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; |
| HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; |
| HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; |
| HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; |
| HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; |
| HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; |
| HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; |
| HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; |
| HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; |
| HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; |
| HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; |
| HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; |
| HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; |
| HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; |
| HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; |
| HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; |
| HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; |
| HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; |
| HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; |
| HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; |
| HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; |
| HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; |
| HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; |
| })(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); |
| var Headers; |
| (function (Headers) { |
| Headers["Accept"] = "accept"; |
| Headers["ContentType"] = "content-type"; |
| })(Headers = exports.Headers || (exports.Headers = {})); |
| var MediaTypes; |
| (function (MediaTypes) { |
| MediaTypes["ApplicationJson"] = "application/json"; |
| })(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); |
| /** |
| * Returns the proxy URL, depending upon the supplied url and proxy environment variables. |
| * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com |
| */ |
| function getProxyUrl(serverUrl) { |
| let proxyUrl = pm.getProxyUrl(new URL(serverUrl)); |
| return proxyUrl ? proxyUrl.href : ''; |
| } |
| exports.getProxyUrl = getProxyUrl; |
| const HttpRedirectCodes = [ |
| HttpCodes.MovedPermanently, |
| HttpCodes.ResourceMoved, |
| HttpCodes.SeeOther, |
| HttpCodes.TemporaryRedirect, |
| HttpCodes.PermanentRedirect |
| ]; |
| const HttpResponseRetryCodes = [ |
| HttpCodes.BadGateway, |
| HttpCodes.ServiceUnavailable, |
| HttpCodes.GatewayTimeout |
| ]; |
| const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; |
| const ExponentialBackoffCeiling = 10; |
| const ExponentialBackoffTimeSlice = 5; |
| class HttpClientError extends Error { |
| constructor(message, statusCode) { |
| super(message); |
| this.name = 'HttpClientError'; |
| this.statusCode = statusCode; |
| Object.setPrototypeOf(this, HttpClientError.prototype); |
| } |
| } |
| exports.HttpClientError = HttpClientError; |
| class HttpClientResponse { |
| constructor(message) { |
| this.message = message; |
| } |
| readBody() { |
| return new Promise(async (resolve, reject) => { |
| let output = Buffer.alloc(0); |
| this.message.on('data', (chunk) => { |
| output = Buffer.concat([output, chunk]); |
| }); |
| this.message.on('end', () => { |
| resolve(output.toString()); |
| }); |
| }); |
| } |
| } |
| exports.HttpClientResponse = HttpClientResponse; |
| function isHttps(requestUrl) { |
| let parsedUrl = new URL(requestUrl); |
| return parsedUrl.protocol === 'https:'; |
| } |
| exports.isHttps = isHttps; |
| class HttpClient { |
| constructor(userAgent, handlers, requestOptions) { |
| this._ignoreSslError = false; |
| this._allowRedirects = true; |
| this._allowRedirectDowngrade = false; |
| this._maxRedirects = 50; |
| this._allowRetries = false; |
| this._maxRetries = 1; |
| this._keepAlive = false; |
| this._disposed = false; |
| this.userAgent = userAgent; |
| this.handlers = handlers || []; |
| this.requestOptions = requestOptions; |
| if (requestOptions) { |
| if (requestOptions.ignoreSslError != null) { |
| this._ignoreSslError = requestOptions.ignoreSslError; |
| } |
| this._socketTimeout = requestOptions.socketTimeout; |
| if (requestOptions.allowRedirects != null) { |
| this._allowRedirects = requestOptions.allowRedirects; |
| } |
| if (requestOptions.allowRedirectDowngrade != null) { |
| this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; |
| } |
| if (requestOptions.maxRedirects != null) { |
| this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); |
| } |
| if (requestOptions.keepAlive != null) { |
| this._keepAlive = requestOptions.keepAlive; |
| } |
| if (requestOptions.allowRetries != null) { |
| this._allowRetries = requestOptions.allowRetries; |
| } |
| if (requestOptions.maxRetries != null) { |
| this._maxRetries = requestOptions.maxRetries; |
| } |
| } |
| } |
| options(requestUrl, additionalHeaders) { |
| return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); |
| } |
| get(requestUrl, additionalHeaders) { |
| return this.request('GET', requestUrl, null, additionalHeaders || {}); |
| } |
| del(requestUrl, additionalHeaders) { |
| return this.request('DELETE', requestUrl, null, additionalHeaders || {}); |
| } |
| post(requestUrl, data, additionalHeaders) { |
| return this.request('POST', requestUrl, data, additionalHeaders || {}); |
| } |
| patch(requestUrl, data, additionalHeaders) { |
| return this.request('PATCH', requestUrl, data, additionalHeaders || {}); |
| } |
| put(requestUrl, data, additionalHeaders) { |
| return this.request('PUT', requestUrl, data, additionalHeaders || {}); |
| } |
| head(requestUrl, additionalHeaders) { |
| return this.request('HEAD', requestUrl, null, additionalHeaders || {}); |
| } |
| sendStream(verb, requestUrl, stream, additionalHeaders) { |
| return this.request(verb, requestUrl, stream, additionalHeaders); |
| } |
| /** |
| * Gets a typed object from an endpoint |
| * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise |
| */ |
| async getJson(requestUrl, additionalHeaders = {}) { |
| additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); |
| let res = await this.get(requestUrl, additionalHeaders); |
| return this._processResponse(res, this.requestOptions); |
| } |
| async postJson(requestUrl, obj, additionalHeaders = {}) { |
| let data = JSON.stringify(obj, null, 2); |
| additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); |
| additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); |
| let res = await this.post(requestUrl, data, additionalHeaders); |
| return this._processResponse(res, this.requestOptions); |
| } |
| async putJson(requestUrl, obj, additionalHeaders = {}) { |
| let data = JSON.stringify(obj, null, 2); |
| additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); |
| additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); |
| let res = await this.put(requestUrl, data, additionalHeaders); |
| return this._processResponse(res, this.requestOptions); |
| } |
| async patchJson(requestUrl, obj, additionalHeaders = {}) { |
| let data = JSON.stringify(obj, null, 2); |
| additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); |
| additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); |
| let res = await this.patch(requestUrl, data, additionalHeaders); |
| return this._processResponse(res, this.requestOptions); |
| } |
| /** |
| * Makes a raw http request. |
| * All other methods such as get, post, patch, and request ultimately call this. |
| * Prefer get, del, post and patch |
| */ |
| async request(verb, requestUrl, data, headers) { |
| if (this._disposed) { |
| throw new Error('Client has already been disposed.'); |
| } |
| let parsedUrl = new URL(requestUrl); |
| let info = this._prepareRequest(verb, parsedUrl, headers); |
| // Only perform retries on reads since writes may not be idempotent. |
| let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1 |
| ? this._maxRetries + 1 |
| : 1; |
| let numTries = 0; |
| let response; |
| while (numTries < maxTries) { |
| response = await this.requestRaw(info, data); |
| // Check if it's an authentication challenge |
| if (response && |
| response.message && |
| response.message.statusCode === HttpCodes.Unauthorized) { |
| let authenticationHandler; |
| for (let i = 0; i < this.handlers.length; i++) { |
| if (this.handlers[i].canHandleAuthentication(response)) { |
| authenticationHandler = this.handlers[i]; |
| break; |
| } |
| } |
| if (authenticationHandler) { |
| return authenticationHandler.handleAuthentication(this, info, data); |
| } |
| else { |
| // We have received an unauthorized response but have no handlers to handle it. |
| // Let the response return to the caller. |
| return response; |
| } |
| } |
| let redirectsRemaining = this._maxRedirects; |
| while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 && |
| this._allowRedirects && |
| redirectsRemaining > 0) { |
| const redirectUrl = response.message.headers['location']; |
| if (!redirectUrl) { |
| // if there's no location to redirect to, we won't |
| break; |
| } |
| let parsedRedirectUrl = new URL(redirectUrl); |
| if (parsedUrl.protocol == 'https:' && |
| parsedUrl.protocol != parsedRedirectUrl.protocol && |
| !this._allowRedirectDowngrade) { |
| throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); |
| } |
| // we need to finish reading the response before reassigning response |
| // which will leak the open socket. |
| await response.readBody(); |
| // strip authorization header if redirected to a different hostname |
| if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { |
| for (let header in headers) { |
| // header names are case insensitive |
| if (header.toLowerCase() === 'authorization') { |
| delete headers[header]; |
| } |
| } |
| } |
| // let's make the request with the new redirectUrl |
| info = this._prepareRequest(verb, parsedRedirectUrl, headers); |
| response = await this.requestRaw(info, data); |
| redirectsRemaining--; |
| } |
| if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { |
| // If not a retry code, return immediately instead of retrying |
| return response; |
| } |
| numTries += 1; |
| if (numTries < maxTries) { |
| await response.readBody(); |
| await this._performExponentialBackoff(numTries); |
| } |
| } |
| return response; |
| } |
| /** |
| * Needs to be called if keepAlive is set to true in request options. |
| */ |
| dispose() { |
| if (this._agent) { |
| this._agent.destroy(); |
| } |
| this._disposed = true; |
| } |
| /** |
| * Raw request. |
| * @param info |
| * @param data |
| */ |
| requestRaw(info, data) { |
| return new Promise((resolve, reject) => { |
| let callbackForResult = function (err, res) { |
| if (err) { |
| reject(err); |
| } |
| resolve(res); |
| }; |
| this.requestRawWithCallback(info, data, callbackForResult); |
| }); |
| } |
| /** |
| * Raw request with callback. |
| * @param info |
| * @param data |
| * @param onResult |
| */ |
| requestRawWithCallback(info, data, onResult) { |
| let socket; |
| if (typeof data === 'string') { |
| info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); |
| } |
| let callbackCalled = false; |
| let handleResult = (err, res) => { |
| if (!callbackCalled) { |
| callbackCalled = true; |
| onResult(err, res); |
| } |
| }; |
| let req = info.httpModule.request(info.options, (msg) => { |
| let res = new HttpClientResponse(msg); |
| handleResult(null, res); |
| }); |
| req.on('socket', sock => { |
| socket = sock; |
| }); |
| // If we ever get disconnected, we want the socket to timeout eventually |
| req.setTimeout(this._socketTimeout || 3 * 60000, () => { |
| if (socket) { |
| socket.end(); |
| } |
| handleResult(new Error('Request timeout: ' + info.options.path), null); |
| }); |
| req.on('error', function (err) { |
| // err has statusCode property |
| // res should have headers |
| handleResult(err, null); |
| }); |
| if (data && typeof data === 'string') { |
| req.write(data, 'utf8'); |
| } |
| if (data && typeof data !== 'string') { |
| data.on('close', function () { |
| req.end(); |
| }); |
| data.pipe(req); |
| } |
| else { |
| req.end(); |
| } |
| } |
| /** |
| * Gets an http agent. This function is useful when you need an http agent that handles |
| * routing through a proxy server - depending upon the url and proxy environment variables. |
| * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com |
| */ |
| getAgent(serverUrl) { |
| let parsedUrl = new URL(serverUrl); |
| return this._getAgent(parsedUrl); |
| } |
| _prepareRequest(method, requestUrl, headers) { |
| const info = {}; |
| info.parsedUrl = requestUrl; |
| const usingSsl = info.parsedUrl.protocol === 'https:'; |
| info.httpModule = usingSsl ? https : http; |
| const defaultPort = usingSsl ? 443 : 80; |
| info.options = {}; |
| info.options.host = info.parsedUrl.hostname; |
| info.options.port = info.parsedUrl.port |
| ? parseInt(info.parsedUrl.port) |
| : defaultPort; |
| info.options.path = |
| (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); |
| info.options.method = method; |
| info.options.headers = this._mergeHeaders(headers); |
| if (this.userAgent != null) { |
| info.options.headers['user-agent'] = this.userAgent; |
| } |
| info.options.agent = this._getAgent(info.parsedUrl); |
| // gives handlers an opportunity to participate |
| if (this.handlers) { |
| this.handlers.forEach(handler => { |
| handler.prepareRequest(info.options); |
| }); |
| } |
| return info; |
| } |
| _mergeHeaders(headers) { |
| const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); |
| if (this.requestOptions && this.requestOptions.headers) { |
| return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); |
| } |
| return lowercaseKeys(headers || {}); |
| } |
| _getExistingOrDefaultHeader(additionalHeaders, header, _default) { |
| const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); |
| let clientHeader; |
| if (this.requestOptions && this.requestOptions.headers) { |
| clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; |
| } |
| return additionalHeaders[header] || clientHeader || _default; |
| } |
| _getAgent(parsedUrl) { |
| let agent; |
| let proxyUrl = pm.getProxyUrl(parsedUrl); |
| let useProxy = proxyUrl && proxyUrl.hostname; |
| if (this._keepAlive && useProxy) { |
| agent = this._proxyAgent; |
| } |
| if (this._keepAlive && !useProxy) { |
| agent = this._agent; |
| } |
| // if agent is already assigned use that agent. |
| if (!!agent) { |
| return agent; |
| } |
| const usingSsl = parsedUrl.protocol === 'https:'; |
| let maxSockets = 100; |
| if (!!this.requestOptions) { |
| maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; |
| } |
| if (useProxy) { |
| // If using proxy, need tunnel |
| if (!tunnel) { |
| tunnel = __nccwpck_require__(294); |
| } |
| const agentOptions = { |
| maxSockets: maxSockets, |
| keepAlive: this._keepAlive, |
| proxy: { |
| ...((proxyUrl.username || proxyUrl.password) && { |
| proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` |
| }), |
| host: proxyUrl.hostname, |
| port: proxyUrl.port |
| } |
| }; |
| let tunnelAgent; |
| const overHttps = proxyUrl.protocol === 'https:'; |
| if (usingSsl) { |
| tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; |
| } |
| else { |
| tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; |
| } |
| agent = tunnelAgent(agentOptions); |
| this._proxyAgent = agent; |
| } |
| // if reusing agent across request and tunneling agent isn't assigned create a new agent |
| if (this._keepAlive && !agent) { |
| const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; |
| agent = usingSsl ? new https.Agent(options) : new http.Agent(options); |
| this._agent = agent; |
| } |
| // if not using private agent and tunnel agent isn't setup then use global agent |
| if (!agent) { |
| agent = usingSsl ? https.globalAgent : http.globalAgent; |
| } |
| if (usingSsl && this._ignoreSslError) { |
| // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process |
| // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options |
| // we have to cast it to any and change it directly |
| agent.options = Object.assign(agent.options || {}, { |
| rejectUnauthorized: false |
| }); |
| } |
| return agent; |
| } |
| _performExponentialBackoff(retryNumber) { |
| retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); |
| const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); |
| return new Promise(resolve => setTimeout(() => resolve(), ms)); |
| } |
| static dateTimeDeserializer(key, value) { |
| if (typeof value === 'string') { |
| let a = new Date(value); |
| if (!isNaN(a.valueOf())) { |
| return a; |
| } |
| } |
| return value; |
| } |
| async _processResponse(res, options) { |
| return new Promise(async (resolve, reject) => { |
| const statusCode = res.message.statusCode; |
| const response = { |
| statusCode: statusCode, |
| result: null, |
| headers: {} |
| }; |
| // not found leads to null obj returned |
| if (statusCode == HttpCodes.NotFound) { |
| resolve(response); |
| } |
| let obj; |
| let contents; |
| // get the result from the body |
| try { |
| contents = await res.readBody(); |
| if (contents && contents.length > 0) { |
| if (options && options.deserializeDates) { |
| obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); |
| } |
| else { |
| obj = JSON.parse(contents); |
| } |
| response.result = obj; |
| } |
| response.headers = res.message.headers; |
| } |
| catch (err) { |
| // Invalid resource (contents not json); leaving result obj null |
| } |
| // note that 3xx redirects are handled by the http layer. |
| if (statusCode > 299) { |
| let msg; |
| // if exception/error in body, attempt to get better error |
| if (obj && obj.message) { |
| msg = obj.message; |
| } |
| else if (contents && contents.length > 0) { |
| // it may be the case that the exception is in the body message as string |
| msg = contents; |
| } |
| else { |
| msg = 'Failed request: (' + statusCode + ')'; |
| } |
| let err = new HttpClientError(msg, statusCode); |
| err.result = response.result; |
| reject(err); |
| } |
| else { |
| resolve(response); |
| } |
| }); |
| } |
| } |
| exports.HttpClient = HttpClient; |
| |
| |
| /***/ }), |
| |
| /***/ 443: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| function getProxyUrl(reqUrl) { |
| let usingSsl = reqUrl.protocol === 'https:'; |
| let proxyUrl; |
| if (checkBypass(reqUrl)) { |
| return proxyUrl; |
| } |
| let proxyVar; |
| if (usingSsl) { |
| proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY']; |
| } |
| else { |
| proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY']; |
| } |
| if (proxyVar) { |
| proxyUrl = new URL(proxyVar); |
| } |
| return proxyUrl; |
| } |
| exports.getProxyUrl = getProxyUrl; |
| function checkBypass(reqUrl) { |
| if (!reqUrl.hostname) { |
| return false; |
| } |
| let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; |
| if (!noProxy) { |
| return false; |
| } |
| // Determine the request port |
| let reqPort; |
| if (reqUrl.port) { |
| reqPort = Number(reqUrl.port); |
| } |
| else if (reqUrl.protocol === 'http:') { |
| reqPort = 80; |
| } |
| else if (reqUrl.protocol === 'https:') { |
| reqPort = 443; |
| } |
| // Format the request hostname and hostname with port |
| let upperReqHosts = [reqUrl.hostname.toUpperCase()]; |
| if (typeof reqPort === 'number') { |
| upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); |
| } |
| // Compare request host against noproxy |
| for (let upperNoProxyItem of noProxy |
| .split(',') |
| .map(x => x.trim().toUpperCase()) |
| .filter(x => x)) { |
| if (upperReqHosts.some(x => x === upperNoProxyItem)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| exports.checkBypass = checkBypass; |
| |
| |
| /***/ }), |
| |
| /***/ 962: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| var _a; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getCmdPath = exports.tryGetExecutablePath = exports.isRooted = exports.isDirectory = exports.exists = exports.IS_WINDOWS = exports.unlink = exports.symlink = exports.stat = exports.rmdir = exports.rename = exports.readlink = exports.readdir = exports.mkdir = exports.lstat = exports.copyFile = exports.chmod = void 0; |
| const fs = __importStar(__nccwpck_require__(147)); |
| const path = __importStar(__nccwpck_require__(17)); |
| _a = fs.promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink; |
| exports.IS_WINDOWS = process.platform === 'win32'; |
| function exists(fsPath) { |
| return __awaiter(this, void 0, void 0, function* () { |
| try { |
| yield exports.stat(fsPath); |
| } |
| catch (err) { |
| if (err.code === 'ENOENT') { |
| return false; |
| } |
| throw err; |
| } |
| return true; |
| }); |
| } |
| exports.exists = exists; |
| function isDirectory(fsPath, useStat = false) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath); |
| return stats.isDirectory(); |
| }); |
| } |
| exports.isDirectory = isDirectory; |
| /** |
| * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like: |
| * \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases). |
| */ |
| function isRooted(p) { |
| p = normalizeSeparators(p); |
| if (!p) { |
| throw new Error('isRooted() parameter "p" cannot be empty'); |
| } |
| if (exports.IS_WINDOWS) { |
| return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello |
| ); // e.g. C: or C:\hello |
| } |
| return p.startsWith('/'); |
| } |
| exports.isRooted = isRooted; |
| /** |
| * Best effort attempt to determine whether a file exists and is executable. |
| * @param filePath file path to check |
| * @param extensions additional file extensions to try |
| * @return if file exists and is executable, returns the file path. otherwise empty string. |
| */ |
| function tryGetExecutablePath(filePath, extensions) { |
| return __awaiter(this, void 0, void 0, function* () { |
| let stats = undefined; |
| try { |
| // test file exists |
| stats = yield exports.stat(filePath); |
| } |
| catch (err) { |
| if (err.code !== 'ENOENT') { |
| // eslint-disable-next-line no-console |
| console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); |
| } |
| } |
| if (stats && stats.isFile()) { |
| if (exports.IS_WINDOWS) { |
| // on Windows, test for valid extension |
| const upperExt = path.extname(filePath).toUpperCase(); |
| if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) { |
| return filePath; |
| } |
| } |
| else { |
| if (isUnixExecutable(stats)) { |
| return filePath; |
| } |
| } |
| } |
| // try each extension |
| const originalFilePath = filePath; |
| for (const extension of extensions) { |
| filePath = originalFilePath + extension; |
| stats = undefined; |
| try { |
| stats = yield exports.stat(filePath); |
| } |
| catch (err) { |
| if (err.code !== 'ENOENT') { |
| // eslint-disable-next-line no-console |
| console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); |
| } |
| } |
| if (stats && stats.isFile()) { |
| if (exports.IS_WINDOWS) { |
| // preserve the case of the actual file (since an extension was appended) |
| try { |
| const directory = path.dirname(filePath); |
| const upperName = path.basename(filePath).toUpperCase(); |
| for (const actualName of yield exports.readdir(directory)) { |
| if (upperName === actualName.toUpperCase()) { |
| filePath = path.join(directory, actualName); |
| break; |
| } |
| } |
| } |
| catch (err) { |
| // eslint-disable-next-line no-console |
| console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); |
| } |
| return filePath; |
| } |
| else { |
| if (isUnixExecutable(stats)) { |
| return filePath; |
| } |
| } |
| } |
| } |
| return ''; |
| }); |
| } |
| exports.tryGetExecutablePath = tryGetExecutablePath; |
| function normalizeSeparators(p) { |
| p = p || ''; |
| if (exports.IS_WINDOWS) { |
| // convert slashes on Windows |
| p = p.replace(/\//g, '\\'); |
| // remove redundant slashes |
| return p.replace(/\\\\+/g, '\\'); |
| } |
| // remove redundant slashes |
| return p.replace(/\/\/+/g, '/'); |
| } |
| // on Mac/Linux, test the execute bit |
| // R W X R W X R W X |
| // 256 128 64 32 16 8 4 2 1 |
| function isUnixExecutable(stats) { |
| return ((stats.mode & 1) > 0 || |
| ((stats.mode & 8) > 0 && stats.gid === process.getgid()) || |
| ((stats.mode & 64) > 0 && stats.uid === process.getuid())); |
| } |
| // Get the path of cmd.exe in windows |
| function getCmdPath() { |
| var _a; |
| return (_a = process.env['COMSPEC']) !== null && _a !== void 0 ? _a : `cmd.exe`; |
| } |
| exports.getCmdPath = getCmdPath; |
| //# sourceMappingURL=io-util.js.map |
| |
| /***/ }), |
| |
| /***/ 436: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); |
| }) : (function(o, m, k, k2) { |
| if (k2 === undefined) k2 = k; |
| o[k2] = m[k]; |
| })); |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| }) : function(o, v) { |
| o["default"] = v; |
| }); |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.findInPath = exports.which = exports.mkdirP = exports.rmRF = exports.mv = exports.cp = void 0; |
| const assert_1 = __nccwpck_require__(491); |
| const childProcess = __importStar(__nccwpck_require__(81)); |
| const path = __importStar(__nccwpck_require__(17)); |
| const util_1 = __nccwpck_require__(837); |
| const ioUtil = __importStar(__nccwpck_require__(962)); |
| const exec = util_1.promisify(childProcess.exec); |
| const execFile = util_1.promisify(childProcess.execFile); |
| /** |
| * Copies a file or folder. |
| * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js |
| * |
| * @param source source path |
| * @param dest destination path |
| * @param options optional. See CopyOptions. |
| */ |
| function cp(source, dest, options = {}) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const { force, recursive, copySourceDirectory } = readCopyOptions(options); |
| const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; |
| // Dest is an existing file, but not forcing |
| if (destStat && destStat.isFile() && !force) { |
| return; |
| } |
| // If dest is an existing directory, should copy inside. |
| const newDest = destStat && destStat.isDirectory() && copySourceDirectory |
| ? path.join(dest, path.basename(source)) |
| : dest; |
| if (!(yield ioUtil.exists(source))) { |
| throw new Error(`no such file or directory: ${source}`); |
| } |
| const sourceStat = yield ioUtil.stat(source); |
| if (sourceStat.isDirectory()) { |
| if (!recursive) { |
| throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); |
| } |
| else { |
| yield cpDirRecursive(source, newDest, 0, force); |
| } |
| } |
| else { |
| if (path.relative(source, newDest) === '') { |
| // a file cannot be copied to itself |
| throw new Error(`'${newDest}' and '${source}' are the same file`); |
| } |
| yield copyFile(source, newDest, force); |
| } |
| }); |
| } |
| exports.cp = cp; |
| /** |
| * Moves a path. |
| * |
| * @param source source path |
| * @param dest destination path |
| * @param options optional. See MoveOptions. |
| */ |
| function mv(source, dest, options = {}) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (yield ioUtil.exists(dest)) { |
| let destExists = true; |
| if (yield ioUtil.isDirectory(dest)) { |
| // If dest is directory copy src into dest |
| dest = path.join(dest, path.basename(source)); |
| destExists = yield ioUtil.exists(dest); |
| } |
| if (destExists) { |
| if (options.force == null || options.force) { |
| yield rmRF(dest); |
| } |
| else { |
| throw new Error('Destination already exists'); |
| } |
| } |
| } |
| yield mkdirP(path.dirname(dest)); |
| yield ioUtil.rename(source, dest); |
| }); |
| } |
| exports.mv = mv; |
| /** |
| * Remove a path recursively with force |
| * |
| * @param inputPath path to remove |
| */ |
| function rmRF(inputPath) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (ioUtil.IS_WINDOWS) { |
| // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another |
| // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del. |
| // Check for invalid characters |
| // https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file |
| if (/[*"<>|]/.test(inputPath)) { |
| throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows'); |
| } |
| try { |
| const cmdPath = ioUtil.getCmdPath(); |
| if (yield ioUtil.isDirectory(inputPath, true)) { |
| yield exec(`${cmdPath} /s /c "rd /s /q "%inputPath%""`, { |
| env: { inputPath } |
| }); |
| } |
| else { |
| yield exec(`${cmdPath} /s /c "del /f /a "%inputPath%""`, { |
| env: { inputPath } |
| }); |
| } |
| } |
| catch (err) { |
| // if you try to delete a file that doesn't exist, desired result is achieved |
| // other errors are valid |
| if (err.code !== 'ENOENT') |
| throw err; |
| } |
| // Shelling out fails to remove a symlink folder with missing source, this unlink catches that |
| try { |
| yield ioUtil.unlink(inputPath); |
| } |
| catch (err) { |
| // if you try to delete a file that doesn't exist, desired result is achieved |
| // other errors are valid |
| if (err.code !== 'ENOENT') |
| throw err; |
| } |
| } |
| else { |
| let isDir = false; |
| try { |
| isDir = yield ioUtil.isDirectory(inputPath); |
| } |
| catch (err) { |
| // if you try to delete a file that doesn't exist, desired result is achieved |
| // other errors are valid |
| if (err.code !== 'ENOENT') |
| throw err; |
| return; |
| } |
| if (isDir) { |
| yield execFile(`rm`, [`-rf`, `${inputPath}`]); |
| } |
| else { |
| yield ioUtil.unlink(inputPath); |
| } |
| } |
| }); |
| } |
| exports.rmRF = rmRF; |
| /** |
| * Make a directory. Creates the full path with folders in between |
| * Will throw if it fails |
| * |
| * @param fsPath path to create |
| * @returns Promise<void> |
| */ |
| function mkdirP(fsPath) { |
| return __awaiter(this, void 0, void 0, function* () { |
| assert_1.ok(fsPath, 'a path argument must be provided'); |
| yield ioUtil.mkdir(fsPath, { recursive: true }); |
| }); |
| } |
| exports.mkdirP = mkdirP; |
| /** |
| * Returns path of a tool had the tool actually been invoked. Resolves via paths. |
| * If you check and the tool does not exist, it will throw. |
| * |
| * @param tool name of the tool |
| * @param check whether to check if tool exists |
| * @returns Promise<string> path to tool |
| */ |
| function which(tool, check) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (!tool) { |
| throw new Error("parameter 'tool' is required"); |
| } |
| // recursive when check=true |
| if (check) { |
| const result = yield which(tool, false); |
| if (!result) { |
| if (ioUtil.IS_WINDOWS) { |
| throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); |
| } |
| else { |
| throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); |
| } |
| } |
| return result; |
| } |
| const matches = yield findInPath(tool); |
| if (matches && matches.length > 0) { |
| return matches[0]; |
| } |
| return ''; |
| }); |
| } |
| exports.which = which; |
| /** |
| * Returns a list of all occurrences of the given tool on the system path. |
| * |
| * @returns Promise<string[]> the paths of the tool |
| */ |
| function findInPath(tool) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (!tool) { |
| throw new Error("parameter 'tool' is required"); |
| } |
| // build the list of extensions to try |
| const extensions = []; |
| if (ioUtil.IS_WINDOWS && process.env['PATHEXT']) { |
| for (const extension of process.env['PATHEXT'].split(path.delimiter)) { |
| if (extension) { |
| extensions.push(extension); |
| } |
| } |
| } |
| // if it's rooted, return it if exists. otherwise return empty. |
| if (ioUtil.isRooted(tool)) { |
| const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); |
| if (filePath) { |
| return [filePath]; |
| } |
| return []; |
| } |
| // if any path separators, return empty |
| if (tool.includes(path.sep)) { |
| return []; |
| } |
| // build the list of directories |
| // |
| // Note, technically "where" checks the current directory on Windows. From a toolkit perspective, |
| // it feels like we should not do this. Checking the current directory seems like more of a use |
| // case of a shell, and the which() function exposed by the toolkit should strive for consistency |
| // across platforms. |
| const directories = []; |
| if (process.env.PATH) { |
| for (const p of process.env.PATH.split(path.delimiter)) { |
| if (p) { |
| directories.push(p); |
| } |
| } |
| } |
| // find all matches |
| const matches = []; |
| for (const directory of directories) { |
| const filePath = yield ioUtil.tryGetExecutablePath(path.join(directory, tool), extensions); |
| if (filePath) { |
| matches.push(filePath); |
| } |
| } |
| return matches; |
| }); |
| } |
| exports.findInPath = findInPath; |
| function readCopyOptions(options) { |
| const force = options.force == null ? true : options.force; |
| const recursive = Boolean(options.recursive); |
| const copySourceDirectory = options.copySourceDirectory == null |
| ? true |
| : Boolean(options.copySourceDirectory); |
| return { force, recursive, copySourceDirectory }; |
| } |
| function cpDirRecursive(sourceDir, destDir, currentDepth, force) { |
| return __awaiter(this, void 0, void 0, function* () { |
| // Ensure there is not a run away recursive copy |
| if (currentDepth >= 255) |
| return; |
| currentDepth++; |
| yield mkdirP(destDir); |
| const files = yield ioUtil.readdir(sourceDir); |
| for (const fileName of files) { |
| const srcFile = `${sourceDir}/${fileName}`; |
| const destFile = `${destDir}/${fileName}`; |
| const srcFileStat = yield ioUtil.lstat(srcFile); |
| if (srcFileStat.isDirectory()) { |
| // Recurse |
| yield cpDirRecursive(srcFile, destFile, currentDepth, force); |
| } |
| else { |
| yield copyFile(srcFile, destFile, force); |
| } |
| } |
| // Change the mode for the newly created directory |
| yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); |
| }); |
| } |
| // Buffered file copy |
| function copyFile(srcFile, destFile, force) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { |
| // unlink/re-link it |
| try { |
| yield ioUtil.lstat(destFile); |
| yield ioUtil.unlink(destFile); |
| } |
| catch (e) { |
| // Try to override file permission |
| if (e.code === 'EPERM') { |
| yield ioUtil.chmod(destFile, '0666'); |
| yield ioUtil.unlink(destFile); |
| } |
| // other errors = it doesn't exist, no work to do |
| } |
| // Copy over symlink |
| const symlinkFull = yield ioUtil.readlink(srcFile); |
| yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null); |
| } |
| else if (!(yield ioUtil.exists(destFile)) || force) { |
| yield ioUtil.copyFile(srcFile, destFile); |
| } |
| }); |
| } |
| //# sourceMappingURL=io.js.map |
| |
| /***/ }), |
| |
| /***/ 294: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| module.exports = __nccwpck_require__(219); |
| |
| |
| /***/ }), |
| |
| /***/ 219: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| |
| |
| var net = __nccwpck_require__(808); |
| var tls = __nccwpck_require__(404); |
| var http = __nccwpck_require__(685); |
| var https = __nccwpck_require__(687); |
| var events = __nccwpck_require__(361); |
| var assert = __nccwpck_require__(491); |
| var util = __nccwpck_require__(837); |
| |
| |
| exports.httpOverHttp = httpOverHttp; |
| exports.httpsOverHttp = httpsOverHttp; |
| exports.httpOverHttps = httpOverHttps; |
| exports.httpsOverHttps = httpsOverHttps; |
| |
| |
| function httpOverHttp(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = http.request; |
| return agent; |
| } |
| |
| function httpsOverHttp(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = http.request; |
| agent.createSocket = createSecureSocket; |
| agent.defaultPort = 443; |
| return agent; |
| } |
| |
| function httpOverHttps(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = https.request; |
| return agent; |
| } |
| |
| function httpsOverHttps(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = https.request; |
| agent.createSocket = createSecureSocket; |
| agent.defaultPort = 443; |
| return agent; |
| } |
| |
| |
| function TunnelingAgent(options) { |
| var self = this; |
| self.options = options || {}; |
| self.proxyOptions = self.options.proxy || {}; |
| self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; |
| self.requests = []; |
| self.sockets = []; |
| |
| self.on('free', function onFree(socket, host, port, localAddress) { |
| var options = toOptions(host, port, localAddress); |
| for (var i = 0, len = self.requests.length; i < len; ++i) { |
| var pending = self.requests[i]; |
| if (pending.host === options.host && pending.port === options.port) { |
| // Detect the request to connect same origin server, |
| // reuse the connection. |
| self.requests.splice(i, 1); |
| pending.request.onSocket(socket); |
| return; |
| } |
| } |
| socket.destroy(); |
| self.removeSocket(socket); |
| }); |
| } |
| util.inherits(TunnelingAgent, events.EventEmitter); |
| |
| TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { |
| var self = this; |
| var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); |
| |
| if (self.sockets.length >= this.maxSockets) { |
| // We are over limit so we'll add it to the queue. |
| self.requests.push(options); |
| return; |
| } |
| |
| // If we are under maxSockets create a new one. |
| self.createSocket(options, function(socket) { |
| socket.on('free', onFree); |
| socket.on('close', onCloseOrRemove); |
| socket.on('agentRemove', onCloseOrRemove); |
| req.onSocket(socket); |
| |
| function onFree() { |
| self.emit('free', socket, options); |
| } |
| |
| function onCloseOrRemove(err) { |
| self.removeSocket(socket); |
| socket.removeListener('free', onFree); |
| socket.removeListener('close', onCloseOrRemove); |
| socket.removeListener('agentRemove', onCloseOrRemove); |
| } |
| }); |
| }; |
| |
| TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { |
| var self = this; |
| var placeholder = {}; |
| self.sockets.push(placeholder); |
| |
| var connectOptions = mergeOptions({}, self.proxyOptions, { |
| method: 'CONNECT', |
| path: options.host + ':' + options.port, |
| agent: false, |
| headers: { |
| host: options.host + ':' + options.port |
| } |
| }); |
| if (options.localAddress) { |
| connectOptions.localAddress = options.localAddress; |
| } |
| if (connectOptions.proxyAuth) { |
| connectOptions.headers = connectOptions.headers || {}; |
| connectOptions.headers['Proxy-Authorization'] = 'Basic ' + |
| new Buffer(connectOptions.proxyAuth).toString('base64'); |
| } |
| |
| debug('making CONNECT request'); |
| var connectReq = self.request(connectOptions); |
| connectReq.useChunkedEncodingByDefault = false; // for v0.6 |
| connectReq.once('response', onResponse); // for v0.6 |
| connectReq.once('upgrade', onUpgrade); // for v0.6 |
| connectReq.once('connect', onConnect); // for v0.7 or later |
| connectReq.once('error', onError); |
| connectReq.end(); |
| |
| function onResponse(res) { |
| // Very hacky. This is necessary to avoid http-parser leaks. |
| res.upgrade = true; |
| } |
| |
| function onUpgrade(res, socket, head) { |
| // Hacky. |
| process.nextTick(function() { |
| onConnect(res, socket, head); |
| }); |
| } |
| |
| function onConnect(res, socket, head) { |
| connectReq.removeAllListeners(); |
| socket.removeAllListeners(); |
| |
| if (res.statusCode !== 200) { |
| debug('tunneling socket could not be established, statusCode=%d', |
| res.statusCode); |
| socket.destroy(); |
| var error = new Error('tunneling socket could not be established, ' + |
| 'statusCode=' + res.statusCode); |
| error.code = 'ECONNRESET'; |
| options.request.emit('error', error); |
| self.removeSocket(placeholder); |
| return; |
| } |
| if (head.length > 0) { |
| debug('got illegal response body from proxy'); |
| socket.destroy(); |
| var error = new Error('got illegal response body from proxy'); |
| error.code = 'ECONNRESET'; |
| options.request.emit('error', error); |
| self.removeSocket(placeholder); |
| return; |
| } |
| debug('tunneling connection has established'); |
| self.sockets[self.sockets.indexOf(placeholder)] = socket; |
| return cb(socket); |
| } |
| |
| function onError(cause) { |
| connectReq.removeAllListeners(); |
| |
| debug('tunneling socket could not be established, cause=%s\n', |
| cause.message, cause.stack); |
| var error = new Error('tunneling socket could not be established, ' + |
| 'cause=' + cause.message); |
| error.code = 'ECONNRESET'; |
| options.request.emit('error', error); |
| self.removeSocket(placeholder); |
| } |
| }; |
| |
| TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { |
| var pos = this.sockets.indexOf(socket) |
| if (pos === -1) { |
| return; |
| } |
| this.sockets.splice(pos, 1); |
| |
| var pending = this.requests.shift(); |
| if (pending) { |
| // If we have pending requests and a socket gets closed a new one |
| // needs to be created to take over in the pool for the one that closed. |
| this.createSocket(pending, function(socket) { |
| pending.request.onSocket(socket); |
| }); |
| } |
| }; |
| |
| function createSecureSocket(options, cb) { |
| var self = this; |
| TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { |
| var hostHeader = options.request.getHeader('host'); |
| var tlsOptions = mergeOptions({}, self.options, { |
| socket: socket, |
| servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host |
| }); |
| |
| // 0 is dummy port for v0.6 |
| var secureSocket = tls.connect(0, tlsOptions); |
| self.sockets[self.sockets.indexOf(socket)] = secureSocket; |
| cb(secureSocket); |
| }); |
| } |
| |
| |
| function toOptions(host, port, localAddress) { |
| if (typeof host === 'string') { // since v0.10 |
| return { |
| host: host, |
| port: port, |
| localAddress: localAddress |
| }; |
| } |
| return host; // for v0.11 or later |
| } |
| |
| function mergeOptions(target) { |
| for (var i = 1, len = arguments.length; i < len; ++i) { |
| var overrides = arguments[i]; |
| if (typeof overrides === 'object') { |
| var keys = Object.keys(overrides); |
| for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { |
| var k = keys[j]; |
| if (overrides[k] !== undefined) { |
| target[k] = overrides[k]; |
| } |
| } |
| } |
| } |
| return target; |
| } |
| |
| |
| var debug; |
| if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { |
| debug = function() { |
| var args = Array.prototype.slice.call(arguments); |
| if (typeof args[0] === 'string') { |
| args[0] = 'TUNNEL: ' + args[0]; |
| } else { |
| args.unshift('TUNNEL:'); |
| } |
| console.error.apply(console, args); |
| } |
| } else { |
| debug = function() {}; |
| } |
| exports.debug = debug; // for test |
| |
| |
| /***/ }), |
| |
| /***/ 491: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("assert"); |
| |
| /***/ }), |
| |
| /***/ 81: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("child_process"); |
| |
| /***/ }), |
| |
| /***/ 361: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("events"); |
| |
| /***/ }), |
| |
| /***/ 147: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("fs"); |
| |
| /***/ }), |
| |
| /***/ 685: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("http"); |
| |
| /***/ }), |
| |
| /***/ 687: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("https"); |
| |
| /***/ }), |
| |
| /***/ 808: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("net"); |
| |
| /***/ }), |
| |
| /***/ 37: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("os"); |
| |
| /***/ }), |
| |
| /***/ 17: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("path"); |
| |
| /***/ }), |
| |
| /***/ 576: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("string_decoder"); |
| |
| /***/ }), |
| |
| /***/ 512: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("timers"); |
| |
| /***/ }), |
| |
| /***/ 404: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("tls"); |
| |
| /***/ }), |
| |
| /***/ 837: |
| /***/ ((module) => { |
| |
| module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("util"); |
| |
| /***/ }) |
| |
| /******/ }); |
| /************************************************************************/ |
| /******/ // The module cache |
| /******/ var __webpack_module_cache__ = {}; |
| /******/ |
| /******/ // The require function |
| /******/ function __nccwpck_require__(moduleId) { |
| /******/ // Check if module is in cache |
| /******/ var cachedModule = __webpack_module_cache__[moduleId]; |
| /******/ if (cachedModule !== undefined) { |
| /******/ return cachedModule.exports; |
| /******/ } |
| /******/ // Create a new module (and put it into the cache) |
| /******/ var module = __webpack_module_cache__[moduleId] = { |
| /******/ // no module.id needed |
| /******/ // no module.loaded needed |
| /******/ exports: {} |
| /******/ }; |
| /******/ |
| /******/ // Execute the module function |
| /******/ var threw = true; |
| /******/ try { |
| /******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__); |
| /******/ threw = false; |
| /******/ } finally { |
| /******/ if(threw) delete __webpack_module_cache__[moduleId]; |
| /******/ } |
| /******/ |
| /******/ // Return the exports of the module |
| /******/ return module.exports; |
| /******/ } |
| /******/ |
| /************************************************************************/ |
| /******/ /* webpack/runtime/compat get default export */ |
| /******/ (() => { |
| /******/ // getDefaultExport function for compatibility with non-harmony modules |
| /******/ __nccwpck_require__.n = (module) => { |
| /******/ var getter = module && module.__esModule ? |
| /******/ () => (module['default']) : |
| /******/ () => (module); |
| /******/ __nccwpck_require__.d(getter, { a: getter }); |
| /******/ return getter; |
| /******/ }; |
| /******/ })(); |
| /******/ |
| /******/ /* webpack/runtime/define property getters */ |
| /******/ (() => { |
| /******/ // define getter functions for harmony exports |
| /******/ __nccwpck_require__.d = (exports, definition) => { |
| /******/ for(var key in definition) { |
| /******/ if(__nccwpck_require__.o(definition, key) && !__nccwpck_require__.o(exports, key)) { |
| /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); |
| /******/ } |
| /******/ } |
| /******/ }; |
| /******/ })(); |
| /******/ |
| /******/ /* webpack/runtime/hasOwnProperty shorthand */ |
| /******/ (() => { |
| /******/ __nccwpck_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) |
| /******/ })(); |
| /******/ |
| /******/ /* webpack/runtime/compat */ |
| /******/ |
| /******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = new URL('.', import.meta.url).pathname.slice(import.meta.url.match(/^file:\/\/\/\w:/) ? 1 : 0, -1) + "/"; |
| /******/ |
| /************************************************************************/ |
| var __webpack_exports__ = {}; |
| // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk. |
| (() => { |
| /* harmony import */ var _actions_core__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(186); |
| /* harmony import */ var _actions_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__nccwpck_require__.n(_actions_core__WEBPACK_IMPORTED_MODULE_0__); |
| /* harmony import */ var _actions_exec__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(514); |
| /* harmony import */ var _actions_exec__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__nccwpck_require__.n(_actions_exec__WEBPACK_IMPORTED_MODULE_1__); |
| var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) { |
| function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| return new (P || (P = Promise))(function (resolve, reject) { |
| function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| |
| |
| function run() { |
| return __awaiter(this, void 0, void 0, function* () { |
| const port = _actions_core__WEBPACK_IMPORTED_MODULE_0__.getInput('port'); |
| let runArguments = [ |
| "run", "-d", "-p", `${port}:12321`, |
| "--name", "cache_proxy", |
| "--env", "ACTIONS_CACHE_URL", |
| "--env", "ACTIONS_RUNTIME_URL", |
| "--env", "ACTIONS_RUNTIME_TOKEN", |
| "ghcr.io/cirruslabs/actions-http-cache-proxy:latest" |
| ]; |
| try { |
| yield (0,_actions_exec__WEBPACK_IMPORTED_MODULE_1__.exec)(`"docker"`, runArguments); |
| } |
| catch (e) { |
| _actions_core__WEBPACK_IMPORTED_MODULE_0__.error(e); |
| } |
| }); |
| } |
| run(); |
| |
| })(); |
| |