build-dfu-tools: drop macos-13; alias darwin-x86_64 → darwin-arm64

GitHub deprecated macos-13 (Intel) runners; jobs targeting that label now
queue indefinitely and never get picked up. Apple Silicon Macs have been
Apple's only product since late 2023, and any remaining Intel Mac runs
the arm64 binary fine via Rosetta 2 (bundled with macOS).

Changes:
- Remove macos-13 row from the build matrix.
- Remove darwin-x86_64 entry from manifest.json's platforms map.
- Add a platform_aliases section: darwin-x86_64 → darwin-arm64. The
  fetcher honours these on miss, picking up the aliased platform's
  binary (and recording the actual platform we picked in ToolSpec.platform
  so diagnostics aren't lying).

Tests: 79 passing (+1 for the alias-fallback path).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: robkersey

.github/workflows/build-dfu-tools.yml

@@ -43,9 +43,9 @@ jobs:
           - runner: macos-14         # Apple Silicon
             platform_tag: darwin-arm64
             artifact_name: bert-dfu-darwin-arm64
-          - runner: macos-13         # Intel
-            platform_tag: darwin-x86_64
-            artifact_name: bert-dfu-darwin-x86_64
+          # macos-13 (Intel) runners deprecated by GitHub; queue indefinitely.
+          # Intel Macs run the arm64 binary fine via Rosetta 2 (bundled with
+          # macOS). The Bert runtime handles the platform-tag fallback.
           - runner: ubuntu-22.04
             platform_tag: linux-x86_64
             artifact_name: bert-dfu-linux-x86_64

src/bert/adapters/firmware_fetch.py

@@ -146,7 +146,13 @@ def host_platform_tag() -> str:
 
 
 def load_tool_manifest() -> dict[str, ToolSpec]:
-    """Load all helper-binary specs for the current host platform."""
+    """Load all helper-binary specs for the current host platform.
+
+    Honours per-tool ``platform_aliases``: if the host's tag isn't in the
+    ``platforms`` map, look it up in ``platform_aliases`` to find a
+    compatible alternative (e.g. Intel Macs falling back to ``darwin-arm64``
+    binaries that run under Rosetta 2).
+    """
 
     raw = _read_manifest()
     out: dict[str, ToolSpec] = {}
@@ -155,7 +161,18 @@ def load_tool_manifest() -> dict[str, ToolSpec]:
         if tool_name == "comment" or not isinstance(entry, dict):
             continue
         platforms = entry.get("platforms") or {}
-        plat_entry = platforms.get(host_tag)
+        aliases = entry.get("platform_aliases") or {}
+        # Resolve host_tag → effective platform via alias chain (max one hop).
+        effective_tag = host_tag
+        if effective_tag not in platforms and effective_tag in aliases:
+            aliased = aliases[effective_tag]
+            if isinstance(aliased, str) and aliased in platforms:
+                log.info(
+                    "platform %s: falling back to %s binary (alias)",
+                    host_tag, aliased,
+                )
+                effective_tag = aliased
+        plat_entry = platforms.get(effective_tag)
         if plat_entry is None:
             log.debug("no %s binary for platform %s", tool_name, host_tag)
             continue
@@ -169,7 +186,7 @@ def load_tool_manifest() -> dict[str, ToolSpec]:
             continue
         out[tool_name] = ToolSpec(
             name=tool_name,
-            platform=host_tag,
+            platform=effective_tag,  # actual binary's native platform; see alias resolution above
             filename=filename,
             url=url,
             sha256=sha,

src/bert/firmware/manifest.json

@@ -31,11 +31,6 @@
           "sha256": "0000000000000000000000000000000000000000000000000000000000000000",
           "size_bytes": 0
         },
-        "darwin-x86_64": {
-          "filename": "bert-dfu-darwin-x86_64",
-          "sha256": "0000000000000000000000000000000000000000000000000000000000000000",
-          "size_bytes": 0
-        },
         "linux-x86_64": {
           "filename": "bert-dfu-linux-x86_64",
           "sha256": "0000000000000000000000000000000000000000000000000000000000000000",
@@ -46,6 +41,10 @@
           "sha256": "0000000000000000000000000000000000000000000000000000000000000000",
           "size_bytes": 0
         }
+      },
+      "platform_aliases": {
+        "_comment": "Map host platforms we don't ship binaries for to ones that work via emulation. macOS Intel runs darwin-arm64 binaries via Rosetta 2.",
+        "darwin-x86_64": "darwin-arm64"
       }
     }
   }

tests/unit/test_firmware_fetch.py

@@ -214,6 +214,19 @@ def test_load_tool_manifest_skips_unknown_platform(
     assert tools == {}
 
 
+def test_load_tool_manifest_resolves_platform_alias(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Intel Macs (darwin-x86_64) should pick up the darwin-arm64 binary
+    via the manifest's platform_aliases. Rosetta 2 handles the rest."""
+    monkeypatch.setattr(firmware_fetch, "host_platform_tag", lambda: "darwin-x86_64")
+    tools = firmware_fetch.load_tool_manifest()
+    if "bert-dfu" in tools:
+        # The shipped manifest aliases darwin-x86_64 → darwin-arm64.
+        assert tools["bert-dfu"].platform == "darwin-arm64"
+        assert tools["bert-dfu"].filename == "bert-dfu-darwin-arm64"
+
+
 @pytest.fixture
 def isolated_tool_cache(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
     monkeypatch.setenv("BERT_TOOLS_CACHE", str(tmp_path / "tcache"))