fix: Chef cook uses wrong toolchain

This adds a toolchain setup step to the base image so we do not have to
do it multiple times

.cargo/config.toml

@@ -1,3 +1,2 @@
-[build]
+[env]
-target = "x86_64-unknown-linux-gnu"
+RUST_LOG = "automation=debug"
-rustflags = ["--cfg", "tokio_unstable"]

.dockerignore

@@ -1,2 +1,4 @@
 /target
 .env
+# Use the rust environment provided by the container
+rust-toolchain.toml

.gitattributes

@@ -0,0 +1 @@
+*.xcf filter=lfs diff=lfs merge=lfs -text

.gitea/workflows/build.yml

@@ -1,84 +1,24 @@
-# Based on: https://pastebin.com/99Fq2b2w
 name: Build and deploy
 on:
     push:
         branches:
             - master
             - feature/**
+        tags:
+            - v*.*.*
 
 jobs:
     build:
-        name: Build application
+        uses: dreaded_x/workflows/.gitea/workflows/docker-kubernetes.yaml@ef78704b98c72e4a6b8340f9bff7b085a7bdd95c
-        runs-on: ubuntu-latest
+        secrets: inherit
-        container: catthehacker/ubuntu:act-latest
+        with:
-        steps:
+            push_manifests: false
-            - name: Checkout
-              uses: actions/checkout@v4
-
-            - name: Setup Rust
-              uses: actions-rust-lang/setup-rust-toolchain@v1
-              with:
-                  rustflags: ""
-
-            - name: Build
-              run: cargo build --release
-
-            - name: Upload artifact
-              uses: actions/upload-artifact@v3
-              with:
-                  name: automation
-                  path: target/x86_64-unknown-linux-gnu/release/automation
-
-    container:
-        name: Build container
-        runs-on: ubuntu-latest
-        needs: [build]
-        container: catthehacker/ubuntu:act-latest
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-
-            - name: Download artifact
-              uses: actions/download-artifact@v3
-              with:
-                  name: automation
-
-            - name: Set permissions
-              run: |
-                  chown 65532:65532 ./automation
-                  chmod 0755 ./automation
-
-            - name: Docker meta
-              id: meta
-              uses: https://github.com/docker/metadata-action@v5
-              with:
-                  images: git.huizinga.dev/dreaded_x/automation_rs
-                  tags: |
-                      type=ref,event=branch
-                      type=ref,event=pr
-                      type=semver,pattern={{version}}
-                      type=semver,pattern={{major}}.{{minor}}
-
-            - name: Login to registry
-              uses: https://github.com/docker/login-action@v3
-              with:
-                  registry: git.huizinga.dev
-                  username: ${{ gitea.actor }}
-                  password: ${{ secrets.REGISTRY_TOKEN }}
-
-            - name: Build and push Docker image
-              uses: https://github.com/docker/build-push-action@v5
-              with:
-                  context: .
-                  push: true
-                  tags: ${{ steps.meta.outputs.tags }}
-                  labels: ${{ steps.meta.outputs.labels }}
 
     deploy:
         name: Deploy container
         runs-on: ubuntu-latest
         container: catthehacker/ubuntu:act-latest
-        needs: [container]
+        needs: build
         if: gitea.ref == 'refs/heads/master'
         steps:
             - name: Stop and remove current container
@@ -94,14 +34,12 @@ jobs:
                     --name automation_rs \
                     --network mqtt \
                     -e RUST_LOG=automation=debug \
-                    -e MQTT_PASSWORD=${{ secrets.MQTT_PASSWORD }} \
+                    -e AUTOMATION__SECRETS__MQTT_PASSWORD=${{ secrets.MQTT_PASSWORD }} \
-                    -e HUE_TOKEN=${{ secrets.HUE_TOKEN }} \
+                    -e AUTOMATION__SECRETS__HUE_TOKEN=${{ secrets.HUE_TOKEN }} \
-                    -e NTFY_TOPIC=${{ secrets.NTFY_TOPIC }} \
+                    -e AUTOMATION__SECRETS__NTFY_TOPIC=${{ secrets.NTFY_TOPIC }} \
-                    git.huizinga.dev/dreaded_x/automation_rs:master
+                    $(echo ${{ toJSON(needs.build.outputs.images) }} | jq .automation -r)
 
                   docker network connect web automation_rs
 
             - name: Start container
               run: docker start automation_rs
-
-            # TODO: Perform a healthcheck

.gitea/workflows/checks.yml

@@ -1,31 +0,0 @@
-name: Check
-on:
-    push:
-        branches: "**"
-
-jobs:
-    check:
-        name: Run checks
-        runs-on: ubuntu-latest
-        container: git.huizinga.dev/dreaded_x/pre-commit:master
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-
-            - uses: https://gitea.com/actions/go-hashfiles@v0.0.1
-              id: get-hash
-              with:
-                  patterns: |-
-                      .pre-commit-config.yaml
-
-            - name: set PY
-              run: echo "PY=$(python -VV | sha256sum | cut -d ' ' -f1)" >> $GITHUB_ENV
-
-            - uses: actions/cache@v4
-              with:
-                  path: ~/.cache/pre-commit
-                  key: pre-commit|${{ env.PY }}|${{ steps.get-hash.outputs.hash }}
-
-            - name: Run pre-commit
-              run: SKIP=sqlx-prepare pre-commit run --show-diff-on-failure --color=always --all-files
-              shell: bash

.gitignore

@@ -1,2 +1,3 @@
 /target
 .env
+automation.toml

.pre-commit-config.yaml

@@ -1,32 +1,101 @@
+default_install_hook_types:
+  - pre-commit
+  - commit-msg
+default_stages:
+  - pre-commit
+
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.6.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
       - id: check-yaml
+        args:
+          - --allow-multiple-documents
       - id: check-toml
       - id: check-added-large-files
       - id: check-merge-conflict
 
-  - repo: https://github.com/doublify/pre-commit-rust
+  - repo: https://github.com/compilerla/conventional-pre-commit
-    rev: v1.0
+    rev: v4.2.0
     hooks:
-      - id: clippy
+      - id: conventional-pre-commit
-      - id: fmt
+        stages: [commit-msg]
+        args: [--verbose]
 
   - repo: https://github.com/JohnnyMorganz/StyLua
-    rev: v0.20.0
+    rev: v2.1.0
     hooks:
       - id: stylua
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.21.0
+    rev: v1.36.1
     hooks:
       - id: typos
         args: ["--force-exclude"]
 
-  - repo: https://github.com/pryorda/dockerfilelint-precommit-hooks
+  - repo: local
-    rev: v0.1.0
     hooks:
-      - id: dockerfilelint
+      - id: fmt
+        name: fmt
+        description: Format files with cargo fmt.
+        entry: cargo +nightly fmt
+        language: system
+        types: [rust]
+        args: ["--", "--check"]
+        # For some reason some formatting is different depending on how you invoke?
+        pass_filenames: false
+
+      - id: clippy
+        name: clippy
+        description: Lint rust sources
+        entry: cargo clippy
+        language: system
+        args: ["--", "-D", "warnings"]
+        types: [file]
+        files: (\.rs|Cargo.lock)$
+        pass_filenames: false
+
+      - id: generate_definitions
+        name: generate definitions
+        description: Generate lua definitions
+        entry: cargo run --bin generate_definitions
+        language: system
+        types: [rust]
+        pass_filenames: false
+
+      - id: test
+        name: test
+        description: Rust test
+        entry: cargo test
+        language: system
+        args: ["--workspace"]
+        types: [file]
+        files: (\.rs|Cargo.lock)$
+        pass_filenames: false
+
+      - id: udeps
+        name: unused
+        description: Check for unused crates
+        entry: cargo udeps
+        args: ["--workspace"]
+        language: system
+        types: [file]
+        files: (\.rs|Cargo.lock)$
+        pass_filenames: false
+
+      - id: audit
+        name: audit
+        description: Audit packages
+        entry: cargo audit
+        args: ["--deny", "warnings"]
+        language: system
+        pass_filenames: false
+        verbose: true
+        always_run: true
+
+  - repo: https://github.com/hadolint/hadolint
+    rev: v2.13.1
+    hooks:
+      - id: hadolint

.typos.toml

@@ -1,2 +0,0 @@
-[default.extend-words]
-mosquitto = "mosquitto"

Cargo.toml

@@ -1,49 +1,43 @@
 [package]
 name = "automation"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
+default-run = "automation"
 
 [workspace]
-members = ["automation_macro", "automation_cast", "google_home/google_home", "google_home/google_home_macro"]
+members = [
+  "automation_cast",
+  "automation_devices",
+  "automation_lib",
+  "automation_macro",
+  "google_home/google_home",
+  "google_home/google_home_macro",
+]
 
-
+[workspace.dependencies]
-[dependencies]
+air_filter_types = { git = "https://git.huizinga.dev/Dreaded_X/airfilter", tag = "v0.4.4" }
+anyhow = "1.0.99"
+async-trait = "0.1.89"
+automation_cast = { path = "./automation_cast" }
+automation_devices = { path = "./automation_devices" }
+automation_lib = { path = "./automation_lib" }
 automation_macro = { path = "./automation_macro" }
-automation_cast = { path = "./automation_cast/" }
+axum = "0.8.4"
-rumqttc = "0.18"
+bytes = "1.10.1"
-serde = { version = "1.0.149", features = ["derive"] }
+dyn-clone = "1.0.20"
-serde_json = "1.0.89"
+eui48 = { version = "1.1.0", features = [
-google_home = { path = "./google_home/google_home/" }
-paste = "1.0.10"
-tokio = { version = "1", features = ["rt-multi-thread"] }
-dotenvy = "0.15.0"
-reqwest = { version = "0.11.13", features = [
-  "json",
-  "rustls-tls",
-], default-features = false } # Use rustls, since the other packages also use rustls
-axum = "0.6.1"
-serde_repr = "0.1.10"
-tracing = "0.1.37"
-bytes = "1.3.0"
-pollster = "0.2.5"
-regex = "1.7.0"
-async-trait = "0.1.61"
-futures = "0.3.25"
-eui48 = { version = "1.1.0", default-features = false, features = [
   "disp_hexstring",
   "serde",
-] }
+], default-features = false }
-thiserror = "1.0.38"
+futures = "0.3.31"
-anyhow = "1.0.68"
+google_home = { path = "./google_home/google_home" }
-wakey = "0.3.0"
+google_home_macro = { path = "./google_home/google_home_macro" }
-console-subscriber = "0.1.8"
+hostname = "0.4.1"
-tracing-subscriber = "0.3.16"
+inventory = "0.3.21"
-serde_with = "3.2.0"
+itertools = "0.14.0"
-enum_dispatch = "0.3.12"
+json_value_merge = "2.0.1"
-indexmap = { version = "2.0.0", features = ["serde"] }
+lua_typed = { git = "https://git.huizinga.dev/Dreaded_X/lua_typed" }
-serde_yaml = "0.9.27"
+mlua = { version = "0.11.3", features = [
-tokio-cron-scheduler = "0.9.4"
-mlua = { version = "0.9.7", features = [
   "lua54",
   "vendored",
   "macros",
@@ -51,14 +45,55 @@ mlua = { version = "0.9.7", features = [
   "async",
   "send",
 ] }
-once_cell = "1.19.0"
+proc-macro2 = "1.0.101"
-hostname = "0.4.0"
+quote = "1.0.40"
-tokio-util = { version = "0.7.11", features = ["full"] }
+reqwest = { version = "0.12.23", features = [
-uuid = "1.8.0"
+  "json",
-dyn-clone = "1.0.17"
+  "rustls-tls",
+], default-features = false } # Use rustls, since the other packages also use rustls
+rumqttc = "0.24.0"
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.143"
+serde_repr = "0.1.20"
+syn = { version = "2.0.106" }
+thiserror = "2.0.16"
+tokio = { version = "1", features = ["rt-multi-thread"] }
+tokio-cron-scheduler = "0.15.0"
+tracing = "0.1.41"
+tracing-subscriber = "0.3.20"
+wakey = "0.3.0"
+
+[dependencies]
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+automation_devices = { workspace = true }
+automation_lib = { workspace = true }
+automation_macro = { path = "./automation_macro" }
+axum = { workspace = true }
+config = { version = "0.15.15", default-features = false, features = [
+  "async",
+  "toml",
+] }
+git-version = "0.3.9"
+google_home = { workspace = true }
+lua_typed = { workspace = true }
+inventory = { workspace = true }
+mlua = { workspace = true }
+reqwest = { workspace = true }
+rumqttc = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+tokio-cron-scheduler = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [patch.crates-io]
 wakey = { git = "https://git.huizinga.dev/Dreaded_X/wakey" }
 
 [profile.release]
 lto = true
+
+[package.metadata.typos.default.extend-words]
+mosquitto = "mosquitto"

Dockerfile

@@ -1,8 +1,29 @@
-FROM gcr.io/distroless/cc-debian12:nonroot
+FROM rust:1.89 AS base
+ENV CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse
+RUN cargo install cargo-chef --locked --version 0.1.71 && \
+    cargo install cargo-auditable --locked --version 0.6.6
+WORKDIR /app
+COPY ./rust-toolchain.toml .
+RUN rustup toolchain install
 
-ENV AUTOMATION_CONFIG=/app/config.lua
+FROM base AS planner
-COPY ./config.lua /app/config.lua
+COPY . .
+RUN cargo chef prepare --recipe-path recipe.json
 
-COPY ./automation /app/automation
+FROM base AS builder
+# HACK: Now we can use unstable feature while on stable rust!
+ENV RUSTC_BOOTSTRAP=1
+COPY --from=planner /app/recipe.json recipe.json
+RUN cargo chef cook --release --recipe-path recipe.json
 
-CMD ["/app/automation"]
+COPY . .
+ARG RELEASE_VERSION
+ENV RELEASE_VERSION=${RELEASE_VERSION}
+RUN cargo auditable build --release
+
+FROM gcr.io/distroless/cc-debian12:nonroot AS runtime
+COPY --from=builder /app/target/release/automation /app/automation
+ENV AUTOMATION__ENTRYPOINT=/app/config/config.lua
+ENV LUA_PATH="/app/?.lua;;"
+COPY ./config /app/config
+CMD [ "/app/automation" ]

automation_cast/Cargo.toml

@@ -1,8 +1,6 @@
 [package]
 name = "automation_cast"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]

automation_devices/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "automation_devices"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+air_filter_types = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+automation_lib = { workspace = true }
+automation_macro = { workspace = true }
+bytes = { workspace = true }
+dyn-clone = { workspace = true }
+eui48 = { workspace = true }
+google_home = { workspace = true }
+inventory = { workspace = true }
+lua_typed = { workspace = true }
+mlua = { workspace = true }
+reqwest = { workspace = true }
+rumqttc = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+serde_repr = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+wakey = { workspace = true }

automation_devices/src/air_filter.rs

@@ -1,66 +1,71 @@
-use std::sync::Arc;
-
 use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
+use automation_lib::config::InfoConfig;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_macro::{Device, LuaDeviceConfig};
 use google_home::device::Name;
 use google_home::errors::ErrorCode;
 use google_home::traits::{
-    AvailableSpeeds, FanSpeed, HumiditySetting, OnOff, Speed, SpeedValue, TemperatureSetting,
+    AvailableSpeeds, FanSpeed, HumiditySetting, OnOff, Speed, SpeedValue, TemperatureControl,
     TemperatureUnit,
 };
 use google_home::types::Type;
-use rumqttc::Publish;
+use lua_typed::Typed;
-use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use thiserror::Error;
-use tracing::{debug, error, trace, warn};
+use tracing::{debug, trace};
 
-use super::LuaDeviceCreate;
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
-use crate::config::{InfoConfig, MqttDeviceConfig};
+#[typed(as = "AirFilterConfig")]
-use crate::devices::Device;
-use crate::event::OnMqtt;
-use crate::messages::{AirFilterFanState, AirFilterState, SetAirFilterFanState};
-use crate::mqtt::WrappedAsyncClient;
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
 pub struct Config {
     #[device_config(flatten)]
+    #[typed(flatten)]
     pub info: InfoConfig,
-    #[device_config(flatten)]
+    pub url: String,
-    pub mqtt: MqttDeviceConfig,
-    #[device_config(from_lua)]
-    pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff))]
 pub struct AirFilter {
     config: Config,
-    state: Arc<RwLock<AirFilterState>>,
+}
+crate::register_device!(AirFilter);
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Connection error")]
+    ReqwestError(#[from] reqwest::Error),
 }
 
+impl From<Error> for google_home::errors::ErrorCode {
+    fn from(value: Error) -> Self {
+        match value {
+            // Assume that if we encounter a ReqwestError the device is offline
+            Error::ReqwestError(_) => {
+                Self::DeviceError(google_home::errors::DeviceError::DeviceOffline)
+            }
+        }
+    }
+}
+
+// TODO: Handle error properly
 impl AirFilter {
-    async fn set_speed(&self, state: AirFilterFanState) {
+    async fn set_fan_speed(&self, speed: air_filter_types::FanSpeed) -> Result<(), Error> {
-        let message = SetAirFilterFanState::new(state);
+        let message = air_filter_types::SetFanSpeed::new(speed);
+        let url = format!("{}/state/fan", self.config.url);
+        let client = reqwest::Client::new();
+        client.put(url).json(&message).send().await?;
 
-        let topic = format!("{}/set", self.config.mqtt.topic);
+        Ok(())
-        // TODO: Handle potential errors here
-        self.config
-            .client
-            .publish(
-                &topic,
-                rumqttc::QoS::AtLeastOnce,
-                false,
-                serde_json::to_string(&message).unwrap(),
-            )
-            .await
-            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
-            .ok();
     }
 
-    async fn state(&self) -> RwLockReadGuard<AirFilterState> {
+    async fn get_fan_state(&self) -> Result<air_filter_types::FanState, Error> {
-        self.state.read().await
+        let url = format!("{}/state/fan", self.config.url);
+        Ok(reqwest::get(url).await?.json().await?)
     }
 
-    async fn state_mut(&self) -> RwLockWriteGuard<AirFilterState> {
+    async fn get_sensor_data(&self) -> Result<air_filter_types::SensorData, Error> {
-        self.state.write().await
+        let url = format!("{}/state/sensor", self.config.url);
+        Ok(reqwest::get(url).await?.json().await?)
     }
 }
 
@@ -72,19 +77,7 @@ impl LuaDeviceCreate for AirFilter {
     async fn create(config: Self::Config) -> Result<Self, Self::Error> {
         trace!(id = config.info.identifier(), "Setting up AirFilter");
 
-        config
+        Ok(Self { config })
-            .client
-            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
-            .await?;
-
-        let state = AirFilterState {
-            state: AirFilterFanState::Off,
-            humidity: 0.0,
-            temperature: 0.0,
-        };
-        let state = Arc::new(RwLock::new(state));
-
-        Ok(Self { config, state })
     }
 }
 
@@ -95,30 +88,6 @@ impl Device for AirFilter {
 }
 
 #[async_trait]
-impl OnMqtt for AirFilter {
-    async fn on_mqtt(&self, message: Publish) {
-        if !rumqttc::matches(&message.topic, &self.config.mqtt.topic) {
-            return;
-        }
-
-        let state = match AirFilterState::try_from(message) {
-            Ok(state) => state,
-            Err(err) => {
-                error!(id = Device::get_id(self), "Failed to parse message: {err}");
-                return;
-            }
-        };
-
-        if state == *self.state().await {
-            return;
-        }
-
-        debug!(id = Device::get_id(self), "Updating state to {state:?}");
-
-        *self.state_mut().await = state;
-    }
-}
-
 impl google_home::Device for AirFilter {
     fn get_device_type(&self) -> Type {
         Type::AirPurifier
@@ -132,8 +101,8 @@ impl google_home::Device for AirFilter {
         Device::get_id(self)
     }
 
-    fn is_online(&self) -> bool {
+    async fn is_online(&self) -> bool {
-        true
+        self.get_sensor_data().await.is_ok()
     }
 
     fn get_room_hint(&self) -> Option<&str> {
@@ -148,16 +117,16 @@ impl google_home::Device for AirFilter {
 #[async_trait]
 impl OnOff for AirFilter {
     async fn on(&self) -> Result<bool, ErrorCode> {
-        Ok(self.state().await.state != AirFilterFanState::Off)
+        Ok(self.get_fan_state().await?.speed != air_filter_types::FanSpeed::Off)
     }
 
     async fn set_on(&self, on: bool) -> Result<(), ErrorCode> {
         debug!("Turning on air filter: {on}");
 
         if on {
-            self.set_speed(AirFilterFanState::High).await;
+            self.set_fan_speed(air_filter_types::FanSpeed::High).await?;
         } else {
-            self.set_speed(AirFilterFanState::Off).await;
+            self.set_fan_speed(air_filter_types::FanSpeed::Off).await?;
         }
 
         Ok(())
@@ -203,11 +172,12 @@ impl FanSpeed for AirFilter {
     }
 
     async fn current_fan_speed_setting(&self) -> Result<String, ErrorCode> {
-        let speed = match self.state().await.state {
+        let speed = self.get_fan_state().await?.speed;
-            AirFilterFanState::Off => "off",
+        let speed = match speed {
-            AirFilterFanState::Low => "low",
+            air_filter_types::FanSpeed::Off => "off",
-            AirFilterFanState::Medium => "medium",
+            air_filter_types::FanSpeed::Low => "low",
-            AirFilterFanState::High => "high",
+            air_filter_types::FanSpeed::Medium => "medium",
+            air_filter_types::FanSpeed::High => "high",
         };
 
         Ok(speed.into())
@@ -215,19 +185,19 @@ impl FanSpeed for AirFilter {
 
     async fn set_fan_speed(&self, fan_speed: String) -> Result<(), ErrorCode> {
         let fan_speed = fan_speed.as_str();
-        let state = if fan_speed == "off" {
+        let speed = if fan_speed == "off" {
-            AirFilterFanState::Off
+            air_filter_types::FanSpeed::Off
         } else if fan_speed == "low" {
-            AirFilterFanState::Low
+            air_filter_types::FanSpeed::Low
         } else if fan_speed == "medium" {
-            AirFilterFanState::Medium
+            air_filter_types::FanSpeed::Medium
         } else if fan_speed == "high" {
-            AirFilterFanState::High
+            air_filter_types::FanSpeed::High
         } else {
             return Err(google_home::errors::DeviceError::TransientError.into());
         };
 
-        self.set_speed(state).await;
+        self.set_fan_speed(speed).await?;
 
         Ok(())
     }
@@ -240,12 +210,12 @@ impl HumiditySetting for AirFilter {
     }
 
     async fn humidity_ambient_percent(&self) -> Result<isize, ErrorCode> {
-        Ok(self.state().await.humidity.round() as isize)
+        Ok(self.get_sensor_data().await?.humidity().round() as isize)
     }
 }
 
 #[async_trait]
-impl TemperatureSetting for AirFilter {
+impl TemperatureControl for AirFilter {
     fn query_only_temperature_control(&self) -> Option<bool> {
         Some(true)
     }
@@ -255,8 +225,8 @@ impl TemperatureSetting for AirFilter {
         TemperatureUnit::Celsius
     }
 
-    async fn temperature_ambient_celsius(&self) -> f32 {
+    async fn temperature_ambient_celsius(&self) -> Result<f32, ErrorCode> {
         // HACK: Round to one decimal place
-        (10.0 * self.state().await.temperature).round() / 10.0
+        Ok((10.0 * self.get_sensor_data().await?.temperature()).round() / 10.0)
     }
 }

automation_devices/src/contact_sensor.rs

@@ -0,0 +1,192 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::{InfoConfig, MqttDeviceConfig};
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::error::DeviceConfigError;
+use automation_lib::event::OnMqtt;
+use automation_lib::messages::ContactMessage;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig};
+use google_home::device;
+use google_home::errors::{DeviceError, ErrorCode};
+use google_home::traits::OpenClose;
+use google_home::types::Type;
+use lua_typed::Typed;
+use serde::Deserialize;
+use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use tracing::{debug, error, trace};
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Copy, Typed)]
+pub enum SensorType {
+    Door,
+    Drawer,
+    Window,
+}
+crate::register_type!(SensorType);
+
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "ContactSensorConfig")]
+pub struct Config {
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub info: InfoConfig,
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub mqtt: MqttDeviceConfig,
+
+    #[device_config(default(SensorType::Window))]
+    #[typed(default)]
+    pub sensor_type: SensorType,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub callback: ActionCallback<(ContactSensor, bool)>,
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub battery_callback: ActionCallback<(ContactSensor, f32)>,
+
+    #[device_config(from_lua)]
+    #[typed(default)]
+    pub client: WrappedAsyncClient,
+}
+crate::register_type!(Config);
+
+#[derive(Debug)]
+struct State {
+    is_closed: bool,
+}
+
+#[derive(Debug, Clone, Device)]
+#[device(traits(OpenClose))]
+pub struct ContactSensor {
+    config: Config,
+    state: Arc<RwLock<State>>,
+}
+crate::register_device!(ContactSensor);
+
+impl ContactSensor {
+    async fn state(&self) -> RwLockReadGuard<'_, State> {
+        self.state.read().await
+    }
+
+    async fn state_mut(&self) -> RwLockWriteGuard<'_, State> {
+        self.state.write().await
+    }
+}
+
+#[async_trait]
+impl LuaDeviceCreate for ContactSensor {
+    type Config = Config;
+    type Error = DeviceConfigError;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = config.info.identifier(), "Setting up ContactSensor");
+
+        config
+            .client
+            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
+            .await?;
+
+        let state = State { is_closed: true };
+        let state = Arc::new(RwLock::new(state));
+
+        Ok(Self { config, state })
+    }
+}
+
+impl Device for ContactSensor {
+    fn get_id(&self) -> String {
+        self.config.info.identifier()
+    }
+}
+
+#[async_trait]
+impl google_home::Device for ContactSensor {
+    fn get_device_type(&self) -> google_home::types::Type {
+        match self.config.sensor_type {
+            SensorType::Door => Type::Door,
+            SensorType::Drawer => Type::Drawer,
+            SensorType::Window => Type::Window,
+        }
+    }
+
+    fn get_id(&self) -> String {
+        Device::get_id(self)
+    }
+
+    fn get_device_name(&self) -> google_home::device::Name {
+        device::Name::new(&self.config.info.name)
+    }
+
+    fn get_room_hint(&self) -> Option<&str> {
+        self.config.info.room.as_deref()
+    }
+
+    fn will_report_state(&self) -> bool {
+        false
+    }
+
+    async fn is_online(&self) -> bool {
+        true
+    }
+}
+
+#[async_trait]
+impl OpenClose for ContactSensor {
+    fn discrete_only_open_close(&self) -> Option<bool> {
+        Some(true)
+    }
+
+    fn query_only_open_close(&self) -> Option<bool> {
+        Some(true)
+    }
+
+    async fn open_percent(&self) -> Result<u8, ErrorCode> {
+        if self.state().await.is_closed {
+            Ok(0)
+        } else {
+            Ok(100)
+        }
+    }
+
+    async fn set_open_percent(&self, _open_percent: u8) -> Result<(), ErrorCode> {
+        Err(DeviceError::ActionNotAvailable.into())
+    }
+}
+
+#[async_trait]
+impl OnMqtt for ContactSensor {
+    async fn on_mqtt(&self, message: rumqttc::Publish) {
+        if !rumqttc::matches(&message.topic, &self.config.mqtt.topic) {
+            return;
+        }
+
+        let message = match ContactMessage::try_from(message) {
+            Ok(message) => message,
+            Err(err) => {
+                error!(id = self.get_id(), "Failed to parse message: {err}");
+                return;
+            }
+        };
+
+        if let Some(is_closed) = message.contact {
+            if is_closed == self.state().await.is_closed {
+                return;
+            }
+
+            self.config.callback.call((self.clone(), !is_closed)).await;
+
+            debug!(id = self.get_id(), "Updating state to {is_closed}");
+            self.state_mut().await.is_closed = is_closed;
+        }
+
+        if let Some(battery) = message.battery {
+            self.config
+                .battery_callback
+                .call((self.clone(), battery))
+                .await;
+        }
+    }
+}

automation_devices/src/hue_bridge.rs

@@ -2,39 +2,72 @@ use std::convert::Infallible;
 use std::net::SocketAddr;
 
 use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::lua::traits::PartialUserData;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
+use mlua::LuaSerdeExt;
 use serde::{Deserialize, Serialize};
 use tracing::{error, trace, warn};
 
-use super::LuaDeviceCreate;
+#[derive(Debug, Deserialize, Typed)]
-use crate::devices::Device;
+#[serde(rename_all = "snake_case")]
-use crate::event::{OnDarkness, OnPresence};
+#[typed(rename_all = "snake_case")]
-
-#[derive(Debug)]
 pub enum Flag {
     Presence,
     Darkness,
 }
+crate::register_type!(Flag);
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Typed)]
 pub struct FlagIDs {
     presence: isize,
     darkness: isize,
 }
+crate::register_type!(FlagIDs);
 
-#[derive(Debug, LuaDeviceConfig, Clone)]
+#[derive(Debug, LuaDeviceConfig, Clone, Typed)]
+#[typed(as = "HueBridgeConfig")]
 pub struct Config {
     pub identifier: String,
     #[device_config(rename("ip"), with(|ip| SocketAddr::new(ip, 80)))]
+    #[typed(as = "ip")]
     pub addr: SocketAddr,
     pub login: String,
     pub flags: FlagIDs,
 }
+crate::register_type!(Config);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Device)]
+#[device(extra_user_data = SetFlag)]
 pub struct HueBridge {
     config: Config,
 }
+crate::register_device!(HueBridge);
+
+struct SetFlag;
+impl PartialUserData<HueBridge> for SetFlag {
+    fn add_methods<M: mlua::UserDataMethods<HueBridge>>(methods: &mut M) {
+        methods.add_async_method(
+            "set_flag",
+            async |lua, this, (flag, value): (mlua::Value, bool)| {
+                let flag: Flag = lua.from_value(flag)?;
+
+                this.set_flag(flag, value).await;
+
+                Ok(())
+            },
+        );
+    }
+
+    fn definitions() -> Option<String> {
+        Some(format!(
+            "---@async\n---@param flag {}\n---@param value boolean\nfunction {}:set_flag(flag, value) end\n",
+            <Flag as Typed>::type_name(),
+            <HueBridge as Typed>::type_name(),
+        ))
+    }
+}
 
 #[derive(Debug, Serialize)]
 struct FlagMessage {
@@ -90,19 +123,3 @@ impl Device for HueBridge {
         self.config.identifier.clone()
     }
 }
-
-#[async_trait]
-impl OnPresence for HueBridge {
-    async fn on_presence(&self, presence: bool) {
-        trace!("Bridging presence to hue");
-        self.set_flag(Flag::Presence, presence).await;
-    }
-}
-
-#[async_trait]
-impl OnDarkness for HueBridge {
-    async fn on_darkness(&self, dark: bool) {
-        trace!("Bridging darkness to hue");
-        self.set_flag(Flag::Darkness, dark).await;
-    }
-}

automation_devices/src/hue_group.rs

@@ -0,0 +1,168 @@
+use std::net::SocketAddr;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use automation_macro::{Device, LuaDeviceConfig};
+use google_home::errors::ErrorCode;
+use google_home::traits::OnOff;
+use lua_typed::Typed;
+use tracing::{error, trace, warn};
+
+use super::{Device, LuaDeviceCreate};
+
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "HueGroupConfig")]
+pub struct Config {
+    pub identifier: String,
+    #[device_config(rename("ip"), with(|ip| SocketAddr::new(ip, 80)))]
+    #[typed(as = "ip")]
+    pub addr: SocketAddr,
+    pub login: String,
+    pub group_id: isize,
+    pub scene_id: String,
+}
+crate::register_type!(Config);
+
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff))]
+pub struct HueGroup {
+    config: Config,
+}
+crate::register_device!(HueGroup);
+
+// Couple of helper function to get the correct urls
+#[async_trait]
+impl LuaDeviceCreate for HueGroup {
+    type Config = Config;
+    type Error = rumqttc::ClientError;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = config.identifier, "Setting up AudioSetup");
+
+        Ok(Self { config })
+    }
+}
+
+impl HueGroup {
+    fn url_base(&self) -> String {
+        format!("http://{}/api/{}", self.config.addr, self.config.login)
+    }
+
+    fn url_set_action(&self) -> String {
+        format!("{}/groups/{}/action", self.url_base(), self.config.group_id)
+    }
+
+    fn url_get_state(&self) -> String {
+        format!("{}/groups/{}", self.url_base(), self.config.group_id)
+    }
+}
+
+impl Device for HueGroup {
+    fn get_id(&self) -> String {
+        self.config.identifier.clone()
+    }
+}
+
+#[async_trait]
+impl OnOff for HueGroup {
+    async fn set_on(&self, on: bool) -> Result<(), ErrorCode> {
+        let message = if on {
+            message::Action::scene(self.config.scene_id.clone())
+        } else {
+            message::Action::on(false)
+        };
+
+        let res = reqwest::Client::new()
+            .put(self.url_set_action())
+            .json(&message)
+            .send()
+            .await;
+
+        match res {
+            Ok(res) => {
+                let status = res.status();
+                if !status.is_success() {
+                    warn!(id = self.get_id(), "Status code is not success: {status}");
+                }
+            }
+            Err(err) => error!(id = self.get_id(), "Error: {err}"),
+        }
+
+        Ok(())
+    }
+
+    async fn on(&self) -> Result<bool, ErrorCode> {
+        let res = reqwest::Client::new()
+            .get(self.url_get_state())
+            .send()
+            .await;
+
+        match res {
+            Ok(res) => {
+                let status = res.status();
+                if !status.is_success() {
+                    warn!(id = self.get_id(), "Status code is not success: {status}");
+                }
+
+                let on = match res.json::<message::Info>().await {
+                    Ok(info) => info.any_on(),
+                    Err(err) => {
+                        error!(id = self.get_id(), "Failed to parse message: {err}");
+                        // TODO: Error code
+                        return Ok(false);
+                    }
+                };
+
+                return Ok(on);
+            }
+            Err(err) => error!(id = self.get_id(), "Error: {err}"),
+        }
+
+        Ok(false)
+    }
+}
+
+mod message {
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, Serialize, Deserialize)]
+    pub struct Action {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        on: Option<bool>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        scene: Option<String>,
+    }
+
+    impl Action {
+        pub fn on(on: bool) -> Self {
+            Self {
+                on: Some(on),
+                scene: None,
+            }
+        }
+
+        pub fn scene(scene: String) -> Self {
+            Self {
+                on: None,
+                scene: Some(scene),
+            }
+        }
+    }
+
+    #[derive(Debug, Serialize, Deserialize)]
+    struct State {
+        all_on: bool,
+        any_on: bool,
+    }
+
+    #[derive(Debug, Serialize, Deserialize)]
+    pub struct Info {
+        state: State,
+    }
+
+    impl Info {
+        pub fn any_on(&self) -> bool {
+            self.state.any_on
+        }
+    }
+}

automation_devices/src/hue_switch.rs

@@ -0,0 +1,147 @@
+use async_trait::async_trait;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::{InfoConfig, MqttDeviceConfig};
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
+use rumqttc::{Publish, matches};
+use serde::Deserialize;
+use tracing::{debug, trace, warn};
+
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "HueSwitchConfig")]
+pub struct Config {
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub info: InfoConfig,
+
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub mqtt: MqttDeviceConfig,
+
+    #[device_config(from_lua)]
+    pub client: WrappedAsyncClient,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub left_callback: ActionCallback<HueSwitch>,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub right_callback: ActionCallback<HueSwitch>,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub left_hold_callback: ActionCallback<HueSwitch>,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub right_hold_callback: ActionCallback<HueSwitch>,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub battery_callback: ActionCallback<(HueSwitch, f32)>,
+}
+crate::register_type!(Config);
+
+#[derive(Debug, Copy, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum Action {
+    LeftPress,
+    LeftPressRelease,
+    LeftHold,
+    LeftHoldRelease,
+    RightPress,
+    RightPressRelease,
+    RightHold,
+    RightHoldRelease,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct State {
+    action: Option<Action>,
+    battery: Option<f32>,
+}
+
+#[derive(Debug, Clone, Device)]
+pub struct HueSwitch {
+    config: Config,
+}
+crate::register_device!(HueSwitch);
+
+impl Device for HueSwitch {
+    fn get_id(&self) -> String {
+        self.config.info.identifier()
+    }
+}
+
+#[async_trait]
+impl LuaDeviceCreate for HueSwitch {
+    type Config = Config;
+    type Error = rumqttc::ClientError;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = config.info.identifier(), "Setting up HueSwitch");
+
+        config
+            .client
+            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
+            .await?;
+
+        Ok(Self { config })
+    }
+}
+
+#[async_trait]
+impl OnMqtt for HueSwitch {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the device itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let message = match serde_json::from_slice::<State>(&message.payload) {
+                Ok(message) => message,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            if let Some(action) = message.action {
+                debug!(
+                    id = Device::get_id(self),
+                    ?message.action,
+                    "Action received",
+                );
+
+                match action {
+                    Action::LeftPressRelease => self.config.left_callback.call(self.clone()).await,
+                    Action::RightPressRelease => {
+                        self.config.right_callback.call(self.clone()).await
+                    }
+                    Action::LeftHold => self.config.left_hold_callback.call(self.clone()).await,
+                    Action::RightHold => self.config.right_hold_callback.call(self.clone()).await,
+                    // If there is no hold action, the switch will act like a normal release
+                    Action::RightHoldRelease => {
+                        if self.config.right_hold_callback.is_empty() {
+                            self.config.right_callback.call(self.clone()).await
+                        }
+                    }
+                    Action::LeftHoldRelease => {
+                        if self.config.left_hold_callback.is_empty() {
+                            self.config.left_callback.call(self.clone()).await
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            if let Some(battery) = message.battery {
+                self.config
+                    .battery_callback
+                    .call((self.clone(), battery))
+                    .await;
+            }
+        }
+    }
+}

automation_devices/src/ikea_remote.rs

@@ -0,0 +1,112 @@
+use async_trait::async_trait;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::{InfoConfig, MqttDeviceConfig};
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::messages::{RemoteAction, RemoteMessage};
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
+use rumqttc::{Publish, matches};
+use tracing::{debug, error, trace};
+
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "IkeaRemoteConfig")]
+pub struct Config {
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub info: InfoConfig,
+
+    #[device_config(default)]
+    #[typed(default)]
+    pub single_button: bool,
+
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub mqtt: MqttDeviceConfig,
+
+    #[device_config(from_lua)]
+    pub client: WrappedAsyncClient,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub callback: ActionCallback<(IkeaRemote, bool)>,
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub battery_callback: ActionCallback<(IkeaRemote, f32)>,
+}
+crate::register_type!(Config);
+
+#[derive(Debug, Clone, Device)]
+pub struct IkeaRemote {
+    config: Config,
+}
+crate::register_device!(IkeaRemote);
+
+impl Device for IkeaRemote {
+    fn get_id(&self) -> String {
+        self.config.info.identifier()
+    }
+}
+
+#[async_trait]
+impl LuaDeviceCreate for IkeaRemote {
+    type Config = Config;
+    type Error = rumqttc::ClientError;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = config.info.identifier(), "Setting up IkeaRemote");
+
+        config
+            .client
+            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
+            .await?;
+
+        Ok(Self { config })
+    }
+}
+
+#[async_trait]
+impl OnMqtt for IkeaRemote {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the deviec itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let message = match RemoteMessage::try_from(message) {
+                Ok(message) => message,
+                Err(err) => {
+                    error!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            if let Some(action) = message.action {
+                debug!(id = Device::get_id(self), "Remote action = {:?}", action);
+
+                let on = if self.config.single_button {
+                    match action {
+                        RemoteAction::On => Some(true),
+                        RemoteAction::BrightnessMoveUp => Some(false),
+                        _ => None,
+                    }
+                } else {
+                    match action {
+                        RemoteAction::On => Some(true),
+                        RemoteAction::Off => Some(false),
+                        _ => None,
+                    }
+                };
+
+                if let Some(on) = on {
+                    self.config.callback.call((self.clone(), on)).await;
+                }
+            }
+
+            if let Some(battery) = message.battery {
+                self.config
+                    .battery_callback
+                    .call((self.clone(), battery))
+                    .await;
+            }
+        }
+    }
+}

automation_devices/src/kasa_outlet.rs

@@ -3,29 +3,34 @@ use std::net::SocketAddr;
 use std::str::Utf8Error;
 
 use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_macro::{Device, LuaDeviceConfig};
 use bytes::{Buf, BufMut};
 use google_home::errors::{self, DeviceError};
-use google_home::traits;
+use google_home::traits::OnOff;
+use lua_typed::Typed;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tracing::trace;
 
-use super::{Device, LuaDeviceCreate};
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
-
+#[typed(as = "KasaOutletConfig")]
-#[derive(Debug, Clone, LuaDeviceConfig)]
 pub struct Config {
     pub identifier: String,
     #[device_config(rename("ip"), with(|ip| SocketAddr::new(ip, 9999)))]
+    #[typed(as = "ip")]
     pub addr: SocketAddr,
 }
+crate::register_type!(Config);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff))]
 pub struct KasaOutlet {
     config: Config,
 }
+crate::register_device!(KasaOutlet);
 
 #[async_trait]
 impl LuaDeviceCreate for KasaOutlet {
@@ -206,7 +211,7 @@ impl Response {
 }
 
 #[async_trait]
-impl traits::OnOff for KasaOutlet {
+impl OnOff for KasaOutlet {
     async fn on(&self) -> Result<bool, errors::ErrorCode> {
         let mut stream = TcpStream::connect(self.config.addr)
             .await

automation_devices/src/lib.rs

@@ -0,0 +1,130 @@
+#![feature(iter_intersperse)]
+mod air_filter;
+mod contact_sensor;
+mod hue_bridge;
+mod hue_group;
+mod hue_switch;
+mod ikea_remote;
+mod kasa_outlet;
+mod light_sensor;
+mod ntfy;
+mod presence;
+mod wake_on_lan;
+mod washer;
+mod zigbee;
+
+use automation_lib::Module;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use tracing::{debug, warn};
+
+type DeviceNameFn = fn() -> String;
+type RegisterDeviceFn = fn(lua: &mlua::Lua) -> mlua::Result<mlua::AnyUserData>;
+
+pub struct RegisteredDevice {
+    name_fn: DeviceNameFn,
+    register_fn: RegisterDeviceFn,
+}
+
+impl RegisteredDevice {
+    pub const fn new(name_fn: DeviceNameFn, register_fn: RegisterDeviceFn) -> Self {
+        Self {
+            name_fn,
+            register_fn,
+        }
+    }
+
+    pub fn get_name(&self) -> String {
+        (self.name_fn)()
+    }
+
+    pub fn register(&self, lua: &mlua::Lua) -> mlua::Result<mlua::AnyUserData> {
+        (self.register_fn)(lua)
+    }
+}
+
+macro_rules! register_device {
+    ($device:ty) => {
+        ::inventory::submit!(crate::RegisteredDevice::new(
+            <$device as ::lua_typed::Typed>::type_name,
+            ::mlua::Lua::create_proxy::<$device>
+        ));
+
+        crate::register_type!($device);
+    };
+}
+pub(crate) use register_device;
+
+inventory::collect!(RegisteredDevice);
+
+pub fn create_module(lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
+    let devices = lua.create_table()?;
+
+    debug!("Loading devices...");
+    for device in inventory::iter::<RegisteredDevice> {
+        let name = device.get_name();
+        debug!(name, "Registering device");
+        let proxy = device.register(lua)?;
+        devices.set(name, proxy)?;
+    }
+
+    Ok(devices)
+}
+
+type TypeNameFn = fn() -> String;
+type TypeDefinitionFn = fn() -> Option<String>;
+
+pub struct RegisteredType {
+    name_fn: TypeNameFn,
+    definition_fn: TypeDefinitionFn,
+}
+
+impl RegisteredType {
+    pub const fn new(name_fn: TypeNameFn, definition_fn: TypeDefinitionFn) -> Self {
+        Self {
+            name_fn,
+            definition_fn,
+        }
+    }
+
+    pub fn get_name(&self) -> String {
+        (self.name_fn)()
+    }
+
+    pub fn register(&self) -> Option<String> {
+        (self.definition_fn)()
+    }
+}
+
+macro_rules! register_type {
+    ($ty:ty) => {
+        ::inventory::submit!(crate::RegisteredType::new(
+            <$ty as ::lua_typed::Typed>::type_name,
+            <$ty as ::lua_typed::Typed>::generate_full
+        ));
+    };
+}
+pub(crate) use register_type;
+
+inventory::collect!(RegisteredType);
+
+fn generate_definitions() -> String {
+    let mut output = String::new();
+
+    let mut types: Vec<_> = inventory::iter::<RegisteredType>.into_iter().collect();
+    types.sort_by_key(|ty| ty.get_name());
+
+    output += "---@meta\n\nlocal devices\n\n";
+    for ty in types {
+        if let Some(def) = (ty.definition_fn)() {
+            output += &(def + "\n");
+        } else {
+            // NOTE: Due to how this works the typed is erased, so we don't know the cause
+            warn!("Registered type is missing generate_full function");
+        }
+    }
+    output += "return devices";
+
+    output
+}
+
+inventory::submit! {Module::new("automation:devices", create_module, Some(generate_definitions))}

automation_devices/src/light_sensor.rs

@@ -1,30 +1,36 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::MqttDeviceConfig;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::messages::BrightnessMessage;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, trace, warn};
 
-use super::LuaDeviceCreate;
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
-use crate::config::MqttDeviceConfig;
+#[typed(as = "LightSensorConfig")]
-use crate::devices::Device;
-use crate::event::{self, Event, EventChannel, OnMqtt};
-use crate::messages::BrightnessMessage;
-use crate::mqtt::WrappedAsyncClient;
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
 pub struct Config {
     pub identifier: String,
     #[device_config(flatten)]
+    #[typed(flatten)]
     pub mqtt: MqttDeviceConfig,
     pub min: isize,
     pub max: isize,
-    #[device_config(rename("event_channel"), from_lua, with(|ec: EventChannel| ec.get_tx()))]
+
-    pub tx: event::Sender,
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub callback: ActionCallback<(LightSensor, bool)>,
+
     #[device_config(from_lua)]
     pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);
 
 const DEFAULT: bool = false;
 
@@ -33,18 +39,19 @@ pub struct State {
     is_dark: bool,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Device)]
 pub struct LightSensor {
     config: Config,
     state: Arc<RwLock<State>>,
 }
+crate::register_device!(LightSensor);
 
 impl LightSensor {
-    async fn state(&self) -> RwLockReadGuard<State> {
+    async fn state(&self) -> RwLockReadGuard<'_, State> {
         self.state.read().await
     }
 
-    async fn state_mut(&self) -> RwLockWriteGuard<State> {
+    async fn state_mut(&self) -> RwLockWriteGuard<'_, State> {
         self.state.write().await
     }
 }
@@ -90,6 +97,7 @@ impl OnMqtt for LightSensor {
             }
         };
 
+        // TODO: Move this logic to lua at some point
         debug!("Illuminance: {illuminance}");
         let is_dark = if illuminance <= self.config.min {
             trace!("It is dark");
@@ -101,9 +109,7 @@ impl OnMqtt for LightSensor {
             let is_dark = self.state().await.is_dark;
             trace!(
                 "In between min ({}) and max ({}) value, keeping current state: {}",
-                self.config.min,
+                self.config.min, self.config.max, is_dark
-                self.config.max,
-                is_dark
             );
             is_dark
         };
@@ -112,9 +118,10 @@ impl OnMqtt for LightSensor {
             debug!("Dark state has changed: {is_dark}");
             self.state_mut().await.is_dark = is_dark;
 
-            if self.config.tx.send(Event::Darkness(is_dark)).await.is_err() {
+            self.config
-                warn!("There are no receivers on the event channel");
+                .callback
-            }
+                .call((self.clone(), !self.state().await.is_dark))
+                .await;
         }
     }
 }

automation_devices/src/ntfy.rs

@@ -0,0 +1,161 @@
+use std::collections::HashMap;
+use std::convert::Infallible;
+
+use async_trait::async_trait;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::lua::traits::PartialUserData;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
+use mlua::LuaSerdeExt;
+use serde::{Deserialize, Serialize};
+use serde_repr::*;
+use tracing::{error, trace, warn};
+
+#[derive(Debug, Serialize_repr, Deserialize, Clone, Copy, Typed)]
+#[repr(u8)]
+#[serde(rename_all = "snake_case")]
+#[typed(rename_all = "snake_case")]
+pub enum Priority {
+    Min = 1,
+    Low,
+    Default,
+    High,
+    Max,
+}
+crate::register_type!(Priority);
+
+#[derive(Debug, Serialize, Deserialize, Clone, Typed)]
+#[serde(rename_all = "snake_case", tag = "action")]
+#[typed(rename_all = "snake_case", tag = "action")]
+pub enum ActionType {
+    Broadcast {
+        #[serde(skip_serializing_if = "HashMap::is_empty")]
+        #[serde(default)]
+        #[typed(default)]
+        extras: HashMap<String, String>,
+    },
+    // View,
+    // Http
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, Typed)]
+pub struct Action {
+    #[serde(flatten)]
+    #[typed(flatten)]
+    pub action: ActionType,
+    pub label: String,
+    pub clear: Option<bool>,
+}
+crate::register_type!(Action);
+
+#[derive(Serialize, Deserialize, Typed)]
+struct NotificationFinal {
+    topic: String,
+    #[serde(flatten)]
+    #[typed(flatten)]
+    inner: Notification,
+}
+
+#[derive(Debug, Serialize, Clone, Deserialize, Typed)]
+pub struct Notification {
+    title: String,
+    message: Option<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default = "Default::default")]
+    #[typed(default)]
+    tags: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    priority: Option<Priority>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default = "Default::default")]
+    #[typed(default)]
+    actions: Vec<Action>,
+}
+crate::register_type!(Notification);
+
+impl Notification {
+    fn finalize(self, topic: &str) -> NotificationFinal {
+        NotificationFinal {
+            topic: topic.into(),
+            inner: self,
+        }
+    }
+}
+
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "NtfyConfig")]
+pub struct Config {
+    #[device_config(default("https://ntfy.sh".into()))]
+    #[typed(default)]
+    pub url: String,
+    pub topic: String,
+}
+crate::register_type!(Config);
+
+#[derive(Debug, Clone, Device)]
+#[device(extra_user_data = SendNotification)]
+pub struct Ntfy {
+    config: Config,
+}
+crate::register_device!(Ntfy);
+
+struct SendNotification;
+impl PartialUserData<Ntfy> for SendNotification {
+    fn add_methods<M: mlua::UserDataMethods<Ntfy>>(methods: &mut M) {
+        methods.add_async_method(
+            "send_notification",
+            async |lua, this, notification: mlua::Value| {
+                let notification: Notification = lua.from_value(notification)?;
+
+                this.send(notification).await;
+
+                Ok(())
+            },
+        );
+    }
+
+    fn definitions() -> Option<String> {
+        Some(format!(
+            "---@async\n---@param notification {}\nfunction {}:send_notification(notification) end\n",
+            <Notification as Typed>::type_name(),
+            <Ntfy as Typed>::type_name(),
+        ))
+    }
+}
+
+#[async_trait]
+impl LuaDeviceCreate for Ntfy {
+    type Config = Config;
+    type Error = Infallible;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = "ntfy", "Setting up Ntfy");
+        Ok(Self { config })
+    }
+}
+
+impl Device for Ntfy {
+    fn get_id(&self) -> String {
+        "ntfy".to_string()
+    }
+}
+
+impl Ntfy {
+    async fn send(&self, notification: Notification) {
+        let notification = notification.finalize(&self.config.topic);
+
+        // Create the request
+        let res = reqwest::Client::new()
+            .post(self.config.url.clone())
+            .json(&notification)
+            .send()
+            .await;
+
+        if let Err(err) = res {
+            error!("Something went wrong while sending the notification: {err}");
+        } else if let Ok(res) = res {
+            let status = res.status();
+            if !status.is_success() {
+                warn!("Received status {status} when sending notification");
+            }
+        }
+    }
+}

automation_devices/src/presence.rs

@@ -2,27 +2,34 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::MqttDeviceConfig;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::lua::traits::PartialUserData;
+use automation_lib::messages::PresenceMessage;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use tracing::{debug, trace, warn};
 
-use super::LuaDeviceCreate;
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
-use crate::config::MqttDeviceConfig;
+#[typed(as = "PresenceConfig")]
-use crate::devices::Device;
-use crate::event::{self, Event, EventChannel, OnMqtt};
-use crate::messages::PresenceMessage;
-use crate::mqtt::WrappedAsyncClient;
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
 pub struct Config {
     #[device_config(flatten)]
+    #[typed(flatten)]
     pub mqtt: MqttDeviceConfig,
-    #[device_config(from_lua, rename("event_channel"), with(|ec: EventChannel| ec.get_tx()))]
+
-    pub tx: event::Sender,
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub callback: ActionCallback<(Presence, bool)>,
+
     #[device_config(from_lua)]
     pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);
 
 pub const DEFAULT_PRESENCE: bool = false;
 
@@ -32,18 +39,36 @@ pub struct State {
     current_overall_presence: bool,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Device)]
+#[device(extra_user_data = OverallPresence)]
 pub struct Presence {
     config: Config,
     state: Arc<RwLock<State>>,
 }
+crate::register_device!(Presence);
+
+struct OverallPresence;
+impl PartialUserData<Presence> for OverallPresence {
+    fn add_methods<M: mlua::UserDataMethods<Presence>>(methods: &mut M) {
+        methods.add_async_method("overall_presence", async |_lua, this, ()| {
+            Ok(this.state().await.current_overall_presence)
+        });
+    }
+
+    fn definitions() -> Option<String> {
+        Some(format!(
+            "---@async\n---@return boolean\nfunction {}:overall_presence() end\n",
+            <Presence as Typed>::type_name(),
+        ))
+    }
+}
 
 impl Presence {
-    async fn state(&self) -> RwLockReadGuard<State> {
+    async fn state(&self) -> RwLockReadGuard<'_, State> {
         self.state.read().await
     }
 
-    async fn state_mut(&self) -> RwLockWriteGuard<State> {
+    async fn state_mut(&self) -> RwLockWriteGuard<'_, State> {
         self.state.write().await
     }
 }
@@ -115,15 +140,10 @@ impl OnMqtt for Presence {
             debug!("Overall presence updated: {overall_presence}");
             self.state_mut().await.current_overall_presence = overall_presence;
 
-            if self
+            self.config
-                .config
+                .callback
-                .tx
+                .call((self.clone(), overall_presence))
-                .send(Event::Presence(overall_presence))
+                .await;
-                .await
-                .is_err()
-            {
-                warn!("There are no receivers on the event channel");
-            }
         }
     }
 }

automation_devices/src/wake_on_lan.rs

@@ -1,38 +1,44 @@
 use std::net::Ipv4Addr;
 
 use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
+use automation_lib::config::{InfoConfig, MqttDeviceConfig};
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::messages::ActivateMessage;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig};
 use eui48::MacAddress;
 use google_home::device;
 use google_home::errors::ErrorCode;
 use google_home::traits::{self, Scene};
 use google_home::types::Type;
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tracing::{debug, error, trace};
 
-use super::{Device, LuaDeviceCreate};
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
-use crate::config::{InfoConfig, MqttDeviceConfig};
+#[typed(as = "WolConfig")]
-use crate::event::OnMqtt;
-use crate::messages::ActivateMessage;
-use crate::mqtt::WrappedAsyncClient;
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
 pub struct Config {
     #[device_config(flatten)]
+    #[typed(flatten)]
     pub info: InfoConfig,
     #[device_config(flatten)]
+    #[typed(flatten)]
     pub mqtt: MqttDeviceConfig,
     pub mac_address: MacAddress,
     #[device_config(default(Ipv4Addr::new(255, 255, 255, 255)))]
+    #[typed(default)]
     pub broadcast_ip: Ipv4Addr,
     #[device_config(from_lua)]
     pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Device)]
 pub struct WakeOnLAN {
     config: Config,
 }
+crate::register_device!(WakeOnLAN);
 
 #[async_trait]
 impl LuaDeviceCreate for WakeOnLAN {
@@ -76,6 +82,7 @@ impl OnMqtt for WakeOnLAN {
     }
 }
 
+#[async_trait]
 impl google_home::Device for WakeOnLAN {
     fn get_device_type(&self) -> Type {
         Type::Scene
@@ -92,7 +99,7 @@ impl google_home::Device for WakeOnLAN {
         Device::get_id(self)
     }
 
-    fn is_online(&self) -> bool {
+    async fn is_online(&self) -> bool {
         true
     }
 

automation_devices/src/washer.rs

@@ -1,30 +1,36 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::MqttDeviceConfig;
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::messages::PowerMessage;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig};
+use lua_typed::Typed;
 use rumqttc::Publish;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use tracing::{debug, error, trace, warn};
+use tracing::{debug, error, trace};
 
-use super::ntfy::Priority;
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
-use super::{Device, LuaDeviceCreate, Notification};
+#[typed(as = "WasherConfig")]
-use crate::config::MqttDeviceConfig;
-use crate::event::{self, Event, EventChannel, OnMqtt};
-use crate::messages::PowerMessage;
-use crate::mqtt::WrappedAsyncClient;
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
 pub struct Config {
     pub identifier: String,
     #[device_config(flatten)]
+    #[typed(flatten)]
     pub mqtt: MqttDeviceConfig,
     // Power in Watt
     pub threshold: f32,
-    #[device_config(rename("event_channel"), from_lua, with(|ec: EventChannel| ec.get_tx()))]
+
-    pub tx: event::Sender,
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub done_callback: ActionCallback<Washer>,
+
     #[device_config(from_lua)]
     pub client: WrappedAsyncClient,
 }
+crate::register_type!(Config);
 
 #[derive(Debug)]
 pub struct State {
@@ -32,18 +38,19 @@ pub struct State {
 }
 
 // TODO: Add google home integration
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Device)]
 pub struct Washer {
     config: Config,
     state: Arc<RwLock<State>>,
 }
+crate::register_device!(Washer);
 
 impl Washer {
-    async fn state(&self) -> RwLockReadGuard<State> {
+    async fn state(&self) -> RwLockReadGuard<'_, State> {
         self.state.read().await
     }
 
-    async fn state_mut(&self) -> RwLockWriteGuard<State> {
+    async fn state_mut(&self) -> RwLockWriteGuard<'_, State> {
         self.state.write().await
     }
 }
@@ -97,8 +104,6 @@ impl OnMqtt for Washer {
             }
         };
 
-        // debug!(id = self.identifier, power, "Washer state update");
-
         if power < self.config.threshold && self.state().await.running >= HYSTERESIS {
             // The washer is done running
             debug!(
@@ -109,21 +114,8 @@ impl OnMqtt for Washer {
             );
 
             self.state_mut().await.running = 0;
-            let notification = Notification::new()
-                .set_title("Laundy is done")
-                .set_message("Don't forget to hang it!")
-                .add_tag("womans_clothes")
-                .set_priority(Priority::High);
 
-            if self
+            self.config.done_callback.call(self.clone()).await;
-                .config
-                .tx
-                .send(Event::Ntfy(notification))
-                .await
-                .is_err()
-            {
-                warn!("There are no receivers on the event channel");
-            }
         } else if power < self.config.threshold {
             // Prevent false positives
             self.state_mut().await.running = 0;

automation_devices/src/zigbee/light.rs

@@ -0,0 +1,447 @@
+use std::fmt::Debug;
+use std::ops::Deref;
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::{InfoConfig, MqttDeviceConfig};
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::helpers::serialization::state_deserializer;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig, LuaSerialize};
+use google_home::device;
+use google_home::errors::ErrorCode;
+use google_home::traits::{Brightness, Color, ColorSetting, ColorTemperatureRange, OnOff};
+use google_home::types::Type;
+use lua_typed::Typed;
+use rumqttc::{Publish, matches};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use tracing::{debug, trace, warn};
+
+pub trait LightState:
+    Debug + Clone + Default + Sync + Send + Serialize + Into<StateOnOff> + Typed + 'static
+{
+}
+
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "ConfigLight")]
+pub struct Config<T: LightState>
+where
+    Light<T>: Typed,
+{
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub info: InfoConfig,
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub mqtt: MqttDeviceConfig,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub callback: ActionCallback<(Light<T>, T)>,
+
+    #[device_config(from_lua)]
+    #[typed(default)]
+    pub client: WrappedAsyncClient,
+}
+crate::register_type!(Config<StateOnOff>);
+crate::register_type!(Config<StateBrightness>);
+crate::register_type!(Config<StateColorTemperature>);
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "LightStateOnOff")]
+pub struct StateOnOff {
+    #[serde(deserialize_with = "state_deserializer")]
+    state: bool,
+}
+
+impl LightState for StateOnOff {}
+crate::register_type!(StateOnOff);
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "LightStateBrightness")]
+pub struct StateBrightness {
+    #[serde(deserialize_with = "state_deserializer")]
+    state: bool,
+    brightness: f32,
+}
+
+impl LightState for StateBrightness {}
+crate::register_type!(StateBrightness);
+
+impl From<StateBrightness> for StateOnOff {
+    fn from(state: StateBrightness) -> Self {
+        StateOnOff { state: state.state }
+    }
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "LightStateColorTemperature")]
+pub struct StateColorTemperature {
+    #[serde(deserialize_with = "state_deserializer")]
+    state: bool,
+    brightness: f32,
+    color_temp: u32,
+}
+crate::register_type!(StateColorTemperature);
+
+impl LightState for StateColorTemperature {}
+
+impl From<StateColorTemperature> for StateOnOff {
+    fn from(state: StateColorTemperature) -> Self {
+        StateOnOff { state: state.state }
+    }
+}
+
+impl From<StateColorTemperature> for StateBrightness {
+    fn from(state: StateColorTemperature) -> Self {
+        StateBrightness {
+            state: state.state,
+            brightness: state.brightness,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff for LightOnOff, LightBrightness, LightColorTemperature))]
+#[device(traits(Brightness for LightBrightness, LightColorTemperature))]
+#[device(traits(ColorSetting for LightColorTemperature))]
+pub struct Light<T: LightState>
+where
+    Light<T>: Typed,
+{
+    config: Config<T>,
+
+    state: Arc<RwLock<T>>,
+}
+
+pub type LightOnOff = Light<StateOnOff>;
+crate::register_device!(LightOnOff);
+
+pub type LightBrightness = Light<StateBrightness>;
+crate::register_device!(LightBrightness);
+
+pub type LightColorTemperature = Light<StateColorTemperature>;
+crate::register_device!(LightColorTemperature);
+
+impl<T: LightState> Light<T>
+where
+    Light<T>: Typed,
+{
+    async fn state(&self) -> RwLockReadGuard<'_, T> {
+        self.state.read().await
+    }
+
+    async fn state_mut(&self) -> RwLockWriteGuard<'_, T> {
+        self.state.write().await
+    }
+}
+
+#[async_trait]
+impl<T: LightState> LuaDeviceCreate for Light<T>
+where
+    Light<T>: Typed,
+{
+    type Config = Config<T>;
+    type Error = rumqttc::ClientError;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = config.info.identifier(), "Setting up IkeaOutlet");
+
+        config
+            .client
+            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
+            .await?;
+
+        Ok(Self {
+            config,
+            state: Default::default(),
+        })
+    }
+}
+
+impl<T: LightState> Device for Light<T>
+where
+    Light<T>: Typed,
+{
+    fn get_id(&self) -> String {
+        self.config.info.identifier()
+    }
+}
+
+#[async_trait]
+impl OnMqtt for LightOnOff {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the device itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let state = match serde_json::from_slice::<StateOnOff>(&message.payload) {
+                Ok(state) => state,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            // No need to do anything if the state has not changed
+            if state.state == self.state().await.state {
+                return;
+            }
+
+            self.state_mut().await.state = state.state;
+            debug!(
+                id = Device::get_id(self),
+                "Updating state to {:?}",
+                self.state().await
+            );
+
+            self.config
+                .callback
+                .call((self.clone(), self.state().await.clone()))
+                .await;
+        }
+    }
+}
+
+#[async_trait]
+impl OnMqtt for LightBrightness {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the deviec itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let state = match serde_json::from_slice::<StateBrightness>(&message.payload) {
+                Ok(state) => state,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            {
+                let current_state = self.state().await;
+                // No need to do anything if the state has not changed
+                if state.state == current_state.state
+                    && state.brightness == current_state.brightness
+                {
+                    return;
+                }
+            }
+
+            self.state_mut().await.state = state.state;
+            self.state_mut().await.brightness = state.brightness;
+            debug!(
+                id = Device::get_id(self),
+                "Updating state to {:?}",
+                self.state().await
+            );
+
+            self.config
+                .callback
+                .call((self.clone(), self.state().await.clone()))
+                .await;
+        }
+    }
+}
+
+#[async_trait]
+impl OnMqtt for LightColorTemperature {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the deviec itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let state = match serde_json::from_slice::<StateColorTemperature>(&message.payload) {
+                Ok(state) => state,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            {
+                let current_state = self.state().await;
+                // No need to do anything if the state has not changed
+                if state.state == current_state.state
+                    && state.brightness == current_state.brightness
+                    && state.color_temp == current_state.color_temp
+                {
+                    return;
+                }
+            }
+
+            self.state_mut().await.state = state.state;
+            self.state_mut().await.brightness = state.brightness;
+            self.state_mut().await.color_temp = state.color_temp;
+            debug!(
+                id = Device::get_id(self),
+                "Updating state to {:?}",
+                self.state().await
+            );
+
+            self.config
+                .callback
+                .call((self.clone(), self.state().await.clone()))
+                .await;
+        }
+    }
+}
+
+#[async_trait]
+impl<T: LightState> google_home::Device for Light<T>
+where
+    Light<T>: Typed,
+{
+    fn get_device_type(&self) -> Type {
+        Type::Light
+    }
+
+    fn get_device_name(&self) -> device::Name {
+        device::Name::new(&self.config.info.name)
+    }
+
+    fn get_id(&self) -> String {
+        Device::get_id(self)
+    }
+
+    async fn is_online(&self) -> bool {
+        true
+    }
+
+    fn get_room_hint(&self) -> Option<&str> {
+        self.config.info.room.as_deref()
+    }
+
+    fn will_report_state(&self) -> bool {
+        // TODO: Implement state reporting
+        false
+    }
+}
+
+#[async_trait]
+impl<T> OnOff for Light<T>
+where
+    T: LightState,
+    Light<T>: Typed,
+{
+    async fn on(&self) -> Result<bool, ErrorCode> {
+        let state = self.state().await;
+        let state: StateOnOff = state.deref().clone().into();
+        Ok(state.state)
+    }
+
+    async fn set_on(&self, on: bool) -> Result<(), ErrorCode> {
+        let message = json!({
+            "state": if on { "ON" } else { "OFF"}
+        });
+
+        debug!(id = Device::get_id(self), "{message}");
+
+        let topic = format!("{}/set", self.config.mqtt.topic);
+        // TODO: Handle potential errors here
+        self.config
+            .client
+            .publish(
+                &topic,
+                rumqttc::QoS::AtLeastOnce,
+                false,
+                serde_json::to_string(&message).unwrap(),
+            )
+            .await
+            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
+            .ok();
+
+        Ok(())
+    }
+}
+
+const FACTOR: f32 = 30.0;
+
+#[async_trait]
+impl<T> Brightness for Light<T>
+where
+    T: LightState,
+    T: Into<StateBrightness>,
+    Light<T>: Typed,
+{
+    async fn brightness(&self) -> Result<u8, ErrorCode> {
+        let state = self.state().await;
+        let state: StateBrightness = state.deref().clone().into();
+        let brightness =
+            100.0 * f32::log10(state.brightness / FACTOR + 1.0) / f32::log10(254.0 / FACTOR + 1.0);
+
+        Ok(brightness.clamp(0.0, 100.0).round() as u8)
+    }
+
+    async fn set_brightness(&self, brightness: u8) -> Result<(), ErrorCode> {
+        let brightness =
+            FACTOR * ((FACTOR / (FACTOR + 254.0)).powf(-(brightness as f32) / 100.0) - 1.0);
+
+        let message = json!({
+            "brightness": brightness.clamp(0.0, 254.0).round() as u8
+        });
+
+        let topic = format!("{}/set", self.config.mqtt.topic);
+        // TODO: Handle potential errors here
+        self.config
+            .client
+            .publish(
+                &topic,
+                rumqttc::QoS::AtLeastOnce,
+                false,
+                serde_json::to_string(&message).unwrap(),
+            )
+            .await
+            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
+            .ok();
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl<T> ColorSetting for Light<T>
+where
+    T: LightState,
+    T: Into<StateColorTemperature>,
+    Light<T>: Typed,
+{
+    fn color_temperature_range(&self) -> ColorTemperatureRange {
+        ColorTemperatureRange {
+            temperature_min_k: 2200,
+            temperature_max_k: 4000,
+        }
+    }
+
+    async fn color(&self) -> Color {
+        let state = self.state().await;
+        let state: StateColorTemperature = state.deref().clone().into();
+
+        let temperature = 1_000_000 / state.color_temp;
+
+        Color { temperature }
+    }
+
+    async fn set_color(&self, color: Color) -> Result<(), ErrorCode> {
+        let temperature = 1_000_000 / color.temperature;
+
+        let message = json!({
+            "color_temp": temperature,
+        });
+
+        let topic = format!("{}/set", self.config.mqtt.topic);
+        // TODO: Handle potential errors here
+        self.config
+            .client
+            .publish(
+                &topic,
+                rumqttc::QoS::AtLeastOnce,
+                false,
+                serde_json::to_string(&message).unwrap(),
+            )
+            .await
+            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
+            .ok();
+
+        Ok(())
+    }
+}

automation_devices/src/zigbee/mod.rs

@@ -0,0 +1,2 @@
+pub mod light;
+pub mod outlet;

automation_devices/src/zigbee/outlet.rs

@@ -0,0 +1,297 @@
+use std::fmt::Debug;
+use std::ops::Deref;
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::{InfoConfig, MqttDeviceConfig};
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::OnMqtt;
+use automation_lib::helpers::serialization::state_deserializer;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::{Device, LuaDeviceConfig, LuaSerialize};
+use google_home::device;
+use google_home::errors::ErrorCode;
+use google_home::traits::OnOff;
+use google_home::types::Type;
+use lua_typed::Typed;
+use rumqttc::{Publish, matches};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use tracing::{debug, trace, warn};
+
+pub trait OutletState:
+    Debug + Clone + Default + Sync + Send + Serialize + Into<StateOnOff> + Typed + 'static
+{
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Copy, Typed)]
+pub enum OutletType {
+    Outlet,
+    Kettle,
+}
+crate::register_type!(OutletType);
+
+impl From<OutletType> for Type {
+    fn from(outlet: OutletType) -> Self {
+        match outlet {
+            OutletType::Outlet => Type::Outlet,
+            OutletType::Kettle => Type::Kettle,
+        }
+    }
+}
+
+#[derive(Debug, Clone, LuaDeviceConfig, Typed)]
+#[typed(as = "ConfigOutlet")]
+pub struct Config<T: OutletState>
+where
+    Outlet<T>: Typed,
+{
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub info: InfoConfig,
+    #[device_config(flatten)]
+    #[typed(flatten)]
+    pub mqtt: MqttDeviceConfig,
+    #[device_config(default(OutletType::Outlet))]
+    #[typed(default)]
+    pub outlet_type: OutletType,
+
+    #[device_config(from_lua, default)]
+    #[typed(default)]
+    pub callback: ActionCallback<(Outlet<T>, T)>,
+
+    #[device_config(from_lua)]
+    pub client: WrappedAsyncClient,
+}
+crate::register_type!(Config<StateOnOff>);
+crate::register_type!(Config<StatePower>);
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "OutletStateOnOff")]
+pub struct StateOnOff {
+    #[serde(deserialize_with = "state_deserializer")]
+    state: bool,
+}
+crate::register_type!(StateOnOff);
+
+impl OutletState for StateOnOff {}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, LuaSerialize, Typed)]
+#[typed(as = "OutletStatePower")]
+pub struct StatePower {
+    #[serde(deserialize_with = "state_deserializer")]
+    state: bool,
+    power: f64,
+}
+crate::register_type!(StatePower);
+
+impl OutletState for StatePower {}
+
+impl From<StatePower> for StateOnOff {
+    fn from(state: StatePower) -> Self {
+        StateOnOff { state: state.state }
+    }
+}
+
+#[derive(Debug, Clone, Device)]
+#[device(traits(OnOff for OutletOnOff, OutletPower))]
+pub struct Outlet<T: OutletState>
+where
+    Outlet<T>: Typed,
+{
+    config: Config<T>,
+
+    state: Arc<RwLock<T>>,
+}
+
+pub type OutletOnOff = Outlet<StateOnOff>;
+crate::register_device!(OutletOnOff);
+
+pub type OutletPower = Outlet<StatePower>;
+crate::register_device!(OutletPower);
+
+impl<T: OutletState> Outlet<T>
+where
+    Outlet<T>: Typed,
+{
+    async fn state(&self) -> RwLockReadGuard<'_, T> {
+        self.state.read().await
+    }
+
+    async fn state_mut(&self) -> RwLockWriteGuard<'_, T> {
+        self.state.write().await
+    }
+}
+
+#[async_trait]
+impl<T: OutletState> LuaDeviceCreate for Outlet<T>
+where
+    Outlet<T>: Typed,
+{
+    type Config = Config<T>;
+    type Error = rumqttc::ClientError;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = config.info.identifier(), "Setting up IkeaOutlet");
+
+        config
+            .client
+            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
+            .await?;
+
+        Ok(Self {
+            config,
+            state: Default::default(),
+        })
+    }
+}
+
+impl<T: OutletState> Device for Outlet<T>
+where
+    Outlet<T>: Typed,
+{
+    fn get_id(&self) -> String {
+        self.config.info.identifier()
+    }
+}
+
+#[async_trait]
+impl OnMqtt for OutletOnOff {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the device itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let state = match serde_json::from_slice::<StateOnOff>(&message.payload) {
+                Ok(state) => state,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            // No need to do anything if the state has not changed
+            if state.state == self.state().await.state {
+                return;
+            }
+
+            self.state_mut().await.state = state.state;
+            debug!(
+                id = Device::get_id(self),
+                "Updating state to {:?}",
+                self.state().await
+            );
+
+            self.config
+                .callback
+                .call((self.clone(), self.state().await.clone()))
+                .await;
+        }
+    }
+}
+
+#[async_trait]
+impl OnMqtt for OutletPower {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the deviec itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let state = match serde_json::from_slice::<StatePower>(&message.payload) {
+                Ok(state) => state,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            {
+                let current_state = self.state().await;
+                // No need to do anything if the state has not changed
+                if state.state == current_state.state && state.power == current_state.power {
+                    return;
+                }
+            }
+
+            self.state_mut().await.state = state.state;
+            self.state_mut().await.power = state.power;
+            debug!(
+                id = Device::get_id(self),
+                "Updating state to {:?}",
+                self.state().await
+            );
+
+            self.config
+                .callback
+                .call((self.clone(), self.state().await.clone()))
+                .await;
+        }
+    }
+}
+
+#[async_trait]
+impl<T: OutletState> google_home::Device for Outlet<T>
+where
+    Outlet<T>: Typed,
+{
+    fn get_device_type(&self) -> Type {
+        self.config.outlet_type.into()
+    }
+
+    fn get_device_name(&self) -> device::Name {
+        device::Name::new(&self.config.info.name)
+    }
+
+    fn get_id(&self) -> String {
+        Device::get_id(self)
+    }
+
+    async fn is_online(&self) -> bool {
+        true
+    }
+
+    fn get_room_hint(&self) -> Option<&str> {
+        self.config.info.room.as_deref()
+    }
+
+    fn will_report_state(&self) -> bool {
+        // TODO: Implement state reporting
+        false
+    }
+}
+
+#[async_trait]
+impl<T> OnOff for Outlet<T>
+where
+    T: OutletState,
+    Outlet<T>: Typed,
+{
+    async fn on(&self) -> Result<bool, ErrorCode> {
+        let state = self.state().await;
+        let state: StateOnOff = state.deref().clone().into();
+        Ok(state.state)
+    }
+
+    async fn set_on(&self, on: bool) -> Result<(), ErrorCode> {
+        let message = json!({
+            "state": if on { "ON" } else { "OFF"}
+        });
+
+        debug!(id = Device::get_id(self), "{message}");
+
+        let topic = format!("{}/set", self.config.mqtt.topic);
+        // TODO: Handle potential errors here
+        self.config
+            .client
+            .publish(
+                &topic,
+                rumqttc::QoS::AtLeastOnce,
+                false,
+                serde_json::to_string(&message).unwrap(),
+            )
+            .await
+            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
+            .ok();
+
+        Ok(())
+    }
+}

automation_lib/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "automation_lib"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+automation_macro = { workspace = true }
+async-trait = { workspace = true }
+automation_cast = { workspace = true }
+bytes = { workspace = true }
+dyn-clone = { workspace = true }
+futures = { workspace = true }
+google_home = { workspace = true }
+hostname = { workspace = true }
+inventory = { workspace = true }
+lua_typed = { workspace = true }
+mlua = { workspace = true }
+rumqttc = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }

automation_lib/src/action_callback.rs

@@ -0,0 +1,94 @@
+use std::marker::PhantomData;
+
+use futures::future::try_join_all;
+use lua_typed::Typed;
+use mlua::{FromLua, IntoLuaMulti};
+
+#[derive(Debug, Clone)]
+pub struct ActionCallback<P> {
+    callbacks: Vec<mlua::Function>,
+    _parameters: PhantomData<P>,
+}
+
+impl Typed for ActionCallback<()> {
+    fn type_name() -> String {
+        "fun() | fun()[]".into()
+    }
+}
+
+impl<A: Typed> Typed for ActionCallback<A> {
+    fn type_name() -> String {
+        let type_name = A::type_name();
+        format!("fun(_: {type_name}) | fun(_: {type_name})[]")
+    }
+}
+
+impl<A: Typed, B: Typed> Typed for ActionCallback<(A, B)> {
+    fn type_name() -> String {
+        let type_name_a = A::type_name();
+        let type_name_b = B::type_name();
+        format!(
+            "fun(_: {type_name_a}, _: {type_name_b}) | fun(_: {type_name_a}, _: {type_name_b})[]"
+        )
+    }
+}
+
+// NOTE: For some reason the derive macro combined with PhantomData leads to issues where it
+// requires all types part of P to implement default, even if they never actually get constructed.
+// By manually implemented Default it works fine.
+impl<P> Default for ActionCallback<P> {
+    fn default() -> Self {
+        Self {
+            callbacks: Default::default(),
+            _parameters: Default::default(),
+        }
+    }
+}
+
+impl<P> FromLua for ActionCallback<P> {
+    fn from_lua(value: mlua::Value, _lua: &mlua::Lua) -> mlua::Result<Self> {
+        let callbacks = match value {
+            mlua::Value::Function(f) => vec![f],
+            mlua::Value::Table(table) => table
+                .pairs::<mlua::Value, mlua::Function>()
+                .map(|pair| {
+                    let (_, f) = pair?;
+
+                    Ok::<_, mlua::Error>(f)
+                })
+                .try_collect()?,
+            _ => {
+                return Err(mlua::Error::FromLuaConversionError {
+                    from: value.type_name(),
+                    to: "ActionCallback".into(),
+                    message: Some("expected function or table of functions".into()),
+                });
+            }
+        };
+
+        Ok(ActionCallback {
+            callbacks,
+            _parameters: PhantomData::<P>,
+        })
+    }
+}
+
+// TODO: Return proper error here
+impl<P> ActionCallback<P>
+where
+    P: IntoLuaMulti + Sync + Clone,
+{
+    pub async fn call(&self, parameters: P) {
+        try_join_all(
+            self.callbacks
+                .iter()
+                .map(async |f| f.call_async::<()>(parameters.clone()).await),
+        )
+        .await
+        .unwrap();
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.callbacks.is_empty()
+    }
+}

automation_lib/src/config.rs

@@ -0,0 +1,23 @@
+use lua_typed::Typed;
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Deserialize, Typed)]
+pub struct InfoConfig {
+    pub name: String,
+    pub room: Option<String>,
+}
+
+impl InfoConfig {
+    pub fn identifier(&self) -> String {
+        (if let Some(room) = &self.room {
+            room.to_ascii_lowercase().replace(' ', "_") + "_"
+        } else {
+            String::new()
+        }) + &self.name.to_ascii_lowercase().replace(' ', "_")
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Typed)]
+pub struct MqttDeviceConfig {
+    pub topic: String,
+}

automation_lib/src/device.rs

@@ -0,0 +1,54 @@
+use std::fmt::Debug;
+
+use automation_cast::Cast;
+use dyn_clone::DynClone;
+use lua_typed::Typed;
+use mlua::ObjectLike;
+
+use crate::event::OnMqtt;
+
+#[async_trait::async_trait]
+pub trait LuaDeviceCreate {
+    type Config;
+    type Error;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error>
+    where
+        Self: Sized;
+}
+
+pub trait Device:
+    Debug + DynClone + Sync + Send + Cast<dyn google_home::Device> + Cast<dyn OnMqtt>
+{
+    fn get_id(&self) -> String;
+}
+
+impl mlua::FromLua for Box<dyn Device> {
+    fn from_lua(value: mlua::Value, _lua: &mlua::Lua) -> mlua::Result<Self> {
+        match value {
+            mlua::Value::UserData(ud) => {
+                let ud = if ud.is::<Self>() {
+                    ud
+                } else {
+                    ud.call_method::<_>("__box", ())?
+                };
+
+                let b = ud.borrow::<Self>()?.clone();
+                Ok(b)
+            }
+            _ => Err(mlua::Error::runtime(format!(
+                "Expected user data, instead found: {}",
+                value.type_name()
+            ))),
+        }
+    }
+}
+impl mlua::UserData for Box<dyn Device> {}
+
+impl Typed for Box<dyn Device> {
+    fn type_name() -> String {
+        "DeviceInterface".into()
+    }
+}
+
+dyn_clone::clone_trait_object!(Device);

automation_lib/src/device_manager.rs

@@ -0,0 +1,89 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use futures::future::join_all;
+use tokio::sync::{RwLock, RwLockReadGuard};
+use tracing::{debug, instrument, trace};
+
+use crate::device::Device;
+use crate::event::{Event, EventChannel, OnMqtt};
+
+pub type DeviceMap = HashMap<String, Box<dyn Device>>;
+
+#[derive(Clone)]
+pub struct DeviceManager {
+    devices: Arc<RwLock<DeviceMap>>,
+    event_channel: EventChannel,
+}
+
+impl DeviceManager {
+    pub async fn new() -> Self {
+        let (event_channel, mut event_rx) = EventChannel::new();
+
+        let device_manager = Self {
+            devices: Arc::new(RwLock::new(HashMap::new())),
+            event_channel,
+        };
+
+        tokio::spawn({
+            let device_manager = device_manager.clone();
+            async move {
+                loop {
+                    if let Some(event) = event_rx.recv().await {
+                        device_manager.handle_event(event).await;
+                    } else {
+                        todo!("Handle errors with the event channel properly")
+                    }
+                }
+            }
+        });
+
+        device_manager
+    }
+
+    pub async fn add(&self, device: Box<dyn Device>) {
+        let id = device.get_id();
+
+        debug!(id, "Adding device");
+
+        self.devices.write().await.insert(id, device);
+    }
+
+    pub fn event_channel(&self) -> EventChannel {
+        self.event_channel.clone()
+    }
+
+    pub async fn get(&self, name: &str) -> Option<Box<dyn Device>> {
+        self.devices.read().await.get(name).cloned()
+    }
+
+    pub async fn devices(&self) -> RwLockReadGuard<'_, DeviceMap> {
+        self.devices.read().await
+    }
+
+    #[instrument(skip(self))]
+    async fn handle_event(&self, event: Event) {
+        match event {
+            Event::MqttMessage(message) => {
+                let devices = self.devices.read().await;
+                let iter = devices.iter().map(async |(id, device)| {
+                    let device: Option<&dyn OnMqtt> = device.cast();
+                    if let Some(device) = device {
+                        // let subscribed = device
+                        //     .topics()
+                        //     .iter()
+                        //     .any(|topic| matches(&message.topic, topic));
+                        //
+                        // if subscribed {
+                        trace!(id, "Handling");
+                        device.on_mqtt(message.clone()).await;
+                        trace!(id, "Done");
+                        // }
+                    }
+                });
+
+                join_all(iter).await;
+            }
+        }
+    }
+}

automation_lib/src/error.rs

@@ -1,10 +1,7 @@
 use std::{error, fmt, result};
 
-use axum::http::status::InvalidStatusCode;
-use axum::response::IntoResponse;
 use bytes::Bytes;
 use rumqttc::ClientError;
-use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 #[derive(Debug, Clone)]
@@ -41,7 +38,9 @@ impl fmt::Display for MissingEnv {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Missing environment variable")?;
         if self.keys.is_empty() {
-            unreachable!("This error should only be returned if there are actually missing environment variables");
+            unreachable!(
+                "This error should only be returned if there are actually missing environment variables"
+            );
         }
         if self.keys.len() == 1 {
             write!(f, " '{}'", self.keys[0])?;
@@ -101,68 +100,3 @@ pub enum LightSensorError {
     #[error(transparent)]
     SubscribeError(#[from] ClientError),
 }
-
-#[derive(Debug, Error)]
-#[error("{source}")]
-pub struct ApiError {
-    status_code: axum::http::StatusCode,
-    source: Box<dyn std::error::Error>,
-}
-
-impl ApiError {
-    pub fn new(status_code: axum::http::StatusCode, source: Box<dyn std::error::Error>) -> Self {
-        Self {
-            status_code,
-            source,
-        }
-    }
-}
-
-impl From<ApiError> for ApiErrorJson {
-    fn from(value: ApiError) -> Self {
-        let error = ApiErrorJsonError {
-            code: value.status_code.as_u16(),
-            status: value.status_code.to_string(),
-            reason: value.source.to_string(),
-        };
-
-        Self { error }
-    }
-}
-
-impl IntoResponse for ApiError {
-    fn into_response(self) -> axum::response::Response {
-        (
-            self.status_code,
-            serde_json::to_string::<ApiErrorJson>(&self.into())
-                .expect("Serialization should not fail"),
-        )
-            .into_response()
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct ApiErrorJsonError {
-    code: u16,
-    status: String,
-    reason: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ApiErrorJson {
-    error: ApiErrorJsonError,
-}
-
-impl TryFrom<ApiErrorJson> for ApiError {
-    type Error = InvalidStatusCode;
-
-    fn try_from(value: ApiErrorJson) -> result::Result<Self, Self::Error> {
-        let status_code = axum::http::StatusCode::from_u16(value.error.code)?;
-        let source = value.error.reason.into();
-
-        Ok(Self {
-            status_code,
-            source,
-        })
-    }
-}

automation_lib/src/event.rs

@@ -3,14 +3,9 @@ use mlua::FromLua;
 use rumqttc::Publish;
 use tokio::sync::mpsc;
 
-use crate::devices::Notification;
-
 #[derive(Debug, Clone)]
 pub enum Event {
     MqttMessage(Publish),
-    Darkness(bool),
-    Presence(bool),
-    Ntfy(Notification),
 }
 
 pub type Sender = mpsc::Sender<Event>;
@@ -38,18 +33,3 @@ pub trait OnMqtt: Sync + Send {
     // fn topics(&self) -> Vec<&str>;
     async fn on_mqtt(&self, message: Publish);
 }
-
-#[async_trait]
-pub trait OnPresence: Sync + Send {
-    async fn on_presence(&self, presence: bool);
-}
-
-#[async_trait]
-pub trait OnDarkness: Sync + Send {
-    async fn on_darkness(&self, dark: bool);
-}
-
-#[async_trait]
-pub trait OnNotification: Sync + Send {
-    async fn on_notification(&self, notification: Notification);
-}

automation_lib/src/helpers/mod.rs

@@ -0,0 +1 @@
+pub mod serialization;

automation_lib/src/helpers/serialization.rs

@@ -0,0 +1,16 @@
+use serde::de::{self, Unexpected};
+use serde::{Deserialize, Deserializer};
+
+pub fn state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    match String::deserialize(deserializer)?.as_ref() {
+        "ON" => Ok(true),
+        "OFF" => Ok(false),
+        other => Err(de::Error::invalid_value(
+            Unexpected::Str(other),
+            &"Value expected was either ON or OFF",
+        )),
+    }
+}

automation_lib/src/lib.rs

@@ -0,0 +1,62 @@
+#![feature(iterator_try_collect)]
+#![feature(with_negative_coherence)]
+
+use tracing::debug;
+
+pub mod action_callback;
+pub mod config;
+pub mod device;
+pub mod device_manager;
+pub mod error;
+pub mod event;
+pub mod helpers;
+pub mod lua;
+pub mod messages;
+pub mod mqtt;
+
+type RegisterFn = fn(lua: &mlua::Lua) -> mlua::Result<mlua::Table>;
+type DefinitionsFn = fn() -> String;
+
+pub struct Module {
+    name: &'static str,
+    register_fn: RegisterFn,
+    definitions_fn: Option<DefinitionsFn>,
+}
+
+impl Module {
+    pub const fn new(
+        name: &'static str,
+        register_fn: RegisterFn,
+        definitions_fn: Option<DefinitionsFn>,
+    ) -> Self {
+        Self {
+            name,
+            register_fn,
+            definitions_fn,
+        }
+    }
+
+    pub const fn get_name(&self) -> &'static str {
+        self.name
+    }
+
+    pub fn register(&self, lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
+        (self.register_fn)(lua)
+    }
+
+    pub fn definitions(&self) -> Option<String> {
+        self.definitions_fn.map(|f| f())
+    }
+}
+
+pub fn load_modules(lua: &mlua::Lua) -> mlua::Result<()> {
+    for module in inventory::iter::<Module> {
+        debug!(name = module.get_name(), "Loading module");
+        let table = module.register(lua)?;
+        lua.register_module(module.get_name(), table)?;
+    }
+
+    Ok(())
+}
+
+inventory::collect!(Module);

automation_lib/src/lua/mod.rs

@@ -0,0 +1,3 @@
+pub mod traits;
+
+mod utils;

automation_lib/src/lua/traits.rs

@@ -0,0 +1,127 @@
+use std::ops::Deref;
+
+// TODO: Enable and disable functions based on query_only and command_only
+
+pub trait PartialUserData<T> {
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M);
+
+    fn interface_name() -> Option<&'static str> {
+        None
+    }
+
+    fn definitions() -> Option<String> {
+        None
+    }
+}
+
+pub struct Device;
+
+impl<T> PartialUserData<T> for Device
+where
+    T: crate::device::Device + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
+        methods.add_async_method("get_id", async |_lua, this, _: ()| Ok(this.get_id()));
+    }
+
+    fn interface_name() -> Option<&'static str> {
+        Some("DeviceInterface")
+    }
+}
+
+pub struct OnOff;
+
+impl<T> PartialUserData<T> for OnOff
+where
+    T: google_home::traits::OnOff + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
+        methods.add_async_method("set_on", async |_lua, this, on: bool| {
+            this.deref().set_on(on).await.unwrap();
+
+            Ok(())
+        });
+
+        methods.add_async_method("on", async |_lua, this, ()| {
+            Ok(this.deref().on().await.unwrap())
+        });
+    }
+
+    fn interface_name() -> Option<&'static str> {
+        Some("OnOffInterface")
+    }
+}
+
+pub struct Brightness;
+
+impl<T> PartialUserData<T> for Brightness
+where
+    T: google_home::traits::Brightness + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
+        methods.add_async_method("set_brightness", async |_lua, this, brightness: u8| {
+            this.set_brightness(brightness).await.unwrap();
+
+            Ok(())
+        });
+
+        methods.add_async_method("brightness", async |_lua, this, _: ()| {
+            Ok(this.brightness().await.unwrap())
+        });
+    }
+
+    fn interface_name() -> Option<&'static str> {
+        Some("BrightnessInterface")
+    }
+}
+
+pub struct ColorSetting;
+
+impl<T> PartialUserData<T> for ColorSetting
+where
+    T: google_home::traits::ColorSetting + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
+        methods.add_async_method(
+            "set_color_temperature",
+            async |_lua, this, temperature: u32| {
+                this.set_color(google_home::traits::Color { temperature })
+                    .await
+                    .unwrap();
+
+                Ok(())
+            },
+        );
+
+        methods.add_async_method("color_temperature", async |_lua, this, ()| {
+            Ok(this.color().await.temperature)
+        });
+    }
+
+    fn interface_name() -> Option<&'static str> {
+        Some("ColorSettingInterface")
+    }
+}
+
+pub struct OpenClose;
+
+impl<T> PartialUserData<T> for OpenClose
+where
+    T: google_home::traits::OpenClose + 'static,
+{
+    fn add_methods<M: mlua::UserDataMethods<T>>(methods: &mut M) {
+        methods.add_async_method("set_open_percent", async |_lua, this, open_percent: u8| {
+            this.set_open_percent(open_percent).await.unwrap();
+
+            Ok(())
+        });
+
+        methods.add_async_method("open_percent", async |_lua, this, _: ()| {
+            Ok(this.open_percent().await.unwrap())
+        });
+    }
+
+    fn interface_name() -> Option<&'static str> {
+        Some("OpenCloseInterface")
+    }
+}

automation_lib/src/lua/utils/mod.rs

@@ -0,0 +1,48 @@
+mod timeout;
+
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use lua_typed::Typed;
+pub use timeout::Timeout;
+
+use crate::Module;
+
+fn create_module(lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
+    let utils = lua.create_table()?;
+
+    utils.set(Timeout::type_name(), lua.create_proxy::<Timeout>()?)?;
+
+    let get_hostname = lua.create_function(|_lua, ()| {
+        hostname::get()
+            .map(|name| name.to_str().unwrap_or("unknown").to_owned())
+            .map_err(mlua::ExternalError::into_lua_err)
+    })?;
+    utils.set("get_hostname", get_hostname)?;
+    let get_epoch = lua.create_function(|_lua, ()| {
+        Ok(SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("Time is after UNIX EPOCH")
+            .as_millis())
+    })?;
+    utils.set("get_epoch", get_epoch)?;
+
+    Ok(utils)
+}
+
+fn generate_definitions() -> String {
+    let mut output = String::new();
+
+    output += "---@meta\n\nlocal utils\n\n";
+
+    output += &Timeout::generate_full().expect("Timeout should have generate_full");
+    output += "\n";
+
+    output += "---@return string\nfunction utils.get_hostname() end\n\n";
+    output += "---@return integer\nfunction utils.get_epoch() end\n\n";
+
+    output += "return utils";
+
+    output
+}
+
+inventory::submit! {Module::new("automation:utils", create_module, Some(generate_definitions))}

automation_lib/src/lua/utils/timeout.rs

@@ -0,0 +1,118 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use lua_typed::Typed;
+use tokio::sync::RwLock;
+use tokio::task::JoinHandle;
+use tracing::debug;
+
+use crate::action_callback::ActionCallback;
+
+#[derive(Debug, Default)]
+pub struct State {
+    handle: Option<JoinHandle<()>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Timeout {
+    state: Arc<RwLock<State>>,
+}
+
+impl mlua::UserData for Timeout {
+    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
+        methods.add_function("new", |_lua, ()| {
+            let device = Self {
+                state: Default::default(),
+            };
+
+            Ok(device)
+        });
+
+        methods.add_async_method(
+            "start",
+            async |_lua, this, (timeout, callback): (f32, ActionCallback<()>)| {
+                if let Some(handle) = this.state.write().await.handle.take() {
+                    handle.abort();
+                }
+
+                debug!("Running timeout callback after {timeout}s");
+
+                let timeout = Duration::from_secs_f32(timeout);
+
+                this.state.write().await.handle = Some(tokio::spawn({
+                    async move {
+                        tokio::time::sleep(timeout).await;
+
+                        callback.call(()).await;
+                    }
+                }));
+
+                Ok(())
+            },
+        );
+
+        methods.add_async_method("cancel", async |_lua, this, ()| {
+            debug!("Canceling timeout callback");
+
+            if let Some(handle) = this.state.write().await.handle.take() {
+                handle.abort();
+            }
+
+            Ok(())
+        });
+
+        methods.add_async_method("is_waiting", async |_lua, this, ()| {
+            debug!("Canceling timeout callback");
+
+            if let Some(handle) = this.state.read().await.handle.as_ref() {
+                debug!("Join handle: {}", handle.is_finished());
+                return Ok(!handle.is_finished());
+            }
+
+            debug!("Join handle: None");
+
+            Ok(false)
+        });
+    }
+}
+
+impl Typed for Timeout {
+    fn type_name() -> String {
+        "Timeout".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        let type_name = Self::type_name();
+        Some(format!("---@class {type_name}\nlocal {type_name}\n"))
+    }
+
+    fn generate_members() -> Option<String> {
+        let mut output = String::new();
+
+        let type_name = Self::type_name();
+
+        output += &format!(
+            "---@async\n---@param timeout number\n---@param callback {}\nfunction {type_name}:start(timeout, callback) end\n",
+            ActionCallback::<()>::type_name()
+        );
+
+        output += &format!("---@async\nfunction {type_name}:cancel() end\n",);
+
+        output +=
+            &format!("---@async\n---@return boolean\nfunction {type_name}:is_waiting() end\n",);
+
+        Some(output)
+    }
+
+    fn generate_footer() -> Option<String> {
+        let mut output = String::new();
+
+        let type_name = Self::type_name();
+
+        output += &format!("utils.{type_name} = {{}}\n");
+        output += &format!("---@return {type_name}\n");
+        output += &format!("function utils.{type_name}.new() end\n");
+
+        Some(output)
+    }
+}

automation_lib/src/messages.rs

@@ -68,13 +68,8 @@ pub enum RemoteAction {
 // Message used to report the action performed by a remote
 #[derive(Debug, Deserialize)]
 pub struct RemoteMessage {
-    action: RemoteAction,
+    pub action: Option<RemoteAction>,
-}
+    pub battery: Option<f32>,
-
-impl RemoteMessage {
-    pub fn action(&self) -> RemoteAction {
-        self.action
-    }
 }
 
 impl TryFrom<Publish> for RemoteMessage {
@@ -144,13 +139,8 @@ impl TryFrom<Publish> for BrightnessMessage {
 // Message to report the state of a contact sensor
 #[derive(Debug, Deserialize)]
 pub struct ContactMessage {
-    contact: bool,
+    pub contact: Option<bool>,
-}
+    pub battery: Option<f32>,
-
-impl ContactMessage {
-    pub fn is_closed(&self) -> bool {
-        self.contact
-    }
 }
 
 impl TryFrom<Publish> for ContactMessage {
@@ -162,40 +152,6 @@ impl TryFrom<Publish> for ContactMessage {
     }
 }
 
-// Message used to report the current darkness state
-#[derive(Debug, Deserialize, Serialize)]
-pub struct DarknessMessage {
-    state: bool,
-    updated: Option<u128>,
-}
-
-impl DarknessMessage {
-    pub fn new(state: bool) -> Self {
-        Self {
-            state,
-            updated: Some(
-                SystemTime::now()
-                    .duration_since(UNIX_EPOCH)
-                    .expect("Time is after UNIX EPOCH")
-                    .as_millis(),
-            ),
-        }
-    }
-
-    pub fn is_dark(&self) -> bool {
-        self.state
-    }
-}
-
-impl TryFrom<Publish> for DarknessMessage {
-    type Error = ParseError;
-
-    fn try_from(message: Publish) -> Result<Self, Self::Error> {
-        serde_json::from_slice(&message.payload)
-            .or(Err(ParseError::InvalidPayload(message.payload.clone())))
-    }
-}
-
 // Message used to report the power draw a smart plug
 #[derive(Debug, Deserialize)]
 pub struct PowerMessage {
@@ -241,40 +197,3 @@ impl TryFrom<Bytes> for HueMessage {
         serde_json::from_slice(&bytes).or(Err(ParseError::InvalidPayload(bytes.clone())))
     }
 }
-
-// TODO: Import this from the air_filter code itself instead of copying
-#[derive(PartialEq, Eq, Debug, Clone, Copy, Deserialize, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum AirFilterFanState {
-    Off,
-    Low,
-    Medium,
-    High,
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
-pub struct SetAirFilterFanState {
-    state: AirFilterFanState,
-}
-
-#[derive(PartialEq, Debug, Clone, Copy, Deserialize, Serialize)]
-pub struct AirFilterState {
-    pub state: AirFilterFanState,
-    pub humidity: f32,
-    pub temperature: f32,
-}
-
-impl SetAirFilterFanState {
-    pub fn new(state: AirFilterFanState) -> Self {
-        Self { state }
-    }
-}
-
-impl TryFrom<Publish> for AirFilterState {
-    type Error = ParseError;
-
-    fn try_from(message: Publish) -> Result<Self, Self::Error> {
-        serde_json::from_slice(&message.payload)
-            .or(Err(ParseError::InvalidPayload(message.payload.clone())))
-    }
-}

automation_lib/src/mqtt.rs

@@ -0,0 +1,128 @@
+use std::ops::{Deref, DerefMut};
+use std::time::Duration;
+
+use automation_macro::LuaDeviceConfig;
+use lua_typed::Typed;
+use mlua::FromLua;
+use rumqttc::{AsyncClient, Event, Incoming, MqttOptions, Transport};
+use serde::Deserialize;
+use tracing::{debug, warn};
+
+use crate::event::{self, EventChannel};
+
+#[derive(Debug, Clone, LuaDeviceConfig, Deserialize, Typed)]
+pub struct MqttConfig {
+    pub host: String,
+    pub port: u16,
+    pub client_name: String,
+    pub username: String,
+    pub password: String,
+    #[serde(default)]
+    #[typed(default)]
+    pub tls: bool,
+}
+
+impl From<MqttConfig> for MqttOptions {
+    fn from(value: MqttConfig) -> Self {
+        let mut mqtt_options = MqttOptions::new(value.client_name, value.host, value.port);
+        mqtt_options.set_credentials(value.username, value.password);
+        mqtt_options.set_keep_alive(Duration::from_secs(5));
+
+        if value.tls {
+            mqtt_options.set_transport(Transport::tls_with_default_config());
+        }
+
+        mqtt_options
+    }
+}
+
+#[derive(Debug, Clone, FromLua)]
+pub struct WrappedAsyncClient(pub AsyncClient);
+
+impl Typed for WrappedAsyncClient {
+    fn type_name() -> String {
+        "AsyncClient".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        let type_name = Self::type_name();
+        Some(format!("---@class {type_name}\nlocal {type_name}\n"))
+    }
+
+    fn generate_members() -> Option<String> {
+        let mut output = String::new();
+
+        let type_name = Self::type_name();
+
+        output += &format!(
+            "---@async\n---@param topic string\n---@param message table?\nfunction {type_name}:send_message(topic, message) end\n"
+        );
+
+        Some(output)
+    }
+}
+
+impl Deref for WrappedAsyncClient {
+    type Target = AsyncClient;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for WrappedAsyncClient {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl mlua::UserData for WrappedAsyncClient {
+    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
+        methods.add_async_method(
+            "send_message",
+            async |_lua, this, (topic, message): (String, mlua::Value)| {
+                // serde_json converts nil => "null", but we actually want nil to send an empty
+                // message
+                let message = if message.is_nil() {
+                    "".into()
+                } else {
+                    serde_json::to_string(&message).unwrap()
+                };
+
+                debug!("message = {message}");
+
+                this.0
+                    .publish(topic, rumqttc::QoS::AtLeastOnce, true, message)
+                    .await
+                    .unwrap();
+
+                Ok(())
+            },
+        );
+    }
+}
+
+pub fn start(config: MqttConfig, event_channel: &EventChannel) -> WrappedAsyncClient {
+    let tx = event_channel.get_tx();
+    let (client, mut eventloop) = AsyncClient::new(config.into(), 100);
+
+    tokio::spawn(async move {
+        debug!("Listening for MQTT events");
+        loop {
+            let notification = eventloop.poll().await;
+            match notification {
+                Ok(Event::Incoming(Incoming::Publish(p))) => {
+                    tx.send(event::Event::MqttMessage(p)).await.ok();
+                }
+                Ok(..) => continue,
+                Err(err) => {
+                    // Something has gone wrong
+                    // We stay in the loop as that will attempt to reconnect
+                    warn!("{}", err);
+                }
+            }
+        }
+    });
+
+    WrappedAsyncClient(client)
+}

automation_macro/Cargo.toml

@@ -1,20 +1,16 @@
 [package]
 name = "automation_macro"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [lib]
 proc-macro = true
 
 [dependencies]
-automation_cast = { path = "../automation_cast" }
+itertools = { workspace = true }
-async-trait = "0.1.80"
+proc-macro2 = { workspace = true }
-itertools = "0.12.1"
+quote = { workspace = true }
-proc-macro2 = "1.0.81"
+syn = { workspace = true }
-quote = "1.0.36"
-serde = { version = "1.0.202", features = ["derive"] }
-syn = { version = "2.0.60", features = ["extra-traits", "full"] }
-serde_json = "1.0.118"
 
 [dev-dependencies]
-serde = { version = "1.0.202", features = ["derive"] }
+mlua = { workspace = true }

automation_macro/src/device.rs

@@ -0,0 +1,265 @@
+use std::collections::HashMap;
+
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::parse::{Parse, ParseStream};
+use syn::punctuated::Punctuated;
+use syn::spanned::Spanned;
+use syn::{Attribute, DeriveInput, Token, parenthesized};
+
+enum Attr {
+    Trait(TraitAttr),
+    ExtraUserData(ExtraUserDataAttr),
+}
+
+impl Attr {
+    fn parse(attr: &Attribute) -> syn::Result<Self> {
+        let mut parsed = None;
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("traits") {
+                let input;
+                _ = parenthesized!(input in meta.input);
+                parsed = Some(Attr::Trait(input.parse()?));
+            } else if meta.path.is_ident("extra_user_data") {
+                let value = meta.value()?;
+                parsed = Some(Attr::ExtraUserData(value.parse()?));
+            } else {
+                return Err(syn::Error::new(meta.path.span(), "Unknown attribute"));
+            }
+
+            Ok(())
+        })?;
+
+        Ok(parsed.expect("Parsed should be set"))
+    }
+}
+
+struct TraitAttr {
+    traits: Traits,
+    aliases: Aliases,
+}
+
+impl Parse for TraitAttr {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            traits: input.parse()?,
+            aliases: input.parse()?,
+        })
+    }
+}
+
+#[derive(Default)]
+struct Traits(Vec<syn::Ident>);
+
+impl Traits {
+    fn extend(&mut self, other: &Traits) {
+        self.0.extend_from_slice(&other.0);
+    }
+}
+
+impl Parse for Traits {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        input
+            .call(Punctuated::<_, Token![,]>::parse_separated_nonempty)
+            .map(|traits| traits.into_iter().collect())
+            .map(Self)
+    }
+}
+
+#[derive(Default)]
+struct Aliases(Vec<syn::Ident>);
+
+impl Aliases {
+    fn has_aliases(&self) -> bool {
+        !self.0.is_empty()
+    }
+}
+
+impl Parse for Aliases {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if !input.peek(Token![for]) {
+            if input.is_empty() {
+                return Ok(Default::default());
+            } else {
+                return Err(input.error("Expected ')' or 'for'"));
+            }
+        }
+
+        _ = input.parse::<syn::Token![for]>()?;
+
+        input
+            .call(Punctuated::<_, Token![,]>::parse_separated_nonempty)
+            .map(|aliases| aliases.into_iter().collect())
+            .map(Self)
+    }
+}
+
+#[derive(Clone)]
+struct ExtraUserDataAttr(syn::Ident);
+
+impl Parse for ExtraUserDataAttr {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self(input.parse()?))
+    }
+}
+
+struct Implementation {
+    name: syn::Ident,
+    traits: Traits,
+    extra_user_data: Vec<ExtraUserDataAttr>,
+}
+
+impl quote::ToTokens for Implementation {
+    fn to_tokens(&self, tokens: &mut TokenStream2) {
+        let Self {
+            name,
+            traits,
+            extra_user_data,
+        } = &self;
+        let Traits(traits) = traits;
+        let extra_user_data: Vec<_> = extra_user_data.iter().map(|tr| tr.0.clone()).collect();
+
+        tokens.extend(quote! {
+            impl mlua::UserData for #name {
+                fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
+                    methods.add_async_function("new", async |_lua, config| {
+                        let device: Self = LuaDeviceCreate::create(config)
+                            .await
+                            .map_err(mlua::ExternalError::into_lua_err)?;
+
+                        Ok(device)
+                    });
+
+                    methods.add_method("__box", |_lua, this, _: ()| {
+                        let b: Box<dyn Device> = Box::new(this.clone());
+                        Ok(b)
+                    });
+
+                    <::automation_lib::lua::traits::Device as ::automation_lib::lua::traits::PartialUserData<#name>>::add_methods(methods);
+
+                    #(
+                        <::automation_lib::lua::traits::#traits as ::automation_lib::lua::traits::PartialUserData<#name>>::add_methods(methods);
+                    )*
+
+                    #(
+                        <#extra_user_data as ::automation_lib::lua::traits::PartialUserData<#name>>::add_methods(methods);
+                    )*
+                }
+            }
+
+            impl ::lua_typed::Typed for #name {
+                fn type_name() -> String {
+                    stringify!(#name).into()
+                }
+
+                fn generate_header() -> std::option::Option<::std::string::String> {
+                    let type_name = <Self as ::lua_typed::Typed>::type_name();
+                    let mut output = String::new();
+
+                    let interfaces: String = [
+                        <::automation_lib::lua::traits::Device as ::automation_lib::lua::traits::PartialUserData<#name>>::interface_name(),
+                        #(
+                            <::automation_lib::lua::traits::#traits as ::automation_lib::lua::traits::PartialUserData<#name>>::interface_name(),
+                        )*
+                    ].into_iter().flatten().intersperse(", ").collect();
+
+                    let interfaces = if interfaces.is_empty() {
+                        "".into()
+                    } else {
+                        format!(": {interfaces}")
+                    };
+
+                    Some(format!("---@class {type_name}{interfaces}\nlocal {type_name}\n"))
+                }
+
+                fn generate_members() -> Option<String> {
+                    let mut output = String::new();
+
+                    let type_name = <Self as ::lua_typed::Typed>::type_name();
+                    output += &format!("devices.{type_name} = {{}}\n");
+                    let config_name = <<Self as ::automation_lib::device::LuaDeviceCreate>::Config as ::lua_typed::Typed>::type_name();
+                    output += &format!("---@param config {config_name}\n");
+                    output += &format!("---@return {type_name}\n");
+                    output += &format!("function devices.{type_name}.new(config) end\n");
+
+                    output += &<::automation_lib::lua::traits::Device as ::automation_lib::lua::traits::PartialUserData<#name>>::definitions().unwrap_or("".into());
+
+                    #(
+                        output += &<::automation_lib::lua::traits::#traits as ::automation_lib::lua::traits::PartialUserData<#name>>::definitions().unwrap_or("".into());
+                    )*
+                    #(
+                        output += &<#extra_user_data as ::automation_lib::lua::traits::PartialUserData<#name>>::definitions().unwrap_or("".into());
+                    )*
+
+
+                    Some(output)
+                }
+            }
+        });
+    }
+}
+
+struct Implementations(Vec<Implementation>);
+
+impl Implementations {
+    fn from_attr(attributes: Vec<Attr>, name: syn::Ident) -> Self {
+        let mut add_methods = Vec::new();
+        let mut all = Traits::default();
+        let mut implementations: HashMap<_, Traits> = HashMap::new();
+        for attribute in attributes {
+            match attribute {
+                Attr::Trait(attribute) => {
+                    if attribute.aliases.has_aliases() {
+                        for alias in &attribute.aliases.0 {
+                            implementations
+                                .entry(Some(alias.clone()))
+                                .or_default()
+                                .extend(&attribute.traits);
+                        }
+                    } else {
+                        all.extend(&attribute.traits);
+                    }
+                }
+                Attr::ExtraUserData(attribute) => add_methods.push(attribute),
+            }
+        }
+
+        if implementations.is_empty() {
+            implementations.entry(None).or_default().extend(&all);
+        } else {
+            for traits in implementations.values_mut() {
+                traits.extend(&all);
+            }
+        }
+
+        Self(
+            implementations
+                .into_iter()
+                .map(|(alias, traits)| Implementation {
+                    name: alias.unwrap_or(name.clone()),
+                    traits,
+                    extra_user_data: add_methods.clone(),
+                })
+                .collect(),
+        )
+    }
+}
+
+pub fn device(input: DeriveInput) -> TokenStream2 {
+    let Implementations(imp) = match input
+        .attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("device"))
+        .map(Attr::parse)
+        .try_collect::<Vec<_>>()
+    {
+        Ok(attr) => Implementations::from_attr(attr, input.ident),
+        Err(err) => return err.into_compile_error(),
+    };
+
+    quote! {
+        #(
+            #imp
+        )*
+    }
+}

automation_macro/src/lib.rs

@@ -1,9 +1,11 @@
-#![feature(let_chains)]
 #![feature(iter_intersperse)]
+#![feature(iterator_try_collect)]
+mod device;
 mod lua_device_config;
 
 use lua_device_config::impl_lua_device_config_macro;
-use syn::{parse_macro_input, DeriveInput};
+use quote::quote;
+use syn::{DeriveInput, parse_macro_input};
 
 #[proc_macro_derive(LuaDeviceConfig, attributes(device_config))]
 pub fn lua_device_config_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -11,3 +13,61 @@ pub fn lua_device_config_derive(input: proc_macro::TokenStream) -> proc_macro::T
 
     impl_lua_device_config_macro(&ast).into()
 }
+
+#[proc_macro_derive(LuaSerialize, attributes(traits))]
+pub fn lua_serialize(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let name = &ast.ident;
+
+    quote! {
+        impl ::mlua::IntoLua for #name {
+            fn into_lua(self, lua: &::mlua::Lua) -> ::mlua::Result<::mlua::Value> {
+                ::mlua::LuaSerdeExt::to_value(lua, &self)
+            }
+        }
+    }
+    .into()
+}
+
+/// Derive macro generating an impl for the trait `::mlua::UserData`
+///
+/// # Device traits
+/// The `device(traits)` attribute can be used to tell the macro what traits are implemented so that
+/// the appropriate methods can automatically be registered.
+/// If the struct does not have any type parameters the syntax is very simple:
+/// ```rust
+/// #[device(traits(TraitA, TraitB))]
+/// ```
+///
+/// If the type does have type parameters you will have to manually specify all variations that
+/// have the trait available:
+/// ```rust
+/// #[device(traits(TraitA, TraitB for <StateA>, <StateB>))]
+/// ```
+/// If multiple of these attributes are specified they will all combined appropriately.
+///
+///
+/// ## NOTE
+/// If your type _has_ type parameters any instance of the traits attribute that does not specify
+/// any type parameters will have the traits applied to _all_ other type parameter variations
+/// listed in the other trait attributes. This behavior only applies if there is at least one
+/// instance with type parameters specified.
+///
+/// # Additional methods
+/// Additional methods can be added by using the `device(add_methods)` attribute. This attribute
+/// takes the path to a function with the following signature that can register the additional methods:
+///
+/// ```rust
+/// # struct D;
+/// fn top_secret<M: mlua::UserDataMethods<D>>(methods: &mut M) {}
+/// ```
+/// It can then be registered with:
+/// ```rust
+/// #[device(add_methods = top_secret)]
+/// ```
+#[proc_macro_derive(Device, attributes(device))]
+pub fn device(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    device::device(ast).into()
+}

automation_macro/src/lua_device_config.rs

@@ -6,8 +6,8 @@ use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::token::Paren;
 use syn::{
-    parenthesized, Data, DataStruct, DeriveInput, Expr, Field, Fields, FieldsNamed, LitStr, Result,
+    Data, DataStruct, DeriveInput, Expr, Field, Fields, FieldsNamed, LitStr, Result, Token, Type,
-    Token, Type,
+    parenthesized,
 };
 
 mod kw {
@@ -155,7 +155,7 @@ fn field_from_lua(field: &Field) -> TokenStream {
         [] => field.ident.clone().unwrap().to_string(),
         [rename] => rename.to_owned(),
         _ => {
-            return quote_spanned! {field.span() => compile_error!("Field contains duplicate 'rename'")}
+            return quote_spanned! {field.span() => compile_error!("Field contains duplicate 'rename'")};
         }
     };
 
@@ -174,7 +174,7 @@ fn field_from_lua(field: &Field) -> TokenStream {
         [] => quote! {panic!(#missing)},
         [default] => default.to_owned(),
         _ => {
-            return quote_spanned! {field.span() => compile_error!("Field contains duplicate 'default'")}
+            return quote_spanned! {field.span() => compile_error!("Field contains duplicate 'default'")};
         }
     };
 
@@ -232,7 +232,7 @@ fn field_from_lua(field: &Field) -> TokenStream {
         [] => value,
         [value] => value.to_owned(),
         _ => {
-            return quote_spanned! {field.span() => compile_error!("Only one of either 'from' or 'with' is allowed")}
+            return quote_spanned! {field.span() => compile_error!("Only one of either 'from' or 'with' is allowed")};
         }
     };
 
@@ -260,9 +260,10 @@ pub fn impl_lua_device_config_macro(ast: &DeriveInput) -> TokenStream {
         })
         .collect();
 
+    let (impl_generics, type_generics, where_clause) = ast.generics.split_for_impl();
     let impl_from_lua = quote! {
-        impl<'lua> mlua::FromLua<'lua> for #name {
+        impl #impl_generics mlua::FromLua for #name #type_generics #where_clause {
-            fn from_lua(value: mlua::Value<'lua>, lua: &'lua mlua::Lua) -> mlua::Result<Self> {
+            fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
                 if !value.is_table() {
                     panic!("Expected table");
                 }

config.lua

@@ -1,191 +0,0 @@
-print("Hello from lua")
-
-local host = automation.util.get_hostname()
-print("Running @" .. host)
-
-local debug, value = pcall(automation.util.get_env, "DEBUG")
-if debug and value ~= "true" then
-	debug = false
-end
-
-local function mqtt_z2m(topic)
-	return "zigbee2mqtt/" .. topic
-end
-
-local function mqtt_automation(topic)
-	return "automation/" .. topic
-end
-
-automation.fulfillment = {
-	openid_url = "https://login.huizinga.dev/api/oidc",
-}
-
-local mqtt_client = automation.new_mqtt_client({
-	host = (host == "zeus" and "olympus.lan.huizinga.dev")
-		or (host == "hephaestus" and "olympus.vpn.huizinga.dev")
-		or "mosquitto",
-	port = 8883,
-	client_name = "automation-" .. host,
-	username = "mqtt",
-	password = automation.util.get_env("MQTT_PASSWORD"),
-	tls = host == "zeus" or host == "hephaestus",
-})
-
-automation.device_manager:add(Ntfy.new({
-	topic = automation.util.get_env("NTFY_TOPIC"),
-	event_channel = automation.device_manager:event_channel(),
-}))
-
-automation.device_manager:add(Presence.new({
-	topic = mqtt_automation("presence/+/#"),
-	client = mqtt_client,
-	event_channel = automation.device_manager:event_channel(),
-}))
-
-automation.device_manager:add(DebugBridge.new({
-	identifier = "debug_bridge",
-	topic = mqtt_automation("debug"),
-	client = mqtt_client,
-}))
-
-local hue_ip = "10.0.0.146"
-local hue_token = automation.util.get_env("HUE_TOKEN")
-
-automation.device_manager:add(HueBridge.new({
-	identifier = "hue_bridge",
-	ip = hue_ip,
-	login = hue_token,
-	flags = {
-		presence = 41,
-		darkness = 43,
-	},
-}))
-
-automation.device_manager:add(LightSensor.new({
-	identifier = "living_light_sensor",
-	topic = mqtt_z2m("living/light"),
-	client = mqtt_client,
-	min = 22000,
-	max = 23500,
-	event_channel = automation.device_manager:event_channel(),
-}))
-
-automation.device_manager:add(WakeOnLAN.new({
-	name = "Zeus",
-	room = "Living Room",
-	topic = mqtt_automation("appliance/living_room/zeus"),
-	client = mqtt_client,
-	mac_address = "30:9c:23:60:9c:13",
-	broadcast_ip = "10.0.0.255",
-}))
-
-local living_mixer = KasaOutlet.new({ identifier = "living_mixer", ip = "10.0.0.49" })
-automation.device_manager:add(living_mixer)
-local living_speakers = KasaOutlet.new({ identifier = "living_speakers", ip = "10.0.0.182" })
-automation.device_manager:add(living_speakers)
-
-automation.device_manager:add(AudioSetup.new({
-	identifier = "living_audio",
-	topic = mqtt_z2m("living/remote"),
-	client = mqtt_client,
-	mixer = living_mixer,
-	speakers = living_speakers,
-}))
-
-automation.device_manager:add(IkeaOutlet.new({
-	outlet_type = "Kettle",
-	name = "Kettle",
-	room = "Kitchen",
-	topic = mqtt_z2m("kitchen/kettle"),
-	client = mqtt_client,
-	timeout = debug and 5 or 300,
-	remotes = {
-		{ topic = mqtt_z2m("bedroom/remote") },
-		{ topic = mqtt_z2m("kitchen/remote") },
-	},
-}))
-
-automation.device_manager:add(IkeaOutlet.new({
-	outlet_type = "Light",
-	name = "Light",
-	room = "Bathroom",
-	topic = mqtt_z2m("bathroom/light"),
-	client = mqtt_client,
-	timeout = debug and 60 or 45 * 60,
-}))
-
-automation.device_manager:add(Washer.new({
-	identifier = "bathroom_washer",
-	topic = mqtt_z2m("bathroom/washer"),
-	client = mqtt_client,
-	threshold = 1,
-	event_channel = automation.device_manager:event_channel(),
-}))
-
-automation.device_manager:add(IkeaOutlet.new({
-	outlet_type = "Charger",
-	name = "Charger",
-	room = "Workbench",
-	topic = mqtt_z2m("workbench/charger"),
-	client = mqtt_client,
-	timeout = debug and 5 or 20 * 3600,
-}))
-
-automation.device_manager:add(IkeaOutlet.new({
-	name = "Outlet",
-	room = "Workbench",
-	topic = mqtt_z2m("workbench/outlet"),
-	client = mqtt_client,
-}))
-
-local hallway_lights = HueGroup.new({
-	identifier = "hallway_lights",
-	ip = hue_ip,
-	login = hue_token,
-	group_id = 81,
-	scene_id = "3qWKxGVadXFFG4o",
-	timer_id = 1,
-	remotes = {
-		{ topic = mqtt_z2m("hallway/remote") },
-	},
-	client = mqtt_client,
-})
-automation.device_manager:add(hallway_lights)
-
-automation.device_manager:add(ContactSensor.new({
-	identifier = "hallway_frontdoor",
-	topic = mqtt_z2m("hallway/frontdoor"),
-	client = mqtt_client,
-	presence = {
-		topic = mqtt_automation("presence/contact/frontdoor"),
-		timeout = debug and 10 or 15 * 60,
-	},
-	trigger = {
-		devices = { hallway_lights },
-		timeout = debug and 10 or 2 * 60,
-	},
-}))
-
-automation.device_manager:add(ContactSensor.new({
-	identifier = "hallway_trash",
-	topic = mqtt_z2m("hallway/trash"),
-	client = mqtt_client,
-	trigger = {
-		devices = { hallway_lights },
-	},
-}))
-
-local bedroom_air_filter = AirFilter.new({
-	name = "Air Filter",
-	room = "Bedroom",
-	topic = "pico/filter/bedroom",
-	client = mqtt_client,
-})
-automation.device_manager:add(bedroom_air_filter)
-
-automation.device_manager:schedule("0 0 19 * * *", function()
-	bedroom_air_filter:set_on(true)
-end)
-automation.device_manager:schedule("0 0 20 * * *", function()
-	bedroom_air_filter:set_on(false)
-end)

config/battery.lua

@@ -0,0 +1,47 @@
+local ntfy = require("config.ntfy")
+
+--- @class BatteryModule: Module
+local module = {}
+
+--- @type {[string]: number}
+local low_battery = {}
+
+--- @param device DeviceInterface
+--- @param battery number
+function module.callback(device, battery)
+	local id = device:get_id()
+	if battery < 15 then
+		print("Device '" .. id .. "' has low battery: " .. tostring(battery))
+		low_battery[id] = battery
+	else
+		low_battery[id] = nil
+	end
+end
+
+local function notify_low_battery()
+	-- Don't send notifications if there are now devices with low battery
+	if next(low_battery) == nil then
+		print("No devices with low battery")
+		return
+	end
+
+	local lines = {}
+	for name, battery in pairs(low_battery) do
+		table.insert(lines, name .. ": " .. tostring(battery) .. "%")
+	end
+	local message = table.concat(lines, "\n")
+
+	ntfy.send_notification({
+		title = "Low battery",
+		message = message,
+		tags = { "battery" },
+		priority = "default",
+	})
+end
+
+--- @type Schedule
+module.schedule = {
+	["0 0 21 */1 * *"] = notify_low_battery,
+}
+
+return module

config/config.lua

@@ -0,0 +1,32 @@
+local utils = require("automation:utils")
+local secrets = require("automation:secrets")
+
+local host = utils.get_hostname()
+print("Lua " .. _VERSION .. " running on " .. utils.get_hostname())
+
+---@type Config
+return {
+	fulfillment = {
+		openid_url = "https://login.huizinga.dev/api/oidc",
+	},
+	mqtt = {
+		host = ((host == "zeus" or host == "hephaestus") and "olympus.lan.huizinga.dev") or "mosquitto",
+		port = 8883,
+		client_name = "automation-" .. host,
+		username = "mqtt",
+		password = secrets.mqtt_password,
+		tls = host == "zeus" or host == "hephaestus",
+	},
+	modules = {
+		require("config.battery"),
+		require("config.debug"),
+		require("config.hallway_automation"),
+		require("config.helper"),
+		require("config.hue_bridge"),
+		require("config.light"),
+		require("config.ntfy"),
+		require("config.presence"),
+		require("config.rooms"),
+		require("config.windows"),
+	},
+}

config/debug.lua

@@ -0,0 +1,35 @@
+local helper = require("config.helper")
+local light = require("config.light")
+local presence = require("config.presence")
+local utils = require("automation:utils")
+local variables = require("automation:variables")
+
+--- @class DebugModule: Module
+local module = {}
+
+if variables.debug == "true" then
+	module.debug_mode = true
+elseif not variables.debug or variables.debug == "false" then
+	module.debug_mode = false
+else
+	error("Variable debug has invalid value '" .. variables.debug .. "', expected 'true' or 'false'")
+end
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	presence.add_callback(function(p)
+		mqtt_client:send_message(helper.mqtt_automation("debug") .. "/presence", {
+			state = p,
+			updated = utils.get_epoch(),
+		})
+	end)
+
+	light.add_callback(function(l)
+		mqtt_client:send_message(helper.mqtt_automation("debug") .. "/darkness", {
+			state = not l,
+			updated = utils.get_epoch(),
+		})
+	end)
+end
+
+return module

config/hallway_automation.lua

@@ -0,0 +1,85 @@
+local debug = require("config.debug")
+local utils = require("automation:utils")
+
+--- @class HallwayAutomationModule: Module
+local module = {}
+
+local timeout = utils.Timeout.new()
+local forced = false
+--- @type OpenCloseInterface?
+local trash = nil
+--- @type OpenCloseInterface?
+local door = nil
+
+--- @type fun(on: boolean)[]
+local callbacks = {}
+
+--- @param on boolean
+local function callback(on)
+	for _, f in ipairs(callbacks) do
+		f(on)
+	end
+end
+
+---@type fun(device: DeviceInterface, on: boolean)
+function module.switch_callback(_, on)
+	timeout:cancel()
+	callback(on)
+	forced = on
+end
+
+---@type fun(device: DeviceInterface, open: boolean)
+function module.door_callback(_, open)
+	if open then
+		timeout:cancel()
+
+		callback(true)
+	elseif not forced then
+		timeout:start(debug.debug_mode and 10 or 2 * 60, function()
+			if trash == nil or trash:open_percent() == 0 then
+				callback(false)
+			end
+		end)
+	end
+end
+
+---@type fun(device: DeviceInterface, open: boolean)
+function module.trash_callback(_, open)
+	if open then
+		callback(true)
+	else
+		if not forced and not timeout:is_waiting() and (door == nil or door:open_percent() == 0) then
+			callback(false)
+		end
+	end
+end
+
+---@type fun(device: DeviceInterface, state: { state: boolean })
+function module.light_callback(_, state)
+	print("LIGHT = " .. tostring(state.state))
+	if state.state and (trash == nil or trash:open_percent()) == 0 and (door == nil or door:open_percent() == 0) then
+		-- If the door and trash are not open, that means the light got turned on manually
+		timeout:cancel()
+		forced = true
+	elseif not state.state then
+		-- The light is never forced when it is off
+		forced = false
+	end
+end
+
+--- @param t OpenCloseInterface
+function module.set_trash(t)
+	trash = t
+end
+
+--- @param d OpenCloseInterface
+function module.set_door(d)
+	door = d
+end
+
+--- @param c fun(on: boolean)
+function module.add_callback(c)
+	table.insert(callbacks, c)
+end
+
+return module

config/helper.lua

@@ -0,0 +1,49 @@
+local utils = require("automation:utils")
+
+--- @class HelperModule: Module
+local module = {}
+
+--- @param topic string
+--- @return string
+function module.mqtt_z2m(topic)
+	return "zigbee2mqtt/" .. topic
+end
+
+--- @param topic string
+--- @return string
+function module.mqtt_automation(topic)
+	return "automation/" .. topic
+end
+
+--- @return fun(self: OnOffInterface, state: {state: boolean, power: number})
+function module.auto_off()
+	local timeout = utils.Timeout.new()
+
+	return function(self, state)
+		if state.state and state.power < 100 then
+			timeout:start(3, function()
+				self:set_on(false)
+			end)
+		else
+			timeout:cancel()
+		end
+	end
+end
+
+--- @param duration number
+--- @return fun(self: OnOffInterface, state: {state: boolean})
+function module.off_timeout(duration)
+	local timeout = utils.Timeout.new()
+
+	return function(self, state)
+		if state.state then
+			timeout:start(duration, function()
+				self:set_on(false)
+			end)
+		else
+			timeout:cancel()
+		end
+	end
+end
+
+return module

config/hue_bridge.lua

@@ -0,0 +1,41 @@
+local devices = require("automation:devices")
+local light = require("config.light")
+local presence = require("config.presence")
+local secrets = require("automation:secrets")
+
+--- @class HueBridgeModule: Module
+local module = {}
+
+module.ip = "10.0.0.102"
+module.token = secrets.hue_token
+
+if module.token == nil then
+	error("Hue token is not specified")
+end
+
+--- @type SetupFunction
+function module.setup()
+	local bridge = devices.HueBridge.new({
+		identifier = "hue_bridge",
+		ip = module.ip,
+		login = module.token,
+		flags = {
+			presence = 41,
+			darkness = 43,
+		},
+	})
+
+	light.add_callback(function(l)
+		bridge:set_flag("darkness", not l)
+	end)
+
+	presence.add_callback(function(p)
+		bridge:set_flag("presence", p)
+	end)
+
+	return {
+		bridge,
+	}
+end
+
+return module

config/light.lua

@@ -0,0 +1,44 @@
+local devices = require("automation:devices")
+local helper = require("config.helper")
+
+--- @class LightModule: Module
+local module = {}
+
+--- @class OnPresence
+--- @field [integer] fun(light: boolean)
+local callbacks = {}
+
+--- @param callback fun(light: boolean)
+function module.add_callback(callback)
+	table.insert(callbacks, callback)
+end
+
+--- @param _ DeviceInterface
+--- @param light boolean
+local function callback(_, light)
+	for _, f in ipairs(callbacks) do
+		f(light)
+	end
+end
+
+--- @type LightSensor?
+module.device = nil
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	module.device = devices.LightSensor.new({
+		identifier = "living_light_sensor",
+		topic = helper.mqtt_z2m("living/light"),
+		client = mqtt_client,
+		min = 22000,
+		max = 23500,
+		callback = callback,
+	})
+
+	--- @type Module
+	return {
+		module.device,
+	}
+end
+
+return module

config/ntfy.lua

@@ -0,0 +1,34 @@
+local devices = require("automation:devices")
+local secrets = require("automation:secrets")
+
+--- @class NtfyModule: Module
+local module = {}
+
+local ntfy_topic = secrets.ntfy_topic
+if ntfy_topic == nil then
+	error("Ntfy topic is not specified")
+end
+
+--- @type Ntfy?
+local ntfy = nil
+
+--- @param notification Notification
+function module.send_notification(notification)
+	if ntfy then
+		ntfy:send_notification(notification)
+	end
+end
+
+--- @type SetupFunction
+function module.setup()
+	ntfy = devices.Ntfy.new({
+		topic = ntfy_topic,
+	})
+
+	--- @type Module
+	return {
+		ntfy,
+	}
+end
+
+return module

config/presence.lua

@@ -0,0 +1,80 @@
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local ntfy = require("config.ntfy")
+
+--- @class PresenceModule: Module
+local module = {}
+
+--- @class OnPresence
+--- @field [integer] fun(presence: boolean)
+local callbacks = {}
+
+--- @param callback fun(presence: boolean)
+function module.add_callback(callback)
+	table.insert(callbacks, callback)
+end
+
+--- @param device OnOffInterface
+function module.turn_off_when_away(device)
+	module.add_callback(function(presence)
+		if not presence then
+			device:set_on(false)
+		end
+	end)
+end
+
+--- @param _ DeviceInterface
+--- @param presence boolean
+local function callback(_, presence)
+	for _, f in ipairs(callbacks) do
+		f(presence)
+	end
+end
+
+--- @type Presence?
+local presence = nil
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	presence = devices.Presence.new({
+		topic = helper.mqtt_automation("presence/+/#"),
+		client = mqtt_client,
+		callback = callback,
+	})
+
+	module.add_callback(function(p)
+		ntfy.send_notification({
+			title = "Presence",
+			message = p and "Home" or "Away",
+			tags = { "house" },
+			priority = "low",
+			actions = {
+				{
+					action = "broadcast",
+					extras = {
+						cmd = "presence",
+						state = p and "0" or "1",
+					},
+					label = p and "Set away" or "Set home",
+					clear = true,
+				},
+			},
+		})
+	end)
+
+	--- @type Module
+	return {
+		presence,
+	}
+end
+
+function module.overall_presence()
+	-- Default to no presence when the device has not been created yet
+	if not presence then
+		return false
+	end
+
+	return presence:overall_presence()
+end
+
+return module

config/rooms.lua

@@ -0,0 +1,12 @@
+--- @type Module
+return {
+	require("config.rooms.bathroom"),
+	require("config.rooms.bedroom"),
+	require("config.rooms.guest_bedroom"),
+	require("config.rooms.hallway_bottom"),
+	require("config.rooms.hallway_top"),
+	require("config.rooms.kitchen"),
+	require("config.rooms.living_room"),
+	require("config.rooms.storage"),
+	require("config.rooms.workbench"),
+}

config/rooms/bathroom.lua

@@ -0,0 +1,40 @@
+local debug = require("config.debug")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local ntfy = require("config.ntfy")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.LightOnOff.new({
+		name = "Light",
+		room = "Bathroom",
+		topic = helper.mqtt_z2m("bathroom/light"),
+		client = mqtt_client,
+		callback = helper.off_timeout(debug.debug_mode and 60 or 45 * 60),
+	})
+
+	local washer = devices.Washer.new({
+		identifier = "bathroom_washer",
+		topic = helper.mqtt_z2m("bathroom/washer"),
+		client = mqtt_client,
+		threshold = 1,
+		done_callback = function()
+			ntfy.send_notification({
+				title = "Laundy is done",
+				message = "Don't forget to hang it!",
+				tags = { "womans_clothes" },
+				priority = "high",
+			})
+		end,
+	})
+
+	--- @type Module
+	return {
+		light,
+		washer,
+	}
+end
+
+return module

config/rooms/bedroom.lua

@@ -0,0 +1,78 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+--- @type AirFilter?
+local air_filter = nil
+
+function module.setup(mqtt_client)
+	local lights = devices.HueGroup.new({
+		identifier = "bedroom_lights",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 3,
+		scene_id = "PvRs-lGD4VRytL9",
+	})
+	local lights_relax = devices.HueGroup.new({
+		identifier = "bedroom_lights_relax",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 3,
+		scene_id = "60tfTyR168v2csz",
+	})
+
+	air_filter = devices.AirFilter.new({
+		name = "Air Filter",
+		room = "Bedroom",
+		url = "http://10.0.0.103",
+	})
+
+	local switch = devices.HueSwitch.new({
+		name = "Switch",
+		room = "Bedroom",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("bedroom/switch"),
+		left_callback = function()
+			lights:set_on(not lights:on())
+		end,
+		left_hold_callback = function()
+			lights_relax:set_on(true)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local window = devices.ContactSensor.new({
+		name = "Window",
+		room = "Bedroom",
+		topic = helper.mqtt_z2m("bedroom/window"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(window)
+
+	--- @type Module
+	return {
+		devices = {
+			lights,
+			lights_relax,
+			air_filter,
+			switch,
+			window,
+		},
+		schedule = {
+			["0 0 19 * * *"] = function()
+				air_filter:set_on(true)
+			end,
+			["0 0 20 * * *"] = function()
+				air_filter:set_on(false)
+			end,
+		},
+	}
+end
+
+return module

config/rooms/guest_bedroom.lua

@@ -0,0 +1,43 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local presence = require("config.presence")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.LightOnOff.new({
+		name = "Light",
+		room = "Guest Room",
+		topic = helper.mqtt_z2m("guest/light"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(light)
+
+	local window = devices.ContactSensor.new({
+		name = "Window",
+		room = "Guest Room",
+		topic = helper.mqtt_z2m("guest/window"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(window)
+
+	local printer = devices.OutletOnOff.new({
+		name = "3D Printer",
+		room = "Guest Room",
+		topic = helper.mqtt_z2m("guest/printer"),
+		client = mqtt_client,
+	})
+
+	--- @type Module
+	return {
+		light,
+		window,
+		printer,
+	}
+end
+
+return module

config/rooms/hallway_bottom.lua

@@ -0,0 +1,105 @@
+local battery = require("config.battery")
+local debug = require("config.debug")
+local devices = require("automation:devices")
+local hallway_automation = require("config.hallway_automation")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local presence = require("config.presence")
+local utils = require("automation:utils")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local main_light = devices.HueGroup.new({
+		identifier = "hallway_main_light",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 81,
+		scene_id = "3qWKxGVadXFFG4o",
+	})
+	hallway_automation.add_callback(function(on)
+		main_light:set_on(on)
+	end)
+
+	local storage_light = devices.LightBrightness.new({
+		name = "Storage",
+		room = "Hallway",
+		topic = helper.mqtt_z2m("hallway/storage"),
+		client = mqtt_client,
+		callback = hallway_automation.light_callback,
+	})
+	presence.turn_off_when_away(storage_light)
+	hallway_automation.add_callback(function(on)
+		if on then
+			storage_light:set_brightness(80)
+		else
+			storage_light:set_on(false)
+		end
+	end)
+
+	local remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Hallway",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("hallway/remote"),
+		callback = hallway_automation.switch_callback,
+		battery_callback = battery.callback,
+	})
+
+	local trash = devices.ContactSensor.new({
+		name = "Trash",
+		room = "Hallway",
+		sensor_type = "Drawer",
+		topic = helper.mqtt_z2m("hallway/trash"),
+		client = mqtt_client,
+		callback = hallway_automation.trash_callback,
+		battery_callback = battery.callback,
+	})
+	hallway_automation.set_trash(trash)
+
+	local timeout = utils.Timeout.new()
+	local function frontdoor_presence(_, open)
+		if open then
+			timeout:cancel()
+
+			if not presence.overall_presence() then
+				mqtt_client:send_message(helper.mqtt_automation("presence/contact/frontdoor"), {
+					state = true,
+					updated = utils.get_epoch(),
+				})
+			end
+		else
+			timeout:start(debug.debug_mode and 10 or 15 * 60, function()
+				mqtt_client:send_message(helper.mqtt_automation("presence/contact/frontdoor"), nil)
+			end)
+		end
+	end
+
+	local frontdoor = devices.ContactSensor.new({
+		name = "Frontdoor",
+		room = "Hallway",
+		sensor_type = "Door",
+		topic = helper.mqtt_z2m("hallway/frontdoor"),
+		client = mqtt_client,
+		callback = {
+			frontdoor_presence,
+			hallway_automation.door_callback,
+		},
+		battery_callback = battery.callback,
+	})
+	windows.add(frontdoor)
+	hallway_automation.set_door(frontdoor)
+
+	--- @type Module
+	return {
+		main_light,
+		storage_light,
+		remote,
+		trash,
+		frontdoor,
+	}
+end
+
+return module

config/rooms/hallway_top.lua

@@ -0,0 +1,48 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.HueGroup.new({
+		identifier = "hallway_top_light",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 83,
+		scene_id = "QeufkFDICEHWeKJ7",
+	})
+
+	local top_switch = devices.HueSwitch.new({
+		name = "SwitchTop",
+		room = "Hallway",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("hallway/switchtop"),
+		left_callback = function()
+			light:set_on(not light:on())
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local bottom_switch = devices.HueSwitch.new({
+		name = "SwitchBottom",
+		room = "Hallway",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("hallway/switchbottom"),
+		left_callback = function()
+			light:set_on(not light:on())
+		end,
+		battery_callback = battery.callback,
+	})
+
+	--- @type Module
+	return {
+		light,
+		top_switch,
+		bottom_switch,
+	}
+end
+
+return module

config/rooms/kitchen.lua

@@ -0,0 +1,71 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local presence = require("config.presence")
+
+--- @class KitchenModule: Module
+local module = {}
+
+--- @type HueGroup?
+local lights = nil
+
+--- @type SetupFunction
+function module.setup(mqtt_client)
+	lights = devices.HueGroup.new({
+		identifier = "kitchen_lights",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 7,
+		scene_id = "7MJLG27RzeRAEVJ",
+	})
+
+	local kettle = devices.OutletPower.new({
+		outlet_type = "Kettle",
+		name = "Kettle",
+		room = "Kitchen",
+		topic = helper.mqtt_z2m("kitchen/kettle"),
+		client = mqtt_client,
+		callback = helper.auto_off(),
+	})
+	presence.turn_off_when_away(kettle)
+
+	local kettle_remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Kitchen",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("kitchen/remote"),
+		single_button = true,
+		callback = function(_, on)
+			kettle:set_on(on)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local kettle_remote_bedroom = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Bedroom",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("bedroom/remote"),
+		single_button = true,
+		callback = function(_, on)
+			kettle:set_on(on)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	return {
+		lights,
+		kettle,
+		kettle_remote,
+		kettle_remote_bedroom,
+	}
+end
+
+function module.toggle_lights()
+	if lights then
+		lights:set_on(not lights:on())
+	end
+end
+
+return module

config/rooms/living_room.lua

@@ -0,0 +1,126 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local hue_bridge = require("config.hue_bridge")
+local presence = require("config.presence")
+local windows = require("config.windows")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local lights = devices.HueGroup.new({
+		identifier = "living_lights",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 1,
+		scene_id = "SNZw7jUhQ3cXSjkj",
+	})
+
+	local lights_relax = devices.HueGroup.new({
+		identifier = "living_lights_relax",
+		ip = hue_bridge.ip,
+		login = hue_bridge.token,
+		group_id = 1,
+		scene_id = "eRJ3fvGHCcb6yNw",
+	})
+
+	local switch = devices.HueSwitch.new({
+		name = "Switch",
+		room = "Living",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("living/switch"),
+		left_callback = require("config.rooms.kitchen").toggle_lights,
+		right_callback = function()
+			lights:set_on(not lights:on())
+		end,
+		right_hold_callback = function()
+			lights_relax:set_on(true)
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local pc = devices.WakeOnLAN.new({
+		name = "Zeus",
+		room = "Living Room",
+		topic = helper.mqtt_automation("appliance/living_room/zeus"),
+		client = mqtt_client,
+		mac_address = "30:9c:23:60:9c:13",
+		broadcast_ip = "10.0.3.255",
+	})
+
+	local mixer = devices.OutletOnOff.new({
+		name = "Mixer",
+		room = "Living Room",
+		topic = helper.mqtt_z2m("living/mixer"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(mixer)
+
+	local speakers = devices.OutletOnOff.new({
+		name = "Speakers",
+		room = "Living Room",
+		topic = helper.mqtt_z2m("living/speakers"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(speakers)
+
+	local audio_remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Living Room",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("living/remote"),
+		single_button = true,
+		callback = function(_, on)
+			if on then
+				if mixer:on() then
+					mixer:set_on(false)
+					speakers:set_on(false)
+				else
+					mixer:set_on(true)
+					speakers:set_on(true)
+				end
+			else
+				if not mixer:on() then
+					mixer:set_on(true)
+				else
+					speakers:set_on(not speakers:on())
+				end
+			end
+		end,
+		battery_callback = battery.callback,
+	})
+
+	local balcony = devices.ContactSensor.new({
+		name = "Balcony",
+		room = "Living Room",
+		sensor_type = "Door",
+		topic = helper.mqtt_z2m("living/balcony"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(balcony)
+	local window = devices.ContactSensor.new({
+		name = "Window",
+		room = "Living Room",
+		topic = helper.mqtt_z2m("living/window"),
+		client = mqtt_client,
+		battery_callback = battery.callback,
+	})
+	windows.add(window)
+
+	--- @type Module
+	return {
+		lights,
+		lights_relax,
+		switch,
+		pc,
+		mixer,
+		speakers,
+		audio_remote,
+		balcony,
+		window,
+	}
+end
+
+return module

config/rooms/storage.lua

@@ -0,0 +1,41 @@
+local battery = require("config.battery")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local presence = require("config.presence")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local light = devices.LightBrightness.new({
+		name = "Light",
+		room = "Storage",
+		topic = helper.mqtt_z2m("storage/light"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(light)
+
+	local door = devices.ContactSensor.new({
+		name = "Door",
+		room = "Storage",
+		sensor_type = "Door",
+		topic = helper.mqtt_z2m("storage/door"),
+		client = mqtt_client,
+		callback = function(_, open)
+			if open then
+				light:set_brightness(100)
+			else
+				light:set_on(false)
+			end
+		end,
+		battery_callback = battery.callback,
+	})
+
+	--- @type Module
+	return {
+		light,
+		door,
+	}
+end
+
+return module

config/rooms/workbench.lua

@@ -0,0 +1,69 @@
+local battery = require("config.battery")
+local debug = require("config.debug")
+local devices = require("automation:devices")
+local helper = require("config.helper")
+local presence = require("config.presence")
+local utils = require("automation:utils")
+
+--- @type Module
+local module = {}
+
+function module.setup(mqtt_client)
+	local charger = devices.OutletOnOff.new({
+		name = "Charger",
+		room = "Workbench",
+		topic = helper.mqtt_z2m("workbench/charger"),
+		client = mqtt_client,
+		callback = helper.off_timeout(debug.debug_mode and 5 or 20 * 3600),
+	})
+
+	local outlets = devices.OutletOnOff.new({
+		name = "Outlets",
+		room = "Workbench",
+		topic = helper.mqtt_z2m("workbench/outlet"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(outlets)
+
+	local light = devices.LightColorTemperature.new({
+		name = "Light",
+		room = "Workbench",
+		topic = helper.mqtt_z2m("workbench/light"),
+		client = mqtt_client,
+	})
+	presence.turn_off_when_away(light)
+
+	local delay_color_temp = utils.Timeout.new()
+	local remote = devices.IkeaRemote.new({
+		name = "Remote",
+		room = "Workbench",
+		client = mqtt_client,
+		topic = helper.mqtt_z2m("workbench/remote"),
+		callback = function(_, on)
+			delay_color_temp:cancel()
+			if on then
+				light:set_brightness(82)
+				-- NOTE: This light does NOT support changing both the brightness and color
+				-- temperature at the same time, so we first change the brightness and once
+				-- that is complete we change the color temperature, as that is less likely
+				-- to have to actually change.
+				delay_color_temp:start(0.5, function()
+					light:set_color_temperature(3333)
+				end)
+			else
+				light:set_on(false)
+			end
+		end,
+		battery_callback = battery.callback,
+	})
+
+	--- @type Module
+	return {
+		charger,
+		outlets,
+		light,
+		remote,
+	}
+end
+
+return module

config/windows.lua

@@ -0,0 +1,43 @@
+local ntfy = require("config.ntfy")
+local presence = require("config.presence")
+
+--- @class WindowsModule: Module
+local module = {}
+
+--- @class OnPresence
+--- @field [integer] OpenCloseInterface
+local sensors = {}
+
+--- @param sensor OpenCloseInterface
+function module.add(sensor)
+	table.insert(sensors, sensor)
+end
+
+--- @type SetupFunction
+function module.setup()
+	presence.add_callback(function(p)
+		if not p then
+			local open = {}
+			for _, sensor in ipairs(sensors) do
+				if sensor:open_percent() > 0 then
+					local id = sensor:get_id()
+					print("Open window detected: " .. id)
+					table.insert(open, id)
+				end
+			end
+
+			if #open > 0 then
+				local message = table.concat(open, "\n")
+
+				ntfy.send_notification({
+					title = "Windows are open",
+					message = message,
+					tags = { "window" },
+					priority = "high",
+				})
+			end
+		end
+	end)
+end
+
+return module

definitions/automation:devices.lua

@@ -0,0 +1,337 @@
+-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED
+---@meta
+
+local devices
+
+---@class Action
+---@field action
+---| "broadcast"
+---@field extras (table<string, string>)?
+---@field label string
+---@field clear (boolean)?
+local Action
+
+---@class AirFilter: DeviceInterface, OnOffInterface
+local AirFilter
+devices.AirFilter = {}
+---@param config AirFilterConfig
+---@return AirFilter
+function devices.AirFilter.new(config) end
+
+---@class AirFilterConfig
+---@field name string
+---@field room (string)?
+---@field url string
+local AirFilterConfig
+
+---@class ConfigLightLightStateBrightness
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field callback (fun(_: LightBrightness, _: LightStateBrightness) | fun(_: LightBrightness, _: LightStateBrightness)[])?
+---@field client (AsyncClient)?
+local ConfigLightLightStateBrightness
+
+---@class ConfigLightLightStateColorTemperature
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field callback (fun(_: LightColorTemperature, _: LightStateColorTemperature) | fun(_: LightColorTemperature, _: LightStateColorTemperature)[])?
+---@field client (AsyncClient)?
+local ConfigLightLightStateColorTemperature
+
+---@class ConfigLightLightStateOnOff
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field callback (fun(_: LightOnOff, _: LightStateOnOff) | fun(_: LightOnOff, _: LightStateOnOff)[])?
+---@field client (AsyncClient)?
+local ConfigLightLightStateOnOff
+
+---@class ConfigOutletOutletStateOnOff
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field outlet_type (OutletType)?
+---@field callback (fun(_: OutletOnOff, _: OutletStateOnOff) | fun(_: OutletOnOff, _: OutletStateOnOff)[])?
+---@field client AsyncClient
+local ConfigOutletOutletStateOnOff
+
+---@class ConfigOutletOutletStatePower
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field outlet_type (OutletType)?
+---@field callback (fun(_: OutletPower, _: OutletStatePower) | fun(_: OutletPower, _: OutletStatePower)[])?
+---@field client AsyncClient
+local ConfigOutletOutletStatePower
+
+---@class ContactSensor: DeviceInterface, OpenCloseInterface
+local ContactSensor
+devices.ContactSensor = {}
+---@param config ContactSensorConfig
+---@return ContactSensor
+function devices.ContactSensor.new(config) end
+
+---@class ContactSensorConfig
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field sensor_type (SensorType)?
+---@field callback (fun(_: ContactSensor, _: boolean) | fun(_: ContactSensor, _: boolean)[])?
+---@field battery_callback (fun(_: ContactSensor, _: number) | fun(_: ContactSensor, _: number)[])?
+---@field client (AsyncClient)?
+local ContactSensorConfig
+
+---@alias Flag
+---| "presence"
+---| "darkness"
+
+---@class FlagIDs
+---@field presence integer
+---@field darkness integer
+local FlagIDs
+
+---@class HueBridge: DeviceInterface
+local HueBridge
+devices.HueBridge = {}
+---@param config HueBridgeConfig
+---@return HueBridge
+function devices.HueBridge.new(config) end
+---@async
+---@param flag Flag
+---@param value boolean
+function HueBridge:set_flag(flag, value) end
+
+---@class HueBridgeConfig
+---@field identifier string
+---@field ip string
+---@field login string
+---@field flags FlagIDs
+local HueBridgeConfig
+
+---@class HueGroup: DeviceInterface, OnOffInterface
+local HueGroup
+devices.HueGroup = {}
+---@param config HueGroupConfig
+---@return HueGroup
+function devices.HueGroup.new(config) end
+
+---@class HueGroupConfig
+---@field identifier string
+---@field ip string
+---@field login string
+---@field group_id integer
+---@field scene_id string
+local HueGroupConfig
+
+---@class HueSwitch: DeviceInterface
+local HueSwitch
+devices.HueSwitch = {}
+---@param config HueSwitchConfig
+---@return HueSwitch
+function devices.HueSwitch.new(config) end
+
+---@class HueSwitchConfig
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field client AsyncClient
+---@field left_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field right_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field left_hold_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field right_hold_callback (fun(_: HueSwitch) | fun(_: HueSwitch)[])?
+---@field battery_callback (fun(_: HueSwitch, _: number) | fun(_: HueSwitch, _: number)[])?
+local HueSwitchConfig
+
+---@class IkeaRemote: DeviceInterface
+local IkeaRemote
+devices.IkeaRemote = {}
+---@param config IkeaRemoteConfig
+---@return IkeaRemote
+function devices.IkeaRemote.new(config) end
+
+---@class IkeaRemoteConfig
+---@field name string
+---@field room (string)?
+---@field single_button (boolean)?
+---@field topic string
+---@field client AsyncClient
+---@field callback (fun(_: IkeaRemote, _: boolean) | fun(_: IkeaRemote, _: boolean)[])?
+---@field battery_callback (fun(_: IkeaRemote, _: number) | fun(_: IkeaRemote, _: number)[])?
+local IkeaRemoteConfig
+
+---@class KasaOutlet: DeviceInterface, OnOffInterface
+local KasaOutlet
+devices.KasaOutlet = {}
+---@param config KasaOutletConfig
+---@return KasaOutlet
+function devices.KasaOutlet.new(config) end
+
+---@class KasaOutletConfig
+---@field identifier string
+---@field ip string
+local KasaOutletConfig
+
+---@class LightBrightness: DeviceInterface, OnOffInterface, BrightnessInterface
+local LightBrightness
+devices.LightBrightness = {}
+---@param config ConfigLightLightStateBrightness
+---@return LightBrightness
+function devices.LightBrightness.new(config) end
+
+---@class LightColorTemperature: DeviceInterface, OnOffInterface, BrightnessInterface, ColorSettingInterface
+local LightColorTemperature
+devices.LightColorTemperature = {}
+---@param config ConfigLightLightStateColorTemperature
+---@return LightColorTemperature
+function devices.LightColorTemperature.new(config) end
+
+---@class LightOnOff: DeviceInterface, OnOffInterface
+local LightOnOff
+devices.LightOnOff = {}
+---@param config ConfigLightLightStateOnOff
+---@return LightOnOff
+function devices.LightOnOff.new(config) end
+
+---@class LightSensor: DeviceInterface
+local LightSensor
+devices.LightSensor = {}
+---@param config LightSensorConfig
+---@return LightSensor
+function devices.LightSensor.new(config) end
+
+---@class LightSensorConfig
+---@field identifier string
+---@field topic string
+---@field min integer
+---@field max integer
+---@field callback (fun(_: LightSensor, _: boolean) | fun(_: LightSensor, _: boolean)[])?
+---@field client AsyncClient
+local LightSensorConfig
+
+---@class LightStateBrightness
+---@field state boolean
+---@field brightness number
+local LightStateBrightness
+
+---@class LightStateColorTemperature
+---@field state boolean
+---@field brightness number
+---@field color_temp integer
+local LightStateColorTemperature
+
+---@class LightStateOnOff
+---@field state boolean
+local LightStateOnOff
+
+---@class Notification
+---@field title string
+---@field message (string)?
+---@field tags ((string)[])?
+---@field priority (Priority)?
+---@field actions ((Action)[])?
+local Notification
+
+---@class Ntfy: DeviceInterface
+local Ntfy
+devices.Ntfy = {}
+---@param config NtfyConfig
+---@return Ntfy
+function devices.Ntfy.new(config) end
+---@async
+---@param notification Notification
+function Ntfy:send_notification(notification) end
+
+---@class NtfyConfig
+---@field url (string)?
+---@field topic string
+local NtfyConfig
+
+---@class OutletOnOff: DeviceInterface, OnOffInterface
+local OutletOnOff
+devices.OutletOnOff = {}
+---@param config ConfigOutletOutletStateOnOff
+---@return OutletOnOff
+function devices.OutletOnOff.new(config) end
+
+---@class OutletPower: DeviceInterface, OnOffInterface
+local OutletPower
+devices.OutletPower = {}
+---@param config ConfigOutletOutletStatePower
+---@return OutletPower
+function devices.OutletPower.new(config) end
+
+---@class OutletStateOnOff
+---@field state boolean
+local OutletStateOnOff
+
+---@class OutletStatePower
+---@field state boolean
+---@field power number
+local OutletStatePower
+
+---@alias OutletType
+---| "Outlet"
+---| "Kettle"
+
+---@class Presence: DeviceInterface
+local Presence
+devices.Presence = {}
+---@param config PresenceConfig
+---@return Presence
+function devices.Presence.new(config) end
+---@async
+---@return boolean
+function Presence:overall_presence() end
+
+---@class PresenceConfig
+---@field topic string
+---@field callback (fun(_: Presence, _: boolean) | fun(_: Presence, _: boolean)[])?
+---@field client AsyncClient
+local PresenceConfig
+
+---@alias Priority
+---| "min"
+---| "low"
+---| "default"
+---| "high"
+---| "max"
+
+---@alias SensorType
+---| "Door"
+---| "Drawer"
+---| "Window"
+
+---@class WakeOnLAN: DeviceInterface
+local WakeOnLAN
+devices.WakeOnLAN = {}
+---@param config WolConfig
+---@return WakeOnLAN
+function devices.WakeOnLAN.new(config) end
+
+---@class Washer: DeviceInterface
+local Washer
+devices.Washer = {}
+---@param config WasherConfig
+---@return Washer
+function devices.Washer.new(config) end
+
+---@class WasherConfig
+---@field identifier string
+---@field topic string
+---@field threshold number
+---@field done_callback (fun(_: Washer) | fun(_: Washer)[])?
+---@field client AsyncClient
+local WasherConfig
+
+---@class WolConfig
+---@field name string
+---@field room (string)?
+---@field topic string
+---@field mac_address string
+---@field broadcast_ip (string)?
+---@field client AsyncClient
+local WolConfig
+
+return devices

definitions/automation:secrets.lua

@@ -0,0 +1,6 @@
+---@meta
+
+---@type table<string, string?>
+local secrets
+
+return secrets

definitions/automation:utils.lua

@@ -0,0 +1,27 @@
+-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED
+---@meta
+
+local utils
+
+---@class Timeout
+local Timeout
+---@async
+---@param timeout number
+---@param callback fun() | fun()[]
+function Timeout:start(timeout, callback) end
+---@async
+function Timeout:cancel() end
+---@async
+---@return boolean
+function Timeout:is_waiting() end
+utils.Timeout = {}
+---@return Timeout
+function utils.Timeout.new() end
+
+---@return string
+function utils.get_hostname() end
+
+---@return integer
+function utils.get_epoch() end
+
+return utils

definitions/automation:variables.lua

@@ -0,0 +1,6 @@
+---@meta
+
+---@type table<string, string?>
+local variables
+
+return variables

definitions/config.lua

@@ -0,0 +1,41 @@
+-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED
+---@meta
+
+---@class FulfillmentConfig
+---@field openid_url string
+---@field ip (string)?
+---@field port (integer)?
+local FulfillmentConfig
+
+---@class Config
+---@field fulfillment FulfillmentConfig
+---@field modules (Module)[]
+---@field mqtt MqttConfig
+local Config
+
+---@alias SetupFunction fun(mqtt_client: AsyncClient): Module | DeviceInterface[] | nil
+
+---@alias Schedule table<string, fun() | fun()[]>
+
+---@class Module
+---@field setup (SetupFunction)?
+---@field devices (DeviceInterface)[]?
+---@field schedule Schedule?
+---@field [number] (Module)[]?
+local Module
+
+---@class MqttConfig
+---@field host string
+---@field port integer
+---@field client_name string
+---@field username string
+---@field password string
+---@field tls (boolean)?
+local MqttConfig
+
+---@class AsyncClient
+local AsyncClient
+---@async
+---@param topic string
+---@param message table?
+function AsyncClient:send_message(topic, message) end

definitions/interfaces.lua

@@ -0,0 +1,42 @@
+--- @meta
+
+---@class DeviceInterface
+local DeviceInterface
+---@return string
+function DeviceInterface:get_id() end
+
+---@class OnOffInterface: DeviceInterface
+local OnOffInterface
+---@async
+---@param on boolean
+function OnOffInterface:set_on(on) end
+---@async
+---@return boolean
+function OnOffInterface:on() end
+
+---@class BrightnessInterface: DeviceInterface
+local BrightnessInterface
+---@async
+---@param brightness integer
+function BrightnessInterface:set_brightness(brightness) end
+---@async
+---@return integer
+function BrightnessInterface:brightness() end
+
+---@class ColorSettingInterface: DeviceInterface
+local ColorSettingInterface
+---@async
+---@param temperature integer
+function ColorSettingInterface:set_color_temperature(temperature) end
+---@async
+---@return integer
+function ColorSettingInterface:color_temperature() end
+
+---@class OpenCloseInterface: DeviceInterface
+local OpenCloseInterface
+---@async
+---@param open_percent integer
+function OpenCloseInterface:set_open_percent(open_percent) end
+---@async
+---@return integer
+function OpenCloseInterface:open_percent() end

docker-bake.hcl

@@ -0,0 +1,18 @@
+variable "TAG_BASE" {}
+variable "RELEASE_VERSION" {}
+
+group "default" {
+	targets = ["automation"]
+}
+
+target "docker-metadata-action" {}
+
+target "automation" {
+	inherits = ["docker-metadata-action"]
+	context = "./"
+	dockerfile = "Dockerfile"
+	tags = [for tag in target.docker-metadata-action.tags : "${TAG_BASE}:${tag}"]
+	args = {
+		RELEASE_VERSION="${RELEASE_VERSION}"
+	}
+}

google_home/google_home/Cargo.toml

@@ -1,18 +1,15 @@
 [package]
 name = "google_home"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-automation_cast = { path = "../../automation_cast/" }
+async-trait = { workspace = true }
-google_home_macro = { path = "../google_home_macro/" }
+automation_cast = { workspace = true }
-serde = { version = "1.0.149", features = ["derive"] }
+futures = { workspace = true }
-serde_json = "1.0.89"
+google_home_macro = { workspace = true }
-thiserror = "1.0.37"
+json_value_merge = { workspace = true }
-tokio = { version = "1", features = ["sync", "full"] }
+serde = { workspace = true }
-async-trait = "0.1.61"
+serde_json = { workspace = true }
-futures = "0.3.25"
+thiserror = { workspace = true }
-anyhow = "1.0.75"
+tokio = { workspace = true }
-json_value_merge = "2.0.0"

google_home/google_home/src/device.rs

@@ -11,7 +11,7 @@ pub trait Device: DeviceFulfillment {
     fn get_device_type(&self) -> Type;
     fn get_device_name(&self) -> Name;
     fn get_id(&self) -> String;
-    fn is_online(&self) -> bool;
+    async fn is_online(&self) -> bool;
 
     // Default values that can optionally be overridden
     fn will_report_state(&self) -> bool {
@@ -37,29 +37,39 @@ pub trait Device: DeviceFulfillment {
         }
         device.device_info = self.get_device_info();
 
-        let (traits, attributes) = DeviceFulfillment::sync(self).await.unwrap();
+        // TODO: Return the appropriate error
-
+        if let Ok((traits, attributes)) = DeviceFulfillment::sync(self).await {
-        device.traits = traits;
+            device.traits = traits;
-        device.attributes = attributes;
+            device.attributes = attributes;
+        }
 
         device
     }
 
     async fn query(&self) -> response::query::Device {
         let mut device = response::query::Device::new();
-        if !self.is_online() {
+        if !self.is_online().await {
             device.set_offline();
         }
 
-        device.state = DeviceFulfillment::query(self).await.unwrap();
+        // TODO: Return the appropriate error
+        if let Ok(state) = DeviceFulfillment::query(self).await {
+            device.state = state;
+        }
 
         device
     }
 
     async fn execute(&self, command: Command) -> Result<(), ErrorCode> {
-        DeviceFulfillment::execute(self, command.clone())
+        // TODO: Do something with the return value, or just get rut of the return value?
+        if DeviceFulfillment::execute(self, command.clone())
             .await
-            .unwrap();
+            .is_err()
+        {
+            return Err(ErrorCode::DeviceError(
+                crate::errors::DeviceError::TransientError,
+            ));
+        }
 
         Ok(())
     }

google_home/google_home/src/fulfillment.rs

@@ -2,14 +2,14 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use automation_cast::Cast;
-use futures::future::{join_all, OptionFuture};
+use futures::future::{OptionFuture, join_all};
 use thiserror::Error;
 use tokio::sync::Mutex;
 
+use crate::Device;
 use crate::errors::{DeviceError, ErrorCode};
 use crate::request::{self, Intent, Request};
-use crate::response::{self, execute, query, sync, Response, ResponsePayload};
+use crate::response::{self, Response, ResponsePayload, execute, query, sync};
-use crate::Device;
 
 #[derive(Debug)]
 pub struct GoogleHome {
@@ -40,15 +40,13 @@ impl GoogleHome {
         let intent = request.inputs.into_iter().next();
 
         let payload: OptionFuture<_> = intent
-            .map(|intent| async move {
+            .map(async |intent| match intent {
-                match intent {
+                Intent::Sync => ResponsePayload::Sync(self.sync(devices).await),
-                    Intent::Sync => ResponsePayload::Sync(self.sync(devices).await),
+                Intent::Query(payload) => {
-                    Intent::Query(payload) => {
+                    ResponsePayload::Query(self.query(payload, devices).await)
-                        ResponsePayload::Query(self.query(payload, devices).await)
+                }
-                    }
+                Intent::Execute(payload) => {
-                    Intent::Execute(payload) => {
+                    ResponsePayload::Execute(self.execute(payload, devices).await)
-                        ResponsePayload::Execute(self.execute(payload, devices).await)
-                    }
                 }
             })
             .into();
@@ -64,7 +62,7 @@ impl GoogleHome {
         devices: &HashMap<String, Box<T>>,
     ) -> sync::Payload {
         let mut resp_payload = sync::Payload::new(&self.user_id);
-        let f = devices.iter().map(|(_, device)| async move {
+        let f = devices.values().map(async |device| {
             if let Some(device) = device.as_ref().cast() {
                 Some(Device::sync(device).await)
             } else {
@@ -86,7 +84,7 @@ impl GoogleHome {
             .devices
             .into_iter()
             .map(|device| device.id)
-            .map(|id| async move {
+            .map(async |id| {
                 // NOTE: Requires let_chains feature
                 let device = if let Some(device) = devices.get(id.as_str())
                     && let Some(device) = device.as_ref().cast()
@@ -115,84 +113,77 @@ impl GoogleHome {
     ) -> execute::Payload {
         let resp_payload = Arc::new(Mutex::new(response::execute::Payload::new()));
 
-        let f = payload.commands.into_iter().map(|command| {
+        let f = payload.commands.into_iter().map(async |command| {
-            let resp_payload = resp_payload.clone();
+            let mut success = response::execute::Command::new(execute::Status::Success);
-            async move {
+            success.states = Some(execute::States {
-                let mut success = response::execute::Command::new(execute::Status::Success);
+                online: true,
-                success.states = Some(execute::States {
+                state: Default::default(),
-                    online: true,
+            });
-                    state: Default::default(),
+            let mut offline = response::execute::Command::new(execute::Status::Offline);
-                });
+            offline.states = Some(execute::States {
-                let mut offline = response::execute::Command::new(execute::Status::Offline);
+                online: false,
-                offline.states = Some(execute::States {
+                state: Default::default(),
-                    online: false,
+            });
-                    state: Default::default(),
+            let mut errors: HashMap<ErrorCode, response::execute::Command> = HashMap::new();
-                });
-                let mut errors: HashMap<ErrorCode, response::execute::Command> = HashMap::new();
 
-                let f = command
+            let f = command
-                    .devices
+                .devices
-                    .into_iter()
+                .into_iter()
-                    .map(|device| device.id)
+                .map(|device| device.id)
-                    .map(|id| {
+                .map(async |id| {
-                        let execution = command.execution.clone();
+                    if let Some(device) = devices.get(id.as_str())
-                        async move {
+                        && let Some(device) = device.as_ref().cast()
-                            if let Some(device) = devices.get(id.as_str())
+                    {
-                                && let Some(device) = device.as_ref().cast()
+                        if !device.is_online().await {
-                            {
+                            return (id, Ok(false));
-                                if !device.is_online() {
-                                    return (id, Ok(false));
-                                }
-
-                                // NOTE: We can not use .map here because async =(
-                                let mut results = Vec::new();
-                                for cmd in &execution {
-                                    results.push(Device::execute(device, cmd.clone()).await);
-                                }
-
-                                // Convert vec of results to a result with a vec and the first
-                                // encountered error
-                                let results =
-                                    results.into_iter().collect::<Result<Vec<_>, ErrorCode>>();
-
-                                // TODO: We only get one error not all errors
-                                if let Err(err) = results {
-                                    (id, Err(err))
-                                } else {
-                                    (id, Ok(true))
-                                }
-                            } else {
-                                (id.clone(), Err(DeviceError::DeviceNotFound.into()))
-                            }
                         }
-                    });
 
-                let a = join_all(f).await;
+                        // NOTE: We can not use .map here because async =(
-                a.into_iter().for_each(|(id, state)| {
+                        let mut results = Vec::new();
-                    match state {
+                        for cmd in &command.execution {
-                        Ok(true) => success.add_id(&id),
+                            results.push(Device::execute(device, cmd.clone()).await);
-                        Ok(false) => offline.add_id(&id),
+                        }
-                        Err(err) => errors
+
-                            .entry(err)
+                        // Convert vec of results to a result with a vec and the first
-                            .or_insert_with(|| match &err {
+                        // encountered error
-                                ErrorCode::DeviceError(_) => {
+                        let results = results.into_iter().collect::<Result<Vec<_>, ErrorCode>>();
-                                    response::execute::Command::new(execute::Status::Error)
+
-                                }
+                        // TODO: We only get one error not all errors
-                                ErrorCode::DeviceException(_) => {
+                        if let Err(err) = results {
-                                    response::execute::Command::new(execute::Status::Exceptions)
+                            (id, Err(err))
-                                }
+                        } else {
-                            })
+                            (id, Ok(true))
-                            .add_id(&id),
+                        }
-                    };
+                    } else {
+                        (id.clone(), Err(DeviceError::DeviceNotFound.into()))
+                    }
                 });
 
-                let mut resp_payload = resp_payload.lock().await;
+            let a = join_all(f).await;
-                resp_payload.add_command(success);
+            a.into_iter().for_each(|(id, state)| {
-                resp_payload.add_command(offline);
+                match state {
-                for (error, mut cmd) in errors {
+                    Ok(true) => success.add_id(&id),
-                    cmd.error_code = Some(error);
+                    Ok(false) => offline.add_id(&id),
-                    resp_payload.add_command(cmd);
+                    Err(err) => errors
-                }
+                        .entry(err)
+                        .or_insert_with(|| match &err {
+                            ErrorCode::DeviceError(_) => {
+                                response::execute::Command::new(execute::Status::Error)
+                            }
+                            ErrorCode::DeviceException(_) => {
+                                response::execute::Command::new(execute::Status::Exceptions)
+                            }
+                        })
+                        .add_id(&id),
+                };
+            });
+
+            let mut resp_payload = resp_payload.lock().await;
+            resp_payload.add_command(success);
+            resp_payload.add_command(offline);
+            for (error, mut cmd) in errors {
+                cmd.error_code = Some(error);
+                resp_payload.add_command(cmd);
             }
         });
 

google_home/google_home/src/lib.rs

@@ -1,6 +1,5 @@
 #![allow(incomplete_features)]
 #![feature(specialization)]
-#![feature(let_chains)]
 pub mod device;
 mod fulfillment;
 

google_home/google_home/src/traits.rs

@@ -1,10 +1,10 @@
 #![allow(non_snake_case)]
 use automation_cast::Cast;
 use google_home_macro::traits;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-use crate::errors::ErrorCode;
 use crate::Device;
+use crate::errors::ErrorCode;
 
 traits! {
     Device,
@@ -14,6 +14,24 @@ traits! {
         async fn on(&self) -> Result<bool, ErrorCode>,
         "action.devices.commands.OnOff" => async fn set_on(&self, on: bool) -> Result<(), ErrorCode>,
     },
+    "action.devices.traits.OpenClose" => trait OpenClose {
+        discrete_only_open_close: Option<bool>,
+        command_only_open_close: Option<bool>,
+        query_only_open_close: Option<bool>,
+        async fn open_percent(&self) -> Result<u8, ErrorCode>,
+        "action.devices.commands.OpenClose" => async fn set_open_percent(&self, open_percent: u8) -> Result<(), ErrorCode>,
+    },
+    "action.devices.traits.Brightness" => trait Brightness {
+        command_only_brightness: Option<bool>,
+        async fn brightness(&self) -> Result<u8, ErrorCode>,
+        "action.devices.commands.BrightnessAbsolute" => async fn set_brightness(&self, brightness: u8) -> Result<(), ErrorCode>,
+    },
+    "action.devices.traits.ColorSetting" => trait ColorSetting {
+        color_temperature_range: ColorTemperatureRange,
+
+        async fn color(&self) -> Color,
+        "action.devices.commands.ColorAbsolute" => async fn set_color(&self, color: Color) -> Result<(), ErrorCode>,
+    },
     "action.devices.traits.Scene" => trait Scene {
         scene_reversible: Option<bool>,
 
@@ -35,15 +53,29 @@ traits! {
 
         async fn humidity_ambient_percent(&self) -> Result<isize, ErrorCode>,
     },
-    "action.devices.traits.TemperatureControl" => trait TemperatureSetting {
+    "action.devices.traits.TemperatureControl" => trait TemperatureControl {
         query_only_temperature_control: Option<bool>,
         // TODO: Add rename
         temperatureUnitForUX: TemperatureUnit,
 
-        async fn temperature_ambient_celsius(&self) -> f32,
+        async fn temperature_ambient_celsius(&self) -> Result<f32, ErrorCode>,
     }
 }
 
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ColorTemperatureRange {
+    pub temperature_min_k: u32,
+    pub temperature_max_k: u32,
+}
+
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Color {
+    #[serde(rename(serialize = "temperatureK"))]
+    pub temperature: u32,
+}
+
 #[derive(Debug, Serialize)]
 pub struct SpeedValue {
     pub speed_synonym: Vec<String>,

google_home/google_home/src/types.rs

@@ -12,4 +12,10 @@ pub enum Type {
     Scene,
     #[serde(rename = "action.devices.types.AIRPURIFIER")]
     AirPurifier,
+    #[serde(rename = "action.devices.types.DOOR")]
+    Door,
+    #[serde(rename = "action.devices.types.WINDOW")]
+    Window,
+    #[serde(rename = "action.devices.types.DRAWER")]
+    Drawer,
 }

google_home/google_home_macro/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "google_home_macro"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [lib]
 proc-macro = true
 
 [dependencies]
-proc-macro2 = "1.0.81"
+proc-macro2 = { workspace = true }
-quote = "1.0.36"
+quote = { workspace = true }
-syn = { version = "2.0.60", features = ["extra-traits", "full"] }
+syn = { workspace = true }

google_home/google_home_macro/src/lib.rs

@@ -1,4 +1,3 @@
-#![feature(let_chains)]
 #![feature(iter_intersperse)]
 use proc_macro::TokenStream;
 use quote::quote;
@@ -6,8 +5,8 @@ use syn::parse::Parse;
 use syn::punctuated::Punctuated;
 use syn::token::Brace;
 use syn::{
-    braced, parse_macro_input, GenericArgument, Ident, LitStr, Path, PathArguments, PathSegment,
+    GenericArgument, Ident, LitStr, Path, PathArguments, PathSegment, ReturnType, Signature, Token,
-    ReturnType, Signature, Token, Type, TypePath,
+    Type, TypePath, braced, parse_macro_input,
 };
 
 mod kw {

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2024-07-25"
+channel = "nightly-2025-08-20"
 components = ["rustfmt", "clippy", "rust-analyzer"]
 profile = "minimal"

src/auth.rs

@@ -1,62 +0,0 @@
-use axum::async_trait;
-use axum::extract::{FromRef, FromRequestParts};
-use axum::http::request::Parts;
-use axum::http::StatusCode;
-use serde::Deserialize;
-
-use crate::error::{ApiError, ApiErrorJson};
-
-#[derive(Debug, Deserialize)]
-pub struct User {
-    pub preferred_username: String,
-}
-
-#[async_trait]
-impl<S> FromRequestParts<S> for User
-where
-    String: FromRef<S>,
-    S: Send + Sync,
-{
-    type Rejection = ApiError;
-
-    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
-        // Get the state
-        let openid_url = String::from_ref(state);
-
-        // Create a request to the auth server
-        // TODO: Do some discovery to find the correct url for this instead of assuming
-        let mut req = reqwest::Client::new().get(format!("{}/userinfo", openid_url));
-
-        // Add auth header to the request if it exists
-        if let Some(auth) = parts.headers.get(axum::http::header::AUTHORIZATION) {
-            req = req.header(reqwest::header::AUTHORIZATION, auth);
-        }
-
-        // Send the request
-        let res = req
-            .send()
-            .await
-            .map_err(|err| ApiError::new(StatusCode::INTERNAL_SERVER_ERROR, err.into()))?;
-
-        // If the request is success full the auth token is valid and we are given userinfo
-        let status = res.status();
-        if status.is_success() {
-            let user = res
-                .json()
-                .await
-                .map_err(|err| ApiError::new(StatusCode::INTERNAL_SERVER_ERROR, err.into()))?;
-
-            return Ok(user);
-        } else {
-            let err: ApiErrorJson = res
-                .json()
-                .await
-                .map_err(|err| ApiError::new(StatusCode::INTERNAL_SERVER_ERROR, err.into()))?;
-
-            let err = ApiError::try_from(err)
-                .map_err(|err| ApiError::new(StatusCode::INTERNAL_SERVER_ERROR, err.into()))?;
-
-            Err(err)
-        }
-    }
-}

src/bin/automation.rs

@@ -0,0 +1,167 @@
+#![feature(iter_intersperse)]
+
+use std::net::SocketAddr;
+use std::path::Path;
+use std::process;
+
+use ::config::{Environment, File};
+use automation::config::{Config, Setup};
+use automation::secret::EnvironmentSecretFile;
+use automation::version::VERSION;
+use automation::web::{ApiError, User};
+use automation_lib::device_manager::DeviceManager;
+use automation_lib::mqtt;
+use axum::extract::{FromRef, State};
+use axum::http::StatusCode;
+use axum::routing::post;
+use axum::{Json, Router};
+use google_home::{GoogleHome, Request, Response};
+use mlua::LuaSerdeExt;
+use tokio::net::TcpListener;
+use tracing::{debug, error, info, warn};
+
+// Force automation_devices to link so that it gets registered as a module
+extern crate automation_devices;
+
+#[derive(Clone)]
+struct AppState {
+    pub openid_url: String,
+    pub device_manager: DeviceManager,
+}
+
+impl FromRef<AppState> for String {
+    fn from_ref(input: &AppState) -> Self {
+        input.openid_url.clone()
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    if let Err(err) = app().await {
+        error!("Error: {err}");
+        let mut cause = err.source();
+        while let Some(c) = cause {
+            error!("Cause: {c}");
+            cause = c.source();
+        }
+        process::exit(1);
+    }
+}
+
+async fn fulfillment(
+    State(state): State<AppState>,
+    user: User,
+    Json(payload): Json<Request>,
+) -> Result<Json<Response>, ApiError> {
+    debug!(username = user.preferred_username, "{payload:#?}");
+    let gc = GoogleHome::new(&user.preferred_username);
+    let devices = state.device_manager.devices().await;
+    let result = gc
+        .handle_request(payload, &devices)
+        .await
+        .map_err(|err| ApiError::new(StatusCode::INTERNAL_SERVER_ERROR, err.into()))?;
+
+    debug!(username = user.preferred_username, "{result:#?}");
+
+    Ok(Json(result))
+}
+
+async fn app() -> anyhow::Result<()> {
+    tracing_subscriber::fmt::init();
+
+    info!(version = VERSION, "automation_rs");
+
+    let setup: Setup = ::config::Config::builder()
+        .add_source(
+            File::with_name(&format!("{}.toml", std::env!("CARGO_PKG_NAME"))).required(false),
+        )
+        .add_source(
+            Environment::default()
+                .prefix(std::env!("CARGO_PKG_NAME"))
+                .separator("__"),
+        )
+        .add_source(EnvironmentSecretFile::default())
+        .build()
+        .unwrap()
+        .try_deserialize()
+        .unwrap();
+
+    // Setup the device handler
+    let device_manager = DeviceManager::new().await;
+
+    let lua = mlua::Lua::new();
+
+    lua.set_warning_function(|_lua, text, _cont| {
+        warn!("{text}");
+        Ok(())
+    });
+    let print = lua.create_function(|lua, values: mlua::Variadic<mlua::Value>| {
+        // Fortmat the values the same way lua does by default
+        let text: String = values
+            .iter()
+            .map(|value| {
+                value.to_string().unwrap_or_else(|_| {
+                    format!("{}: {}", value.type_name(), value.to_pointer().addr())
+                })
+            })
+            .intersperse("\t".to_owned())
+            .collect();
+
+        // Level 1 of the stack gives us the location that called this function
+        let (file, line) = lua
+            .inspect_stack(1, |debug| {
+                (
+                    debug
+                        .source()
+                        .short_src
+                        .unwrap_or("???".into())
+                        .into_owned(),
+                    debug.current_line().unwrap_or(0),
+                )
+            })
+            .unwrap();
+
+        // The target is overridden to make it possible to filter for logs originating from the
+        // config
+        info!(target: "automation_config", %file, line, "{text}");
+
+        Ok(())
+    })?;
+    lua.globals().set("print", print)?;
+
+    automation_lib::load_modules(&lua)?;
+
+    lua.register_module("automation:variables", lua.to_value(&setup.variables)?)?;
+    lua.register_module("automation:secrets", lua.to_value(&setup.secrets)?)?;
+
+    let entrypoint = Path::new(&setup.entrypoint);
+    let config: Config = lua.load(entrypoint).eval_async().await?;
+
+    let mqtt_client = mqtt::start(config.mqtt, &device_manager.event_channel());
+
+    let resolved = config.modules.resolve(&lua, &mqtt_client).await?;
+    for device in resolved.devices {
+        device_manager.add(device).await;
+    }
+
+    resolved.scheduler.start().await?;
+
+    // Create google home fulfillment route
+    let fulfillment = Router::new().route("/google_home", post(fulfillment));
+
+    // Combine together all the routes
+    let app = Router::new()
+        .nest("/fulfillment", fulfillment)
+        .with_state(AppState {
+            openid_url: config.fulfillment.openid_url.clone(),
+            device_manager,
+        });
+
+    // Start the web server
+    let addr: SocketAddr = config.fulfillment.into();
+    info!("Server started on http://{addr}");
+    let listener = TcpListener::bind(addr).await?;
+    axum::serve(listener, app).await?;
+
+    Ok(())
+}

src/bin/generate_definitions.rs

@@ -0,0 +1,45 @@
+use std::fs::{self, File};
+use std::io::Write;
+
+use automation::config::generate_definitions;
+use automation_lib::Module;
+use tracing::{info, warn};
+
+extern crate automation_devices;
+
+fn write_definitions(filename: &str, definitions: &str) -> std::io::Result<()> {
+    let definitions_directory =
+        std::path::Path::new(std::env!("CARGO_MANIFEST_DIR")).join("definitions");
+    fs::create_dir_all(&definitions_directory)?;
+
+    let mut file = File::create(definitions_directory.join(filename))?;
+
+    file.write_all(b"-- DO NOT MODIFY, FILE IS AUTOMATICALLY GENERATED\n")?;
+    file.write_all(definitions.as_bytes())?;
+
+    // Make sure we have a trailing new line
+    if !definitions.ends_with("\n") {
+        file.write_all(b"\n")?;
+    }
+
+    Ok(())
+}
+
+fn main() -> std::io::Result<()> {
+    tracing_subscriber::fmt::init();
+
+    for module in inventory::iter::<Module> {
+        if let Some(definitions) = module.definitions() {
+            info!(name = module.get_name(), "Generating definitions");
+
+            let filename = format!("{}.lua", module.get_name());
+            write_definitions(&filename, &definitions)?;
+        } else {
+            warn!(name = module.get_name(), "No definitions");
+        }
+    }
+
+    write_definitions("config.lua", &generate_definitions())?;
+
+    Ok(())
+}

src/config.rs

@@ -1,49 +1,262 @@
+use std::collections::{HashMap, VecDeque};
 use std::net::{Ipv4Addr, SocketAddr};
-use std::time::Duration;
+use std::ops::Deref;
 
-use rumqttc::{MqttOptions, Transport};
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::device::Device;
+use automation_lib::mqtt::{MqttConfig, WrappedAsyncClient};
+use automation_macro::LuaDeviceConfig;
+use lua_typed::Typed;
+use mlua::FromLua;
 use serde::Deserialize;
 
-#[derive(Debug, Clone, Deserialize)]
+use crate::schedule::Scheduler;
-pub struct MqttConfig {
-    pub host: String,
-    pub port: u16,
-    pub client_name: String,
-    pub username: String,
-    pub password: String,
-    #[serde(default)]
-    pub tls: bool,
-}
-
-impl From<MqttConfig> for MqttOptions {
-    fn from(value: MqttConfig) -> Self {
-        let mut mqtt_options = MqttOptions::new(value.client_name, value.host, value.port);
-        mqtt_options.set_credentials(value.username, value.password);
-        mqtt_options.set_keep_alive(Duration::from_secs(5));
-
-        if value.tls {
-            mqtt_options.set_transport(Transport::tls_with_default_config());
-        }
-
-        mqtt_options
-    }
-}
 
 #[derive(Debug, Deserialize)]
+pub struct Setup {
+    #[serde(default = "default_entrypoint")]
+    pub entrypoint: String,
+    #[serde(default)]
+    pub variables: HashMap<String, String>,
+    #[serde(default)]
+    pub secrets: HashMap<String, String>,
+}
+
+fn default_entrypoint() -> String {
+    "./config/config.lua".into()
+}
+
+#[derive(Debug, Deserialize, Typed)]
 pub struct FulfillmentConfig {
     pub openid_url: String,
     #[serde(default = "default_fulfillment_ip")]
+    #[typed(default)]
     pub ip: Ipv4Addr,
     #[serde(default = "default_fulfillment_port")]
+    #[typed(default)]
     pub port: u16,
 }
 
+#[derive(Debug)]
+struct SetupFunction(mlua::Function);
+
+impl Typed for SetupFunction {
+    fn type_name() -> String {
+        "SetupFunction".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        Some(format!(
+            "---@alias {} fun(mqtt_client: {}): {} | DeviceInterface[] | nil\n",
+            Self::type_name(),
+            WrappedAsyncClient::type_name(),
+            Module::type_name()
+        ))
+    }
+}
+
+impl FromLua for SetupFunction {
+    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
+        Ok(Self(FromLua::from_lua(value, lua)?))
+    }
+}
+
+impl Deref for SetupFunction {
+    type Target = mlua::Function;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Debug, Default)]
+struct Schedule(HashMap<String, ActionCallback<()>>);
+
+impl Typed for Schedule {
+    fn type_name() -> String {
+        "Schedule".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        Some(format!(
+            "---@alias {} {}\n",
+            Self::type_name(),
+            HashMap::<String, ActionCallback<()>>::type_name(),
+        ))
+    }
+}
+
+impl FromLua for Schedule {
+    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
+        Ok(Self(FromLua::from_lua(value, lua)?))
+    }
+}
+
+impl IntoIterator for Schedule {
+    type Item = <HashMap<String, ActionCallback<()>> as IntoIterator>::Item;
+
+    type IntoIter = <HashMap<String, ActionCallback<()>> as IntoIterator>::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[derive(Debug, Default)]
+struct Module {
+    setup: Option<SetupFunction>,
+    devices: Vec<Box<dyn Device>>,
+    schedule: Schedule,
+    modules: Vec<Module>,
+}
+
+// TODO: Add option to typed to rename field
+impl Typed for Module {
+    fn type_name() -> String {
+        "Module".into()
+    }
+
+    fn generate_header() -> Option<String> {
+        Some(format!("---@class {}\n", Self::type_name()))
+    }
+
+    fn generate_members() -> Option<String> {
+        Some(format!(
+            r#"---@field setup {}
+---@field devices {}?
+---@field schedule {}?
+---@field [number] {}?
+"#,
+            Option::<SetupFunction>::type_name(),
+            Vec::<Box<dyn Device>>::type_name(),
+            Schedule::type_name(),
+            Vec::<Module>::type_name(),
+        ))
+    }
+
+    fn generate_footer() -> Option<String> {
+        let type_name = <Self as Typed>::type_name();
+        Some(format!("local {type_name}\n"))
+    }
+}
+
+impl FromLua for Module {
+    fn from_lua(value: mlua::Value, _lua: &mlua::Lua) -> mlua::Result<Self> {
+        // When calling require it might return a result from the searcher indicating how the
+        // module was found, we want to ignore these entries.
+        // TODO: Find a better solution for this
+        if value.is_string() {
+            return Ok(Default::default());
+        }
+
+        let mlua::Value::Table(table) = value else {
+            return Err(mlua::Error::runtime(format!(
+                "Expected module table, instead found: {}",
+                value.type_name()
+            )));
+        };
+
+        let setup = table.get("setup")?;
+        let devices = table.get("devices").unwrap_or_default();
+        let schedule = table.get("schedule").unwrap_or_default();
+
+        let mut modules = Vec::new();
+
+        for module in table.sequence_values::<Module>() {
+            modules.push(module?);
+        }
+
+        Ok(Module {
+            setup,
+            devices,
+            schedule,
+            modules,
+        })
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Modules(Vec<Module>);
+
+impl Typed for Modules {
+    fn type_name() -> String {
+        Vec::<Module>::type_name()
+    }
+}
+
+impl FromLua for Modules {
+    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
+        Ok(Self(FromLua::from_lua(value, lua)?))
+    }
+}
+
+impl Modules {
+    pub async fn resolve(
+        self,
+        lua: &mlua::Lua,
+        client: &WrappedAsyncClient,
+    ) -> mlua::Result<Resolved> {
+        let mut devices = Vec::new();
+        let mut scheduler = Scheduler::default();
+
+        let mut modules: VecDeque<_> = self.0.into();
+        loop {
+            let Some(module) = modules.pop_front() else {
+                break;
+            };
+
+            modules.extend(module.modules);
+
+            if let Some(setup) = module.setup {
+                let result: mlua::Value = setup.call_async(client.clone()).await?;
+
+                if result.is_nil() {
+                    // We ignore nil results
+                } else if let Ok(d) = <Vec<_> as FromLua>::from_lua(result.clone(), lua)
+                    && !d.is_empty()
+                {
+                    // This is a shortcut for the common pattern of setup functions that only
+                    // return devices
+                    devices.extend(d);
+                } else if let Ok(module) = FromLua::from_lua(result.clone(), lua) {
+                    modules.push_back(module);
+                } else {
+                    return Err(mlua::Error::runtime(
+                        "Setup function returned data in an unexpected format",
+                    ));
+                }
+            }
+
+            devices.extend(module.devices);
+            for (cron, f) in module.schedule {
+                scheduler.add_job(cron, f);
+            }
+        }
+
+        Ok(Resolved { devices, scheduler })
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Resolved {
+    pub devices: Vec<Box<dyn Device>>,
+    pub scheduler: Scheduler,
+}
+
+#[derive(Debug, LuaDeviceConfig, Typed)]
+pub struct Config {
+    pub fulfillment: FulfillmentConfig,
+    #[device_config(from_lua, default)]
+    pub modules: Modules,
+    #[device_config(from_lua)]
+    pub mqtt: MqttConfig,
+}
+
 impl From<FulfillmentConfig> for SocketAddr {
     fn from(fulfillment: FulfillmentConfig) -> Self {
         (fulfillment.ip, fulfillment.port).into()
     }
 }
-
 fn default_fulfillment_ip() -> Ipv4Addr {
     [0, 0, 0, 0].into()
 }
@@ -52,23 +265,24 @@ fn default_fulfillment_port() -> u16 {
     7878
 }
 
-#[derive(Debug, Clone, Deserialize)]
+pub fn generate_definitions() -> String {
-pub struct InfoConfig {
+    let mut output = "---@meta\n\n".to_string();
-    pub name: String,
-    pub room: Option<String>,
-}
 
-impl InfoConfig {
+    output +=
-    pub fn identifier(&self) -> String {
+        &FulfillmentConfig::generate_full().expect("FulfillmentConfig should have a definition");
-        (if let Some(room) = &self.room {
+    output += "\n";
-            room.to_ascii_lowercase().replace(' ', "_") + "_"
+    output += &Config::generate_full().expect("Config should have a definition");
-        } else {
+    output += "\n";
-            String::new()
+    output += &SetupFunction::generate_full().expect("SetupFunction should have a definition");
-        }) + &self.name.to_ascii_lowercase().replace(' ', "_")
+    output += "\n";
-    }
+    output += &Schedule::generate_full().expect("Schedule should have a definition");
-}
+    output += "\n";
+    output += &Module::generate_full().expect("Module should have a definition");
+    output += "\n";
+    output += &MqttConfig::generate_full().expect("MqttConfig should have a definition");
+    output += "\n";
+    output +=
+        &WrappedAsyncClient::generate_full().expect("WrappedAsyncClient should have a definition");
 
-#[derive(Debug, Clone, Deserialize)]
+    output
-pub struct MqttDeviceConfig {
-    pub topic: String,
 }

src/device_manager.rs

@@ -1,234 +0,0 @@
-use std::collections::HashMap;
-use std::ops::{Deref, DerefMut};
-use std::pin::Pin;
-use std::sync::Arc;
-
-use futures::future::join_all;
-use futures::Future;
-use google_home::traits::OnOff;
-use mlua::FromLua;
-use tokio::sync::{RwLock, RwLockReadGuard};
-use tokio_cron_scheduler::{Job, JobScheduler};
-use tokio_util::task::LocalPoolHandle;
-use tracing::{debug, instrument, trace};
-
-use crate::devices::Device;
-use crate::event::{Event, EventChannel, OnDarkness, OnMqtt, OnNotification, OnPresence};
-use crate::LUA;
-
-#[derive(Debug, FromLua, Clone)]
-pub struct WrappedDevice(Box<dyn Device>);
-
-impl WrappedDevice {
-    pub fn new(device: impl Device + 'static) -> Self {
-        Self(Box::new(device))
-    }
-}
-
-impl Deref for WrappedDevice {
-    type Target = Box<dyn Device>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for WrappedDevice {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl mlua::UserData for WrappedDevice {
-    fn add_methods<'lua, M: mlua::prelude::LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("get_id", |_lua, this, _: ()| async { Ok(this.get_id()) });
-
-        methods.add_async_method("set_on", |_lua, this, on: bool| async move {
-            if let Some(device) = this.cast() as Option<&dyn OnOff> {
-                device.set_on(on).await.unwrap()
-            };
-
-            Ok(())
-        });
-    }
-}
-
-pub type DeviceMap = HashMap<String, Box<dyn Device>>;
-
-#[derive(Clone)]
-pub struct DeviceManager {
-    devices: Arc<RwLock<DeviceMap>>,
-    event_channel: EventChannel,
-    scheduler: JobScheduler,
-}
-
-impl DeviceManager {
-    pub async fn new() -> Self {
-        let (event_channel, mut event_rx) = EventChannel::new();
-
-        let device_manager = Self {
-            devices: Arc::new(RwLock::new(HashMap::new())),
-            event_channel,
-            scheduler: JobScheduler::new().await.unwrap(),
-        };
-
-        tokio::spawn({
-            let device_manager = device_manager.clone();
-            async move {
-                loop {
-                    if let Some(event) = event_rx.recv().await {
-                        device_manager.handle_event(event).await;
-                    } else {
-                        todo!("Handle errors with the event channel properly")
-                    }
-                }
-            }
-        });
-
-        device_manager.scheduler.start().await.unwrap();
-
-        device_manager
-    }
-
-    pub async fn add(&self, device: Box<dyn Device>) {
-        let id = device.get_id();
-
-        debug!(id, "Adding device");
-
-        self.devices.write().await.insert(id, device);
-    }
-
-    pub fn event_channel(&self) -> EventChannel {
-        self.event_channel.clone()
-    }
-
-    pub async fn get(&self, name: &str) -> Option<Box<dyn Device>> {
-        self.devices.read().await.get(name).cloned()
-    }
-
-    pub async fn devices(&self) -> RwLockReadGuard<DeviceMap> {
-        self.devices.read().await
-    }
-
-    #[instrument(skip(self))]
-    async fn handle_event(&self, event: Event) {
-        match event {
-            Event::MqttMessage(message) => {
-                let devices = self.devices.read().await;
-                let iter = devices.iter().map(|(id, device)| {
-                    let message = message.clone();
-                    async move {
-                        let device: Option<&dyn OnMqtt> = device.cast();
-                        if let Some(device) = device {
-                            // let subscribed = device
-                            //     .topics()
-                            //     .iter()
-                            //     .any(|topic| matches(&message.topic, topic));
-                            //
-                            // if subscribed {
-                            trace!(id, "Handling");
-                            device.on_mqtt(message).await;
-                            trace!(id, "Done");
-                            // }
-                        }
-                    }
-                });
-
-                join_all(iter).await;
-            }
-            Event::Darkness(dark) => {
-                let devices = self.devices.read().await;
-                let iter = devices.iter().map(|(id, device)| async move {
-                    let device: Option<&dyn OnDarkness> = device.cast();
-                    if let Some(device) = device {
-                        trace!(id, "Handling");
-                        device.on_darkness(dark).await;
-                        trace!(id, "Done");
-                    }
-                });
-
-                join_all(iter).await;
-            }
-            Event::Presence(presence) => {
-                let devices = self.devices.read().await;
-                let iter = devices.iter().map(|(id, device)| async move {
-                    let device: Option<&dyn OnPresence> = device.cast();
-                    if let Some(device) = device {
-                        trace!(id, "Handling");
-                        device.on_presence(presence).await;
-                        trace!(id, "Done");
-                    }
-                });
-
-                join_all(iter).await;
-            }
-            Event::Ntfy(notification) => {
-                let devices = self.devices.read().await;
-                let iter = devices.iter().map(|(id, device)| {
-                    let notification = notification.clone();
-                    async move {
-                        let device: Option<&dyn OnNotification> = device.cast();
-                        if let Some(device) = device {
-                            trace!(id, "Handling");
-                            device.on_notification(notification).await;
-                            trace!(id, "Done");
-                        }
-                    }
-                });
-
-                join_all(iter).await;
-            }
-        }
-    }
-}
-
-fn run_schedule(
-    uuid: uuid::Uuid,
-    _: tokio_cron_scheduler::JobScheduler,
-) -> Pin<Box<dyn Future<Output = ()> + Send>> {
-    Box::pin(async move {
-        // Lua is not Send, so we need to make sure that the task stays on the same thread
-        let pool = LocalPoolHandle::new(1);
-        pool.spawn_pinned(move || async move {
-            let lua = LUA.lock().await;
-            let f: mlua::Function = lua.named_registry_value(uuid.to_string().as_str()).unwrap();
-            f.call_async::<_, ()>(()).await.unwrap();
-        })
-        .await
-        .unwrap();
-    })
-}
-
-impl mlua::UserData for DeviceManager {
-    fn add_methods<'lua, M: mlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("add", |_lua, this, device: WrappedDevice| async move {
-            this.add(device.0).await;
-
-            Ok(())
-        });
-
-        methods.add_async_method(
-            "schedule",
-            |lua, this, (schedule, f): (String, mlua::Function)| async move {
-                debug!("schedule = {schedule}");
-                let job = Job::new_async(schedule.as_str(), run_schedule).unwrap();
-
-                let uuid = this.scheduler.add(job).await.unwrap();
-
-                // Store the function in the registry
-                lua.set_named_registry_value(uuid.to_string().as_str(), f)
-                    .unwrap();
-
-                Ok(())
-            },
-        );
-
-        // methods.add_async_method("add_schedule", |lua, this, schedule| async {
-        //     let schedule = lua.from_value(schedule)?;
-        //     this.add_schedule(schedule).await;
-        //     Ok(())
-        // });
-
-        methods.add_method("event_channel", |_lua, this, ()| Ok(this.event_channel()))
-    }
-}

src/devices/audio_setup.rs

@@ -1,127 +0,0 @@
-use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
-use google_home::traits::OnOff;
-use tracing::{debug, error, trace, warn};
-
-use super::{Device, LuaDeviceCreate};
-use crate::config::MqttDeviceConfig;
-use crate::device_manager::WrappedDevice;
-use crate::error::DeviceConfigError;
-use crate::event::{OnMqtt, OnPresence};
-use crate::messages::{RemoteAction, RemoteMessage};
-use crate::mqtt::WrappedAsyncClient;
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct Config {
-    pub identifier: String,
-    #[device_config(flatten)]
-    pub mqtt: MqttDeviceConfig,
-    #[device_config(from_lua)]
-    pub mixer: WrappedDevice,
-    #[device_config(from_lua)]
-    pub speakers: WrappedDevice,
-    #[device_config(from_lua)]
-    pub client: WrappedAsyncClient,
-}
-
-#[derive(Debug, Clone)]
-pub struct AudioSetup {
-    config: Config,
-}
-
-#[async_trait]
-impl LuaDeviceCreate for AudioSetup {
-    type Config = Config;
-    type Error = DeviceConfigError;
-
-    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
-        trace!(id = config.identifier, "Setting up AudioSetup");
-
-        {
-            let mixer_id = config.mixer.get_id().to_owned();
-            if (config.mixer.cast() as Option<&dyn OnOff>).is_none() {
-                return Err(DeviceConfigError::MissingTrait(mixer_id, "OnOff".into()));
-            }
-
-            let speakers_id = config.speakers.get_id().to_owned();
-            if (config.speakers.cast() as Option<&dyn OnOff>).is_none() {
-                return Err(DeviceConfigError::MissingTrait(speakers_id, "OnOff".into()));
-            }
-        }
-
-        config
-            .client
-            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
-            .await?;
-
-        Ok(AudioSetup { config })
-    }
-}
-
-impl Device for AudioSetup {
-    fn get_id(&self) -> String {
-        self.config.identifier.clone()
-    }
-}
-
-#[async_trait]
-impl OnMqtt for AudioSetup {
-    async fn on_mqtt(&self, message: rumqttc::Publish) {
-        if !rumqttc::matches(&message.topic, &self.config.mqtt.topic) {
-            return;
-        }
-
-        let action = match RemoteMessage::try_from(message) {
-            Ok(message) => message.action(),
-            Err(err) => {
-                error!(id = self.get_id(), "Failed to parse message: {err}");
-                return;
-            }
-        };
-
-        if let (Some(mixer), Some(speakers)) = (
-            self.config.mixer.cast() as Option<&dyn OnOff>,
-            self.config.speakers.cast() as Option<&dyn OnOff>,
-        ) {
-            match action {
-				RemoteAction::On => {
-					if mixer.on().await.unwrap() {
-						speakers.set_on(false).await.unwrap();
-						mixer.set_on(false).await.unwrap();
-					} else {
-						speakers.set_on(true).await.unwrap();
-						mixer.set_on(true).await.unwrap();
-					}
-				},
-				RemoteAction::BrightnessMoveUp => {
-					if !mixer.on().await.unwrap() {
-						mixer.set_on(true).await.unwrap();
-					} else if speakers.on().await.unwrap() {
-						speakers.set_on(false).await.unwrap();
-					} else {
-						speakers.set_on(true).await.unwrap();
-					}
-				},
-				RemoteAction::BrightnessStop => { /* Ignore this action */ },
-				_ => warn!("Expected ikea shortcut button which only supports 'on' and 'brightness_move_up', got: {action:?}")
-			}
-        }
-    }
-}
-
-#[async_trait]
-impl OnPresence for AudioSetup {
-    async fn on_presence(&self, presence: bool) {
-        if let (Some(mixer), Some(speakers)) = (
-            self.config.mixer.cast() as Option<&dyn OnOff>,
-            self.config.speakers.cast() as Option<&dyn OnOff>,
-        ) {
-            // Turn off the audio setup when we leave the house
-            if !presence {
-                debug!(id = self.get_id(), "Turning devices off");
-                speakers.set_on(false).await.unwrap();
-                mixer.set_on(false).await.unwrap();
-            }
-        }
-    }
-}

src/devices/contact_sensor.rs

@@ -1,249 +0,0 @@
-use std::sync::Arc;
-use std::time::Duration;
-
-use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
-use google_home::traits::OnOff;
-use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use tokio::task::JoinHandle;
-use tracing::{debug, error, trace, warn};
-
-use super::{Device, LuaDeviceCreate};
-use crate::config::MqttDeviceConfig;
-use crate::device_manager::WrappedDevice;
-use crate::devices::DEFAULT_PRESENCE;
-use crate::error::DeviceConfigError;
-use crate::event::{OnMqtt, OnPresence};
-use crate::messages::{ContactMessage, PresenceMessage};
-use crate::mqtt::WrappedAsyncClient;
-use crate::traits::Timeout;
-
-// NOTE: If we add more presence devices we might need to move this out of here
-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct PresenceDeviceConfig {
-    #[device_config(flatten)]
-    pub mqtt: MqttDeviceConfig,
-    #[device_config(with(Duration::from_secs))]
-    pub timeout: Duration,
-}
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct TriggerConfig {
-    #[device_config(from_lua)]
-    pub devices: Vec<WrappedDevice>,
-    #[device_config(default, with(|t: Option<_>| t.map(Duration::from_secs)))]
-    pub timeout: Option<Duration>,
-}
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct Config {
-    pub identifier: String,
-    #[device_config(flatten)]
-    pub mqtt: MqttDeviceConfig,
-    #[device_config(from_lua, default)]
-    pub presence: Option<PresenceDeviceConfig>,
-    #[device_config(from_lua)]
-    pub trigger: Option<TriggerConfig>,
-    #[device_config(from_lua)]
-    pub client: WrappedAsyncClient,
-}
-
-#[derive(Debug)]
-struct State {
-    overall_presence: bool,
-    is_closed: bool,
-    previous: Vec<bool>,
-    handle: Option<JoinHandle<()>>,
-}
-
-#[derive(Debug, Clone)]
-pub struct ContactSensor {
-    config: Config,
-    state: Arc<RwLock<State>>,
-}
-
-impl ContactSensor {
-    async fn state(&self) -> RwLockReadGuard<State> {
-        self.state.read().await
-    }
-
-    async fn state_mut(&self) -> RwLockWriteGuard<State> {
-        self.state.write().await
-    }
-}
-
-#[async_trait]
-impl LuaDeviceCreate for ContactSensor {
-    type Config = Config;
-    type Error = DeviceConfigError;
-
-    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
-        trace!(id = config.identifier, "Setting up ContactSensor");
-
-        let mut previous = Vec::new();
-        // Make sure the devices implement the required traits
-        if let Some(trigger) = &config.trigger {
-            for device in &trigger.devices {
-                {
-                    let id = device.get_id().to_owned();
-                    if (device.cast() as Option<&dyn OnOff>).is_none() {
-                        return Err(DeviceConfigError::MissingTrait(id, "OnOff".into()));
-                    }
-
-                    if trigger.timeout.is_none()
-                        && (device.cast() as Option<&dyn Timeout>).is_none()
-                    {
-                        return Err(DeviceConfigError::MissingTrait(id, "Timeout".into()));
-                    }
-                }
-            }
-            previous.resize(trigger.devices.len(), false);
-        }
-
-        config
-            .client
-            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
-            .await?;
-
-        let state = State {
-            overall_presence: DEFAULT_PRESENCE,
-            is_closed: true,
-            previous,
-            handle: None,
-        };
-        let state = Arc::new(RwLock::new(state));
-
-        Ok(Self { config, state })
-    }
-}
-
-impl Device for ContactSensor {
-    fn get_id(&self) -> String {
-        self.config.identifier.clone()
-    }
-}
-
-#[async_trait]
-impl OnPresence for ContactSensor {
-    async fn on_presence(&self, presence: bool) {
-        self.state_mut().await.overall_presence = presence;
-    }
-}
-
-#[async_trait]
-impl OnMqtt for ContactSensor {
-    async fn on_mqtt(&self, message: rumqttc::Publish) {
-        if !rumqttc::matches(&message.topic, &self.config.mqtt.topic) {
-            return;
-        }
-
-        let is_closed = match ContactMessage::try_from(message) {
-            Ok(state) => state.is_closed(),
-            Err(err) => {
-                error!(id = self.get_id(), "Failed to parse message: {err}");
-                return;
-            }
-        };
-
-        if is_closed == self.state().await.is_closed {
-            return;
-        }
-
-        debug!(id = self.get_id(), "Updating state to {is_closed}");
-        self.state_mut().await.is_closed = is_closed;
-
-        if let Some(trigger) = &self.config.trigger {
-            if !is_closed {
-                for (light, previous) in trigger
-                    .devices
-                    .iter()
-                    .zip(self.state_mut().await.previous.iter_mut())
-                {
-                    if let Some(light) = light.cast() as Option<&dyn OnOff> {
-                        *previous = light.on().await.unwrap();
-                        light.set_on(true).await.ok();
-                    }
-                }
-            } else {
-                for (light, previous) in trigger
-                    .devices
-                    .iter()
-                    .zip(self.state_mut().await.previous.iter())
-                {
-                    if !previous {
-                        // If the timeout is zero just turn the light off directly
-                        if trigger.timeout.is_none()
-                            && let Some(light) = light.cast() as Option<&dyn OnOff>
-                        {
-                            light.set_on(false).await.ok();
-                        } else if let Some(timeout) = trigger.timeout
-                            && let Some(light) = light.cast() as Option<&dyn Timeout>
-                        {
-                            light.start_timeout(timeout).await.unwrap();
-                        }
-                        // TODO: Put a warning/error on creation if either of this has to option to fail
-                    }
-                }
-            }
-        }
-
-        // Check if this contact sensor works as a presence device
-        // If not we are done here
-        let presence = match &self.config.presence {
-            Some(presence) => presence.clone(),
-            None => return,
-        };
-
-        if !is_closed {
-            // Activate presence and stop any timeout once we open the door
-            if let Some(handle) = self.state_mut().await.handle.take() {
-                handle.abort();
-            }
-
-            // Only use the door as an presence sensor if there the current presence is set false
-            // This is to prevent the house from being marked as present for however long the
-            // timeout is set when leaving the house
-            if !self.state().await.overall_presence {
-                self.config
-                    .client
-                    .publish(
-                        &presence.mqtt.topic,
-                        rumqttc::QoS::AtLeastOnce,
-                        false,
-                        serde_json::to_string(&PresenceMessage::new(true)).unwrap(),
-                    )
-                    .await
-                    .map_err(|err| {
-                        warn!(
-                            "Failed to publish presence on {}: {err}",
-                            presence.mqtt.topic
-                        )
-                    })
-                    .ok();
-            }
-        } else {
-            // Once the door is closed again we start a timeout for removing the presence
-            let device = self.clone();
-            self.state_mut().await.handle = Some(tokio::spawn(async move {
-                debug!(
-                    id = device.get_id(),
-                    "Starting timeout ({:?}) for contact sensor...", presence.timeout
-                );
-                tokio::time::sleep(presence.timeout).await;
-                debug!(id = device.get_id(), "Removing door device!");
-                device
-                    .config
-                    .client
-                    .publish(&presence.mqtt.topic, rumqttc::QoS::AtLeastOnce, false, "")
-                    .await
-                    .map_err(|err| {
-                        warn!(
-                            "Failed to publish presence on {}: {err}",
-                            presence.mqtt.topic
-                        )
-                    })
-                    .ok();
-            }));
-        }
-    }
-}

src/devices/debug_bridge.rs

@@ -1,91 +0,0 @@
-use std::convert::Infallible;
-
-use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
-use tracing::{trace, warn};
-
-use super::LuaDeviceCreate;
-use crate::config::MqttDeviceConfig;
-use crate::devices::Device;
-use crate::event::{OnDarkness, OnPresence};
-use crate::messages::{DarknessMessage, PresenceMessage};
-use crate::mqtt::WrappedAsyncClient;
-
-#[derive(Debug, LuaDeviceConfig, Clone)]
-pub struct Config {
-    pub identifier: String,
-    #[device_config(flatten)]
-    pub mqtt: MqttDeviceConfig,
-    #[device_config(from_lua)]
-    pub client: WrappedAsyncClient,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugBridge {
-    config: Config,
-}
-
-#[async_trait]
-impl LuaDeviceCreate for DebugBridge {
-    type Config = Config;
-    type Error = Infallible;
-
-    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
-        trace!(id = config.identifier, "Setting up DebugBridge");
-        Ok(Self { config })
-    }
-}
-
-impl Device for DebugBridge {
-    fn get_id(&self) -> String {
-        self.config.identifier.clone()
-    }
-}
-
-#[async_trait]
-impl OnPresence for DebugBridge {
-    async fn on_presence(&self, presence: bool) {
-        let message = PresenceMessage::new(presence);
-        let topic = format!("{}/presence", self.config.mqtt.topic);
-        self.config
-            .client
-            .publish(
-                topic,
-                rumqttc::QoS::AtLeastOnce,
-                true,
-                serde_json::to_string(&message).expect("Serialization should not fail"),
-            )
-            .await
-            .map_err(|err| {
-                warn!(
-                    "Failed to update presence on {}/presence: {err}",
-                    self.config.mqtt.topic
-                )
-            })
-            .ok();
-    }
-}
-
-#[async_trait]
-impl OnDarkness for DebugBridge {
-    async fn on_darkness(&self, dark: bool) {
-        let message = DarknessMessage::new(dark);
-        let topic = format!("{}/darkness", self.config.mqtt.topic);
-        self.config
-            .client
-            .publish(
-                topic,
-                rumqttc::QoS::AtLeastOnce,
-                true,
-                serde_json::to_string(&message).unwrap(),
-            )
-            .await
-            .map_err(|err| {
-                warn!(
-                    "Failed to update presence on {}/presence: {err}",
-                    self.config.mqtt.topic
-                )
-            })
-            .ok();
-    }
-}

src/devices/hue_group.rs

@@ -1,312 +0,0 @@
-use std::net::SocketAddr;
-use std::time::Duration;
-
-use anyhow::{anyhow, Context, Result};
-use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
-use google_home::errors::ErrorCode;
-use google_home::traits::OnOff;
-use rumqttc::{Publish, SubscribeFilter};
-use tracing::{debug, error, trace, warn};
-
-use super::{Device, LuaDeviceCreate};
-use crate::config::MqttDeviceConfig;
-use crate::event::OnMqtt;
-use crate::messages::{RemoteAction, RemoteMessage};
-use crate::mqtt::WrappedAsyncClient;
-use crate::traits::Timeout;
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct Config {
-    pub identifier: String,
-    #[device_config(rename("ip"), with(|ip| SocketAddr::new(ip, 80)))]
-    pub addr: SocketAddr,
-    pub login: String,
-    pub group_id: isize,
-    pub timer_id: isize,
-    pub scene_id: String,
-    #[device_config(default)]
-    pub remotes: Vec<MqttDeviceConfig>,
-    #[device_config(from_lua)]
-    pub client: WrappedAsyncClient,
-}
-
-#[derive(Debug, Clone)]
-pub struct HueGroup {
-    config: Config,
-}
-
-// Couple of helper function to get the correct urls
-#[async_trait]
-impl LuaDeviceCreate for HueGroup {
-    type Config = Config;
-    type Error = rumqttc::ClientError;
-
-    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
-        trace!(id = config.identifier, "Setting up AudioSetup");
-
-        if !config.remotes.is_empty() {
-            config
-                .client
-                .subscribe_many(config.remotes.iter().map(|remote| SubscribeFilter {
-                    path: remote.topic.clone(),
-                    qos: rumqttc::QoS::AtLeastOnce,
-                }))
-                .await?;
-        }
-
-        Ok(Self { config })
-    }
-}
-
-impl HueGroup {
-    fn url_base(&self) -> String {
-        format!("http://{}/api/{}", self.config.addr, self.config.login)
-    }
-
-    fn url_set_schedule(&self) -> String {
-        format!("{}/schedules/{}", self.url_base(), self.config.timer_id)
-    }
-
-    fn url_set_action(&self) -> String {
-        format!("{}/groups/{}/action", self.url_base(), self.config.group_id)
-    }
-
-    fn url_get_state(&self) -> String {
-        format!("{}/groups/{}", self.url_base(), self.config.group_id)
-    }
-}
-
-impl Device for HueGroup {
-    fn get_id(&self) -> String {
-        self.config.identifier.clone()
-    }
-}
-
-#[async_trait]
-impl OnMqtt for HueGroup {
-    async fn on_mqtt(&self, message: Publish) {
-        if !self
-            .config
-            .remotes
-            .iter()
-            .any(|remote| rumqttc::matches(&message.topic, &remote.topic))
-        {
-            return;
-        }
-
-        let action = match RemoteMessage::try_from(message) {
-            Ok(message) => message.action(),
-            Err(err) => {
-                error!(id = self.get_id(), "Failed to parse message: {err}");
-                return;
-            }
-        };
-
-        debug!("Action: {action:#?}");
-
-        match action {
-            RemoteAction::On | RemoteAction::BrightnessMoveUp => self.set_on(true).await.unwrap(),
-            RemoteAction::Off | RemoteAction::BrightnessMoveDown => {
-                self.set_on(false).await.unwrap()
-            }
-            RemoteAction::BrightnessStop => { /* Ignore this action */ }
-        };
-    }
-}
-
-#[async_trait]
-impl OnOff for HueGroup {
-    async fn set_on(&self, on: bool) -> Result<(), ErrorCode> {
-        // Abort any timer that is currently running
-        self.stop_timeout().await.unwrap();
-
-        let message = if on {
-            message::Action::scene(self.config.scene_id.clone())
-        } else {
-            message::Action::on(false)
-        };
-
-        let res = reqwest::Client::new()
-            .put(self.url_set_action())
-            .json(&message)
-            .send()
-            .await;
-
-        match res {
-            Ok(res) => {
-                let status = res.status();
-                if !status.is_success() {
-                    warn!(id = self.get_id(), "Status code is not success: {status}");
-                }
-            }
-            Err(err) => error!(id = self.get_id(), "Error: {err}"),
-        }
-
-        Ok(())
-    }
-
-    async fn on(&self) -> Result<bool, ErrorCode> {
-        let res = reqwest::Client::new()
-            .get(self.url_get_state())
-            .send()
-            .await;
-
-        match res {
-            Ok(res) => {
-                let status = res.status();
-                if !status.is_success() {
-                    warn!(id = self.get_id(), "Status code is not success: {status}");
-                }
-
-                let on = match res.json::<message::Info>().await {
-                    Ok(info) => info.any_on(),
-                    Err(err) => {
-                        error!(id = self.get_id(), "Failed to parse message: {err}");
-                        // TODO: Error code
-                        return Ok(false);
-                    }
-                };
-
-                return Ok(on);
-            }
-            Err(err) => error!(id = self.get_id(), "Error: {err}"),
-        }
-
-        Ok(false)
-    }
-}
-
-#[async_trait]
-impl Timeout for HueGroup {
-    async fn start_timeout(&self, timeout: Duration) -> Result<()> {
-        // Abort any timer that is currently running
-        self.stop_timeout().await?;
-
-        // NOTE: This uses an existing timer, as we are unable to cancel it on the hub otherwise
-        let message = message::Timeout::new(Some(timeout));
-        let res = reqwest::Client::new()
-            .put(self.url_set_schedule())
-            .json(&message)
-            .send()
-            .await
-            .context("Failed to start timeout")?;
-
-        let status = res.status();
-        if !status.is_success() {
-            return Err(anyhow!(
-                "Hue bridge returned unsuccessful status '{status}'"
-            ));
-        }
-
-        Ok(())
-    }
-
-    async fn stop_timeout(&self) -> Result<()> {
-        let message = message::Timeout::new(None);
-        let res = reqwest::Client::new()
-            .put(self.url_set_schedule())
-            .json(&message)
-            .send()
-            .await
-            .context("Failed to stop timeout")?;
-
-        let status = res.status();
-        if !status.is_success() {
-            return Err(anyhow!(
-                "Hue bridge returned unsuccessful status '{status}'"
-            ));
-        }
-
-        Ok(())
-    }
-}
-
-mod message {
-    use std::time::Duration;
-
-    use serde::ser::SerializeStruct;
-    use serde::{Deserialize, Serialize};
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct Action {
-        #[serde(skip_serializing_if = "Option::is_none")]
-        on: Option<bool>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        scene: Option<String>,
-    }
-
-    impl Action {
-        pub fn on(on: bool) -> Self {
-            Self {
-                on: Some(on),
-                scene: None,
-            }
-        }
-
-        pub fn scene(scene: String) -> Self {
-            Self {
-                on: None,
-                scene: Some(scene),
-            }
-        }
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    struct State {
-        all_on: bool,
-        any_on: bool,
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct Info {
-        state: State,
-    }
-
-    impl Info {
-        pub fn any_on(&self) -> bool {
-            self.state.any_on
-        }
-
-        // pub fn all_on(&self) -> bool {
-        // 	self.state.all_on
-        // }
-    }
-
-    #[derive(Debug)]
-    pub struct Timeout {
-        timeout: Option<Duration>,
-    }
-
-    impl Timeout {
-        pub fn new(timeout: Option<Duration>) -> Self {
-            Self { timeout }
-        }
-    }
-
-    impl Serialize for Timeout {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            let len = if self.timeout.is_some() { 2 } else { 1 };
-            let mut state = serializer.serialize_struct("TimerMessage", len)?;
-            if self.timeout.is_some() {
-                state.serialize_field("status", "enabled")?;
-            } else {
-                state.serialize_field("status", "disabled")?;
-            }
-
-            if let Some(timeout) = self.timeout {
-                let seconds = timeout.as_secs() % 60;
-                let minutes = (timeout.as_secs() / 60) % 60;
-                let hours = timeout.as_secs() / 3600;
-
-                let time = format!("PT{hours:<02}:{minutes:<02}:{seconds:<02}");
-                state.serialize_field("localtime", &time)?;
-            };
-
-            state.end()
-        }
-    }
-}

src/devices/ikea_outlet.rs

@@ -1,259 +0,0 @@
-use std::sync::Arc;
-use std::time::Duration;
-
-use anyhow::Result;
-use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
-use google_home::device;
-use google_home::errors::ErrorCode;
-use google_home::traits::{self, OnOff};
-use google_home::types::Type;
-use rumqttc::{matches, Publish, SubscribeFilter};
-use serde::Deserialize;
-use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use tokio::task::JoinHandle;
-use tracing::{debug, error, trace, warn};
-
-use super::LuaDeviceCreate;
-use crate::config::{InfoConfig, MqttDeviceConfig};
-use crate::devices::Device;
-use crate::event::{OnMqtt, OnPresence};
-use crate::messages::{OnOffMessage, RemoteAction, RemoteMessage};
-use crate::mqtt::WrappedAsyncClient;
-use crate::traits::Timeout;
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Copy)]
-pub enum OutletType {
-    Outlet,
-    Kettle,
-    Charger,
-    Light,
-}
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct Config {
-    #[device_config(flatten)]
-    pub info: InfoConfig,
-    #[device_config(flatten)]
-    pub mqtt: MqttDeviceConfig,
-    #[device_config(default(OutletType::Outlet))]
-    pub outlet_type: OutletType,
-    #[device_config(default, with(|t: Option<_>| t.map(Duration::from_secs)))]
-    pub timeout: Option<Duration>,
-    #[device_config(default)]
-    pub remotes: Vec<MqttDeviceConfig>,
-
-    #[device_config(from_lua)]
-    pub client: WrappedAsyncClient,
-}
-
-#[derive(Debug)]
-pub struct State {
-    last_known_state: bool,
-    handle: Option<JoinHandle<()>>,
-}
-
-#[derive(Debug, Clone)]
-pub struct IkeaOutlet {
-    config: Config,
-
-    state: Arc<RwLock<State>>,
-}
-
-impl IkeaOutlet {
-    async fn state(&self) -> RwLockReadGuard<State> {
-        self.state.read().await
-    }
-
-    async fn state_mut(&self) -> RwLockWriteGuard<State> {
-        self.state.write().await
-    }
-}
-
-#[async_trait]
-impl LuaDeviceCreate for IkeaOutlet {
-    type Config = Config;
-    type Error = rumqttc::ClientError;
-
-    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
-        trace!(id = config.info.identifier(), "Setting up IkeaOutlet");
-
-        if !config.remotes.is_empty() {
-            config
-                .client
-                .subscribe_many(config.remotes.iter().map(|remote| SubscribeFilter {
-                    path: remote.topic.clone(),
-                    qos: rumqttc::QoS::AtLeastOnce,
-                }))
-                .await?;
-        }
-
-        config
-            .client
-            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
-            .await?;
-
-        let state = State {
-            last_known_state: false,
-            handle: None,
-        };
-        let state = Arc::new(RwLock::new(state));
-
-        Ok(Self { config, state })
-    }
-}
-
-impl Device for IkeaOutlet {
-    fn get_id(&self) -> String {
-        self.config.info.identifier()
-    }
-}
-
-#[async_trait]
-impl OnMqtt for IkeaOutlet {
-    async fn on_mqtt(&self, message: Publish) {
-        // Check if the message is from the deviec itself or from a remote
-        if matches(&message.topic, &self.config.mqtt.topic) {
-            // Update the internal state based on what the device has reported
-            let state = match OnOffMessage::try_from(message) {
-                Ok(state) => state.state(),
-                Err(err) => {
-                    error!(id = Device::get_id(self), "Failed to parse message: {err}");
-                    return;
-                }
-            };
-
-            // No need to do anything if the state has not changed
-            if state == self.state().await.last_known_state {
-                return;
-            }
-
-            // Abort any timer that is currently running
-            self.stop_timeout().await.unwrap();
-
-            debug!(id = Device::get_id(self), "Updating state to {state}");
-            self.state_mut().await.last_known_state = state;
-
-            // If this is a kettle start a timeout for turning it of again
-            if state && let Some(timeout) = self.config.timeout {
-                self.start_timeout(timeout).await.unwrap();
-            }
-        } else if self
-            .config
-            .remotes
-            .iter()
-            .any(|remote| rumqttc::matches(&message.topic, &remote.topic))
-        {
-            let action = match RemoteMessage::try_from(message) {
-                Ok(message) => message.action(),
-                Err(err) => {
-                    error!(id = Device::get_id(self), "Failed to parse message: {err}");
-                    return;
-                }
-            };
-
-            match action {
-				RemoteAction::On => self.set_on(true).await.unwrap(),
-				RemoteAction::BrightnessMoveUp => self.set_on(false).await.unwrap(),
-				RemoteAction::BrightnessStop => { /* Ignore this action */ },
-				_ => warn!("Expected ikea shortcut button which only supports 'on' and 'brightness_move_up', got: {action:?}")
-			}
-        }
-    }
-}
-
-#[async_trait]
-impl OnPresence for IkeaOutlet {
-    async fn on_presence(&self, presence: bool) {
-        // Turn off the outlet when we leave the house (Not if it is a battery charger)
-        if !presence && self.config.outlet_type != OutletType::Charger {
-            debug!(id = Device::get_id(self), "Turning device off");
-            self.set_on(false).await.ok();
-        }
-    }
-}
-
-impl google_home::Device for IkeaOutlet {
-    fn get_device_type(&self) -> Type {
-        match self.config.outlet_type {
-            OutletType::Outlet => Type::Outlet,
-            OutletType::Kettle => Type::Kettle,
-            OutletType::Light => Type::Light, // Find a better device type for this, ideally would like to use charger, but that needs more work
-            OutletType::Charger => Type::Outlet, // Find a better device type for this, ideally would like to use charger, but that needs more work
-        }
-    }
-
-    fn get_device_name(&self) -> device::Name {
-        device::Name::new(&self.config.info.name)
-    }
-
-    fn get_id(&self) -> String {
-        Device::get_id(self)
-    }
-
-    fn is_online(&self) -> bool {
-        true
-    }
-
-    fn get_room_hint(&self) -> Option<&str> {
-        self.config.info.room.as_deref()
-    }
-
-    fn will_report_state(&self) -> bool {
-        // TODO: Implement state reporting
-        false
-    }
-}
-
-#[async_trait]
-impl traits::OnOff for IkeaOutlet {
-    async fn on(&self) -> Result<bool, ErrorCode> {
-        Ok(self.state().await.last_known_state)
-    }
-
-    async fn set_on(&self, on: bool) -> Result<(), ErrorCode> {
-        let message = OnOffMessage::new(on);
-
-        let topic = format!("{}/set", self.config.mqtt.topic);
-        // TODO: Handle potential errors here
-        self.config
-            .client
-            .publish(
-                &topic,
-                rumqttc::QoS::AtLeastOnce,
-                false,
-                serde_json::to_string(&message).unwrap(),
-            )
-            .await
-            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
-            .ok();
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl crate::traits::Timeout for IkeaOutlet {
-    async fn start_timeout(&self, timeout: Duration) -> Result<()> {
-        // Abort any timer that is currently running
-        self.stop_timeout().await?;
-
-        let device = self.clone();
-        self.state_mut().await.handle = Some(tokio::spawn(async move {
-            debug!(id = device.get_id(), "Starting timeout ({timeout:?})...");
-            tokio::time::sleep(timeout).await;
-            debug!(id = device.get_id(), "Turning outlet off!");
-            device.set_on(false).await.unwrap();
-        }));
-
-        Ok(())
-    }
-
-    async fn stop_timeout(&self) -> Result<()> {
-        if let Some(handle) = self.state_mut().await.handle.take() {
-            handle.abort();
-        }
-
-        Ok(())
-    }
-}

src/devices/mod.rs

@@ -1,123 +0,0 @@
-mod air_filter;
-mod audio_setup;
-mod contact_sensor;
-mod debug_bridge;
-mod hue_bridge;
-mod hue_group;
-mod ikea_outlet;
-mod kasa_outlet;
-mod light_sensor;
-mod ntfy;
-mod presence;
-mod wake_on_lan;
-mod washer;
-
-use std::fmt::Debug;
-
-use async_trait::async_trait;
-use automation_cast::Cast;
-use dyn_clone::DynClone;
-use google_home::traits::OnOff;
-
-pub use self::air_filter::AirFilter;
-pub use self::audio_setup::AudioSetup;
-pub use self::contact_sensor::ContactSensor;
-pub use self::debug_bridge::DebugBridge;
-pub use self::hue_bridge::HueBridge;
-pub use self::hue_group::HueGroup;
-pub use self::ikea_outlet::IkeaOutlet;
-pub use self::kasa_outlet::KasaOutlet;
-pub use self::light_sensor::LightSensor;
-pub use self::ntfy::{Notification, Ntfy};
-pub use self::presence::{Presence, DEFAULT_PRESENCE};
-pub use self::wake_on_lan::WakeOnLAN;
-pub use self::washer::Washer;
-use crate::event::{OnDarkness, OnMqtt, OnNotification, OnPresence};
-use crate::traits::Timeout;
-
-#[async_trait]
-pub trait LuaDeviceCreate {
-    type Config;
-    type Error;
-
-    async fn create(config: Self::Config) -> Result<Self, Self::Error>
-    where
-        Self: Sized;
-}
-
-macro_rules! register_device {
-    ($lua:expr, $device:ty) => {
-        $lua.globals()
-            .set(stringify!($device), $lua.create_proxy::<$device>()?)?;
-    };
-}
-
-macro_rules! impl_device {
-    ($lua:expr, $device:ty) => {
-        impl mlua::UserData for $device {
-            fn add_methods<'lua, M: mlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
-                methods.add_async_function("new", |lua, config: mlua::Value| async {
-                    let config = mlua::FromLua::from_lua(config, lua)?;
-
-                    // TODO: Using crate:: could cause issues
-                    let device: $device = crate::devices::LuaDeviceCreate::create(config)
-                        .await
-                        .map_err(mlua::ExternalError::into_lua_err)?;
-
-                    Ok(crate::device_manager::WrappedDevice::new(device))
-                });
-            }
-        }
-    };
-}
-
-impl_device!(lua, AirFilter);
-impl_device!(lua, AudioSetup);
-impl_device!(lua, ContactSensor);
-impl_device!(lua, DebugBridge);
-impl_device!(lua, HueBridge);
-impl_device!(lua, HueGroup);
-impl_device!(lua, IkeaOutlet);
-impl_device!(lua, KasaOutlet);
-impl_device!(lua, LightSensor);
-impl_device!(lua, Ntfy);
-impl_device!(lua, Presence);
-impl_device!(lua, WakeOnLAN);
-impl_device!(lua, Washer);
-
-pub fn register_with_lua(lua: &mlua::Lua) -> mlua::Result<()> {
-    register_device!(lua, AirFilter);
-    register_device!(lua, AudioSetup);
-    register_device!(lua, ContactSensor);
-    register_device!(lua, DebugBridge);
-    register_device!(lua, HueBridge);
-    register_device!(lua, HueGroup);
-    register_device!(lua, IkeaOutlet);
-    register_device!(lua, KasaOutlet);
-    register_device!(lua, LightSensor);
-    register_device!(lua, Ntfy);
-    register_device!(lua, Presence);
-    register_device!(lua, WakeOnLAN);
-    register_device!(lua, Washer);
-
-    Ok(())
-}
-
-pub trait Device:
-    Debug
-    + DynClone
-    + Sync
-    + Send
-    + Cast<dyn google_home::Device>
-    + Cast<dyn OnMqtt>
-    + Cast<dyn OnMqtt>
-    + Cast<dyn OnPresence>
-    + Cast<dyn OnDarkness>
-    + Cast<dyn OnNotification>
-    + Cast<dyn OnOff>
-    + Cast<dyn Timeout>
-{
-    fn get_id(&self) -> String;
-}
-
-dyn_clone::clone_trait_object!(Device);

src/devices/ntfy.rs

@@ -1,208 +0,0 @@
-use std::collections::HashMap;
-use std::convert::Infallible;
-
-use async_trait::async_trait;
-use automation_macro::LuaDeviceConfig;
-use serde::Serialize;
-use serde_repr::*;
-use tracing::{error, trace, warn};
-
-use super::LuaDeviceCreate;
-use crate::devices::Device;
-use crate::event::{self, Event, EventChannel, OnNotification, OnPresence};
-
-#[derive(Debug, Serialize_repr, Clone, Copy)]
-#[repr(u8)]
-pub enum Priority {
-    Min = 1,
-    Low,
-    Default,
-    High,
-    Max,
-}
-
-#[derive(Debug, Serialize, Clone)]
-#[serde(rename_all = "snake_case", tag = "action")]
-pub enum ActionType {
-    Broadcast {
-        #[serde(skip_serializing_if = "HashMap::is_empty")]
-        extras: HashMap<String, String>,
-    },
-    // View,
-    // Http
-}
-
-#[derive(Debug, Serialize, Clone)]
-pub struct Action {
-    #[serde(flatten)]
-    pub action: ActionType,
-    pub label: String,
-    pub clear: Option<bool>,
-}
-
-#[derive(Serialize)]
-struct NotificationFinal {
-    topic: String,
-    #[serde(flatten)]
-    inner: Notification,
-}
-
-#[derive(Debug, Serialize, Clone)]
-pub struct Notification {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    title: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    message: Option<String>,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    tags: Vec<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    priority: Option<Priority>,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    actions: Vec<Action>,
-}
-
-impl Notification {
-    pub fn new() -> Self {
-        Self {
-            title: None,
-            message: None,
-            tags: Vec::new(),
-            priority: None,
-            actions: Vec::new(),
-        }
-    }
-
-    pub fn set_title(mut self, title: &str) -> Self {
-        self.title = Some(title.into());
-        self
-    }
-
-    pub fn set_message(mut self, message: &str) -> Self {
-        self.message = Some(message.into());
-        self
-    }
-
-    pub fn add_tag(mut self, tag: &str) -> Self {
-        self.tags.push(tag.into());
-        self
-    }
-
-    pub fn set_priority(mut self, priority: Priority) -> Self {
-        self.priority = Some(priority);
-        self
-    }
-
-    pub fn add_action(mut self, action: Action) -> Self {
-        self.actions.push(action);
-        self
-    }
-
-    fn finalize(self, topic: &str) -> NotificationFinal {
-        NotificationFinal {
-            topic: topic.into(),
-            inner: self,
-        }
-    }
-}
-
-impl Default for Notification {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[derive(Debug, Clone, LuaDeviceConfig)]
-pub struct Config {
-    #[device_config(default("https://ntfy.sh".into()))]
-    pub url: String,
-    pub topic: String,
-    #[device_config(rename("event_channel"), from_lua, with(|ec: EventChannel| ec.get_tx()))]
-    pub tx: event::Sender,
-}
-
-#[derive(Debug, Clone)]
-pub struct Ntfy {
-    config: Config,
-}
-
-#[async_trait]
-impl LuaDeviceCreate for Ntfy {
-    type Config = Config;
-    type Error = Infallible;
-
-    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
-        trace!(id = "ntfy", "Setting up Ntfy");
-        Ok(Self { config })
-    }
-}
-
-impl Device for Ntfy {
-    fn get_id(&self) -> String {
-        "ntfy".to_string()
-    }
-}
-
-impl Ntfy {
-    async fn send(&self, notification: Notification) {
-        let notification = notification.finalize(&self.config.topic);
-
-        // Create the request
-        let res = reqwest::Client::new()
-            .post(self.config.url.clone())
-            .json(&notification)
-            .send()
-            .await;
-
-        if let Err(err) = res {
-            error!("Something went wrong while sending the notification: {err}");
-        } else if let Ok(res) = res {
-            let status = res.status();
-            if !status.is_success() {
-                warn!("Received status {status} when sending notification");
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl OnPresence for Ntfy {
-    async fn on_presence(&self, presence: bool) {
-        // Setup extras for the broadcast
-        let extras = HashMap::from([
-            ("cmd".into(), "presence".into()),
-            ("state".into(), if presence { "0" } else { "1" }.into()),
-        ]);
-
-        // Create broadcast action
-        let action = Action {
-            action: ActionType::Broadcast { extras },
-            label: if presence { "Set away" } else { "Set home" }.into(),
-            clear: Some(true),
-        };
-
-        // Create the notification
-        let notification = Notification::new()
-            .set_title("Presence")
-            .set_message(if presence { "Home" } else { "Away" })
-            .add_tag("house")
-            .add_action(action)
-            .set_priority(Priority::Low);
-
-        if self
-            .config
-            .tx
-            .send(Event::Ntfy(notification))
-            .await
-            .is_err()
-        {
-            warn!("There are no receivers on the event channel");
-        }
-    }
-}
-
-#[async_trait]
-impl OnNotification for Ntfy {
-    async fn on_notification(&self, notification: Notification) {
-        self.send(notification).await;
-    }
-}