Add defined error for when build fails

Fix stats test and add more for known errors
Fix docker ratelimit exception and tests
2025-11-27 11:38:07 +00:00 · 2025-11-21 19:11:26 +00:00 · 2025-11-21 18:40:55 +00:00 · 2025-11-21 18:40:54 +00:00 · 2025-11-21 18:40:53 +00:00 · 2025-11-21 18:40:52 +00:00
54 changed files with 1258 additions and 930 deletions
--- a/.github/workflows/builder.yml
+++ b/.github/workflows/builder.yml
@@ -34,9 +34,6 @@ on:

 env:
  DEFAULT_PYTHON: "3.13"
-  COSIGN_VERSION: "v2.5.3"
-  CRANE_VERSION: "v0.20.7"
-  CRANE_SHA256: "8ef3564d264e6b5ca93f7b7f5652704c4dd29d33935aff6947dd5adefd05953e"
  BUILD_NAME: supervisor
  BUILD_TYPE: supervisor

@@ -110,7 +107,7 @@ jobs:
      # home-assistant/wheels doesn't support sha pinning
      - name: Build wheels
        if: needs.init.outputs.requirements == 'true'
-        uses: home-assistant/wheels@2025.11.0
+        uses: home-assistant/wheels@2025.10.0
        with:
          abi: cp313
          tag: musllinux_1_2
@@ -129,7 +126,7 @@ jobs:

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
        if: needs.init.outputs.publish == 'true'
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}

@@ -137,7 +134,7 @@ jobs:
        if: needs.init.outputs.publish == 'true'
        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
        with:
-          cosign-release: ${{ env.COSIGN_VERSION }}
+          cosign-release: "v2.5.3"

      - name: Install dirhash and calc hash
        if: needs.init.outputs.publish == 'true'
@@ -176,7 +173,7 @@ jobs:

  version:
    name: Update version
-    needs: ["init", "run_supervisor", "retag_deprecated"]
+    needs: ["init", "run_supervisor"]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout the repository
@@ -355,50 +352,3 @@ jobs:
      - name: Get supervisor logs on failiure
        if: ${{ cancelled() || failure() }}
        run: docker logs hassio_supervisor
-
-  retag_deprecated:
-    needs: ["build", "init"]
-    name: Re-tag deprecated ${{ matrix.arch }} images
-    if: needs.init.outputs.publish == 'true'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-      packages: write
-    strategy:
-      matrix:
-        arch: ["armhf", "armv7", "i386"]
-    env:
-      # Last available release for deprecated architectures
-      FROZEN_VERSION: "2025.11.5"
-    steps:
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install Cosign
-        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
-        with:
-          cosign-release: ${{ env.COSIGN_VERSION }}
-
-      - name: Install crane
-        run: |
-          curl -sLO https://github.com/google/go-containerregistry/releases/download/${{ env.CRANE_VERSION }}/go-containerregistry_Linux_x86_64.tar.gz
-          echo "${{ env.CRANE_SHA256 }}  go-containerregistry_Linux_x86_64.tar.gz" | sha256sum -c -
-          tar xzf go-containerregistry_Linux_x86_64.tar.gz crane
-          sudo mv crane /usr/local/bin/
-
-      - name: Re-tag deprecated image with updated version label
-        run: |
-          crane auth login ghcr.io -u ${{ github.repository_owner }} -p ${{ secrets.GITHUB_TOKEN }}
-          crane mutate \
-            --label io.hass.version=${{ needs.init.outputs.version }} \
-            --tag ghcr.io/home-assistant/${{ matrix.arch }}-hassio-supervisor:${{ needs.init.outputs.version }} \
-            ghcr.io/home-assistant/${{ matrix.arch }}-hassio-supervisor:${{ env.FROZEN_VERSION }}
-
-      - name: Sign image with Cosign
-        run: |
-          cosign sign --yes ghcr.io/home-assistant/${{ matrix.arch }}-hassio-supervisor:${{ needs.init.outputs.version }}
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -29,7 +29,7 @@ jobs:
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python
        id: python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
      - name: Restore Python virtual environment
@@ -70,7 +70,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
@@ -113,7 +113,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
@@ -171,7 +171,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
@@ -215,7 +215,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
@@ -259,7 +259,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
@@ -295,7 +295,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
@@ -341,7 +341,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
@@ -400,7 +400,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        id: python
        with:
          python-version: ${{ needs.prepare.outputs.python-version }}
--- a/.github/workflows/update_frontend.yml
+++ b/.github/workflows/update_frontend.yml
@@ -68,7 +68,7 @@ jobs:
        run: |
          rm -f supervisor/api/panel/home_assistant_frontend_supervisor-*.tar.gz
      - name: Create PR
-        uses: peter-evans/create-pull-request@84ae59a2cdc2258d6fa0732dd66352dddae2a412 # v7.0.9
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b9829c1cb33d45e # v7.0.8
        with:
          commit-message: "Update frontend to version ${{ needs.check-version.outputs.latest_version }}"
          branch: autoupdate-frontend
--- a/build.yaml
+++ b/build.yaml
@@ -1,7 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-hassio-supervisor
 build_from:
  aarch64: ghcr.io/home-assistant/aarch64-base-python:3.13-alpine3.22-2025.11.1
+  armhf: ghcr.io/home-assistant/armhf-base-python:3.13-alpine3.22-2025.11.1
+  armv7: ghcr.io/home-assistant/armv7-base-python:3.13-alpine3.22-2025.11.1
  amd64: ghcr.io/home-assistant/amd64-base-python:3.13-alpine3.22-2025.11.1
+  i386: ghcr.io/home-assistant/i386-base-python:3.13-alpine3.22-2025.11.1
 cosign:
  base_identity: https://github.com/home-assistant/docker-base/.*
  identity: https://github.com/home-assistant/supervisor/.*
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,7 +4,7 @@ aiohttp==3.13.2
 atomicwrites-homeassistant==1.4.1
 attrs==25.4.0
 awesomeversion==25.8.0
-backports.zstd==1.1.0
+backports.zstd==1.0.0
 blockbuster==1.5.25
 brotli==1.2.0
 ciso8601==2.3.3
@@ -25,8 +25,8 @@ pyudev==0.24.4
 PyYAML==6.0.3
 requests==2.32.5
 securetar==2025.2.1
-sentry-sdk==2.46.0
+sentry-sdk==2.45.0
 setuptools==80.9.0
 voluptuous==0.15.2
-dbus-fast==3.1.2
+dbus-fast==2.45.1
 zlib-fast==0.2.1
--- a/requirements_tests.txt
+++ b/requirements_tests.txt
@@ -1,16 +1,16 @@
 astroid==4.0.2
 coverage==7.12.0
 mypy==1.18.2
-pre-commit==4.5.0
+pre-commit==4.4.0
 pylint==4.0.3
 pytest-aiohttp==1.1.0
 pytest-asyncio==1.3.0
 pytest-cov==7.0.0
 pytest-timeout==2.4.0
 pytest==9.0.1
-ruff==0.14.6
-time-machine==3.1.0
-types-docker==7.1.0.20251125
+ruff==0.14.5
+time-machine==3.0.0
+types-docker==7.1.0.20251009
 types-pyyaml==6.0.12.20250915
 types-requests==2.32.4.20250913
 urllib3==2.5.0
--- a/supervisor/addons/addon.py
+++ b/supervisor/addons/addon.py
@@ -66,13 +66,22 @@ from ..docker.const import ContainerState
 from ..docker.monitor import DockerContainerStateEvent
 from ..docker.stats import DockerStats
 from ..exceptions import (
-    AddonConfigurationError,
+    AddonBackupMetadataInvalidError,
+    AddonBuildFailedUnknownError,
+    AddonConfigurationInvalidError,
+    AddonNotRunningError,
    AddonNotSupportedError,
+    AddonNotSupportedWriteStdinError,
+    AddonPrePostBackupCommandReturnedError,
    AddonsError,
    AddonsJobError,
+    AddonUnknownError,
+    BackupRestoreUnknownError,
    ConfigurationFileError,
+    DockerBuildError,
    DockerError,
    HostAppArmorError,
+    StoreAddonNotFoundError,
 )
 from ..hardware.data import Device
 from ..homeassistant.const import WSEvent
@@ -235,7 +244,7 @@ class Addon(AddonModel):
            await self.instance.check_image(self.version, default_image, self.arch)
        except DockerError:
            _LOGGER.info("No %s addon Docker image %s found", self.slug, self.image)
-            with suppress(DockerError):
+            with suppress(DockerError, AddonNotSupportedError):
                await self.instance.install(self.version, default_image, arch=self.arch)

        self.persist[ATTR_IMAGE] = default_image
@@ -718,18 +727,16 @@ class Addon(AddonModel):
            options = self.schema.validate(self.options)
            await self.sys_run_in_executor(write_json_file, self.path_options, options)
        except vol.Invalid as ex:
-            _LOGGER.error(
-                "Add-on %s has invalid options: %s",
-                self.slug,
-                humanize_error(self.options, ex),
-            )
-        except ConfigurationFileError:
+            raise AddonConfigurationInvalidError(
+                _LOGGER.error,
+                addon=self.slug,
+                validation_error=humanize_error(self.options, ex),
+            ) from None
+        except ConfigurationFileError as err:
            _LOGGER.error("Add-on %s can't write options", self.slug)
-        else:
-            _LOGGER.debug("Add-on %s write options: %s", self.slug, options)
-            return
+            raise AddonUnknownError(addon=self.slug) from err

-        raise AddonConfigurationError()
+        _LOGGER.debug("Add-on %s write options: %s", self.slug, options)

    @Job(
        name="addon_unload",
@@ -772,7 +779,7 @@ class Addon(AddonModel):
    async def install(self) -> None:
        """Install and setup this addon."""
        if not self.addon_store:
-            raise AddonsError("Missing from store, cannot install!")
+            raise StoreAddonNotFoundError(addon=self.slug)

        await self.sys_addons.data.install(self.addon_store)

@@ -793,9 +800,17 @@ class Addon(AddonModel):
            await self.instance.install(
                self.latest_version, self.addon_store.image, arch=self.arch
            )
-        except DockerError as err:
+        except AddonsError:
            await self.sys_addons.data.uninstall(self)
-            raise AddonsError() from err
+            raise
+        except DockerBuildError as err:
+            _LOGGER.error("Could not build image for addon %s: %s", self.slug, err)
+            await self.sys_addons.data.uninstall(self)
+            raise AddonBuildFailedUnknownError(addon=self.slug) from err
+        except DockerError as err:
+            _LOGGER.error("Could not pull image to update addon %s: %s", self.slug, err)
+            await self.sys_addons.data.uninstall(self)
+            raise AddonUnknownError(addon=self.slug) from err

        # Finish initialization and set up listeners
        await self.load()
@@ -819,7 +834,8 @@ class Addon(AddonModel):
        try:
            await self.instance.remove(remove_image=remove_image)
        except DockerError as err:
-            raise AddonsError() from err
+            _LOGGER.error("Could not remove image for addon %s: %s", self.slug, err)
+            raise AddonUnknownError(addon=self.slug) from err

        self.state = AddonState.UNKNOWN

@@ -884,7 +900,7 @@ class Addon(AddonModel):
        if it was running. Else nothing is returned.
        """
        if not self.addon_store:
-            raise AddonsError("Missing from store, cannot update!")
+            raise StoreAddonNotFoundError(addon=self.slug)

        old_image = self.image
        # Cache data to prevent races with other updates to global
@@ -892,8 +908,12 @@ class Addon(AddonModel):

        try:
            await self.instance.update(store.version, store.image, arch=self.arch)
+        except DockerBuildError as err:
+            _LOGGER.error("Could not build image for addon %s: %s", self.slug, err)
+            raise AddonBuildFailedUnknownError(addon=self.slug) from err
        except DockerError as err:
-            raise AddonsError() from err
+            _LOGGER.error("Could not pull image to update addon %s: %s", self.slug, err)
+            raise AddonUnknownError(addon=self.slug) from err

        # Stop the addon if running
        if (last_state := self.state) in {AddonState.STARTED, AddonState.STARTUP}:
@@ -935,12 +955,23 @@ class Addon(AddonModel):
        """
        last_state: AddonState = self.state
        try:
-            # remove docker container but not addon config
+            # remove docker container and image but not addon config
            try:
                await self.instance.remove()
-                await self.instance.install(self.version)
            except DockerError as err:
-                raise AddonsError() from err
+                _LOGGER.error("Could not remove image for addon %s: %s", self.slug, err)
+                raise AddonUnknownError(addon=self.slug) from err
+
+            try:
+                await self.instance.install(self.version)
+            except DockerBuildError as err:
+                _LOGGER.error("Could not build image for addon %s: %s", self.slug, err)
+                raise AddonBuildFailedUnknownError(addon=self.slug) from err
+            except DockerError as err:
+                _LOGGER.error(
+                    "Could not pull image to update addon %s: %s", self.slug, err
+                )
+                raise AddonUnknownError(addon=self.slug) from err

            if self.addon_store:
                await self.sys_addons.data.update(self.addon_store)
@@ -1111,8 +1142,9 @@ class Addon(AddonModel):
        try:
            await self.instance.run()
        except DockerError as err:
+            _LOGGER.error("Could not start container for addon %s: %s", self.slug, err)
            self.state = AddonState.ERROR
-            raise AddonsError() from err
+            raise AddonUnknownError(addon=self.slug) from err

        return self.sys_create_task(self._wait_for_startup())

@@ -1127,8 +1159,9 @@ class Addon(AddonModel):
        try:
            await self.instance.stop()
        except DockerError as err:
+            _LOGGER.error("Could not stop container for addon %s: %s", self.slug, err)
            self.state = AddonState.ERROR
-            raise AddonsError() from err
+            raise AddonUnknownError(addon=self.slug) from err

    @Job(
        name="addon_restart",
@@ -1161,9 +1194,15 @@ class Addon(AddonModel):
    async def stats(self) -> DockerStats:
        """Return stats of container."""
        try:
+            if not await self.is_running():
+                raise AddonNotRunningError(_LOGGER.warning, addon=self.slug)
+
            return await self.instance.stats()
        except DockerError as err:
-            raise AddonsError() from err
+            _LOGGER.error(
+                "Could not get stats of container for addon %s: %s", self.slug, err
+            )
+            raise AddonUnknownError(addon=self.slug) from err

    @Job(
        name="addon_write_stdin",
@@ -1173,14 +1212,18 @@ class Addon(AddonModel):
    async def write_stdin(self, data) -> None:
        """Write data to add-on stdin."""
        if not self.with_stdin:
-            raise AddonNotSupportedError(
-                f"Add-on {self.slug} does not support writing to stdin!", _LOGGER.error
-            )
+            raise AddonNotSupportedWriteStdinError(_LOGGER.error, addon=self.slug)

        try:
-            return await self.instance.write_stdin(data)
+            if not await self.is_running():
+                raise AddonNotRunningError(_LOGGER.warning, addon=self.slug)
+
+            await self.instance.write_stdin(data)
        except DockerError as err:
-            raise AddonsError() from err
+            _LOGGER.error(
+                "Could not write stdin to container for addon %s: %s", self.slug, err
+            )
+            raise AddonUnknownError(addon=self.slug) from err

    async def _backup_command(self, command: str) -> None:
        try:
@@ -1189,15 +1232,14 @@ class Addon(AddonModel):
                _LOGGER.debug(
                    "Pre-/Post backup command failed with: %s", command_return.output
                )
-                raise AddonsError(
-                    f"Pre-/Post backup command returned error code: {command_return.exit_code}",
-                    _LOGGER.error,
+                raise AddonPrePostBackupCommandReturnedError(
+                    _LOGGER.error, addon=self.slug, exit_code=command_return.exit_code
                )
        except DockerError as err:
-            raise AddonsError(
-                f"Failed running pre-/post backup command {command}: {str(err)}",
-                _LOGGER.error,
-            ) from err
+            _LOGGER.error(
+                "Failed running pre-/post backup command %s: %s", command, err
+            )
+            raise AddonUnknownError(addon=self.slug) from err

    @Job(
        name="addon_begin_backup",
@@ -1286,15 +1328,14 @@ class Addon(AddonModel):
                    try:
                        self.instance.export_image(temp_path.joinpath("image.tar"))
                    except DockerError as err:
-                        raise AddonsError() from err
+                        raise BackupRestoreUnknownError() from err

                # Store local configs/state
                try:
                    write_json_file(temp_path.joinpath("addon.json"), metadata)
                except ConfigurationFileError as err:
-                    raise AddonsError(
-                        f"Can't save meta for {self.slug}", _LOGGER.error
-                    ) from err
+                    _LOGGER.error("Can't save meta for %s: %s", self.slug, err)
+                    raise BackupRestoreUnknownError() from err

                # Store AppArmor Profile
                if apparmor_profile:
@@ -1304,9 +1345,7 @@ class Addon(AddonModel):
                            apparmor_profile, profile_backup_file
                        )
                    except HostAppArmorError as err:
-                        raise AddonsError(
-                            "Can't backup AppArmor profile", _LOGGER.error
-                        ) from err
+                        raise BackupRestoreUnknownError() from err

                # Write tarfile
                with tar_file as backup:
@@ -1360,7 +1399,8 @@ class Addon(AddonModel):
            )
            _LOGGER.info("Finish backup for addon %s", self.slug)
        except (tarfile.TarError, OSError, AddFileError) as err:
-            raise AddonsError(f"Can't write tarfile: {err}", _LOGGER.error) from err
+            _LOGGER.error("Can't write backup tarfile for addon %s: %s", self.slug, err)
+            raise BackupRestoreUnknownError() from err
        finally:
            if was_running:
                wait_for_start = await self.end_backup()
@@ -1402,28 +1442,24 @@ class Addon(AddonModel):
        try:
            tmp, data = await self.sys_run_in_executor(_extract_tarfile)
        except tarfile.TarError as err:
-            raise AddonsError(
-                f"Can't read tarfile {tar_file}: {err}", _LOGGER.error
-            ) from err
+            _LOGGER.error("Can't extract backup tarfile for %s: %s", self.slug, err)
+            raise BackupRestoreUnknownError() from err
        except ConfigurationFileError as err:
-            raise AddonsError() from err
+            raise AddonUnknownError(addon=self.slug) from err

        try:
            # Validate
            try:
                data = SCHEMA_ADDON_BACKUP(data)
            except vol.Invalid as err:
-                raise AddonsError(
-                    f"Can't validate {self.slug}, backup data: {humanize_error(data, err)}",
+                raise AddonBackupMetadataInvalidError(
                    _LOGGER.error,
+                    addon=self.slug,
+                    validation_error=humanize_error(data, err),
                ) from err

-            # If available
-            if not self._available(data[ATTR_SYSTEM]):
-                raise AddonNotSupportedError(
-                    f"Add-on {self.slug} is not available for this platform",
-                    _LOGGER.error,
-                )
+            # Validate availability. Raises if not
+            self._validate_availability(data[ATTR_SYSTEM], logger=_LOGGER.error)

            # Restore local add-on information
            _LOGGER.info("Restore config for addon %s", self.slug)
@@ -1482,9 +1518,10 @@ class Addon(AddonModel):
                try:
                    await self.sys_run_in_executor(_restore_data)
                except shutil.Error as err:
-                    raise AddonsError(
-                        f"Can't restore origin data: {err}", _LOGGER.error
-                    ) from err
+                    _LOGGER.error(
+                        "Can't restore origin data for %s: %s", self.slug, err
+                    )
+                    raise BackupRestoreUnknownError() from err

                # Restore AppArmor
                profile_file = Path(tmp.name, "apparmor.txt")
@@ -1495,10 +1532,11 @@ class Addon(AddonModel):
                        )
                    except HostAppArmorError as err:
                        _LOGGER.error(
-                            "Can't restore AppArmor profile for add-on %s",
+                            "Can't restore AppArmor profile for add-on %s: %s",
                            self.slug,
+                            err,
                        )
-                        raise AddonsError() from err
+                        raise BackupRestoreUnknownError() from err

            finally:
                # Is add-on loaded
--- a/supervisor/addons/build.py
+++ b/supervisor/addons/build.py
@@ -3,6 +3,7 @@
 from __future__ import annotations

 from functools import cached_property
+import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any

@@ -19,13 +20,20 @@ from ..const import (
 )
 from ..coresys import CoreSys, CoreSysAttributes
 from ..docker.interface import MAP_ARCH
-from ..exceptions import ConfigurationFileError, HassioArchNotFound
+from ..exceptions import (
+    AddonBuildArchitectureNotSupportedError,
+    AddonBuildDockerfileMissingError,
+    ConfigurationFileError,
+    HassioArchNotFound,
+)
 from ..utils.common import FileConfiguration, find_one_filetype
 from .validate import SCHEMA_BUILD_CONFIG

 if TYPE_CHECKING:
    from .manager import AnyAddon

+_LOGGER: logging.Logger = logging.getLogger(__name__)
+

 class AddonBuild(FileConfiguration, CoreSysAttributes):
    """Handle build options for add-ons."""
@@ -106,7 +114,7 @@ class AddonBuild(FileConfiguration, CoreSysAttributes):
            return self.addon.path_location.joinpath(f"Dockerfile.{self.arch}")
        return self.addon.path_location.joinpath("Dockerfile")

-    async def is_valid(self) -> bool:
+    async def is_valid(self) -> None:
        """Return true if the build env is valid."""

        def build_is_valid() -> bool:
@@ -118,9 +126,17 @@ class AddonBuild(FileConfiguration, CoreSysAttributes):
            )

        try:
-            return await self.sys_run_in_executor(build_is_valid)
+            if not await self.sys_run_in_executor(build_is_valid):
+                raise AddonBuildDockerfileMissingError(
+                    _LOGGER.error, addon=self.addon.slug
+                )
        except HassioArchNotFound:
-            return False
+            raise AddonBuildArchitectureNotSupportedError(
+                _LOGGER.error,
+                addon=self.addon.slug,
+                addon_arch_list=self.addon.supported_arch,
+                system_arch_list=self.sys_arch.supported,
+            ) from None

    def get_docker_args(
        self, version: AwesomeVersion, image_tag: str
--- a/supervisor/api/addons.py
+++ b/supervisor/api/addons.py
@@ -100,6 +100,9 @@ from ..const import (
 from ..coresys import CoreSysAttributes
 from ..docker.stats import DockerStats
 from ..exceptions import (
+    AddonBootConfigCannotChangeError,
+    AddonConfigurationInvalidError,
+    AddonNotSupportedWriteStdinError,
    APIAddonNotInstalled,
    APIError,
    APIForbidden,
@@ -125,6 +128,7 @@ SCHEMA_OPTIONS = vol.Schema(
        vol.Optional(ATTR_AUDIO_INPUT): vol.Maybe(str),
        vol.Optional(ATTR_INGRESS_PANEL): vol.Boolean(),
        vol.Optional(ATTR_WATCHDOG): vol.Boolean(),
+        vol.Optional(ATTR_OPTIONS): vol.Maybe(dict),
    }
 )

@@ -300,19 +304,20 @@ class APIAddons(CoreSysAttributes):
        # Update secrets for validation
        await self.sys_homeassistant.secrets.reload()

-        # Extend schema with add-on specific validation
-        addon_schema = SCHEMA_OPTIONS.extend(
-            {vol.Optional(ATTR_OPTIONS): vol.Maybe(addon.schema)}
-        )
-
        # Validate/Process Body
-        body = await api_validate(addon_schema, request)
+        body = await api_validate(SCHEMA_OPTIONS, request)
        if ATTR_OPTIONS in body:
-            addon.options = body[ATTR_OPTIONS]
+            try:
+                addon.options = addon.schema(body[ATTR_OPTIONS])
+            except vol.Invalid as ex:
+                raise AddonConfigurationInvalidError(
+                    addon=addon.slug,
+                    validation_error=humanize_error(body[ATTR_OPTIONS], ex),
+                ) from None
        if ATTR_BOOT in body:
            if addon.boot_config == AddonBootConfig.MANUAL_ONLY:
-                raise APIError(
-                    f"Addon {addon.slug} boot option is set to {addon.boot_config} so it cannot be changed"
+                raise AddonBootConfigCannotChangeError(
+                    addon=addon.slug, boot_config=addon.boot_config.value
                )
            addon.boot = body[ATTR_BOOT]
        if ATTR_AUTO_UPDATE in body:
@@ -476,7 +481,7 @@ class APIAddons(CoreSysAttributes):
        """Write to stdin of add-on."""
        addon = self.get_addon_for_request(request)
        if not addon.with_stdin:
-            raise APIError(f"STDIN not supported the {addon.slug} add-on")
+            raise AddonNotSupportedWriteStdinError(_LOGGER.error, addon=addon.slug)

        data = await request.read()
        await asyncio.shield(addon.write_stdin(data))
--- a/supervisor/api/auth.py
+++ b/supervisor/api/auth.py
@@ -15,7 +15,7 @@ import voluptuous as vol
 from ..addons.addon import Addon
 from ..const import ATTR_NAME, ATTR_PASSWORD, ATTR_USERNAME, REQUEST_FROM
 from ..coresys import CoreSysAttributes
-from ..exceptions import APIForbidden
+from ..exceptions import APIForbidden, AuthInvalidNonStringValueError
 from .const import (
    ATTR_GROUP_IDS,
    ATTR_IS_ACTIVE,
@@ -69,7 +69,9 @@ class APIAuth(CoreSysAttributes):
        try:
            _ = username.encode and password.encode  # type: ignore
        except AttributeError:
-            raise HTTPUnauthorized(headers=REALM_HEADER) from None
+            raise AuthInvalidNonStringValueError(
+                _LOGGER.error, headers=REALM_HEADER
+            ) from None

        return self.sys_auth.check_login(
            addon, cast(str, username), cast(str, password)
--- a/supervisor/api/host.py
+++ b/supervisor/api/host.py
@@ -343,14 +343,10 @@ class APIHost(CoreSysAttributes):

        disk = self.sys_hardware.disk

-        total, _, free = await self.sys_run_in_executor(
+        total, used, _ = await self.sys_run_in_executor(
            disk.disk_usage, self.sys_config.path_supervisor
        )

-        # Calculate used by subtracting free makes sure we include reserved space
-        # in used space reporting.
-        used = total - free
-
        known_paths = await self.sys_run_in_executor(
            disk.get_dir_sizes,
            {
--- a/supervisor/api/store.py
+++ b/supervisor/api/store.py
@@ -53,7 +53,7 @@ from ..const import (
    REQUEST_FROM,
 )
 from ..coresys import CoreSysAttributes
-from ..exceptions import APIError, APIForbidden, APINotFound
+from ..exceptions import APIError, APIForbidden, APINotFound, StoreAddonNotFoundError
 from ..store.addon import AddonStore
 from ..store.repository import Repository
 from ..store.validate import validate_repository
@@ -104,7 +104,7 @@ class APIStore(CoreSysAttributes):
        addon_slug: str = request.match_info["addon"]

        if not (addon := self.sys_addons.get(addon_slug)):
-            raise APINotFound(f"Addon {addon_slug} does not exist")
+            raise StoreAddonNotFoundError(addon=addon_slug)

        if installed and not addon.is_installed:
            raise APIError(f"Addon {addon_slug} is not installed")
@@ -112,7 +112,7 @@ class APIStore(CoreSysAttributes):
        if not installed and addon.is_installed:
            addon = cast(Addon, addon)
            if not addon.addon_store:
-                raise APINotFound(f"Addon {addon_slug} does not exist in the store")
+                raise StoreAddonNotFoundError(addon=addon_slug)
            return addon.addon_store

        return addon
--- a/supervisor/api/utils.py
+++ b/supervisor/api/utils.py
@@ -1,7 +1,7 @@
 """Init file for Supervisor util for RESTful API."""

 import asyncio
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 import json
 from typing import Any, cast

@@ -26,7 +26,7 @@ from ..const import (
    RESULT_OK,
 )
 from ..coresys import CoreSys, CoreSysAttributes
-from ..exceptions import APIError, BackupFileNotFoundError, DockerAPIError, HassioError
+from ..exceptions import APIError, DockerAPIError, HassioError
 from ..jobs import JobSchedulerOptions, SupervisorJob
 from ..utils import check_exception_chain, get_message_from_exception_chain
 from ..utils.json import json_dumps, json_loads as json_loads_util
@@ -63,14 +63,16 @@ def json_loads(data: Any) -> dict[str, Any]:
 def api_process(method):
    """Wrap function with true/false calls to rest api."""

-    async def wrap_api(*args, **kwargs) -> web.Response | web.StreamResponse:
+    async def wrap_api(
+        api: CoreSysAttributes, *args, **kwargs
+    ) -> web.Response | web.StreamResponse:
        """Return API information."""
        try:
-            answer = await method(*args, **kwargs)
-        except BackupFileNotFoundError as err:
-            return api_return_error(err, status=404)
+            answer = await method(api, *args, **kwargs)
        except APIError as err:
-            return api_return_error(err, status=err.status, job_id=err.job_id)
+            return api_return_error(
+                err, status=err.status, job_id=err.job_id, headers=err.headers
+            )
        except HassioError as err:
            return api_return_error(err)

@@ -107,10 +109,12 @@ def api_process_raw(content, *, error_type=None):
    def wrap_method(method):
        """Wrap function with raw output to rest api."""

-        async def wrap_api(*args, **kwargs) -> web.Response | web.StreamResponse:
+        async def wrap_api(
+            api: CoreSysAttributes, *args, **kwargs
+        ) -> web.Response | web.StreamResponse:
            """Return api information."""
            try:
-                msg_data = await method(*args, **kwargs)
+                msg_data = await method(api, *args, **kwargs)
            except APIError as err:
                return api_return_error(
                    err,
@@ -139,6 +143,7 @@ def api_return_error(
    error_type: str | None = None,
    status: int = 400,
    *,
+    headers: Mapping[str, str] | None = None,
    job_id: str | None = None,
 ) -> web.Response:
    """Return an API error message."""
@@ -151,10 +156,15 @@ def api_return_error(

    match error_type:
        case const.CONTENT_TYPE_TEXT:
-            return web.Response(body=message, content_type=error_type, status=status)
+            return web.Response(
+                body=message, content_type=error_type, status=status, headers=headers
+            )
        case const.CONTENT_TYPE_BINARY:
            return web.Response(
-                body=message.encode(), content_type=error_type, status=status
+                body=message.encode(),
+                content_type=error_type,
+                status=status,
+                headers=headers,
            )
        case _:
            result: dict[str, Any] = {
@@ -172,6 +182,7 @@ def api_return_error(
        result,
        status=status,
        dumps=json_dumps,
+        headers=headers,
    )


--- a/supervisor/auth.py
+++ b/supervisor/auth.py
@@ -9,8 +9,10 @@ from .addons.addon import Addon
 from .const import ATTR_PASSWORD, ATTR_TYPE, ATTR_USERNAME, FILE_HASSIO_AUTH
 from .coresys import CoreSys, CoreSysAttributes
 from .exceptions import (
-    AuthError,
+    AuthHomeAssistantAPIValidationError,
+    AuthInvalidNonStringValueError,
    AuthListUsersError,
+    AuthListUsersNoneResponseError,
    AuthPasswordResetError,
    HomeAssistantAPIError,
    HomeAssistantWSError,
@@ -83,10 +85,8 @@ class Auth(FileConfiguration, CoreSysAttributes):
        self, addon: Addon, username: str | None, password: str | None
    ) -> bool:
        """Check username login."""
-        if password is None:
-            raise AuthError("None as password is not supported!", _LOGGER.error)
-        if username is None:
-            raise AuthError("None as username is not supported!", _LOGGER.error)
+        if username is None or password is None:
+            raise AuthInvalidNonStringValueError(_LOGGER.error)

        _LOGGER.info("Auth request from '%s' for '%s'", addon.slug, username)

@@ -137,7 +137,7 @@ class Auth(FileConfiguration, CoreSysAttributes):
        finally:
            self._running.pop(username, None)

-        raise AuthError()
+        raise AuthHomeAssistantAPIValidationError()

    async def change_password(self, username: str, password: str) -> None:
        """Change user password login."""
@@ -155,7 +155,7 @@ class Auth(FileConfiguration, CoreSysAttributes):
        except HomeAssistantAPIError as err:
            _LOGGER.error("Can't request password reset on Home Assistant: %s", err)

-        raise AuthPasswordResetError()
+        raise AuthPasswordResetError(user=username)

    async def list_users(self) -> list[dict[str, Any]]:
        """List users on the Home Assistant instance."""
@@ -166,15 +166,12 @@ class Auth(FileConfiguration, CoreSysAttributes):
                {ATTR_TYPE: "config/auth/list"}
            )
        except HomeAssistantWSError as err:
-            raise AuthListUsersError(
-                f"Can't request listing users on Home Assistant: {err}", _LOGGER.error
-            ) from err
+            _LOGGER.error("Can't request listing users on Home Assistant: %s", err)
+            raise AuthListUsersError() from err

        if users is not None:
            return users
-        raise AuthListUsersError(
-            "Can't request listing users on Home Assistant!", _LOGGER.error
-        )
+        raise AuthListUsersNoneResponseError(_LOGGER.error)

    @staticmethod
    def _rehash(value: str, salt2: str = "") -> str:
--- a/supervisor/backups/backup.py
+++ b/supervisor/backups/backup.py
@@ -628,9 +628,6 @@ class Backup(JobGroup):
                if start_task := await self._addon_save(addon):
                    start_tasks.append(start_task)
            except BackupError as err:
-                err = BackupError(
-                    f"Can't backup add-on {addon.slug}: {str(err)}", _LOGGER.error
-                )
                self.sys_jobs.current.capture_error(err)

        return start_tasks
--- a/supervisor/dbus/const.py
+++ b/supervisor/dbus/const.py
@@ -306,8 +306,6 @@ class DeviceType(IntEnum):
    VLAN = 11
    TUN = 16
    VETH = 20
-    WIREGUARD = 29
-    LOOPBACK = 32


 class WirelessMethodType(IntEnum):
--- a/supervisor/dbus/manager.py
+++ b/supervisor/dbus/manager.py
@@ -115,7 +115,7 @@ class DBusManager(CoreSysAttributes):

    async def load(self) -> None:
        """Connect interfaces to D-Bus."""
-        if not await self.sys_run_in_executor(SOCKET_DBUS.exists):
+        if not SOCKET_DBUS.exists():
            _LOGGER.error(
                "No D-Bus support on Host. Disabled any kind of host control!"
            )
--- a/supervisor/dbus/network/init.py
+++ b/supervisor/dbus/network/init.py
@@ -134,10 +134,9 @@ class NetworkManager(DBusInterfaceProxy):
    async def check_connectivity(self, *, force: bool = False) -> ConnectivityState:
        """Check the connectivity of the host."""
        if force:
-            return ConnectivityState(
-                await self.connected_dbus.call("check_connectivity")
-            )
-        return ConnectivityState(await self.connected_dbus.get("connectivity"))
+            return await self.connected_dbus.call("check_connectivity")
+        else:
+            return await self.connected_dbus.get("connectivity")

    async def connect(self, bus: MessageBus) -> None:
        """Connect to system's D-Bus."""
--- a/supervisor/dbus/network/connection.py
+++ b/supervisor/dbus/network/connection.py
@@ -69,7 +69,7 @@ class NetworkConnection(DBusInterfaceProxy):
    @dbus_property
    def state(self) -> ConnectionStateType:
        """Return the state of the connection."""
-        return ConnectionStateType(self.properties[DBUS_ATTR_STATE])
+        return self.properties[DBUS_ATTR_STATE]

    @property
    def state_flags(self) -> set[ConnectionStateFlags]:
--- a/supervisor/dbus/network/interface.py
+++ b/supervisor/dbus/network/interface.py
@@ -1,6 +1,5 @@
 """NetworkInterface object for Network Manager."""

-import logging
 from typing import Any

 from dbus_fast.aio.message_bus import MessageBus
@@ -24,8 +23,6 @@ from .connection import NetworkConnection
 from .setting import NetworkSetting
 from .wireless import NetworkWireless

-_LOGGER: logging.Logger = logging.getLogger(__name__)
-

 class NetworkInterface(DBusInterfaceProxy):
    """NetworkInterface object represents Network Manager Device objects.
@@ -60,15 +57,7 @@ class NetworkInterface(DBusInterfaceProxy):
    @dbus_property
    def type(self) -> DeviceType:
        """Return interface type."""
-        try:
-            return DeviceType(self.properties[DBUS_ATTR_DEVICE_TYPE])
-        except ValueError:
-            _LOGGER.debug(
-                "Unknown device type %s for %s, treating as UNKNOWN",
-                self.properties[DBUS_ATTR_DEVICE_TYPE],
-                self.object_path,
-            )
-            return DeviceType.UNKNOWN
+        return self.properties[DBUS_ATTR_DEVICE_TYPE]

    @property
    @dbus_property
--- a/supervisor/dbus/resolved.py
+++ b/supervisor/dbus/resolved.py
@@ -75,7 +75,7 @@ class Resolved(DBusInterfaceProxy):
    @dbus_property
    def current_dns_server(
        self,
-    ) -> tuple[int, DNSAddressFamily, bytes] | None:
+    ) -> list[tuple[int, DNSAddressFamily, bytes]] | None:
        """Return current DNS server."""
        return self.properties[DBUS_ATTR_CURRENT_DNS_SERVER]

@@ -83,7 +83,7 @@ class Resolved(DBusInterfaceProxy):
    @dbus_property
    def current_dns_server_ex(
        self,
-    ) -> tuple[int, DNSAddressFamily, bytes, int, str] | None:
+    ) -> list[tuple[int, DNSAddressFamily, bytes, int, str]] | None:
        """Return current DNS server including port and server name."""
        return self.properties[DBUS_ATTR_CURRENT_DNS_SERVER_EX]

--- a/supervisor/dbus/systemd.py
+++ b/supervisor/dbus/systemd.py
@@ -70,7 +70,7 @@ class SystemdUnit(DBusInterface):
    @dbus_connected
    async def get_active_state(self) -> UnitActiveState:
        """Get active state of the unit."""
-        return UnitActiveState(await self.connected_dbus.Unit.get("active_state"))
+        return await self.connected_dbus.Unit.get("active_state")

    @dbus_connected
    def properties_changed(self) -> DBusSignalWrapper:
--- a/supervisor/dbus/udisks2/data.py
+++ b/supervisor/dbus/udisks2/data.py
@@ -9,7 +9,7 @@ from dbus_fast import Variant
 from .const import EncryptType, EraseMode


-def udisks2_bytes_to_path(path_bytes: bytes) -> Path:
+def udisks2_bytes_to_path(path_bytes: bytearray) -> Path:
    """Convert bytes to path object without null character on end."""
    if path_bytes and path_bytes[-1] == 0:
        return Path(path_bytes[:-1].decode())
@@ -73,7 +73,7 @@ FormatOptionsDataType = TypedDict(
    {
        "label": NotRequired[str],
        "take-ownership": NotRequired[bool],
-        "encrypt.passphrase": NotRequired[bytes],
+        "encrypt.passphrase": NotRequired[bytearray],
        "encrypt.type": NotRequired[str],
        "erase": NotRequired[str],
        "update-partition-type": NotRequired[bool],
--- a/supervisor/docker/addon.py
+++ b/supervisor/docker/addon.py
@@ -2,6 +2,7 @@

 from __future__ import annotations

+from collections.abc import Awaitable
 from contextlib import suppress
 from ipaddress import IPv4Address
 import logging
@@ -33,6 +34,7 @@ from ..coresys import CoreSys
 from ..exceptions import (
    CoreDNSError,
    DBusError,
+    DockerBuildError,
    DockerError,
    DockerJobError,
    DockerNotFound,
@@ -680,9 +682,8 @@ class DockerAddon(DockerInterface):
    async def _build(self, version: AwesomeVersion, image: str | None = None) -> None:
        """Build a Docker container."""
        build_env = await AddonBuild(self.coresys, self.addon).load_config()
-        if not await build_env.is_valid():
-            _LOGGER.error("Invalid build environment, can't build this add-on!")
-            raise DockerError()
+        # Check if the build environment is valid, raises if not
+        await build_env.is_valid()

        _LOGGER.info("Starting build for %s:%s", self.image, version)

@@ -733,8 +734,9 @@ class DockerAddon(DockerInterface):
            requests.RequestException,
            aiodocker.DockerError,
        ) as err:
-            _LOGGER.error("Can't build %s:%s: %s", self.image, version, err)
-            raise DockerError() from err
+            raise DockerBuildError(
+                f"Can't build {self.image}:{version}: {err!s}", _LOGGER.error
+            ) from err

        _LOGGER.info("Build %s:%s done", self.image, version)

@@ -792,12 +794,9 @@ class DockerAddon(DockerInterface):
        on_condition=DockerJobError,
        concurrency=JobConcurrency.GROUP_REJECT,
    )
-    async def write_stdin(self, data: bytes) -> None:
+    def write_stdin(self, data: bytes) -> Awaitable[None]:
        """Write to add-on stdin."""
-        if not await self.is_running():
-            raise DockerError()
-
-        await self.sys_run_in_executor(self._write_stdin, data)
+        return self.sys_run_in_executor(self._write_stdin, data)

    def _write_stdin(self, data: bytes) -> None:
        """Write to add-on stdin.
--- a/supervisor/docker/interface.py
+++ b/supervisor/docker/interface.py
@@ -208,6 +208,17 @@ class DockerInterface(JobGroup, ABC):

        return credentials

+    async def _docker_login(self, image: str) -> None:
+        """Try to log in to the registry if there are credentials available."""
+        if not self.sys_docker.config.registries:
+            return
+
+        credentials = self._get_credentials(image)
+        if not credentials:
+            return
+
+        await self.sys_run_in_executor(self.sys_docker.dockerpy.login, **credentials)
+
    def _process_pull_image_log(  # noqa: C901
        self, install_job_id: str, reference: PullLogEntry
    ) -> None:
@@ -239,16 +250,28 @@ class DockerInterface(JobGroup, ABC):
                job = j
                break

-        # There should no longer be any real risk of logs out of order anymore.
-        # However tests with very small images have shown that sometimes Docker
-        # skips stages in log. So keeping this one as a safety check on null job
+        # This likely only occurs if the logs came in out of sync and we got progress before the Pulling FS Layer one
        if not job:
            raise DockerLogOutOfOrder(
                f"Received pull image log with status {reference.status} for image id {reference.id} and parent job {install_job_id} but could not find a matching job, skipping",
                _LOGGER.debug,
            )

-        # For progress calculation we assume downloading is 70% of time, extracting is 30% and others stages negligible
+        # Hopefully these come in order but if they sometimes get out of sync, avoid accidentally going backwards
+        # If it happens a lot though we may need to reconsider the value of this feature
+        if job.done:
+            raise DockerLogOutOfOrder(
+                f"Received pull image log with status {reference.status} for job {job.uuid} but job was done, skipping",
+                _LOGGER.debug,
+            )
+
+        if job.stage and stage < PullImageLayerStage.from_status(job.stage):
+            raise DockerLogOutOfOrder(
+                f"Received pull image log with status {reference.status} for job {job.uuid} but job was already on stage {job.stage}, skipping",
+                _LOGGER.debug,
+            )
+
+        # For progress calcuation we assume downloading and extracting are each 50% of the time and others stages negligible
        progress = job.progress
        match stage:
            case PullImageLayerStage.DOWNLOADING | PullImageLayerStage.EXTRACTING:
@@ -257,26 +280,22 @@ class DockerInterface(JobGroup, ABC):
                    and reference.progress_detail.current
                    and reference.progress_detail.total
                ):
-                    progress = (
+                    progress = 50 * (
                        reference.progress_detail.current
                        / reference.progress_detail.total
                    )
-                    if stage == PullImageLayerStage.DOWNLOADING:
-                        progress = 70 * progress
-                    else:
-                        progress = 70 + 30 * progress
+                    if stage == PullImageLayerStage.EXTRACTING:
+                        progress += 50
            case (
                PullImageLayerStage.VERIFYING_CHECKSUM
                | PullImageLayerStage.DOWNLOAD_COMPLETE
            ):
-                progress = 70
+                progress = 50
            case PullImageLayerStage.PULL_COMPLETE:
                progress = 100
            case PullImageLayerStage.RETRYING_DOWNLOAD:
                progress = 0

-        # No real risk of getting things out of order in current implementation
-        # but keeping this one in case another change to these trips us up.
        if stage != PullImageLayerStage.RETRYING_DOWNLOAD and progress < job.progress:
            raise DockerLogOutOfOrder(
                f"Received pull image log with status {reference.status} for job {job.uuid} that implied progress was {progress} but current progress is {job.progress}, skipping",
@@ -340,7 +359,7 @@ class DockerInterface(JobGroup, ABC):
        progress = 0.0
        stage = PullImageLayerStage.PULL_COMPLETE
        for job in layer_jobs:
-            if not job.extra or not job.extra.get("total"):
+            if not job.extra:
                return
            progress += job.progress * (job.extra["total"] / total)
            job_stage = PullImageLayerStage.from_status(cast(str, job.stage))
@@ -384,8 +403,9 @@ class DockerInterface(JobGroup, ABC):

        _LOGGER.info("Downloading docker image %s with tag %s.", image, version)
        try:
-            # Get credentials for private registries to pass to aiodocker
-            credentials = self._get_credentials(image) or None
+            if self.sys_docker.config.registries:
+                # Try login if we have defined credentials
+                await self._docker_login(image)

            curr_job_id = self.sys_jobs.current.uuid

@@ -401,13 +421,12 @@ class DockerInterface(JobGroup, ABC):
                BusEvent.DOCKER_IMAGE_PULL_UPDATE, process_pull_image_log
            )

-            # Pull new image, passing credentials to aiodocker
+            # Pull new image
            docker_image = await self.sys_docker.pull_image(
                self.sys_jobs.current.uuid,
                image,
                str(version),
                platform=MAP_ARCH[image_arch],
-                auth=credentials,
            )

            # Tag latest
@@ -463,35 +482,34 @@ class DockerInterface(JobGroup, ABC):
            return True
        return False

-    async def is_running(self) -> bool:
-        """Return True if Docker is running."""
+    async def _get_container(self) -> Container | None:
+        """Get docker container, returns None if not found."""
        try:
-            docker_container = await self.sys_run_in_executor(
+            return await self.sys_run_in_executor(
                self.sys_docker.containers.get, self.name
            )
        except docker.errors.NotFound:
-            return False
+            return None
        except docker.errors.DockerException as err:
-            raise DockerAPIError() from err
+            raise DockerAPIError(
+                f"Docker API error occurred while getting container information: {err!s}"
+            ) from err
        except requests.RequestException as err:
-            raise DockerRequestError() from err
+            raise DockerRequestError(
+                f"Error communicating with Docker to get container information: {err!s}"
+            ) from err

-        return docker_container.status == "running"
+    async def is_running(self) -> bool:
+        """Return True if Docker is running."""
+        if docker_container := await self._get_container():
+            return docker_container.status == "running"
+        return False

    async def current_state(self) -> ContainerState:
        """Return current state of container."""
-        try:
-            docker_container = await self.sys_run_in_executor(
-                self.sys_docker.containers.get, self.name
-            )
-        except docker.errors.NotFound:
-            return ContainerState.UNKNOWN
-        except docker.errors.DockerException as err:
-            raise DockerAPIError() from err
-        except requests.RequestException as err:
-            raise DockerRequestError() from err
-
-        return _container_state_from_model(docker_container)
+        if docker_container := await self._get_container():
+            return _container_state_from_model(docker_container)
+        return ContainerState.UNKNOWN

    @Job(name="docker_interface_attach", concurrency=JobConcurrency.GROUP_QUEUE)
    async def attach(
@@ -526,7 +544,9 @@ class DockerInterface(JobGroup, ABC):

        # Successful?
        if not self._meta:
-            raise DockerError()
+            raise DockerError(
+                f"Could not get metadata on container or image for {self.name}"
+            )
        _LOGGER.info("Attaching to %s with version %s", self.image, self.version)

    @Job(
@@ -731,14 +751,8 @@ class DockerInterface(JobGroup, ABC):

    async def is_failed(self) -> bool:
        """Return True if Docker is failing state."""
-        try:
-            docker_container = await self.sys_run_in_executor(
-                self.sys_docker.containers.get, self.name
-            )
-        except docker.errors.NotFound:
+        if not (docker_container := await self._get_container()):
            return False
-        except (docker.errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err

        # container is not running
        if docker_container.status != "exited":
--- a/supervisor/docker/manager.py
+++ b/supervisor/docker/manager.py
@@ -76,25 +76,15 @@ class DockerInfo:
    storage: str = attr.ib()
    logging: str = attr.ib()
    cgroup: str = attr.ib()
-    support_cpu_realtime: bool = attr.ib()

    @staticmethod
-    async def new(data: dict[str, Any]) -> DockerInfo:
+    def new(data: dict[str, Any]):
        """Create a object from docker info."""
-        # Check if CONFIG_RT_GROUP_SCHED is loaded (blocking I/O in executor)
-        cpu_rt_file_exists = await asyncio.get_running_loop().run_in_executor(
-            None, Path("/sys/fs/cgroup/cpu/cpu.rt_runtime_us").exists
-        )
-        cpu_rt_supported = (
-            cpu_rt_file_exists and os.environ.get(ENV_SUPERVISOR_CPU_RT) == "1"
-        )
-
        return DockerInfo(
            AwesomeVersion(data.get("ServerVersion", "0.0.0")),
            data.get("Driver", "unknown"),
            data.get("LoggingDriver", "unknown"),
            data.get("CgroupVersion", "1"),
-            cpu_rt_supported,
        )

    @property
@@ -105,21 +95,23 @@ class DockerInfo:
        except AwesomeVersionCompareException:
            return False

+    @property
+    def support_cpu_realtime(self) -> bool:
+        """Return true, if CONFIG_RT_GROUP_SCHED is loaded."""
+        if not Path("/sys/fs/cgroup/cpu/cpu.rt_runtime_us").exists():
+            return False
+        return bool(os.environ.get(ENV_SUPERVISOR_CPU_RT) == "1")
+

@dataclass(frozen=True, slots=True)
 class PullProgressDetail:
    """Progress detail information for pull.

    Documentation lacking but both of these seem to be in bytes when populated.
-
-    Containerd-snapshot update - When leveraging this new feature, this information
-    becomes useless to us while extracting. It simply tells elapsed time using
-    current and units.
    """

    current: int | None = None
    total: int | None = None
-    units: str | None = None

    @classmethod
    def from_pull_log_dict(cls, value: dict[str, int]) -> PullProgressDetail:
@@ -242,7 +234,7 @@ class DockerAPI(CoreSysAttributes):
                timeout=900,
            ),
        )
-        self._info = await DockerInfo.new(self.dockerpy.info())
+        self._info = DockerInfo.new(self.dockerpy.info())
        await self.config.read_data()
        self._network = await DockerNetwork(self.dockerpy).post_init(
            self.config.enable_ipv6, self.config.mtu
@@ -437,7 +429,6 @@ class DockerAPI(CoreSysAttributes):
        repository: str,
        tag: str = "latest",
        platform: str | None = None,
-        auth: dict[str, str] | None = None,
    ) -> dict[str, Any]:
        """Pull the specified image and return it.

@@ -447,7 +438,7 @@ class DockerAPI(CoreSysAttributes):
        on the bus so listeners can use that to update status for users.
        """
        async for e in self.images.pull(
-            repository, tag=tag, platform=platform, auth=auth, stream=True
+            repository, tag=tag, platform=platform, stream=True
        ):
            entry = PullLogEntry.from_pull_log_dict(job_id, e)
            if entry.error:
@@ -587,9 +578,15 @@ class DockerAPI(CoreSysAttributes):
        except aiodocker.DockerError as err:
            if err.status == HTTPStatus.NOT_FOUND:
                return False
-            raise DockerError() from err
+            raise DockerError(
+                f"Could not get container {name} or image {image}:{version} to check state: {err!s}",
+                _LOGGER.error,
+            ) from err
        except (docker_errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err
+            raise DockerError(
+                f"Could not get container {name} or image {image}:{version} to check state: {err!s}",
+                _LOGGER.error,
+            ) from err

        # Check the image is correct and state is good
        return (
@@ -605,9 +602,13 @@ class DockerAPI(CoreSysAttributes):
        try:
            docker_container: Container = self.containers.get(name)
        except docker_errors.NotFound:
+            # Generally suppressed so we don't log this
            raise DockerNotFound() from None
        except (docker_errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err
+            raise DockerError(
+                f"Could not get container {name} for stopping: {err!s}",
+                _LOGGER.error,
+            ) from err

        if docker_container.status == "running":
            _LOGGER.info("Stopping %s application", name)
@@ -647,9 +648,13 @@ class DockerAPI(CoreSysAttributes):
        try:
            container: Container = self.containers.get(name)
        except docker_errors.NotFound:
-            raise DockerNotFound() from None
+            raise DockerNotFound(
+                f"Container {name} not found for restarting", _LOGGER.warning
+            ) from None
        except (docker_errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err
+            raise DockerError(
+                f"Could not get container {name} for restarting: {err!s}", _LOGGER.error
+            ) from err

        _LOGGER.info("Restarting %s", name)
        try:
@@ -662,9 +667,13 @@ class DockerAPI(CoreSysAttributes):
        try:
            docker_container: Container = self.containers.get(name)
        except docker_errors.NotFound:
-            raise DockerNotFound() from None
+            raise DockerNotFound(
+                f"Container {name} not found for logs", _LOGGER.warning
+            ) from None
        except (docker_errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err
+            raise DockerError(
+                f"Could not get container {name} for logs: {err!s}", _LOGGER.error
+            ) from err

        try:
            return docker_container.logs(tail=tail, stdout=True, stderr=True)
@@ -678,9 +687,13 @@ class DockerAPI(CoreSysAttributes):
        try:
            docker_container: Container = self.containers.get(name)
        except docker_errors.NotFound:
-            raise DockerNotFound() from None
+            raise DockerNotFound(
+                f"Container {name} not found for stats", _LOGGER.warning
+            ) from None
        except (docker_errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err
+            raise DockerError(
+                f"Could not inspect container '{name}': {err!s}", _LOGGER.error
+            ) from err

        # container is not running
        if docker_container.status != "running":
@@ -698,15 +711,21 @@ class DockerAPI(CoreSysAttributes):
        try:
            docker_container: Container = self.containers.get(name)
        except docker_errors.NotFound:
-            raise DockerNotFound() from None
+            raise DockerNotFound(
+                f"Container {name} not found for running command", _LOGGER.warning
+            ) from None
        except (docker_errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err
+            raise DockerError(
+                f"Can't get container {name} to run command: {err!s}"
+            ) from err

        # Execute
        try:
            code, output = docker_container.exec_run(command)
        except (docker_errors.DockerException, requests.RequestException) as err:
-            raise DockerError() from err
+            raise DockerError(
+                f"Can't run command in container {name}: {err!s}"
+            ) from err

        return CommandReturn(code, output)

--- a/supervisor/exceptions.py
+++ b/supervisor/exceptions.py
@@ -1,25 +1,25 @@
 """Core Exceptions."""

-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import Any

+MESSAGE_CHECK_SUPERVISOR_LOGS = (
+    "Check supervisor logs for details (check with '{logs_command}')"
+)
+EXTRA_FIELDS_LOGS_COMMAND = {"logs_command": "ha supervisor logs"}
+

 class HassioError(Exception):
    """Root exception."""

    error_key: str | None = None
    message_template: str | None = None
+    extra_fields: dict[str, Any] | None = None

    def __init__(
-        self,
-        message: str | None = None,
-        logger: Callable[..., None] | None = None,
-        *,
-        extra_fields: dict[str, Any] | None = None,
+        self, message: str | None = None, logger: Callable[..., None] | None = None
    ) -> None:
        """Raise & log."""
-        self.extra_fields = extra_fields or {}
-
        if not message and self.message_template:
            message = (
                self.message_template.format(**self.extra_fields)
@@ -41,6 +41,94 @@ class HassioNotSupportedError(HassioError):
    """Function is not supported."""


+# API
+
+
+class APIError(HassioError, RuntimeError):
+    """API errors."""
+
+    status = 400
+    headers: Mapping[str, str] | None = None
+
+    def __init__(
+        self,
+        message: str | None = None,
+        logger: Callable[..., None] | None = None,
+        *,
+        headers: Mapping[str, str] | None = None,
+        job_id: str | None = None,
+    ) -> None:
+        """Raise & log, optionally with job."""
+        super().__init__(message, logger)
+        self.headers = headers
+        self.job_id = job_id
+
+
+class APIUnauthorized(APIError):
+    """API unauthorized error."""
+
+    status = 401
+
+
+class APIForbidden(APIError):
+    """API forbidden error."""
+
+    status = 403
+
+
+class APINotFound(APIError):
+    """API not found error."""
+
+    status = 404
+
+
+class APIGone(APIError):
+    """API is no longer available."""
+
+    status = 410
+
+
+class APITooManyRequests(APIError):
+    """API too many requests error."""
+
+    status = 429
+
+
+class APIInternalServerError(APIError):
+    """API internal server error."""
+
+    status = 500
+
+
+class APIAddonNotInstalled(APIError):
+    """Not installed addon requested at addons API."""
+
+
+class APIDBMigrationInProgress(APIError):
+    """Service is unavailable due to an offline DB migration is in progress."""
+
+    status = 503
+
+
+class APIUnknownSupervisorError(APIError):
+    """Unknown error occurred within supervisor. Adds supervisor check logs rider to mesage template."""
+
+    status = 500
+
+    def __init__(
+        self,
+        logger: Callable[..., None] | None = None,
+        *,
+        job_id: str | None = None,
+    ) -> None:
+        """Initialize exception."""
+        self.message_template = (
+            f"{self.message_template}. {MESSAGE_CHECK_SUPERVISOR_LOGS}"
+        )
+        self.extra_fields = (self.extra_fields or {}) | EXTRA_FIELDS_LOGS_COMMAND
+        super().__init__(None, logger, job_id=job_id)
+
+
 # JobManager


@@ -122,6 +210,13 @@ class SupervisorAppArmorError(SupervisorError):
    """Supervisor AppArmor error."""


+class SupervisorUnknownError(SupervisorError, APIUnknownSupervisorError):
+    """Raise when an unknown error occurs interacting with Supervisor or its container."""
+
+    error_key = "supervisor_unknown_error"
+    message_template = "An unknown error occurred with Supervisor"
+
+
 class SupervisorJobError(SupervisorError, JobException):
    """Raise on job errors."""

@@ -250,6 +345,54 @@ class AddonConfigurationError(AddonsError):
    """Error with add-on configuration."""


+class AddonConfigurationInvalidError(AddonConfigurationError, APIError):
+    """Raise if invalid configuration provided for addon."""
+
+    error_key = "addon_configuration_invalid_error"
+    message_template = "Add-on {addon} has invalid options: {validation_error}"
+
+    def __init__(
+        self,
+        logger: Callable[..., None] | None = None,
+        *,
+        addon: str,
+        validation_error: str,
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon, "validation_error": validation_error}
+        super().__init__(None, logger)
+
+
+class AddonBootConfigCannotChangeError(AddonsError, APIError):
+    """Raise if user attempts to change addon boot config when it can't be changed."""
+
+    error_key = "addon_boot_config_cannot_change_error"
+    message_template = (
+        "Addon {addon} boot option is set to {boot_config} so it cannot be changed"
+    )
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str, boot_config: str
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon, "boot_config": boot_config}
+        super().__init__(None, logger)
+
+
+class AddonNotRunningError(AddonsError, APIError):
+    """Raise when an addon is not running."""
+
+    error_key = "addon_not_running_error"
+    message_template = "Add-on {addon} is not running"
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon}
+        super().__init__(None, logger)
+
+
 class AddonNotSupportedError(HassioNotSupportedError):
    """Addon doesn't support a function."""

@@ -268,11 +411,8 @@ class AddonNotSupportedArchitectureError(AddonNotSupportedError):
        architectures: list[str],
    ) -> None:
        """Initialize exception."""
-        super().__init__(
-            None,
-            logger,
-            extra_fields={"slug": slug, "architectures": ", ".join(architectures)},
-        )
+        self.extra_fields = {"slug": slug, "architectures": ", ".join(architectures)}
+        super().__init__(None, logger)


 class AddonNotSupportedMachineTypeError(AddonNotSupportedError):
@@ -289,11 +429,8 @@ class AddonNotSupportedMachineTypeError(AddonNotSupportedError):
        machine_types: list[str],
    ) -> None:
        """Initialize exception."""
-        super().__init__(
-            None,
-            logger,
-            extra_fields={"slug": slug, "machine_types": ", ".join(machine_types)},
-        )
+        self.extra_fields = {"slug": slug, "machine_types": ", ".join(machine_types)}
+        super().__init__(None, logger)


 class AddonNotSupportedHomeAssistantVersionError(AddonNotSupportedError):
@@ -310,11 +447,96 @@ class AddonNotSupportedHomeAssistantVersionError(AddonNotSupportedError):
        version: str,
    ) -> None:
        """Initialize exception."""
-        super().__init__(
-            None,
-            logger,
-            extra_fields={"slug": slug, "version": version},
-        )
+        self.extra_fields = {"slug": slug, "version": version}
+        super().__init__(None, logger)
+
+
+class AddonNotSupportedWriteStdinError(AddonNotSupportedError, APIError):
+    """Addon does not support writing to stdin."""
+
+    error_key = "addon_not_supported_write_stdin_error"
+    message_template = "Add-on {addon} does not support writing to stdin"
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon}
+        super().__init__(None, logger)
+
+
+class AddonBuildDockerfileMissingError(AddonNotSupportedError, APIError):
+    """Raise when addon build invalid because dockerfile is missing."""
+
+    error_key = "addon_build_dockerfile_missing_error"
+    message_template = (
+        "Cannot build addon '{addon}' because dockerfile is missing. A repair "
+        "using '{repair_command}' will fix this if the cause is data "
+        "corruption. Otherwise please report this to the addon developer."
+    )
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon, "repair_command": "ha supervisor repair"}
+        super().__init__(None, logger)
+
+
+class AddonBuildArchitectureNotSupportedError(AddonNotSupportedError, APIError):
+    """Raise when addon cannot be built on system because it doesn't support its architecture."""
+
+    error_key = "addon_build_architecture_not_supported_error"
+    message_template = (
+        "Cannot build addon '{addon}' because its supported architectures "
+        "({addon_arches}) do not match the system supported architectures ({system_arches})"
+    )
+
+    def __init__(
+        self,
+        logger: Callable[..., None] | None = None,
+        *,
+        addon: str,
+        addon_arch_list: list[str],
+        system_arch_list: list[str],
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {
+            "addon": addon,
+            "addon_arches": ", ".join(addon_arch_list),
+            "system_arches": ", ".join(system_arch_list),
+        }
+        super().__init__(None, logger)
+
+
+class AddonUnknownError(AddonsError, APIUnknownSupervisorError):
+    """Raise when unknown error occurs taking an action for an addon."""
+
+    error_key = "addon_unknown_error"
+    message_template = "An unknown error occurred with addon {addon}"
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon}
+        super().__init__(logger)
+
+
+class AddonBuildFailedUnknownError(AddonsError, APIUnknownSupervisorError):
+    """Raise when the build failed for an addon due to an unknown error."""
+
+    error_key = "addon_build_failed_unknown_error"
+    message_template = (
+        "An unknown error occurred while trying to build the image for addon {addon}"
+    )
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon}
+        super().__init__(logger)


 class AddonsJobError(AddonsError, JobException):
@@ -346,13 +568,68 @@ class AuthError(HassioError):
    """Auth errors."""


-class AuthPasswordResetError(HassioError):
+# This one uses the check logs rider even though its not a 500 error because it
+# is bad practice to return error specifics from a password reset API.
+class AuthPasswordResetError(AuthError, APIError):
    """Auth error if password reset failed."""

+    error_key = "auth_password_reset_error"
+    message_template = (
+        f"Unable to reset password for '{{user}}'. {MESSAGE_CHECK_SUPERVISOR_LOGS}"
+    )

-class AuthListUsersError(HassioError):
+    def __init__(
+        self,
+        logger: Callable[..., None] | None = None,
+        *,
+        user: str,
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"user": user} | EXTRA_FIELDS_LOGS_COMMAND
+        super().__init__(None, logger)
+
+
+class AuthListUsersError(AuthError, APIUnknownSupervisorError):
    """Auth error if listing users failed."""

+    error_key = "auth_list_users_error"
+    message_template = "Can't request listing users on Home Assistant"
+
+
+class AuthListUsersNoneResponseError(AuthError, APIInternalServerError):
+    """Auth error if listing users returned invalid None response."""
+
+    error_key = "auth_list_users_none_response_error"
+    message_template = "Home Assistant returned invalid response of `{none}` instead of a list of users. Check Home Assistant logs for details (check with `{logs_command}`)"
+    extra_fields = {"none": "None", "logs_command": "ha core logs"}
+
+    def __init__(self, logger: Callable[..., None] | None = None) -> None:
+        """Initialize exception."""
+        super().__init__(None, logger)
+
+
+class AuthInvalidNonStringValueError(AuthError, APIUnauthorized):
+    """Auth error if something besides a string provided as username or password."""
+
+    error_key = "auth_invalid_non_string_value_error"
+    message_template = "Username and password must be strings"
+
+    def __init__(
+        self,
+        logger: Callable[..., None] | None = None,
+        *,
+        headers: Mapping[str, str] | None = None,
+    ) -> None:
+        """Initialize exception."""
+        super().__init__(None, logger, headers=headers)
+
+
+class AuthHomeAssistantAPIValidationError(AuthError, APIUnknownSupervisorError):
+    """Error encountered trying to validate auth details via Home Assistant API."""
+
+    error_key = "auth_home_assistant_api_validation_error"
+    message_template = "Unable to validate authentication details with Home Assistant"
+

 # Host

@@ -385,60 +662,6 @@ class HostLogError(HostError):
    """Internal error with host log."""


-# API
-
-
-class APIError(HassioError, RuntimeError):
-    """API errors."""
-
-    status = 400
-
-    def __init__(
-        self,
-        message: str | None = None,
-        logger: Callable[..., None] | None = None,
-        *,
-        job_id: str | None = None,
-        error: HassioError | None = None,
-    ) -> None:
-        """Raise & log, optionally with job."""
-        # Allow these to be set from another error here since APIErrors essentially wrap others to add a status
-        self.error_key = error.error_key if error else None
-        self.message_template = error.message_template if error else None
-        super().__init__(
-            message, logger, extra_fields=error.extra_fields if error else None
-        )
-        self.job_id = job_id
-
-
-class APIForbidden(APIError):
-    """API forbidden error."""
-
-    status = 403
-
-
-class APINotFound(APIError):
-    """API not found error."""
-
-    status = 404
-
-
-class APIGone(APIError):
-    """API is no longer available."""
-
-    status = 410
-
-
-class APIAddonNotInstalled(APIError):
-    """Not installed addon requested at addons API."""
-
-
-class APIDBMigrationInProgress(APIError):
-    """Service is unavailable due to an offline DB migration is in progress."""
-
-    status = 503
-
-
 # Service / Discovery


@@ -616,6 +839,10 @@ class DockerError(HassioError):
    """Docker API/Transport errors."""


+class DockerBuildError(DockerError):
+    """Docker error during build."""
+
+
 class DockerAPIError(DockerError):
    """Docker API error."""

@@ -647,7 +874,7 @@ class DockerNoSpaceOnDevice(DockerError):
        super().__init__(None, logger=logger)


-class DockerHubRateLimitExceeded(DockerError):
+class DockerHubRateLimitExceeded(DockerError, APITooManyRequests):
    """Raise for docker hub rate limit exceeded error."""

    error_key = "dockerhub_rate_limit_exceeded"
@@ -655,16 +882,13 @@ class DockerHubRateLimitExceeded(DockerError):
        "Your IP address has made too many requests to Docker Hub which activated a rate limit. "
        "For more details see {dockerhub_rate_limit_url}"
    )
+    extra_fields = {
+        "dockerhub_rate_limit_url": "https://www.home-assistant.io/more-info/dockerhub-rate-limit"
+    }

    def __init__(self, logger: Callable[..., None] | None = None) -> None:
        """Raise & log."""
-        super().__init__(
-            None,
-            logger=logger,
-            extra_fields={
-                "dockerhub_rate_limit_url": "https://www.home-assistant.io/more-info/dockerhub-rate-limit"
-            },
-        )
+        super().__init__(None, logger=logger)


 class DockerJobError(DockerError, JobException):
@@ -735,6 +959,20 @@ class StoreNotFound(StoreError):
    """Raise if slug is not known."""


+class StoreAddonNotFoundError(StoreError, APINotFound):
+    """Raise if a requested addon is not in the store."""
+
+    error_key = "store_addon_not_found_error"
+    message_template = "Addon {addon} does not exist in the store"
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon}
+        super().__init__(None, logger)
+
+
 class StoreJobError(StoreError, JobException):
    """Raise on job error with git."""

@@ -770,7 +1008,7 @@ class BackupJobError(BackupError, JobException):
    """Raise on Backup job error."""


-class BackupFileNotFoundError(BackupError):
+class BackupFileNotFoundError(BackupError, APINotFound):
    """Raise if the backup file hasn't been found."""


@@ -782,6 +1020,55 @@ class BackupFileExistError(BackupError):
    """Raise if the backup file already exists."""


+class AddonBackupMetadataInvalidError(BackupError, APIError):
+    """Raise if invalid metadata file provided for addon in backup."""
+
+    error_key = "addon_backup_metadata_invalid_error"
+    message_template = (
+        "Metadata file for add-on {addon} in backup is invalid: {validation_error}"
+    )
+
+    def __init__(
+        self,
+        logger: Callable[..., None] | None = None,
+        *,
+        addon: str,
+        validation_error: str,
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {"addon": addon, "validation_error": validation_error}
+        super().__init__(None, logger)
+
+
+class AddonPrePostBackupCommandReturnedError(BackupError, APIError):
+    """Raise when addon's pre/post backup command returns an error."""
+
+    error_key = "addon_pre_post_backup_command_returned_error"
+    message_template = (
+        "Pre-/Post backup command for add-on {addon} returned error code: "
+        "{exit_code}. Please report this to the addon developer. Enable debug "
+        "logging to capture complete command output using {debug_logging_command}"
+    )
+
+    def __init__(
+        self, logger: Callable[..., None] | None = None, *, addon: str, exit_code: int
+    ) -> None:
+        """Initialize exception."""
+        self.extra_fields = {
+            "addon": addon,
+            "exit_code": exit_code,
+            "debug_logging_command": "ha supervisor options --logging debug",
+        }
+        super().__init__(None, logger)
+
+
+class BackupRestoreUnknownError(BackupError, APIUnknownSupervisorError):
+    """Raise when an unknown error occurs during backup or restore."""
+
+    error_key = "backup_restore_unknown_error"
+    message_template = "An unknown error occurred during backup/restore"
+
+
 # Security


--- a/supervisor/jobs/init.py
+++ b/supervisor/jobs/init.py
@@ -9,7 +9,7 @@ from contextvars import Context, ContextVar, Token
 from dataclasses import dataclass
 from datetime import datetime
 import logging
-from typing import Any, Self, cast
+from typing import Any, Self
 from uuid import uuid4

 from attr.validators import gt, lt
@@ -102,13 +102,17 @@ class SupervisorJobError:
        "Unknown error, see Supervisor logs (check with 'ha supervisor logs')"
    )
    stage: str | None = None
+    error_key: str | None = None
+    extra_fields: dict[str, Any] | None = None

-    def as_dict(self) -> dict[str, str | None]:
+    def as_dict(self) -> dict[str, Any]:
        """Return dictionary representation."""
        return {
            "type": self.type_.__name__,
            "message": self.message,
            "stage": self.stage,
+            "error_key": self.error_key,
+            "extra_fields": self.extra_fields,
        }


@@ -158,7 +162,9 @@ class SupervisorJob:
    def capture_error(self, err: HassioError | None = None) -> None:
        """Capture an error or record that an unknown error has occurred."""
        if err:
-            new_error = SupervisorJobError(type(err), str(err), self.stage)
+            new_error = SupervisorJobError(
+                type(err), str(err), self.stage, err.error_key, err.extra_fields
+            )
        else:
            new_error = SupervisorJobError(stage=self.stage)
        self.errors += [new_error]
@@ -196,7 +202,7 @@ class SupervisorJob:
        self,
        progress: float | None = None,
        stage: str | None = None,
-        extra: dict[str, Any] | None | type[DEFAULT] = DEFAULT,
+        extra: dict[str, Any] | None = DEFAULT,  # type: ignore
        done: bool | None = None,
    ) -> None:
        """Update multiple fields with one on change event."""
@@ -207,8 +213,8 @@ class SupervisorJob:
            self.progress = progress
        if stage is not None:
            self.stage = stage
-        if extra is not DEFAULT:
-            self.extra = cast(dict[str, Any] | None, extra)
+        if extra != DEFAULT:
+            self.extra = extra

        # Done has special event. use that to trigger on change if included
        # If not then just use any other field to trigger
@@ -306,21 +312,19 @@ class JobManager(FileConfiguration, CoreSysAttributes):
        reference: str | None = None,
        initial_stage: str | None = None,
        internal: bool = False,
-        parent_id: str | None | type[DEFAULT] = DEFAULT,
+        parent_id: str | None = DEFAULT,  # type: ignore
        child_job_syncs: list[ChildJobSyncFilter] | None = None,
    ) -> SupervisorJob:
        """Create a new job."""
-        kwargs: dict[str, Any] = {
-            "reference": reference,
-            "stage": initial_stage,
-            "on_change": self._on_job_change,
-            "internal": internal,
-            "child_job_syncs": child_job_syncs,
-        }
-        if parent_id is not DEFAULT:
-            kwargs["parent_id"] = parent_id
-
-        job = SupervisorJob(name, **kwargs)
+        job = SupervisorJob(
+            name,
+            reference=reference,
+            stage=initial_stage,
+            on_change=self._on_job_change,
+            internal=internal,
+            child_job_syncs=child_job_syncs,
+            **({} if parent_id == DEFAULT else {"parent_id": parent_id}),  # type: ignore
+        )

        # Shouldn't happen but inability to find a parent for progress reporting
        # shouldn't raise and break the active job
--- a/supervisor/misc/tasks.py
+++ b/supervisor/misc/tasks.py
@@ -1,6 +1,5 @@
 """A collection of tasks."""

-from contextlib import suppress
 from datetime import datetime, timedelta
 import logging
 from typing import cast
@@ -14,7 +13,6 @@ from ..exceptions import (
    BackupFileNotFoundError,
    HomeAssistantError,
    ObserverError,
-    SupervisorUpdateError,
 )
 from ..homeassistant.const import LANDINGPAGE, WSType
 from ..jobs.const import JobConcurrency
@@ -176,11 +174,7 @@ class Tasks(CoreSysAttributes):
            "Found new Supervisor version %s, updating",
            self.sys_supervisor.latest_version,
        )
-
-        # Errors are logged by the exceptions, we can't really do something
-        # if an update fails here.
-        with suppress(SupervisorUpdateError):
-            await self.sys_supervisor.update()
+        await self.sys_supervisor.update()

    async def _watchdog_homeassistant_api(self):
        """Create scheduler task for monitoring running state of API.
--- a/supervisor/mounts/mount.py
+++ b/supervisor/mounts/mount.py
@@ -135,7 +135,7 @@ class Mount(CoreSysAttributes, ABC):
    @property
    def state(self) -> UnitActiveState | None:
        """Get state of mount."""
-        return UnitActiveState(self._state) if self._state is not None else None
+        return self._state

    @cached_property
    def local_where(self) -> Path:
--- a/supervisor/resolution/evaluations/operating_system.py
+++ b/supervisor/resolution/evaluations/operating_system.py
@@ -5,6 +5,8 @@ from ...coresys import CoreSys
 from ..const import UnsupportedReason
 from .base import EvaluateBase

+SUPPORTED_OS = ["Debian GNU/Linux 12 (bookworm)"]
+

 def setup(coresys: CoreSys) -> EvaluateBase:
    """Initialize evaluation-setup function."""
@@ -31,4 +33,6 @@ class EvaluateOperatingSystem(EvaluateBase):

    async def evaluate(self) -> bool:
        """Run evaluation."""
-        return not self.sys_os.available
+        if self.sys_os.available:
+            return False
+        return self.sys_host.info.operating_system not in SUPPORTED_OS
--- a/supervisor/supervisor.py
+++ b/supervisor/supervisor.py
@@ -28,8 +28,8 @@ from .exceptions import (
    DockerError,
    HostAppArmorError,
    SupervisorAppArmorError,
-    SupervisorError,
    SupervisorJobError,
+    SupervisorUnknownError,
    SupervisorUpdateError,
 )
 from .jobs.const import JobCondition, JobThrottle
@@ -261,7 +261,7 @@ class Supervisor(CoreSysAttributes):
        try:
            return await self.instance.stats()
        except DockerError as err:
-            raise SupervisorError() from err
+            raise SupervisorUnknownError() from err

    async def repair(self):
        """Repair local Supervisor data."""
--- a/supervisor/utils/dbus.py
+++ b/supervisor/utils/dbus.py
@@ -7,7 +7,13 @@ from collections.abc import Awaitable, Callable
 import logging
 from typing import Any, Protocol, cast

-from dbus_fast import ErrorType, InvalidIntrospectionError, Message, MessageType
+from dbus_fast import (
+    ErrorType,
+    InvalidIntrospectionError,
+    Message,
+    MessageType,
+    Variant,
+)
 from dbus_fast.aio.message_bus import MessageBus
 from dbus_fast.aio.proxy_object import ProxyInterface, ProxyObject
 from dbus_fast.errors import DBusError as DBusFastDBusError
@@ -259,7 +265,7 @@ class DBus:
        """

        async def sync_property_change(
-            prop_interface: str, changed: dict[str, Any], invalidated: list[str]
+            prop_interface: str, changed: dict[str, Variant], invalidated: list[str]
        ) -> None:
            """Sync property changes to cache."""
            if interface != prop_interface:
--- a/tests/addons/test_addon.py
+++ b/tests/addons/test_addon.py
@@ -5,6 +5,7 @@ from datetime import timedelta
 import errno
 from http import HTTPStatus
 from pathlib import Path
+from typing import Any
 from unittest.mock import MagicMock, PropertyMock, call, patch

 import aiodocker
@@ -23,7 +24,13 @@ from supervisor.docker.addon import DockerAddon
 from supervisor.docker.const import ContainerState
 from supervisor.docker.manager import CommandReturn, DockerAPI
 from supervisor.docker.monitor import DockerContainerStateEvent
-from supervisor.exceptions import AddonsError, AddonsJobError, AudioUpdateError
+from supervisor.exceptions import (
+    AddonPrePostBackupCommandReturnedError,
+    AddonsJobError,
+    AddonUnknownError,
+    AudioUpdateError,
+    HassioError,
+)
 from supervisor.hardware.helper import HwHelper
 from supervisor.ingress import Ingress
 from supervisor.store.repository import Repository
@@ -502,31 +509,26 @@ async def test_backup_with_pre_post_command(


@pytest.mark.parametrize(
-    "get_error,exception_on_exec",
+    ("container_get_side_effect", "exec_run_side_effect", "exc_type_raised"),
    [
-        (NotFound("missing"), False),
-        (DockerException(), False),
-        (None, True),
-        (None, False),
+        (NotFound("missing"), [(1, None)], AddonUnknownError),
+        (DockerException(), [(1, None)], AddonUnknownError),
+        (None, DockerException(), AddonUnknownError),
+        (None, [(1, None)], AddonPrePostBackupCommandReturnedError),
    ],
 )
+@pytest.mark.usefixtures("tmp_supervisor_data", "path_extern")
 async def test_backup_with_pre_command_error(
    coresys: CoreSys,
    install_addon_ssh: Addon,
    container: MagicMock,
-    get_error: DockerException | None,
-    exception_on_exec: bool,
-    tmp_supervisor_data,
-    path_extern,
+    container_get_side_effect: DockerException | None,
+    exec_run_side_effect: DockerException | list[tuple[int, Any]],
+    exc_type_raised: type[HassioError],
 ) -> None:
    """Test backing up an addon with error running pre command."""
-    if get_error:
-        coresys.docker.containers.get.side_effect = get_error
-
-    if exception_on_exec:
-        container.exec_run.side_effect = DockerException()
-    else:
-        container.exec_run.return_value = (1, None)
+    coresys.docker.containers.get.side_effect = container_get_side_effect
+    container.exec_run.side_effect = exec_run_side_effect

    install_addon_ssh.path_data.mkdir()
    await install_addon_ssh.load()
@@ -535,7 +537,7 @@ async def test_backup_with_pre_command_error(
    with (
        patch.object(DockerAddon, "is_running", return_value=True),
        patch.object(Addon, "backup_pre", new=PropertyMock(return_value="backup_pre")),
-        pytest.raises(AddonsError),
+        pytest.raises(exc_type_raised),
    ):
        assert await install_addon_ssh.backup(tarfile) is None

@@ -947,7 +949,7 @@ async def test_addon_load_succeeds_with_docker_errors(
    )
    caplog.clear()
    await install_addon_ssh.load()
-    assert "Invalid build environment" in caplog.text
+    assert "Cannot build addon 'local_ssh' because dockerfile is missing" in caplog.text

    # Image build failure
    caplog.clear()
--- a/tests/addons/test_build.py
+++ b/tests/addons/test_build.py
@@ -3,10 +3,12 @@
 from unittest.mock import PropertyMock, patch

 from awesomeversion import AwesomeVersion
+import pytest

 from supervisor.addons.addon import Addon
 from supervisor.addons.build import AddonBuild
 from supervisor.coresys import CoreSys
+from supervisor.exceptions import AddonBuildDockerfileMissingError

 from tests.common import is_in_list

@@ -102,11 +104,11 @@ async def test_build_valid(coresys: CoreSys, install_addon_ssh: Addon):
            type(coresys.arch), "default", new=PropertyMock(return_value="aarch64")
        ),
    ):
-        assert await build.is_valid()
+        assert (await build.is_valid()) is None


 async def test_build_invalid(coresys: CoreSys, install_addon_ssh: Addon):
-    """Test platform set in docker args."""
+    """Test build not supported because Dockerfile missing for specified architecture."""
    build = await AddonBuild(coresys, install_addon_ssh).load_config()
    with (
        patch.object(
@@ -115,5 +117,6 @@ async def test_build_invalid(coresys: CoreSys, install_addon_ssh: Addon):
        patch.object(
            type(coresys.arch), "default", new=PropertyMock(return_value="amd64")
        ),
+        pytest.raises(AddonBuildDockerfileMissingError),
    ):
-        assert not await build.is_valid()
+        await build.is_valid()
--- a/tests/api/test_addons.py
+++ b/tests/api/test_addons.py
@@ -5,6 +5,7 @@ from unittest.mock import MagicMock, PropertyMock, patch

 from aiohttp import ClientResponse
 from aiohttp.test_utils import TestClient
+from docker.errors import DockerException
 import pytest

 from supervisor.addons.addon import Addon
@@ -471,6 +472,11 @@ async def test_addon_options_boot_mode_manual_only_invalid(
        body["message"]
        == "Addon local_example boot option is set to manual_only so it cannot be changed"
    )
+    assert body["error_key"] == "addon_boot_config_cannot_change_error"
+    assert body["extra_fields"] == {
+        "addon": "local_example",
+        "boot_config": "manual_only",
+    }


 async def get_message(resp: ClientResponse, json_expected: bool) -> str:
@@ -539,3 +545,131 @@ async def test_addon_not_installed(
    resp = await api_client.request(method, url)
    assert resp.status == 400
    assert await get_message(resp, json_expected) == "Addon is not installed"
+
+
+async def test_addon_set_options(api_client: TestClient, install_addon_example: Addon):
+    """Test setting options for an addon."""
+    resp = await api_client.post(
+        "/addons/local_example/options", json={"options": {"message": "test"}}
+    )
+    assert resp.status == 200
+    assert install_addon_example.options == {"message": "test"}
+
+
+async def test_addon_set_options_error(
+    api_client: TestClient, install_addon_example: Addon
+):
+    """Test setting options for an addon."""
+    resp = await api_client.post(
+        "/addons/local_example/options", json={"options": {"message": True}}
+    )
+    assert resp.status == 400
+    body = await resp.json()
+    assert (
+        body["message"]
+        == "Add-on local_example has invalid options: not a valid value. Got {'message': True}"
+    )
+    assert body["error_key"] == "addon_configuration_invalid_error"
+    assert body["extra_fields"] == {
+        "addon": "local_example",
+        "validation_error": "not a valid value. Got {'message': True}",
+    }
+
+
+async def test_addon_start_options_error(
+    api_client: TestClient,
+    install_addon_example: Addon,
+    caplog: pytest.LogCaptureFixture,
+):
+    """Test error writing options when trying to start addon."""
+    install_addon_example.options = {"message": "hello"}
+
+    # Simulate OS error trying to write the file
+    with patch("supervisor.utils.json.atomic_write", side_effect=OSError("fail")):
+        resp = await api_client.post("/addons/local_example/start")
+        assert resp.status == 500
+        body = await resp.json()
+        assert (
+            body["message"]
+            == "An unknown error occurred with addon local_example. Check supervisor logs for details (check with 'ha supervisor logs')"
+        )
+        assert body["error_key"] == "addon_unknown_error"
+        assert body["extra_fields"] == {
+            "addon": "local_example",
+            "logs_command": "ha supervisor logs",
+        }
+        assert "Add-on local_example can't write options" in caplog.text
+
+    # Simulate an update with a breaking change for options schema creating failure on start
+    caplog.clear()
+    install_addon_example.data["schema"] = {"message": "bool"}
+    resp = await api_client.post("/addons/local_example/start")
+    assert resp.status == 400
+    body = await resp.json()
+    assert (
+        body["message"]
+        == "Add-on local_example has invalid options: expected boolean. Got {'message': 'hello'}"
+    )
+    assert body["error_key"] == "addon_configuration_invalid_error"
+    assert body["extra_fields"] == {
+        "addon": "local_example",
+        "validation_error": "expected boolean. Got {'message': 'hello'}",
+    }
+    assert (
+        "Add-on local_example has invalid options: expected boolean. Got {'message': 'hello'}"
+        in caplog.text
+    )
+
+
+@pytest.mark.parametrize(("method", "action"), [("get", "stats"), ("post", "stdin")])
+@pytest.mark.usefixtures("install_addon_example")
+async def test_addon_not_running_error(
+    api_client: TestClient, method: str, action: str
+):
+    """Test addon not running error for endpoints that require that."""
+    with patch.object(
+        Addon, "with_stdin", return_value=PropertyMock(return_value=True)
+    ):
+        resp = await api_client.request(method, f"/addons/local_example/{action}")
+
+    assert resp.status == 400
+    body = await resp.json()
+    assert body["message"] == "Add-on local_example is not running"
+    assert body["error_key"] == "addon_not_running_error"
+    assert body["extra_fields"] == {"addon": "local_example"}
+
+
+@pytest.mark.usefixtures("install_addon_example")
+async def test_addon_write_stdin_not_supported_error(api_client: TestClient):
+    """Test error when trying to write stdin to addon that does not support it."""
+    resp = await api_client.post("/addons/local_example/stdin")
+    assert resp.status == 400
+    body = await resp.json()
+    assert body["message"] == "Add-on local_example does not support writing to stdin"
+    assert body["error_key"] == "addon_not_supported_write_stdin_error"
+    assert body["extra_fields"] == {"addon": "local_example"}
+
+
+@pytest.mark.usefixtures("install_addon_ssh")
+async def test_addon_rebuild_fails_error(api_client: TestClient, coresys: CoreSys):
+    """Test error when build fails during rebuild for addon."""
+    coresys.hardware.disk.get_disk_free_space = lambda x: 5000
+    coresys.docker.containers.run.side_effect = DockerException("fail")
+
+    with (
+        patch.object(CpuArch, "supported", new=PropertyMock(return_value=["aarch64"])),
+        patch.object(CpuArch, "default", new=PropertyMock(return_value="aarch64")),
+        patch.object(AddonBuild, "get_docker_args", return_value={}),
+    ):
+        resp = await api_client.post("/addons/local_ssh/rebuild")
+    assert resp.status == 500
+    body = await resp.json()
+    assert (
+        body["message"]
+        == "An unknown error occurred while trying to build the image for addon local_ssh. Check supervisor logs for details (check with 'ha supervisor logs')"
+    )
+    assert body["error_key"] == "addon_build_failed_unknown_error"
+    assert body["extra_fields"] == {
+        "addon": "local_ssh",
+        "logs_command": "ha supervisor logs",
+    }
--- a/tests/api/test_auth.py
+++ b/tests/api/test_auth.py
@@ -6,9 +6,12 @@ from unittest.mock import AsyncMock, MagicMock, patch
 from aiohttp.hdrs import WWW_AUTHENTICATE
 from aiohttp.test_utils import TestClient
 import pytest
+from securetar import Any

 from supervisor.addons.addon import Addon
 from supervisor.coresys import CoreSys
+from supervisor.exceptions import HomeAssistantAPIError, HomeAssistantWSError
+from supervisor.homeassistant.api import HomeAssistantAPI

 from tests.common import MockResponse
 from tests.const import TEST_ADDON_SLUG
@@ -100,6 +103,52 @@ async def test_password_reset(
    assert "Successful password reset for 'john'" in caplog.text


+@pytest.mark.parametrize(
+    ("post_mock", "expected_log"),
+    [
+        (
+            MagicMock(return_value=MockResponse(status=400)),
+            "The user 'john' is not registered",
+        ),
+        (
+            MagicMock(side_effect=HomeAssistantAPIError("fail")),
+            "Can't request password reset on Home Assistant: fail",
+        ),
+    ],
+)
+async def test_failed_password_reset(
+    api_client: TestClient,
+    coresys: CoreSys,
+    caplog: pytest.LogCaptureFixture,
+    websession: MagicMock,
+    post_mock: MagicMock,
+    expected_log: str,
+):
+    """Test failed password reset."""
+    coresys.homeassistant.api.access_token = "abc123"
+    # pylint: disable-next=protected-access
+    coresys.homeassistant.api._access_token_expires = datetime.now(tz=UTC) + timedelta(
+        days=1
+    )
+
+    websession.post = post_mock
+    resp = await api_client.post(
+        "/auth/reset", json={"username": "john", "password": "doe"}
+    )
+    assert resp.status == 400
+    body = await resp.json()
+    assert (
+        body["message"]
+        == "Unable to reset password for 'john'. Check supervisor logs for details (check with 'ha supervisor logs')"
+    )
+    assert body["error_key"] == "auth_password_reset_error"
+    assert body["extra_fields"] == {
+        "user": "john",
+        "logs_command": "ha supervisor logs",
+    }
+    assert expected_log in caplog.text
+
+
 async def test_list_users(
    api_client: TestClient, coresys: CoreSys, ha_ws_client: AsyncMock
 ):
@@ -120,6 +169,48 @@ async def test_list_users(
    ]


+@pytest.mark.parametrize(
+    ("send_command_mock", "error_response", "expected_log"),
+    [
+        (
+            AsyncMock(return_value=None),
+            {
+                "result": "error",
+                "message": "Home Assistant returned invalid response of `None` instead of a list of users. Check Home Assistant logs for details (check with `ha core logs`)",
+                "error_key": "auth_list_users_none_response_error",
+                "extra_fields": {"none": "None", "logs_command": "ha core logs"},
+            },
+            "Home Assistant returned invalid response of `None` instead of a list of users. Check Home Assistant logs for details (check with `ha core logs`)",
+        ),
+        (
+            AsyncMock(side_effect=HomeAssistantWSError("fail")),
+            {
+                "result": "error",
+                "message": "Can't request listing users on Home Assistant. Check supervisor logs for details (check with 'ha supervisor logs')",
+                "error_key": "auth_list_users_error",
+                "extra_fields": {"logs_command": "ha supervisor logs"},
+            },
+            "Can't request listing users on Home Assistant: fail",
+        ),
+    ],
+)
+async def test_list_users_failure(
+    api_client: TestClient,
+    ha_ws_client: AsyncMock,
+    caplog: pytest.LogCaptureFixture,
+    send_command_mock: AsyncMock,
+    error_response: dict[str, Any],
+    expected_log: str,
+):
+    """Test failure listing users via API."""
+    ha_ws_client.async_send_command = send_command_mock
+    resp = await api_client.get("/auth/list")
+    assert resp.status == 500
+    result = await resp.json()
+    assert result == error_response
+    assert expected_log in caplog.text
+
+
@pytest.mark.parametrize(
    ("field", "api_client"),
    [("username", TEST_ADDON_SLUG), ("user", TEST_ADDON_SLUG)],
@@ -156,6 +247,13 @@ async def test_auth_json_failure_none(
    mock_check_login.return_value = True
    resp = await api_client.post("/auth", json={"username": user, "password": password})
    assert resp.status == 401
+    assert (
+        resp.headers["WWW-Authenticate"]
+        == 'Basic realm="Home Assistant Authentication"'
+    )
+    body = await resp.json()
+    assert body["message"] == "Username and password must be strings"
+    assert body["error_key"] == "auth_invalid_non_string_value_error"


@pytest.mark.parametrize("api_client", [TEST_ADDON_SLUG], indirect=True)
@@ -267,3 +365,26 @@ async def test_non_addon_token_no_auth_access(api_client: TestClient):
    """Test auth where add-on is not allowed to access auth API."""
    resp = await api_client.post("/auth", json={"username": "test", "password": "pass"})
    assert resp.status == 403
+
+
+@pytest.mark.parametrize("api_client", [TEST_ADDON_SLUG], indirect=True)
+@pytest.mark.usefixtures("install_addon_ssh")
+async def test_auth_backend_login_failure(api_client: TestClient):
+    """Test backend login failure on auth."""
+    with (
+        patch.object(HomeAssistantAPI, "check_api_state", return_value=True),
+        patch.object(
+            HomeAssistantAPI, "make_request", side_effect=HomeAssistantAPIError("fail")
+        ),
+    ):
+        resp = await api_client.post(
+            "/auth", json={"username": "test", "password": "pass"}
+        )
+    assert resp.status == 500
+    body = await resp.json()
+    assert (
+        body["message"]
+        == "Unable to validate authentication details with Home Assistant. Check supervisor logs for details (check with 'ha supervisor logs')"
+    )
+    assert body["error_key"] == "auth_home_assistant_api_validation_error"
+    assert body["extra_fields"] == {"logs_command": "ha supervisor logs"}
--- a/tests/api/test_backups.py
+++ b/tests/api/test_backups.py
@@ -17,6 +17,7 @@ from supervisor.const import CoreState
 from supervisor.coresys import CoreSys
 from supervisor.docker.manager import DockerAPI
 from supervisor.exceptions import (
+    AddonPrePostBackupCommandReturnedError,
    AddonsError,
    BackupInvalidError,
    HomeAssistantBackupError,
@@ -24,6 +25,7 @@ from supervisor.exceptions import (
 from supervisor.homeassistant.core import HomeAssistantCore
 from supervisor.homeassistant.module import HomeAssistant
 from supervisor.homeassistant.websocket import HomeAssistantWebSocket
+from supervisor.jobs import SupervisorJob
 from supervisor.mounts.mount import Mount
 from supervisor.supervisor import Supervisor

@@ -401,6 +403,8 @@ async def test_api_backup_errors(
            "type": "BackupError",
            "message": str(err),
            "stage": None,
+            "error_key": None,
+            "extra_fields": None,
        }
    ]
    assert job["child_jobs"][2]["name"] == "backup_store_folders"
@@ -437,6 +441,8 @@ async def test_api_backup_errors(
            "type": "HomeAssistantBackupError",
            "message": "Backup error",
            "stage": "home_assistant",
+            "error_key": None,
+            "extra_fields": None,
        }
    ]
    assert job["child_jobs"][0]["name"] == "backup_store_homeassistant"
@@ -445,6 +451,8 @@ async def test_api_backup_errors(
            "type": "HomeAssistantBackupError",
            "message": "Backup error",
            "stage": None,
+            "error_key": None,
+            "extra_fields": None,
        }
    ]
    assert len(job["child_jobs"]) == 1
@@ -749,6 +757,8 @@ async def test_backup_to_multiple_locations_error_on_copy(
            "type": "BackupError",
            "message": "Could not copy backup to .cloud_backup due to: ",
            "stage": None,
+            "error_key": None,
+            "extra_fields": None,
        }
    ]

@@ -1483,3 +1493,44 @@ async def test_immediate_list_after_missing_file_restore(
    result = await resp.json()
    assert len(result["data"]["backups"]) == 1
    assert result["data"]["backups"][0]["slug"] == "93b462f8"
+
+
+@pytest.mark.parametrize("command", ["backup_pre", "backup_post"])
+@pytest.mark.usefixtures("install_addon_example", "tmp_supervisor_data")
+async def test_pre_post_backup_command_error(
+    api_client: TestClient, coresys: CoreSys, container: MagicMock, command: str
+):
+    """Test pre/post backup command error."""
+    await coresys.core.set_state(CoreState.RUNNING)
+    coresys.hardware.disk.get_disk_free_space = lambda x: 5000
+
+    container.status = "running"
+    container.exec_run.return_value = (1, b"")
+    with patch.object(Addon, command, return_value=PropertyMock(return_value="test")):
+        resp = await api_client.post(
+            "/backups/new/partial", json={"addons": ["local_example"]}
+        )
+
+    assert resp.status == 200
+    body = await resp.json()
+    job_id = body["data"]["job_id"]
+    job: SupervisorJob | None = None
+    for j in coresys.jobs.jobs:
+        if j.name == "backup_store_addons" and j.parent_id == job_id:
+            job = j
+            break
+
+    assert job
+    assert job.done is True
+    assert job.errors[0].type_ == AddonPrePostBackupCommandReturnedError
+    assert job.errors[0].message == (
+        "Pre-/Post backup command for add-on local_example returned error code: "
+        "1. Please report this to the addon developer. Enable debug "
+        "logging to capture complete command output using ha supervisor options --logging debug"
+    )
+    assert job.errors[0].error_key == "addon_pre_post_backup_command_returned_error"
+    assert job.errors[0].extra_fields == {
+        "addon": "local_example",
+        "exit_code": 1,
+        "debug_logging_command": "ha supervisor options --logging debug",
+    }
--- a/tests/api/test_homeassistant.py
+++ b/tests/api/test_homeassistant.py
@@ -323,29 +323,29 @@ async def test_api_progress_updates_home_assistant_update(
        },
        {
            "stage": None,
-            "progress": 1.7,
+            "progress": 1.2,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 4.0,
+            "progress": 2.8,
            "done": False,
        },
    ]
    assert events[-5:] == [
        {
            "stage": None,
-            "progress": 98.2,
+            "progress": 97.2,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 98.3,
+            "progress": 98.4,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 99.3,
+            "progress": 99.4,
            "done": False,
        },
        {
--- a/tests/api/test_jobs.py
+++ b/tests/api/test_jobs.py
@@ -374,6 +374,8 @@ async def test_job_with_error(
                    "type": "SupervisorError",
                    "message": "bad",
                    "stage": "test",
+                    "error_key": None,
+                    "extra_fields": None,
                }
            ],
            "child_jobs": [
@@ -391,6 +393,8 @@ async def test_job_with_error(
                            "type": "SupervisorError",
                            "message": "bad",
                            "stage": None,
+                            "error_key": None,
+                            "extra_fields": None,
                        }
                    ],
                    "child_jobs": [],
--- a/tests/api/test_store.py
+++ b/tests/api/test_store.py
@@ -4,7 +4,6 @@ import asyncio
 from pathlib import Path
 from unittest.mock import AsyncMock, MagicMock, PropertyMock, patch

-from aiohttp import ClientResponse
 from aiohttp.test_utils import TestClient
 from awesomeversion import AwesomeVersion
 import pytest
@@ -290,14 +289,6 @@ async def test_api_detached_addon_documentation(
    assert result == "Addon local_ssh does not exist in the store"


-async def get_message(resp: ClientResponse, json_expected: bool) -> str:
-    """Get message from response based on response type."""
-    if json_expected:
-        body = await resp.json()
-        return body["message"]
-    return await resp.text()
-
-
@pytest.mark.parametrize(
    ("method", "url", "json_expected"),
    [
@@ -323,7 +314,13 @@ async def test_store_addon_not_found(
    """Test store addon not found error."""
    resp = await api_client.request(method, url)
    assert resp.status == 404
-    assert await get_message(resp, json_expected) == "Addon bad does not exist"
+    if json_expected:
+        body = await resp.json()
+        assert body["message"] == "Addon bad does not exist in the store"
+        assert body["error_key"] == "store_addon_not_found_error"
+        assert body["extra_fields"] == {"addon": "bad"}
+    else:
+        assert await resp.text() == "Addon bad does not exist in the store"


@pytest.mark.parametrize(
@@ -773,29 +770,29 @@ async def test_api_progress_updates_addon_install_update(
        },
        {
            "stage": None,
-            "progress": 1.7,
+            "progress": 1.2,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 4.0,
+            "progress": 2.8,
            "done": False,
        },
    ]
    assert events[-5:] == [
        {
            "stage": None,
-            "progress": 98.2,
+            "progress": 97.2,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 98.3,
+            "progress": 98.4,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 99.3,
+            "progress": 99.4,
            "done": False,
        },
        {
--- a/tests/api/test_supervisor.py
+++ b/tests/api/test_supervisor.py
@@ -7,6 +7,7 @@ from unittest.mock import AsyncMock, MagicMock, PropertyMock, patch
 from aiohttp.test_utils import TestClient
 from awesomeversion import AwesomeVersion
 from blockbuster import BlockingError
+from docker.errors import DockerException
 import pytest

 from supervisor.const import CoreState
@@ -371,29 +372,29 @@ async def test_api_progress_updates_supervisor_update(
        },
        {
            "stage": None,
-            "progress": 1.7,
+            "progress": 1.2,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 4.0,
+            "progress": 2.8,
            "done": False,
        },
    ]
    assert events[-5:] == [
        {
            "stage": None,
-            "progress": 98.2,
+            "progress": 97.2,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 98.3,
+            "progress": 98.4,
            "done": False,
        },
        {
            "stage": None,
-            "progress": 99.3,
+            "progress": 99.4,
            "done": False,
        },
        {
@@ -407,3 +408,37 @@ async def test_api_progress_updates_supervisor_update(
            "done": True,
        },
    ]
+
+
+async def test_api_supervisor_stats(api_client: TestClient, coresys: CoreSys):
+    """Test supervisor stats."""
+    coresys.docker.containers.get.return_value.status = "running"
+    coresys.docker.containers.get.return_value.stats.return_value = load_json_fixture(
+        "container_stats.json"
+    )
+
+    resp = await api_client.get("/supervisor/stats")
+    assert resp.status == 200
+    result = await resp.json()
+    assert result["data"]["cpu_percent"] == 90.0
+    assert result["data"]["memory_usage"] == 59700000
+    assert result["data"]["memory_limit"] == 4000000000
+    assert result["data"]["memory_percent"] == 1.49
+
+
+async def test_supervisor_api_stats_failure(
+    api_client: TestClient, coresys: CoreSys, caplog: pytest.LogCaptureFixture
+):
+    """Test supervisor stats failure."""
+    coresys.docker.containers.get.side_effect = DockerException("fail")
+
+    resp = await api_client.get("/supervisor/stats")
+    assert resp.status == 500
+    body = await resp.json()
+    assert (
+        body["message"]
+        == "An unknown error occurred with Supervisor. Check supervisor logs for details (check with 'ha supervisor logs')"
+    )
+    assert body["error_key"] == "supervisor_unknown_error"
+    assert body["extra_fields"] == {"logs_command": "ha supervisor logs"}
+    assert "Could not inspect container 'hassio_supervisor': fail" in caplog.text
--- a/tests/dbus/network/test_interface.py
+++ b/tests/dbus/network/test_interface.py
@@ -184,20 +184,3 @@ async def test_interface_becomes_unmanaged(
    assert wireless.is_connected is False
    assert eth0.connection is None
    assert connection.is_connected is False
-
-
-async def test_unknown_device_type(
-    device_eth0_service: DeviceService, dbus_session_bus: MessageBus
-):
-    """Test unknown device types are handled gracefully."""
-    interface = NetworkInterface("/org/freedesktop/NetworkManager/Devices/1")
-    await interface.connect(dbus_session_bus)
-
-    # Emit an unknown device type (e.g., 1000 which doesn't exist in the enum)
-    device_eth0_service.emit_properties_changed({"DeviceType": 1000})
-    await device_eth0_service.ping()
-
-    # Should return UNKNOWN instead of crashing
-    assert interface.type == DeviceType.UNKNOWN
-    # Wireless should be None since it's not a wireless device
-    assert interface.wireless is None
--- a/tests/dbus/test_resolved.py
+++ b/tests/dbus/test_resolved.py
@@ -41,51 +41,51 @@ async def test_dbus_resolved_info(
    assert resolved.dns_over_tls == DNSOverTLSEnabled.NO

    assert len(resolved.dns) == 2
-    assert resolved.dns[0] == (0, 2, inet_aton("127.0.0.1"))
-    assert resolved.dns[1] == (0, 10, inet_pton(AF_INET6, "::1"))
+    assert resolved.dns[0] == [0, 2, inet_aton("127.0.0.1")]
+    assert resolved.dns[1] == [0, 10, inet_pton(AF_INET6, "::1")]
    assert len(resolved.dns_ex) == 2
-    assert resolved.dns_ex[0] == (0, 2, inet_aton("127.0.0.1"), 0, "")
-    assert resolved.dns_ex[1] == (0, 10, inet_pton(AF_INET6, "::1"), 0, "")
+    assert resolved.dns_ex[0] == [0, 2, inet_aton("127.0.0.1"), 0, ""]
+    assert resolved.dns_ex[1] == [0, 10, inet_pton(AF_INET6, "::1"), 0, ""]

    assert len(resolved.fallback_dns) == 2
-    assert resolved.fallback_dns[0] == (0, 2, inet_aton("1.1.1.1"))
-    assert resolved.fallback_dns[1] == (
+    assert resolved.fallback_dns[0] == [0, 2, inet_aton("1.1.1.1")]
+    assert resolved.fallback_dns[1] == [
        0,
        10,
        inet_pton(AF_INET6, "2606:4700:4700::1111"),
-    )
+    ]
    assert len(resolved.fallback_dns_ex) == 2
-    assert resolved.fallback_dns_ex[0] == (
+    assert resolved.fallback_dns_ex[0] == [
        0,
        2,
        inet_aton("1.1.1.1"),
        0,
        "cloudflare-dns.com",
-    )
-    assert resolved.fallback_dns_ex[1] == (
+    ]
+    assert resolved.fallback_dns_ex[1] == [
        0,
        10,
        inet_pton(AF_INET6, "2606:4700:4700::1111"),
        0,
        "cloudflare-dns.com",
-    )
+    ]

-    assert resolved.current_dns_server == (0, 2, inet_aton("127.0.0.1"))
-    assert resolved.current_dns_server_ex == (
+    assert resolved.current_dns_server == [0, 2, inet_aton("127.0.0.1")]
+    assert resolved.current_dns_server_ex == [
        0,
        2,
        inet_aton("127.0.0.1"),
        0,
        "",
-    )
+    ]

    assert len(resolved.domains) == 1
-    assert resolved.domains[0] == (0, "local.hass.io", False)
+    assert resolved.domains[0] == [0, "local.hass.io", False]

-    assert resolved.transaction_statistics == (0, 100000)
-    assert resolved.cache_statistics == (10, 50000, 10000)
+    assert resolved.transaction_statistics == [0, 100000]
+    assert resolved.cache_statistics == [10, 50000, 10000]
    assert resolved.dnssec == DNSSECValidation.NO
-    assert resolved.dnssec_statistics == (0, 0, 0, 0)
+    assert resolved.dnssec_statistics == [0, 0, 0, 0]
    assert resolved.dnssec_supported is False
    assert resolved.dnssec_negative_trust_anchors == [
        "168.192.in-addr.arpa",
--- a/tests/dbus/test_systemd.py
+++ b/tests/dbus/test_systemd.py
@@ -185,10 +185,10 @@ async def test_start_transient_unit(
            "tmp-test.mount",
            "fail",
            [
-                ("Description", Variant("s", "Test")),
-                ("What", Variant("s", "//homeassistant/config")),
-                ("Type", Variant("s", "cifs")),
-                ("Options", Variant("s", "username=homeassistant,password=password")),
+                ["Description", Variant("s", "Test")],
+                ["What", Variant("s", "//homeassistant/config")],
+                ["Type", Variant("s", "cifs")],
+                ["Options", Variant("s", "username=homeassistant,password=password")],
            ],
            [],
        )
--- a/tests/dbus_service_mocks/resolved.py
+++ b/tests/dbus_service_mocks/resolved.py
@@ -45,8 +45,8 @@ class Resolved(DBusServiceMock):
    def DNS(self) -> "a(iiay)":
        """Get DNS."""
        return [
-            (0, 2, bytes([127, 0, 0, 1])),
-            (
+            [0, 2, bytes([127, 0, 0, 1])],
+            [
                0,
                10,
                bytes(
@@ -69,15 +69,15 @@ class Resolved(DBusServiceMock):
                        0x1,
                    ]
                ),
-            ),
+            ],
        ]

    @dbus_property(access=PropertyAccess.READ)
    def DNSEx(self) -> "a(iiayqs)":
        """Get DNSEx."""
        return [
-            (0, 2, bytes([127, 0, 0, 1]), 0, ""),
-            (
+            [0, 2, bytes([127, 0, 0, 1]), 0, ""],
+            [
                0,
                10,
                bytes(
@@ -102,15 +102,15 @@ class Resolved(DBusServiceMock):
                ),
                0,
                "",
-            ),
+            ],
        ]

    @dbus_property(access=PropertyAccess.READ)
    def FallbackDNS(self) -> "a(iiay)":
        """Get FallbackDNS."""
        return [
-            (0, 2, bytes([1, 1, 1, 1])),
-            (
+            [0, 2, bytes([1, 1, 1, 1])],
+            [
                0,
                10,
                bytes(
@@ -133,15 +133,15 @@ class Resolved(DBusServiceMock):
                        0x11,
                    ]
                ),
-            ),
+            ],
        ]

    @dbus_property(access=PropertyAccess.READ)
    def FallbackDNSEx(self) -> "a(iiayqs)":
        """Get FallbackDNSEx."""
        return [
-            (0, 2, bytes([1, 1, 1, 1]), 0, "cloudflare-dns.com"),
-            (
+            [0, 2, bytes([1, 1, 1, 1]), 0, "cloudflare-dns.com"],
+            [
                0,
                10,
                bytes(
@@ -166,33 +166,33 @@ class Resolved(DBusServiceMock):
                ),
                0,
                "cloudflare-dns.com",
-            ),
+            ],
        ]

    @dbus_property(access=PropertyAccess.READ)
    def CurrentDNSServer(self) -> "(iiay)":
        """Get CurrentDNSServer."""
-        return (0, 2, bytes([127, 0, 0, 1]))
+        return [0, 2, bytes([127, 0, 0, 1])]

    @dbus_property(access=PropertyAccess.READ)
    def CurrentDNSServerEx(self) -> "(iiayqs)":
        """Get CurrentDNSServerEx."""
-        return (0, 2, bytes([127, 0, 0, 1]), 0, "")
+        return [0, 2, bytes([127, 0, 0, 1]), 0, ""]

    @dbus_property(access=PropertyAccess.READ)
    def Domains(self) -> "a(isb)":
        """Get Domains."""
-        return [(0, "local.hass.io", False)]
+        return [[0, "local.hass.io", False]]

    @dbus_property(access=PropertyAccess.READ)
    def TransactionStatistics(self) -> "(tt)":
        """Get TransactionStatistics."""
-        return (0, 100000)
+        return [0, 100000]

    @dbus_property(access=PropertyAccess.READ)
    def CacheStatistics(self) -> "(ttt)":
        """Get CacheStatistics."""
-        return (10, 50000, 10000)
+        return [10, 50000, 10000]

    @dbus_property(access=PropertyAccess.READ)
    def DNSSEC(self) -> "s":
@@ -202,7 +202,7 @@ class Resolved(DBusServiceMock):
    @dbus_property(access=PropertyAccess.READ)
    def DNSSECStatistics(self) -> "(tttt)":
        """Get DNSSECStatistics."""
-        return (0, 0, 0, 0)
+        return [0, 0, 0, 0]

    @dbus_property(access=PropertyAccess.READ)
    def DNSSECSupported(self) -> "b":
--- a/tests/docker/test_interface.py
+++ b/tests/docker/test_interface.py
@@ -16,7 +16,7 @@ from supervisor.addons.manager import Addon
 from supervisor.const import BusEvent, CoreState, CpuArch
 from supervisor.coresys import CoreSys
 from supervisor.docker.const import ContainerState
-from supervisor.docker.interface import DOCKER_HUB, DockerInterface
+from supervisor.docker.interface import DockerInterface
 from supervisor.docker.manager import PullLogEntry, PullProgressDetail
 from supervisor.docker.monitor import DockerContainerStateEvent
 from supervisor.exceptions import (
@@ -26,10 +26,7 @@ from supervisor.exceptions import (
    DockerNotFound,
    DockerRequestError,
 )
-from supervisor.homeassistant.const import WSEvent, WSType
-from supervisor.jobs import ChildJobSyncFilter, JobSchedulerOptions, SupervisorJob
-from supervisor.jobs.decorator import Job
-from supervisor.supervisor import Supervisor
+from supervisor.jobs import JobSchedulerOptions, SupervisorJob

 from tests.common import AsyncIterator, load_json_fixture

@@ -54,7 +51,7 @@ async def test_docker_image_platform(
    coresys.docker.images.inspect.return_value = {"Id": "test:1.2.3"}
    await test_docker_interface.install(AwesomeVersion("1.2.3"), "test", arch=cpu_arch)
    coresys.docker.images.pull.assert_called_once_with(
-        "test", tag="1.2.3", platform=platform, auth=None, stream=True
+        "test", tag="1.2.3", platform=platform, stream=True
    )
    coresys.docker.images.inspect.assert_called_once_with("test:1.2.3")

@@ -71,50 +68,12 @@ async def test_docker_image_default_platform(
    ):
        await test_docker_interface.install(AwesomeVersion("1.2.3"), "test")
        coresys.docker.images.pull.assert_called_once_with(
-            "test", tag="1.2.3", platform="linux/386", auth=None, stream=True
+            "test", tag="1.2.3", platform="linux/386", stream=True
        )

    coresys.docker.images.inspect.assert_called_once_with("test:1.2.3")


-@pytest.mark.parametrize(
-    "image,registry_key",
-    [
-        ("homeassistant/amd64-supervisor", DOCKER_HUB),
-        ("ghcr.io/home-assistant/amd64-supervisor", "ghcr.io"),
-    ],
-)
-async def test_private_registry_credentials_passed_to_pull(
-    coresys: CoreSys,
-    test_docker_interface: DockerInterface,
-    image: str,
-    registry_key: str,
-):
-    """Test credentials for private registries are passed to aiodocker pull."""
-    coresys.docker.images.inspect.return_value = {"Id": f"{image}:1.2.3"}
-
-    # Configure registry credentials
-    coresys.docker.config._data["registries"] = {  # pylint: disable=protected-access
-        registry_key: {"username": "testuser", "password": "testpass"}
-    }
-
-    with patch.object(
-        type(coresys.supervisor), "arch", PropertyMock(return_value="amd64")
-    ):
-        await test_docker_interface.install(
-            AwesomeVersion("1.2.3"), image, arch=CpuArch.AMD64
-        )
-
-    # Verify credentials were passed to aiodocker
-    expected_auth = {"username": "testuser", "password": "testpass"}
-    if registry_key != DOCKER_HUB:
-        expected_auth["registry"] = registry_key
-
-    coresys.docker.images.pull.assert_called_once_with(
-        image, tag="1.2.3", platform="linux/amd64", auth=expected_auth, stream=True
-    )
-
-
@pytest.mark.parametrize(
    "attrs,expected",
    [
@@ -317,7 +276,7 @@ async def test_install_fires_progress_events(
        },
        {"status": "Already exists", "progressDetail": {}, "id": "6e771e15690e"},
        {"status": "Pulling fs layer", "progressDetail": {}, "id": "1578b14a573c"},
-        {"status": "Waiting", "progressDetail": {}, "id": "1578b14a573c"},
+        {"status": "Waiting", "progressDetail": {}, "id": "2488d0e401e1"},
        {
            "status": "Downloading",
            "progressDetail": {"current": 1378, "total": 1486},
@@ -360,7 +319,7 @@ async def test_install_fires_progress_events(
    ):
        await test_docker_interface.install(AwesomeVersion("1.2.3"), "test")
        coresys.docker.images.pull.assert_called_once_with(
-            "test", tag="1.2.3", platform="linux/386", auth=None, stream=True
+            "test", tag="1.2.3", platform="linux/386", stream=True
        )
        coresys.docker.images.inspect.assert_called_once_with("test:1.2.3")

@@ -387,7 +346,7 @@ async def test_install_fires_progress_events(
            job_id=ANY,
            status="Waiting",
            progress_detail=PullProgressDetail(),
-            id="1578b14a573c",
+            id="2488d0e401e1",
        ),
        PullLogEntry(
            job_id=ANY,
@@ -541,7 +500,6 @@ async def test_install_raises_on_pull_error(
            "status": "Pulling from home-assistant/odroid-n2-homeassistant",
            "id": "2025.7.2",
        },
-        {"status": "Pulling fs layer", "progressDetail": {}, "id": "1578b14a573c"},
        {
            "status": "Downloading",
            "progressDetail": {"current": 1378, "total": 1486},
@@ -596,39 +554,16 @@ async def test_install_progress_handles_download_restart(
    capture_exception.assert_not_called()


-@pytest.mark.parametrize(
-    "extract_log",
-    [
-        {
-            "status": "Extracting",
-            "progressDetail": {"current": 96, "total": 96},
-            "progress": "[==================================================>]      96B/96B",
-            "id": "02a6e69d8d00",
-        },
-        {
-            "status": "Extracting",
-            "progressDetail": {"current": 1, "units": "s"},
-            "progress": "1 s",
-            "id": "02a6e69d8d00",
-        },
-    ],
-    ids=["normal_extract_log", "containerd_snapshot_extract_log"],
-)
 async def test_install_progress_handles_layers_skipping_download(
    coresys: CoreSys,
    test_docker_interface: DockerInterface,
    capture_exception: Mock,
-    extract_log: dict[str, Any],
 ):
    """Test install handles small layers that skip downloading phase and go directly to download complete.

    Reproduces the real-world scenario from Supervisor issue #6286:
    - Small layer (02a6e69d8d00) completes Download complete at 10:14:08 without ever Downloading
    - Normal layer (3f4a84073184) starts Downloading at 10:14:09 with progress updates
-
-    Under containerd snapshotter this presumably can still occur and Supervisor will have even less info
-    since extract logs don't have a total. Supervisor should generally just ignore these and set progress
-    from the larger images that take all the time.
    """
    coresys.core.set_state(CoreState.RUNNING)

@@ -672,7 +607,12 @@ async def test_install_progress_handles_layers_skipping_download(
        },
        {"status": "Pull complete", "progressDetail": {}, "id": "3f4a84073184"},
        # Small layer finally extracts (10:14:58 in logs)
-        extract_log,
+        {
+            "status": "Extracting",
+            "progressDetail": {"current": 96, "total": 96},
+            "progress": "[==================================================>]      96B/96B",
+            "id": "02a6e69d8d00",
+        },
        {"status": "Pull complete", "progressDetail": {}, "id": "02a6e69d8d00"},
        {"status": "Digest: sha256:test"},
        {"status": "Status: Downloaded newer image for test/image:latest"},
@@ -780,88 +720,3 @@ async def test_missing_total_handled_gracefully(
    await event.wait()

    capture_exception.assert_not_called()
-
-
-async def test_install_progress_containerd_snapshot(
-    coresys: CoreSys, ha_ws_client: AsyncMock
-):
-    """Test install handles docker progress events using containerd snapshotter."""
-    coresys.core.set_state(CoreState.RUNNING)
-
-    class TestDockerInterface(DockerInterface):
-        """Test interface for events."""
-
-        @property
-        def name(self) -> str:
-            """Name of test interface."""
-            return "test_interface"
-
-        @Job(
-            name="mock_docker_interface_install",
-            child_job_syncs=[
-                ChildJobSyncFilter("docker_interface_install", progress_allocation=1.0)
-            ],
-        )
-        async def mock_install(self) -> None:
-            """Mock install."""
-            await super().install(
-                AwesomeVersion("1.2.3"), image="test", arch=CpuArch.I386
-            )
-
-    # Fixture emulates log as received when using containerd snapshotter
-    # Should not error but progress gets choppier once extraction starts
-    logs = load_json_fixture("docker_pull_image_log_containerd_snapshot.json")
-    coresys.docker.images.pull.return_value = AsyncIterator(logs)
-    test_docker_interface = TestDockerInterface(coresys)
-
-    with patch.object(Supervisor, "arch", PropertyMock(return_value="i386")):
-        await test_docker_interface.mock_install()
-        coresys.docker.images.pull.assert_called_once_with(
-            "test", tag="1.2.3", platform="linux/386", auth=None, stream=True
-        )
-        coresys.docker.images.inspect.assert_called_once_with("test:1.2.3")
-
-    await asyncio.sleep(1)
-
-    def job_event(progress: float, done: bool = False):
-        return {
-            "type": WSType.SUPERVISOR_EVENT,
-            "data": {
-                "event": WSEvent.JOB,
-                "data": {
-                    "name": "mock_docker_interface_install",
-                    "reference": "test_interface",
-                    "uuid": ANY,
-                    "progress": progress,
-                    "stage": None,
-                    "done": done,
-                    "parent_id": None,
-                    "errors": [],
-                    "created": ANY,
-                    "extra": None,
-                },
-            },
-        }
-
-    assert [c.args[0] for c in ha_ws_client.async_send_command.call_args_list] == [
-        # During downloading we get continuous progress updates from download status
-        job_event(0),
-        job_event(3.4),
-        job_event(8.5),
-        job_event(10.2),
-        job_event(15.3),
-        job_event(18.8),
-        job_event(29.0),
-        job_event(35.8),
-        job_event(42.6),
-        job_event(49.5),
-        job_event(56.0),
-        job_event(62.8),
-        # Downloading phase is considered 70% of total. After we only get one update
-        # per image downloaded when extraction is finished. It uses the total size
-        # received during downloading to determine percent complete then.
-        job_event(70.0),
-        job_event(84.8),
-        job_event(100),
-        job_event(100, True),
-    ]
--- a/tests/fixtures/docker_pull_image_log_containerd_snapshot.json
+++ b/tests/fixtures/docker_pull_image_log_containerd_snapshot.json
@@ -1,196 +0,0 @@
-[
-  {
-    "status": "Pulling from home-assistant/home-assistant",
-    "id": "2025.12.0.dev202511080235"
-  },
-  { "status": "Pulling fs layer", "progressDetail": {}, "id": "eafecc6b43cc" },
-  { "status": "Pulling fs layer", "progressDetail": {}, "id": "333270549f95" },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 1048576, "total": 21863319 },
-    "progress": "[==\u003e                                                ]  1.049MB/21.86MB",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 1048576, "total": 21179924 },
-    "progress": "[==\u003e                                                ]  1.049MB/21.18MB",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 4194304, "total": 21863319 },
-    "progress": "[=========\u003e                                         ]  4.194MB/21.86MB",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 2097152, "total": 21179924 },
-    "progress": "[====\u003e                                              ]  2.097MB/21.18MB",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 7340032, "total": 21863319 },
-    "progress": "[================\u003e                                  ]   7.34MB/21.86MB",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 4194304, "total": 21179924 },
-    "progress": "[=========\u003e                                         ]  4.194MB/21.18MB",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 13631488, "total": 21863319 },
-    "progress": "[===============================\u003e                   ]  13.63MB/21.86MB",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 8388608, "total": 21179924 },
-    "progress": "[===================\u003e                               ]  8.389MB/21.18MB",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 17825792, "total": 21863319 },
-    "progress": "[========================================\u003e          ]  17.83MB/21.86MB",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 12582912, "total": 21179924 },
-    "progress": "[=============================\u003e                     ]  12.58MB/21.18MB",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 21863319, "total": 21863319 },
-    "progress": "[==================================================\u003e]  21.86MB/21.86MB",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 16777216, "total": 21179924 },
-    "progress": "[=======================================\u003e           ]  16.78MB/21.18MB",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Downloading",
-    "progressDetail": { "current": 21179924, "total": 21179924 },
-    "progress": "[==================================================\u003e]  21.18MB/21.18MB",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Download complete",
-    "progressDetail": { "hidecounts": true },
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Download complete",
-    "progressDetail": { "hidecounts": true },
-    "id": "333270549f95"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 1, "units": "s" },
-    "progress": "1 s",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 1, "units": "s" },
-    "progress": "1 s",
-    "id": "333270549f95"
-  },
-  {
-    "status": "Pull complete",
-    "progressDetail": { "hidecounts": true },
-    "id": "333270549f95"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 1, "units": "s" },
-    "progress": "1 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 1, "units": "s" },
-    "progress": "1 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 2, "units": "s" },
-    "progress": "2 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 2, "units": "s" },
-    "progress": "2 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 3, "units": "s" },
-    "progress": "3 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 3, "units": "s" },
-    "progress": "3 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 4, "units": "s" },
-    "progress": "4 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 4, "units": "s" },
-    "progress": "4 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 5, "units": "s" },
-    "progress": "5 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 5, "units": "s" },
-    "progress": "5 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 6, "units": "s" },
-    "progress": "6 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Extracting",
-    "progressDetail": { "current": 6, "units": "s" },
-    "progress": "6 s",
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Pull complete",
-    "progressDetail": { "hidecounts": true },
-    "id": "eafecc6b43cc"
-  },
-  {
-    "status": "Digest: sha256:bfc9efc13552c0c228f3d9d35987331cce68b43c9bc79c80a57eeadadd44cccf"
-  },
-  {
-    "status": "Status: Downloaded newer image for ghcr.io/home-assistant/home-assistant:2025.12.0.dev202511080235"
-  }
-]
--- a/tests/homeassistant/test_core.py
+++ b/tests/homeassistant/test_core.py
@@ -477,7 +477,6 @@ async def test_core_loads_wrong_image_for_machine(
            "ghcr.io/home-assistant/qemux86-64-homeassistant",
            "2024.4.0",
            platform="linux/amd64",
-            auth=None,
        )

    container.remove.assert_called_once_with(force=True, v=True)
@@ -536,7 +535,6 @@ async def test_core_loads_wrong_image_for_architecture(
            "ghcr.io/home-assistant/qemux86-64-homeassistant",
            "2024.4.0",
            platform="linux/amd64",
-            auth=None,
        )

    container.remove.assert_called_once_with(force=True, v=True)
--- a/tests/jobs/test_job_manager.py
+++ b/tests/jobs/test_job_manager.py
@@ -200,6 +200,8 @@ async def test_notify_on_change(coresys: CoreSys, ha_ws_client: AsyncMock):
                                "type": "HassioError",
                                "message": "Unknown error, see Supervisor logs (check with 'ha supervisor logs')",
                                "stage": "test",
+                                "error_key": None,
+                                "extra_fields": None,
                            }
                        ],
                        "created": ANY,
@@ -228,6 +230,8 @@ async def test_notify_on_change(coresys: CoreSys, ha_ws_client: AsyncMock):
                            "type": "HassioError",
                            "message": "Unknown error, see Supervisor logs (check with 'ha supervisor logs')",
                            "stage": "test",
+                            "error_key": None,
+                            "extra_fields": None,
                        }
                    ],
                    "created": ANY,
--- a/tests/mounts/test_manager.py
+++ b/tests/mounts/test_manager.py
@@ -119,10 +119,10 @@ async def test_load(
                "mnt-data-supervisor-mounts-backup_test.mount",
                "fail",
                [
-                    ("Options", Variant("s", "noserverino,guest")),
-                    ("Type", Variant("s", "cifs")),
-                    ("Description", Variant("s", "Supervisor cifs mount: backup_test")),
-                    ("What", Variant("s", "//backup.local/backups")),
+                    ["Options", Variant("s", "noserverino,guest")],
+                    ["Type", Variant("s", "cifs")],
+                    ["Description", Variant("s", "Supervisor cifs mount: backup_test")],
+                    ["What", Variant("s", "//backup.local/backups")],
                ],
                [],
            ),
@@ -130,10 +130,10 @@ async def test_load(
                "mnt-data-supervisor-mounts-media_test.mount",
                "fail",
                [
-                    ("Options", Variant("s", "soft,timeo=200")),
-                    ("Type", Variant("s", "nfs")),
-                    ("Description", Variant("s", "Supervisor nfs mount: media_test")),
-                    ("What", Variant("s", "media.local:/media")),
+                    ["Options", Variant("s", "soft,timeo=200")],
+                    ["Type", Variant("s", "nfs")],
+                    ["Description", Variant("s", "Supervisor nfs mount: media_test")],
+                    ["What", Variant("s", "media.local:/media")],
                ],
                [],
            ),
@@ -141,12 +141,12 @@ async def test_load(
                "mnt-data-supervisor-media-media_test.mount",
                "fail",
                [
-                    ("Options", Variant("s", "bind")),
-                    (
+                    ["Options", Variant("s", "bind")],
+                    [
                        "Description",
                        Variant("s", "Supervisor bind mount: bind_media_test"),
-                    ),
-                    ("What", Variant("s", "/mnt/data/supervisor/mounts/media_test")),
+                    ],
+                    ["What", Variant("s", "/mnt/data/supervisor/mounts/media_test")],
                ],
                [],
            ),
@@ -198,10 +198,10 @@ async def test_load_share_mount(
            "mnt-data-supervisor-mounts-share_test.mount",
            "fail",
            [
-                ("Options", Variant("s", "soft,timeo=200")),
-                ("Type", Variant("s", "nfs")),
-                ("Description", Variant("s", "Supervisor nfs mount: share_test")),
-                ("What", Variant("s", "share.local:/share")),
+                ["Options", Variant("s", "soft,timeo=200")],
+                ["Type", Variant("s", "nfs")],
+                ["Description", Variant("s", "Supervisor nfs mount: share_test")],
+                ["What", Variant("s", "share.local:/share")],
            ],
            [],
        ),
@@ -209,9 +209,9 @@ async def test_load_share_mount(
            "mnt-data-supervisor-share-share_test.mount",
            "fail",
            [
-                ("Options", Variant("s", "bind")),
-                ("Description", Variant("s", "Supervisor bind mount: bind_share_test")),
-                ("What", Variant("s", "/mnt/data/supervisor/mounts/share_test")),
+                ["Options", Variant("s", "bind")],
+                ["Description", Variant("s", "Supervisor bind mount: bind_share_test")],
+                ["What", Variant("s", "/mnt/data/supervisor/mounts/share_test")],
            ],
            [],
        ),
@@ -318,12 +318,12 @@ async def test_mount_failed_during_load(
        "mnt-data-supervisor-media-media_test.mount",
        "fail",
        [
-            ("Options", Variant("s", "ro,bind")),
-            (
+            ["Options", Variant("s", "ro,bind")],
+            [
                "Description",
                Variant("s", "Supervisor bind mount: emergency_media_test"),
-            ),
-            ("What", Variant("s", "/mnt/data/supervisor/emergency/media_test")),
+            ],
+            ["What", Variant("s", "/mnt/data/supervisor/emergency/media_test")],
        ],
        [],
    )
@@ -634,10 +634,10 @@ async def test_reload_mounts_attempts_initial_mount(
            "mnt-data-supervisor-mounts-media_test.mount",
            "fail",
            [
-                ("Options", Variant("s", "soft,timeo=200")),
-                ("Type", Variant("s", "nfs")),
-                ("Description", Variant("s", "Supervisor nfs mount: media_test")),
-                ("What", Variant("s", "media.local:/media")),
+                ["Options", Variant("s", "soft,timeo=200")],
+                ["Type", Variant("s", "nfs")],
+                ["Description", Variant("s", "Supervisor nfs mount: media_test")],
+                ["What", Variant("s", "media.local:/media")],
            ],
            [],
        ),
@@ -645,9 +645,9 @@ async def test_reload_mounts_attempts_initial_mount(
            "mnt-data-supervisor-media-media_test.mount",
            "fail",
            [
-                ("Options", Variant("s", "bind")),
-                ("Description", Variant("s", "Supervisor bind mount: bind_media_test")),
-                ("What", Variant("s", "/mnt/data/supervisor/mounts/media_test")),
+                ["Options", Variant("s", "bind")],
+                ["Description", Variant("s", "Supervisor bind mount: bind_media_test")],
+                ["What", Variant("s", "/mnt/data/supervisor/mounts/media_test")],
            ],
            [],
        ),
--- a/tests/mounts/test_mount.py
+++ b/tests/mounts/test_mount.py
@@ -105,7 +105,7 @@ async def test_cifs_mount(
            "mnt-data-supervisor-mounts-test.mount",
            "fail",
            [
-                (
+                [
                    "Options",
                    Variant(
                        "s",
@@ -117,10 +117,10 @@ async def test_cifs_mount(
                            ]
                        ),
                    ),
-                ),
-                ("Type", Variant("s", "cifs")),
-                ("Description", Variant("s", "Supervisor cifs mount: test")),
-                ("What", Variant("s", "//test.local/camera")),
+                ],
+                ["Type", Variant("s", "cifs")],
+                ["Description", Variant("s", "Supervisor cifs mount: test")],
+                ["What", Variant("s", "//test.local/camera")],
            ],
            [],
        )
@@ -177,10 +177,10 @@ async def test_cifs_mount_read_only(
            "mnt-data-supervisor-mounts-test.mount",
            "fail",
            [
-                ("Options", Variant("s", "ro,noserverino,guest")),
-                ("Type", Variant("s", "cifs")),
-                ("Description", Variant("s", "Supervisor cifs mount: test")),
-                ("What", Variant("s", "//test.local/camera")),
+                ["Options", Variant("s", "ro,noserverino,guest")],
+                ["Type", Variant("s", "cifs")],
+                ["Description", Variant("s", "Supervisor cifs mount: test")],
+                ["What", Variant("s", "//test.local/camera")],
            ],
            [],
        )
@@ -237,10 +237,10 @@ async def test_nfs_mount(
            "mnt-data-supervisor-mounts-test.mount",
            "fail",
            [
-                ("Options", Variant("s", "port=1234,soft,timeo=200")),
-                ("Type", Variant("s", "nfs")),
-                ("Description", Variant("s", "Supervisor nfs mount: test")),
-                ("What", Variant("s", "test.local:/media/camera")),
+                ["Options", Variant("s", "port=1234,soft,timeo=200")],
+                ["Type", Variant("s", "nfs")],
+                ["Description", Variant("s", "Supervisor nfs mount: test")],
+                ["What", Variant("s", "test.local:/media/camera")],
            ],
            [],
        )
@@ -283,10 +283,10 @@ async def test_nfs_mount_read_only(
            "mnt-data-supervisor-mounts-test.mount",
            "fail",
            [
-                ("Options", Variant("s", "ro,port=1234,soft,timeo=200")),
-                ("Type", Variant("s", "nfs")),
-                ("Description", Variant("s", "Supervisor nfs mount: test")),
-                ("What", Variant("s", "test.local:/media/camera")),
+                ["Options", Variant("s", "ro,port=1234,soft,timeo=200")],
+                ["Type", Variant("s", "nfs")],
+                ["Description", Variant("s", "Supervisor nfs mount: test")],
+                ["What", Variant("s", "test.local:/media/camera")],
            ],
            [],
        )
@@ -331,10 +331,10 @@ async def test_load(
            "mnt-data-supervisor-mounts-test.mount",
            "fail",
            [
-                ("Options", Variant("s", "noserverino,guest")),
-                ("Type", Variant("s", "cifs")),
-                ("Description", Variant("s", "Supervisor cifs mount: test")),
-                ("What", Variant("s", "//test.local/share")),
+                ["Options", Variant("s", "noserverino,guest")],
+                ["Type", Variant("s", "cifs")],
+                ["Description", Variant("s", "Supervisor cifs mount: test")],
+                ["What", Variant("s", "//test.local/share")],
            ],
            [],
        )
@@ -736,10 +736,10 @@ async def test_mount_fails_if_down(
            "mnt-data-supervisor-mounts-test.mount",
            "fail",
            [
-                ("Options", Variant("s", "port=1234,soft,timeo=200")),
-                ("Type", Variant("s", "nfs")),
-                ("Description", Variant("s", "Supervisor nfs mount: test")),
-                ("What", Variant("s", "test.local:/media/camera")),
+                ["Options", Variant("s", "port=1234,soft,timeo=200")],
+                ["Type", Variant("s", "nfs")],
+                ["Description", Variant("s", "Supervisor nfs mount: test")],
+                ["What", Variant("s", "test.local:/media/camera")],
            ],
            [],
        )
--- a/tests/plugins/test_plugin_base.py
+++ b/tests/plugins/test_plugin_base.py
@@ -369,7 +369,7 @@ async def test_load_with_incorrect_image(
    with patch.object(DockerAPI, "pull_image", return_value=img_data) as pull_image:
        await plugin.load()
        pull_image.assert_called_once_with(
-            ANY, correct_image, "2024.4.0", platform="linux/amd64", auth=None
+            ANY, correct_image, "2024.4.0", platform="linux/amd64"
        )

    container.remove.assert_called_once_with(force=True, v=True)
--- a/tests/resolution/evaluation/test_evaluate_operating_system.py
+++ b/tests/resolution/evaluation/test_evaluate_operating_system.py
@@ -5,7 +5,10 @@ from unittest.mock import MagicMock, patch

 from supervisor.const import CoreState
 from supervisor.coresys import CoreSys
-from supervisor.resolution.evaluations.operating_system import EvaluateOperatingSystem
+from supervisor.resolution.evaluations.operating_system import (
+    SUPPORTED_OS,
+    EvaluateOperatingSystem,
+)


 async def test_evaluation(coresys: CoreSys):
@@ -22,7 +25,13 @@ async def test_evaluation(coresys: CoreSys):
    assert operating_system.reason in coresys.resolution.unsupported

    coresys.os._available = True
-    assert coresys.os.available
+    await operating_system()
+    assert operating_system.reason not in coresys.resolution.unsupported
+    coresys.os._available = False
+
+    coresys.host._info = MagicMock(
+        operating_system=SUPPORTED_OS[0], timezone=None, timezone_tzinfo=None
+    )
    await operating_system()
    assert operating_system.reason not in coresys.resolution.unsupported
Author	SHA1	Message	Date
Mike Degatano	5781b8c35c	Add defined error for when build fails	2025-11-21 19:11:26 +00:00
Mike Degatano	9be1ad4fb9	Fix stats test and add more for known errors	2025-11-21 18:40:55 +00:00
Mike Degatano	9ae4322313	Fix docker ratelimit exception and tests	2025-11-21 18:40:54 +00:00
Mike Degatano	240dce1e29	Remove customized unknown error types	2025-11-21 18:40:53 +00:00
Mike Degatano	52feac110c	Remove unknown errors from addons	2025-11-21 18:40:52 +00:00