Nice Work

box/core/announce.py

@@ -18,6 +18,9 @@ class AnnounceConfig:
     server_url: str
     firmware_version: str
     capabilities: dict[str, Any]
+    api_port: int
+    setup_port: int
+    media_root: str
     announce_interval_seconds: int = 30
     polling_interval_seconds: int = 10
 
@@ -33,6 +36,9 @@ def build_payload(
         "fingerprint": fingerprint,
         "firmware_version": config.firmware_version,
         "capabilities": config.capabilities,
+        "api_port": config.api_port,
+        "setup_port": config.setup_port,
+        "media_root": config.media_root,
     }
 
 
@@ -67,8 +73,9 @@ async def announce_loop(
     announce_url = f"{config.server_url}/api/boxes/announce"
 
     while not stop_event.is_set():
-        if not pairing.is_paired():
-            await asyncio.to_thread(_post_json, announce_url, payload)
+        response = await asyncio.to_thread(_post_json, announce_url, payload)
+        if response and response.get("force_unpair") is True:
+            pairing.unpair(reset_state=True)
         await asyncio.sleep(config.announce_interval_seconds)
 
 

box/core/box_controller.py

@@ -2,11 +2,15 @@
 
 from __future__ import annotations
 
+import json
 from pathlib import Path
 from typing import Any
+import time
+import shutil
 
 from core.state import BoxState, RuntimeState
 from player.base_player import BasePlayer
+from core.media_sync import MediaSyncClient
 import hashlib
 
 
@@ -17,11 +21,17 @@ class BoxController:
         player: BasePlayer,
         config: dict[str, Any],
         config_path: str,
+        media_sync: MediaSyncClient | None = None,
     ) -> None:
         self._state = state
         self._player = player
         self._config = config
         self._config_path = Path(config_path)
+        self._media_sync = media_sync
+
+    @property
+    def config(self) -> dict[str, Any]:
+        return self._config
 
     @property
     def state(self) -> RuntimeState:
@@ -40,10 +50,24 @@ class BoxController:
             print("error: server not reachable")
             self._trigger_error("server_unreachable")
             return None
+        blocked = self._config.get("blocked_tags")
+        if isinstance(blocked, list) and uid in blocked:
+            self._state.last_nfc_uid = uid
+            self._state.last_nfc_known = True
+            self._state.last_nfc_at = int(time.time())
+            self._trigger_error("tag_blocked")
+            return None
         tag = self._resolve_tag(uid)
+        resolve_error = None
+        if tag is None:
+            tag, resolve_error = self._resolve_tag_from_server(uid)
+        self._state.last_nfc_uid = uid
+        self._state.last_nfc_known = tag is not None or resolve_error == "tag_blocked"
+        self._state.last_nfc_at = int(time.time())
+        if resolve_error == "tag_blocked":
+            self._trigger_error("tag_blocked")
+            return None
         if tag is None:
-            print(f"error: uid '{uid}' not found in config tags")
-            self._trigger_error("uid_unmapped")
             return None
         self._state.last_error = None
 
@@ -51,11 +75,22 @@ class BoxController:
         if not playlist:
             path_value = tag.get("path", "-")
             resolved = self._resolve_path(path_value)
-            print(
-                f"error: no playable files found for uid '{uid}' at path '{resolved}'"
-            )
-            self._trigger_error("no_playable_files")
-            return None
+            if self._request_media_sync(uid):
+                playlist = self._build_playlist(tag)
+                if playlist:
+                    self._state.last_error = None
+                else:
+                    print(
+                        f"error: no playable files found for uid '{uid}' at path '{resolved}'"
+                    )
+                    self._trigger_error("no_playable_files")
+                    return None
+            else:
+                print(
+                    f"error: no playable files found for uid '{uid}' at path '{resolved}'"
+                )
+                self._trigger_error("no_playable_files")
+                return None
 
         if uid in self._state._resume:
             file_index, position = self._state._resume[uid]
@@ -100,11 +135,81 @@ class BoxController:
     def handle_nfc_off(self, uid: str) -> None:
         if self._state.state == BoxState.ERROR:
             return None
+        if self._state.last_nfc_uid == uid:
+            self._state.last_nfc_uid = None
+            self._state.last_nfc_known = None
+            self._state.last_nfc_at = None
         if self._state.active_uid != uid:
             return None
         self._store_progress(uid)
         self.stop()
 
+    def set_tag(self, uid: str, media_path: str) -> None:
+        tags = self._config.get("tags")
+        if not isinstance(tags, dict):
+            tags = {}
+            self._config["tags"] = tags
+        tags[uid] = {"type": "folder", "path": media_path}
+        if uid in self._state._resume:
+            self._state._resume.pop(uid, None)
+        self._state._resume[uid] = (0, 0)
+        if self._state.last_nfc_uid == uid:
+            self._state.last_nfc_known = True
+        self._save_config()
+        if not self._build_playlist(tags[uid]):
+            self._request_media_sync(uid)
+
+    def _remove_tag_data(self, uid: str) -> None:
+        tags = self._config.get("tags")
+        if not isinstance(tags, dict):
+            return None
+        removed = None
+        if uid in tags:
+            removed = tags.pop(uid)
+        self._state._resume.pop(uid, None)
+        if self._state.active_uid == uid:
+            self.stop()
+        if self._state.last_nfc_uid == uid:
+            self._state.last_nfc_uid = None
+            self._state.last_nfc_known = None
+            self._state.last_nfc_at = None
+        if isinstance(removed, dict):
+            path_value = removed.get("path")
+            if isinstance(path_value, str):
+                media_root = (self._config_path.parent.parent / "media").resolve()
+                resolved = self._resolve_path(path_value)
+                if media_root in resolved.parents:
+                    shutil.rmtree(resolved, ignore_errors=True)
+
+    def remove_tag(self, uid: str) -> None:
+        self._remove_tag_data(uid)
+        blocked = self._config.get("blocked_tags")
+        if isinstance(blocked, list) and uid in blocked:
+            blocked = [value for value in blocked if value != uid]
+            self._config["blocked_tags"] = blocked
+        self._save_config()
+
+    def block_tag(self, uid: str) -> None:
+        blocked = self._config.get("blocked_tags")
+        if not isinstance(blocked, list):
+            blocked = []
+        if uid not in blocked:
+            blocked.append(uid)
+        self._config["blocked_tags"] = blocked
+        if self._state.active_uid == uid or self._state.last_nfc_uid == uid:
+            self._trigger_error("tag_blocked")
+        self._remove_tag_data(uid)
+        self._save_config()
+
+    def unblock_tag(self, uid: str) -> None:
+        blocked = self._config.get("blocked_tags")
+        if not isinstance(blocked, list):
+            return None
+        if uid in blocked:
+            blocked = [value for value in blocked if value != uid]
+            self._config["blocked_tags"] = blocked
+            self._save_config()
+
     def _resolve_tag(self, uid: str) -> dict[str, Any] | None:
         tags = self._config.get("tags", {})
         if not isinstance(tags, dict):
@@ -116,6 +221,56 @@ class BoxController:
             return None
         return tag
 
+    def _save_config(self) -> None:
+        data = dict(self._config)
+        self._config_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    def _request_media_sync(self, uid: str) -> bool:
+        if not self._media_sync:
+            return False
+        ok = self._media_sync.request_tag_media(uid)
+        if ok:
+            print(f"info: media sync requested for uid '{uid}'")
+        else:
+            print(f"error: media sync request failed for uid '{uid}'")
+        return ok
+
+    def _resolve_tag_from_server(self, uid: str) -> tuple[dict[str, Any] | None, str | None]:
+        if not self._media_sync:
+            return None, None
+        media_path, error = self._media_sync.resolve_tag(uid)
+        if error:
+            return None, error
+        if not media_path:
+            return None, None
+        self.set_tag(uid, f"media/{uid}")
+        return self._resolve_tag(uid), None
+
+    def export_tag_media(self, uid: str, target_folder: str) -> bool:
+        if not self._media_sync:
+            return False
+        tag = self._resolve_tag(uid)
+        if not tag:
+            return False
+        path_value = tag.get("path")
+        if not isinstance(path_value, str):
+            return False
+        root = self._resolve_path(path_value)
+        if not root.exists() or not root.is_dir():
+            return False
+
+        for file_path in root.rglob("*"):
+            if not file_path.is_file():
+                continue
+            rel_path = file_path.relative_to(root).as_posix()
+            try:
+                data = file_path.read_bytes()
+            except OSError:
+                return False
+            if not self._media_sync.upload_media_file(target_folder, rel_path, data):
+                return False
+        return True
+
     def tick(self, seconds: int) -> None:
         if self._state.state == BoxState.ERROR:
             return None
@@ -186,7 +341,10 @@ class BoxController:
     def _resolve_path(self, path_value: str) -> Path:
         path = Path(path_value)
         if not path.is_absolute():
-            return (self._config_path.parent / path).resolve()
+            media_root = self._config_path.parent.parent / "media"
+            if path_value.startswith("media/"):
+                return (media_root / path_value.replace("media/", "", 1)).resolve()
+            return (media_root / path).resolve()
         return path
 
     def _store_progress(self, uid: str) -> None:
@@ -199,8 +357,6 @@ class BoxController:
         durations = {"01.mp3": 180, "02.mp3": 200, "03.mp3": 220}
         if name in durations:
             return durations[name]
-        if not name.lower().endswith(".mp3"):
-            return 0
         digest = hashlib.md5(name.encode("utf-8")).hexdigest()
         seed = int(digest[:8], 16)
         return 120 + (seed % 241)
@@ -288,3 +444,12 @@ class BoxController:
 
     def trigger_error(self, code: str) -> None:
         self._trigger_error(code)
+
+    def factory_reset(self) -> None:
+        self.stop()
+        self._state._resume.clear()
+        self._state.last_error = None
+        self._state.last_nfc_uid = None
+        self._state.last_nfc_known = None
+        self._state.last_nfc_at = None
+        self._config.clear()

box/core/media_sync.py

@@ -0,0 +1,111 @@
+"""Client to request media sync from the server."""
+
+from __future__ import annotations
+
+import json
+import base64
+from dataclasses import dataclass
+from typing import Callable
+from urllib import request, error
+
+
+@dataclass
+class MediaSyncClient:
+    server_url: str
+    box_id: str
+    token_provider: Callable[[], str | None]
+    timeout_seconds: int = 5
+
+    def request_tag_media(self, uid: str) -> bool:
+        token = self.token_provider()
+        if not token:
+            return False
+        endpoint = f"{self.server_url.rstrip('/')}/api/boxes/{self.box_id}/media-sync"
+        payload = json.dumps({"uid": uid}).encode("utf-8")
+        req = request.Request(
+            endpoint,
+            data=payload,
+            method="POST",
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Token": token,
+            },
+        )
+        try:
+            with request.urlopen(req, timeout=self.timeout_seconds) as response:
+                return 200 <= response.status < 300
+        except error.HTTPError:
+            return False
+        except error.URLError:
+            return False
+
+    def resolve_tag(self, uid: str) -> tuple[str | None, str | None]:
+        token = self.token_provider()
+        if not token:
+            return None, None
+        endpoint = (
+            f"{self.server_url.rstrip('/')}/api/boxes/{self.box_id}/resolve-tag"
+        )
+        payload = json.dumps({"uid": uid}).encode("utf-8")
+        req = request.Request(
+            endpoint,
+            data=payload,
+            method="POST",
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Token": token,
+            },
+        )
+        try:
+            with request.urlopen(req, timeout=self.timeout_seconds) as response:
+                body = response.read().decode("utf-8")
+        except error.HTTPError as http_error:
+            try:
+                detail = json.loads(http_error.read().decode("utf-8")).get("detail")
+            except Exception:
+                detail = None
+            if detail == "tag_blocked":
+                return None, "tag_blocked"
+            return None, None
+        except error.URLError:
+            return None, None
+
+        try:
+            data = json.loads(body)
+        except json.JSONDecodeError:
+            return None, None
+        media_path = data.get("media_path")
+        if isinstance(media_path, str) and media_path:
+            return media_path, None
+        return None, None
+
+    def upload_media_file(self, target_folder: str, rel_path: str, data: bytes) -> bool:
+        token = self.token_provider()
+        if not token:
+            return False
+        endpoint = (
+            f"{self.server_url.rstrip('/')}/api/boxes/{self.box_id}/media-import"
+        )
+        payload = json.dumps(
+            {
+                "target_folder": target_folder,
+                "rel_path": rel_path,
+                "content_base64": base64.b64encode(data).decode("ascii"),
+            }
+        ).encode("utf-8")
+        req = request.Request(
+            endpoint,
+            data=payload,
+            method="POST",
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Token": token,
+            },
+        )
+        try:
+            with request.urlopen(req, timeout=self.timeout_seconds) as response:
+                return 200 <= response.status < 300
+        except error.HTTPError:
+            return False
+        except error.URLError:
+            return False

box/core/pairing.py

@@ -48,6 +48,15 @@ class PairingManager:
         self._secret_store.save_api_token(token)
         self.set_state(PairingState.PAIRED)
 
+    def unpair(self, reset_state: bool = False) -> None:
+        self._secret_store.clear_api_token()
+        self.set_state(PairingState.UNPAIRED)
+        if reset_state:
+            data = self._state_store.load()
+            data["pairing"] = {"state": PairingState.UNPAIRED.name}
+            data["resume"] = {}
+            self._state_store.save(data)
+
     def _load(self) -> None:
         data = self._state_store.load()
         pairing = data.get("pairing") if isinstance(data.get("pairing"), dict) else {}

box/core/state.py

@@ -28,6 +28,9 @@ class RuntimeState:
     file_index: Optional[int] = None
     position: Optional[int] = None
     last_error: Optional[str] = None
+    last_nfc_uid: Optional[str] = None
+    last_nfc_known: Optional[bool] = None
+    last_nfc_at: Optional[int] = None
     _resume: dict[str, tuple[int, int]] = field(default_factory=dict)
     _playlist: list[str] = field(default_factory=list)
     max_volume: int = 100