action.yml

name: "Dagger for GitHub"
description: "Run dagger commands in Github Actions"
inputs:
  version:
    description: "Dagger Version"
    required: true
  commit:
    description: "Dagger Dev Commit"
    required: false
    default: ""
  dagger-flags:
    description: "Dagger CLI Flags"
    required: false
    default: "--progress plain"
  verb:
    description: "CLI verb (call, run, download, up, functions, shell, query)"
    required: false
    default: "call"
  workdir:
    description: "The working directory in which to run the Dagger CLI"
    required: false
    default: "."
  cloud-token:
    description: "Dagger Cloud Token"
    required: false
    default: ""
  module:
    description: "Dagger module to call. Local or Git"
    required: false
    default: ""
  args:
    description: "Arguments to pass to CLI"
    required: false
    default: ""
  engine-stop:
    description: "Whether to stop the Dagger Engine after this run"
    required: false
    default: "true"
  call:
    description: "Function and arguments for dagger call"
    required: false
    default: ""
  cache_config:
    description: "Cache configuration"
    required: false
    default: ""
  export_logs:
    description: "Whether to export logs"
    required: false
    default: "false"
outputs:
  output:
    description: "Job output"
    value: ${{ steps.exec.outputs.stdout }}
runs:
  using: "composite"
  steps:
    - shell: bash
      run: |
        set -o pipefail
        # Fallback to /usr/local for backwards compatability
        prefix_dir="${RUNNER_TEMP:-/usr/local}"
        # Ensure the dir is writable otherwise fallback to tmpdir
        if [[ ! -d "$prefix_dir" ]] || [[ ! -w "$prefix_dir" ]]; then
            prefix_dir="$(mktemp -d)"
        fi
        printf '%s/bin' "$prefix_dir" >> $GITHUB_PATH

        # If the dagger version is 'latest', set the version back to an empty
        # string. This allows the install script to detect and install the latest
        # version itself
        VERSION=${{ inputs.version }}
        if [[ "$VERSION" == "latest" ]]; then
          VERSION=
        fi

        COMMIT=${{ inputs.commit }}

        # The install.sh script creates path ${prefix_dir}/bin
        curl -fsS https://dl.dagger.io/dagger/install.sh \
        | BIN_DIR=${prefix_dir}/bin DAGGER_VERSION="$VERSION" DAGGER_COMMIT="$COMMIT" sh

    - id: exec
      if: inputs.call != '' || inputs.args != ''
      shell: bash
      env:
        _EXPERIMENTAL_DAGGER_CACHE_CONFIG: ${{ inputs.cache_config }}
        INPUT_MODULE: ${{ inputs.module }}
      run: |
        echo "Cache Config: ${_EXPERIMENTAL_DAGGER_CACHE_CONFIG}"

        tmpout=$(mktemp)
        cd ${{ inputs.workdir }} && { \
        DAGGER_CLOUD_TOKEN=${{ inputs.cloud-token }} \
        dagger \
        ${{ inputs.dagger-flags }} \
        ${{ inputs.verb }} \
        ${INPUT_MODULE:+-m $INPUT_MODULE} \
        ${{ inputs.args || inputs.call }}; } | tee "${tmpout}"

        {
          # we need a delim that doesn't appear in the output - a hash of the
          # file itself *probably* won't (if it does, we have larger
          # cryptographic problems)
          delim="$(sha256sum $tmpout | cut -d " " -f1)"
          echo "stdout<<${delim}"
          cat "${tmpout}"
          echo
          echo "${delim}"
        } >> "$GITHUB_OUTPUT"

    - if: (inputs.call != '' || inputs.args != '') && inputs.engine-stop == 'true'
      shell: bash
      run: |
        mapfile -t containers < <(docker ps --filter name="dagger-engine-*" -q)
        if [[ "${#containers[@]}" -gt 0 ]]; then
          # Export logs if requested
          if [[ "${{ inputs.export_logs }}" == "true" ]]; then
            mkdir -p /tmp/engine-logs
            for container in "${containers[@]}"; do
              docker logs "$container" >& "/tmp/engine-logs/${container}.log"
            done
          fi

          docker stop -t 300 "${containers[@]}";
        fi
    - if: inputs.export_logs == 'true'
      name: Export logs as artifacts
      uses: actions/upload-artifact@v4
      with:
        name: engine-logs
        path: /tmp/engine-logs