fix: improve proxy liveness and graceful shutdown

.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+
+# Environnements locaux
+.venv/
+.env
+
+# Journaux et fichiers temporaires
+*.log
+*.tmp
+*.swp
+*~
+
+# Tests et caches
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Éditeurs et système
+.vscode/
+.idea/
+.DS_Store

AGENTS.md

@@ -0,0 +1,310 @@
+# AGENTS.md
+
+## Objet du projet
+
+Ce dépôt contient l’add-on Home Assistant `arkteos-proxy-addon`.
+
+Son rôle est de maintenir une connexion TCP unique vers une PAC Arkteos et de
+mettre ce flux à disposition de plusieurs clients TCP.
+
+Gitea est le dépôt principal de développement interne via `origin` :
+
+- https://gitea.i-host.fr/raph666/arkteos-proxy-addon
+
+GitHub est le miroir public via `github` et l’URL de distribution de l’add-on :
+
+- https://github.com/raph666/arkteos-proxy-addon
+
+Les fichiers publics destinés aux utilisateurs, notamment `README.md`,
+`config.yaml` et `repository.yaml`, doivent utiliser l’URL GitHub, sauf demande
+contraire. L’URL Gitea reste réservée à la documentation interne.
+
+## Architecture
+
+Le proxy comporte deux côtés distincts :
+
+- côté PAC :
+  - connexion sortante vers `pac_host:pac_port` ;
+  - port par défaut : `9641` ;
+- côté clients :
+  - écoute sur `0.0.0.0:proxy_port` ;
+  - port par défaut : `9641`.
+
+Le proxy distribue les données reçues de la PAC vers tous les clients connectés.
+
+Le proxy peut aussi relayer les données envoyées par les clients vers la PAC
+lorsque cette fonctionnalité est explicitement activée.
+
+## Contraintes importantes
+
+### Connexion PAC unique
+
+La PAC ne doit avoir qu’une seule connexion TCP active.
+
+Ne jamais ajouter une seconde connexion concurrente vers la PAC.
+
+Tous les clients Home Assistant, outils de diagnostic ou autres consommateurs
+doivent passer par le proxy.
+
+### Compatibilité protocolaire
+
+Ne pas inventer de protocole, checksum ou validation non observée.
+
+Ne modifier ni le contenu ni l’ordre des octets transmis sans preuve issue :
+
+- d’une capture réelle ;
+- du comportement actuel ;
+- ou d’une documentation fiable.
+
+### Keepalive
+
+Le proxy envoie actuellement un octet nul toutes les 300 secondes.
+
+Le rôle exact de ce keepalive côté PAC n’est pas confirmé.
+
+Ne pas modifier :
+
+- sa valeur ;
+- sa fréquence ;
+- son activation ;
+
+sans test préalable et justification documentée.
+
+### Écritures vers la PAC
+
+Le proxy peut fonctionner en mode bidirectionnel.
+
+Les données envoyées par les clients peuvent atteindre la PAC si le mode
+d’écriture est activé.
+
+Règles :
+
+- lecture seule par défaut ;
+- aucune écriture client ne doit être autorisée implicitement ;
+- toute option d’écriture doit être explicite ;
+- les écritures vers la PAC doivent être sérialisées ;
+- utiliser `writer.drain()` après une écriture ;
+- ne jamais journaliser les données brutes envoyées par un client ;
+- ne jamais exposer le port du proxy sur Internet ;
+- aucune authentification réseau ne doit être supposée si elle n’existe pas.
+
+## Sécurité
+
+Ne jamais ajouter au dépôt :
+
+- mot de passe ;
+- token ;
+- clé API ;
+- secret Home Assistant ;
+- clé privée ;
+- adresse IP personnelle inutile ;
+- flow Node-RED contenant des identifiants réels ;
+- contenu issu d’un autre projet sans rapport avec Arkteos.
+
+Les exemples doivent utiliser des valeurs neutres :
+
+- `192.168.1.100`
+- `PAC_IP`
+- `CHANGEME`
+- `example.local`
+
+Ne jamais afficher une valeur sensible dans les rapports ou les logs.
+
+## Fichiers principaux
+
+Vérifier en priorité :
+
+- `config.yaml`
+- `repository.yaml`
+- `Dockerfile`
+- `run.sh`
+- `arkteos_proxy.py`
+- `README.md`
+- `CHANGELOG.md`
+- `.gitignore`
+- `AGENTS.md`
+
+Le point d’entrée réel doit toujours être confirmé depuis `run.sh` et le
+Dockerfile.
+
+## Règles de modification
+
+Avant toute modification :
+
+1. afficher l’état Git ;
+2. inspecter le code existant ;
+3. distinguer les faits observés des hypothèses ;
+4. présenter le plan si la modification touche le réseau ou le protocole.
+
+Ne jamais :
+
+- supprimer une fonction utile sans accord ;
+- modifier un port par défaut sans demande ;
+- modifier le protocole silencieusement ;
+- remplacer une logique existante par une implémentation supposée ;
+- modifier plusieurs sujets sans rapport dans le même changement ;
+- réécrire l’historique Git sans accord explicite ;
+- utiliser `git push --force` ;
+- créer un commit, un tag ou un push sans demande explicite.
+
+## Style Python
+
+- utiliser `asyncio` lorsque pertinent ;
+- gérer explicitement les déconnexions ;
+- fermer proprement les writers ;
+- utiliser `await writer.wait_closed()` lorsque possible ;
+- annuler proprement les tâches ;
+- éviter les tâches asyncio résiduelles après arrêt ;
+- journaliser les exceptions réseau sans arrêter définitivement le proxy ;
+- temporiser les boucles de reconnexion ;
+- éviter les variables globales mutables non protégées ;
+- utiliser un verrou dédié pour les écritures vers la PAC ;
+- ne pas réutiliser le verrou de la liste des clients pour les écritures réseau.
+
+## Journalisation
+
+Les logs doivent indiquer clairement :
+
+- connexion à la PAC ;
+- déconnexion de la PAC ;
+- tentative de reconnexion ;
+- connexion d’un client ;
+- déconnexion d’un client ;
+- mode lecture seule ou bidirectionnel ;
+- erreur réseau utile au diagnostic.
+
+Ne pas journaliser :
+
+- secrets ;
+- mots de passe ;
+- contenu brut des commandes clients ;
+- flux binaires complets en fonctionnement normal.
+
+Les logs fréquents doivent éviter de saturer le journal Home Assistant.
+
+## Tests
+
+Toute modification fonctionnelle doit être accompagnée de tests lorsque
+possible.
+
+Tester au minimum les zones concernées :
+
+- connexion à la PAC ;
+- reconnexion après coupure ;
+- connexion et déconnexion des clients ;
+- distribution PAC vers plusieurs clients ;
+- blocage des écritures en mode lecture seule ;
+- relais client vers PAC en mode autorisé ;
+- sérialisation des écritures concurrentes ;
+- keepalive ;
+- fermeture propre ;
+- absence de vraie connexion à une PAC pendant les tests.
+
+Les tests doivent utiliser des mocks, des serveurs asyncio locaux ou des writers
+simulés.
+
+## Validations obligatoires
+
+Avant de proposer un commit :
+
+```bash
+python3 -m compileall .
+bash -n run.sh
+```
+
+Valider les fichiers YAML :
+
+```bash
+python3 - <<'PY'
+from pathlib import Path
+import yaml
+
+for filename in ("config.yaml", "repository.yaml"):
+    with Path(filename).open(encoding="utf-8") as file:
+        data = yaml.safe_load(file)
+
+    if not isinstance(data, dict):
+        raise SystemExit(f"ERREUR : {filename}")
+
+    print(f"OK YAML : {filename}")
+PY
+```
+
+S’il existe des tests :
+
+```bash
+python3 -m pytest -v
+```
+
+Toujours exécuter :
+
+```bash
+git diff --check
+git status --short
+```
+
+## Versionnement
+
+La version de l’add-on est définie dans `config.yaml`.
+
+Avant une release :
+
+- vérifier la cohérence avec `CHANGELOG.md` ;
+- vérifier la documentation ;
+- vérifier que les tests passent ;
+- vérifier l’absence de secret ;
+- vérifier les URLs Gitea et GitHub ;
+- créer le commit avant le tag ;
+- créer un tag au format `vX.Y.Z`.
+
+Ne jamais déplacer ou recréer un tag déjà publié.
+
+## Workflow Git
+
+Dépôt principal :
+
+```bash
+git pull
+git push
+```
+
+Ces commandes doivent utiliser Gitea via `origin`.
+
+Miroir GitHub :
+
+```bash
+git push github main
+git push github --tags
+```
+
+Les remotes attendus sont :
+
+- `origin` → Gitea ;
+- `github` → GitHub.
+
+Ne jamais inverser ces rôles sans demande explicite.
+
+## Documentation
+
+Toute modification fonctionnelle doit être reflétée dans :
+
+- `README.md` ;
+- `CHANGELOG.md` ;
+- `config.yaml` si une option est ajoutée ou modifiée.
+
+La documentation doit décrire le comportement réel du code.
+
+Ne jamais présenter le proxy comme strictement passif si les clients peuvent
+écrire vers la PAC.
+
+## Rapport attendu après modification
+
+À la fin d’une tâche, indiquer :
+
+- fichiers modifiés ;
+- fichiers ajoutés ;
+- comportement modifié ;
+- validations exécutées ;
+- résultats des tests ;
+- avertissements restants ;
+- confirmation de l’absence de commit, push ou tag si cela n’était pas demandé.

CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+Toutes les modifications importantes de ce projet sont documentées ici.
+
+## [Unreleased]
+
+## [1.0.6] - 2026-07-22
+
+### Fixed
+
+- Ajout d’un délai maximal pour l’établissement de la connexion à la PAC.
+- Détection d’une connexion PAC silencieuse malgré une socket toujours ouverte.
+- Fermeture propre du serveur, des clients et de la connexion PAC lors de l’arrêt de l’add-on.
+- Validation plus stricte de la configuration au démarrage.
+
+### Tests
+
+- Ajout de tests pour les timeouts, la reconnexion, l’arrêt gracieux et les configurations invalides.
+
+## [1.0.5] - 2026-07-22
+
+### Changed
+
+- Mise à jour de la description de l’add-on pour retirer la référence obsolète à Node-RED.
+- Clarification du fonctionnement multi-clients et de la lecture seule par défaut.
+
+## [1.0.4] - 2026-07-22
+
+### Changed
+
+- Utilisation de GitHub comme URL publique d’installation et de documentation.
+- Suppression des références Gitea dans les fichiers destinés aux utilisateurs.
+- Gitea reste le dépôt principal de développement interne.
+
+## [1.0.3] - 2026-07-22
+
+### Fixed
+
+- Correction de la version déclarée dans `config.yaml`.
+- La release `v1.0.2` contenait encore la version interne `1.0.1`.
+
+## [1.0.2] - 2026-07-22
+
+### Fixed
+
+- Ajout de l’entrée manquante pour la correction du Dockerfile publiée en 1.0.1.
+- Documentation de l’utilisation de l’image de base explicite `ghcr.io/home-assistant/base:latest`.
+
+## [1.0.1] - 2026-07-22
+
+### Fixed
+
+- Correction du Dockerfile pour le système de build actuel de Home Assistant.
+- Utilisation explicite de l’image multiarchitecture `ghcr.io/home-assistant/base:latest`.
+
+## [1.0.0] - 2026-07-21
+
+### Added
+
+- Add-on Home Assistant pour le proxy TCP Arkteos.
+- Maintien d’une connexion unique vers la PAC.
+- Multiplexage du flux vers plusieurs clients TCP.
+- Reconnexion automatique à la PAC après une coupure.
+- Keepalive composé d’un octet nul toutes les 300 secondes ; son rôle exact côté PAC n’est pas confirmé.
+- Fonctionnement en lecture seule par défaut.
+- Option `allow_client_writes` pour activer explicitement le relais bidirectionnel des données entre les clients et la PAC.
+- Sérialisation des écritures vers la PAC lorsque le mode bidirectionnel est activé.
+- Support des architectures déclarées dans `config.yaml`.
+- Documentation de sécurité réseau.
+
+### Changed
+
+- Gitea devient le dépôt principal.
+- GitHub est conservé comme miroir secondaire.
+- Correction du bit exécutable de `run.sh`.
+
+### Removed
+
+- Suppression d’un flow Solarwatt ajouté par erreur.
+- Nettoyage de l’historique Git contenant ce fichier étranger au projet.

Dockerfile

@@ -1,5 +1,4 @@
-ARG BUILD_FROM
+FROM ghcr.io/home-assistant/base:latest
-FROM $BUILD_FROM
 
 RUN apk add --no-cache python3
 

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 raph666
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,8 +1,6 @@
 # Arkteos Proxy — Home Assistant Addon
 
-Proxy TCP pour PAC Arkteos REG3 (Zuran 4, Baguio 4, etc.).
+Proxy TCP pour PAC Arkteos REG3 (Zuran 4, Baguio 4, etc.). Il maintient une connexion unique vers la PAC et partage son flux avec plusieurs clients TCP locaux. Les écritures client sont désactivées par défaut.
-
-Permet les connexions simultanées de Node-RED et de l'application mobile Arkteos, en relayant le flux binaire de la PAC vers tous les clients connectés.
 
 ## Installation
 
@@ -20,126 +18,33 @@ Permet les connexions simultanées de Node-RED et de l'application mobile Arkteo
 | `pac_host` | Adresse IP de la PAC | `192.168.X.X` |
 | `pac_port` | Port TCP de la PAC | `9641` |
 | `proxy_port` | Port d'écoute interne du proxy | `9641` |
+| `allow_client_writes` | Autorise le relais des données clients vers la PAC | `false` |
 
-## Intégration Node-RED
+## Fonctionnement du proxy
 
-### Import
+Le proxy se connecte à la PAC avec `pac_host` et `pac_port`. Il écoute les clients TCP sur toutes les interfaces réseau, avec `proxy_port`.
 
-1. Dans Node-RED : menu hamburger → **Import** → colle le contenu du fichier JSON
+Les données reçues de la PAC sont distribuées à tous les clients connectés. Par défaut, les données reçues d’un client sont ignorées : le client reste connecté et peut continuer à recevoir le flux de la PAC.
-2. Double-clique sur le nœud **PAC via proxy** et remplace `<IP_HA>` par l'IP de ton Home Assistant
-3. Double-clique sur le nœud **MQTT publish** → icône crayon → onglet **Security** → renseigne le login et mot de passe Mosquitto
-4. Clique **Deploy**
 
-### Fonctionnement
+Active `allow_client_writes` uniquement si un client de confiance doit écrire vers la PAC. Dans ce mode bidirectionnel, les données client sont relayées telles quelles, sans filtrage ni validation ; les écritures vers la PAC sont sérialisées.
 
-Le flow se connecte en streaming permanent au proxy. Chaque trame reçue est parsée, filtrée puis publiée sur MQTT.
+Un keepalive composé d’un octet nul est envoyé toutes les 300 secondes à la PAC afin de maintenir la connexion. Le code n’établit pas le rôle exact de cet octet pour la PAC.
 
-**Filtrage des valeurs aberrantes**
+## Robustesse de la connexion
 
-Les valeurs hors plage physiquement plausible sont ignorées et loguées dans la console Node-RED :
+L’établissement de la connexion vers la PAC est limité dans le temps. Le proxy se reconnecte automatiquement après une coupure ou lorsqu’aucun octet n’est reçu de la PAC pendant une période prolongée, même si la socket reste ouverte.
 
-| Valeur | Plage valide |
+Lors d’un arrêt, d’une mise à jour ou d’un redémarrage de l’add-on, le proxy arrête les reconnexions et ferme proprement le serveur, les clients et la connexion PAC. Ces mécanismes ne garantissent pas la disponibilité de la PAC ou du réseau.
-|---|---|
-| Température extérieure | -50°C à 150°C |
-| Températures circuit primaire | -10°C à 90°C |
-| Consigne départ eau primaire | -10°C à 90°C |
-| Températures ECS | 0°C à 95°C |
-| Consigne ECS | 0°C à 80°C |
-| Température intérieure zone 1 | -10°C à 50°C |
-| Consigne zone 1 | 5°C à 35°C |
-| Puissances | 0 à 50 000 W |
-| Pression eau primaire | 0 à 10 bar |
-| Fréquence compresseur actuelle | 0 à 200 Hz |
-| Fréquence compresseur cible | 0 à 200 Hz |
-| Vitesse ventilateur | 0 à 3 000 rpm |
-| Voltage DC | 0 à 1 000 V |
-| Débit eau primaire | 0 à 10 000 L/h |
-| Circulateur primaire | 0% à 100% |
-| Statut frigo | 0 à 3 |
-| Statut PAC | 0 à 9 |
-| Signal RF sonde | -128 à 127 dBm |
-| Nombre de dégivrages | 0 à 99 999 |
-| Temps fonctionnement compresseur | 0 à 999 999 h |
-| Nb cycles compresseur | 0 à 9 999 999 |
-| Temps mise sous tension | 0 à 999 999 h |
 
-**Throttling**
+## Clients TCP
 
-Une valeur n'est publiée que si elle a changé au-delà d'un seuil défini, avec un rafraîchissement forcé à intervalle maximum :
+Les clients TCP utilisent le port du proxy pour recevoir le flux binaire de la PAC. Aucun client particulier n’est requis pour le fonctionnement de l’add-on.
 
-| Valeur | Seuil | Intervalle max |
+## Sécurité réseau
-|---|---|---|
-| Température extérieure | 0.5°C | 60s |
-| Températures circuit primaire | 0.5°C | 60s |
-| Consigne départ eau primaire | 0.5°C | 60s |
-| Températures ECS | 0.5°C | 60s |
-| Consigne ECS | 0.5°C | 60s |
-| Température intérieure zone 1 | 0.5°C | 60s |
-| Consigne zone 1 | 0.5°C | 60s |
-| Puissance produite | 10 W | 30s |
-| Puissance consommée | 10 W | 30s |
-| Pression eau primaire | 0.1 bar | 60s |
-| Fréquence compresseur actuelle | 1 Hz | 30s |
-| Fréquence compresseur cible | 1 Hz | 30s |
-| Vitesse ventilateur | 10 rpm | 30s |
-| Voltage DC | 5 V | 60s |
-| Débit eau primaire | 1 L/h | 60s |
-| Circulateur primaire | 1% | 60s |
-| Modèle PAC | changement | 1h |
-| Statut frigo | changement | 60s |
-| Statut PAC | changement | 60s |
-| Erreurs | changement | 60s |
-| Nombre de dégivrages | 1 | 5 min |
-| Nb cycles compresseur | 100 | 5 min |
-| Temps fonctionnement compresseur | 1 h | 5 min |
-| Temps mise sous tension | 1 h | 5 min |
-| Signal RF sonde | 1 dBm | 5 min |
 
-**Statut de connexion**
+Ne pas exposer le port du proxy sur Internet. Limite l’accès au réseau local ou à des clients de confiance : lorsque `allow_client_writes` est activée, un client qui accède au proxy peut potentiellement transmettre des données à la PAC.
 
-Un `binary_sensor` HA indique si la PAC est connectée. Il passe à `OFF` si aucune trame n'est reçue depuis plus de 30 secondes.
+Le proxy ne met en œuvre ni authentification, ni filtrage protocolaire, ni contrôle d’accès. Il ne doit donc pas être considéré comme une barrière de contrôle d’accès, particulièrement en mode bidirectionnel.
-
-### Entités créées dans HA
-
-Le flow publie automatiquement via MQTT Discovery dans un appareil **PAC Arkteos Zuran 4** :
-
-**Statut**
-- PAC connectée (binary_sensor)
-
-**Groupe frigorifique**
-- Température extérieure (°C)
-- Nombre de dégivrages
-- Temps fonctionnement compresseur (h)
-- Nombre de cycles compresseur
-- Fréquence compresseur actuelle (Hz)
-- Fréquence compresseur cible (Hz)
-- Vitesse ventilateur groupe frigo (rpm)
-- Voltage DC compresseur (V)
-- Statut frigo (0-3)
-- Statut frigo texte (Arret / Refroidissement / Chauffage / Degivrage)
-- Erreur active frigo
-
-**Régulation**
-- Puissance instantanée produite (W)
-- Puissance instantanée consommée (W)
-- Temps mise sous tension (h)
-- Modèle PAC (texte)
-- Consigne départ eau primaire (°C)
-- Température eau primaire aller (°C)
-- Température eau primaire retour (°C)
-- Débit eau primaire (L/h)
-- Pression eau primaire (bar)
-- Circulateur primaire (%)
-- Température intérieure zone 1 (°C)
-- Consigne température zone 1 (°C)
-- Température ballon ECS milieu (°C)
-- Température ballon ECS bas (°C)
-- Consigne ECS (°C)
-- Cycles compresseur (régulation)
-- Statut PAC (0-9)
-- Statut PAC texte (Arret / Attente / Chaud / Froid / Hors Gel / ECS / Piscine / etc.)
-- Erreur active régulation
-- Signal RF sonde zone 1 (dBm)
 
 ## Protocole
 

arkteos_proxy.py

@@ -1,180 +1,339 @@
 #!/usr/bin/env python3
-# Proxy TCP pour PAC Arkteos REG3
+"""Proxy TCP pour PAC Arkteos REG3."""
-# Permet les connexions simultanées de Node-RED et de l'app mobile Arkteos
-# Usage : arkteos_proxy.py <pac_host> <pac_port> <proxy_port>
 
-import socket
+import asyncio
-import threading
-import sys
-import time
 import logging
+import signal
+import sys
 
-# Configuration depuis les arguments (injectés par run.sh depuis les options HA)
+
-PAC_HOST  = sys.argv[1] if len(sys.argv) > 1 else "192.168.X.X"
+KEEPALIVE_INTERVAL = 300
-PAC_PORT  = int(sys.argv[2]) if len(sys.argv) > 2 else 9641
+RECONNECT_DELAY = 10
-PROXY_PORT = int(sys.argv[3]) if len(sys.argv) > 3 else 9641
+PAC_CONNECT_TIMEOUT = 10.0
+PAC_READ_TIMEOUT = 600.0
 
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s %(levelname)s %(message)s',
+    format="%(asctime)s %(levelname)s %(message)s",
-    stream=sys.stdout
+    stream=sys.stdout,
 )
 logger = logging.getLogger(__name__)
 
-stop_event = threading.Event()
-clients = []
-clients_lock = threading.Lock()
 
-def log(msg):
+class ConfigurationError(ValueError):
-    logger.info(msg)
+    """Configuration de l'add-on invalide."""
 
-def connect_to_pac():
+
-    while not stop_event.is_set():
+def parse_allow_client_writes(value: bool | str | None) -> bool:
+    """Accepte uniquement un booléen ou les chaînes explicites true et false."""
+    if value is None:
+        return False
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized == "true":
+            return True
+        if normalized == "false":
+            return False
+    raise ConfigurationError("allow_client_writes doit être true ou false")
+
+
+def parse_port(value: int | str, option_name: str) -> int:
+    """Valide un port TCP sans accepter de valeur ambiguë."""
+    if isinstance(value, bool):
+        raise ConfigurationError(f"{option_name} doit être un entier entre 1 et 65535")
+    if isinstance(value, str):
+        if not value.strip().isdigit():
+            raise ConfigurationError(f"{option_name} doit être un entier entre 1 et 65535")
+        value = int(value.strip())
+    if not isinstance(value, int) or not 1 <= value <= 65535:
+        raise ConfigurationError(f"{option_name} doit être un entier entre 1 et 65535")
+    return value
+
+
+def validate_configuration(
+    pac_host: str,
+    pac_port: int | str,
+    proxy_port: int | str,
+    allow_client_writes: bool | str | None,
+) -> tuple[str, int, int, bool]:
+    """Retourne une configuration validée avant toute ouverture réseau."""
+    if not isinstance(pac_host, str) or not pac_host.strip():
+        raise ConfigurationError("pac_host doit être une chaîne non vide")
+    return (
+        pac_host.strip(),
+        parse_port(pac_port, "pac_port"),
+        parse_port(proxy_port, "proxy_port"),
+        parse_allow_client_writes(allow_client_writes),
+    )
+
+
+class ArkteosProxy:
+    def __init__(
+        self,
+        pac_host: str,
+        pac_port: int,
+        proxy_port: int,
+        allow_client_writes: bool = False,
+    ) -> None:
+        self.pac_host = pac_host
+        self.pac_port = pac_port
+        self.proxy_port = proxy_port
+        self.allow_client_writes = allow_client_writes
+        self.clients: set[asyncio.StreamWriter] = set()
+        self.client_tasks: set[asyncio.Task[None]] = set()
+        self.pac_writer: asyncio.StreamWriter | None = None
+        self.pac_write_lock = asyncio.Lock()
+        self.stop_event = asyncio.Event()
+        self.server: asyncio.AbstractServer | None = None
+        self.pac_reader_task: asyncio.Task[None] | None = None
+        self.keepalive_task: asyncio.Task[None] | None = None
+
+    def request_stop(self) -> None:
+        """Déclenche l'arrêt sans bloquer un gestionnaire de signal."""
+        if self.stop_event.is_set():
+            return
+        logger.info("Arrêt du proxy demandé")
+        self.stop_event.set()
+        if self.server is not None:
+            self.server.close()
+        if self.keepalive_task is not None:
+            self.keepalive_task.cancel()
+        if self.pac_reader_task is not None:
+            self.pac_reader_task.cancel()
+        if self.pac_writer is not None:
+            self.pac_writer.close()
+        for writer in tuple(self.clients):
+            writer.close()
+
+    async def write_to_pac(self, data: bytes) -> None:
+        """Écrit un bloc complet vers la PAC sans l'altérer."""
+        async with self.pac_write_lock:
+            if self.pac_writer is None:
+                raise ConnectionError("PAC non connectée")
+            self.pac_writer.write(data)
+            await self.pac_writer.drain()
+
+    async def send_keepalive(self) -> None:
+        await self.write_to_pac(b"\x00")
+        logger.info("Keepalive envoyé à la PAC")
+
+    async def pac_reader(self, reader: asyncio.StreamReader) -> None:
+        logger.info("Démarrage lecture PAC")
         try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            while not self.stop_event.is_set():
-            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                try:
-            s.connect((PAC_HOST, PAC_PORT))
+                    async with asyncio.timeout(PAC_READ_TIMEOUT):
-            log(f"Connecté à la PAC {PAC_HOST}:{PAC_PORT}")
+                        data = await reader.read(4096)
-            return s
+                except TimeoutError:
-        except Exception as e:
+                    logger.warning("PAC restée silencieuse pendant %.0f secondes", PAC_READ_TIMEOUT)
-            log(f"Échec connexion PAC : {e}. Nouvelle tentative dans 10s...")
+                    return
-            time.sleep(10)
+                if not data:
-    return None
+                    logger.info("PAC a fermé la connexion")
+                    return
+                await self.broadcast_to_clients(data)
+        except (ConnectionError, OSError) as error:
+            logger.info("Erreur lecture PAC : %s", error)
+        except asyncio.CancelledError:
+            if not self.stop_event.is_set():
+                raise
+        finally:
+            logger.info("Arrêt lecture PAC")
 
-def pac_reader(pac_socket):
+    async def broadcast_to_clients(self, data: bytes) -> None:
-    log("Démarrage thread lecture PAC")
+        dead_clients: list[asyncio.StreamWriter] = []
-    try:
+        for writer in tuple(self.clients):
-        while not stop_event.is_set():
             try:
-                data = pac_socket.recv(4096)
+                writer.write(data)
-            except Exception as e:
+                await writer.drain()
-                log(f"Erreur lecture PAC : {e}")
+            except (ConnectionError, OSError):
-                break
+                dead_clients.append(writer)
-            if not data:
+        for writer in dead_clients:
-                log("PAC a fermé la connexion")
+            await self.close_client(writer)
-                break
 
-            dead_clients = []
+    async def pac_keepalive(self) -> None:
-            with clients_lock:
+        logger.info("Démarrage keepalive PAC")
-                for c in clients:
-                    try:
-                        c.sendall(data)
-                    except Exception:
-                        dead_clients.append(c)
-
-            if dead_clients:
-                with clients_lock:
-                    for c in dead_clients:
-                        try:
-                            c.close()
-                        except Exception:
-                            pass
-                        if c in clients:
-                            clients.remove(c)
-                        log("Client déconnecté nettoyé")
-    finally:
-        log("Arrêt thread lecture PAC")
-        pac_socket.close()
-
-def pac_keepalive(pac_socket):
-    log("Démarrage thread keepalive PAC")
-    while not stop_event.is_set():
-        time.sleep(300)
         try:
-            pac_socket.sendall(b'\x00')
+            while not self.stop_event.is_set():
-            log("Keepalive envoyé à la PAC")
+                try:
-        except Exception as e:
+                    async with asyncio.timeout(KEEPALIVE_INTERVAL):
-            log(f"Erreur keepalive PAC : {e}")
+                        await self.stop_event.wait()
-            break
+                    return
-    log("Arrêt thread keepalive PAC")
+                except TimeoutError:
+                    await self.send_keepalive()
+        except (ConnectionError, OSError) as error:
+            logger.info("Erreur keepalive PAC : %s", error)
+        except asyncio.CancelledError:
+            if not self.stop_event.is_set():
+                raise
+        finally:
+            logger.info("Arrêt keepalive PAC")
 
-def handle_client(client_socket, client_addr, pac_socket):
+    async def handle_client(
-    log(f"Nouveau client : {client_addr}")
+        self,
-    with clients_lock:
+        reader: asyncio.StreamReader,
-        clients.append(client_socket)
+        writer: asyncio.StreamWriter,
-    try:
+    ) -> None:
-        while not stop_event.is_set():
+        task = asyncio.current_task()
-            try:
+        if task is not None:
-                data = client_socket.recv(1024)
+            self.client_tasks.add(task)
-            except Exception:
+        peername = writer.get_extra_info("peername")
-                break
+        logger.info("Nouveau client : %s", peername)
-            if not data:
+        self.clients.add(writer)
-                break
+        blocked_write_logged = False
-            try:
-                pac_socket.sendall(data)
-            except Exception as e:
-                log(f"Erreur envoi PAC depuis {client_addr} : {e}")
-                break
-    finally:
-        with clients_lock:
-            if client_socket in clients:
-                clients.remove(client_socket)
         try:
-            client_socket.close()
+            while not self.stop_event.is_set():
-        except Exception:
+                data = await reader.read(1024)
+                if not data:
+                    return
+                if not self.allow_client_writes:
+                    if not blocked_write_logged:
+                        logger.info("Tentative d’écriture client ignorée")
+                        blocked_write_logged = True
+                    continue
+                try:
+                    await self.write_to_pac(data)
+                except (ConnectionError, OSError) as error:
+                    logger.info("Erreur envoi PAC depuis %s : %s", peername, error)
+                    return
+        except (ConnectionError, OSError) as error:
+            logger.info("Erreur client %s : %s", peername, error)
+        except asyncio.CancelledError:
+            if not self.stop_event.is_set():
+                raise
+        finally:
+            await self.close_client(writer)
+            if task is not None:
+                self.client_tasks.discard(task)
+
+    async def close_client(self, writer: asyncio.StreamWriter) -> None:
+        if writer not in self.clients:
+            return
+        self.clients.discard(writer)
+        writer.close()
+        try:
+            await writer.wait_closed()
+        except (ConnectionError, OSError):
             pass
-        log(f"Client déconnecté : {client_addr}")
+        logger.info("Client déconnecté nettoyé")
 
-def start_proxy():
+    async def close_clients(self) -> None:
-    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        for writer in tuple(self.clients):
-    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            await self.close_client(writer)
-    server_socket.bind(('0.0.0.0', PROXY_PORT))
-    server_socket.listen(5)
-    log(f"Proxy en écoute sur 0.0.0.0:{PROXY_PORT}")
 
-    pac_socket = connect_to_pac()
+    async def stop_client_tasks(self) -> None:
-    if pac_socket is None:
+        current_task = asyncio.current_task()
-        log("Impossible de se connecter à la PAC. Arrêt.")
+        tasks = [task for task in self.client_tasks if task is not current_task]
-        return
+        for task in tasks:
+            task.cancel()
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
 
-    reader_thread = threading.Thread(target=pac_reader, args=(pac_socket,), daemon=True)
+    async def run_pac_connection(self) -> None:
-    reader_thread.start()
+        try:
+            async with asyncio.timeout(PAC_CONNECT_TIMEOUT):
+                reader, writer = await asyncio.open_connection(self.pac_host, self.pac_port)
+        except TimeoutError as error:
+            logger.warning("Délai de connexion PAC dépassé après %.0f secondes", PAC_CONNECT_TIMEOUT)
+            raise ConnectionError("Délai de connexion PAC dépassé") from error
 
-    keepalive_thread = threading.Thread(target=pac_keepalive, args=(pac_socket,), daemon=True)
+        self.pac_writer = writer
-    keepalive_thread.start()
+        logger.info("Connecté à la PAC %s:%s", self.pac_host, self.pac_port)
-
+        self.pac_reader_task = asyncio.create_task(self.pac_reader(reader))
-    try:
+        self.keepalive_task = asyncio.create_task(self.pac_keepalive())
-        while not stop_event.is_set():
+        try:
-            server_socket.settimeout(1)
             try:
-                client_socket, addr = server_socket.accept()
+                await self.pac_reader_task
-                t = threading.Thread(target=handle_client, args=(client_socket, addr, pac_socket), daemon=True)
+            except asyncio.CancelledError:
-                t.start()
+                if not self.stop_event.is_set():
-            except socket.timeout:
+                    raise
+        finally:
+            if self.keepalive_task is not None:
+                self.keepalive_task.cancel()
+                await asyncio.gather(self.keepalive_task, return_exceptions=True)
+            self.keepalive_task = None
+            self.pac_reader_task = None
+            if self.pac_writer is writer:
+                self.pac_writer = None
+            writer.close()
+            try:
+                await writer.wait_closed()
+            except (ConnectionError, OSError):
                 pass
+            await self.close_clients()
+            await self.stop_client_tasks()
 
-            # Reconnexion si la PAC s'est déconnectée
+    async def wait_for_reconnect_delay(self) -> None:
-            if not reader_thread.is_alive():
-                log("Thread lecture PAC mort, reconnexion...")
-                with clients_lock:
-                    for c in clients:
-                        try:
-                            c.close()
-                        except Exception:
-                            pass
-                    clients.clear()
-                pac_socket = connect_to_pac()
-                if pac_socket is None:
-                    break
-                reader_thread = threading.Thread(target=pac_reader, args=(pac_socket,), daemon=True)
-                reader_thread.start()
-                keepalive_thread = threading.Thread(target=pac_keepalive, args=(pac_socket,), daemon=True)
-                keepalive_thread.start()
-    except Exception as e:
-        log(f"Erreur serveur proxy : {e}")
-    finally:
-        stop_event.set()
-        server_socket.close()
         try:
-            pac_socket.close()
+            async with asyncio.timeout(RECONNECT_DELAY):
-        except Exception:
+                await self.stop_event.wait()
+        except TimeoutError:
             pass
-        log("Proxy arrêté.")
+
+    async def serve(self) -> None:
+        mode = (
+            "Mode bidirectionnel : écritures des clients autorisées"
+            if self.allow_client_writes
+            else "Mode lecture seule : écritures des clients bloquées"
+        )
+        logger.info(mode)
+        self.server = await asyncio.start_server(self.handle_client, "0.0.0.0", self.proxy_port)
+        logger.info("Proxy en écoute sur 0.0.0.0:%s", self.proxy_port)
+        try:
+            while not self.stop_event.is_set():
+                try:
+                    await self.run_pac_connection()
+                except (ConnectionError, OSError) as error:
+                    if not self.stop_event.is_set():
+                        logger.info("Échec connexion PAC : %s", error)
+                if not self.stop_event.is_set():
+                    logger.info("Nouvelle tentative de connexion PAC dans 10s...")
+                    await self.wait_for_reconnect_delay()
+        finally:
+            self.request_stop()
+            if self.server is not None:
+                await self.server.wait_closed()
+                self.server = None
+            await self.close_clients()
+            await self.stop_client_tasks()
+            logger.info("Proxy arrêté")
+
+
+async def run_proxy(proxy: ArkteosProxy) -> None:
+    loop = asyncio.get_running_loop()
+    installed_signals: list[signal.Signals] = []
+    for signal_name in (signal.SIGTERM, signal.SIGINT):
+        try:
+            loop.add_signal_handler(signal_name, proxy.request_stop)
+            installed_signals.append(signal_name)
+        except (NotImplementedError, RuntimeError):
+            pass
+    try:
+        await proxy.serve()
+    finally:
+        for signal_name in installed_signals:
+            loop.remove_signal_handler(signal_name)
+
+
+def main() -> int:
+    try:
+        pac_host, pac_port, proxy_port, allow_client_writes = validate_configuration(
+            sys.argv[1] if len(sys.argv) > 1 else "192.168.X.X",
+            sys.argv[2] if len(sys.argv) > 2 else "9641",
+            sys.argv[3] if len(sys.argv) > 3 else "9641",
+            sys.argv[4] if len(sys.argv) > 4 else None,
+        )
+    except ConfigurationError as error:
+        logger.error("Configuration invalide : %s", error)
+        return 2
+    proxy = ArkteosProxy(pac_host, pac_port, proxy_port, allow_client_writes)
+    try:
+        asyncio.run(run_proxy(proxy))
+    except KeyboardInterrupt:
+        logger.info("Arrêt demandé")
+    return 0
+
 
 if __name__ == "__main__":
-    try:
+    raise SystemExit(main())
-        start_proxy()
-    except KeyboardInterrupt:
-        log("Arrêt demandé")
-        stop_event.set()
-        sys.exit(0)

config.yaml

@@ -1,8 +1,8 @@
 name: Arkteos Proxy
-version: "1.0.0"
+version: "1.0.6"
 slug: arkteos_proxy
-description: Proxy TCP pour PAC Arkteos REG3 — permet les connexions simultanées de Node-RED et de l'app mobile Arkteos.
+description: Proxy TCP pour PAC Arkteos REG3 — maintient une connexion unique vers la PAC et partage le flux avec plusieurs clients locaux. Les écritures client sont désactivées par défaut.
-url: https://github.com/raph666/arkteos-proxy-addon
+url: "https://github.com/raph666/arkteos-proxy-addon"
 arch:
   - aarch64
   - amd64
@@ -14,10 +14,12 @@ options:
   pac_host: "192.168.X.X"
   pac_port: 9641
   proxy_port: 9641
+  allow_client_writes: false
 schema:
   pac_host: str
   pac_port: int
   proxy_port: int
+  allow_client_writes: bool
 ports:
   9641/tcp: 9641
 ports_description:

repository.yaml

@@ -1,3 +1,3 @@
 name: Arkteos Proxy
-url: https://github.com/raph666/arkteos-proxy-addon
+url: "https://github.com/raph666/arkteos-proxy-addon"
 maintainer: raph666

run.sh

@@ -3,9 +3,10 @@
 PAC_HOST=$(bashio::config 'pac_host')
 PAC_PORT=$(bashio::config 'pac_port')
 PROXY_PORT=$(bashio::config 'proxy_port')
+ALLOW_CLIENT_WRITES=$(bashio::config 'allow_client_writes')
 
 bashio::log.info "Démarrage du proxy Arkteos"
 bashio::log.info "PAC : ${PAC_HOST}:${PAC_PORT}"
 bashio::log.info "Proxy en écoute sur port : ${PROXY_PORT}"
 
-exec python3 /arkteos_proxy.py "${PAC_HOST}" "${PAC_PORT}" "${PROXY_PORT}"
+exec python3 /arkteos_proxy.py "${PAC_HOST}" "${PAC_PORT}" "${PROXY_PORT}" "${ALLOW_CLIENT_WRITES:-false}"

tests/test_arkteos_proxy.py

@@ -0,0 +1,289 @@
+import asyncio
+import unittest
+from unittest.mock import AsyncMock, patch
+
+from arkteos_proxy import (
+    ArkteosProxy,
+    ConfigurationError,
+    KEEPALIVE_INTERVAL,
+    RECONNECT_DELAY,
+    validate_configuration,
+)
+
+
+class QueueReader:
+    def __init__(self):
+        self.items = asyncio.Queue()
+
+    async def read(self, _size):
+        return await self.items.get()
+
+
+class FakeWriter:
+    def __init__(self):
+        self.writes = []
+        self.drain_calls = 0
+        self.closed = False
+
+    def write(self, data):
+        self.writes.append(data)
+
+    async def drain(self):
+        self.drain_calls += 1
+
+    def close(self):
+        self.closed = True
+
+    async def wait_closed(self):
+        return None
+
+    def get_extra_info(self, _name):
+        return ("127.0.0.1", 12345)
+
+
+class SerialWriter(FakeWriter):
+    def __init__(self):
+        super().__init__()
+        self.active_drains = 0
+        self.maximum_active_drains = 0
+
+    async def drain(self):
+        self.drain_calls += 1
+        self.active_drains += 1
+        self.maximum_active_drains = max(self.maximum_active_drains, self.active_drains)
+        await asyncio.sleep(0)
+        self.active_drains -= 1
+
+
+class FakeServer:
+    def __init__(self):
+        self.closed = False
+
+    def close(self):
+        self.closed = True
+
+    async def wait_closed(self):
+        return None
+
+
+class ArkteosProxyTests(unittest.IsolatedAsyncioTestCase):
+    async def test_default_mode_blocks_client_writes_and_keeps_client_connected(self):
+        proxy = ArkteosProxy("pac", 9641, 9641)
+        pac_writer = FakeWriter()
+        proxy.pac_writer = pac_writer
+        reader = QueueReader()
+        client_writer = FakeWriter()
+        task = asyncio.create_task(proxy.handle_client(reader, client_writer))
+
+        await reader.items.put(b"client-data")
+        await asyncio.sleep(0)
+        self.assertEqual(pac_writer.writes, [])
+        self.assertIn(client_writer, proxy.clients)
+
+        await proxy.broadcast_to_clients(b"pac-data")
+        self.assertEqual(client_writer.writes, [b"pac-data"])
+
+        await reader.items.put(b"")
+        await task
+
+    async def test_bidirectional_mode_relays_data_and_drains_writer(self):
+        proxy = ArkteosProxy("pac", 9641, 9641, allow_client_writes=True)
+        pac_writer = FakeWriter()
+        proxy.pac_writer = pac_writer
+        reader = QueueReader()
+        client_writer = FakeWriter()
+        task = asyncio.create_task(proxy.handle_client(reader, client_writer))
+
+        await reader.items.put(b"client-data")
+        await reader.items.put(b"")
+        await task
+
+        self.assertEqual(pac_writer.writes, [b"client-data"])
+        self.assertEqual(pac_writer.drain_calls, 1)
+
+    async def test_two_clients_writes_are_serialized(self):
+        proxy = ArkteosProxy("pac", 9641, 9641, allow_client_writes=True)
+        pac_writer = SerialWriter()
+        proxy.pac_writer = pac_writer
+        first_reader = QueueReader()
+        second_reader = QueueReader()
+        first_task = asyncio.create_task(proxy.handle_client(first_reader, FakeWriter()))
+        second_task = asyncio.create_task(proxy.handle_client(second_reader, FakeWriter()))
+
+        await first_reader.items.put(b"first")
+        await second_reader.items.put(b"second")
+        await first_reader.items.put(b"")
+        await second_reader.items.put(b"")
+        await asyncio.gather(first_task, second_task)
+
+        self.assertCountEqual(pac_writer.writes, [b"first", b"second"])
+        self.assertEqual(pac_writer.maximum_active_drains, 1)
+
+    async def test_keepalive_uses_serialized_write_and_keeps_protocol_values(self):
+        proxy = ArkteosProxy("pac", 9641, 9641)
+        pac_writer = SerialWriter()
+        proxy.pac_writer = pac_writer
+
+        await proxy.send_keepalive()
+
+        self.assertEqual(KEEPALIVE_INTERVAL, 300)
+        self.assertEqual(pac_writer.writes, [b"\x00"])
+        self.assertEqual(pac_writer.drain_calls, 1)
+        self.assertEqual(pac_writer.maximum_active_drains, 1)
+
+    async def test_pac_disconnect_closes_clients(self):
+        proxy = ArkteosProxy("pac", 9641, 9641)
+        first_client = FakeWriter()
+        second_client = FakeWriter()
+        proxy.clients.update({first_client, second_client})
+
+        await proxy.close_clients()
+
+        self.assertTrue(first_client.closed)
+        self.assertTrue(second_client.closed)
+        self.assertEqual(proxy.clients, set())
+
+    async def test_reconnection_loop_is_preserved(self):
+        proxy = ArkteosProxy("pac", 9641, 0)
+        attempts = 0
+
+        async def fake_pac_connection():
+            nonlocal attempts
+            attempts += 1
+            if attempts == 1:
+                raise ConnectionError("PAC fermée")
+            proxy.stop_event.set()
+
+        proxy.run_pac_connection = fake_pac_connection
+        proxy.wait_for_reconnect_delay = AsyncMock()
+        with (
+            patch("arkteos_proxy.asyncio.start_server", new_callable=AsyncMock, return_value=FakeServer()),
+        ):
+            await proxy.serve()
+
+        self.assertEqual(attempts, 2)
+        proxy.wait_for_reconnect_delay.assert_awaited_once_with()
+
+    def test_missing_option_defaults_to_read_only(self):
+        self.assertFalse(ArkteosProxy("pac", 9641, 9641).allow_client_writes)
+
+    async def test_connection_timeout_stops_a_single_attempt(self):
+        proxy = ArkteosProxy("pac", 9641, 9641)
+
+        async def never_connect(*_args, **_kwargs):
+            await asyncio.Event().wait()
+
+        with (
+            patch("arkteos_proxy.PAC_CONNECT_TIMEOUT", 0.01),
+            patch("arkteos_proxy.asyncio.open_connection", new_callable=AsyncMock, side_effect=never_connect) as connect,
+        ):
+            with self.assertRaises(ConnectionError):
+                await proxy.run_pac_connection()
+
+        connect.assert_awaited_once_with("pac", 9641)
+
+    async def test_silent_pac_closes_writer_and_cancels_keepalive(self):
+        proxy = ArkteosProxy("pac", 9641, 9641)
+        reader = QueueReader()
+        writer = FakeWriter()
+        keepalive_cancelled = asyncio.Event()
+
+        async def tracked_keepalive():
+            try:
+                await asyncio.Event().wait()
+            except asyncio.CancelledError:
+                keepalive_cancelled.set()
+                raise
+
+        proxy.pac_keepalive = tracked_keepalive
+        with (
+            patch("arkteos_proxy.PAC_READ_TIMEOUT", 0.01),
+            patch("arkteos_proxy.asyncio.open_connection", new_callable=AsyncMock, return_value=(reader, writer)),
+        ):
+            await proxy.run_pac_connection()
+
+        self.assertTrue(writer.closed)
+        self.assertTrue(keepalive_cancelled.is_set())
+        self.assertIsNone(proxy.pac_writer)
+        self.assertIsNone(proxy.keepalive_task)
+
+    async def test_pac_activity_is_distributed_before_connection_closes(self):
+        proxy = ArkteosProxy("pac", 9641, 9641)
+        reader = QueueReader()
+        writer = FakeWriter()
+        client = FakeWriter()
+        proxy.clients.add(client)
+        await reader.items.put(b"pac-data")
+        await reader.items.put(b"")
+
+        with (
+            patch("arkteos_proxy.PAC_READ_TIMEOUT", 0.01),
+            patch("arkteos_proxy.asyncio.open_connection", new_callable=AsyncMock, return_value=(reader, writer)),
+        ):
+            await proxy.run_pac_connection()
+
+        self.assertEqual(client.writes, [b"pac-data"])
+        self.assertTrue(writer.closed)
+
+    async def test_graceful_stop_closes_server_clients_and_pac_writer(self):
+        proxy = ArkteosProxy("pac", 9641, 0)
+        server = FakeServer()
+        pac_writer = FakeWriter()
+        client = FakeWriter()
+        proxy.pac_writer = pac_writer
+        proxy.clients.add(client)
+
+        async def wait_for_stop():
+            await proxy.stop_event.wait()
+
+        proxy.run_pac_connection = wait_for_stop
+        with patch("arkteos_proxy.asyncio.start_server", new_callable=AsyncMock, return_value=server):
+            task = asyncio.create_task(proxy.serve())
+            await asyncio.sleep(0)
+            proxy.request_stop()
+            await task
+
+        self.assertTrue(server.closed)
+        self.assertTrue(client.closed)
+        self.assertTrue(pac_writer.closed)
+        self.assertEqual(proxy.client_tasks, set())
+
+    async def test_stop_during_reconnect_does_not_wait_for_full_delay(self):
+        proxy = ArkteosProxy("pac", 9641, 0)
+        server = FakeServer()
+
+        async def failed_connection():
+            raise ConnectionError("PAC indisponible")
+
+        async def stop_during_delay():
+            proxy.request_stop()
+
+        proxy.run_pac_connection = failed_connection
+        proxy.wait_for_reconnect_delay = stop_during_delay
+        with patch("arkteos_proxy.asyncio.start_server", new_callable=AsyncMock, return_value=server):
+            await asyncio.wait_for(proxy.serve(), timeout=0.1)
+
+        self.assertTrue(server.closed)
+
+    def test_configuration_validation_rejects_invalid_values(self):
+        invalid_configurations = (
+            ("   ", "9641", "9641", "false"),
+            ("pac", "0", "9641", "false"),
+            ("pac", "65536", "9641", "false"),
+            ("pac", "9641", "invalid", "false"),
+            ("pac", "9641", "9641", "maybe"),
+        )
+        for configuration in invalid_configurations:
+            with self.subTest(configuration=configuration):
+                with self.assertRaises(ConfigurationError):
+                    validate_configuration(*configuration)
+
+    def test_configuration_validation_accepts_supported_values(self):
+        self.assertEqual(
+            validate_configuration(" pac ", "9641", 9641, "false"),
+            ("pac", 9641, 9641, False),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()