main.js

import * as core from '@actions/core'
import * as exec from '@actions/exec'
import * as github from '@actions/github'
import { defaults as githubDefaults } from '@actions/github/lib/utils'
import * as artifact from '@actions/artifact'
import AdmZip from 'adm-zip'
import { randomUUID } from 'node:crypto'
import pathname from 'node:path'
import fs from 'node:fs'
import { pipeline } from 'node:stream/promises'

async function main() {
    try {
        const token = core.getInput("github_token", { required: true })
        const [owner, repo] = core.getInput("repo", { required: true }).split("/")
        const path = core.getInput("path", { required: true })
        const name = core.getInput("name")
        const nameIsRegExp = core.getBooleanInput("name_is_regexp")
        const skipUnpack = core.getBooleanInput("skip_unpack")
        const ifNoArtifactFound = core.getInput("if_no_artifact_found")
        const useUnzip = core.getBooleanInput("use_unzip")
        const mergeMultiple = core.getBooleanInput("merge_multiple")
        let workflow = core.getInput("workflow")
        let workflowSearch = core.getBooleanInput("workflow_search")
        let workflowConclusion = core.getInput("workflow_conclusion")
        let pr = core.getInput("pr")
        let commit = core.getInput("commit")
        let branch = core.getInput("branch")
        let ref = core.getInput("ref")
        let event = core.getInput("event")
        let runID = core.getInput("run_id")
        let runNumber = core.getInput("run_number")
        let checkArtifacts = core.getBooleanInput("check_artifacts")
        let searchArtifacts = core.getBooleanInput("search_artifacts")
        const allowForks = core.getBooleanInput("allow_forks")
        let dryRun = core.getBooleanInput("dry_run")

        const client = github.getOctokit(token)
        const artifactClient = new artifact.DefaultArtifactClient()
        const hostname = new URL(github.context.serverUrl).hostname.toUpperCase()
        const canStreamArtifacts = hostname === "GITHUB.COM" || hostname.endsWith(".GHE.COM") || hostname.endsWith(".LOCALHOST")
        const matchesName = artifact => nameIsRegExp ? artifact.name.match(name) !== null : artifact.name == name

        core.info(`==> Repository: ${owner}/${repo}`)
        core.info(`==> Artifact name: ${name}`)
        core.info(`==> Local path: ${path}`)

        if (!workflow && !workflowSearch) {
            workflow = (await client.rest.actions.getWorkflowRun({
                owner: owner,
                repo: repo,
                run_id: runID || github.context.runId,
            })).data.workflow_id
        }

        if (workflow) {
            core.info(`==> Workflow name: ${workflow}`)
        }
        core.info(`==> Workflow conclusion: ${workflowConclusion}`)

        const exclusiveInputs = { pr, commit, branch, ref, "run_id": runID }
        if (Object.values(exclusiveInputs).filter(Boolean).length > 1) {
            throw new Error(`The following inputs cannot be used together: ${Object.keys(exclusiveInputs).join(", ")}`)
        }

        if (pr) {
            core.info(`==> PR: ${pr}`)
            const pull = await client.rest.pulls.get({
                owner: owner,
                repo: repo,
                pull_number: pr,
            })
            commit = pull.data.head.sha
        }

        if (ref) {
            // Try to determine if the ref is a branch or a commit
            core.info(`==> Ref: ${ref}`)
            try {
                await client.rest.repos.getBranch({
                    owner: owner,
                    repo: repo,
                    branch: ref,
                })
                branch = ref
            } catch (error) {
                const response = await client.rest.repos.getCommit({
                    owner: owner,
                    repo: repo,
                    ref: ref,
                })
                commit = response.data.sha
            }
        }

        if (commit) {
            core.info(`==> Commit: ${commit}`)
        }

        if (branch) {
            branch = branch.replace(/^refs\/heads\//, "")
            core.info(`==> Branch: ${branch}`)
        }

        if (event) {
            core.info(`==> Event: ${event}`)
        }

        if (runNumber) {
            core.info(`==> Run number: ${runNumber}`)
        }

        core.info(`==> Allow forks: ${allowForks}`)

        if (!runID) {
            const runGetter = workflow ? client.rest.actions.listWorkflowRuns : client.rest.actions.listWorkflowRunsForRepo
            // Filtered queries are served by a search index that intermittently returns a random subset of runs,
            // so merge in the latest unfiltered runs, matched locally. Only helps if the newest match is among them.
            let latestRuns = []
            if (branch || event || commit) {
                latestRuns = (await runGetter({
                    owner: owner,
                    repo: repo,
                    per_page: 100,
                    ...(workflow ? { workflow_id: workflow } : {}),
                })).data.workflow_runs.filter(run =>
                    (!branch || run.head_branch === branch) &&
                    (!event || run.event === event) &&
                    (!commit || run.head_sha === commit)
                )
            }
            for await (const runs of client.paginate.iterator(runGetter, {
                owner: owner,
                repo: repo,
                per_page: 100,
                ...(workflow ? { workflow_id: workflow } : {}),
                ...(branch ? { branch } : {}),
                ...(event ? { event } : {}),
                ...(commit ? { head_sha: commit } : {}),
            }
            )) {
                core.debug(`==> Fetched page of ${runs.data.length} runs: ${runs.data.map(run => run.id).join(", ")}`)
                const missingRuns = latestRuns.filter(run => !runs.data.some(r => r.id === run.id))
                if (missingRuns.length) {
                    core.debug(`==> Merging runs missing from filtered page: ${missingRuns.map(run => run.id).join(", ")}`)
                }
                latestRuns = []
                // Do not rely on the API returning runs in most recent first order, it sometimes does not.
                for (const run of [...runs.data, ...missingRuns].sort((a, b) => b.id - a.id)) {
                    if (runNumber && run.run_number != runNumber) {
                        continue
                    }
                    if (workflowConclusion && workflowConclusion != run.conclusion && workflowConclusion != run.status) {
                        core.debug(`==> Skipping run ${run.id} (${run.created_at}): status ${run.status}, conclusion ${run.conclusion}`)
                        continue
                    }
                    if (!allowForks && run.head_repository.full_name !== `${owner}/${repo}`) {
                        core.info(`==> Skipping run from fork: ${run.head_repository.full_name}`)
                        continue
                    }
                    if (checkArtifacts || searchArtifacts) {
                        const artifacts = (await client.paginate(client.rest.actions.listWorkflowRunArtifacts, {
                            owner: owner,
                            repo: repo,
                            run_id: run.id,
                        })).filter(artifact => !artifact.expired)
                        if (artifacts.length === 0 || (searchArtifacts && !artifacts.some(matchesName))) {
                            core.debug(`==> Skipping run ${run.id} (${run.created_at}): artifacts [${artifacts.map(artifact => artifact.name).join(", ")}]`)
                            continue
                        }
                    }

                    runID = run.id
                    core.info(`==> (found) Run ID: ${runID}`)
                    core.info(`==> (found) Run date: ${run.created_at}`)

                    if (!workflow) {
                        workflow = run.workflow_id
                        core.info(`==> (found) Workflow: ${workflow}`)
                    }
                    break
                }
                if (runID) {
                    break
                }
            }
        }

        if (!runID) {
            if (workflowConclusion && (workflowConclusion != 'in_progress')) {
                return setExitMessage(ifNoArtifactFound, "no matching workflow run found with any artifacts?")
            }
            runID = github.context.runId
            core.info(`==> (current) Run ID: ${runID}`)
        }

        let artifacts = await client.paginate(client.rest.actions.listWorkflowRunArtifacts, {
            owner: owner,
            repo: repo,
            run_id: runID,
        })

        // One artifact if 'name' input is specified, one or more if `name` is a regular expression, all otherwise.
        if (name) {
            const filtered = artifacts.filter(matchesName)
            if (filtered.length == 0) {
                core.info(`==> (not found) Artifact: ${name}`)
                core.info('==> Found the following artifacts instead:')
                for (const artifact of artifacts) {
                    core.info(`\t==> (found) Artifact: ${artifact.name}`)
                }
            }
            artifacts = filtered
        }

        artifacts.sort((a, b) => a.created_at.localeCompare(b.created_at))

        core.setOutput("artifacts", artifacts)

        if (dryRun) {
            const found = artifacts.length > 0
            core.setOutput("found_artifact", found)
            if (!found) return
            core.info('==> (found) Artifacts')
            for (const artifact of artifacts) {
                core.info(`\t==> Artifact:`)
                core.info(`\t==> ID: ${artifact.id}`)
                core.info(`\t==> Name: ${artifact.name}`)
                core.info(`\t==> Size: ${artifact.size_in_bytes} bytes`)
            }
            return
        }

        if (artifacts.length == 0) {
            return setExitMessage(ifNoArtifactFound, "no artifacts found")
        }

        const expiredArtifacts = []

        for (const artifact of artifacts) {
            core.info(`==> Artifact: ${artifact.id}`)

            core.info(`==> Downloading: ${artifact.name} (${artifact.size_in_bytes} bytes)`)

            if (artifact.expired) {
                if (ifNoArtifactFound === "fail") {
                    return setExitMessage(ifNoArtifactFound, "no downloadable artifacts found (expired)")
                }
                expiredArtifacts.push(artifact.name)
                continue
            }

            const dir = skipUnpack || (name && (!nameIsRegExp || mergeMultiple))
                ? path
                : pathname.join(path, artifact.name)

            if (canStreamArtifacts) {
                let response
                try {
                    response = await artifactClient.downloadArtifact(artifact.id, {
                        path: dir,
                        skipDecompress: skipUnpack || useUnzip,
                        ...(artifact.digest ? { expectedHash: artifact.digest } : {}),
                        findBy: {
                            token: token,
                            workflowRunId: Number(runID),
                            repositoryOwner: owner,
                            repositoryName: repo,
                        },
                    })
                } catch (error) {
                    if (error.message.includes("Artifact has expired")) {
                        if (ifNoArtifactFound === "fail") {
                            return setExitMessage(ifNoArtifactFound, "no downloadable artifacts found (expired)")
                        }
                        expiredArtifacts.push(artifact.name)
                        continue
                    }
                    throw error
                }

                if (response.digestMismatch) {
                    throw new Error(`artifact digest mismatch: ${artifact.name}`)
                }

                const zipPath = pathname.join(dir, `${artifact.name}.zip`)
                if (useUnzip && !skipUnpack && fs.existsSync(zipPath)) {
                    core.startGroup(`==> Extracting: ${artifact.name}.zip`)
                    try {
                        await exec.exec("unzip", [zipPath, "-d", dir])
                    } finally {
                        core.endGroup()
                    }
                    fs.rmSync(zipPath)
                }
                continue
            }

            fs.mkdirSync(dir, { recursive: true })
            const zipPath = pathname.join(dir, `.artifact-${randomUUID()}.zip`)

            try {
                await client.request("GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}", {
                    owner: owner,
                    repo: repo,
                    artifact_id: artifact.id,
                    archive_format: "zip",
                    request: {
                        fetch: async (url, options) => {
                            const response = await githubDefaults.request.fetch(url, { ...options, redirect: "follow" })
                            if (!response.ok) return response
                            await pipeline(response.body, fs.createWriteStream(zipPath))
                            return new Response(null, { status: 200, headers: response.headers })
                        },
                    },
                })
            } catch (error) {
                fs.rmSync(zipPath, { force: true })
                if (error.message?.startsWith("Artifact has expired")) {
                    if (ifNoArtifactFound === "fail") {
                        return setExitMessage(ifNoArtifactFound, "no downloadable artifacts found (expired)")
                    }
                    expiredArtifacts.push(artifact.name)
                    continue
                }
                throw error
            }

            if (skipUnpack) {
                try {
                    fs.renameSync(zipPath, `${pathname.join(path, artifact.name)}.zip`)
                } finally {
                    fs.rmSync(zipPath, { force: true })
                }
                continue
            }

            try {
                core.startGroup(`==> Extracting: ${artifact.name}.zip`)
                try {
                    if (useUnzip) {
                        await exec.exec("unzip", [zipPath, "-d", dir])
                    } else {
                        new AdmZip(zipPath).extractAllTo(dir, true)
                    }
                } finally {
                    core.endGroup()
                }
            } finally {
                fs.rmSync(zipPath, { force: true })
            }
        }

        if (expiredArtifacts.length === artifacts.length) {
            return setExitMessage(ifNoArtifactFound, "no downloadable artifacts found (expired)")
        }

        if (expiredArtifacts.length > 0) {
            const message = `skipped expired artifact${expiredArtifacts.length === 1 ? "" : "s"}: ${expiredArtifacts.join(", ")}`
            if (ifNoArtifactFound === "warn") core.warning(message)
            else core.info(message)
        }

        core.setOutput("found_artifact", true)
    } catch (error) {
        core.setOutput("found_artifact", false)
        core.setOutput("error_message", error.message)
        core.setFailed(error.message)
    }

    function setExitMessage(ifNoArtifactFound, message) {
        core.setOutput("found_artifact", false)
        if (ifNoArtifactFound === "fail") return core.setFailed(message)
        if (ifNoArtifactFound === "warn") return core.warning(message)
        core.info(message)
    }
}

main()