gowalk-cicd 1.0.14 → 1.0.15

package/README.md

@@ -205,6 +205,29 @@ committed back. If the module computes its `versionCode` instead of declaring a
 literal, the action emits a `::warning::` and leaves the project's own value
 alone.
 
+### Gradle wrapper floor (Flutter apps)
+
+The Flutter Gradle plugin refuses to apply to a project whose wrapper is older
+than the SDK's floor:
+
+```
+Your project's Gradle version (8.11.1) is lower than Flutter's minimum
+supported version of 8.14.0.
+```
+
+CI installs the current `stable` Flutter, so that floor rises on Flutter's
+release cadence rather than the app's — every app in a fleet breaks on the same
+day, long after the last commit that could have anticipated it. Before building,
+the action reads the floor out of the runner's Flutter SDK and, when the
+project's `gradle-wrapper.properties` is below it, rewrites `distributionUrl`
+**in the checkout** with a `::warning::`. Same policy as the versionCode
+rewrite: the edit is never committed back, so the project keeps whatever
+version its authors chose. Commit the bump yourself to silence the warning.
+
+(The rewritten name is verified against `services.gradle.org` because Gradle's
+own naming is inconsistent across majors — `gradle-8.14-all.zip` but
+`gradle-9.0.0-all.zip`.)
+
 ### iOS delivery
 
 The iOS composite action runs on `macos-15` and:

package/action/.daemux-version

@@ -1 +1 @@
-1.0.14
+1.0.15

package/android-action/.daemux-version

@@ -1 +1 @@
-1.0.14
+1.0.15

package/android-action/scripts/gradle_wrapper.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Raise a Flutter app's Gradle wrapper to the version its Flutter SDK requires.
+
+The Flutter Gradle plugin refuses to apply when the project's wrapper is older
+than the SDK's floor:
+
+    Your project's Gradle version (8.11.1) is lower than Flutter's minimum
+    supported version of 8.14.0.
+
+CI installs the current `stable` Flutter, so that floor rises on Flutter's
+release cadence, not the app's. Every app in a fleet then breaks on the same
+day — long after the last commit that could have anticipated it.
+
+This raises the wrapper inside the CI checkout, the same way the action already
+rewrites versionCode there. The edit is never committed back; the project keeps
+whatever version its authors chose, and the build stops depending on the
+project having been touched since the last Flutter release.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+# `stable` moves the floor over time, so read it from the SDK rather than
+# hardcoding a number this file would have to chase.
+_CHECKER = Path("packages/flutter_tools/gradle/src/main/kotlin/DependencyVersionChecker.kt")
+_ERROR_VERSION = re.compile(r"errorGradleVersion\s*:\s*Version\s*=\s*Version\((\d+),\s*(\d+),\s*(\d+)\)")
+_DISTRIBUTION = re.compile(r"^(distributionUrl=.*gradle-)([0-9]+(?:\.[0-9]+)*)(-(?:all|bin)\.zip)$", re.M)
+
+Version = tuple[int, ...]
+
+
+def parse_version(text: str) -> Version | None:
+    if not re.fullmatch(r"[0-9]+(\.[0-9]+)*", text or ""):
+        return None
+    return tuple(int(part) for part in text.split("."))
+
+
+def _render(version: Version) -> str:
+    return ".".join(str(part) for part in version)
+
+
+def _stripped(version: Version) -> str:
+    parts = list(version)
+    while len(parts) > 2 and parts[-1] == 0:
+        parts.pop()
+    return _render(tuple(parts))
+
+
+def candidates(version: Version) -> list[str]:
+    """Distribution names to try, best guess first.
+
+    Gradle's naming is not consistent across majors: 8.x drops a trailing zero
+    patch (`gradle-8.14-all.zip`; `gradle-8.14.0-all.zip` is a 404) while 9.x
+    keeps it (`gradle-9.0.0-all.zip`; `gradle-9.0-all.zip` is a 404). Getting
+    this wrong swaps the error being fixed for a download failure that does not
+    look like our doing, so order by the observed rule and keep the other form
+    as a fallback.
+    """
+    stripped, full = _stripped(version), _render(version)
+    order = [full, stripped] if version and version[0] >= 9 else [stripped, full]
+    return list(dict.fromkeys(order))
+
+
+def _exists(name: str) -> bool | None:
+    """True/False if the distribution could be checked, None if we could not."""
+    import urllib.error
+    import urllib.request
+
+    url = f"https://services.gradle.org/distributions/gradle-{name}-all.zip"
+    request = urllib.request.Request(url, method="HEAD")
+    try:
+        with urllib.request.urlopen(request, timeout=15) as response:
+            return response.status == 200
+    except urllib.error.HTTPError as exc:
+        return exc.code == 200
+    except OSError:
+        return None
+
+
+def normalize(version: Version, probe=_exists) -> str:
+    """The distribution name to write into distributionUrl.
+
+    Probes services.gradle.org so a future naming change corrects itself; falls
+    back to the ordering in `candidates` when the network is unavailable, which
+    is no worse than not probing at all.
+    """
+    options = candidates(version)
+    for name in options:
+        if probe(name) is True:
+            return name
+    return options[0]
+
+
+def flutter_minimum_gradle(flutter_root: Path) -> Version | None:
+    """The oldest Gradle this Flutter SDK will apply its plugin against."""
+    checker = flutter_root / _CHECKER
+    try:
+        match = _ERROR_VERSION.search(checker.read_text(encoding="utf-8"))
+    except OSError:
+        return None
+    if not match:
+        return None
+    return tuple(int(group) for group in match.groups())
+
+
+def wrapper_properties(workspace: Path, gradle_root: Path | None = None) -> Path:
+    root = gradle_root or (workspace / "android")
+    return root / "gradle" / "wrapper" / "gradle-wrapper.properties"
+
+
+def read_wrapper_version(properties: Path) -> Version | None:
+    try:
+        match = _DISTRIBUTION.search(properties.read_text(encoding="utf-8"))
+    except OSError:
+        return None
+    return parse_version(match.group(2)) if match else None
+
+
+def set_wrapper_version(properties: Path, version: Version) -> bool:
+    try:
+        text = properties.read_text(encoding="utf-8")
+    except OSError:
+        return False
+    replaced, count = _DISTRIBUTION.subn(
+        lambda m: f"{m.group(1)}{normalize(version)}{m.group(3)}", text
+    )
+    if not count:
+        return False
+    properties.write_text(replaced, encoding="utf-8")
+    return True
+
+
+def ensure_minimum(workspace: Path, flutter_root: Path, gradle_root: Path | None = None) -> str:
+    """Raise the wrapper to Flutter's floor. Returns a line for the build log."""
+    properties = wrapper_properties(workspace, gradle_root)
+    if not properties.is_file():
+        return ""
+    minimum = flutter_minimum_gradle(flutter_root)
+    if minimum is None:
+        return (
+            "::warning::Could not read Flutter's minimum Gradle version from "
+            f"{flutter_root}; leaving the wrapper alone"
+        )
+    current = read_wrapper_version(properties)
+    if current is None:
+        return f"::warning::No Gradle distributionUrl found in {properties}; leaving it alone"
+    if current >= minimum:
+        return f"Gradle wrapper {normalize(current)} meets Flutter's minimum {normalize(minimum)}"
+    if not set_wrapper_version(properties, minimum):
+        return f"::warning::Failed to rewrite the Gradle distributionUrl in {properties}"
+    return (
+        f"::warning::Gradle wrapper {normalize(current)} is below Flutter's minimum "
+        f"{normalize(minimum)}; raised it to {normalize(minimum)} for this build only. "
+        f"Commit the bump in {properties.name} to make it permanent."
+    )

package/android-action/scripts/resolve_android.py

@@ -4,9 +4,11 @@
 from __future__ import annotations
 
 import os
+import shutil
 import sys
 from pathlib import Path
 
+import gradle_wrapper
 from android_config import (
     ConfigError,
     detect_package_name,
@@ -126,6 +128,22 @@ def apply_gradle_version(project, build_number: int, build_name: str) -> None:
         )
 
 
+def flutter_root() -> Path | None:
+    """Where the runner's Flutter SDK lives.
+
+    flutter-action exports FLUTTER_ROOT; a self-hosted runner with Flutter
+    merely on PATH does not, so fall back to walking up from the binary
+    (<root>/bin/flutter).
+    """
+    declared = os.environ.get("FLUTTER_ROOT")
+    if declared:
+        return Path(declared)
+    binary = shutil.which("flutter")
+    if not binary:
+        return None
+    return Path(binary).resolve().parent.parent
+
+
 def main() -> None:
     workspace = Path(os.environ.get("GITHUB_WORKSPACE", ".")).resolve()
     env_path = Path(os.environ["GITHUB_ENV"])
@@ -151,6 +169,18 @@ def main() -> None:
             apply_gradle_version(
                 project, build_number, os.environ.get("INPUT_BUILD_NAME") or ""
             )
+        else:
+            # Flutter refuses to apply its Gradle plugin to a wrapper older than
+            # the SDK's floor, and CI tracks `stable`, so that floor rises
+            # without the app changing. Raise it in the checkout rather than
+            # letting every app in the fleet break on Flutter's release day.
+            root = flutter_root()
+            if root is None:
+                print("::warning::Flutter SDK not found; skipping the Gradle wrapper check")
+            else:
+                message = gradle_wrapper.ensure_minimum(workspace, root)
+                if message:
+                    print(message)
     except (ConfigError, KeyError, OSError) as exc:
         print(f"::error::{exc}")
         raise SystemExit(1) from exc

package/android-action/scripts/test_gradle_wrapper.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Tests for raising a Flutter app's Gradle wrapper to the SDK's floor."""
+
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+import gradle_wrapper as gw
+
+CHECKER_SOURCE = """
+package com.flutter.gradle
+object DependencyVersionChecker {
+    internal val warnGradleVersion: Version = Version(8, 7, 0)
+    internal val errorGradleVersion: Version = Version(8, 14, 0)
+}
+"""
+
+WRAPPER = (
+    "distributionBase=GRADLE_USER_HOME\n"
+    "distributionPath=wrapper/dists\n"
+    "distributionUrl=https\\://services.gradle.org/distributions/gradle-8.11.1-all.zip\n"
+)
+
+
+def never(_name: str) -> bool:
+    """Probe stub for tests: the network is never consulted."""
+    return False
+
+
+class RenderTest(unittest.TestCase):
+    def test_eight_x_drops_a_trailing_zero_patch(self):
+        self.assertEqual(gw.candidates((8, 14, 0))[0], "8.14")
+
+    def test_nine_x_keeps_a_trailing_zero_patch(self):
+        # gradle-9.0-all.zip is a 404; gradle-9.0.0-all.zip is the real name.
+        self.assertEqual(gw.candidates((9, 0, 0))[0], "9.0.0")
+
+    def test_a_real_patch_is_never_stripped(self):
+        self.assertEqual(gw.candidates((8, 14, 3)), ["8.14.3"])
+
+    def test_the_other_spelling_stays_available_as_a_fallback(self):
+        self.assertIn("8.14.0", gw.candidates((8, 14, 0)))
+
+    def test_falls_back_to_the_first_candidate_without_network(self):
+        self.assertEqual(gw.normalize((8, 14, 0), probe=never), "8.14")
+
+    def test_a_successful_probe_wins_over_the_ordering(self):
+        self.assertEqual(
+            gw.normalize((8, 14, 0), probe=lambda name: name == "8.14.0"), "8.14.0"
+        )
+
+
+class WrapperFileTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.workspace = Path(self.tmp.name)
+        self.properties = gw.wrapper_properties(self.workspace)
+        self.properties.parent.mkdir(parents=True)
+        self.properties.write_text(WRAPPER, encoding="utf-8")
+        self.flutter = self.workspace / "flutter"
+        checker = self.flutter / gw._CHECKER
+        checker.parent.mkdir(parents=True)
+        checker.write_text(CHECKER_SOURCE, encoding="utf-8")
+        self.addCleanup(self.tmp.cleanup)
+
+    def test_reads_the_declared_version(self):
+        self.assertEqual(gw.read_wrapper_version(self.properties), (8, 11, 1))
+
+    def test_reads_the_sdk_floor(self):
+        self.assertEqual(gw.flutter_minimum_gradle(self.flutter), (8, 14, 0))
+
+    def test_raises_a_wrapper_below_the_floor(self):
+        gw.set_wrapper_version(self.properties, (8, 14, 0))
+        self.assertEqual(gw.read_wrapper_version(self.properties), (8, 14,))
+        self.assertIn("gradle-8.14-all.zip", self.properties.read_text())
+
+    def test_preserves_a_bin_distribution(self):
+        self.properties.write_text(
+            WRAPPER.replace("-all.zip", "-bin.zip"), encoding="utf-8"
+        )
+        gw.set_wrapper_version(self.properties, (8, 14, 0))
+        self.assertIn("gradle-8.14-bin.zip", self.properties.read_text())
+
+    def test_leaves_a_wrapper_already_at_the_floor_alone(self):
+        self.properties.write_text(
+            WRAPPER.replace("8.11.1", "8.14.3"), encoding="utf-8"
+        )
+        message = gw.ensure_minimum(self.workspace, self.flutter)
+        self.assertIn("meets Flutter's minimum", message)
+        self.assertIn("gradle-8.14.3-all.zip", self.properties.read_text())
+
+    def test_warns_and_raises_when_below_the_floor(self):
+        message = gw.ensure_minimum(self.workspace, self.flutter)
+        self.assertTrue(message.startswith("::warning::"))
+        self.assertIn("8.11.1", message)
+        self.assertIn("gradle-8.14", self.properties.read_text())
+
+    def test_no_wrapper_is_not_an_error(self):
+        self.properties.unlink()
+        self.assertEqual(gw.ensure_minimum(self.workspace, self.flutter), "")
+
+    def test_unreadable_sdk_leaves_the_wrapper_untouched(self):
+        message = gw.ensure_minimum(self.workspace, self.workspace / "nope")
+        self.assertTrue(message.startswith("::warning::"))
+        self.assertIn("gradle-8.11.1-all.zip", self.properties.read_text())
+
+    def test_a_wrapper_without_a_distribution_url_is_left_alone(self):
+        self.properties.write_text("distributionBase=GRADLE_USER_HOME\n", encoding="utf-8")
+        message = gw.ensure_minimum(self.workspace, self.flutter)
+        self.assertIn("No Gradle distributionUrl", message)
+
+    def test_honours_an_explicit_gradle_root(self):
+        root = self.workspace / "nested"
+        properties = gw.wrapper_properties(self.workspace, root)
+        properties.parent.mkdir(parents=True)
+        properties.write_text(WRAPPER, encoding="utf-8")
+        gw.ensure_minimum(self.workspace, self.flutter, gradle_root=root)
+        self.assertIn("gradle-8.14", properties.read_text())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gowalk-cicd",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "Zero-config GitHub Actions delivery for iOS TestFlight and Android Google Play.",
   "type": "module",
   "bin": {