Merge pull request #1704 from home-assistant/dev

Fix panel
2025-08-13 11:09:21 +00:00 · 2020-05-07 19:15:59 +02:00 · 2020-05-07 17:14:52 +00:00 · 2020-05-07 19:02:31 +02:00 · 2020-05-07 17:41:10 +02:00 · 2020-05-07 17:04:08 +02:00
531 changed files with 108263 additions and 1638 deletions
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -33,6 +33,14 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
        containerd.io \
    && rm -rf /var/lib/apt/lists/*

+# Install tools
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        jq \
+        dbus \
+        network-manager \
+        libpulse0 \
+    && rm -rf /var/lib/apt/lists/*
+
 # Install Python dependencies from requirements.txt if it exists
 COPY requirements.txt requirements_tests.txt ./
 RUN pip3 install -r requirements.txt -r requirements_tests.txt \
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,31 +1,24 @@
 // See https://aka.ms/vscode-remote/devcontainer.json for format details.
 {
-	"name": "Hass.io dev",
-	"context": "..",
-	"dockerFile": "Dockerfile",
-	"appPort": "9123:8123",
-	"runArgs": [
-		"-e",
-		"GIT_EDITOR=code --wait",
-		"--privileged"
-	],
-	"extensions": [
-		"ms-python.python",
-		"visualstudioexptteam.vscodeintellicode",
-		"esbenp.prettier-vscode"
-	],
-	"settings": {
-		"python.pythonPath": "/usr/local/bin/python",
-		"python.linting.pylintEnabled": true,
-		"python.linting.enabled": true,
-		"python.formatting.provider": "black",
-		"python.formatting.blackArgs": [
-			"--target-version",
-			"py37"
-		],
-		"editor.formatOnPaste": false,
-		"editor.formatOnSave": true,
-		"editor.formatOnType": true,
-		"files.trimTrailingWhitespace": true
-	}
-}
+  "name": "Supervisor dev",
+  "context": "..",
+  "dockerFile": "Dockerfile",
+  "appPort": "9123:8123",
+  "runArgs": ["-e", "GIT_EDITOR=code --wait", "--privileged"],
+  "extensions": [
+    "ms-python.python",
+    "visualstudioexptteam.vscodeintellicode",
+    "esbenp.prettier-vscode"
+  ],
+  "settings": {
+    "python.pythonPath": "/usr/local/bin/python",
+    "python.linting.pylintEnabled": true,
+    "python.linting.enabled": true,
+    "python.formatting.provider": "black",
+    "python.formatting.blackArgs": ["--target-version", "py37"],
+    "editor.formatOnPaste": false,
+    "editor.formatOnSave": true,
+    "editor.formatOnType": true,
+    "files.trimTrailingWhitespace": true
+  }
+}
--- a/.dockerignore
+++ b/.dockerignore
@@ -14,10 +14,10 @@
 # virtualenv
 venv/

-# HA
-home-assistant-polymer/*
-misc/*
-script/*
+# Data
+home-assistant-polymer/
+script/
+tests/

 # Test ENV
 data/
--- a/.gitignore
+++ b/.gitignore
@@ -95,3 +95,4 @@ ENV/
 .vscode/*
 !.vscode/cSpell.json
 !.vscode/tasks.json
+!.vscode/launch.json
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -0,0 +1,18 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Supervisor remote debug",
+      "type": "python",
+      "request": "attach",
+      "port": 33333,
+      "host": "172.30.32.2",
+      "pathMappings": [
+        {
+          "localRoot": "${workspaceFolder}",
+          "remoteRoot": "/usr/src/supervisor"
+        }
+      ]
+    }
+  ]
+}
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -1,92 +1,90 @@
 {
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "Run Testenv",
-            "type": "shell",
-            "command": "./scripts/test_env.sh",
-            "group": {
-                "kind": "test",
-                "isDefault": true,
-            },
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Run Testenv CLI",
-            "type": "shell",
-            "command": "docker run --rm -ti -v /etc/machine-id:/etc/machine-id --network=hassio --add-host hassio:172.30.32.2 homeassistant/amd64-hassio-cli:dev",
-            "group": {
-                "kind": "test",
-                "isDefault": true,
-            },
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Update UI",
-            "type": "shell",
-            "command": "./scripts/update-frontend.sh",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Pytest",
-            "type": "shell",
-            "command": "pytest --timeout=10 tests",
-            "group": {
-                "kind": "test",
-                "isDefault": true,
-            },
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Flake8",
-            "type": "shell",
-            "command": "flake8 hassio tests",
-            "group": {
-                "kind": "test",
-                "isDefault": true,
-            },
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Pylint",
-            "type": "shell",
-            "command": "pylint hassio",
-            "dependsOn": [
-                "Install all Requirements"
-            ],
-            "group": {
-                "kind": "test",
-                "isDefault": true,
-            },
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": []
-        }
-    ]
-}
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Run Testenv",
+      "type": "shell",
+      "command": "./scripts/test_env.sh",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Run Testenv CLI",
+      "type": "shell",
+      "command": "docker exec -ti hassio_cli /usr/bin/cli.sh",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Update UI",
+      "type": "shell",
+      "command": "./scripts/update-frontend.sh",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Pytest",
+      "type": "shell",
+      "command": "pytest --timeout=10 tests",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Flake8",
+      "type": "shell",
+      "command": "flake8 hassio tests",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Pylint",
+      "type": "shell",
+      "command": "pylint hassio",
+      "dependsOn": ["Install all Requirements"],
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    }
+  ]
+}
--- a/API.md
+++ b/API.md
@@ -2,7 +2,8 @@

 ## Supervisor RESTful API

-Interface for Home Assistant to control things from supervisor.
+The RESTful API for Home Assistant allows you to control things around
+around the Supervisor and other components.

 On error / Code 400:

@@ -22,8 +23,10 @@ On success / Code 200:
 }
 ```

-For access to API you need use a authorization header with a `Bearer` token.
-They are available for Add-ons and the Home Assistant using the `SUPERVISOR_TOKEN` environment variable.
+To access the API you need use an authorization header with a `Bearer` token.
+
+The token is available for add-ons and Home Assistant using the 
+`SUPERVISOR_TOKEN` environment variable.

 ### Supervisor

@@ -33,12 +36,12 @@ This API call don't need a token.

 - GET `/supervisor/info`

-The addons from `addons` are only installed one.
+Shows the installed add-ons from `addons`.

 ```json
 {
  "version": "INSTALL_VERSION",
-  "last_version": "LAST_VERSION",
+  "version_latest": "version_latest",
  "arch": "armhf|aarch64|i386|amd64",
  "channel": "stable|beta|dev",
  "timezone": "TIMEZONE",
@@ -90,11 +93,11 @@ Optional:

 - POST `/supervisor/reload`

-Reload addons/version.
+Reload the add-ons/version.

 - GET `/supervisor/logs`

-Output is the raw docker log.
+Output is the raw Docker log.

 - GET `/supervisor/stats`

@@ -113,7 +116,7 @@ Output is the raw docker log.

 - GET `/supervisor/repair`

-Repair overlayfs issue and restore lost images
+Repair overlayfs issue and restore lost images.

 ### Snapshot

@@ -134,7 +137,6 @@ Repair overlayfs issue and restore lost images
 ```

 - POST `/snapshots/reload`
-
 - POST `/snapshots/new/upload`

 return:
@@ -208,9 +210,7 @@ return:
 ```

 - POST `/snapshots/{slug}/remove`
-
 - GET `/snapshots/{slug}/download`
-
 - POST `/snapshots/{slug}/restore/full`

 ```json
@@ -233,11 +233,8 @@ return:
 ### Host

 - POST `/host/reload`
-
 - POST `/host/shutdown`
-
 - POST `/host/reboot`
-
 - GET `/host/info`

 ```json
@@ -252,6 +249,10 @@ return:
 }
 ```

+- GET `/host/logs`
+
+Return the host log messages (dmesg).
+
 - POST `/host/options`

 ```json
@@ -291,9 +292,7 @@ return:
 ```json
 {
  "version": "2.3",
-  "version_cli": "7",
  "version_latest": "2.4",
-  "version_cli_latest": "8",
  "board": "ova|rpi",
  "boot": "rauc boot slot"
 }
@@ -307,17 +306,9 @@ return:
 }
 ```

- POST `/os/update/cli`
-
-```json
-{
-  "version": "optional"
-}
-```
-
 - POST `/os/config/sync`

-Load host configs from a USB stick.
+Load host configurations from an USB stick.

 ### Hardware

@@ -360,7 +351,7 @@ Load host configs from a USB stick.

 - POST `/hardware/trigger`

-Trigger an udev reload
+Trigger an UDEV reload.

 ### Home Assistant

@@ -369,17 +360,18 @@ Trigger an udev reload
 ```json
 {
  "version": "INSTALL_VERSION",
-  "last_version": "LAST_VERSION",
+  "version_latest": "version_latest",
  "arch": "arch",
  "machine": "Image machine type",
  "ip_address": "ip address",
  "image": "str",
-  "custom": "bool -> if custom image",
  "boot": "bool",
  "port": 8123,
  "ssl": "bool",
  "watchdog": "bool",
-  "wait_boot": 600
+  "wait_boot": 600,
+  "audio_input": "null|profile",
+  "audio_output": "null|profile"
 }
 ```

@@ -408,16 +400,18 @@ Output is the raw Docker log.
 ```json
 {
  "image": "Optional|null",
-  "last_version": "Optional for custom image|null",
+  "version_latest": "Optional for custom image|null",
  "port": "port for access core",
  "ssl": "bool",
  "refresh_token": "",
  "watchdog": "bool",
-  "wait_boot": 600
+  "wait_boot": 600,
+  "audio_input": "null|profile",
+  "audio_output": "null|profile"
 }
 ```

-Image with `null` and last_version with `null` reset this options.
+Image with `null` and `version_latest` with `null` reset this options.

 - POST/GET `/core/api`

@@ -460,7 +454,7 @@ Get all available add-ons.
      "advanced": "bool",
      "stage": "stable|experimental|deprecated",
      "repository": "core|local|REP_ID",
-      "version": "LAST_VERSION",
+      "version": "version_latest",
      "installed": "none|INSTALL_VERSION",
      "detached": "bool",
      "available": "bool",
@@ -504,7 +498,7 @@ Get all available add-ons.
  "homeassistant": "null|min Home Assistant Core version",
  "repository": "12345678|null",
  "version": "null|VERSION_INSTALLED",
-  "last_version": "LAST_VERSION",
+  "version_latest": "version_latest",
  "state": "none|started|stopped",
  "boot": "auto|manual",
  "build": "bool",
@@ -554,13 +548,9 @@ Get all available add-ons.
 ```

 - GET `/addons/{addon}/icon`
-
 - GET `/addons/{addon}/logo`
-
 - GET `/addons/{addon}/changelog`
-
 - GET `/addons/{addon}/documentation`
-
 - POST `/addons/{addon}/options`

 ```json
@@ -577,7 +567,7 @@ Get all available add-ons.
 }
 ```

-Reset custom network/audio/options, set it `null`.
+Reset custom network, audio and options, set it to `null`.

 - POST `/addons/{addon}/security`

@@ -590,28 +580,22 @@ This function is not callable by itself.
 ```

 - POST `/addons/{addon}/start`
-
 - POST `/addons/{addon}/stop`
-
 - POST `/addons/{addon}/install`
-
 - POST `/addons/{addon}/uninstall`
-
 - POST `/addons/{addon}/update`
-
 - GET `/addons/{addon}/logs`

 Output is the raw Docker log.

 - POST `/addons/{addon}/restart`
-
 - POST `/addons/{addon}/rebuild`

-Only supported for local build addons
+Only supported for local build add-ons.

 - POST `/addons/{addon}/stdin`

-Write data to add-on stdin
+Write data to add-on stdin.

 - GET `/addons/{addon}/stats`

@@ -632,7 +616,7 @@ Write data to add-on stdin

 - POST `/ingress/session`

-Create a new Session for access to ingress service.
+Create a new session for access to the ingress service.

 ```json
 {
@@ -659,8 +643,8 @@ Return a list of enabled panels.

 - VIEW `/ingress/{token}`

-Ingress WebUI for this Add-on. The addon need support HASS Auth!
-Need ingress session as cookie.
+Ingress WebUI for this add-on. The add-on need support for the Home Assistant
+authentication system. Needs an ingress session as cookie.

 ### discovery

@@ -810,7 +794,7 @@ return:
 {
  "host": "ip-address",
  "version": "1",
-  "latest_version": "2",
+  "version_latest": "2",
  "servers": ["dns://8.8.8.8"],
  "locals": ["dns://xy"]
 }
@@ -853,18 +837,281 @@ return:
 }
 ```

-### Auth / SSO API
+### CLI

-You can use the user system on homeassistant. We handle this auth system on
-supervisor.
+- GET `/cli/info`

-You can call post `/auth`
+```json
+{
+  "version": "1",
+  "version_latest": "2"
+}
+```
+
+- POST `/cli/update`
+
+```json
+{
+  "version": "VERSION"
+}
+```
+
+- GET `/cli/stats`
+
+```json
+{
+  "cpu_percent": 0.0,
+  "memory_usage": 283123,
+  "memory_limit": 329392,
+  "memory_percent": 1.4,
+  "network_tx": 0,
+  "network_rx": 0,
+  "blk_read": 0,
+  "blk_write": 0
+}
+```
+
+### Multicast
+
+- GET `/multicast/info`
+
+```json
+{
+  "version": "1",
+  "version_latest": "2"
+}
+```
+
+- POST `/multicast/update`
+
+```json
+{
+  "version": "VERSION"
+}
+```
+
+- POST `/multicast/restart`
+
+- GET `/multicast/logs`
+
+- GET `/multicast/stats`
+
+```json
+{
+  "cpu_percent": 0.0,
+  "memory_usage": 283123,
+  "memory_limit": 329392,
+  "memory_percent": 1.4,
+  "network_tx": 0,
+  "network_rx": 0,
+  "blk_read": 0,
+  "blk_write": 0
+}
+```
+
+### Audio
+
+- GET `/audio/info`
+
+```json
+{
+  "host": "ip-address",
+  "version": "1",
+  "latest_version": "2",
+  "audio": {
+    "card": [
+      {
+        "name": "...",
+        "index": 1,
+        "driver": "...",
+        "profiles": [
+          {
+            "name": "...",
+            "description": "...",
+            "active": false
+          }
+        ]
+      }
+    ],
+    "input": [
+      {
+        "name": "...",
+        "index": 0,
+        "description": "...",
+        "volume": 0.3,
+        "mute": false,
+        "default": false,
+        "card": "null|int",
+        "applications": [
+          {
+            "name": "...",
+            "index": 0,
+            "stream_index": 0,
+            "stream_type": "INPUT",
+            "volume": 0.3,
+            "mute": false,
+            "addon": ""
+          }
+        ]
+      }
+    ],
+    "output": [
+      {
+        "name": "...",
+        "index": 0,
+        "description": "...",
+        "volume": 0.3,
+        "mute": false,
+        "default": false,
+        "card": "null|int",
+        "applications": [
+          {
+            "name": "...",
+            "index": 0,
+            "stream_index": 0,
+            "stream_type": "OUTPUT",
+            "volume": 0.3,
+            "mute": false,
+            "addon": ""
+          }
+        ]
+      }
+    ],
+    "application": [
+      {
+        "name": "...",
+        "index": 0,
+        "stream_index": 0,
+        "stream_type": "OUTPUT",
+        "volume": 0.3,
+        "mute": false,
+        "addon": ""
+      }
+    ]
+  }
+}
+```
+
+- POST `/audio/update`
+
+```json
+{
+  "version": "VERSION"
+}
+```
+
+- POST `/audio/restart`
+
+- POST `/audio/reload`
+
+- GET `/audio/logs`
+
+- POST `/audio/volume/input`
+
+```json
+{
+  "index": "...",
+  "volume": 0.5
+}
+```
+
+- POST `/audio/volume/output`
+
+```json
+{
+  "index": "...",
+  "volume": 0.5
+}
+```
+
+- POST `/audio/volume/{output|input}/application`
+
+```json
+{
+  "index": "...",
+  "volume": 0.5
+}
+```
+
+- POST `/audio/mute/input`
+
+```json
+{
+  "index": "...",
+  "active": false
+}
+```
+
+- POST `/audio/mute/output`
+
+```json
+{
+  "index": "...",
+  "active": false
+}
+```
+
+- POST `/audio/mute/{output|input}/application`
+
+```json
+{
+  "index": "...",
+  "active": false
+}
+```
+
+- POST `/audio/default/input`
+
+```json
+{
+  "name": "..."
+}
+```
+
+- POST `/audio/default/output`
+
+```json
+{
+  "name": "..."
+}
+```
+
+- POST `/audio/profile`
+
+```json
+{
+  "card": "...",
+  "name": "..."
+}
+```
+
+- GET `/audio/stats`
+
+```json
+{
+  "cpu_percent": 0.0,
+  "memory_usage": 283123,
+  "memory_limit": 329392,
+  "memory_percent": 1.4,
+  "network_tx": 0,
+  "network_rx": 0,
+  "blk_read": 0,
+  "blk_write": 0
+}
+```
+
+### Authentication/SSO API
+
+You can use the user system from Home Assistant. The auth system can be handled
+with the Supervisor.
+
+`/auth` is accepting POST calls.

 We support:

- Json `{ "user|name": "...", "password": "..." }`
- application/x-www-form-urlencoded `user|name=...&password=...`
- BasicAuth
+- JSON: `{ "user|name": "...", "password": "..." }`
+- `application/x-www-form-urlencoded`: `user|name=...&password=...`
+- Basic Authentication

 * POST `/auth/reset`

--- a/41
+++ b/41
@@ -1,37 +1,40 @@
 ARG BUILD_FROM
 FROM $BUILD_FROM

+ENV \
+    S6_SERVICES_GRACETIME=10000
+
 # Install base
-RUN apk add --no-cache \
-    openssl \
-    libffi \
-    musl \
-    git \
-    socat \
-    glib \
-    eudev \
-    eudev-libs
+RUN \
+    apk add --no-cache \
+        eudev \
+        eudev-libs \
+        git \
+        glib \
+        libffi \
+        libpulse \
+        musl \
+        openssl \
+        socat

 ARG BUILD_ARCH
 WORKDIR /usr/src

 # Install requirements
 COPY requirements.txt .
-RUN export MAKEFLAGS="-j$(nproc)" \
+RUN \
+    export MAKEFLAGS="-j$(nproc)" \
    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links \
        "https://wheels.home-assistant.io/alpine-$(cut -d '.' -f 1-2 < /etc/alpine-release)/${BUILD_ARCH}/" \
        -r ./requirements.txt \
    && rm -f requirements.txt

-# Install HassIO
-COPY . hassio
-RUN pip3 install --no-cache-dir -e ./hassio \
-    && python3 -m compileall ./hassio/hassio
+# Install Home Assistant Supervisor
+COPY . supervisor
+RUN \
+    pip3 install --no-cache-dir -e ./supervisor \
+    && python3 -m compileall ./supervisor/supervisor


-# Initialize udev daemon, handle CMD
-COPY entry.sh /bin/
-ENTRYPOINT ["/bin/entry.sh"]
-
 WORKDIR /
-CMD [ "python3", "-m", "hassio" ]
+COPY rootfs /
--- a/811
+++ b/811
@@ -1,201 +1,674 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007

-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.

-   1. Definitions.
+                            Preamble

-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.

-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.

-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.

-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.

-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.

-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.

-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.

-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.

-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.

-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
+  The precise terms and conditions for copying, distribution and
+modification follow.

-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
+                       TERMS AND CONDITIONS

-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
+  0. Definitions.

-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
+  "This License" refers to version 3 of the GNU General Public License.

-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.

-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.

-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.

-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
+  A "covered work" means either the unmodified Program or a work based
+on the Program.

-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.

-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.

-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.

-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
+  1. Source Code.

-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.

-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.

-   END OF TERMS AND CONDITIONS
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.

-   APPENDIX: How to apply the Apache License to your work.
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.

-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.

-   Copyright 2017 Pascal Vizeli
+  The Corresponding Source for a work in source code form is that
+same work.

-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
+  2. Basic Permissions.

-       http://www.apache.org/licenses/LICENSE-2.0
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.

-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,3 +1,3 @@
 include LICENSE.md
-graft hassio
+graft supervisor
 recursive-exclude * *.py[co]
--- a/README.md
+++ b/README.md
@@ -1,30 +1,26 @@
-[![Build Status](https://dev.azure.com/home-assistant/Hass.io/_apis/build/status/hassio?branchName=dev)](https://dev.azure.com/home-assistant/Hass.io/_build/latest?definitionId=2&branchName=dev)
-
-# Hass.io
+# Home Assistant Supervisor

 ## First private cloud solution for home automation

-Hass.io is a Docker-based system for managing your Home Assistant installation
-and related applications. The system is controlled via Home Assistant which
-communicates with the Supervisor. The Supervisor provides an API to manage the
-installation. This includes changing network settings or installing
-and updating software.
-
-![](misc/hassio.png?raw=true)
+Home Assistant (former Hass.io) is a container-based system for managing your
+Home Assistant Core installation and related applications. The system is
+controlled via Home Assistant which communicates with the Supervisor. The
+Supervisor provides an API to manage the installation. This includes changing
+network settings or installing and updating software.

 ## Installation

-Installation instructions can be found at <https://home-assistant.io/hassio>.
+Installation instructions can be found at https://home-assistant.io/hassio.

 ## Development

-The development of the supervisor is a bit tricky. Not difficult but tricky.
+The development of the Supervisor is not difficult but tricky.

- You can use the builder to build your supervisor: https://github.com/home-assistant/hassio-builder
- Go into a HassOS device or VM and pull your supervisor.
- Set the developer modus with cli `hassio supervisor options --channel=dev`
+- You can use the builder to create your Supervisor: https://github.com/home-assistant/hassio-builder
+- Access a HassOS device or VM and pull your Supervisor.
+- Set the developer modus with the CLI tool: `ha supervisor options --channel=dev`
 - Tag it as `homeassistant/xy-hassio-supervisor:latest`
- Restart the service like `systemctl restart hassos-supervisor | journalctl -fu hassos-supervisor`
+- Restart the service with `systemctl restart hassos-supervisor | journalctl -fu hassos-supervisor`
 - Test your changes

-Small Bugfix or improvements, make a PR. Significant change makes first an RFC.
+For small bugfixes or improvements, make a PR. For significant changes open a RFC first, please. Thanks.
--- a/azure-pipelines-ci.yml
+++ b/azure-pipelines-ci.yml
@@ -17,6 +17,10 @@ jobs:
    pool:
      vmImage: "ubuntu-latest"
    steps:
+      - script: |
+          sudo apt-get update
+          sudo apt-get install -y libpulse0 libudev1
+        displayName: "Install Host library"
      - task: UsePythonVersion@0
        displayName: "Use Python 3.7"
        inputs:
--- a/azure-pipelines-release.yml
+++ b/azure-pipelines-release.yml
@@ -10,10 +10,8 @@ trigger:
      - "*"
 pr: none
 variables:
-  - name: basePythonTag
-    value: "3.7-alpine3.11"
  - name: versionBuilder
-    value: "6.9"
+    value: "7.0"
  - group: docker

 jobs:
@@ -51,6 +49,5 @@ jobs:
            -v ~/.docker:/root/.docker \
            -v /run/docker.sock:/run/docker.sock:rw -v $(pwd):/data:ro \
            homeassistant/amd64-builder:$(versionBuilder) \
-            --supervisor $(basePythonTag) --version $(Build.SourceBranchName) \
-            --all -t /data --docker-hub homeassistant
+            --generic $(Build.SourceBranchName) --all -t /data
        displayName: "Build Release"
--- a/azure-pipelines-wheels.yml
+++ b/azure-pipelines-wheels.yml
@@ -8,53 +8,19 @@ trigger:
 pr: none
 variables:
  - name: versionWheels
-    value: "1.6-3.7-alpine3.11"
-  - group: wheels
+    value: '1.6.1-3.7-alpine3.11'
+resources:
+  repositories:
+    - repository: azure
+      type: github
+      name: 'home-assistant/ci-azure'
+      endpoint: 'home-assistant'
+

 jobs:
-  - job: "Wheels"
-    timeoutInMinutes: 360
-    pool:
-      vmImage: "ubuntu-latest"
-    strategy:
-      maxParallel: 5
-      matrix:
-        amd64:
-          buildArch: "amd64"
-        i386:
-          buildArch: "i386"
-        armhf:
-          buildArch: "armhf"
-        armv7:
-          buildArch: "armv7"
-        aarch64:
-          buildArch: "aarch64"
-    steps:
-      - script: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends \
-            qemu-user-static \
-            binfmt-support \
-            curl
-
-          sudo mount binfmt_misc -t binfmt_misc /proc/sys/fs/binfmt_misc
-          sudo update-binfmts --enable qemu-arm
-          sudo update-binfmts --enable qemu-aarch64
-        displayName: "Initial cross build"
-      - script: |
-          mkdir -p .ssh
-          echo -e "-----BEGIN RSA PRIVATE KEY-----\n$(wheelsSSH)\n-----END RSA PRIVATE KEY-----" >> .ssh/id_rsa
-          ssh-keyscan -H $(wheelsHost) >> .ssh/known_hosts
-          chmod 600 .ssh/*
-        displayName: "Install ssh key"
-      - script: sudo docker pull homeassistant/$(buildArch)-wheels:$(versionWheels)
-        displayName: "Install wheels builder"
-      - script: |
-          sudo docker run --rm -v $(pwd):/data:ro -v $(pwd)/.ssh:/root/.ssh:rw \
-            homeassistant/$(buildArch)-wheels:$(versionWheels) \
-            --apk "build-base;libffi-dev;openssl-dev" \
-            --index $(wheelsIndex) \
-            --requirement requirements.txt \
-            --upload rsync \
-            --remote wheels@$(wheelsHost):/opt/wheels
-        displayName: "Run wheels build"
+- template: templates/azp-job-wheels.yaml@azure
+  parameters:
+    builderVersion: '$(versionWheels)'
+    builderApk: 'build-base;libffi-dev;openssl-dev'
+    builderPip: 'Cython'
+    wheelsRequirement: 'requirements.txt'
--- a/build.json
+++ b/build.json
@@ -0,0 +1,13 @@
+{
+  "image": "homeassistant/{arch}-hassio-supervisor",
+  "build_from": {
+    "aarch64": "homeassistant/aarch64-base-python:3.7-alpine3.11",
+    "armhf": "homeassistant/armhf-base-python:3.7-alpine3.11",
+    "armv7": "homeassistant/armv7-base-python:3.7-alpine3.11",
+    "amd64": "homeassistant/amd64-base-python:3.7-alpine3.11",
+    "i386": "homeassistant/i386-base-python:3.7-alpine3.11"
+  },
+  "labels": {
+    "io.hass.type": "supervisor"
+  }
+}
--- a/entry.sh
+++ b/entry.sh
@@ -1,13 +0,0 @@
-#!/bin/bash
-set -e
-
-udevd --daemon
-udevadm trigger
-
-if CMD="$(command -v "$1")"; then
-  shift
-  exec "$CMD" "$@"
-else
-  echo "Command not found: $1"
-  exit 1
-fi
--- a/hassio/init.py
+++ b/hassio/init.py
@@ -1 +0,0 @@
-"""Init file for Hass.io."""
--- a/hassio/api/panel/entrypoint.js
+++ b/hassio/api/panel/entrypoint.js
@@ -1,2 +0,0 @@
-!function(e){function n(n){for(var t,o,a=n[0],i=n[1],c=0,d=[];c<a.length;c++)o=a[c],Object.prototype.hasOwnProperty.call(r,o)&&r[o]&&d.push(r[o][0]),r[o]=0;for(t in i)Object.prototype.hasOwnProperty.call(i,t)&&(e[t]=i[t]);for(u&&u(n);d.length;)d.shift()()}var t={},r={6:0};function o(n){if(t[n])return t[n].exports;var r=t[n]={i:n,l:!1,exports:{}};return e[n].call(r.exports,r,r.exports,o),r.l=!0,r.exports}o.e=function(e){var n=[],t=r[e];if(0!==t)if(t)n.push(t[2]);else{var a=new Promise(function(n,o){t=r[e]=[n,o]});n.push(t[2]=a);var i,c=document.createElement("script");c.charset="utf-8",c.timeout=120,o.nc&&c.setAttribute("nonce",o.nc),c.src=function(e){return o.p+"chunk."+{0:"87b1d37fc9b8a6f7e2a6",1:"e46c606dd9100816af4e",2:"92a11ac1b80e0d7839d2",3:"429840c83fad61bc51a8",4:"715824f4764bdbe425b1",5:"9d371c8143226d4eaaee",7:"43e40fd69686ad51301d",8:"0b82745c7bdffe5c1404",9:"990ee58006b248f55d23",10:"4d45ee0a3d852768f97e",11:"b60200a57d6f63941b30",12:"b2dce600432c76a53d8c",13:"8527374a266cecf93aa9",14:"f49e500cf58ea310d452",15:"d4931d72592ad48ba2be"}[e]+".js"}(e);var u=new Error;i=function(n){c.onerror=c.onload=null,clearTimeout(d);var t=r[e];if(0!==t){if(t){var o=n&&("load"===n.type?"missing":n.type),a=n&&n.target&&n.target.src;u.message="Loading chunk "+e+" failed.\n("+o+": "+a+")",u.name="ChunkLoadError",u.type=o,u.request=a,t[1](u)}r[e]=void 0}};var d=setTimeout(function(){i({type:"timeout",target:c})},12e4);c.onerror=c.onload=i,document.head.appendChild(c)}return Promise.all(n)},o.m=e,o.c=t,o.d=function(e,n,t){o.o(e,n)||Object.defineProperty(e,n,{enumerable:!0,get:t})},o.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},o.t=function(e,n){if(1&n&&(e=o(e)),8&n)return e;if(4&n&&"object"==typeof e&&e&&e.__esModule)return e;var t=Object.create(null);if(o.r(t),Object.defineProperty(t,"default",{enumerable:!0,value:e}),2&n&&"string"!=typeof e)for(var r in e)o.d(t,r,function(n){return e[n]}.bind(null,r));return t},o.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return o.d(n,"a",n),n},o.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},o.p="/api/hassio/app/",o.oe=function(e){throw console.error(e),e};var a=self.webpackJsonp=self.webpackJsonp||[],i=a.push.bind(a);a.push=n,a=a.slice();for(var c=0;c<a.length;c++)n(a[c]);var u=i;o(o.s=0)}([function(e,n,t){window.loadES5Adapter().then(function(){t.e(12).then(t.t.bind(null,1,7)),Promise.all([t.e(1),t.e(8)]).then(t.bind(null,3)),Promise.all([t.e(1),t.e(15),t.e(10)]).then(t.bind(null,2))});var r=document.createElement("style");r.innerHTML="\nbody {\n  font-family: Roboto, sans-serif;\n  -moz-osx-font-smoothing: grayscale;\n  -webkit-font-smoothing: antialiased;\n  font-weight: 400;\n  margin: 0;\n  padding: 0;\n  height: 100vh;\n}\n",document.head.appendChild(r)}]);
-//# sourceMappingURL=entrypoint.js.map
--- a/hassio/api/panel/entrypoint.js.gz
+++ b/hassio/api/panel/entrypoint.js.gz
--- a/hassio/api/panel/entrypoint.js.map
+++ b/hassio/api/panel/entrypoint.js.map
--- a/hassio/api/panel/manifest.json
+++ b/hassio/api/panel/manifest.json
@@ -1,43 +0,0 @@
-{
-  "vendors~confirmation~hassio-addon-view.js": "/api/hassio/app/chunk.87b1d37fc9b8a6f7e2a6.js",
-  "vendors~confirmation~hassio-addon-view.js.map": "/api/hassio/app/chunk.87b1d37fc9b8a6f7e2a6.js.map",
-  "vendors~hassio-icons~hassio-main.js": "/api/hassio/app/chunk.e46c606dd9100816af4e.js",
-  "vendors~hassio-icons~hassio-main.js.map": "/api/hassio/app/chunk.e46c606dd9100816af4e.js.map",
-  "codemirror.js": "/api/hassio/app/chunk.92a11ac1b80e0d7839d2.js",
-  "codemirror.js.map": "/api/hassio/app/chunk.92a11ac1b80e0d7839d2.js.map",
-  "confirmation.js": "/api/hassio/app/chunk.429840c83fad61bc51a8.js",
-  "confirmation.js.map": "/api/hassio/app/chunk.429840c83fad61bc51a8.js.map",
-  "dialog-hassio-markdown.js": "/api/hassio/app/chunk.715824f4764bdbe425b1.js",
-  "dialog-hassio-markdown.js.map": "/api/hassio/app/chunk.715824f4764bdbe425b1.js.map",
-  "dialog-hassio-snapshot.js": "/api/hassio/app/chunk.9d371c8143226d4eaaee.js",
-  "dialog-hassio-snapshot.js.map": "/api/hassio/app/chunk.9d371c8143226d4eaaee.js.map",
-  "entrypoint.js": "/api/hassio/app/entrypoint.js",
-  "entrypoint.js.map": "/api/hassio/app/entrypoint.js.map",
-  "hassio-addon-view.js": "/api/hassio/app/chunk.43e40fd69686ad51301d.js",
-  "hassio-addon-view.js.map": "/api/hassio/app/chunk.43e40fd69686ad51301d.js.map",
-  "hassio-icons.js": "/api/hassio/app/chunk.0b82745c7bdffe5c1404.js",
-  "hassio-icons.js.map": "/api/hassio/app/chunk.0b82745c7bdffe5c1404.js.map",
-  "hassio-ingress-view.js": "/api/hassio/app/chunk.990ee58006b248f55d23.js",
-  "hassio-ingress-view.js.map": "/api/hassio/app/chunk.990ee58006b248f55d23.js.map",
-  "hassio-main.js": "/api/hassio/app/chunk.4d45ee0a3d852768f97e.js",
-  "hassio-main.js.map": "/api/hassio/app/chunk.4d45ee0a3d852768f97e.js.map",
-  "mdi-icons.js": "/api/hassio/app/chunk.b60200a57d6f63941b30.js",
-  "mdi-icons.js.map": "/api/hassio/app/chunk.b60200a57d6f63941b30.js.map",
-  "roboto.js": "/api/hassio/app/chunk.b2dce600432c76a53d8c.js",
-  "roboto.js.map": "/api/hassio/app/chunk.b2dce600432c76a53d8c.js.map",
-  "vendors~codemirror.js": "/api/hassio/app/chunk.8527374a266cecf93aa9.js",
-  "vendors~codemirror.js.map": "/api/hassio/app/chunk.8527374a266cecf93aa9.js.map",
-  "vendors~hassio-addon-view.js": "/api/hassio/app/chunk.f49e500cf58ea310d452.js",
-  "vendors~hassio-addon-view.js.map": "/api/hassio/app/chunk.f49e500cf58ea310d452.js.map",
-  "vendors~hassio-main.js": "/api/hassio/app/chunk.d4931d72592ad48ba2be.js",
-  "vendors~hassio-main.js.map": "/api/hassio/app/chunk.d4931d72592ad48ba2be.js.map",
-  "201359fd5a526afe13ef.worker.js": "/api/hassio/app/201359fd5a526afe13ef.worker.js",
-  "201359fd5a526afe13ef.worker.js.map": "/api/hassio/app/201359fd5a526afe13ef.worker.js.map",
-  "chunk.429840c83fad61bc51a8.js.LICENSE": "/api/hassio/app/chunk.429840c83fad61bc51a8.js.LICENSE",
-  "chunk.715824f4764bdbe425b1.js.LICENSE": "/api/hassio/app/chunk.715824f4764bdbe425b1.js.LICENSE",
-  "chunk.87b1d37fc9b8a6f7e2a6.js.LICENSE": "/api/hassio/app/chunk.87b1d37fc9b8a6f7e2a6.js.LICENSE",
-  "chunk.9d371c8143226d4eaaee.js.LICENSE": "/api/hassio/app/chunk.9d371c8143226d4eaaee.js.LICENSE",
-  "chunk.d4931d72592ad48ba2be.js.LICENSE": "/api/hassio/app/chunk.d4931d72592ad48ba2be.js.LICENSE",
-  "chunk.e46c606dd9100816af4e.js.LICENSE": "/api/hassio/app/chunk.e46c606dd9100816af4e.js.LICENSE",
-  "chunk.f49e500cf58ea310d452.js.LICENSE": "/api/hassio/app/chunk.f49e500cf58ea310d452.js.LICENSE"
-}
--- a/hassio/data/asound.tmpl
+++ b/hassio/data/asound.tmpl
@@ -1,17 +0,0 @@
-pcm.!default {
-  type asym
-  capture.pcm "mic"
-  playback.pcm "speaker"
-}
-pcm.mic {
-  type plug
-  slave {
-    pcm "hw:$input"
-  }
-}
-pcm.speaker {
-  type plug
-  slave {
-    pcm "hw:$output"
-  }
-}
--- a/hassio/data/audiodb.json
+++ b/hassio/data/audiodb.json
@@ -1,18 +0,0 @@
-{
-    "raspberrypi3": {
-        "bcm2835 - bcm2835 ALSA": {
-            "0,0": "Raspberry Jack",
-            "0,1": "Raspberry HDMI"
-        },
-        "output": "0,0",
-        "input": null
-    },
-    "raspberrypi2": {
-        "output": "0,0",
-        "input": null
-    },
-    "raspberrypi": {
-        "output": "0,0",
-        "input": null
-    }
-}
--- a/hassio/data/coredns.tmpl
+++ b/hassio/data/coredns.tmpl
@@ -1,15 +0,0 @@
-.:53 {
-    log
-    errors
-    hosts /config/hosts {
-        fallthrough
-    }
-    template ANY AAAA local.hass.io hassio {
-        rcode NOERROR
-    }
-    forward . $servers {
-        except local.hass.io
-        policy sequential
-        health_check 10s
-    }
-}
--- a/hassio/discovery/services/home_panel.py
+++ b/hassio/discovery/services/home_panel.py
@@ -1,11 +0,0 @@
-"""Discovery service for Home Panel."""
-import voluptuous as vol
-
-from hassio.validate import network_port
-
-from ..const import ATTR_HOST, ATTR_PORT
-
-
-SCHEMA = vol.Schema(
-    {vol.Required(ATTR_HOST): vol.Coerce(str), vol.Required(ATTR_PORT): network_port}
-)
--- a/hassio/docker/hassos_cli.py
+++ b/hassio/docker/hassos_cli.py
@@ -1,38 +0,0 @@
-"""HassOS Cli docker object."""
-import logging
-
-import docker
-
-from ..coresys import CoreSysAttributes
-from .interface import DockerInterface
-
-_LOGGER: logging.Logger = logging.getLogger(__name__)
-
-
-class DockerHassOSCli(DockerInterface, CoreSysAttributes):
-    """Docker Hass.io wrapper for HassOS Cli."""
-
-    @property
-    def image(self):
-        """Return name of HassOS CLI image."""
-        return f"homeassistant/{self.sys_arch.supervisor}-hassio-cli"
-
-    def _stop(self, remove_container=True):
-        """Don't need stop."""
-        return True
-
-    def _attach(self, tag: str):
-        """Attach to running Docker container.
-        Need run inside executor.
-        """
-        try:
-            image = self.sys_docker.images.get(f"{self.image}:{tag}")
-
-        except docker.errors.DockerException:
-            _LOGGER.warning("Can't find a HassOS CLI %s", self.image)
-
-        else:
-            self._meta = image.attrs
-            _LOGGER.info(
-                "Found HassOS CLI %s with version %s", self.image, self.version
-            )
--- a/hassio/host/alsa.py
+++ b/hassio/host/alsa.py
@@ -1,138 +0,0 @@
-"""Host Audio support."""
-import logging
-import json
-from pathlib import Path
-from string import Template
-
-import attr
-
-from ..const import ATTR_INPUT, ATTR_OUTPUT, ATTR_DEVICES, ATTR_NAME, CHAN_ID, CHAN_TYPE
-from ..coresys import CoreSysAttributes
-
-_LOGGER: logging.Logger = logging.getLogger(__name__)
-
-
-@attr.s()
-class DefaultConfig:
-    """Default config input/output ALSA channel."""
-
-    input: str = attr.ib()
-    output: str = attr.ib()
-
-
-AUDIODB_JSON: Path = Path(__file__).parents[1].joinpath("data/audiodb.json")
-ASOUND_TMPL: Path = Path(__file__).parents[1].joinpath("data/asound.tmpl")
-
-
-class AlsaAudio(CoreSysAttributes):
-    """Handle Audio ALSA host data."""
-
-    def __init__(self, coresys):
-        """Initialize ALSA audio system."""
-        self.coresys = coresys
-        self._data = {ATTR_INPUT: {}, ATTR_OUTPUT: {}}
-        self._cache = 0
-        self._default = None
-
-    @property
-    def input_devices(self):
-        """Return list of ALSA input devices."""
-        self._update_device()
-        return self._data[ATTR_INPUT]
-
-    @property
-    def output_devices(self):
-        """Return list of ALSA output devices."""
-        self._update_device()
-        return self._data[ATTR_OUTPUT]
-
-    def _update_device(self):
-        """Update Internal device DB."""
-        current_id = hash(frozenset(self.sys_hardware.audio_devices))
-
-        # Need rebuild?
-        if current_id == self._cache:
-            return
-
-        # Clean old stuff
-        self._data[ATTR_INPUT].clear()
-        self._data[ATTR_OUTPUT].clear()
-
-        # Init database
-        _LOGGER.info("Update ALSA device list")
-        database = self._audio_database()
-
-        # Process devices
-        for dev_id, dev_data in self.sys_hardware.audio_devices.items():
-            for chan_info in dev_data[ATTR_DEVICES]:
-                chan_id = chan_info[CHAN_ID]
-                chan_type = chan_info[CHAN_TYPE]
-                alsa_id = f"{dev_id},{chan_id}"
-                dev_name = dev_data[ATTR_NAME]
-
-                # Lookup type
-                if chan_type.endswith("playback"):
-                    key = ATTR_OUTPUT
-                elif chan_type.endswith("capture"):
-                    key = ATTR_INPUT
-                else:
-                    _LOGGER.warning("Unknown channel type: %s", chan_type)
-                    continue
-
-                # Use name from DB or a generic name
-                self._data[key][alsa_id] = (
-                    database.get(self.sys_machine, {})
-                    .get(dev_name, {})
-                    .get(alsa_id, f"{dev_name}: {chan_id}")
-                )
-
-        self._cache = current_id
-
-    @staticmethod
-    def _audio_database():
-        """Read local json audio data into dict."""
-        try:
-            return json.loads(AUDIODB_JSON.read_text())
-        except (ValueError, OSError) as err:
-            _LOGGER.warning("Can't read audio DB: %s", err)
-
-        return {}
-
-    @property
-    def default(self):
-        """Generate ALSA default setting."""
-        # Init defaults
-        if self._default is None:
-            database = self._audio_database()
-            alsa_input = database.get(self.sys_machine, {}).get(ATTR_INPUT)
-            alsa_output = database.get(self.sys_machine, {}).get(ATTR_OUTPUT)
-
-            self._default = DefaultConfig(alsa_input, alsa_output)
-
-        # Search exists/new output
-        if self._default.output is None and self.output_devices:
-            self._default.output = next(iter(self.output_devices))
-            _LOGGER.info("Detect output device %s", self._default.output)
-
-        # Search exists/new input
-        if self._default.input is None and self.input_devices:
-            self._default.input = next(iter(self.input_devices))
-            _LOGGER.info("Detect input device %s", self._default.input)
-
-        return self._default
-
-    def asound(self, alsa_input=None, alsa_output=None):
-        """Generate an asound data."""
-        alsa_input = alsa_input or self.default.input
-        alsa_output = alsa_output or self.default.output
-
-        # Read Template
-        try:
-            asound_data = ASOUND_TMPL.read_text()
-        except OSError as err:
-            _LOGGER.error("Can't read asound.tmpl: %s", err)
-            return ""
-
-        # Process Template
-        asound_template = Template(asound_data)
-        return asound_template.safe_substitute(input=alsa_input, output=alsa_output)
--- a/hassio/misc/init.py
+++ b/hassio/misc/init.py
@@ -1 +0,0 @@
-"""Special object and tools for Hass.io."""
--- a/hassio/updater.py
+++ b/hassio/updater.py
@@ -1,130 +0,0 @@
-"""Fetch last versions from webserver."""
-import asyncio
-from contextlib import suppress
-from datetime import timedelta
-import json
-import logging
-from typing import Optional
-
-import aiohttp
-
-from .const import (
-    ATTR_CHANNEL,
-    ATTR_DNS,
-    ATTR_HASSIO,
-    ATTR_HASSOS,
-    ATTR_HASSOS_CLI,
-    ATTR_HOMEASSISTANT,
-    FILE_HASSIO_UPDATER,
-    URL_HASSIO_VERSION,
-    UpdateChannels,
-)
-from .coresys import CoreSysAttributes
-from .exceptions import HassioUpdaterError
-from .utils import AsyncThrottle
-from .utils.json import JsonConfig
-from .validate import SCHEMA_UPDATER_CONFIG
-
-_LOGGER: logging.Logger = logging.getLogger(__name__)
-
-
-class Updater(JsonConfig, CoreSysAttributes):
-    """Fetch last versions from version.json."""
-
-    def __init__(self, coresys):
-        """Initialize updater."""
-        super().__init__(FILE_HASSIO_UPDATER, SCHEMA_UPDATER_CONFIG)
-        self.coresys = coresys
-
-    async def load(self) -> None:
-        """Update internal data."""
-        with suppress(HassioUpdaterError):
-            await self.fetch_data()
-
-    async def reload(self) -> None:
-        """Update internal data."""
-        with suppress(HassioUpdaterError):
-            await self.fetch_data()
-
-    @property
-    def version_homeassistant(self) -> Optional[str]:
-        """Return latest version of Home Assistant."""
-        return self._data.get(ATTR_HOMEASSISTANT)
-
-    @property
-    def version_hassio(self) -> Optional[str]:
-        """Return latest version of Hass.io."""
-        return self._data.get(ATTR_HASSIO)
-
-    @property
-    def version_hassos(self) -> Optional[str]:
-        """Return latest version of HassOS."""
-        return self._data.get(ATTR_HASSOS)
-
-    @property
-    def version_hassos_cli(self) -> Optional[str]:
-        """Return latest version of HassOS cli."""
-        return self._data.get(ATTR_HASSOS_CLI)
-
-    @property
-    def version_dns(self) -> Optional[str]:
-        """Return latest version of Hass.io DNS."""
-        return self._data.get(ATTR_DNS)
-
-    @property
-    def channel(self) -> UpdateChannels:
-        """Return upstream channel of Hass.io instance."""
-        return self._data[ATTR_CHANNEL]
-
-    @channel.setter
-    def channel(self, value: UpdateChannels):
-        """Set upstream mode."""
-        self._data[ATTR_CHANNEL] = value
-
-    @AsyncThrottle(timedelta(seconds=60))
-    async def fetch_data(self):
-        """Fetch current versions from Github.
-
-        Is a coroutine.
-        """
-        url = URL_HASSIO_VERSION.format(channel=self.channel)
-        machine = self.sys_machine or "default"
-        board = self.sys_hassos.board
-
-        try:
-            _LOGGER.info("Fetch update data from %s", url)
-            async with self.sys_websession.get(url, timeout=10) as request:
-                data = await request.json(content_type=None)
-
-        except (aiohttp.ClientError, asyncio.TimeoutError) as err:
-            _LOGGER.warning("Can't fetch versions from %s: %s", url, err)
-            raise HassioUpdaterError() from None
-
-        except json.JSONDecodeError as err:
-            _LOGGER.warning("Can't parse versions from %s: %s", url, err)
-            raise HassioUpdaterError() from None
-
-        # data valid?
-        if not data or data.get(ATTR_CHANNEL) != self.channel:
-            _LOGGER.warning("Invalid data from %s", url)
-            raise HassioUpdaterError() from None
-
-        try:
-            # update supervisor version
-            self._data[ATTR_HASSIO] = data["supervisor"]
-            self._data[ATTR_DNS] = data["dns"]
-
-            # update Home Assistant version
-            self._data[ATTR_HOMEASSISTANT] = data["homeassistant"][machine]
-
-            # update hassos version
-            if self.sys_hassos.available and board:
-                self._data[ATTR_HASSOS] = data["hassos"][board]
-                self._data[ATTR_HASSOS_CLI] = data["hassos-cli"]
-
-        except KeyError as err:
-            _LOGGER.warning("Can't process version data: %s", err)
-            raise HassioUpdaterError() from None
-
-        else:
-            self.save_data()
--- a/2
+++ b/2
--- a/misc/hassio.png
+++ b/misc/hassio.png
--- a/misc/hassio.xml
+++ b/misc/hassio.xml
@@ -1 +0,0 @@
-<mxfile userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36" version="7.9.5" editor="www.draw.io" type="device"><diagram name="Page-1" id="535f6c39-9b73-04c2-941c-82630de90f1a">5VrLcqM4FP0aLzsFiOcycefRVTPVqfFippdYKLYmMvII4cd8/QiQDEKQ4Bicnmp7Yevqybk691zJnoH55vDI4u36d5ogMnOs5DADX2eOY1vAER+F5VhZ3DCoDCuGE9moNizwv0j1lNYcJyjTGnJKCcdb3QhpmiLINVvMGN3rzV4o0WfdxitkGBYwJqb1T5zwtbTaflRXPCG8WsupQ8evKpYxfF0xmqdyvpkDXspXVb2J1VjyQbN1nNB9wwTuZ2DOKOXVt81hjkiBrYKt6vfQU3taN0MpH9JB+mkXkxypFftEdL17oWIEsUB+lKD4/+RUVXzJSpfdigZitoP4EBUl0KJuL4EpalPKNjGpO4tvq+Lz+0LNI9ZWTVVVSFhOszr7NeZosY1hUd6L7SYarfmGiJJdrAYTMqeEsrK1ABv5EAp7xhl9RY0aq3zJ9S/k+B14SdMOMY4ODZPE7xHRDeLsKJqo2ghUXeRe9yLp2329c1wF9LqxaXzZLpabdXUaunaY+CJ91u0/YPjvW4oLvy2OGUebC9GECVqGyy40gQ8ikJz8NS6AwUAAnREAdA0Av1L4itilyEHkCdJfGznXRM7pQg6MgJxvIPc0N1ArQyEqehTUO5PLIUTdXF6GnutZ42Do+p6OoW9i6FkmhN4IEEYGXigROiSLlPE1XdE0Jve19U5HtIEeOmD+V2G+CTxZ/KGqUrGwqs5TxR9yhL8R50epwHHOqTDVE/9G6VaO0Qt1RnMG5fKlyvOYrRDXtknxYG+6gyESc7zTBfgScFUuMTa6zhvoRiLxaeFbFp4Rw+IBELsS6O5ngR705hPLWuHPSzBsv0gw2gnEIt8itsOZCAlqAqbqnuIs+/a9N8E4mZe9SUe9Dez3w5YRnuZz369SDT2gJR4KE3ecsAU8PWyBjqzDDjvilj2GatrOFNyyG8RSUezELY1XZRgbSqJMMIPfFqcCYYBEbA4MlfkBE7WKQVyz1WmkQbbgs8gGpolwmhd0J7Tkoy62A9xAzIe6EKWJOZgwNobqTPjn80sc64Sfpl0qHjSSKzHKl1vx6ALDIppdJ2LFKHyBYyWresRyOtL8U3DS0nx3jIjlX5kr9o2l5wI3dhhemg8MpFWDLilNkcaVN9NmjRHAZITal9dnhDuJ4kifNZK5kRAe7tC+awqYs92Jzx922Kdpk2veTHzAgRoIvd4832d9InK52zrx/rjrrqE1pqduk4SmmeGvbB1vi69bRiHKsvd1RhelwarzIF6lcleHAMFSy/EDEDnA90InDC0XTJRFd2mSY3umJkUjSJK6vJsypNWltuRcmtTJsNck2Sgn2/FClez6THF50JQuV2ei9rlJjVDRUnZyGjfnZ45TUdkYp9wUp6cZtk9Ck6CQU/OKUvEz35CqAbgrqIChQD5eIvJMM8wxTUWTJeWcbkQDUlTcnX610K7Sy98t6jFuCV4VfTk9j+b1zXv7rl5OMAKRW5d4oOMSD3SklqNcwZs0HkBSK9BY6r7HUtvk6BA6XkXzztTxQYqofkH8KZIZtZgGA/f7vRm9CcHbrHSDZCIkNE8u1smrECjS45lrdZzOgqnuk8DbN+Fyc3/gOHYmRybK5RtaW58Bq0U6vWo7jCauSRO1WydXUre1ZdrRdDwJBP0/01lP+bJXCWHMLqefX7466OcV73HoF4FWOtFFv67r3FEULJiIfc19H4yZZU5P2WHs867BvsFu9AySPGK+npoefeqE7MRDwTT0cNWh9Sr0CH8VcYp8naPBZdrk/xraZP4R4g+0LY5alGHUf4vy/yWfusifgHyiWP/5rXJG/Q9DcP8f</diagram></mxfile>
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,16 +1,18 @@
 aiohttp==3.6.1
 async_timeout==3.0.1
 attrs==19.3.0
-cchardet==2.1.5
+cchardet==2.1.6
 colorlog==4.1.0
 cpe==1.2.1
-cryptography==2.8
+cryptography==2.9.2
 docker==4.2.0
-gitpython==3.0.7
-packaging==20.1
-pytz==2019.3
+gitpython==3.1.2
+jinja2==2.11.2
+packaging==20.3
+ptvsd==4.3.2
+pulsectl==20.4.3
+pytz==2020.1
 pyudev==0.22.0
 ruamel.yaml==0.15.100
 uvloop==0.14.0
 voluptuous==0.11.7
-ptvsd==4.3.2
--- a/requirements_tests.txt
+++ b/requirements_tests.txt
@@ -1,6 +1,6 @@
 flake8==3.7.9
-pylint==2.4.4
-pytest==5.3.5
+pylint==2.5.2
+pytest==5.4.1
 pytest-timeout==1.3.4
 pytest-aiohttp==0.3.0
 black==19.10b0
--- a/rootfs/etc/cont-init.d/udev.sh
+++ b/rootfs/etc/cont-init.d/udev.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Start udev service
+# ==============================================================================
+udevd --daemon
+
+bashio::log.info "Update udev informations"
+udevadm trigger
+udevadm settle
--- a/rootfs/etc/pulse/client.conf
+++ b/rootfs/etc/pulse/client.conf
@@ -0,0 +1,35 @@
+# This file is part of PulseAudio.
+#
+# PulseAudio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# PulseAudio is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
+
+## Configuration file for PulseAudio clients. See pulse-client.conf(5) for
+## more information. Default values are commented out.  Use either ; or # for
+## commenting.
+
+; default-sink =
+; default-source =
+default-server = unix://data/audio/external/pulse.sock
+; default-dbus-server =
+
+autospawn = no
+; daemon-binary = /usr/bin/pulseaudio
+; extra-arguments = --log-target=syslog
+
+; cookie-file =
+
+; enable-shm = yes
+; shm-size-bytes = 0 # setting this 0 will use the system-default, usually 64 MiB
+
+; auto-connect-localhost = no
+; auto-connect-display = no
--- a/rootfs/etc/services.d/supervisor/finish
+++ b/rootfs/etc/services.d/supervisor/finish
@@ -0,0 +1,5 @@
+#!/usr/bin/execlineb -S0
+# ==============================================================================
+# Take down the S6 supervision tree when Supervisor fails
+# ==============================================================================
+s6-svscanctl -t /var/run/s6/services
--- a/rootfs/etc/services.d/supervisor/run
+++ b/rootfs/etc/services.d/supervisor/run
@@ -0,0 +1,7 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Start Service service
+# ==============================================================================
+export LD_PRELOAD="/usr/local/lib/libjemalloc.so.2"
+
+exec python3 -m supervisor
--- a/scripts/test_env.sh
+++ b/scripts/test_env.sh
@@ -61,9 +61,7 @@ function build_supervisor() {
    docker run --rm --privileged \
        -v /run/docker.sock:/run/docker.sock -v "$(pwd):/data" \
        homeassistant/amd64-builder:dev \
-            --supervisor 3.7-alpine3.11 --version dev \
-            -t /data --test --amd64 \
-            --no-cache --docker-hub homeassistant
+            --generic dev -t /data --test --amd64 --no-cache
 }


@@ -79,12 +77,7 @@ function cleanup_lastboot() {

 function cleanup_docker() {
    echo "Cleaning up stopped containers..."
-    docker rm $(docker ps -a -q)
-}
-
-
-function install_cli() {
-    docker pull homeassistant/amd64-hassio-cli:dev
+    docker rm $(docker ps -a -q) || true
 }


@@ -103,19 +96,38 @@ function setup_test_env() {
        -e SUPERVISOR_SHARE="/workspaces/test_supervisor" \
        -e SUPERVISOR_NAME=hassio_supervisor \
        -e SUPERVISOR_DEV=1 \
-        -e HOMEASSISTANT_REPOSITORY="homeassistant/qemux86-64-homeassistant" \
+        -e SUPERVISOR_MACHINE="qemux86-64" \
        homeassistant/amd64-hassio-supervisor:latest

 }

+
+function init_dbus() {
+    if pgrep dbus-daemon; then
+        echo "Dbus is running"
+        return 0
+    fi
+
+    echo "Startup dbus"
+    mkdir -p /var/lib/dbus
+    cp -f /etc/machine-id /var/lib/dbus/machine-id
+
+    # cleanups
+    mkdir -p /run/dbus
+    rm -f /run/dbus/pid
+
+    # run
+    dbus-daemon --system --print-address
+}
+
 echo "Start Test-Env"

 start_docker
 trap "stop_docker" ERR

 build_supervisor
-install_cli
 cleanup_lastboot
 cleanup_docker
+init_dbus
 setup_test_env
 stop_docker
--- a/scripts/update-frontend.sh
+++ b/scripts/update-frontend.sh
@@ -14,5 +14,5 @@ cd hassio
 ./script/build_hassio

 # Copy frontend
-rm -f ../../hassio/api/panel/chunk.*
-cp -rf build/* ../../hassio/api/panel/
+rm -f ../../supervisor/hassio/api/panel/chunk.*
+cp -rf build/* ../../supervisor/api/panel/
--- a/setup.py
+++ b/setup.py
@@ -1,10 +1,11 @@
+"""Home Assistant Supervisor setup."""
 from setuptools import setup

-from hassio.const import HASSIO_VERSION
+from supervisor.const import SUPERVISOR_VERSION

 setup(
-    name="HassIO",
-    version=HASSIO_VERSION,
+    name="Supervisor",
+    version=SUPERVISOR_VERSION,
    license="BSD License",
    author="The Home Assistant Authors",
    author_email="hello@home-assistant.io",
@@ -24,19 +25,20 @@ setup(
        "Topic :: Scientific/Engineering :: Atmospheric Science",
        "Development Status :: 5 - Production/Stable",
        "Intended Audience :: Developers",
-        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
    ],
    keywords=["docker", "home-assistant", "api"],
    zip_safe=False,
    platforms="any",
    packages=[
-        "hassio",
-        "hassio.docker",
-        "hassio.addons",
-        "hassio.api",
-        "hassio.misc",
-        "hassio.utils",
-        "hassio.snapshots",
+        "supervisor",
+        "supervisor.docker",
+        "supervisor.addons",
+        "supervisor.api",
+        "supervisor.misc",
+        "supervisor.utils",
+        "supervisor.plugins",
+        "supervisor.snapshots",
    ],
    include_package_data=True,
 )
--- a/supervisor/init.py
+++ b/supervisor/init.py
@@ -0,0 +1 @@
+"""Init file for Supervisor."""
--- a/supervisor/main.py
+++ b/supervisor/main.py
@@ -1,10 +1,10 @@
-"""Main file for Hass.io."""
+"""Main file for Supervisor."""
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
 import logging
 import sys

-from hassio import bootstrap
+from supervisor import bootstrap

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

@@ -29,35 +29,34 @@ if __name__ == "__main__":
    # Init async event loop
    loop = initialize_event_loop()

-    # Check if all information are available to setup Hass.io
-    if not bootstrap.check_environment():
-        sys.exit(1)
+    # Check if all information are available to setup Supervisor
+    bootstrap.check_environment()

    # init executor pool
    executor = ThreadPoolExecutor(thread_name_prefix="SyncWorker")
    loop.set_default_executor(executor)

-    _LOGGER.info("Initialize Hass.io setup")
+    _LOGGER.info("Initialize Supervisor setup")
    coresys = loop.run_until_complete(bootstrap.initialize_coresys())
    loop.run_until_complete(coresys.core.connect())

    bootstrap.supervisor_debugger(coresys)
    bootstrap.migrate_system_env(coresys)

-    _LOGGER.info("Setup HassIO")
+    _LOGGER.info("Setup Supervisor")
    loop.run_until_complete(coresys.core.setup())

    loop.call_soon_threadsafe(loop.create_task, coresys.core.start())
    loop.call_soon_threadsafe(bootstrap.reg_signal, loop)

    try:
-        _LOGGER.info("Run Hass.io")
+        _LOGGER.info("Run Supervisor")
        loop.run_forever()
    finally:
-        _LOGGER.info("Stopping Hass.io")
+        _LOGGER.info("Stopping Supervisor")
        loop.run_until_complete(coresys.core.stop())
        executor.shutdown(wait=False)
        loop.close()

-    _LOGGER.info("Close Hass.io")
+    _LOGGER.info("Close Supervisor")
    sys.exit(0)
--- a/supervisor/addons/init.py
+++ b/supervisor/addons/init.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io add-ons."""
+"""Init file for Supervisor add-ons."""
 import asyncio
 from contextlib import suppress
 import logging
@@ -25,7 +25,7 @@ AnyAddon = Union[Addon, AddonStore]


 class AddonManager(CoreSysAttributes):
-    """Manage add-ons inside Hass.io."""
+    """Manage add-ons inside Supervisor."""

    def __init__(self, coresys: CoreSys):
        """Initialize Docker base wrapper."""
@@ -57,9 +57,9 @@ class AddonManager(CoreSysAttributes):
        return self.store.get(addon_slug)

    def from_token(self, token: str) -> Optional[Addon]:
-        """Return an add-on from Hass.io token."""
+        """Return an add-on from Supervisor token."""
        for addon in self.installed:
-            if token == addon.hassio_token:
+            if token == addon.supervisor_token:
                return addon
        return None

@@ -152,9 +152,9 @@ class AddonManager(CoreSysAttributes):
        await addon.remove_data()

        # Cleanup audio settings
-        if addon.path_asound.exists():
+        if addon.path_pulse.exists():
            with suppress(OSError):
-                addon.path_asound.unlink()
+                addon.path_pulse.unlink()

        # Cleanup AppArmor profile
        with suppress(HostAppArmorError):
@@ -166,6 +166,9 @@ class AddonManager(CoreSysAttributes):
            with suppress(HomeAssistantAPIError):
                await self.sys_ingress.update_hass_panel(addon)

+        # Cleanup Ingress dynamic port assignment
+        self.sys_ingress.del_dynamic_port(slug)
+
        # Cleanup discovery data
        for message in self.sys_discovery.list_messages:
            if message.addon != addon.slug:
@@ -325,10 +328,10 @@ class AddonManager(CoreSysAttributes):
        for addon in self.installed:
            if not await addon.instance.is_running():
                continue
-            self.sys_dns.add_host(
+            self.sys_plugins.dns.add_host(
                ipv4=addon.ip_address, names=[addon.hostname], write=False
            )

        # Write hosts files
        with suppress(CoreDNSError):
-            self.sys_dns.write_hosts()
+            self.sys_plugins.dns.write_hosts()
--- a/supervisor/addons/addon.py
+++ b/supervisor/addons/addon.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io add-ons."""
+"""Init file for Supervisor add-ons."""
 from contextlib import suppress
 from copy import deepcopy
 from ipaddress import IPv4Address
@@ -63,9 +63,11 @@ RE_WEBUI = re.compile(
    r":\/\/\[HOST\]:\[PORT:(?P<t_port>\d+)\](?P<s_suffix>.*)$"
 )

+RE_OLD_AUDIO = re.compile(r"\d+,\d+")
+

 class Addon(AddonModel):
-    """Hold data for add-on inside Hass.io."""
+    """Hold data for add-on inside Supervisor."""

    def __init__(self, coresys: CoreSys, slug: str):
        """Initialize data holder."""
@@ -162,13 +164,13 @@ class Addon(AddonModel):
        return self.persist[ATTR_UUID]

    @property
-    def hassio_token(self) -> Optional[str]:
-        """Return access token for Hass.io API."""
+    def supervisor_token(self) -> Optional[str]:
+        """Return access token for Supervisor API."""
        return self.persist.get(ATTR_ACCESS_TOKEN)

    @property
    def ingress_token(self) -> Optional[str]:
-        """Return access token for Hass.io API."""
+        """Return access token for Supervisor API."""
        return self.persist.get(ATTR_INGRESS_TOKEN)

    @property
@@ -250,7 +252,7 @@ class Addon(AddonModel):

        # lookup the correct protocol from config
        if t_proto:
-            proto = "https" if self.options[t_proto] else "http"
+            proto = "https" if self.options.get(t_proto) else "http"
        else:
            proto = s_prefix

@@ -279,33 +281,39 @@ class Addon(AddonModel):

    @property
    def audio_output(self) -> Optional[str]:
-        """Return ALSA config for output or None."""
+        """Return a pulse profile for output or None."""
        if not self.with_audio:
            return None
-        return self.persist.get(ATTR_AUDIO_OUTPUT, self.sys_host.alsa.default.output)
+
+        # Fallback with old audio settings
+        # Remove after 210
+        output_data = self.persist.get(ATTR_AUDIO_OUTPUT)
+        if output_data and RE_OLD_AUDIO.fullmatch(output_data):
+            return None
+        return output_data

    @audio_output.setter
    def audio_output(self, value: Optional[str]):
-        """Set/reset audio output settings."""
-        if value is None:
-            self.persist.pop(ATTR_AUDIO_OUTPUT, None)
-        else:
-            self.persist[ATTR_AUDIO_OUTPUT] = value
+        """Set audio output profile settings."""
+        self.persist[ATTR_AUDIO_OUTPUT] = value

    @property
    def audio_input(self) -> Optional[str]:
-        """Return ALSA config for input or None."""
+        """Return pulse profile for input or None."""
        if not self.with_audio:
            return None
-        return self.persist.get(ATTR_AUDIO_INPUT, self.sys_host.alsa.default.input)
+
+        # Fallback with old audio settings
+        # Remove after 210
+        input_data = self.persist.get(ATTR_AUDIO_INPUT)
+        if input_data and RE_OLD_AUDIO.fullmatch(input_data):
+            return None
+        return input_data

    @audio_input.setter
    def audio_input(self, value: Optional[str]):
-        """Set/reset audio input settings."""
-        if value is None:
-            self.persist.pop(ATTR_AUDIO_INPUT, None)
-        else:
-            self.persist[ATTR_AUDIO_INPUT] = value
+        """Set audio input settings."""
+        self.persist[ATTR_AUDIO_INPUT] = value

    @property
    def image(self):
@@ -333,14 +341,14 @@ class Addon(AddonModel):
        return Path(self.path_data, "options.json")

    @property
-    def path_asound(self):
+    def path_pulse(self):
        """Return path to asound config."""
-        return Path(self.sys_config.path_tmp, f"{self.slug}_asound")
+        return Path(self.sys_config.path_tmp, f"{self.slug}_pulse")

    @property
-    def path_extern_asound(self):
+    def path_extern_pulse(self):
        """Return path to asound config for Docker."""
-        return Path(self.sys_config.path_extern_tmp, f"{self.slug}_asound")
+        return Path(self.sys_config.path_extern_tmp, f"{self.slug}_pulse")

    def save_persist(self):
        """Save data of add-on."""
@@ -379,20 +387,28 @@ class Addon(AddonModel):
        _LOGGER.info("Remove add-on data folder %s", self.path_data)
        await remove_data(self.path_data)

-    def write_asound(self):
+    def write_pulse(self):
        """Write asound config to file and return True on success."""
-        asound_config = self.sys_host.alsa.asound(
-            alsa_input=self.audio_input, alsa_output=self.audio_output
+        pulse_config = self.sys_plugins.audio.pulse_client(
+            input_profile=self.audio_input, output_profile=self.audio_output
        )

-        try:
-            with self.path_asound.open("w") as config_file:
-                config_file.write(asound_config)
-        except OSError as err:
-            _LOGGER.error("Add-on %s can't write asound: %s", self.slug, err)
-            raise AddonsError()
+        # Cleanup wrong maps
+        if self.path_pulse.is_dir():
+            shutil.rmtree(self.path_pulse, ignore_errors=True)

-        _LOGGER.debug("Add-on %s write asound: %s", self.slug, self.path_asound)
+        # Write pulse config
+        try:
+            with self.path_pulse.open("w") as config_file:
+                config_file.write(pulse_config)
+        except OSError as err:
+            _LOGGER.error(
+                "Add-on %s can't write pulse/client.config: %s", self.slug, err
+            )
+        else:
+            _LOGGER.debug(
+                "Add-on %s write pulse/client.config: %s", self.slug, self.path_pulse
+            )

    async def install_apparmor(self) -> None:
        """Install or Update AppArmor profile for Add-on."""
@@ -468,7 +484,7 @@ class Addon(AddonModel):

        # Sound
        if self.with_audio:
-            self.write_asound()
+            self.write_pulse()

        # Start Add-on
        try:
--- a/supervisor/addons/build.py
+++ b/supervisor/addons/build.py
@@ -1,4 +1,4 @@
-"""Hass.io add-on build environment."""
+"""Supervisor add-on build environment."""
 from __future__ import annotations
 from pathlib import Path
 from typing import TYPE_CHECKING, Dict
@@ -16,7 +16,7 @@ class AddonBuild(JsonConfig, CoreSysAttributes):
    """Handle build options for add-ons."""

    def __init__(self, coresys: CoreSys, addon: AnyAddon) -> None:
-        """Initialize Hass.io add-on builder."""
+        """Initialize Supervisor add-on builder."""
        self.coresys: CoreSys = coresys
        self.addon = addon

--- a/supervisor/addons/data.py
+++ b/supervisor/addons/data.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io add-on data."""
+"""Init file for Supervisor add-on data."""
 from copy import deepcopy
 import logging
 from typing import Any, Dict
@@ -23,7 +23,7 @@ Config = Dict[str, Any]


 class AddonsData(JsonConfig, CoreSysAttributes):
-    """Hold data for installed Add-ons inside Hass.io."""
+    """Hold data for installed Add-ons inside Supervisor."""

    def __init__(self, coresys: CoreSys):
        """Initialize data holder."""
--- a/supervisor/addons/model.py
+++ b/supervisor/addons/model.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io add-ons."""
+"""Init file for Supervisor add-ons."""
 from pathlib import Path
 from typing import Any, Awaitable, Dict, List, Optional

@@ -31,6 +31,7 @@ from ..const import (
    ATTR_HOST_PID,
    ATTR_IMAGE,
    ATTR_INGRESS,
+    ATTR_INIT,
    ATTR_KERNEL_MODULES,
    ATTR_LEGACY,
    ATTR_LOCATON,
@@ -136,13 +137,13 @@ class AddonModel(CoreSysAttributes):
        return None

    @property
-    def hassio_token(self) -> Optional[str]:
-        """Return access token for Hass.io API."""
+    def supervisor_token(self) -> Optional[str]:
+        """Return access token for Supervisor API."""
        return None

    @property
    def ingress_token(self) -> Optional[str]:
-        """Return access token for Hass.io API."""
+        """Return access token for Supervisor API."""
        return None

    @property
@@ -326,7 +327,7 @@ class AddonModel(CoreSysAttributes):

    @property
    def access_hassio_api(self) -> bool:
-        """Return True if the add-on access to Hass.io REASTful API."""
+        """Return True if the add-on access to Supervisor REASTful API."""
        return self.data[ATTR_HASSIO_API]

    @property
@@ -336,7 +337,7 @@ class AddonModel(CoreSysAttributes):

    @property
    def hassio_role(self) -> str:
-        """Return Hass.io role for API."""
+        """Return Supervisor role for API."""
        return self.data[ATTR_HASSIO_ROLE]

    @property
@@ -344,6 +345,11 @@ class AddonModel(CoreSysAttributes):
        """Return Exclude list for snapshot."""
        return self.data.get(ATTR_SNAPSHOT_EXCLUDE, [])

+    @property
+    def default_init(self) -> bool:
+        """Return True if the add-on have no own init."""
+        return self.data[ATTR_INIT]
+
    @property
    def with_stdin(self) -> bool:
        """Return True if the add-on access use stdin input."""
--- a/supervisor/addons/utils.py
+++ b/supervisor/addons/utils.py
@@ -59,7 +59,7 @@ def rating_security(addon: AddonModel) -> int:
    ):
        rating += -1

-    # API Hass.io role
+    # API Supervisor role
    if addon.hassio_role == ROLE_MANAGER:
        rating += -1
    elif addon.hassio_role == ROLE_ADMIN:
--- a/supervisor/addons/validate.py
+++ b/supervisor/addons/validate.py
@@ -44,6 +44,7 @@ from ..const import (
    ATTR_INGRESS_PANEL,
    ATTR_INGRESS_PORT,
    ATTR_INGRESS_TOKEN,
+    ATTR_INIT,
    ATTR_KERNEL_MODULES,
    ATTR_LEGACY,
    ATTR_LOCATON,
@@ -96,7 +97,6 @@ from ..discovery.validate import valid_discovery_service
 from ..validate import (
    DOCKER_PORTS,
    DOCKER_PORTS_DESCRIPTION,
-    alsa_device,
    network_port,
    token,
    uuid_match,
@@ -190,6 +190,7 @@ SCHEMA_ADDON_CONFIG = vol.Schema(
        vol.Optional(ATTR_URL): vol.Url(),
        vol.Required(ATTR_STARTUP): vol.All(_simple_startup, vol.In(STARTUP_ALL)),
        vol.Required(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL]),
+        vol.Optional(ATTR_INIT, default=True): vol.Boolean(),
        vol.Optional(ATTR_ADVANCED, default=False): vol.Boolean(),
        vol.Optional(ATTR_STAGE, default=AddonStages.STABLE): vol.Coerce(AddonStages),
        vol.Optional(ATTR_PORTS): DOCKER_PORTS,
@@ -260,7 +261,7 @@ SCHEMA_ADDON_CONFIG = vol.Schema(
        ),
        vol.Optional(ATTR_IMAGE): vol.Match(RE_DOCKER_IMAGE),
        vol.Optional(ATTR_TIMEOUT, default=10): vol.All(
-            vol.Coerce(int), vol.Range(min=10, max=120)
+            vol.Coerce(int), vol.Range(min=10, max=300)
        ),
    },
    extra=vol.REMOVE_EXTRA,
@@ -296,8 +297,8 @@ SCHEMA_ADDON_USER = vol.Schema(
        vol.Optional(ATTR_AUTO_UPDATE, default=False): vol.Boolean(),
        vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL]),
        vol.Optional(ATTR_NETWORK): DOCKER_PORTS,
-        vol.Optional(ATTR_AUDIO_OUTPUT): alsa_device,
-        vol.Optional(ATTR_AUDIO_INPUT): alsa_device,
+        vol.Optional(ATTR_AUDIO_OUTPUT): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_AUDIO_INPUT): vol.Maybe(vol.Coerce(str)),
        vol.Optional(ATTR_PROTECTED, default=True): vol.Boolean(),
        vol.Optional(ATTR_INGRESS_PANEL, default=False): vol.Boolean(),
    },
--- a/supervisor/api/init.py
+++ b/supervisor/api/init.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io RESTful API."""
+"""Init file for Supervisor RESTful API."""
 import logging
 from pathlib import Path
 from typing import Optional
@@ -7,11 +7,13 @@ from aiohttp import web

 from ..coresys import CoreSys, CoreSysAttributes
 from .addons import APIAddons
+from .audio import APIAudio
 from .auth import APIAuth
+from .cli import APICli
 from .discovery import APIDiscovery
 from .dns import APICoreDNS
 from .hardware import APIHardware
-from .hassos import APIHassOS
+from .os import APIOS
 from .homeassistant import APIHomeAssistant
 from .host import APIHost
 from .info import APIInfo
@@ -21,6 +23,7 @@ from .security import SecurityMiddleware
 from .services import APIServices
 from .snapshots import APISnapshots
 from .supervisor import APISupervisor
+from .multicast import APIMulticast

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

@@ -29,7 +32,7 @@ MAX_CLIENT_SIZE: int = 1024 ** 2 * 16


 class RestAPI(CoreSysAttributes):
-    """Handle RESTful API for Hass.io."""
+    """Handle RESTful API for Supervisor."""

    def __init__(self, coresys: CoreSys):
        """Initialize Docker base wrapper."""
@@ -48,7 +51,9 @@ class RestAPI(CoreSysAttributes):
        """Register REST API Calls."""
        self._register_supervisor()
        self._register_host()
-        self._register_hassos()
+        self._register_os()
+        self._register_cli()
+        self._register_multicast()
        self._register_hardware()
        self._register_homeassistant()
        self._register_proxy()
@@ -61,6 +66,7 @@ class RestAPI(CoreSysAttributes):
        self._register_info()
        self._register_auth()
        self._register_dns()
+        self._register_audio()

    def _register_host(self) -> None:
        """Register hostcontrol functions."""
@@ -70,6 +76,7 @@ class RestAPI(CoreSysAttributes):
        self.webapp.add_routes(
            [
                web.get("/host/info", api_host.info),
+                web.get("/host/logs", api_host.logs),
                web.post("/host/reboot", api_host.reboot),
                web.post("/host/shutdown", api_host.shutdown),
                web.post("/host/reload", api_host.reload),
@@ -82,22 +89,44 @@ class RestAPI(CoreSysAttributes):
            ]
        )

-    def _register_hassos(self) -> None:
-        """Register HassOS functions."""
-        api_hassos = APIHassOS()
-        api_hassos.coresys = self.coresys
+    def _register_os(self) -> None:
+        """Register OS functions."""
+        api_os = APIOS()
+        api_os.coresys = self.coresys

        self.webapp.add_routes(
            [
-                web.get("/os/info", api_hassos.info),
-                web.post("/os/update", api_hassos.update),
-                web.post("/os/update/cli", api_hassos.update_cli),
-                web.post("/os/config/sync", api_hassos.config_sync),
-                # Remove with old Hass.io fallback
-                web.get("/hassos/info", api_hassos.info),
-                web.post("/hassos/update", api_hassos.update),
-                web.post("/hassos/update/cli", api_hassos.update_cli),
-                web.post("/hassos/config/sync", api_hassos.config_sync),
+                web.get("/os/info", api_os.info),
+                web.post("/os/update", api_os.update),
+                web.post("/os/config/sync", api_os.config_sync),
+            ]
+        )
+
+    def _register_cli(self) -> None:
+        """Register HA cli functions."""
+        api_cli = APICli()
+        api_cli.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/cli/info", api_cli.info),
+                web.get("/cli/stats", api_cli.stats),
+                web.post("/cli/update", api_cli.update),
+            ]
+        )
+
+    def _register_multicast(self) -> None:
+        """Register Multicast functions."""
+        api_multicast = APIMulticast()
+        api_multicast.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/multicast/info", api_multicast.info),
+                web.get("/multicast/stats", api_multicast.stats),
+                web.get("/multicast/logs", api_multicast.logs),
+                web.post("/multicast/update", api_multicast.update),
+                web.post("/multicast/restart", api_multicast.restart),
            ]
        )

@@ -165,7 +194,7 @@ class RestAPI(CoreSysAttributes):
                web.post("/core/start", api_hass.start),
                web.post("/core/check", api_hass.check),
                web.post("/core/rebuild", api_hass.rebuild),
-                # Remove with old Hass.io fallback
+                # Remove with old Supervisor fallback
                web.get("/homeassistant/info", api_hass.info),
                web.get("/homeassistant/logs", api_hass.logs),
                web.get("/homeassistant/stats", api_hass.stats),
@@ -192,7 +221,7 @@ class RestAPI(CoreSysAttributes):
                web.post("/core/api/{path:.+}", api_proxy.api),
                web.get("/core/api/{path:.+}", api_proxy.api),
                web.get("/core/api/", api_proxy.api),
-                # Remove with old Hass.io fallback
+                # Remove with old Supervisor fallback
                web.get("/homeassistant/api/websocket", api_proxy.websocket),
                web.get("/homeassistant/websocket", api_proxy.websocket),
                web.get("/homeassistant/api/stream", api_proxy.stream),
@@ -314,6 +343,28 @@ class RestAPI(CoreSysAttributes):
            ]
        )

+    def _register_audio(self) -> None:
+        """Register Audio functions."""
+        api_audio = APIAudio()
+        api_audio.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/audio/info", api_audio.info),
+                web.get("/audio/stats", api_audio.stats),
+                web.get("/audio/logs", api_audio.logs),
+                web.post("/audio/update", api_audio.update),
+                web.post("/audio/restart", api_audio.restart),
+                web.post("/audio/reload", api_audio.reload),
+                web.post("/audio/profile", api_audio.set_profile),
+                web.post("/audio/volume/{source}/application", api_audio.set_volume),
+                web.post("/audio/volume/{source}", api_audio.set_volume),
+                web.post("/audio/mute/{source}/application", api_audio.set_mute),
+                web.post("/audio/mute/{source}", api_audio.set_mute),
+                web.post("/audio/default/{source}", api_audio.set_default),
+            ]
+        )
+
    def _register_panel(self) -> None:
        """Register panel for Home Assistant."""
        panel_dir = Path(__file__).parent.joinpath("panel")
--- a/supervisor/api/addons.py
+++ b/supervisor/api/addons.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io Home Assistant RESTful API."""
+"""Init file for Supervisor Home Assistant RESTful API."""
 import asyncio
 import logging
 from typing import Any, Awaitable, Dict, List
@@ -54,7 +54,7 @@ from ..const import (
    ATTR_INSTALLED,
    ATTR_IP_ADDRESS,
    ATTR_KERNEL_MODULES,
-    ATTR_LAST_VERSION,
+    ATTR_VERSION_LATEST,
    ATTR_LOGO,
    ATTR_LONG_DESCRIPTION,
    ATTR_MACHINE,
@@ -96,7 +96,7 @@ from ..const import (
 from ..coresys import CoreSysAttributes
 from ..docker.stats import DockerStats
 from ..exceptions import APIError
-from ..validate import DOCKER_PORTS, alsa_device
+from ..validate import DOCKER_PORTS
 from .utils import api_process, api_process_raw, api_validate

 _LOGGER: logging.Logger = logging.getLogger(__name__)
@@ -107,10 +107,10 @@ SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 SCHEMA_OPTIONS = vol.Schema(
    {
        vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL]),
-        vol.Optional(ATTR_NETWORK): vol.Any(None, DOCKER_PORTS),
+        vol.Optional(ATTR_NETWORK): vol.Maybe(DOCKER_PORTS),
        vol.Optional(ATTR_AUTO_UPDATE): vol.Boolean(),
-        vol.Optional(ATTR_AUDIO_OUTPUT): alsa_device,
-        vol.Optional(ATTR_AUDIO_INPUT): alsa_device,
+        vol.Optional(ATTR_AUDIO_OUTPUT): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_AUDIO_INPUT): vol.Maybe(vol.Coerce(str)),
        vol.Optional(ATTR_INGRESS_PANEL): vol.Boolean(),
    }
 )
@@ -204,7 +204,7 @@ class APIAddons(CoreSysAttributes):
            ATTR_AUTO_UPDATE: None,
            ATTR_REPOSITORY: addon.repository,
            ATTR_VERSION: None,
-            ATTR_LAST_VERSION: addon.latest_version,
+            ATTR_VERSION_LATEST: addon.latest_version,
            ATTR_PROTECTED: addon.protected,
            ATTR_RATING: rating_security(addon),
            ATTR_BOOT: addon.boot,
--- a/supervisor/api/audio.py
+++ b/supervisor/api/audio.py
@@ -0,0 +1,170 @@
+"""Init file for Supervisor Audio RESTful API."""
+import asyncio
+import logging
+from typing import Any, Awaitable, Dict
+
+from aiohttp import web
+import attr
+import voluptuous as vol
+
+from ..const import (
+    ATTR_ACTIVE,
+    ATTR_APPLICATION,
+    ATTR_AUDIO,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_CARD,
+    ATTR_CPU_PERCENT,
+    ATTR_HOST,
+    ATTR_INDEX,
+    ATTR_INPUT,
+    ATTR_VERSION_LATEST,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_PERCENT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NAME,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_OUTPUT,
+    ATTR_VERSION,
+    ATTR_VOLUME,
+    CONTENT_TYPE_BINARY,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+from ..host.sound import StreamType
+from .utils import api_process, api_process_raw, api_validate
+
+_LOGGER: logging.Logger = logging.getLogger(__name__)
+
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
+
+SCHEMA_VOLUME = vol.Schema(
+    {
+        vol.Required(ATTR_INDEX): vol.Coerce(int),
+        vol.Required(ATTR_VOLUME): vol.Coerce(float),
+    }
+)
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_MUTE = vol.Schema(
+    {
+        vol.Required(ATTR_INDEX): vol.Coerce(int),
+        vol.Required(ATTR_ACTIVE): vol.Boolean(),
+    }
+)
+
+SCHEMA_DEFAULT = vol.Schema({vol.Required(ATTR_NAME): vol.Coerce(str)})
+
+SCHEMA_PROFILE = vol.Schema(
+    {vol.Required(ATTR_CARD): vol.Coerce(str), vol.Required(ATTR_NAME): vol.Coerce(str)}
+)
+
+
+class APIAudio(CoreSysAttributes):
+    """Handle RESTful API for Audio functions."""
+
+    @api_process
+    async def info(self, request: web.Request) -> Dict[str, Any]:
+        """Return Audio information."""
+        return {
+            ATTR_VERSION: self.sys_plugins.audio.version,
+            ATTR_VERSION_LATEST: self.sys_plugins.audio.latest_version,
+            ATTR_HOST: str(self.sys_docker.network.audio),
+            ATTR_AUDIO: {
+                ATTR_CARD: [attr.asdict(card) for card in self.sys_host.sound.cards],
+                ATTR_INPUT: [
+                    attr.asdict(stream) for stream in self.sys_host.sound.inputs
+                ],
+                ATTR_OUTPUT: [
+                    attr.asdict(stream) for stream in self.sys_host.sound.outputs
+                ],
+                ATTR_APPLICATION: [
+                    attr.asdict(stream) for stream in self.sys_host.sound.applications
+                ],
+            },
+        }
+
+    @api_process
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        stats = await self.sys_plugins.audio.stats()
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_MEMORY_PERCENT: stats.memory_percent,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update Audio plugin."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_plugins.audio.latest_version)
+
+        if version == self.sys_plugins.audio.version:
+            raise APIError("Version {} is already in use".format(version))
+        await asyncio.shield(self.sys_plugins.audio.update(version))
+
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return Audio Docker logs."""
+        return self.sys_plugins.audio.logs()
+
+    @api_process
+    def restart(self, request: web.Request) -> Awaitable[None]:
+        """Restart Audio plugin."""
+        return asyncio.shield(self.sys_plugins.audio.restart())
+
+    @api_process
+    def reload(self, request: web.Request) -> Awaitable[None]:
+        """Reload Audio information."""
+        return asyncio.shield(self.sys_host.sound.update())
+
+    @api_process
+    async def set_volume(self, request: web.Request) -> None:
+        """Set audio volume on stream."""
+        source: StreamType = StreamType(request.match_info.get("source"))
+        application: bool = request.path.endswith("application")
+        body = await api_validate(SCHEMA_VOLUME, request)
+
+        await asyncio.shield(
+            self.sys_host.sound.set_volume(
+                source, body[ATTR_INDEX], body[ATTR_VOLUME], application
+            )
+        )
+
+    @api_process
+    async def set_mute(self, request: web.Request) -> None:
+        """Mute audio volume on stream."""
+        source: StreamType = StreamType(request.match_info.get("source"))
+        application: bool = request.path.endswith("application")
+        body = await api_validate(SCHEMA_MUTE, request)
+
+        await asyncio.shield(
+            self.sys_host.sound.set_mute(
+                source, body[ATTR_INDEX], body[ATTR_ACTIVE], application
+            )
+        )
+
+    @api_process
+    async def set_default(self, request: web.Request) -> None:
+        """Set audio default stream."""
+        source: StreamType = StreamType(request.match_info.get("source"))
+        body = await api_validate(SCHEMA_DEFAULT, request)
+
+        await asyncio.shield(self.sys_host.sound.set_default(source, body[ATTR_NAME]))
+
+    @api_process
+    async def set_profile(self, request: web.Request) -> None:
+        """Set audio default sources."""
+        body = await api_validate(SCHEMA_PROFILE, request)
+
+        await asyncio.shield(
+            self.sys_host.sound.ativate_profile(body[ATTR_CARD], body[ATTR_NAME])
+        )
--- a/supervisor/api/auth.py
+++ b/supervisor/api/auth.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io auth/SSO RESTful API."""
+"""Init file for Supervisor auth/SSO RESTful API."""
 import asyncio
 import logging
 from typing import Dict
@@ -76,7 +76,7 @@ class APIAuth(CoreSysAttributes):
            return await self._process_dict(request, addon, data)

        raise HTTPUnauthorized(
-            headers={WWW_AUTHENTICATE: 'Basic realm="Hass.io Authentication"'}
+            headers={WWW_AUTHENTICATE: 'Basic realm="Home Assistant Authentication"'}
        )

    @api_process
--- a/supervisor/api/cli.py
+++ b/supervisor/api/cli.py
@@ -0,0 +1,62 @@
+"""Init file for Supervisor HA cli RESTful API."""
+import asyncio
+import logging
+from typing import Any, Dict
+
+from aiohttp import web
+import voluptuous as vol
+
+from ..const import (
+    ATTR_VERSION,
+    ATTR_VERSION_LATEST,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_CPU_PERCENT,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_PERCENT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+)
+from ..coresys import CoreSysAttributes
+from .utils import api_process, api_validate
+
+_LOGGER: logging.Logger = logging.getLogger(__name__)
+
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
+
+
+class APICli(CoreSysAttributes):
+    """Handle RESTful API for HA Cli functions."""
+
+    @api_process
+    async def info(self, request: web.Request) -> Dict[str, Any]:
+        """Return HA cli information."""
+        return {
+            ATTR_VERSION: self.sys_plugins.cli.version,
+            ATTR_VERSION_LATEST: self.sys_plugins.cli.latest_version,
+        }
+
+    @api_process
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        stats = await self.sys_plugins.cli.stats()
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_MEMORY_PERCENT: stats.memory_percent,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update HA CLI."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_plugins.cli.latest_version)
+
+        await asyncio.shield(self.sys_plugins.cli.update(version))
--- a/supervisor/api/discovery.py
+++ b/supervisor/api/discovery.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io network RESTful API."""
+"""Init file for Supervisor network RESTful API."""
 import voluptuous as vol

 from .utils import api_process, api_validate
@@ -64,7 +64,7 @@ class APIDiscovery(CoreSysAttributes):

        # Access?
        if body[ATTR_SERVICE] not in addon.discovery:
-            raise APIForbidden(f"Can't use discovery!")
+            raise APIForbidden("Can't use discovery!")

        # Process discovery message
        message = self.sys_discovery.send(addon, **body)
@@ -94,7 +94,7 @@ class APIDiscovery(CoreSysAttributes):

        # Permission
        if message.addon != addon.slug:
-            raise APIForbidden(f"Can't remove discovery message")
+            raise APIForbidden("Can't remove discovery message")

        self.sys_discovery.remove(message)
        return True
--- a/supervisor/api/dns.py
+++ b/supervisor/api/dns.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io DNS RESTful API."""
+"""Init file for Supervisor DNS RESTful API."""
 import asyncio
 import logging
 from typing import Any, Awaitable, Dict
@@ -11,7 +11,7 @@ from ..const import (
    ATTR_BLK_WRITE,
    ATTR_CPU_PERCENT,
    ATTR_HOST,
-    ATTR_LATEST_VERSION,
+    ATTR_VERSION_LATEST,
    ATTR_LOCALS,
    ATTR_MEMORY_LIMIT,
    ATTR_MEMORY_PERCENT,
@@ -42,10 +42,10 @@ class APICoreDNS(CoreSysAttributes):
    async def info(self, request: web.Request) -> Dict[str, Any]:
        """Return DNS information."""
        return {
-            ATTR_VERSION: self.sys_dns.version,
-            ATTR_LATEST_VERSION: self.sys_dns.latest_version,
+            ATTR_VERSION: self.sys_plugins.dns.version,
+            ATTR_VERSION_LATEST: self.sys_plugins.dns.latest_version,
            ATTR_HOST: str(self.sys_docker.network.dns),
-            ATTR_SERVERS: self.sys_dns.servers,
+            ATTR_SERVERS: self.sys_plugins.dns.servers,
            ATTR_LOCALS: self.sys_host.network.dns_servers,
        }

@@ -55,15 +55,15 @@ class APICoreDNS(CoreSysAttributes):
        body = await api_validate(SCHEMA_OPTIONS, request)

        if ATTR_SERVERS in body:
-            self.sys_dns.servers = body[ATTR_SERVERS]
-            self.sys_create_task(self.sys_dns.restart())
+            self.sys_plugins.dns.servers = body[ATTR_SERVERS]
+            self.sys_create_task(self.sys_plugins.dns.restart())

-        self.sys_dns.save_data()
+        self.sys_plugins.dns.save_data()

    @api_process
    async def stats(self, request: web.Request) -> Dict[str, Any]:
        """Return resource information."""
-        stats = await self.sys_dns.stats()
+        stats = await self.sys_plugins.dns.stats()

        return {
            ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -80,23 +80,23 @@ class APICoreDNS(CoreSysAttributes):
    async def update(self, request: web.Request) -> None:
        """Update DNS plugin."""
        body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self.sys_dns.latest_version)
+        version = body.get(ATTR_VERSION, self.sys_plugins.dns.latest_version)

-        if version == self.sys_dns.version:
+        if version == self.sys_plugins.dns.version:
            raise APIError("Version {} is already in use".format(version))
-        await asyncio.shield(self.sys_dns.update(version))
+        await asyncio.shield(self.sys_plugins.dns.update(version))

    @api_process_raw(CONTENT_TYPE_BINARY)
    def logs(self, request: web.Request) -> Awaitable[bytes]:
        """Return DNS Docker logs."""
-        return self.sys_dns.logs()
+        return self.sys_plugins.dns.logs()

    @api_process
    def restart(self, request: web.Request) -> Awaitable[None]:
        """Restart CoreDNS plugin."""
-        return asyncio.shield(self.sys_dns.restart())
+        return asyncio.shield(self.sys_plugins.dns.restart())

    @api_process
    def reset(self, request: web.Request) -> Awaitable[None]:
        """Reset CoreDNS plugin."""
-        return asyncio.shield(self.sys_dns.reset())
+        return asyncio.shield(self.sys_plugins.dns.reset())
--- a/supervisor/api/hardware.py
+++ b/supervisor/api/hardware.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io hardware RESTful API."""
+"""Init file for Supervisor hardware RESTful API."""
 import asyncio
 import logging
 from typing import Any, Dict
@@ -37,11 +37,17 @@ class APIHardware(CoreSysAttributes):

    @api_process
    async def audio(self, request: web.Request) -> Dict[str, Any]:
-        """Show ALSA audio devices."""
+        """Show pulse audio profiles."""
        return {
            ATTR_AUDIO: {
-                ATTR_INPUT: self.sys_host.alsa.input_devices,
-                ATTR_OUTPUT: self.sys_host.alsa.output_devices,
+                ATTR_INPUT: {
+                    profile.name: profile.description
+                    for profile in self.sys_host.sound.inputs
+                },
+                ATTR_OUTPUT: {
+                    profile.name: profile.description
+                    for profile in self.sys_host.sound.outputs
+                },
            }
        }

--- a/supervisor/api/homeassistant.py
+++ b/supervisor/api/homeassistant.py
@@ -1,33 +1,34 @@
-"""Init file for Hass.io Home Assistant RESTful API."""
+"""Init file for Supervisor Home Assistant RESTful API."""
 import asyncio
 import logging
-from typing import Coroutine, Dict, Any
+from typing import Any, Coroutine, Dict

-import voluptuous as vol
 from aiohttp import web
+import voluptuous as vol

 from ..const import (
    ATTR_ARCH,
+    ATTR_AUDIO_INPUT,
+    ATTR_AUDIO_OUTPUT,
    ATTR_BLK_READ,
    ATTR_BLK_WRITE,
    ATTR_BOOT,
    ATTR_CPU_PERCENT,
-    ATTR_CUSTOM,
    ATTR_IMAGE,
-    ATTR_LAST_VERSION,
+    ATTR_IP_ADDRESS,
    ATTR_MACHINE,
    ATTR_MEMORY_LIMIT,
-    ATTR_MEMORY_USAGE,
    ATTR_MEMORY_PERCENT,
+    ATTR_MEMORY_USAGE,
    ATTR_NETWORK_RX,
    ATTR_NETWORK_TX,
    ATTR_PORT,
    ATTR_REFRESH_TOKEN,
    ATTR_SSL,
    ATTR_VERSION,
+    ATTR_VERSION_LATEST,
    ATTR_WAIT_BOOT,
    ATTR_WATCHDOG,
-    ATTR_IP_ADDRESS,
    CONTENT_TYPE_BINARY,
 )
 from ..coresys import CoreSysAttributes
@@ -41,13 +42,14 @@ _LOGGER: logging.Logger = logging.getLogger(__name__)
 SCHEMA_OPTIONS = vol.Schema(
    {
        vol.Optional(ATTR_BOOT): vol.Boolean(),
-        vol.Inclusive(ATTR_IMAGE, "custom_hass"): vol.Maybe(docker_image),
-        vol.Inclusive(ATTR_LAST_VERSION, "custom_hass"): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_IMAGE): docker_image,
        vol.Optional(ATTR_PORT): network_port,
        vol.Optional(ATTR_SSL): vol.Boolean(),
        vol.Optional(ATTR_WATCHDOG): vol.Boolean(),
        vol.Optional(ATTR_WAIT_BOOT): vol.All(vol.Coerce(int), vol.Range(min=60)),
        vol.Optional(ATTR_REFRESH_TOKEN): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_AUDIO_OUTPUT): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_AUDIO_INPUT): vol.Maybe(vol.Coerce(str)),
    }
 )

@@ -62,17 +64,20 @@ class APIHomeAssistant(CoreSysAttributes):
        """Return host information."""
        return {
            ATTR_VERSION: self.sys_homeassistant.version,
-            ATTR_LAST_VERSION: self.sys_homeassistant.latest_version,
+            ATTR_VERSION_LATEST: self.sys_homeassistant.latest_version,
            ATTR_MACHINE: self.sys_homeassistant.machine,
            ATTR_IP_ADDRESS: str(self.sys_homeassistant.ip_address),
            ATTR_ARCH: self.sys_homeassistant.arch,
            ATTR_IMAGE: self.sys_homeassistant.image,
-            ATTR_CUSTOM: self.sys_homeassistant.is_custom_image,
            ATTR_BOOT: self.sys_homeassistant.boot,
            ATTR_PORT: self.sys_homeassistant.api_port,
            ATTR_SSL: self.sys_homeassistant.api_ssl,
            ATTR_WATCHDOG: self.sys_homeassistant.watchdog,
            ATTR_WAIT_BOOT: self.sys_homeassistant.wait_boot,
+            ATTR_AUDIO_INPUT: self.sys_homeassistant.audio_input,
+            ATTR_AUDIO_OUTPUT: self.sys_homeassistant.audio_output,
+            # Remove end of Q3 2020
+            "last_version": self.sys_homeassistant.latest_version,
        }

    @api_process
@@ -80,9 +85,8 @@ class APIHomeAssistant(CoreSysAttributes):
        """Set Home Assistant options."""
        body = await api_validate(SCHEMA_OPTIONS, request)

-        if ATTR_IMAGE in body and ATTR_LAST_VERSION in body:
+        if ATTR_IMAGE in body:
            self.sys_homeassistant.image = body[ATTR_IMAGE]
-            self.sys_homeassistant.latest_version = body[ATTR_LAST_VERSION]

        if ATTR_BOOT in body:
            self.sys_homeassistant.boot = body[ATTR_BOOT]
@@ -102,6 +106,12 @@ class APIHomeAssistant(CoreSysAttributes):
        if ATTR_REFRESH_TOKEN in body:
            self.sys_homeassistant.refresh_token = body[ATTR_REFRESH_TOKEN]

+        if ATTR_AUDIO_INPUT in body:
+            self.sys_homeassistant.audio_input = body[ATTR_AUDIO_INPUT]
+
+        if ATTR_AUDIO_OUTPUT in body:
+            self.sys_homeassistant.audio_output = body[ATTR_AUDIO_OUTPUT]
+
        self.sys_homeassistant.save_data()

    @api_process
--- a/supervisor/api/host.py
+++ b/supervisor/api/host.py
@@ -1,24 +1,27 @@
-"""Init file for Hass.io host RESTful API."""
+"""Init file for Supervisor host RESTful API."""
 import asyncio
 import logging
+from typing import Awaitable

+from aiohttp import web
 import voluptuous as vol

-from .utils import api_process, api_validate
 from ..const import (
-    ATTR_HOSTNAME,
-    ATTR_FEATURES,
-    ATTR_KERNEL,
-    ATTR_OPERATING_SYSTEM,
    ATTR_CHASSIS,
-    ATTR_DEPLOYMENT,
-    ATTR_STATE,
-    ATTR_NAME,
-    ATTR_DESCRIPTON,
-    ATTR_SERVICES,
    ATTR_CPE,
+    ATTR_DEPLOYMENT,
+    ATTR_DESCRIPTON,
+    ATTR_FEATURES,
+    ATTR_HOSTNAME,
+    ATTR_KERNEL,
+    ATTR_NAME,
+    ATTR_OPERATING_SYSTEM,
+    ATTR_SERVICES,
+    ATTR_STATE,
+    CONTENT_TYPE_BINARY,
 )
 from ..coresys import CoreSysAttributes
+from .utils import api_process, api_process_raw, api_validate

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

@@ -107,3 +110,8 @@ class APIHost(CoreSysAttributes):
        """Restart a service."""
        unit = request.match_info.get(SERVICE)
        return asyncio.shield(self.sys_host.services.restart(unit))
+
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return host kernel logs."""
+        return self.sys_host.info.get_dmesg()
--- a/supervisor/api/info.py
+++ b/supervisor/api/info.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io info RESTful API."""
+"""Init file for Supervisor info RESTful API."""
 import logging
 from typing import Any, Dict

--- a/supervisor/api/ingress.py
+++ b/supervisor/api/ingress.py
@@ -1,4 +1,4 @@
-"""Hass.io Add-on ingress service."""
+"""Supervisor Add-on ingress service."""
 import asyncio
 from ipaddress import ip_address
 import logging
@@ -81,7 +81,7 @@ class APIIngress(CoreSysAttributes):
    async def handler(
        self, request: web.Request
    ) -> Union[web.Response, web.StreamResponse, web.WebSocketResponse]:
-        """Route data to Hass.io ingress service."""
+        """Route data to Supervisor ingress service."""
        self._check_ha_access(request)

        # Check Ingress Session
--- a/supervisor/api/multicast.py
+++ b/supervisor/api/multicast.py
@@ -0,0 +1,76 @@
+"""Init file for Supervisor Multicast RESTful API."""
+import asyncio
+import logging
+from typing import Any, Awaitable, Dict
+
+from aiohttp import web
+import voluptuous as vol
+
+from ..const import (
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_CPU_PERCENT,
+    ATTR_VERSION_LATEST,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_PERCENT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_VERSION,
+    CONTENT_TYPE_BINARY,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+from .utils import api_process, api_process_raw, api_validate
+
+_LOGGER: logging.Logger = logging.getLogger(__name__)
+
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
+
+
+class APIMulticast(CoreSysAttributes):
+    """Handle RESTful API for Multicast functions."""
+
+    @api_process
+    async def info(self, request: web.Request) -> Dict[str, Any]:
+        """Return Multicast information."""
+        return {
+            ATTR_VERSION: self.sys_plugins.multicast.version,
+            ATTR_VERSION_LATEST: self.sys_plugins.multicast.latest_version,
+        }
+
+    @api_process
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        stats = await self.sys_plugins.multicast.stats()
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_MEMORY_PERCENT: stats.memory_percent,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update Multicast plugin."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_plugins.multicast.latest_version)
+
+        if version == self.sys_plugins.multicast.version:
+            raise APIError("Version {} is already in use".format(version))
+        await asyncio.shield(self.sys_plugins.multicast.update(version))
+
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return Multicast Docker logs."""
+        return self.sys_plugins.multicast.logs()
+
+    @api_process
+    def restart(self, request: web.Request) -> Awaitable[None]:
+        """Restart Multicast plugin."""
+        return asyncio.shield(self.sys_plugins.multicast.restart())
--- a/supervisor/api/os.py
+++ b/supervisor/api/os.py
@@ -1,4 +1,4 @@
-"""Init file for Hass.io HassOS RESTful API."""
+"""Init file for Supervisor HassOS RESTful API."""
 import asyncio
 import logging
 from typing import Any, Awaitable, Dict
@@ -10,8 +10,6 @@ from ..const import (
    ATTR_BOARD,
    ATTR_BOOT,
    ATTR_VERSION,
-    ATTR_VERSION_CLI,
-    ATTR_VERSION_CLI_LATEST,
    ATTR_VERSION_LATEST,
 )
 from ..coresys import CoreSysAttributes
@@ -22,38 +20,28 @@ _LOGGER: logging.Logger = logging.getLogger(__name__)
 SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})


-class APIHassOS(CoreSysAttributes):
-    """Handle RESTful API for HassOS functions."""
+class APIOS(CoreSysAttributes):
+    """Handle RESTful API for OS functions."""

    @api_process
    async def info(self, request: web.Request) -> Dict[str, Any]:
-        """Return HassOS information."""
+        """Return OS information."""
        return {
            ATTR_VERSION: self.sys_hassos.version,
-            ATTR_VERSION_CLI: self.sys_hassos.version_cli,
-            ATTR_VERSION_LATEST: self.sys_hassos.version_latest,
-            ATTR_VERSION_CLI_LATEST: self.sys_hassos.version_cli_latest,
+            ATTR_VERSION_LATEST: self.sys_hassos.latest_version,
            ATTR_BOARD: self.sys_hassos.board,
            ATTR_BOOT: self.sys_dbus.rauc.boot_slot,
        }

    @api_process
    async def update(self, request: web.Request) -> None:
-        """Update HassOS."""
+        """Update OS."""
        body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self.sys_hassos.version_latest)
+        version = body.get(ATTR_VERSION, self.sys_hassos.latest_version)

        await asyncio.shield(self.sys_hassos.update(version))

-    @api_process
-    async def update_cli(self, request: web.Request) -> None:
-        """Update HassOS CLI."""
-        body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self.sys_hassos.version_cli_latest)
-
-        await asyncio.shield(self.sys_hassos.update_cli(version))
-
    @api_process
    def config_sync(self, request: web.Request) -> Awaitable[None]:
-        """Trigger config reload on HassOS."""
+        """Trigger config reload on OS."""
        return asyncio.shield(self.sys_hassos.config_sync())
--- a/supervisor/api/panel/201359fd5a526afe13ef.worker.js
+++ b/supervisor/api/panel/201359fd5a526afe13ef.worker.js
--- a/supervisor/api/panel/201359fd5a526afe13ef.worker.js.gz
+++ b/supervisor/api/panel/201359fd5a526afe13ef.worker.js.gz
--- a/supervisor/api/panel/201359fd5a526afe13ef.worker.js.map
+++ b/supervisor/api/panel/201359fd5a526afe13ef.worker.js.map
--- a/supervisor/api/panel/264283c05b3002fb79ff.worker.js
+++ b/supervisor/api/panel/264283c05b3002fb79ff.worker.js
--- a/supervisor/api/panel/264283c05b3002fb79ff.worker.js.gz
+++ b/supervisor/api/panel/264283c05b3002fb79ff.worker.js.gz
--- a/supervisor/api/panel/264283c05b3002fb79ff.worker.js.map
+++ b/supervisor/api/panel/264283c05b3002fb79ff.worker.js.map
--- a/supervisor/api/panel/7e78115f8d410990252b.worker.js
+++ b/supervisor/api/panel/7e78115f8d410990252b.worker.js
--- a/supervisor/api/panel/7e78115f8d410990252b.worker.js.gz
+++ b/supervisor/api/panel/7e78115f8d410990252b.worker.js.gz
--- a/supervisor/api/panel/a1ebfa0a88593a3b571c.worker.js
+++ b/supervisor/api/panel/a1ebfa0a88593a3b571c.worker.js
--- a/supervisor/api/panel/a1ebfa0a88593a3b571c.worker.js.gz
+++ b/supervisor/api/panel/a1ebfa0a88593a3b571c.worker.js.gz
--- a/supervisor/api/panel/a1ebfa0a88593a3b571c.worker.js.map
+++ b/supervisor/api/panel/a1ebfa0a88593a3b571c.worker.js.map
--- a/supervisor/api/panel/chunk.045f3417b78f858fff44.js
+++ b/supervisor/api/panel/chunk.045f3417b78f858fff44.js
--- a/supervisor/api/panel/chunk.045f3417b78f858fff44.js.gz
+++ b/supervisor/api/panel/chunk.045f3417b78f858fff44.js.gz
--- a/supervisor/api/panel/chunk.045f3417b78f858fff44.js.map
+++ b/supervisor/api/panel/chunk.045f3417b78f858fff44.js.map
--- a/supervisor/api/panel/chunk.05403bc1774dc39117f6.js
+++ b/supervisor/api/panel/chunk.05403bc1774dc39117f6.js
--- a/supervisor/api/panel/chunk.05403bc1774dc39117f6.js.gz
+++ b/supervisor/api/panel/chunk.05403bc1774dc39117f6.js.gz
--- a/supervisor/api/panel/chunk.05403bc1774dc39117f6.js.map
+++ b/supervisor/api/panel/chunk.05403bc1774dc39117f6.js.map
--- a/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js
+++ b/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js
--- a/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js.LICENSE
+++ b/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js.LICENSE
--- a/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js.gz
+++ b/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js.gz
--- a/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js.map
+++ b/supervisor/api/panel/chunk.05d0c315f85f2fc8c34a.js.map
--- a/supervisor/api/panel/chunk.066811ee56df2879fa62.js
+++ b/supervisor/api/panel/chunk.066811ee56df2879fa62.js
--- a/supervisor/api/panel/chunk.066811ee56df2879fa62.js.gz
+++ b/supervisor/api/panel/chunk.066811ee56df2879fa62.js.gz
--- a/supervisor/api/panel/chunk.07363f9b958809b22137.js
+++ b/supervisor/api/panel/chunk.07363f9b958809b22137.js
@@ -0,0 +1,2 @@
+(self.webpackJsonp=self.webpackJsonp||[]).push([[1],{191:function(e,r,n){"use strict";n.r(r),n.d(r,"codeMirror",function(){return c}),n.d(r,"codeMirrorCss",function(){return i});var a=n(54),o=n.n(a),s=n(181),t=(n(182),n(183),n(12));o.a.commands.save=function(e){Object(t.a)(e.getWrapperElement(),"editor-save")};var c=o.a,i=s.a}}]);
+//# sourceMappingURL=chunk.07363f9b958809b22137.js.map
--- a/supervisor/api/panel/chunk.07363f9b958809b22137.js.gz
+++ b/supervisor/api/panel/chunk.07363f9b958809b22137.js.gz
--- a/supervisor/api/panel/chunk.07363f9b958809b22137.js.map
+++ b/supervisor/api/panel/chunk.07363f9b958809b22137.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///./src/resources/codemirror.ts"],"names":["__webpack_require__","r","__webpack_exports__","d","codeMirror","codeMirrorCss","codemirror__WEBPACK_IMPORTED_MODULE_0__","codemirror__WEBPACK_IMPORTED_MODULE_0___default","n","codemirror_lib_codemirror_css__WEBPACK_IMPORTED_MODULE_1__","_common_dom_fire_event__WEBPACK_IMPORTED_MODULE_4__","_CodeMirror","commands","save","cm","fireEvent","getWrapperElement","_codeMirrorCss"],"mappings":"sFAAAA,EAAAC,EAAAC,GAAAF,EAAAG,EAAAD,EAAA,+BAAAE,IAAAJ,EAAAG,EAAAD,EAAA,kCAAAG,IAAA,IAAAC,EAAAN,EAAA,IAAAO,EAAAP,EAAAQ,EAAAF,GAAAG,EAAAT,EAAA,KAAAU,GAAAV,EAAA,KAAAA,EAAA,KAAAA,EAAA,KAQAW,IAAYC,SAASC,KAAO,SAACC,GAC3BC,YAAUD,EAAGE,oBAAqB,gBAE7B,IAAMZ,EAAkBO,IAClBN,EAAqBY","file":"chunk.07363f9b958809b22137.js","sourcesContent":["// @ts-ignore\nimport _CodeMirror, { Editor } from \"codemirror\";\n// @ts-ignore\nimport _codeMirrorCss from \"codemirror/lib/codemirror.css\";\nimport \"codemirror/mode/jinja2/jinja2\";\nimport \"codemirror/mode/yaml/yaml\";\nimport { fireEvent } from \"../common/dom/fire_event\";\n\n_CodeMirror.commands.save = (cm: Editor) => {\n  fireEvent(cm.getWrapperElement(), \"editor-save\");\n};\nexport const codeMirror: any = _CodeMirror;\nexport const codeMirrorCss: any = _codeMirrorCss;\n"],"sourceRoot":""}
--- a/supervisor/api/panel/chunk.0b82745c7bdffe5c1404.js
+++ b/supervisor/api/panel/chunk.0b82745c7bdffe5c1404.js
--- a/supervisor/api/panel/chunk.0b82745c7bdffe5c1404.js.gz
+++ b/supervisor/api/panel/chunk.0b82745c7bdffe5c1404.js.gz
--- a/supervisor/api/panel/chunk.0b82745c7bdffe5c1404.js.map
+++ b/supervisor/api/panel/chunk.0b82745c7bdffe5c1404.js.map
--- a/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js
+++ b/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js
--- a/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js.LICENSE
+++ b/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js.LICENSE
--- a/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js.gz
+++ b/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js.gz
--- a/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js.map
+++ b/supervisor/api/panel/chunk.0f20b7eb2535b079dbfe.js.map
--- a/supervisor/api/panel/chunk.19d5bc1992ac27173ab6.js
+++ b/supervisor/api/panel/chunk.19d5bc1992ac27173ab6.js
--- a/supervisor/api/panel/chunk.19d5bc1992ac27173ab6.js.gz
+++ b/supervisor/api/panel/chunk.19d5bc1992ac27173ab6.js.gz
--- a/supervisor/api/panel/chunk.19d5bc1992ac27173ab6.js.map
+++ b/supervisor/api/panel/chunk.19d5bc1992ac27173ab6.js.map
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`"""Special object and tools for Hass.io."""`
				`@@ -1 +0,0 @@`
				<mxfile userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36" version="7.9.5" editor="www.draw.io" type="device"><diagram name="Page-1" id="535f6c39-9b73-04c2-941c-82630de90f1a">5VrLcqM4FP0aLzsFiOcycefRVTPVqfFippdYKLYmMvII4cd8/QiQDEKQ4Bicnmp7Yevqybk691zJnoH55vDI4u36d5ogMnOs5DADX2eOY1vAER+F5VhZ3DCoDCuGE9moNizwv0j1lNYcJyjTGnJKCcdb3QhpmiLINVvMGN3rzV4o0WfdxitkGBYwJqb1T5zwtbTaflRXPCG8WsupQ8evKpYxfF0xmqdyvpkDXspXVb2J1VjyQbN1nNB9wwTuZ2DOKOXVt81hjkiBrYKt6vfQU3taN0MpH9JB+mkXkxypFftEdL17oWIEsUB+lKD4/+RUVXzJSpfdigZitoP4EBUl0KJuL4EpalPKNjGpO4tvq+Lz+0LNI9ZWTVVVSFhOszr7NeZosY1hUd6L7SYarfmGiJJdrAYTMqeEsrK1ABv5EAp7xhl9RY0aq3zJ9S/k+B14SdMOMY4ODZPE7xHRDeLsKJqo2ghUXeRe9yLp2329c1wF9LqxaXzZLpabdXUaunaY+CJ91u0/YPjvW4oLvy2OGUebC9GECVqGyy40gQ8ikJz8NS6AwUAAnREAdA0Av1L4itilyEHkCdJfGznXRM7pQg6MgJxvIPc0N1ArQyEqehTUO5PLIUTdXF6GnutZ42Do+p6OoW9i6FkmhN4IEEYGXigROiSLlPE1XdE0Jve19U5HtIEeOmD+V2G+CTxZ/KGqUrGwqs5TxR9yhL8R50epwHHOqTDVE/9G6VaO0Qt1RnMG5fKlyvOYrRDXtknxYG+6gyESc7zTBfgScFUuMTa6zhvoRiLxaeFbFp4Rw+IBELsS6O5ngR705hPLWuHPSzBsv0gw2gnEIt8itsOZCAlqAqbqnuIs+/a9N8E4mZe9SUe9Dez3w5YRnuZz369SDT2gJR4KE3ecsAU8PWyBjqzDDjvilj2GatrOFNyyG8RSUezELY1XZRgbSqJMMIPfFqcCYYBEbA4MlfkBE7WKQVyz1WmkQbbgs8gGpolwmhd0J7Tkoy62A9xAzIe6EKWJOZgwNobqTPjn80sc64Sfpl0qHjSSKzHKl1vx6ALDIppdJ2LFKHyBYyWresRyOtL8U3DS0nx3jIjlX5kr9o2l5wI3dhhemg8MpFWDLilNkcaVN9NmjRHAZITal9dnhDuJ4kifNZK5kRAe7tC+awqYs92Jzx922Kdpk2veTHzAgRoIvd4832d9InK52zrx/rjrrqE1pqduk4SmmeGvbB1vi69bRiHKsvd1RhelwarzIF6lcleHAMFSy/EDEDnA90InDC0XTJRFd2mSY3umJkUjSJK6vJsypNWltuRcmtTJsNck2Sgn2/FClez6THF50JQuV2ei9rlJjVDRUnZyGjfnZ45TUdkYp9wUp6cZtk9Ck6CQU/OKUvEz35CqAbgrqIChQD5eIvJMM8wxTUWTJeWcbkQDUlTcnX610K7Sy98t6jFuCV4VfTk9j+b1zXv7rl5OMAKRW5d4oOMSD3SklqNcwZs0HkBSK9BY6r7HUtvk6BA6XkXzztTxQYqofkH8KZIZtZgGA/f7vRm9CcHbrHSDZCIkNE8u1smrECjS45lrdZzOgqnuk8DbN+Fyc3/gOHYmRybK5RtaW58Bq0U6vWo7jCauSRO1WydXUre1ZdrRdDwJBP0/01lP+bJXCWHMLqefX7466OcV73HoF4FWOtFFv67r3FEULJiIfc19H4yZZU5P2WHs867BvsFu9AySPGK+npoefeqE7MRDwTT0cNWh9Sr0CH8VcYp8naPBZdrk/xraZP4R4g+0LY5alGHUf4vy/yWfusifgHyiWP/5rXJG/Q9DcP8f</diagram></mxfile>
				`@@ -0,0 +1 @@`
				{"version":3,"sources":["webpack:///./src/resources/codemirror.ts"],"names":["__webpack_require__","r","__webpack_exports__","d","codeMirror","codeMirrorCss","codemirror__WEBPACK_IMPORTED_MODULE_0__","codemirror__WEBPACK_IMPORTED_MODULE_0___default","n","codemirror_lib_codemirror_css__WEBPACK_IMPORTED_MODULE_1__","_common_dom_fire_event__WEBPACK_IMPORTED_MODULE_4__","_CodeMirror","commands","save","cm","fireEvent","getWrapperElement","_codeMirrorCss"],"mappings":"sFAAAA,EAAAC,EAAAC,GAAAF,EAAAG,EAAAD,EAAA,+BAAAE,IAAAJ,EAAAG,EAAAD,EAAA,kCAAAG,IAAA,IAAAC,EAAAN,EAAA,IAAAO,EAAAP,EAAAQ,EAAAF,GAAAG,EAAAT,EAAA,KAAAU,GAAAV,EAAA,KAAAA,EAAA,KAAAA,EAAA,KAQAW,IAAYC,SAASC,KAAO,SAACC,GAC3BC,YAAUD,EAAGE,oBAAqB,gBAE7B,IAAMZ,EAAkBO,IAClBN,EAAqBY","file":"chunk.07363f9b958809b22137.js","sourcesContent":["// @ts-ignore\nimport _CodeMirror, { Editor } from \"codemirror\";\n// @ts-ignore\nimport _codeMirrorCss from \"codemirror/lib/codemirror.css\";\nimport \"codemirror/mode/jinja2/jinja2\";\nimport \"codemirror/mode/yaml/yaml\";\nimport { fireEvent } from \"../common/dom/fire_event\";\n\n_CodeMirror.commands.save = (cm: Editor) => {\n fireEvent(cm.getWrapperElement(), \"editor-save\");\n};\nexport const codeMirror: any = _CodeMirror;\nexport const codeMirrorCss: any = _codeMirrorCss;\n"],"sourceRoot":""}