zephyr-agent/dist/lib/node-persist/ci-token-identity/gitlab.js

Zephyr plugin agent

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    gitLabCiIdentityProvider: ()=>gitLabCiIdentityProvider
});
const external_utils_js_namespaceObject = require("./utils.js");
const GITLAB_JOB_FETCH_TIMEOUT_MS = 10000;
const gitLabCiIdentityProvider = {
    provider: 'gitlab',
    detect: isGitLabCi,
    infer: inferGitLabIdentity
};
function isGitLabCi(env) {
    return 'true' === env['GITLAB_CI'] || 'GitLab' === env['CI_SERVER_NAME'];
}
async function inferGitLabIdentity(env) {
    const payload = (0, external_utils_js_namespaceObject.decodeJwtPayload)(env['CI_JOB_TOKEN']);
    const jwtEmails = (0, external_utils_js_namespaceObject.getEmailClaims)(payload, [
        'user_email',
        'email'
    ]);
    if (payload && jwtEmails.length > 0 && gitLabClaimsMatchEnvironment(payload, env)) return {
        provider: 'gitlab',
        email: jwtEmails[0],
        emails: jwtEmails,
        issuer: getGitLabIssuer(env),
        providerSubject: (0, external_utils_js_namespaceObject.getStringClaim)(payload, [
            'user_id',
            'user_login',
            'sub'
        ]),
        username: (0, external_utils_js_namespaceObject.getStringClaim)(payload, [
            'user_login',
            'username'
        ]),
        source: 'jwt'
    };
    const apiIdentity = await inferGitLabIdentityFromApi(env);
    if (apiIdentity) return apiIdentity;
    const envEmail = (0, external_utils_js_namespaceObject.getEmail)(env['GITLAB_USER_EMAIL']);
    if (envEmail) return {
        provider: 'gitlab',
        email: envEmail,
        emails: [
            envEmail
        ],
        issuer: getGitLabIssuer(env),
        providerSubject: env['GITLAB_USER_ID']?.trim(),
        username: env['GITLAB_USER_LOGIN']?.trim() || void 0,
        source: 'env'
    };
}
async function inferGitLabIdentityFromApi(env) {
    const apiUrl = getGitLabApiUrl(env);
    const jobToken = env['CI_JOB_TOKEN']?.trim();
    if (!apiUrl || !jobToken) return;
    try {
        const job = await fetchGitLabJob(apiUrl, jobToken);
        if (!gitLabJobMatchesEnvironment(job, env)) return;
        const emails = (0, external_utils_js_namespaceObject.getEmails)([
            job.user?.email,
            job.user?.public_email,
            job.commit?.author_email
        ]);
        if (0 === emails.length) return;
        return {
            provider: 'gitlab',
            email: emails[0],
            emails,
            issuer: getGitLabIssuer(env),
            providerSubject: (0, external_utils_js_namespaceObject.stringifyId)(job.user?.id) ?? env['GITLAB_USER_ID']?.trim(),
            username: job.user?.username?.trim() || void 0,
            source: 'api'
        };
    } catch  {
        return;
    }
}
function getGitLabIssuer(env) {
    const serverUrl = env['CI_SERVER_URL']?.trim();
    if (serverUrl) return serverUrl.replace(/\/+$/, '').toLowerCase();
    const apiUrl = env['CI_API_V4_URL']?.trim();
    return apiUrl ? apiUrl.replace(/\/api\/v4\/?$/, '').replace(/\/+$/, '').toLowerCase() : void 0;
}
function getGitLabApiUrl(env) {
    const apiUrl = env['CI_API_V4_URL']?.trim();
    if (apiUrl) return apiUrl;
    const serverUrl = env['CI_SERVER_URL']?.trim();
    return serverUrl ? `${serverUrl.replace(/\/$/, '')}/api/v4` : void 0;
}
async function fetchGitLabJob(apiUrl, jobToken) {
    const url = new URL('job', apiUrl.endsWith('/') ? apiUrl : `${apiUrl}/`);
    const response = await fetch(url.toString(), {
        headers: {
            'JOB-TOKEN': jobToken
        },
        signal: AbortSignal.timeout(GITLAB_JOB_FETCH_TIMEOUT_MS)
    });
    if (!response.ok) return {};
    return await response.json();
}
function gitLabClaimsMatchEnvironment(payload, env) {
    if (!payload) return false;
    return (0, external_utils_js_namespaceObject.claimMatchesEnv)(payload, 'job_id', env['CI_JOB_ID']) && (0, external_utils_js_namespaceObject.claimMatchesEnv)(payload, 'project_id', env['CI_PROJECT_ID']) && (0, external_utils_js_namespaceObject.claimMatchesEnv)(payload, 'pipeline_id', env['CI_PIPELINE_ID']);
}
function gitLabJobMatchesEnvironment(job, env) {
    return (0, external_utils_js_namespaceObject.claimMatchesEnv)({
        job_id: job.id
    }, 'job_id', env['CI_JOB_ID']) && (0, external_utils_js_namespaceObject.claimMatchesEnv)({
        project_id: job.pipeline?.project_id
    }, 'project_id', env['CI_PROJECT_ID']) && (0, external_utils_js_namespaceObject.claimMatchesEnv)({
        pipeline_id: job.pipeline?.id
    }, 'pipeline_id', env['CI_PIPELINE_ID']);
}
exports.gitLabCiIdentityProvider = __webpack_exports__.gitLabCiIdentityProvider;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "gitLabCiIdentityProvider"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=gitlab.js.map