action.yml

name: Platform setup
description: Install and configure PlatformCLI and Stackctl

inputs:
  version:
    description: |
      The version of PlatformCLI to install. Do not include the `v` prefix here.
      The default is to lookup the latest release. We recommend using this
      default, along with specifying a `required_version` constraint (such as
      `=~ 3`) in your `.platform.yaml`.
    required: false

  token:
    description: |
      A GitHub access token with rights to fetch the private PlatformCLI release
      artifacts. Either this or `github-app-{id,private-key}` must be given.
    required: false

  github-app-id:
    description: |
      Provide this (and `github-private-key`) instead of `token` to generate
      and use one from the identified App.
    required: false

  github-private-key:
    description: |
      Provide this (and `github-app-id`) instead of `token` to generate and use
      one from the identified App.
    required: false

  github-app-private-key:
    description: Deprecated, use github-private-key
    required: false

  app-directory:
    description: |
      If present, this will be set as `PLATFORM_APP_DIRECTORY` for the remainder
      of the workflow. For details on what this affects, see `platform(1)`.
    default: ""

  environment:
    description: |
      If present, this will be set as `PLATFORM_ENVIRONMENT` for the remainder
      of the workflow. For details on what this affects, see `platform(1)`.
    required: false

  resource:
    description: |
      If present, this will be set as `PLATFORM_RESOURCE` for the remainder of
      the workflow. For details on what this affects, see `platform(1)`.
    required: false

  no-validate:
    description: |
      If present, this will be set as `PLATFORM_NO_VALIDATE` for the remainder
      of the workflow. For details on what this affects, see `platform(1)`.
    required: false

  stackctl-version:
    description: |
      The version of Stackctl to install. Do not include the `v` prefix here.
      The default is to lookup the latest release.
    required: false

  stackctl-directory:
    description: Value to set as STACKCTL_DIRECTORY
    default: .platform/specs

  stackctl-filter:
    description: Value to set as STACKCTL_FILTER
    required: false

  fetch-platform-yaml:
    description: |
      Automatically fetch `.platform.yaml` via GitHub API if not present. This
      can be useful to avoid a checkout if all your Job needs is this file. This
      will always use `github.token`, regardless of our own `token` input.
    default: "true"

outputs:
  tag:
    value: ${{ steps.set-tag.outputs.tag }}
    description: |
      A consistent, source-specific value that should be used throughout
      build/push/deploy actions. It's currently the head sha for `pull_request`
      events, the "after" sha for `push` events, and `github.sha` for all other
      events

  cache:
    value: ${{ steps.set-cache.outputs.cache }}
    description: |
      Path to the `.platform/cache` directory, for which we've setup an
      `actions/cache` step. This output is only useful if in a multi-app
      repository.

runs:
  using: composite
  steps:
    - if: ${{ !inputs.token && !(inputs.github-app-id && (inputs.github-private-key || inputs.github-app-private-key)) }}
      shell: bash
      run: |
        # Validate token or github-app inputs
        echo "Either token or github-app-id/private-key must be provided" >&2
        exit 1

    - id: app-token
      if: ${{ !inputs.token }}
      uses: actions/create-github-app-token@v1
      with:
        app-id: ${{ inputs.github-app-id }}
        private-key: ${{ inputs.github-private-key || inputs.github-app-private-key }}
        repositories: platform,stackctl

    - id: token
      shell: bash
      run: |
        # Choose token output
        token=${{ inputs.token || steps.app-token.outputs.token }}
        echo "token=$token" >>"$GITHUB_OUTPUT"

    - if: ${{ runner.os == 'macOS' }}
      shell: bash
      run: |
        # Replace BSD install with GNU install
        brew install coreutils
        sudo mkdir -p /usr/local/bin
        sudo ln -sf "$(which ginstall)" /usr/local/bin/install
        install --version | grep -Fq GNU

    - id: prep
      if: ${{ inputs.version == '' }}
      shell: bash
      run: |
        # Determine latest PlatformCLI version
        curl \
          --header "Authorization: Bearer ${{ steps.token.outputs.token }}" \
          --silent \
          --show-error \
          --fail https://api.github.com/repos/freckle/platform/releases |
          jq '.[] | select(.draft|not) | select(.prerelease|not) | .tag_name' --raw-output |
          head -n 1 |
          sed 's/^v/version=/' >>"$GITHUB_OUTPUT"

    - id: prep-stackctl
      if: ${{ inputs.stackctl-version == '' }}
      shell: bash
      run: |
        # Determine latest Stackctl version
        curl \
          --header "Authorization: Bearer ${{ steps.token.outputs.token }}" \
          --silent \
          --show-error \
          --fail https://api.github.com/repos/freckle/stackctl/releases |
          jq '.[] | select(.draft|not) | select(.prerelease|not) | .tag_name' --raw-output |
          head -n 1 |
          sed 's/^v/version=/' >>"$GITHUB_OUTPUT"

    - name: Install PlatformCLI
      uses: pbrisbin/setup-tool-action@v2
      with:
        name: platform
        version: ${{ inputs.version || steps.prep.outputs.version }}
        url: "https://github.com/freckle/{name}/releases/download/v{version}/{name}-{arch}-{os}.{ext}"
        github-token: ${{ steps.token.outputs.token }}
        arch: x86_64
        os-darwin: osx
        subdir: "{name}"

    - name: Install Stackctl
      uses: pbrisbin/setup-tool-action@v2
      with:
        name: stackctl
        version: ${{ inputs.stackctl-version || steps.prep-stackctl.outputs.version }}
        url: "https://github.com/freckle/{name}/releases/download/v{version}/{name}-{arch}-{os}.{ext}"
        arch: x86_64
        os-darwin: osx
        subdir: "{name}"

    - shell: bash
      run: |
        # Configure PlatformCLI and Stackctl ENV
        {
          echo 'LOG_COLOR=always'
          echo 'LOG_DESTINATION=stderr'

          if [[ -n "${{ inputs.app-directory }}" ]]; then
            echo 'PLATFORM_APP_DIRECTORY=${{ inputs.app-directory }}'
          fi

          if [[ -n "${{ inputs.environment }}" ]]; then
            echo 'PLATFORM_ENVIRONMENT=${{ inputs.environment }}'
          fi

          if [[ -n "${{ inputs.resource }}" ]]; then
            echo 'PLATFORM_RESOURCE=${{ inputs.resource }}'
          fi

          if [[ -n "${{ inputs.no-validate }}" ]]; then
            echo 'PLATFORM_NO_VALIDATE=${{ inputs.no-validate }}'
          fi

          if [[ -n "${{ inputs.stackctl-directory }}" ]]; then
            app=${{ inputs.app-directory }}
            app=${app:-.}
            echo "STACKCTL_DIRECTORY=$app/${{ inputs.stackctl-directory }}"
          fi

          if [[ -n "${{ inputs.stackctl-filter }}" ]]; then
            echo "STACKCTL_FILTER=${{ inputs.stackctl-filter }}"
            echo "STACKCTL_FILTERS=${{ inputs.stackctl-filter }}"
          fi

        } >>"$GITHUB_ENV"

    # https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request
    #
    # > Note that GITHUB_SHA for [the pull] event is the last merge commit of
    # > the pull request merge branch. If you want to get the commit ID for the
    # > last commit to the head branch of the pull request, use
    # > github.event.pull_request.head.sha instead.
    #
    - id: set-tag
      shell: bash
      run: |
        # Set tag output
        tag=${{ github.event.pull_request.head.sha }}
        tag=${tag:-${{ github.event.after }}}
        tag=${tag:-${{ github.sha }}}
        echo "tag=$tag" >>"$GITHUB_OUTPUT"

    - id: set-cache
      shell: bash
      run: |
        # Set cache path output and resource
        app=$PLATFORM_APP_DIRECTORY
        app=${app:-.}
        echo "cache=$app/.platform/cache" >>"$GITHUB_OUTPUT"

        resource=$PLATFORM_RESOURCE
        resource=${resource:-all-resources}
        echo "resource=$resource" >>"$GITHUB_OUTPUT"

    - name: Cache .platform/cache directory
      uses: actions/cache@v4
      with:
        path: ${{ steps.set-cache.outputs.cache }}
        key: ${{ runner.os }}-${{ github.job }}-${{ steps.set-cache.outputs.resource }}-${{ steps.set-tag.outputs.tag }}
        restore-keys: |
          ${{ runner.os }}-${{ github.job }}-${{ steps.set-cache.outputs.resource }}-
          ${{ runner.os }}-${{ github.job }}-

    - shell: bash
      run: |
        # Configure Slack notification ENV
        title="Deploy"

        if [[ -n "$PLATFORM_APP_DIRECTORY" ]] && [[ -n "$PLATFORM_RESOURCE" ]]; then
          title+=" $PLATFORM_APP_DIRECTORY/$PLATFORM_RESOURCE"
        elif [[ -n "$PLATFORM_APP_DIRECTORY" ]]; then
          title+=" $PLATFORM_APP_DIRECTORY"
        elif [[ -n "$PLATFORM_RESOURCE" ]]; then
          title+=" $PLATFORM_RESOURCE"
        fi

        if [[ -n "$PLATFORM_ENVIRONMENT" ]]; then
          title+=" to $PLATFORM_ENVIRONMENT"
        fi

        cat <<EOM >>"$GITHUB_ENV"
        SLACK_ICON=https://github.com/freckle-automation.png?size=48
        SLACK_USERNAME=GitHub Actions
        SLACK_TITLE=$title
        SLACK_FOOTER=${{ steps.set-tag.outputs.tag }}
        MSG_MINIMAL=actions url,commit
        EOM

    - if: ${{ inputs.fetch-platform-yaml == 'true' }}
      shell: bash
      run: |
        # Download .platform.yaml if necessary
        if [[ -e "${PLATFORM_APP_DIRECTORY:-.}/.platform.yaml" ]]; then
          echo "Skipping: .platform.yaml exists"
          exit 0
        fi

        if [[ "$PLATFORM_APP_DIRECTORY" == /* ]]; then
          echo "Skipping: \$PLATFORM_APP_DIRECTORY is an absolute path"
          exit 0
        fi

        if [[ -n "$PLATFORM_APP_DIRECTORY" ]]; then
          config=$PLATFORM_APP_DIRECTORY/.platform.yaml
        else
          config=.platform.yaml
        fi

        ghpath="/repos/$GITHUB_REPOSITORY/contents/$config?ref=$TAG"
        echo "Downloading $ghpath..."

        mkdir -p "$(dirname "$config")"
        gh api "$ghpath" --jq '.content' | base64 -d >"$config"
      env:
        GH_TOKEN: ${{ github.token }}
        GITHUB_REPOSITORY: ${{ github.repository }}
        TAG: ${{ steps.set-tag.outputs.tag }}