Make app builds work without build.yaml

supervisor/addons/build.py

@@ -19,7 +19,13 @@
     ATTR_SQUASH,
     ATTR_USERNAME,
     FILE_SUFFIX_CONFIGURATION,
-    META_ADDON,
+    LABEL_ARCH,
+    LABEL_DESCRIPTION,
+    LABEL_NAME,
+    LABEL_TYPE,
+    LABEL_URL,
+    LABEL_VERSION,
+    META_APP,
     SOCKET_DOCKER,
     CpuArch,
 )
@@ -48,20 +54,29 @@ def __init__(self, coresys: CoreSys, addon: AnyAddon) -> None:
         """Initialize Supervisor add-on builder."""
         self.coresys: CoreSys = coresys
         self.addon = addon
+        self._has_build_file: bool = False
 
         # Search for build file later in executor
         super().__init__(None, SCHEMA_BUILD_CONFIG)
 
+    @property
+    def has_build_file(self) -> bool:
+        """Return True if a build configuration file was found on disk."""
+        return self._has_build_file
+
     def _get_build_file(self) -> Path:
         """Get build file.
 
         Must be run in executor.
         """
         try:
-            return find_one_filetype(
+            result = find_one_filetype(
                 self.addon.path_location, "build", FILE_SUFFIX_CONFIGURATION
             )
+            self._has_build_file = True
+            return result
         except ConfigurationFileError:
+            self._has_build_file = False
             return self.addon.path_location / "build.json"
 
     async def read_data(self) -> None:
@@ -81,10 +96,12 @@ def arch(self) -> CpuArch:
         return self.sys_arch.match([self.addon.arch])
 
     @property
-    def base_image(self) -> str:
-        """Return base image for this add-on."""
+    def base_image(self) -> str | None:
+        """Return base image for this add-on, or None to use Dockerfile default."""
         if not self._data[ATTR_BUILD_FROM]:
-            return f"ghcr.io/home-assistant/{self.arch!s}-base:latest"
+            if self._has_build_file:
+                return "ghcr.io/home-assistant/base:latest"
+            return None
 
         if isinstance(self._data[ATTR_BUILD_FROM], str):
             return self._data[ATTR_BUILD_FROM]
@@ -144,43 +161,33 @@ def build_is_valid() -> bool:
                 system_arch_list=[arch.value for arch in self.sys_arch.supported],
             ) from None
 
-    def get_docker_config_json(self) -> str | None:
-        """Generate Docker config.json content with registry credentials for base image.
+    def _registry_key(self, registry: str) -> str:
+        """Return the Docker config.json key for a registry."""
+        if registry in (DOCKER_HUB, DOCKER_HUB_LEGACY):
+            return "https://index.docker.io/v1/"
+        return registry
 
-        Returns a JSON string with registry credentials for the base image's registry,
-        or None if no matching registry is configured.
+    def _registry_auth(self, registry: str) -> str:
+        """Return base64-encoded auth string for a registry."""
+        stored = self.sys_docker.config.registries[registry]
+        return base64.b64encode(
+            f"{stored[ATTR_USERNAME]}:{stored[ATTR_PASSWORD]}".encode()
+        ).decode()
 
-        Raises:
-            HassioArchNotFound: If the add-on is not supported on the current architecture.
+    def get_docker_config_json(self) -> str | None:
+        """Generate Docker config.json content with all configured registry credentials.
 
+        Returns a JSON string with registry credentials, or None if no registries
+        are configured.
         """
-        # Early return before accessing base_image to avoid unnecessary arch lookup
         if not self.sys_docker.config.registries:
             return None
 
-        registry = self.sys_docker.config.get_registry_for_image(self.base_image)
-        if not registry:
-            return None
-
-        stored = self.sys_docker.config.registries[registry]
-        username = stored[ATTR_USERNAME]
-        password = stored[ATTR_PASSWORD]
-
-        # Docker config.json uses base64-encoded "username:password" for auth
-        auth_string = base64.b64encode(f"{username}:{password}".encode()).decode()
-
-        # Use the actual registry URL for the key
-        # Docker Hub uses "https://index.docker.io/v1/" as the key
-        # Support both docker.io (official) and hub.docker.com (legacy)
-        registry_key = (
-            "https://index.docker.io/v1/"
-            if registry in (DOCKER_HUB, DOCKER_HUB_LEGACY)
-            else registry
-        )
-
-        config = {"auths": {registry_key: {"auth": auth_string}}}
-
-        return json.dumps(config)
+        auths = {
+            self._registry_key(registry): {"auth": self._registry_auth(registry)}
+            for registry in self.sys_docker.config.registries
+        }
+        return json.dumps({"auths": auths})
 
     def get_docker_args(
         self, version: AwesomeVersion, image_tag: str, docker_config_path: Path | None
@@ -203,27 +210,35 @@ def get_docker_args(
         ]
 
         labels = {
-            "io.hass.version": version,
-            "io.hass.arch": self.arch,
-            "io.hass.type": META_ADDON,
-            "io.hass.name": self._fix_label("name"),
-            "io.hass.description": self._fix_label("description"),
+            LABEL_VERSION: version,
+            LABEL_ARCH: self.arch,
+            LABEL_TYPE: META_APP,
             **self.additional_labels,
         }
 
+        # Set name only if non-empty, could have been set in Dockerfile
+        if name := self._fix_label("name"):
+            labels[LABEL_NAME] = name
+
+        # Set description only if non-empty, could have been set in Dockerfile
+        if description := self._fix_label("description"):
+            labels[LABEL_DESCRIPTION] = description
+
         if self.addon.url:
-            labels["io.hass.url"] = self.addon.url
+            labels[LABEL_URL] = self.addon.url
 
         for key, value in labels.items():
             build_cmd.extend(["--label", f"{key}={value}"])
 
         build_args = {
-            "BUILD_FROM": self.base_image,
             "BUILD_VERSION": version,
             "BUILD_ARCH": self.arch,
             **self.additional_args,
         }
 
+        if self.base_image is not None:
+            build_args["BUILD_FROM"] = self.base_image
+
         for key, value in build_args.items():
             build_cmd.extend(["--build-arg", f"{key}={value}"])
 

supervisor/const.py

@@ -65,11 +65,15 @@
 DNS_SUFFIX = "local.hass.io"
 
 LABEL_ARCH = "io.hass.arch"
+LABEL_DESCRIPTION = "io.hass.description"
 LABEL_MACHINE = "io.hass.machine"
+LABEL_NAME = "io.hass.name"
 LABEL_TYPE = "io.hass.type"
+LABEL_URL = "io.hass.url"
 LABEL_VERSION = "io.hass.version"
 
-META_ADDON = "addon"
+META_ADDON = "addon"  # legacy label for app
+META_APP = "app"
 META_HOMEASSISTANT = "homeassistant"
 META_SUPERVISOR = "supervisor"
 

supervisor/docker/addon.py

@@ -684,6 +684,13 @@ async def _build(self, version: AwesomeVersion, image: str | None = None) -> Non
         # Check if the build environment is valid, raises if not
         await build_env.is_valid()
 
+        if build_env.has_build_file:
+            _LOGGER.warning(
+                "App %s uses build.yaml which is deprecated. "
+                "Move build parameters into the Dockerfile directly.",
+                self.addon.slug,
+            )
+
         _LOGGER.info("Starting build for %s:%s", self.image, version)
         if build_env.squash:
             _LOGGER.warning(