@argos-ci/core 2.9.2 → 2.10.0

package/dist/index.mjs

@@ -1,1039 +0,0 @@
-import { createClient, throwAPIError } from '@argos-ci/api-client';
-import convict from 'convict';
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, createReadStream } from 'node:fs';
-import axios from 'axios';
-import createDebug from 'debug';
-import { resolve } from 'node:path';
-import glob from 'fast-glob';
-import { promisify } from 'node:util';
-import sharp from 'sharp';
-import tmp from 'tmp';
-import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { readVersionFromPackage, readMetadata, getPlaywrightTracePath } from '@argos-ci/util';
-import { createRequire } from 'node:module';
-
-/**
- * Check if the current directory is a git repository.
- */ function checkIsGitRepository() {
-    try {
-        return execSync("git rev-parse --is-inside-work-tree").toString().trim() === "true";
-    } catch  {
-        return false;
-    }
-}
-/**
- * Returns the head commit.
- */ function head() {
-    try {
-        return execSync("git rev-parse HEAD").toString().trim();
-    } catch  {
-        return null;
-    }
-}
-/**
- * Returns the current branch.
- */ function branch() {
-    try {
-        const headRef = execSync("git rev-parse --abbrev-ref HEAD").toString().trim();
-        if (headRef === "HEAD") {
-            return null;
-        }
-        return headRef;
-    } catch  {
-        return null;
-    }
-}
-function getMergeBaseCommitShaWithDepth(input) {
-    try {
-        execSync(`git fetch --update-head-ok --depth ${input.depth} origin ${input.head}:${input.head}`);
-        execSync(`git fetch --update-head-ok --depth ${input.depth} origin ${input.base}:${input.base}`);
-        const mergeBase = execSync(`git merge-base ${input.head} ${input.base}`).toString().trim();
-        return mergeBase || null;
-    } catch  {
-        return null;
-    }
-}
-function getMergeBaseCommitSha$1(input) {
-    let depth = 200;
-    while(depth < 1000){
-        const mergeBase = getMergeBaseCommitShaWithDepth({
-            depth,
-            ...input
-        });
-        if (mergeBase) {
-            return mergeBase;
-        }
-        depth += 200;
-    }
-    return null;
-}
-function listParentCommits$1(input) {
-    try {
-        execSync(`git fetch --depth=200 origin ${input.sha}`);
-        const raw = execSync(`git log --format="%H" --max-count=200 ${input.sha}`);
-        const shas = raw.toString().trim().split("\n");
-        return shas;
-    } catch  {
-        return null;
-    }
-}
-
-const getPrNumber$2 = ({ env })=>{
-    return env.BITRISE_PULL_REQUEST ? Number(env.BITRISE_PULL_REQUEST) : null;
-};
-const service$7 = {
-    name: "Bitrise",
-    key: "bitrise",
-    detect: ({ env })=>Boolean(env.BITRISE_IO),
-    config: ({ env })=>{
-        return {
-            commit: env.BITRISE_GIT_COMMIT || null,
-            branch: env.BITRISE_GIT_BRANCH || null,
-            owner: env.BITRISEIO_GIT_REPOSITORY_OWNER || null,
-            repository: env.BITRISEIO_GIT_REPOSITORY_SLUG || null,
-            jobId: null,
-            runId: null,
-            runAttempt: null,
-            prNumber: getPrNumber$2({
-                env
-            }),
-            prHeadCommit: null,
-            prBaseBranch: null,
-            nonce: env.BITRISEIO_PIPELINE_ID || null
-        };
-    },
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-const service$6 = {
-    name: "Buildkite",
-    key: "buildkite",
-    detect: ({ env })=>Boolean(env.BUILDKITE),
-    config: ({ env })=>{
-        return {
-            // Buildkite doesn't work well so we fallback to git to ensure we have commit and branch
-            commit: env.BUILDKITE_COMMIT || head() || null,
-            branch: env.BUILDKITE_BRANCH || branch() || null,
-            owner: env.BUILDKITE_ORGANIZATION_SLUG || null,
-            repository: env.BUILDKITE_PROJECT_SLUG || null,
-            jobId: null,
-            runId: null,
-            runAttempt: null,
-            prNumber: env.BUILDKITE_PULL_REQUEST ? Number(env.BUILDKITE_PULL_REQUEST) : null,
-            prHeadCommit: null,
-            prBaseBranch: null,
-            nonce: env.BUILDKITE_BUILD_ID || null
-        };
-    },
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-const service$5 = {
-    name: "Heroku",
-    key: "heroku",
-    detect: ({ env })=>Boolean(env.HEROKU_TEST_RUN_ID),
-    config: ({ env })=>({
-            commit: env.HEROKU_TEST_RUN_COMMIT_VERSION || null,
-            branch: env.HEROKU_TEST_RUN_BRANCH || null,
-            owner: null,
-            repository: null,
-            jobId: null,
-            runId: null,
-            runAttempt: null,
-            prNumber: null,
-            prHeadCommit: null,
-            prBaseBranch: null,
-            nonce: env.HEROKU_TEST_RUN_ID || null
-        }),
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-const KEY = "@argos-ci/core";
-const debug = createDebug(KEY);
-const debugTime = (arg)=>{
-    const enabled = createDebug.enabled(KEY);
-    if (enabled) {
-        console.time(arg);
-    }
-};
-const debugTimeEnd = (arg)=>{
-    const enabled = createDebug.enabled(KEY);
-    if (enabled) {
-        console.timeEnd(arg);
-    }
-};
-
-/**
- * Get a pull request from a head sha.
- * Fetch the last 30 pull requests sorted by updated date
- * then try to find the one that matches the head sha.
- * If no pull request is found, return null.
- */ async function getPullRequestFromHeadSha({ env }, sha) {
-    debug("Fetching pull request number from head sha", sha);
-    if (!env.GITHUB_REPOSITORY) {
-        throw new Error("GITHUB_REPOSITORY is missing");
-    }
-    if (!env.GITHUB_TOKEN) {
-        // For security reasons, people doesn't want to expose their GITHUB_TOKEN
-        // That's why we allow to disable this warning.
-        if (!env.DISABLE_GITHUB_TOKEN_WARNING) {
-            console.log(`
-Running argos from a "deployment_status" event requires a GITHUB_TOKEN.
-Please add \`GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}\` as environment variable.
-
-Read more at https://argos-ci.com/docs/run-on-preview-deployment
-
-To disable this warning, add \`DISABLE_GITHUB_TOKEN_WARNING: true\` as environment variable.
-`.trim());
-        }
-        return null;
-    }
-    try {
-        const result = await axios.get(`https://api.github.com/repos/${env.GITHUB_REPOSITORY}/pulls`, {
-            params: {
-                state: "open",
-                sort: "updated",
-                per_page: 30,
-                page: 1
-            },
-            headers: {
-                Accept: "application/vnd.github+json",
-                Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
-                "X-GitHub-Api-Version": "2022-11-28"
-            }
-        });
-        if (result.data.length === 0) {
-            debug("Aborting because no pull request found");
-            return null;
-        }
-        const matchingPr = result.data.find((pr)=>pr.head.sha === sha);
-        if (matchingPr) {
-            debug("Pull request found", matchingPr);
-            return matchingPr;
-        }
-        debug("Aborting because no pull request found");
-        return null;
-    } catch (error) {
-        debug("Error while fetching pull request from head sha", error);
-        return null;
-    }
-}
-function getBranch(context, eventPayload) {
-    if (eventPayload?.pull_request?.head.ref) {
-        return eventPayload.pull_request.head.ref;
-    }
-    const { env } = context;
-    if (env.GITHUB_HEAD_REF) {
-        return env.GITHUB_HEAD_REF;
-    }
-    if (!env.GITHUB_REF) {
-        return null;
-    }
-    const branchRegex = /refs\/heads\/(.*)/;
-    const matches = branchRegex.exec(env.GITHUB_REF);
-    return matches?.[1] ?? null;
-}
-function getRepository$1({ env }) {
-    if (!env.GITHUB_REPOSITORY) return null;
-    return env.GITHUB_REPOSITORY.split("/")[1] || null;
-}
-function readEventPayload({ env }) {
-    if (!env.GITHUB_EVENT_PATH) return null;
-    if (!existsSync(env.GITHUB_EVENT_PATH)) return null;
-    return JSON.parse(readFileSync(env.GITHUB_EVENT_PATH, "utf-8"));
-}
-const service$4 = {
-    name: "GitHub Actions",
-    key: "github-actions",
-    detect: (context)=>Boolean(context.env.GITHUB_ACTIONS),
-    config: async (context)=>{
-        const { env } = context;
-        const payload = readEventPayload(context);
-        const sha = process.env.GITHUB_SHA || null;
-        if (!sha) {
-            throw new Error(`GITHUB_SHA is missing`);
-        }
-        const commonConfig = {
-            commit: sha,
-            owner: env.GITHUB_REPOSITORY_OWNER || null,
-            repository: getRepository$1(context),
-            jobId: env.GITHUB_JOB || null,
-            runId: env.GITHUB_RUN_ID || null,
-            runAttempt: env.GITHUB_RUN_ATTEMPT ? Number(env.GITHUB_RUN_ATTEMPT) : null,
-            nonce: `${env.GITHUB_RUN_ID}-${env.GITHUB_RUN_ATTEMPT}` || null
-        };
-        // If the job is triggered by from a "deployment" or a "deployment_status"
-        if (payload?.deployment) {
-            debug("Deployment event detected");
-            // Try to find a relevant pull request for the sha
-            const pullRequest = await getPullRequestFromHeadSha(context, sha);
-            return {
-                ...commonConfig,
-                // If no pull request is found, we fallback to the deployment environment as branch name
-                // Branch name is required to create a build but has no real impact on the build.
-                branch: pullRequest?.head.ref || payload.deployment.environment || null,
-                prNumber: pullRequest?.number || null,
-                prHeadCommit: pullRequest?.head.sha || null,
-                prBaseBranch: null
-            };
-        }
-        return {
-            ...commonConfig,
-            branch: payload?.pull_request?.head.ref || getBranch(context, payload) || null,
-            prNumber: payload?.pull_request?.number || null,
-            prHeadCommit: payload?.pull_request?.head.sha ?? null,
-            prBaseBranch: payload?.pull_request?.base.ref ?? null
-        };
-    },
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-const getPrNumber$1 = ({ env })=>{
-    const branchRegex = /pull\/(\d+)/;
-    const matches = branchRegex.exec(env.CIRCLE_PULL_REQUEST || "");
-    if (matches) {
-        return Number(matches[1]);
-    }
-    return null;
-};
-const service$3 = {
-    name: "CircleCI",
-    key: "circleci",
-    detect: ({ env })=>Boolean(env.CIRCLECI),
-    config: ({ env })=>{
-        return {
-            commit: env.CIRCLE_SHA1 || null,
-            branch: env.CIRCLE_BRANCH || null,
-            owner: env.CIRCLE_PROJECT_USERNAME || null,
-            repository: env.CIRCLE_PROJECT_REPONAME || null,
-            jobId: null,
-            runId: null,
-            runAttempt: null,
-            prNumber: getPrNumber$1({
-                env
-            }),
-            prHeadCommit: null,
-            prBaseBranch: null,
-            nonce: env.CIRCLE_WORKFLOW_ID || env.CIRCLE_BUILD_NUM || null
-        };
-    },
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-const getOwner = ({ env })=>{
-    if (!env.TRAVIS_REPO_SLUG) return null;
-    return env.TRAVIS_REPO_SLUG.split("/")[0] || null;
-};
-const getRepository = ({ env })=>{
-    if (!env.TRAVIS_REPO_SLUG) return null;
-    return env.TRAVIS_REPO_SLUG.split("/")[1] || null;
-};
-const getPrNumber = ({ env })=>{
-    if (env.TRAVIS_PULL_REQUEST) return Number(env.TRAVIS_PULL_REQUEST);
-    return null;
-};
-const service$2 = {
-    name: "Travis CI",
-    key: "travis",
-    detect: ({ env })=>Boolean(env.TRAVIS),
-    config: (ctx)=>{
-        const { env } = ctx;
-        return {
-            commit: env.TRAVIS_COMMIT || null,
-            branch: env.TRAVIS_BRANCH || null,
-            owner: getOwner(ctx),
-            repository: getRepository(ctx),
-            jobId: null,
-            runId: null,
-            runAttempt: null,
-            prNumber: getPrNumber(ctx),
-            prHeadCommit: null,
-            prBaseBranch: null,
-            nonce: env.TRAVIS_BUILD_ID || null
-        };
-    },
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-const service$1 = {
-    name: "GitLab",
-    key: "gitlab",
-    detect: ({ env })=>env.GITLAB_CI === "true",
-    config: ({ env })=>{
-        return {
-            commit: env.CI_COMMIT_SHA || null,
-            branch: env.CI_COMMIT_REF_NAME || null,
-            owner: null,
-            repository: null,
-            jobId: null,
-            runId: null,
-            runAttempt: null,
-            prNumber: null,
-            prHeadCommit: null,
-            prBaseBranch: null,
-            nonce: env.CI_PIPELINE_ID || null
-        };
-    },
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-const service = {
-    name: "Git",
-    key: "git",
-    detect: ()=>checkIsGitRepository(),
-    config: ()=>{
-        return {
-            commit: head() || null,
-            branch: branch() || null,
-            owner: null,
-            repository: null,
-            jobId: null,
-            runId: null,
-            runAttempt: null,
-            prNumber: null,
-            prHeadCommit: null,
-            prBaseBranch: null,
-            nonce: null
-        };
-    },
-    getMergeBaseCommitSha: getMergeBaseCommitSha$1,
-    listParentCommits: listParentCommits$1
-};
-
-// List of services ordered by usage
-// "git" must be the last one
-const services = [
-    service$5,
-    service$4,
-    service$3,
-    service$2,
-    service$6,
-    service$1,
-    service$7,
-    service
-];
-/**
- * Create the context for the CI service detection.
- */ function createContext() {
-    return {
-        env: process.env
-    };
-}
-/**
- * Get the CI service that is currently running.
- */ function getCiService(context) {
-    return services.find((service)=>service.detect(context));
-}
-/**
- * Get the merge base commit.
- */ function getMergeBaseCommitSha(input) {
-    const context = createContext();
-    const service = getCiService(context);
-    if (!service) {
-        return null;
-    }
-    return service.getMergeBaseCommitSha(input, context);
-}
-/**
- * Get the merge base commit.
- */ function listParentCommits(input) {
-    const context = createContext();
-    const service = getCiService(context);
-    if (!service) {
-        return null;
-    }
-    return service.listParentCommits(input, context);
-}
-/**
- * Get the CI environment.
- */ async function getCiEnvironment() {
-    const context = createContext();
-    debug("Detecting CI environment", context);
-    const service = getCiService(context);
-    // Service matched
-    if (service) {
-        debug("Internal service matched", service.name);
-        const variables = await service.config(context);
-        const ciEnvironment = {
-            name: service.name,
-            key: service.key,
-            ...variables
-        };
-        debug("CI environment", ciEnvironment);
-        return ciEnvironment;
-    }
-    return null;
-}
-
-const mustBeApiBaseUrl = (value)=>{
-    const URL_REGEX = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/;
-    if (!URL_REGEX.test(value)) {
-        throw new Error("Invalid Argos API base URL");
-    }
-};
-const mustBeCommit = (value)=>{
-    const SHA1_REGEX = /^[0-9a-f]{40}$/;
-    if (!SHA1_REGEX.test(value)) {
-        const SHA1_SHORT_REGEX = /^[0-9a-f]{7}$/;
-        if (SHA1_SHORT_REGEX.test(value)) {
-            throw new Error("Short SHA1 is not allowed");
-        }
-        throw new Error("Invalid commit");
-    }
-};
-const mustBeArgosToken = (value)=>{
-    if (value && value.length !== 40) {
-        throw new Error("Invalid Argos repository token (must be 40 characters)");
-    }
-};
-convict.addFormat({
-    name: "float-percent",
-    validate: function(val) {
-        if (val !== 0 && (!val || val > 1 || val < 0)) {
-            throw new Error("Must be a float between 0 and 1, inclusive.");
-        }
-    },
-    coerce: function(val) {
-        return parseFloat(val);
-    }
-});
-const schema = {
-    apiBaseUrl: {
-        env: "ARGOS_API_BASE_URL",
-        default: "https://api.argos-ci.com/v2/",
-        format: mustBeApiBaseUrl
-    },
-    commit: {
-        env: "ARGOS_COMMIT",
-        default: null,
-        format: mustBeCommit
-    },
-    branch: {
-        env: "ARGOS_BRANCH",
-        default: null,
-        format: String
-    },
-    token: {
-        env: "ARGOS_TOKEN",
-        default: null,
-        format: mustBeArgosToken
-    },
-    buildName: {
-        env: "ARGOS_BUILD_NAME",
-        default: null,
-        format: String,
-        nullable: true
-    },
-    mode: {
-        env: "ARGOS_MODE",
-        format: [
-            "ci",
-            "monitoring"
-        ],
-        default: null,
-        nullable: true
-    },
-    prNumber: {
-        env: "ARGOS_PR_NUMBER",
-        format: Number,
-        default: null,
-        nullable: true
-    },
-    prHeadCommit: {
-        env: "ARGOS_PR_HEAD_COMMIT",
-        format: String,
-        default: null,
-        nullable: true
-    },
-    prBaseBranch: {
-        env: "ARGOS_PR_BASE_BRANCH",
-        format: String,
-        default: null,
-        nullable: true
-    },
-    parallel: {
-        env: "ARGOS_PARALLEL",
-        default: false,
-        format: Boolean
-    },
-    parallelNonce: {
-        env: "ARGOS_PARALLEL_NONCE",
-        format: String,
-        default: null,
-        nullable: true
-    },
-    parallelIndex: {
-        env: "ARGOS_PARALLEL_INDEX",
-        format: "nat",
-        default: null,
-        nullable: true
-    },
-    parallelTotal: {
-        env: "ARGOS_PARALLEL_TOTAL",
-        format: "int",
-        default: null,
-        nullable: true
-    },
-    referenceBranch: {
-        env: "ARGOS_REFERENCE_BRANCH",
-        format: String,
-        default: null,
-        nullable: true
-    },
-    referenceCommit: {
-        env: "ARGOS_REFERENCE_COMMIT",
-        format: String,
-        default: null,
-        nullable: true
-    },
-    jobId: {
-        format: String,
-        default: null,
-        nullable: true
-    },
-    runId: {
-        format: String,
-        default: null,
-        nullable: true
-    },
-    runAttempt: {
-        format: "nat",
-        default: null,
-        nullable: true
-    },
-    owner: {
-        format: String,
-        default: null,
-        nullable: true
-    },
-    repository: {
-        format: String,
-        default: null,
-        nullable: true
-    },
-    ciProvider: {
-        format: String,
-        default: null,
-        nullable: true
-    },
-    threshold: {
-        env: "ARGOS_THRESHOLD",
-        format: "float-percent",
-        default: null,
-        nullable: true
-    }
-};
-const createConfig = ()=>{
-    return convict(schema, {
-        args: []
-    });
-};
-async function readConfig(options = {}) {
-    const config = createConfig();
-    const ciEnv = await getCiEnvironment();
-    config.load({
-        apiBaseUrl: options.apiBaseUrl || config.get("apiBaseUrl"),
-        commit: options.commit || config.get("commit") || ciEnv?.commit || null,
-        branch: options.branch || config.get("branch") || ciEnv?.branch || null,
-        token: options.token || config.get("token") || null,
-        buildName: options.buildName || config.get("buildName") || null,
-        prNumber: options.prNumber || config.get("prNumber") || ciEnv?.prNumber || null,
-        prHeadCommit: config.get("prHeadCommit") || ciEnv?.prHeadCommit || null,
-        prBaseBranch: config.get("prBaseBranch") || ciEnv?.prBaseBranch || null,
-        referenceBranch: options.referenceBranch || config.get("referenceBranch") || null,
-        referenceCommit: options.referenceCommit || config.get("referenceCommit") || null,
-        owner: ciEnv?.owner || null,
-        repository: ciEnv?.repository || null,
-        jobId: ciEnv?.jobId || null,
-        runId: ciEnv?.runId || null,
-        runAttempt: ciEnv?.runAttempt || null,
-        parallel: options.parallel ?? config.get("parallel") ?? false,
-        parallelNonce: options.parallelNonce || config.get("parallelNonce") || ciEnv?.nonce || null,
-        parallelTotal: options.parallelTotal ?? config.get("parallelTotal") ?? null,
-        parallelIndex: options.parallelIndex ?? config.get("parallelIndex") ?? null,
-        mode: options.mode || config.get("mode") || null,
-        ciProvider: ciEnv?.key || null
-    });
-    config.validate();
-    return config.get();
-}
-
-const discoverScreenshots = async (patterns, { root = process.cwd(), ignore } = {})=>{
-    debug(`Discovering screenshots with patterns: ${Array.isArray(patterns) ? patterns.join(", ") : patterns} in ${root}`);
-    const matches = await glob(patterns, {
-        onlyFiles: true,
-        ignore,
-        cwd: root
-    });
-    return matches.map((match)=>{
-        debug(`Found screenshot: ${match}`);
-        const path = resolve(root, match);
-        return {
-            name: match,
-            path
-        };
-    });
-};
-
-const tmpFile = promisify(tmp.file);
-const optimizeScreenshot = async (filepath)=>{
-    try {
-        const resultFilePath = await tmpFile();
-        await sharp(filepath).resize(2048, 20480, {
-            fit: "inside",
-            withoutEnlargement: true
-        }).png({
-            force: true
-        }).toFile(resultFilePath);
-        return resultFilePath;
-    } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown Error";
-        throw new Error(`Error while processing image (${filepath}): ${message}`, {
-            cause: error
-        });
-    }
-};
-
-const hashFile = async (filepath)=>{
-    const fileStream = createReadStream(filepath);
-    const hash = createHash("sha256");
-    await new Promise((resolve, reject)=>{
-        fileStream.on("error", reject);
-        hash.on("error", reject);
-        hash.on("finish", resolve);
-        fileStream.pipe(hash);
-    });
-    return hash.digest("hex");
-};
-
-const base64Encode = (obj)=>Buffer.from(JSON.stringify(obj), "utf8").toString("base64");
-/**
- * Get the authentication token.
- */ function getAuthToken({ token, ciProvider, owner, repository, jobId, runId, prNumber }) {
-    if (token) {
-        return token;
-    }
-    switch(ciProvider){
-        case "github-actions":
-            {
-                if (!owner || !repository || !jobId || !runId) {
-                    throw new Error(`Automatic GitHub Actions variables detection failed. Please add the 'ARGOS_TOKEN'`);
-                }
-                return `tokenless-github-${base64Encode({
-                    owner,
-                    repository,
-                    jobId,
-                    runId,
-                    prNumber
-                })}`;
-            }
-        default:
-            throw new Error("Missing Argos repository token 'ARGOS_TOKEN'");
-    }
-}
-
-const upload$1 = async (input)=>{
-    const file = await readFile(input.path);
-    await axios({
-        method: "PUT",
-        url: input.url,
-        data: file,
-        headers: {
-            "Content-Type": input.contentType
-        }
-    });
-};
-
-/**
- * Split an array into chunks of a given size.
- */ const chunk = (collection, size)=>{
-    const result = [];
-    // add each chunk to the result
-    for(let x = 0; x < Math.ceil(collection.length / size); x++){
-        let start = x * size;
-        let end = start + size;
-        result.push(collection.slice(start, end));
-    }
-    return result;
-};
-
-const require = createRequire(import.meta.url);
-/**
- * Get the version of the @argos-ci/core package.
- */ async function getArgosCoreSDKIdentifier() {
-    const pkgPath = require.resolve("@argos-ci/core/package.json");
-    const version = await readVersionFromPackage(pkgPath);
-    return `@argos-ci/core@${version}`;
-}
-
-/**
- * Size of the chunks used to upload screenshots to Argos.
- */ const CHUNK_SIZE = 10;
-async function getConfigFromOptions({ parallel, ...options }) {
-    return readConfig({
-        ...options,
-        parallel: Boolean(parallel),
-        parallelNonce: parallel ? parallel.nonce : null,
-        parallelTotal: parallel ? parallel.total : null,
-        parallelIndex: parallel ? parallel.index : null
-    });
-}
-async function uploadFilesToS3(files) {
-    debug(`Split files in chunks of ${CHUNK_SIZE}`);
-    const chunks = chunk(files, CHUNK_SIZE);
-    debug(`Starting upload of ${chunks.length} chunks`);
-    for(let i = 0; i < chunks.length; i++){
-        // Upload files
-        debug(`Uploading chunk ${i + 1}/${chunks.length}`);
-        const timeLabel = `Chunk ${i + 1}/${chunks.length}`;
-        debugTime(timeLabel);
-        const chunk = chunks[i];
-        if (!chunk) {
-            throw new Error(`Invariant: chunk ${i} is empty`);
-        }
-        await Promise.all(chunk.map(async ({ url, path, contentType })=>{
-            await upload$1({
-                url,
-                path,
-                contentType
-            });
-        }));
-        debugTimeEnd(timeLabel);
-    }
-}
-/**
- * Upload screenshots to Argos.
- */ async function upload(params) {
-    debug("Starting upload with params", params);
-    // Read config
-    const [config, argosSdk] = await Promise.all([
-        getConfigFromOptions(params),
-        getArgosCoreSDKIdentifier()
-    ]);
-    const files = params.files ?? [
-        "**/*.{png,jpg,jpeg}"
-    ];
-    debug("Using config and files", config, files);
-    const authToken = getAuthToken(config);
-    const apiClient = createClient({
-        baseUrl: config.apiBaseUrl,
-        authToken
-    });
-    // Collect screenshots
-    const foundScreenshots = await discoverScreenshots(files, {
-        root: params.root,
-        ignore: params.ignore
-    });
-    debug("Found screenshots", foundScreenshots);
-    // Optimize & compute hashes
-    const screenshots = await Promise.all(foundScreenshots.map(async (screenshot)=>{
-        const [metadata, pwTracePath, optimizedPath] = await Promise.all([
-            readMetadata(screenshot.path),
-            getPlaywrightTracePath(screenshot.path),
-            optimizeScreenshot(screenshot.path)
-        ]);
-        const [hash, pwTraceHash] = await Promise.all([
-            hashFile(optimizedPath),
-            pwTracePath ? hashFile(pwTracePath) : null
-        ]);
-        const threshold = metadata?.transient?.threshold ?? null;
-        const baseName = metadata?.transient?.baseName ?? null;
-        if (metadata) {
-            delete metadata.transient;
-        }
-        return {
-            ...screenshot,
-            hash,
-            optimizedPath,
-            metadata,
-            threshold,
-            baseName,
-            pwTrace: pwTracePath && pwTraceHash ? {
-                path: pwTracePath,
-                hash: pwTraceHash
-            } : null
-        };
-    }));
-    debug("Fetch project");
-    const projectResponse = await apiClient.GET("/project");
-    if (projectResponse.error) {
-        throwAPIError(projectResponse.error);
-    }
-    debug("Project fetched", projectResponse.data);
-    const { defaultBaseBranch, hasRemoteContentAccess } = projectResponse.data;
-    const referenceCommit = (()=>{
-        if (config.referenceCommit) {
-            debug("Found reference commit in config", config.referenceCommit);
-            return config.referenceCommit;
-        }
-        // If we have remote access, we will fetch it from the Git Provider.
-        if (hasRemoteContentAccess) {
-            return null;
-        }
-        // We use the pull request as base branch if possible
-        // else branch specified by the user or the default branch.
-        const base = config.referenceBranch || config.prBaseBranch || defaultBaseBranch;
-        const sha = getMergeBaseCommitSha({
-            base,
-            head: config.branch
-        });
-        if (sha) {
-            debug("Found merge base", sha);
-        } else {
-            debug("No merge base found");
-        }
-        return sha;
-    })();
-    const parentCommits = (()=>{
-        // If we have remote access, we will fetch them from the Git Provider.
-        if (hasRemoteContentAccess) {
-            return null;
-        }
-        if (referenceCommit) {
-            const commits = listParentCommits({
-                sha: referenceCommit
-            });
-            if (commits) {
-                debug("Found parent commits", commits);
-            } else {
-                debug("No parent commits found");
-            }
-            return commits;
-        }
-        return null;
-    })();
-    // Create build
-    debug("Creating build");
-    const [pwTraceKeys, screenshotKeys] = screenshots.reduce(([pwTraceKeys, screenshotKeys], screenshot)=>{
-        if (screenshot.pwTrace && !pwTraceKeys.includes(screenshot.pwTrace.hash)) {
-            pwTraceKeys.push(screenshot.pwTrace.hash);
-        }
-        if (!screenshotKeys.includes(screenshot.hash)) {
-            screenshotKeys.push(screenshot.hash);
-        }
-        return [
-            pwTraceKeys,
-            screenshotKeys
-        ];
-    }, [
-        [],
-        []
-    ]);
-    const createBuildResponse = await apiClient.POST("/builds", {
-        body: {
-            commit: config.commit,
-            branch: config.branch,
-            name: config.buildName,
-            mode: config.mode,
-            parallel: config.parallel,
-            parallelNonce: config.parallelNonce,
-            screenshotKeys,
-            pwTraceKeys,
-            prNumber: config.prNumber,
-            prHeadCommit: config.prHeadCommit,
-            referenceBranch: config.referenceBranch,
-            referenceCommit,
-            parentCommits,
-            argosSdk,
-            ciProvider: config.ciProvider,
-            runId: config.runId,
-            runAttempt: config.runAttempt
-        }
-    });
-    if (createBuildResponse.error) {
-        throwAPIError(createBuildResponse.error);
-    }
-    const result = createBuildResponse.data;
-    debug("Got uploads url", result);
-    const uploadFiles = [
-        ...result.screenshots.map(({ key, putUrl })=>{
-            const screenshot = screenshots.find((s)=>s.hash === key);
-            if (!screenshot) {
-                throw new Error(`Invariant: screenshot with hash ${key} not found`);
-            }
-            return {
-                url: putUrl,
-                path: screenshot.optimizedPath,
-                contentType: "image/png"
-            };
-        }),
-        ...result.pwTraces?.map(({ key, putUrl })=>{
-            const screenshot = screenshots.find((s)=>s.pwTrace && s.pwTrace.hash === key);
-            if (!screenshot || !screenshot.pwTrace) {
-                throw new Error(`Invariant: trace with ${key} not found`);
-            }
-            return {
-                url: putUrl,
-                path: screenshot.pwTrace.path,
-                contentType: "application/json"
-            };
-        }) ?? []
-    ];
-    await uploadFilesToS3(uploadFiles);
-    // Update build
-    debug("Updating build");
-    const uploadBuildResponse = await apiClient.PUT("/builds/{buildId}", {
-        params: {
-            path: {
-                buildId: result.build.id
-            }
-        },
-        body: {
-            screenshots: screenshots.map((screenshot)=>({
-                    key: screenshot.hash,
-                    name: screenshot.name,
-                    metadata: screenshot.metadata,
-                    pwTraceKey: screenshot.pwTrace?.hash ?? null,
-                    threshold: screenshot.threshold ?? config?.threshold ?? null,
-                    baseName: screenshot.baseName
-                })),
-            parallel: config.parallel,
-            parallelTotal: config.parallelTotal,
-            parallelIndex: config.parallelIndex,
-            metadata: params.metadata
-        }
-    });
-    if (uploadBuildResponse.error) {
-        throwAPIError(uploadBuildResponse.error);
-    }
-    return {
-        build: uploadBuildResponse.data.build,
-        screenshots
-    };
-}
-
-/**
- * Finalize pending builds.
- */ async function finalize(params) {
-    const config = await readConfig({
-        parallelNonce: params.parallel?.nonce ?? null
-    });
-    const authToken = getAuthToken(config);
-    const apiClient = createClient({
-        baseUrl: config.apiBaseUrl,
-        authToken
-    });
-    if (!config.parallelNonce) {
-        throw new Error("parallel.nonce is required to finalize the build");
-    }
-    const finalizeBuildsResult = await apiClient.POST("/builds/finalize", {
-        body: {
-            parallelNonce: config.parallelNonce
-        }
-    });
-    if (finalizeBuildsResult.error) {
-        throwAPIError(finalizeBuildsResult.error);
-    }
-    return finalizeBuildsResult.data;
-}
-
-export { finalize, readConfig, upload };