build/.gitea/workflows/build.yaml

name: SPT Release Build

on:
  schedule:
    - cron: '* 19 * * *' # Every day at 7pm UTC (3pm ET)
  push:
    # main can be removed when actions are available in the sub-project repos
    branches: [ main, trigger ]

jobs:
  prepare:
    runs-on: ubuntu-latest
    container:
      image: refringe/spt-build-node:1.0.5
    outputs:
      proceed: ${{ steps.check-existence.outputs.proceed }}
      is_nightly: ${{ steps.determine-context.outputs.is_nightly }}
      branch_server: ${{ steps.determine-context.outputs.branch_server }}
      branch_modules: ${{ steps.determine-context.outputs.branch_modules }}
      branch_launcher: ${{ steps.determine-context.outputs.branch_launcher }}
      target_tag: ${{ steps.determine-context.outputs.target_tag }}
      client_version: ${{ steps.versions.outputs.client_version }}
      spt_version: ${{ steps.versions.outputs.spt_version }}
      mod_enabled_bleeding: ${{ steps.mod-config.outputs.bleeding }}
      mod_enabled_debug: ${{ steps.mod-config.outputs.debug }}
      mod_enabled_release: ${{ steps.mod-config.outputs.release }}

    steps:
    - name: Determine Build Context
      id: determine-context
      run: |
        echo "Determining build context..."
        if [[ "${{ github.event_name }}" == "schedule" ]]; then
          echo "::set-output name=is_nightly::true"
          echo "::set-output name=branch_server::3.8.0"
          echo "::set-output name=branch_modules::3.8.0"
          echo "::set-output name=branch_launcher::3.8.0"
        else
          echo "::set-output name=is_nightly::false"
          echo "::set-output name=target_tag::3.8.0-BE-20240314"
        fi
      shell: bash

    - name: Check Existence
      id: check-existence
      run: |
        PROCEED="true"
        if [[ "${{ steps.determine-context.outputs.is_nightly }}" == "true" ]]; then
          declare -A BRANCHES=(
            [Server]="https://dev.sp-tarkov.com/SPT-AKI/Server.git@${{ steps.determine-context.outputs.branch_server }}"
            [Modules]="https://dev.sp-tarkov.com/SPT-AKI/Modules.git@${{ steps.determine-context.outputs.branch_modules }}"
            [Launcher]="https://dev.sp-tarkov.com/SPT-AKI/Launcher.git@${{ steps.determine-context.outputs.branch_launcher }}"
          )
          for REPO_NAME in "${!BRANCHES[@]}"; do
            REPO_URL="${BRANCHES[$REPO_NAME]%@*}"
            BRANCH="${BRANCHES[$REPO_NAME]##*@}"
            echo "Checking for branch $BRANCH in $REPO_NAME..."
            if ! git ls-remote --heads $REPO_URL $BRANCH | grep -q $BRANCH; then
              echo "Branch $BRANCH not found in $REPO_URL"
              PROCEED="false"
              break
            fi
          done
        else
          TAG="${{ steps.determine-context.outputs.target_tag }}"
          REPOS=("https://dev.sp-tarkov.com/SPT-AKI/Server.git" "https://dev.sp-tarkov.com/SPT-AKI/Modules.git" "https://dev.sp-tarkov.com/SPT-AKI/Launcher.git")
          for REPO in "${REPOS[@]}"; do
            echo "Checking for tag $TAG in $REPO..."
            if ! git ls-remote --tags $REPO $TAG | grep -q $TAG; then
              echo "Tag $TAG not found in $REPO"
              PROCEED="false"
              break
            fi
          done
        fi
        echo "::set-output name=proceed::${PROCEED}"
      shell: bash

    - name: Halt Workflow if Necessary
      if: steps.check-existence.outputs.proceed == 'false'
      run: |
        echo "Required branch/tag not found in one or more repositories, halting workflow."
        exit 1
      shell: bash

    - name: Extract Versions
      id: versions
      run: |
        rm -rf /workspace/refringe/Build/server-core
        git init /workspace/refringe/Build/server-core
        cd /workspace/refringe/Build/server-core
        git remote add origin https://dev.sp-tarkov.com/SPT-AKI/Server.git
        git config core.sparseCheckout true
        echo "project/assets/configs/core.json" >> .git/info/sparse-checkout

        if [[ "${{ steps.determine-context.outputs.is_nightly }}" == "true" ]]; then
          REF=${{ steps.determine-context.outputs.branch_server }}
        else
          REF=${{ steps.determine-context.outputs.target_tag }}
        fi

        # Fetch and checkout the specific reference (branch or tag)
        git fetch --depth=1 origin "${REF}"
        git checkout FETCH_HEAD
        ls -la project/assets/configs

        # Extract versions from core.json
        cd project/assets/configs
        SPT_VERSION=$(jq -r '.akiVersion' core.json)
        FULL_VERSION=$(jq -r '.compatibleTarkovVersion' core.json)
        CLIENT_VERSION=${FULL_VERSION##*.}

        echo "::set-output name=client_version::${CLIENT_VERSION}"
        echo "::set-output name=spt_version::${SPT_VERSION}"
      shell: bash

    - name: Extract Mod Configurations
      id: mod-config
      run: |
        rm -rf /workspace/refringe/Build/server-mods-config
        git init /workspace/refringe/Build/server-mods-config
        cd /workspace/refringe/Build/server-mods-config
        git remote add origin https://dev.sp-tarkov.com/SPT-AKI/Server.git
        git config core.sparseCheckout true

        echo "project/src/ide/BleedingEdgeEntry.ts" >> .git/info/sparse-checkout
        echo "project/src/ide/DebugEntry.ts" >> .git/info/sparse-checkout
        echo "project/src/ide/ReleaseEntry.ts" >> .git/info/sparse-checkout

        if [[ "${{ steps.determine-context.outputs.is_nightly }}" == "true" ]]; then
          REF=${{ steps.determine-context.outputs.branch_server }}
        else
          REF=${{ steps.determine-context.outputs.target_tag }}
        fi

        # Fetch and checkout the specific reference (branch or tag)
        git fetch --depth=1 origin "${REF}"
        git checkout FETCH_HEAD
        ls -la project/src/ide

        # Function to parse G_MODS_ENABLED value
        parse_mods_enabled() {
          grep 'G_MODS_ENABLED' $1 | sed -e 's/.*G_MODS_ENABLED\s*=\s*\(.*\);/\1/'
        }

        # Extract the configuration options
        MODS_BLEEDING=$(parse_mods_enabled "project/src/ide/BleedingEdgeEntry.ts")
        MODS_DEBUG=$(parse_mods_enabled "project/src/ide/DebugEntry.ts")
        MODS_RELEASE=$(parse_mods_enabled "project/src/ide/ReleaseEntry.ts")

        echo "::set-output name=bleeding::${MODS_BLEEDING}"
        echo "::set-output name=debug::${MODS_DEBUG}"
        echo "::set-output name=release::${MODS_RELEASE}"
      shell: bash

  build-server:
    needs: [prepare]
    if: needs.prepare.outputs.proceed == 'true'
    runs-on: ubuntu-latest
    container:
      image: refringe/spt-build-node:1.0.5
    outputs:
      build_type: ${{ steps.build-type.outputs.build_type }}
    steps:
    - name: Clone
      run: |
        rm -rf /workspace/refringe/Build/server
        if [[ "${{ needs.prepare.outputs.is_nightly }}" == "true" ]]; then
          BRANCH=${{ needs.prepare.outputs.branch_server }}
          echo "Cloning branch $BRANCH"
          git clone https://dev.sp-tarkov.com/SPT-AKI/Server.git --branch "$BRANCH" --depth 1 /workspace/refringe/Build/server
        else
          TAG=${{ needs.prepare.outputs.target_tag }}
          echo "Cloning tag $TAG"
          git clone https://dev.sp-tarkov.com/SPT-AKI/Server.git --branch "$TAG" --depth 1 /workspace/refringe/Build/server
        fi
      shell: bash

    - name: Pull LFS Files
      run: |
        cd /workspace/refringe/Build/server
        git lfs pull && git lfs ls-files
      shell: bash

    - name: Runner Debug Information
      run: |
        cd /workspace/refringe/Build/server
        echo "Git version: $(git --version)"
        echo "Git LFS version: $(git-lfs --version)"
        echo "Node.js version: $(node --version)"
        echo "NPM version: $(npm --version)"
        echo "Latest Commit Hash: $(git rev-parse HEAD)"
        echo "Associated Tags: $(git tag --contains HEAD)"
        echo "Last Commit Message:" && git log -1 --pretty=%B
      shell: bash

    - name: Determine Build Type
      id: build-type
      run: |
        # Check if this is a nightly build
        if [[ "${{ needs.prepare.outputs.is_nightly }}" == "true" ]]; then
          # Nightly builds are always considered "bleeding"
          BUILD_TYPE="bleeding"
        else
          cd /workspace/refringe/Build/server

          # Prepare tags for check
          TAGS=$(git tag --contains HEAD || echo "no-tag")
          if [ -z "$TAGS" ]; then
            TAGS="no-tag"
          fi
          TAGS="${TAGS//$'\n'/-}"  # Replace newline characters with dashes
          TAGS="${TAGS//,/-}"      # Replace commas with dashes

          # Debug build by default
          # Bleeding builds have "-BE" in the tag
          # Release tags follow basic semantic versioning
          BUILD_TYPE="debug"
          if [[ "$TAGS" =~ -BE ]]; then
            BUILD_TYPE="bleeding"
          elif [[ "$TAGS" =~ ^(v?\d+\.\d+\.\d+)$ ]]; then
            BUILD_TYPE="release"
          fi
        fi
        echo "::set-output name=build_type::${BUILD_TYPE}"
      shell: bash

    - name: Install Dependencies
      run: |
        cd /workspace/refringe/Build/server/project
        rm -rf package-lock.json node_modules
        npm cache clean --force
        npm install
      shell: bash

    - name: Build Server
      run: |
        cd /workspace/refringe/Build/server/project
        BUILD_TYPE="${{ steps.build-type.outputs.build_type }}"
        echo "Running build for $BUILD_TYPE"
        npm run build:$BUILD_TYPE -- --arch=x64 --platform=win32
        printf "\nBuilt!\n\n"
        tree -C /workspace/refringe/Build/server/project/build
      shell: bash

    - name: Artifact Server
      uses: actions/upload-artifact@v3
      with:
        name: server-artifact
        path: /workspace/refringe/Build/server/project/build/
        compression-level: 0
        retention-days: 1
        overwrite: true

  build-modules:
    needs: [prepare]
    if: needs.prepare.outputs.proceed == 'true'
    runs-on: ubuntu-latest
    container:
      image: refringe/spt-build-dotnet:1.0.0
    steps:
    - name: Clone
      run: |
        if [[ "${{ needs.prepare.outputs.is_nightly }}" == "true" ]]; then
          BRANCH=${{ needs.prepare.outputs.branch_modules }}
          echo "Cloning modules from branch $BRANCH"
          git clone https://dev.sp-tarkov.com/SPT-AKI/Modules.git --branch "$BRANCH" --depth 1 /workspace/refringe/Build/modules
        else
          TAG=${{ needs.prepare.outputs.target_tag }}
          echo "Cloning modules from tag $TAG"
          git clone https://dev.sp-tarkov.com/SPT-AKI/Modules.git --branch "$TAG" --depth 1 /workspace/refringe/Build/modules
        fi
      shell: bash

    - name: Download Client Module Package
      run: |
        DIR_MANAGED="/workspace/refringe/Build/modules/project/Shared/Managed"
        DOWNLOAD_PATH="$DIR_MANAGED/${{ needs.prepare.outputs.client_version }}.zip"
        DOWNLOAD_URL="${{ secrets.MODULE_DOMAIN }}/${{ needs.prepare.outputs.client_version }}.zip"
        echo "Downloading Client Module Package from $DOWNLOAD_URL to $DOWNLOAD_PATH"
        mkdir -p "$DIR_MANAGED"
        wget -q -O "$DOWNLOAD_PATH" "$DOWNLOAD_URL" || {
          echo "Failed to download the module package."
          exit 1
        }
        if [ ! -s "$DOWNLOAD_PATH" ]; then
          echo "The module package does not exist or is empty."
          exit 1
        fi
        echo "Download Successful: $DOWNLOAD_PATH"
      shell: bash

    - name: Decompress Client Module Package
      run: |
        cd /workspace/refringe/Build/modules/project/Shared/Managed
        7z x ${{ needs.prepare.outputs.client_version }}.zip -aoa
        echo "Client module package decompressed."
      shell: bash

    - name: Delete Client Module Package
      run: |
        cd /workspace/refringe/Build/modules/project/Shared/Managed
        rm -f ${{ needs.prepare.outputs.client_version }}.zip
        echo "Client module package deleted."
      shell: bash

    - name: Build Modules
      run: |
        cd /workspace/refringe/Build/modules/project
        dotnet build
        printf "\nBuilt!\n\n"
        tree /workspace/refringe/Build/modules/project/Build
      shell: bash

    - name: Artifact Modules
      uses: actions/upload-artifact@v3
      with:
        name: modules-artifact
        path: /workspace/refringe/Build/modules/project/Build
        compression-level: 0
        retention-days: 1
        overwrite: true

  build-launcher:
    needs: [prepare]
    if: needs.prepare.outputs.proceed == 'true'
    runs-on: ubuntu-latest
    container:
      image: refringe/spt-build-dotnet:1.0.0
    steps:
    - name: Clone
      run: |
        if [[ "${{ needs.prepare.outputs.is_nightly }}" == "true" ]]; then
          BRANCH=${{ needs.prepare.outputs.branch_launcher }}
          echo "Cloning launcher from branch $BRANCH"
          git clone https://dev.sp-tarkov.com/SPT-AKI/Launcher.git --branch "$BRANCH" --depth 1 /workspace/refringe/Build/launcher
        else
          TAG=${{ needs.prepare.outputs.target_tag }}
          echo "Cloning launcher from tag $TAG"
          git clone https://dev.sp-tarkov.com/SPT-AKI/Launcher.git --branch "$TAG" --depth 1 /workspace/refringe/Build/launcher
        fi
      shell: bash

    - name: Build Launcher
      run: |
        cd /workspace/refringe/Build/launcher/project
        dotnet build
        printf "\nBuilt!\n\n"
        tree /workspace/refringe/Build/launcher/project/Build
      shell: bash

    - name: Artifact Launcher
      uses: actions/upload-artifact@v3
      with:
        name: launcher-artifact
        path: /workspace/refringe/Build/launcher/project/Build
        compression-level: 0
        retention-days: 1
        overwrite: true

  assemble-release:
    needs: [prepare, build-server, build-modules, build-launcher]
    runs-on: ubuntu-latest
    container:
      image: refringe/spt-build-node:1.0.5
    outputs:
      base_name: ${{ steps.generate-filename.outputs.base_name }}
      build_name: ${{ steps.generate-filename.outputs.build_name }}
    steps:
    - name: Clean Directory
      run: |
        rm -rf /workspace/refringe/Build/release /workspace/refringe/Build/build
        mkdir -p /workspace/refringe/Build/release
      shell: bash

    - name: Download Server Artifact
      uses: actions/download-artifact@v3
      with:
        name: server-artifact
        path: /workspace/refringe/Build/release/

    - name: Download Modules Artifact
      uses: actions/download-artifact@v3
      with:
        name: modules-artifact
        path: /workspace/refringe/Build/release/

    - name: Download Launcher Artifact
      uses: actions/download-artifact@v3
      with:
        name: launcher-artifact
        path: /workspace/refringe/Build/release/

    - name: Clone Build Project
      uses: actions/checkout@v3
      with:
        path: /workspace/refringe/Build/build

    - name: Merge Static Assets and Dynamic Files
      run: cp -rvf /workspace/refringe/Build/build/static-assets/* /workspace/refringe/Build/release/
      shell: bash

    - name: List Release Contents
      run: tree /workspace/refringe/Build/release
      shell: bash

    - name: Generate Release Filename
      id: generate-filename
      run: |
        BUILD_TYPE=${{ needs.build-server.outputs.build_type }}
        SPT_VERSION=${{ needs.prepare.outputs.spt_version }}
        CLIENT_VERSION=${{ needs.prepare.outputs.client_version }}
        TARGET_TAG=${{ needs.prepare.outputs.target_tag }}
        DATE=$(date +%Y%m%d)

        # Conditionally format the BASE_NAME based on BUILD_TYPE and if it's a nightly build
        if [[ "${{ needs.prepare.outputs.is_nightly }}" == "true" ]]; then
          BASE_NAME="SPT-NIGHTLY-${SPT_VERSION}-${CLIENT_VERSION}-${DATE}"
        else
          # Make BUILD_TYPE and TARGET_TAG uppercase
          UPPER_BUILD_TYPE=$(echo "$BUILD_TYPE" | tr '[:lower:]' '[:upper:]')
          UPPER_TARGET_TAG=$(echo "$TARGET_TAG" | tr '[:lower:]' '[:upper:]')

          if [ "$BUILD_TYPE" = "release" ]; then
            BASE_NAME="SPT-${SPT_VERSION}-${CLIENT_VERSION}"
          else
            # For debug and non-nightly-bleeding builds, include either TAG_PART or DATE, but not both
            # Determine TAG_PART based on TARGET_TAG structure
            TAG_PART=""
            if [[ "$UPPER_TARGET_TAG" == *-*-* ]]; then
              SUFFIX="${UPPER_TARGET_TAG##*-}"
              if [ "$SUFFIX" != "$UPPER_TARGET_TAG" ]; then
                TAG_PART="-${SUFFIX}"
              fi
            fi
            if [ -n "$TAG_PART" ]; then
              BASE_NAME="SPT-${UPPER_BUILD_TYPE}-${SPT_VERSION}-${CLIENT_VERSION}${TAG_PART}"
            else
              BASE_NAME="SPT-${UPPER_BUILD_TYPE}-${SPT_VERSION}-${CLIENT_VERSION}-${DATE}"
            fi
          fi
        fi

        echo "::set-output name=base_name::${BASE_NAME}"
        echo "::set-output name=build_name::${BASE_NAME}.7z"
      shell: bash

    - name: Artifact Release
      uses: actions/upload-artifact@v3
      with:
        name: release-artifact
        path: /workspace/refringe/Build/release
        compression-level: 0
        retention-days: 1
        overwrite: true

  publish-release:
    needs: [prepare, assemble-release, build-server]
    runs-on: ubuntu-latest
    container:
      image: refringe/spt-build-node:1.0.5
    steps:
    - name: Download Release Artifact
      uses: actions/download-artifact@v3
      with:
        name: release-artifact
        path: /workspace/refringe/Build/release

    - name: Compress Release
      run: |
        cd /workspace/refringe/Build/release
        7z a -mx=9 -m0=lzma2 "../${{ needs.assemble-release.outputs.build_name }}" ./*
        echo "Release compressed as ${{ needs.assemble-release.outputs.build_name }}."
      shell: bash

    - name: Upload Release to HTTPS Source
      id: upload-https-7z
      run: |
        cd /workspace/refringe/Build/
        echo "${{ secrets.SFTP_HOST_KEY }}" > known_host
        sshpass -p "${{ secrets.SFTP_PASSWORD }}" scp -v -o "Port=${{ secrets.SFTP_PORT }}" -o "ConnectTimeout=20" -o "UserKnownHostsFile=known_host" -o "StrictHostKeyChecking=yes" "/workspace/refringe/Build/${{ needs.assemble-release.outputs.build_name }}" ${{ secrets.SFTP_USERNAME }}@${{ secrets.SFTP_HOST }}:/public
        echo "::set-output name=link_https::${{ secrets.SFTP_MIRROR_LINK }}/${{ needs.assemble-release.outputs.build_name }}"
      shell: bash

    - name: Create Torrent File
      id: torrent_create
      run: |
        BASE_NAME="${{ needs.assemble-release.outputs.base_name }}"
        BUILD_NAME="${{ needs.assemble-release.outputs.build_name }}"
        TORRENT_NAME="${BASE_NAME}.torrent"
        TORF_OUTPUT=$(/opt/venv/bin/torf --yes --out "/workspace/refringe/Build/${TORRENT_NAME}" \
          --webseed "${{ steps.upload-https-7z.outputs.link_https }}" \
          --tracker "http://open.acgnxtracker.com:80/announce,https://tracker.tamersunion.org:443/announce,http://tracker.renfei.net:8080/announce,udp://tracker.torrent.eu.org:451/announce,udp://ec2-18-191-163-220.us-east-2.compute.amazonaws.com:6969/announce" \
          --comment "Official ${BASE_NAME} release, built by the team at sp-tarkov.com. Have fun!" \
          --creator "sp-tarkov.com" \
          --verbose \
          "/workspace/refringe/Build/${{ needs.assemble-release.outputs.build_name }}")
        MAGNET_LINK=$(echo "${TORF_OUTPUT}" | grep -oP 'Magnet\t\K.*')
        echo "::set-output name=link_magnet::${MAGNET_LINK}"
        echo "::set-output name=torrent_name::${TORRENT_NAME}"
      shell: bash

    - name: Upload Torrent to HTTPS Source
      id: upload-https-torrent
      run: |
        cd /workspace/refringe/Build/
        echo "${{ secrets.SFTP_HOST_KEY }}" > known_host
        sshpass -p "${{ secrets.SFTP_PASSWORD }}" scp -v -o "Port=${{ secrets.SFTP_PORT }}" -o "ConnectTimeout=20" -o "UserKnownHostsFile=known_host" -o "StrictHostKeyChecking=yes" "/workspace/refringe/Build/${{ steps.torrent_create.outputs.torrent_name }}" ${{ secrets.SFTP_USERNAME }}@${{ secrets.SFTP_HOST }}:/public
        echo "::set-output name=link_torrent::${{ secrets.SFTP_MIRROR_LINK }}/${{ steps.torrent_create.outputs.torrent_name }}"
      shell: bash

    - name: Clean Old HTTPS Source Releases
      run: |
        cd /workspace/refringe/Build/
        echo "${{ secrets.SFTP_HOST_KEY }}" > known_hosts

        # Creating a script for sftp to execute
        echo "cd /public" > sftp_commands.txt
        echo "ls" >> sftp_commands.txt

        # Fetch a remote list of files
        FILE_LIST=$(sshpass -p "${{ secrets.SFTP_PASSWORD }}" sftp -oBatchMode=no -oPort=${{ secrets.SFTP_PORT }} -oUserKnownHostsFile=known_hosts -oStrictHostKeyChecking=yes -b sftp_commands.txt ${{ secrets.SFTP_USERNAME }}@${{ secrets.SFTP_HOST }})

        echo "Files listed:"
        echo "$FILE_LIST"

        # Filtering and processing the file list
        echo "$FILE_LIST" | tr ' ' '\n' | grep -E 'SPT-(DEBUG|BLEEDING).*\.(7z|torrent)$' | while read filename; do
            echo "Processing file: $filename"
            # Extract date from filename
            if [[ "$filename" =~ ([0-9]{8})\.(7z|torrent)$ ]]; then
              file_date="${BASH_REMATCH[1]}"
              file_date_fmt=$(date -d "${file_date:0:4}-${file_date:4:2}-${file_date:6:2}" +%s)

              current_date=$(date +%s)
              limit_date=$(date -d "@$((current_date - 30 * 24 * 3600))" +%s)

              if [[ "$file_date_fmt" -lt "$limit_date" ]]; then
                echo "Marked for deletion: $filename"
                echo "rm \"/public/$filename\"" >> delete_commands.txt
              fi
            fi
        done

        # Check if there are files to delete and execute
        if [ -s delete_commands.txt ]; then
          echo "Running deletion task..."
          sshpass -p "${{ secrets.SFTP_PASSWORD }}" sftp -oBatchMode=no -oPort=${{ secrets.SFTP_PORT }} -oUserKnownHostsFile=known_hosts -oStrictHostKeyChecking=yes -b delete_commands.txt ${{ secrets.SFTP_USERNAME }}@${{ secrets.SFTP_HOST }}
        else
          echo "No old files to delete."
        fi
      shell: bash

    - name: Upload Release to Mega
      id: upload-mega
      run: |
        mega-https on
        mega-login "${{ secrets.MEGA_EMAIL }}" "${{ secrets.MEGA_PASSWORD }}"

        mega-put -c "/workspace/refringe/Build/${{ needs.assemble-release.outputs.build_name }}" "/spt-release/${{ needs.assemble-release.outputs.build_name }}"

        # Generate link and save it.
        EXPORT_OUTPUT=$(mega-export -a "/spt-release/${{ needs.assemble-release.outputs.build_name }}" -f)
        LINK_MEGA=$(echo "$EXPORT_OUTPUT" | grep -o 'https://mega.nz/file/[A-Za-z0-9#_\-]*')
        echo "::set-output name=link_mega::${LINK_MEGA}"

        mega-logout
      shell: bash

    - name: Clean Old Mega Releases
      run: |
        mega-https on
        mega-login "${{ secrets.MEGA_EMAIL }}" "${{ secrets.MEGA_PASSWORD }}"

        # List files and filter out old DEBUG or BLEEDING files
        mega-ls /spt-release | grep -E 'SPT-(DEBUG|BLEEDING).*\.7z$' | while read -r filename; do
          # Extract date from filename
          if [[ "$filename" =~ ([0-9]{8})\.7z$ ]]; then
            file_date="${BASH_REMATCH[1]}"
            file_date_fmt=$(date -d "${file_date:0:4}-${file_date:4:2}-${file_date:6:2}" +%s)

            # Get current date minus 30 days
            current_date=$(date +%s)
            limit_date=$(date -d "@$((current_date - 30 * 24 * 3600))" +%s)

            # Compare dates and delete old files
            if [[ "$file_date_fmt" -lt "$limit_date" ]]; then
              echo "Deleting old file: $filename"
              mega-rm "/spt-release/$filename"
            fi
          fi
        done

        # Remove old file versions to save space.
        mega-deleteversions -f /spt-release/*

        mega-logout
      shell: bash

    - name: Post Build Info to Discord
      env:
        DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
        BUILD_TYPE: ${{ needs.build-server.outputs.build_type }}
        BASE_NAME: ${{ needs.assemble-release.outputs.base_name }}
        BUILD_NAME: ${{ needs.assemble-release.outputs.build_name }}
        LINK_MEGA: ${{ steps.upload-mega.outputs.link_mega }}
        LINK_HTTPS:  ${{ steps.upload-https-7z.outputs.link_https }}
        LINK_TORRENT: ${{ steps.upload-https-torrent.outputs.link_torrent }}
        MODS_ENABLED_BLEEDING: ${{ needs.prepare.outputs.mod_enabled_bleeding }}
        MODS_ENABLED_DEBUG: ${{ needs.prepare.outputs.mod_enabled_debug }}
        MODS_ENABLED_RELEASE: ${{ needs.prepare.outputs.mod_enabled_release }}
      run: |
        cd /workspace/refringe/Build/
        FOOTER_MESSAGES=("You look great today!" "Powered by coffee" "Did you remember to hydrate today?" "Have you tried turning it off and on again?" "In Chomp we trust" "Beep boop, I'm a bot" "Keep calm and commit your code" "May the source be with you" "Go to bed, Terk" "Please direct all support requests to Drakia" "Meaw")
        FOOTER_MESSAGE="${FOOTER_MESSAGES[$RANDOM % ${#FOOTER_MESSAGES[@]}]}"
        TIMESTAMP=$(date --iso-8601=seconds)
        FILE_SIZE_MB=$(stat -c %s "$BUILD_NAME" | awk '{printf "%.2f MB", $1 / 1024 / 1024}')
        FILE_HASH=$(sha256sum "$BUILD_NAME" | awk '{print $1}')
        MODS=""

        if [[ "${{ needs.prepare.outputs.is_nightly }}" == "true" ]]; then
            EMBED_COLOR=0xfff700
            EMBED_TITLE="Fresh Nightly Build"
            EMBED_DESCRIPTION=$'A new nightly build is now available. These are untested and considered unstable. Absolutely no support is provided—If you ask for help you **will be banned from the #dev-builds channel without notice**. 7-Zip is *required* to extract the release.'
            MODS="$MODS_ENABLED_BLEEDING"
        else
          if [ "$BUILD_TYPE" == "bleeding" ]; then
            EMBED_COLOR=0xff0000
            EMBED_TITLE="New Bleeding Build"
            EMBED_DESCRIPTION=$'A new bleeding edge build is now available. These are for testing issues and not for general gameplay. 7-Zip is *required* to extract the release.'
            MODS="$MODS_ENABLED_BLEEDING"
          elif [ "$BUILD_TYPE" == "debug" ]; then
            EMBED_COLOR=0x000055
            EMBED_TITLE="New Debug Build"
            EMBED_DESCRIPTION=$'A new debug build is now available. These have extra-verbose logging enabled. 7-Zip is *required* to extract the release.'
            MODS="$MODS_ENABLED_DEBUG"
          else
            EMBED_COLOR=0x33ff00
            EMBED_TITLE="New Stable Build"
            EMBED_DESCRIPTION=$'A new stable release build is now ready for download. 7-Zip is *required* to extract the release.'
            MODS="$MODS_ENABLED_RELEASE"
          fi
        fi
        EMBED_DESCRIPTION+=$'\n\n**Build Information:** 📊\nName: *'"${BASE_NAME}"$'*\nMods Enabled: *'"${MODS}"$'*\nFile Size: *'"${FILE_SIZE_MB}"$'*\nSHA-256 Hash: *'"${FILE_HASH}"$'*\n\n**Primary Download Link:** 🚀\n'"${LINK_MEGA}"$'\n\n**Torrent Link:** 🔗\n'"${LINK_TORRENT}"$'\n\nIn order to conserve bandwidth, please consider using the *above* methods to download the release. If you have issues using those methods, you are free to download using any of the following HTTP mirrors.\n\nWhile the links *below* are not secret, **do not advertise them**. The primary MEGA link or torrent should be used to advertise any downloads.\n\n**Mirrors:** 🌐\n'"${LINK_HTTPS}"

        jq -n \
          --arg EMBED_TITLE "$EMBED_TITLE" \
          --arg EMBED_DESCRIPTION "$EMBED_DESCRIPTION" \
          --arg LINK_MEGA "$LINK_MEGA" \
          --argjson EMBED_COLOR $EMBED_COLOR \
          --arg FOOTER_MESSAGE "$FOOTER_MESSAGE" \
          --arg TIMESTAMP "$TIMESTAMP" \
          '{
            "username": "BuildBot",
            "avatar_url": "https://i.imgur.com/28JJJec.png",
            "content": "✨ **New Build Available!** ✨",
            "embeds": [
              {
                "title": $EMBED_TITLE,
                "description": $EMBED_DESCRIPTION,
                "url": $LINK_MEGA,
                "color": $EMBED_COLOR,
                "footer": {
                  "text": $FOOTER_MESSAGE
                },
                "timestamp": $TIMESTAMP
              }
            ]
          }' > payload_discord.json

        echo "Payload Generated:"
        cat payload_discord.json

        echo "Sending Payload..."
        curl -H "Content-Type: application/json" \
          -X POST \
          --data-binary @payload_discord.json \
          $DISCORD_WEBHOOK_URL
      shell: bash