gowalk-cicd 1.0.15 → 1.0.17

package/README.md

@@ -205,7 +205,7 @@ 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)
+### Build toolchain floors (Flutter apps)
 
 The Flutter Gradle plugin refuses to apply to a project whose wrapper is older
 than the SDK's floor:
@@ -220,9 +220,13 @@ release cadence rather than the app's — every app in a fleet breaks on the sam
 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.
+**in the checkout** with a `::warning::`. The Android Gradle Plugin and Kotlin
+Gradle Plugin versions declared in `android/settings.gradle` (or the older
+`buildscript { classpath ... }` / `ext.kotlin_version` form) are raised the same
+way against Flutter's `errorAGPVersion` / `errorKGPVersion`. Same policy as the
+versionCode rewrite: the edits are never committed back, so the project keeps
+whatever versions its authors chose. Commit the bumps yourself to silence the
+warnings.
 
 (The rewritten name is verified against `services.gradle.org` because Gradle's
 own naming is inconsistent across majors — `gradle-8.14-all.zip` but

package/action/.daemux-version

@@ -1 +1 @@
-1.0.15
+1.0.17

package/android-action/.daemux-version

@@ -1 +1 @@
-1.0.15
+1.0.17

package/android-action/scripts/gradle_wrapper.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Raise a Flutter app's Gradle wrapper to the version its Flutter SDK requires.
+"""Raise a Flutter app's build toolchain to the versions its Flutter SDK requires.
 
 The Flutter Gradle plugin refuses to apply when the project's wrapper is older
 than the SDK's floor:
@@ -25,7 +25,15 @@ 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+)\)")
+# The same file declares a floor for each of the three: Gradle, the Android
+# Gradle Plugin and the Kotlin Gradle Plugin. All three are hard errors, and
+# all three move with `stable`.
+_FLOORS = {
+    "gradle": r"errorGradleVersion\s*:\s*Version\s*=\s*Version\((\d+),\s*(\d+),\s*(\d+)\)",
+    "agp": r"errorAGPVersion\s*:\s*AndroidPluginVersion\s*=\s*AndroidPluginVersion\((\d+),\s*(\d+),\s*(\d+)\)",
+    "kgp": r"errorKGPVersion\s*:\s*Version\s*=\s*Version\((\d+),\s*(\d+),\s*(\d+)\)",
+}
+_ERROR_VERSION = re.compile(_FLOORS["gradle"])
 _DISTRIBUTION = re.compile(r"^(distributionUrl=.*gradle-)([0-9]+(?:\.[0-9]+)*)(-(?:all|bin)\.zip)$", re.M)
 
 Version = tuple[int, ...]
@@ -93,18 +101,24 @@ def normalize(version: Version, probe=_exists) -> str:
     return options[0]
 
 
-def flutter_minimum_gradle(flutter_root: Path) -> Version | None:
-    """The oldest Gradle this Flutter SDK will apply its plugin against."""
+def flutter_minimum(flutter_root: Path, tool: str) -> Version | None:
+    """The oldest `tool` (gradle | agp | kgp) this Flutter SDK will build against."""
     checker = flutter_root / _CHECKER
     try:
-        match = _ERROR_VERSION.search(checker.read_text(encoding="utf-8"))
+        text = checker.read_text(encoding="utf-8")
     except OSError:
         return None
+    match = re.search(_FLOORS[tool], text)
     if not match:
         return None
     return tuple(int(group) for group in match.groups())
 
 
+def flutter_minimum_gradle(flutter_root: Path) -> Version | None:
+    """The oldest Gradle this Flutter SDK will apply its plugin against."""
+    return flutter_minimum(flutter_root, "gradle")
+
+
 def wrapper_properties(workspace: Path, gradle_root: Path | None = None) -> Path:
     root = gradle_root or (workspace / "android")
     return root / "gradle" / "wrapper" / "gradle-wrapper.properties"
@@ -155,3 +169,103 @@ def ensure_minimum(workspace: Path, flutter_root: Path, gradle_root: Path | None
         f"{normalize(minimum)}; raised it to {normalize(minimum)} for this build only. "
         f"Commit the bump in {properties.name} to make it permanent."
     )
+
+
+# --- Android Gradle Plugin and Kotlin Gradle Plugin -------------------------
+#
+# Both are declared in `android/settings.gradle(.kts)` in the modern Flutter
+# template and in the top-level `android/build.gradle` in the older one. Flutter
+# floors both, and both floors move with `stable`, so an app that built fine
+# last month stops building without a single line of it having changed.
+
+_PLUGIN_BLOCK = {
+    "agp": re.compile(
+        r"""(id\s*\(?\s*["']com\.android\.application["']\s*\)?\s*version\s*["'])([0-9][0-9.]*)(["'])"""
+    ),
+    "kgp": re.compile(
+        r"""(id\s*\(?\s*["']org\.jetbrains\.kotlin\.android["']\s*\)?\s*version\s*["'])([0-9][0-9.]*)(["'])"""
+    ),
+}
+_LEGACY = {
+    "agp": re.compile(r"""(["']com\.android\.tools\.build:gradle:)([0-9][0-9.]*)(["'])"""),
+    "kgp": re.compile(r"""(ext\.kotlin_version\s*=\s*["'])([0-9][0-9.]*)(["'])"""),
+}
+
+_LABEL = {"agp": "Android Gradle Plugin", "kgp": "Kotlin Gradle Plugin"}
+
+
+def toolchain_files(workspace: Path, gradle_root: Path | None = None) -> list[Path]:
+    root = gradle_root or (workspace / "android")
+    names = ("settings.gradle", "settings.gradle.kts", "build.gradle", "build.gradle.kts")
+    return [root / name for name in names if (root / name).is_file()]
+
+
+def read_declared(files: list[Path], tool: str) -> tuple[Path, Version] | None:
+    """First declaration of `tool` across the candidate build files."""
+    for path in files:
+        try:
+            text = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        for pattern in (_PLUGIN_BLOCK[tool], _LEGACY[tool]):
+            match = pattern.search(text)
+            if match:
+                version = parse_version(match.group(2))
+                if version is not None:
+                    return path, version
+    return None
+
+
+def set_declared(path: Path, tool: str, version: Version) -> bool:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return False
+    total = 0
+    for pattern in (_PLUGIN_BLOCK[tool], _LEGACY[tool]):
+        text, count = pattern.subn(lambda m: f"{m.group(1)}{_render(version)}{m.group(3)}", text)
+        total += count
+    if not total:
+        return False
+    path.write_text(text, encoding="utf-8")
+    return True
+
+
+def ensure_toolchain(
+    workspace: Path, flutter_root: Path, gradle_root: Path | None = None
+) -> list[str]:
+    """Raise Gradle, AGP and KGP to this Flutter SDK's floors. Returns log lines."""
+    messages = []
+    gradle = ensure_minimum(workspace, flutter_root, gradle_root)
+    if gradle:
+        messages.append(gradle)
+    files = toolchain_files(workspace, gradle_root)
+    if not files:
+        return messages
+    for tool in ("agp", "kgp"):
+        minimum = flutter_minimum(flutter_root, tool)
+        if minimum is None:
+            messages.append(
+                f"::warning::Could not read Flutter's minimum {_LABEL[tool]} version; leaving it alone"
+            )
+            continue
+        found = read_declared(files, tool)
+        if found is None:
+            # Plenty of valid projects inherit these from elsewhere; that is not
+            # something to fail a deploy over.
+            continue
+        path, current = found
+        if current >= minimum:
+            messages.append(
+                f"{_LABEL[tool]} {_render(current)} meets Flutter's minimum {_render(minimum)}"
+            )
+            continue
+        if not set_declared(path, tool, minimum):
+            messages.append(f"::warning::Failed to raise the {_LABEL[tool]} version in {path}")
+            continue
+        messages.append(
+            f"::warning::{_LABEL[tool]} {_render(current)} is below Flutter's minimum "
+            f"{_render(minimum)}; raised it to {_render(minimum)} in {path.name} for this build "
+            f"only. Commit the bump to make it permanent."
+        )
+    return messages

package/android-action/scripts/resolve_android.py

@@ -170,16 +170,16 @@ def main() -> None:
                 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.
+            # Flutter refuses to apply its Gradle plugin when the project's
+            # Gradle, AGP or Kotlin plugin is older than the SDK's floor, and CI
+            # tracks `stable`, so those floors rise without the app changing.
+            # Raise them 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")
+                print("::warning::Flutter SDK not found; skipping the build toolchain check")
             else:
-                message = gradle_wrapper.ensure_minimum(workspace, root)
-                if message:
+                for message in gradle_wrapper.ensure_toolchain(workspace, root):
                     print(message)
     except (ConfigError, KeyError, OSError) as exc:
         print(f"::error::{exc}")

package/android-action/scripts/test_gradle_wrapper.py

@@ -122,3 +122,140 @@ class WrapperFileTest(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+SETTINGS = """
+pluginManagement { includeBuild("../flutter/packages/flutter_tools/gradle") }
+plugins {
+    id "dev.flutter.flutter-plugin-loader" version "1.0.0"
+    id "com.android.application" version "8.9.1" apply false
+    id "org.jetbrains.kotlin.android" version "2.1.0" apply false
+}
+include ":app"
+"""
+
+LEGACY_BUILD = """
+buildscript {
+    ext.kotlin_version = '1.7.10'
+    dependencies { classpath 'com.android.tools.build:gradle:7.4.2' }
+}
+"""
+
+CHECKER_WITH_ALL_FLOORS = """
+    internal val errorGradleVersion: Version = Version(8, 14, 0)
+    internal val errorAGPVersion: AndroidPluginVersion = AndroidPluginVersion(8, 11, 1)
+    internal val errorKGPVersion: Version = Version(2, 0, 0)
+"""
+
+
+class ToolchainTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.workspace = Path(self.tmp.name)
+        android = self.workspace / "android"
+        android.mkdir()
+        (android / "settings.gradle").write_text(SETTINGS, encoding="utf-8")
+        properties = gw.wrapper_properties(self.workspace)
+        properties.parent.mkdir(parents=True)
+        properties.write_text(WRAPPER, encoding="utf-8")
+        self.settings = android / "settings.gradle"
+        self.flutter = self.workspace / "flutter"
+        checker = self.flutter / gw._CHECKER
+        checker.parent.mkdir(parents=True)
+        checker.write_text(CHECKER_WITH_ALL_FLOORS, encoding="utf-8")
+        self.addCleanup(self.tmp.cleanup)
+
+    def test_reads_each_floor_from_the_sdk(self):
+        self.assertEqual(gw.flutter_minimum(self.flutter, "gradle"), (8, 14, 0))
+        self.assertEqual(gw.flutter_minimum(self.flutter, "agp"), (8, 11, 1))
+        self.assertEqual(gw.flutter_minimum(self.flutter, "kgp"), (2, 0, 0))
+
+    def test_reads_the_plugins_block(self):
+        files = gw.toolchain_files(self.workspace)
+        self.assertEqual(gw.read_declared(files, "agp")[1], (8, 9, 1))
+        self.assertEqual(gw.read_declared(files, "kgp")[1], (2, 1, 0))
+
+    def test_raises_agp_but_leaves_a_compliant_kgp(self):
+        messages = gw.ensure_toolchain(self.workspace, self.flutter)
+        text = self.settings.read_text()
+        self.assertIn('"com.android.application" version "8.11.1"', text)
+        self.assertIn('"org.jetbrains.kotlin.android" version "2.1.0"', text)
+        self.assertTrue(any("Android Gradle Plugin 8.9.1 is below" in m for m in messages))
+        self.assertTrue(any("Kotlin Gradle Plugin 2.1.0 meets" in m for m in messages))
+
+    def test_raises_the_wrapper_in_the_same_pass(self):
+        gw.ensure_toolchain(self.workspace, self.flutter)
+        self.assertIn("gradle-8.14-all.zip", gw.wrapper_properties(self.workspace).read_text())
+
+    def test_handles_the_legacy_buildscript_form(self):
+        self.settings.unlink()
+        (self.workspace / "android" / "build.gradle").write_text(LEGACY_BUILD, encoding="utf-8")
+        gw.ensure_toolchain(self.workspace, self.flutter)
+        text = (self.workspace / "android" / "build.gradle").read_text()
+        self.assertIn("com.android.tools.build:gradle:8.11.1", text)
+        self.assertIn("ext.kotlin_version = '2.0.0'", text)
+
+    def test_a_project_declaring_neither_is_left_alone(self):
+        self.settings.write_text("include ':app'\n", encoding="utf-8")
+        messages = gw.ensure_toolchain(self.workspace, self.flutter)
+        self.assertFalse(any("Android Gradle Plugin" in m for m in messages))
+
+    def test_an_unreadable_sdk_warns_per_tool(self):
+        messages = gw.ensure_toolchain(self.workspace, self.workspace / "nope")
+        self.assertEqual(sum("::warning::" in m for m in messages), 3)
+
+
+SETTINGS_KTS = """
+plugins {
+    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
+    id("com.android.application") version "8.9.1" apply false
+    id("org.jetbrains.kotlin.android") version "2.1.0" apply false
+}
+include(":app")
+"""
+
+
+class KotlinDslTest(unittest.TestCase):
+    """The Kotlin DSL spells a plugin id `id("x") version "y"`, Groovy spells it
+    `id "x" version "y"`. A matcher written against only one silently no-ops on
+    the other — and a no-op here means shipping an app whose AGP is still below
+    Flutter's floor while the log claims it was raised."""
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.workspace = Path(self.tmp.name)
+        android = self.workspace / "android"
+        android.mkdir()
+        self.settings = android / "settings.gradle.kts"
+        self.settings.write_text(SETTINGS_KTS, encoding="utf-8")
+        properties = gw.wrapper_properties(self.workspace)
+        properties.parent.mkdir(parents=True)
+        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_WITH_ALL_FLOORS, encoding="utf-8")
+        self.addCleanup(self.tmp.cleanup)
+
+    def test_finds_settings_gradle_kts(self):
+        self.assertIn("settings.gradle.kts", [f.name for f in gw.toolchain_files(self.workspace)])
+
+    def test_reads_both_plugin_ids_from_the_kotlin_dsl(self):
+        files = gw.toolchain_files(self.workspace)
+        self.assertEqual(gw.read_declared(files, "agp")[1], (8, 9, 1))
+        self.assertEqual(gw.read_declared(files, "kgp")[1], (2, 1, 0))
+
+    def test_actually_rewrites_the_kotlin_dsl(self):
+        gw.ensure_toolchain(self.workspace, self.flutter)
+        text = self.settings.read_text()
+        self.assertIn('id("com.android.application") version "8.11.1"', text)
+        # Untouched: 2.1.0 already meets the 2.0.0 floor.
+        self.assertIn('id("org.jetbrains.kotlin.android") version "2.1.0"', text)
+        # The loader's own version must not be caught by the AGP matcher.
+        self.assertIn('id("dev.flutter.flutter-plugin-loader") version "1.0.0"', text)
+
+    def test_reports_the_raise_only_when_the_file_really_changed(self):
+        messages = gw.ensure_toolchain(self.workspace, self.flutter)
+        raised = [m for m in messages if "Android Gradle Plugin 8.9.1 is below" in m]
+        self.assertEqual(len(raised), 1)
+        self.assertIn("8.11.1", self.settings.read_text())

package/package.json

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