GKI_KernelSU_SUSFS/.github/workflows/main.yml

name: Build Kernels

permissions:
  contents: write
  actions: write

on:
  workflow_dispatch:
    inputs:
      release_type:
        description: "Release Type"
        type: choice
        options: [ Actions, Pre-Release, Release ]
        default: Actions
      ksu_variant:
        description: "KernelSU Variant"
        type: choice
        options: [ KSU, WKSU, Next, RKSU]
        default: WKSU
      ksu_commit:
        description: "KSU Commit (optional)"
        type: string
        default: ""
        required: false
      build_bypass:
        description: "Build Bypass"
        type: boolean
        default: false
      # Build Selection
      build_a12_5_10:
        description: "Android 12 - 5.10"
        type: boolean
        default: false
      build_a13_5_10:
        description: "Android 13 - 5.10"
        type: boolean
        default: false
      build_a13_5_15:
        description: "Android 13 - 5.15"
        type: boolean
        default: false
      build_a14_5_15:
        description: "Android 14 - 5.15"
        type: boolean
        default: false
      build_a14_6_1:
        description: "Android 14 - 6.1"
        type: boolean
        default: false
      build_a15_6_6:
        description: "Android 15 - 6.6"
        type: boolean
        default: false
      build_a16_6_12:
        description: "Android 16 - 6.12"
        type: boolean
        default: false
      build_custom:
        description: "Custom Builds"
        type: boolean
        default: true
      build_lts:
        description: "Build All LTS Kernels"
        type: boolean
        default: false

jobs:
  build-a12-5-10:
    if: inputs.build_a12_5_10
    uses: ./.github/workflows/kernel-a12-5-10.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-a13-5-10:
    if: inputs.build_a13_5_10
    uses: ./.github/workflows/kernel-a13-5-10.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-a13-5-15:
    if: inputs.build_a13_5_15
    uses: ./.github/workflows/kernel-a13-5-15.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-a14-5-15:
    if: inputs.build_a14_5_15
    uses: ./.github/workflows/kernel-a14-5-15.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-a14-6-1:
    if: inputs.build_a14_6_1
    uses: ./.github/workflows/kernel-a14-6-1.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-a15-6-6:
    if: inputs.build_a15_6_6
    uses: ./.github/workflows/kernel-a15-6-6.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-a16-6-12:
    if: inputs.build_a16_6_12
    uses: ./.github/workflows/kernel-a16-612.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-custom:
    if: inputs.build_custom
    uses: ./.github/workflows/kernel-custom.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  build-lts:
    if: inputs.build_lts
    uses: ./.github/workflows/kernel-lts.yml
    secrets: inherit
    with:
      ksu_variant: ${{ inputs.ksu_variant }}
      ksu_commit: ${{ inputs.ksu_commit }}
      build_bypass: ${{ inputs.build_bypass }}

  rej:
    if: always()
    runs-on: ubuntu-latest
    needs:
    - build-a12-5-10
    - build-a13-5-10
    - build-a13-5-15
    - build-a14-5-15
    - build-a14-6-1
    - build-a15-6-6
    - build-a16-6-12
    - build-custom
    - build-lts
    steps:
    - name: Download Misc Artifacts
      uses: actions/download-artifact@v5
      with:
        path: ./downloaded-artifacts
        pattern: '*-Normal-Misc'

    - name: Process Reject Artifacts
      run: |
        mkdir -p aio-rejects
        
        # Iterate over Misc artifacts in downloaded-artifacts
        for dir in ./downloaded-artifacts/*-Normal-Misc; do
            # Ensure it is a directory
            [ -d "$dir" ] || continue
            
            dirname=$(basename "$dir")
            echo "Processing $dirname..."
            
            # Check for patch-rejects folder
            if [ -d "$dir/patch-rejects" ]; then
                echo "Found patch-rejects in $dirname"
                
                # Get original name (remove -Misc suffix)
                original_name=${dirname%-Misc}
                
                # Move and rename patch-rejects to aio-rejects/original_name
                mv "$dir/patch-rejects" "aio-rejects/$original_name"
            else
                echo "No patch-rejects found in $dirname"
            fi
        done
        
        # Zip and upload if we found anything
        if [ "$(ls -A aio-rejects)" ]; then
            echo "Creating AIO-REJ.zip..."
            cd aio-rejects
            zip -r -q -9 ../AIO-REJ.zip .
            cd ..
        else
            echo "No rejects found to upload."
        fi

    - name: Upload AIO-REJ Artifact
      uses: actions/upload-artifact@v4
      with:
        name: AIO-REJ
        path: AIO-REJ.zip
        if-no-files-found: ignore

  release:
    runs-on: ubuntu-latest
    if: inputs.release_type != 'Actions'
    permissions:
      contents: write
    needs:
    - build-a12-5-10
    - build-a13-5-10
    - build-a13-5-15
    - build-a14-5-15
    - build-a14-6-1
    - build-a15-6-6
    - build-a16-6-12
    - build-custom

    env:
      GH_TOKEN: ${{ github.token }}
      RELEASE_NAME: "!!TESTING!! GKI Kernels With KernelSU-Next & SUSFS v2.0.0 !!TESTING!!"
      RELEASE_BODY: ""
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Generate New Tag
      if: inputs.release_type != 'Actions'
      run: |
        LATEST_TAG=$(gh api repos/${{ github.repository }}/tags --jq '.[0].name' 2>/dev/null || echo "")
        if [[ "$LATEST_TAG" =~ ^(.*)-r([0-9]+)$ ]]; then
          VERSION="${BASH_REMATCH[1]}"
          REV="${BASH_REMATCH[2]}"
          NEW_REV=$((REV + 1))
          NEW_TAG="${VERSION}-r${NEW_REV}"
        else
          NEW_TAG="${LATEST_TAG}-r1"
        fi
        
        echo "New tag: $NEW_TAG"
        echo "NEW_TAG=${NEW_TAG}" >> $GITHUB_ENV

    - name: Set release body
      run: |
        cat << 'EOF' > release_body.md

        !!THIS RELEASE IS A TESTING RELEASE!!

        **IMPORTANT DISCLAIMER**
        This software is provided for testing and educational purposes only. Use at your own risk.
        The developers are not responsible for any damage, data loss, or issues that may occur.
        Please ensure you have proper backups before installation.

        🔹 Normal 
        - Default kernel configuration 
        - Standard kernel module loading behavior 
        - Recommended for most users 

        🔹 Bypass 
        - Includes module check bypass modifications 
        - What are kernel modules? Kernel modules are pieces of code that can be loaded into the kernel at runtime to extend functionality (like device drivers, filesystem support, etc.). These are different from KernelSU/Magisk modules. 
        - The Problem: Sometimes when installing a custom kernel, the device tries to load a kernel module that fails due to version mismatches, missing dependencies, or signature verification issues. This can cause boot failures or device instability. 
        - The Solution: This version changes one line from false to true to force load the kernel module, bypassing the failure check that would normally prevent loading.

        Features:
        -> KernelSU-Next dev-susfs patched by pershoot (Warning from pershoot: This version is not recommended for production use. It is only intended for testing and development purposes.)
        -> SUSFS ඞ v2.0.0
        -> Hybrid Root Hooks
        -> Ptrace Patch Support for Older Kernels (<5.16)
        -> IPSet Support for Advanced Network Filtering
        -> Wireguard Support
        -> BBR v1 Support
        -> BBG: https://github.com/vc-teahouse/Baseband-guard

        🔹 BBG (Baseband-guard)
        - A lightweight LSM (Linux Security Module) for Android kernel
        - Blocks unauthorized writes to critical partitions/device nodes
        - Prevents malicious tampering with baseband and boot chain
        - Kernel-level protection via LSM hooks
        - Reduces risk of soft-brick/hard-brick issues

        Kernel Flasher:
        -> https://github.com/fatalcoder524/KernelFlasher/

        Manager:
        -> Next: https://github.com/KernelSU-Next/KernelSU-Next

        Module: 
        -> https://github.com/sidex15/ksu_module_susfs

        !!THIS RELEASE IS A TESTING RELEASE!!
        EOF

    - name: Create GitHub Release
      run: |
        PRERELEASE_FLAG=""
        if [ "${{ inputs.release_type }}" == "Pre-Release" ]; then
          PRERELEASE_FLAG="--prerelease"
        fi

        echo "Creating release ${{ env.NEW_TAG }}..."
        gh release create "${{ env.NEW_TAG }}" \
          --title "${{ env.RELEASE_NAME }}" \
          --notes-file release_body.md \
          --target "${{ github.sha }}" \
          $PRERELEASE_FLAG

    - name: Download Artifacts
      uses: actions/download-artifact@v5
      with:
        path: ./downloaded-artifacts
        pattern: '*-AnyKernel3'

    - name: Upload Release Assets
      run: |+
        shopt -s nullglob
        anykernel_dirs=(./downloaded-artifacts/*-AnyKernel3/)

        if [ ${#anykernel_dirs[@]} -eq 0 ]; then
          echo "No AnyKernel3 artifact directories found; skipping upload."
          exit 0
        fi

        echo "Found ${#anykernel_dirs[@]} artifacts to process"

        # Create all ZIPs in parallel
        for dir in "${anykernel_dirs[@]}"; do
          artifact_name=$(basename "$dir")
          echo "Creating ZIP for $artifact_name..."
          (cd "$dir" && zip -r -q -9 "$GITHUB_WORKSPACE/${artifact_name}.zip" ./*) &
        done
        wait

        # Upload all ZIPs
        for dir in "${anykernel_dirs[@]}"; do
          artifact_name=$(basename "$dir")
          echo "Uploading ${artifact_name}.zip..."
          gh release upload "${{ env.NEW_TAG }}" "${artifact_name}.zip" --clobber
        done

    - name: DM Artifacts
      if: always()
      run: |
        # Check for TheWildJames and Normal artifacts
        for file in ./*TheWildJames*.zip ./*Normal*.zip; do
          if [ -f "$file" ]; then
            echo "Sending $file to Telegram DM..."
            curl -F chat_id="${{ secrets.TELEGRAM_USER_ID }}" \
                 -F document=@"$file" \
                 -F caption="📦 **Build**: $file" \
                 -F parse_mode="Markdown" \
                 https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendDocument
          fi
        done

    - name: Send Telegram Notification
      if: inputs.release_type != 'Actions'
      run: |
        RELEASE_TYPE_TEXT=""
        if [ "${{ inputs.release_type }}" == "Pre-Release" ]; then
          RELEASE_TYPE_TEXT="🧪 *Pre-Release*"
        else
          RELEASE_TYPE_TEXT="🚀 *Release*"
        fi

        curl -X POST "https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendMessage" \
          -F chat_id="${{ secrets.TELEGRAM_CHAT_ID }}" \
          -F message_thread_id="${{ secrets.TELEGRAM_TOPIC_ID_GKI }}" \
          -F text="
          🌽 *New Kernel $RELEASE_TYPE_TEXT Uploaded*  
          📦 *Repository:* [${{ github.repository }}](https://github.com/${{ github.repository }})  
          ✏️ *Commit:* [${{ github.sha }}](https://github.com/${{ github.repository }}/commit/${{ github.sha }})  
          [🔗 View GitHub Release](https://github.com/${{ github.repository }}/releases/tag/${{ env.NEW_TAG }})" \
          -F parse_mode="Markdown"

  notify-actions:
    runs-on: ubuntu-latest
    if: inputs.release_type == 'Actions'
    steps:
    - name: Send Telegram Notification
      run: |
        curl -X POST "https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendMessage" \
          -F chat_id="${{ secrets.TELEGRAM_CHAT_ID }}" \
          -F message_thread_id="${{ secrets.TELEGRAM_TOPIC_ID_GKI }}" \
          -F text="
          🌽 *New Kernel Actions Build Finished*
          📦 *Repository:* [${{ github.repository }}](https://github.com/${{ github.repository }})
          ✏️ *Commit:* [${{ github.sha }}](https://github.com/${{ github.repository }}/commit/${{ github.sha }})
          [🔗 View Action Run](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})" \
          -F parse_mode="Markdown"