fix(actions): avoid status event fan-out

chore(deps):(deps): bump actions/setup-python from 6 to 7 in the github-actions group across 1 directory

.github/workflows/build.yml

@@ -26,7 +26,7 @@ jobs:
     env:
       # Build configuration
       SOURCE_REPO: "FongMi/TV"
-      SOURCE_BRANCH: "release"
+      SOURCE_BRANCH: "fongmi"
       API_RETRY_COUNT: 3
       API_RETRY_DELAY: 5
 
@@ -38,10 +38,10 @@ jobs:
 
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Checkout source code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
         with:
           repository: ${{ env.SOURCE_REPO }}
           ref: ${{ env.SOURCE_BRANCH }}
@@ -143,15 +143,21 @@ jobs:
 
       - name: Set up JDK 17
         if: steps.check_build.outputs.build_needed == 'true'
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: "temurin"
           java-version: "17"
           cache: "gradle"
 
+      - name: Set up Python 3.10
+        if: steps.check_build.outputs.build_needed == 'true'
+        uses: actions/setup-python@v7
+        with:
+          python-version: "3.10"
+
       - name: Cache Gradle dependencies
         if: steps.check_build.outputs.build_needed == 'true'
-        uses: actions/cache@v4
+        uses: actions/cache@v6
         with:
           path: |
             ~/.gradle/caches
@@ -176,8 +182,31 @@ jobs:
           fi
           echo "✅ Keystore decoded successfully"
 
-      - name: Build release APKs
+      - name: Prepare Android local.properties
         if: steps.check_build.outputs.build_needed == 'true'
+        run: |
+          echo "📝 Preparing Android local.properties for CI..."
+
+          SDK_DIR="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-}}"
+          if [ -z "$SDK_DIR" ]; then
+            echo "❌ ANDROID_HOME / ANDROID_SDK_ROOT is not set"
+            exit 1
+          fi
+
+          cat > src/local.properties <<EOF
+          sdk.dir=$SDK_DIR
+          storeFile=$GITHUB_WORKSPACE/keystore.jks
+          storePassword=$KEYSTORE_PASSWORD
+          keyAlias=$KEY_ALIAS
+          keyPassword=$KEY_PASSWORD
+          EOF
+
+          echo "✅ local.properties created successfully"
+
+      - name: Build release APKs
+        id: build_apks
+        if: steps.check_build.outputs.build_needed == 'true'
+        continue-on-error: true
         run: |
           echo "🔨 Building release APKs..."
           cd src
@@ -202,13 +231,17 @@ jobs:
             
           echo "✅ APK build completed successfully"
 
-          # Clean up keystore for security
+      - name: Clean up keystore
+        if: steps.check_build.outputs.build_needed == 'true'
+        run: |
+          # Clean up generated signing files for security
           rm -f "$GITHUB_WORKSPACE/keystore.jks"
+          rm -f "$GITHUB_WORKSPACE/src/local.properties"
           echo "🔐 Keystore cleaned up"
 
       - name: Create GitHub Release
-        if: steps.check_build.outputs.build_needed == 'true'
-        uses: softprops/action-gh-release@v2
+        if: steps.check_build.outputs.build_needed == 'true' && steps.build_apks.outcome == 'success'
+        uses: softprops/action-gh-release@v3
         with:
           tag_name: ${{ steps.commit_info.outputs.short_hash }}
           name: "FongMi TV APK Release ${{ steps.commit_info.outputs.short_hash }}"
@@ -248,7 +281,7 @@ jobs:
           echo ""
           echo "🚀 **Build Status:**"
           if [ "${{ steps.check_build.outputs.build_needed }}" = "true" ]; then
-            echo "    Status: ✅ Build Executed"
+            echo "    Build Attempted: ✅ Yes"
             echo "    Reason: ${{ steps.check_build.outputs.build_reason }}"
             if [ "${{ steps.check_build.outputs.is_first_release }}" = "true" ]; then
               echo "    Type: 🎉 First Release"
@@ -256,12 +289,15 @@ jobs:
               echo "    Type: 📦 Update Release"
             fi
             
-            # Check if release was created successfully
-            if [ "${{ job.status }}" = "success" ]; then
+            # Check APK build result
+            if [ "${{ steps.build_apks.outcome }}" = "success" ]; then
+              echo "    APK Build: ✅ Succeeded"
               echo "    Release: ✅ Created Successfully"
               echo "    Tag: ${{ steps.commit_info.outputs.short_hash }}"
             else
-              echo "    Release: ❌ Failed to Create"
+              echo "    APK Build: ⚠️ Failed (upstream source issue)"
+              echo "    Release: ⏭️ Skipped due to build failure"
+              echo "    Note: The upstream FongMi/TV repository may have build issues"
             fi
           else
             echo "    Status: ⏭️ Build Skipped"

.github/workflows/dependabot-auto-merge.yml

@@ -0,0 +1,202 @@
+name: Dependabot Auto Merge
+
+on:
+  check_suite:
+    types: [completed]
+  workflow_run:
+    workflows:
+      - "Build"
+      - "CodeQL"
+      - "Dependabot Updates"
+    types:
+      - completed
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch || github.run_id }}
+  cancel-in-progress: false
+
+permissions:
+  contents: write
+  pull-requests: write
+  checks: read
+  statuses: read
+
+jobs:
+  merge:
+    name: Auto-merge Dependabot PRs
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Merge Dependabot PRs when checks pass
+        uses: actions/github-script@v9
+        with:
+          script: |
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+
+            const successfulCheckConclusions = new Set(["success", "skipped", "neutral"]);
+            const successfulStatusStates = new Set(["success"]);
+            const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+            const latestBy = (items, keyOf, timeOf) => {
+              const latest = new Map();
+              for (const item of items) {
+                const key = keyOf(item);
+                const itemTime = new Date(timeOf(item) || 0).getTime();
+                const existing = latest.get(key);
+                const existingTime = existing ? new Date(timeOf(existing) || 0).getTime() : -1;
+                if (!existing || itemTime >= existingTime) {
+                  latest.set(key, item);
+                }
+              }
+              return [...latest.values()];
+            };
+
+            const findCandidatePulls = async () => {
+              const pulls = await github.paginate(github.rest.pulls.list, {
+                owner,
+                repo,
+                state: "open",
+                per_page: 100,
+              });
+            
+              return pulls.filter((pr) => pr.user?.login === "dependabot[bot]");
+            };
+            
+            const getMergeablePullRequest = async (pull_number) => {
+              for (let attempt = 1; attempt <= 6; attempt += 1) {
+                const { data: pr } = await github.rest.pulls.get({ owner, repo, pull_number });
+                if (pr.mergeable !== null) {
+                  return pr;
+                }
+                core.info("PR #" + pull_number + " mergeability is still being computed; retry " + attempt + "/6.");
+                await wait(5000);
+              }
+
+              const { data: pr } = await github.rest.pulls.get({ owner, repo, pull_number });
+              return pr;
+            };
+
+            const getSignalState = async (sha) => {
+              const checkRuns = await github.paginate(github.rest.checks.listForRef, {
+                owner,
+                repo,
+                ref: sha,
+                per_page: 100,
+              });
+
+              const statuses = await github.paginate(github.rest.repos.listCommitStatusesForRef, {
+                owner,
+                repo,
+                ref: sha,
+                per_page: 100,
+              });
+
+              const latestChecks = latestBy(
+                checkRuns.filter((run) => run.name !== "Dependabot Auto Merge"),
+                (run) => (run.app?.slug || "unknown") + ":" + run.name,
+                (run) => run.completed_at || run.started_at || run.created_at,
+              );
+              const latestStatuses = latestBy(statuses, (status) => status.context, (status) => status.updated_at || status.created_at);
+
+              const pendingChecks = latestChecks.filter((run) => run.status !== "completed");
+              const failedChecks = latestChecks.filter(
+                (run) => run.status === "completed" && !successfulCheckConclusions.has(String(run.conclusion || "").toLowerCase()),
+              );
+              const failedStatuses = latestStatuses.filter((status) => !successfulStatusStates.has(String(status.state || "").toLowerCase()));
+
+              return {
+                totalSignals: latestChecks.length + latestStatuses.length,
+                pendingChecks,
+                failedChecks,
+                failedStatuses,
+              };
+            };
+
+            const { data: repository } = await github.rest.repos.get({ owner, repo });
+            const mergeMethods = [];
+            if (repository.allow_merge_commit) mergeMethods.push("merge");
+            if (repository.allow_squash_merge) mergeMethods.push("squash");
+            if (repository.allow_rebase_merge) mergeMethods.push("rebase");
+
+            if (mergeMethods.length === 0) {
+              core.info("This repository has no enabled pull request merge methods.");
+              return;
+            }
+
+            const pulls = await findCandidatePulls();
+            if (pulls.length === 0) {
+              core.info("No open Dependabot PRs to evaluate.");
+              return;
+            }
+
+            for (const candidate of pulls) {
+              const pull_number = candidate.number;
+              const pr = await getMergeablePullRequest(pull_number);
+
+              if (pr.user?.login !== "dependabot[bot]") {
+                core.info("PR #" + pull_number + " is no longer a Dependabot PR.");
+                continue;
+              }
+
+              if (pr.state !== "open" || pr.draft) {
+                core.info("PR #" + pull_number + " is not an open, ready PR.");
+                continue;
+              }
+
+              if (pr.mergeable !== true) {
+                core.info("PR #" + pull_number + " is not currently mergeable.");
+                continue;
+              }
+
+              const signalState = await getSignalState(pr.head.sha);
+              if (signalState.totalSignals === 0) {
+                core.info("PR #" + pull_number + " has no checks or statuses yet; skipping.");
+                continue;
+              }
+
+              if (signalState.pendingChecks.length > 0) {
+                core.info("PR #" + pull_number + " still has pending checks: " + signalState.pendingChecks.map((run) => run.name).join(", ") + ".");
+                continue;
+              }
+
+              if (signalState.failedChecks.length > 0 || signalState.failedStatuses.length > 0) {
+                const failedChecks = signalState.failedChecks.map((run) => run.name + "=" + run.conclusion).join(", ");
+                const failedStatuses = signalState.failedStatuses.map((status) => status.context + "=" + status.state).join(", ");
+                core.info("PR #" + pull_number + " is not green. Checks: " + (failedChecks || "none") + ". Statuses: " + (failedStatuses || "none") + ".");
+                continue;
+              }
+
+              let merged = false;
+              let lastError = null;
+              for (const merge_method of mergeMethods) {
+                try {
+                  await github.rest.pulls.merge({ owner, repo, pull_number, merge_method });
+                  core.info("Merged Dependabot PR #" + pull_number + " with " + merge_method + ".");
+                  merged = true;
+                  break;
+                } catch (error) {
+                  lastError = error;
+                  if (error.status === 403 || error.status === 405 || error.status === 409) {
+                    core.info("Cannot merge PR #" + pull_number + " with " + merge_method + ": " + error.message);
+                    continue;
+                  }
+                  throw error;
+                }
+              }
+
+              if (!merged) {
+                core.info("PR #" + pull_number + " could not be merged: " + (lastError?.message || "unknown error") + ".");
+                continue;
+              }
+
+              if (pr.head.repo?.full_name === owner + "/" + repo) {
+                try {
+                  await github.rest.git.deleteRef({ owner, repo, ref: "heads/" + pr.head.ref });
+                  core.info("Deleted branch " + pr.head.ref + ".");
+                } catch (error) {
+                  core.info("Could not delete branch " + pr.head.ref + ": " + error.message);
+                }
+              }
+            }