artnet2usb-cli 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Remana
+
+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.

package/README.de.md

@@ -0,0 +1,149 @@
+<div align="center">
+
+<img src="src/public/logo.svg" alt="Relackout ArtNet 2 USB" width="96" height="96">
+
+# Relackout ArtNet 2 USB
+
+**Eine kostenlose, fokussierte Art-Net-→-USB-DMX-Bridge mit Desktop-GUI und Headless-CLI.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Platforms](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-informational)](#download)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](package.json)
+
+[Download](https://relackout.com/usb-dmx) · [CLI-Nutzung](#cli-usage) · [Aus dem Quellcode erstellen](#building-from-source) · [Architektur](#architecture)
+
+[English](README.md) · [Türkçe](README.tr.md) · **Deutsch** · [Español](README.es.md) · [Français](README.fr.md) · [Italiano](README.it.md) · [Português](README.pt-BR.md) · [Русский](README.ru.md) · [简体中文](README.zh-Hans.md) · [日本語](README.ja.md)
+
+</div>
+
+---
+
+## Was ist das?
+
+Die meisten Lichtsteuerungs-Programme sprechen **Art-Net** über das Netzwerk, aber viele USB-DMX-Interfaces — Enttecs DMX USB Pro (und kompatible Geräte), generische Open-DMX-/FTDI-Dongles — benötigen weiterhin etwas auf dem Tisch, das dieses Netzwerksignal empfängt und über USB ausgibt.
+
+**Relackout ArtNet 2 USB** ist genau das: eine kleine, fokussierte Bridge, die Sie im Hintergrund laufen lassen. Sie kostet nichts, erfordert kein Konto und wurde entwickelt, um den Umgang mit dem gesamten Art-Net-Ökosystem zu erleichtern — auch mit Konsolen und Software, die nicht von [Relackout](https://relackout.com) stammen.
+
+Es gibt sie in zwei Varianten:
+- **Eine Desktop-GUI** — automatische Erkennung, eine Live-Vorschau aller 512 Kanäle und eine visuelle Routing-Tabelle.
+- **Eine Headless-CLI** (`artnet2usb-cli`) — genau dieselbe Routing-Engine, ohne UI, gedacht für einen Raspberry Pi hinter einer Traverse, einen Backstage-Server ohne Monitor oder das Skripten einer kompletten Show-Konfiguration im Voraus. Beide lesen und schreiben dieselbe Konfigurationsdatei, sodass Sie Routen in der GUI anlegen und headless ausführen können — oder umgekehrt.
+
+## Funktionen
+
+- **Automatische Erkennung** — lauscht passiv auf UDP 6454 und listet jedes im Netzwerk gesendete Art-Net-Universum auf, samt Quell-IP und einer Live-Anzeige der Framerate; `ArtPoll`/`ArtPollReply`-Node-Scanning findet auch Geräte, die noch kein DMX senden.
+- **Live-Kanalvorschau** — beobachten Sie alle 512 Kanäle eines erkannten Universums in Echtzeit, bevor Sie überhaupt etwas routen.
+- **Visuelle Routing-Tabelle** — jede Zeile ist eine Regel: Art-Net-Universum → USB-Gerät + Protokoll + Aktualisierungsrate (1–44 Hz).
+- **Zwei Protokolle** — Enttec DMX USB Pro (und firmwarekompatible Klone) sowie rohe Open-DMX-/FTDI-Ausgabe.
+- **Dauerhafte Geräteidentität** — USB-Interfaces werden anhand ihrer Hardware-Identität (Vendor-ID, Product-ID, Seriennummer) erkannt, nicht anhand ihres OS-Port-Pfads. Benennen Sie ein Gerät einmal um, und Name sowie zugehörige Routen bleiben erhalten, selbst wenn das Gerät abgesteckt und an einem anderen Port wieder angeschlossen wird.
+- **Kanal-Patch-Offset** — gleicht die eigene DMX-Startadresse eines Scheinwerfers oder eine abweichende Kanalnummerierung einer Konsole pro Route aus (`-511..511`). Das Universum wird **zirkulär** innerhalb seiner 512 Kanäle verschoben — es gehen dabei nie Kanaldaten verloren, sie laufen stattdessen um.
+- **Verhalten bei Signalverlust** — legen Sie fest, ob die Ausgabe das letzte Frame hält oder abdunkelt, sobald die Art-Net-Quelle verschwindet.
+- **Portable Konfiguration** — läuft ohne jede Installation von einem USB-Stick; siehe [Portable Konfiguration](#portable-config) unten.
+- **5 Sprachen in der GUI** — Englisch, Deutsch, Französisch, Italienisch, Türkisch.
+
+## Download
+
+Vorgefertigte Single-File-Binärdateien ohne Installer für Windows, macOS und Linux (einschließlich Raspberry Pi für die CLI) finden Sie unter **[relackout.com/usb-dmx](https://relackout.com/usb-dmx)** sowie auf der Seite [GitHub Releases](../../releases).
+
+| | Datei | Hinweise |
+|---|---|---|
+| GUI · Windows | `Relackout-ArtNet2USB-<ver>-portable.exe` | Portabel — kein Installer, einfach ausführen. |
+| GUI · macOS | `Relackout-ArtNet2USB-<ver>-<arch>.dmg` | Drag & Drop, kein Installer. |
+| GUI · Linux | `Relackout-ArtNet2USB-<ver>-<arch>.AppImage` | `chmod +x` und ausführen. |
+| CLI · alle Plattformen | `artnet2usb-cli-<ver>-<platform>[.exe]` | Ein echtes eigenständiges Binary — kein Node.js erforderlich. Deckt macOS (arm64/x64), Linux (x64/arm64/armv7l — einschließlich Raspberry Pi) und Windows (x64) ab. |
+
+> **Unsignierte Builds.** Die Releases sind nicht code-signiert. Beim ersten Start verlangt macOS *Rechtsklick → Öffnen*, und der Windows SmartScreen verlangt *Weitere Informationen → Trotzdem ausführen*.
+
+## CLI-Nutzung
+
+```bash
+npx artnet2usb-cli                 # no args → interactive terminal wizard
+artnet2usb-cli --help              # full command reference
+```
+
+| Befehl | Was er tut |
+|---|---|
+| `configure` | Interaktiver Assistent zum Hinzufügen/Entfernen von Routen und optional zum Starten der Bridge. |
+| `auto` | Erkennt automatisch ein einzelnes Art-Net-Universum und USB-Gerät, speichert die Route und startet sie (`--no-start`, um den Start zu überspringen). |
+| `run` | Startet die Bridge mit den gespeicherten Routen und läuft, bis sie gestoppt wird (`Ctrl+C`). |
+| `route add` / `route list` / `route remove <id>` | Verwaltet Routen nicht-interaktiv — skriptfähig aus einem Shell-Skript oder einem Ansible-Playbook heraus. |
+| `list-ports` | Listet angeschlossene USB-Seriell-Geräte auf. |
+| `list-nodes` | Lauscht im Netzwerk nach Art-Net-Nodes (~3 s) und listet sie auf. |
+| `doctor` | Meldet getrennte Geräte, widersprüchliche Routen und Einstellungen außerhalb des gültigen Bereichs in der gespeicherten Konfiguration. |
+| `install-service` / `uninstall-service` | Erzeugt (und gibt aus, wendet aber nie stillschweigend an) eine systemd-Unit (Linux) oder einen launchd-Agent (macOS), damit die Bridge nach einem Neustart oder Absturz automatisch wieder startet. |
+
+Ein-Befehl-Headless-Einrichtung auf einem Rechner mit genau einem Art-Net-Universum und einem USB-DMX-Interface:
+
+```bash
+artnet2usb-cli auto --protocol enttec-pro --hz 40
+```
+
+Jeder Befehl akzeptiert `--config <dir>`, um ein bestimmtes Konfigurationsverzeichnis anzugeben, und `run`/`auto` akzeptieren `--json`, um newline-delimited JSON-Status statt menschenlesbarem Text auszugeben (praktisch, um den Prozess aus einem anderen Skript heraus zu überwachen).
+
+## Portable Konfiguration
+
+Die App sucht zuerst neben der ausführbaren Datei nach `config.json`, damit sie auf einem USB-Stick zwischen Rechnern wandern kann. Ist dieses Verzeichnis nicht beschreibbar (z. B. wegen Gatekeepers „App-Translokation" bei einer unsignierten macOS-App), weicht sie auf das für das Betriebssystem übliche, benutzerbezogene Konfigurationsverzeichnis aus. GUI und CLI teilen sich dieselbe `config.json`, wenn sie aus demselben Ordner heraus ausgeführt werden — legen Sie Routen visuell an und führen Sie sie dann headless aus, oder umgekehrt.
+
+## Aus dem Quellcode erstellen
+
+```bash
+npm install
+npm run dev             # GUI, electron-vite dev server
+npm test                # unit tests (parser, framing, device uid, config)
+npm run typecheck       # tsc --noEmit
+npm run dist             # package the GUI for the host platform (electron-builder)
+npm run dev:cli          # run the CLI from source (tsx)
+npm run build:cli        # compile the CLI to dist-cli/
+```
+
+### Eigenständige Single-File-Builds
+
+Alle eigenständigen Build-Ergebnisse landen in `dist-standalone/`; jedes Artefakt ist eine einzelne Datei ohne Installation:
+
+```bash
+npm run dist:standalone                                   # host platform: GUI + CLI
+node scripts/build-standalone.mjs --cli --all-targets     # CLI: every platform in one pass
+node scripts/build-standalone.mjs --gui --mac --win       # GUI: selected platforms only
+```
+
+Die CLI wird mit `esbuild` gebündelt und mit [`@yao-pkg/pkg`](https://github.com/yao-pkg/pkg) zu echten Binärdateien gepackt (zum Ausführen ist kein Node.js nötig); die GUI wird mit `electron-builder` gepackt.
+
+## Architektur
+
+```
+app/                      Electron main process
+  artnet.ts                Art-Net listener/parser — no external protocol library, hand-rolled to spec
+  dmxOutput.ts              output engine + protocol drivers (Enttec Pro, Open DMX), via `serialport`
+  store.ts                  device names / routes / settings, portable-config-first
+  main.ts, preload.ts       Electron app lifecycle + the IPC bridge exposed to the renderer
+
+cli/                       Headless CLI (compiles separately, see tsconfig.cli.json)
+  index.ts                  command definitions (commander) + the interactive wizard (@clack/prompts)
+  bridge.ts, autoRoute.ts    shared bridge start-up and single-universe/device auto-pick logic
+  routeCommands.ts           `route add/list/remove` — scriptable route management
+  serviceInstall.ts          systemd/launchd unit generation
+  doctor.ts, configDir.ts    config health checks + config-directory resolution
+
+shared/                    Code shared between the GUI and the CLI
+  types.ts                  RouteConfig, UsbDevice, and the rest of the shared type surface
+  store.ts, portableConfig.ts   the config file itself + the portable-vs-per-user directory rule
+
+scripts/build-standalone.mjs   the single-file distribution pipeline (esbuild + @yao-pkg/pkg + electron-builder)
+scripts/embed-win-resources.mjs   embeds an icon + version metadata into the Windows CLI .exe (via resedit)
+src/                       React + Tailwind renderer (GUI), including src/locales/ for the 5 supported languages
+```
+
+## Mitwirken
+
+Issues und Pull Requests sind willkommen. Bevor Sie einen PR öffnen, stellen Sie bitte sicher, dass sowohl `npm test` als auch `npm run typecheck` erfolgreich durchlaufen.
+
+## Lizenz
+
+[MIT](LICENSE) © Remana
+
+---
+
+<div align="center">
+
+Teil des [Relackout](https://relackout.com) Lichtsteuerungs-Ökosystems.
+
+</div>

package/README.es.md

@@ -0,0 +1,149 @@
+<div align="center">
+
+<img src="src/public/logo.svg" alt="Relackout ArtNet 2 USB" width="96" height="96">
+
+# Relackout ArtNet 2 USB
+
+**Un puente Art-Net → USB DMX gratuito y enfocado, con una interfaz gráfica de escritorio y una CLI sin interfaz.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Platforms](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-informational)](#download)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](package.json)
+
+[Descarga](https://relackout.com/usb-dmx) · [Uso de la CLI](#cli-usage) · [Compilar desde el código fuente](#building-from-source) · [Arquitectura](#architecture)
+
+[English](README.md) · [Türkçe](README.tr.md) · [Deutsch](README.de.md) · **Español** · [Français](README.fr.md) · [Italiano](README.it.md) · [Português](README.pt-BR.md) · [Русский](README.ru.md) · [简体中文](README.zh-Hans.md) · [日本語](README.ja.md)
+
+</div>
+
+---
+
+## ¿Qué es esto?
+
+La mayoría del software de iluminación se comunica mediante **Art-Net** a través de la red, pero muchas interfaces USB DMX — la DMX USB Pro de Enttec (y sus compatibles), o los adaptadores genéricos Open DMX / FTDI — todavía necesitan algo en el escritorio que reciba esa señal de red y la envíe por USB.
+
+**Relackout ArtNet 2 USB** es exactamente eso: un puente pequeño y enfocado que mantienes ejecutándose en segundo plano. No cuesta nada, no requiere ninguna cuenta, y está diseñado para facilitar el trabajo con todo el ecosistema Art-Net, incluyendo consolas y software que no son de [Relackout](https://relackout.com).
+
+Se distribuye de dos maneras:
+- **Una interfaz gráfica de escritorio** — descubrimiento automático, una vista previa en vivo de 512 canales y una tabla de enrutamiento visual.
+- **Una CLI sin interfaz** (`artnet2usb-cli`) — exactamente el mismo motor de enrutamiento, sin interfaz gráfica, pensada para una Raspberry Pi detrás de una estructura de truss, un servidor de backstage sin monitor, o para automatizar todo un montaje antes de un espectáculo. Ambas leen y escriben el **mismo archivo de configuración**, así que puedes crear las rutas en la interfaz gráfica y ejecutarlas sin interfaz, o al revés.
+
+## Características
+
+- **Descubrimiento automático** — escucha de forma pasiva en el puerto UDP 6454 y lista cada universo Art-Net que se transmite en la red, con la IP de origen y una lectura en vivo de la tasa de fotogramas; el escaneo de nodos `ArtPoll`/`ArtPollReply` encuentra dispositivos que todavía no transmiten DMX.
+- **Vista previa de canales en vivo** — observa cómo se actualizan en tiempo real los 512 canales de cualquier universo detectado, antes de enrutar nada.
+- **Tabla de enrutamiento visual** — cada fila es una regla: universo Art-Net → dispositivo USB + protocolo + frecuencia de actualización (1–44 Hz).
+- **Dos protocolos** — Enttec DMX USB Pro (y sus clones compatibles a nivel de firmware) y salida Open DMX / FTDI en bruto.
+- **Identidad persistente del dispositivo** — las interfaces USB se recuerdan por su identidad de hardware (ID de proveedor, ID de producto, número de serie), no por la ruta de puerto del sistema operativo. Renombra un dispositivo una sola vez, y ese nombre y sus rutas sobreviven a que se desconecte y se conecte a un puerto distinto.
+- **Desplazamiento de parche de canales** — compensa la dirección de inicio DMX propia de un fixture o una numeración de canales distinta en una consola, por ruta (`-511..511`). El universo se desplaza de forma **circular** dentro de sus 512 canales — no se pierde ningún dato de canal, simplemente da la vuelta.
+- **Comportamiento ante pérdida de señal** — elige si la salida mantiene el último fotograma o se apaga (blackout) cuando la fuente Art-Net desaparece.
+- **Configuración portátil** — se ejecuta desde una memoria USB sin necesidad de instalación; consulta [Configuración portátil](#portable-config) más abajo.
+- **5 idiomas en la interfaz gráfica** — English, Deutsch, Français, Italiano, Türkçe.
+
+## Descarga
+
+Los binarios precompilados, de un solo archivo y sin instalador para Windows, macOS y Linux (incluyendo Raspberry Pi para la CLI) están disponibles en **[relackout.com/usb-dmx](https://relackout.com/usb-dmx)** y en la página de [GitHub Releases](../../releases).
+
+| | Archivo | Notas |
+|---|---|---|
+| GUI · Windows | `Relackout-ArtNet2USB-<ver>-portable.exe` | Portátil — sin instalador, solo ejecútalo. |
+| GUI · macOS | `Relackout-ArtNet2USB-<ver>-<arch>.dmg` | Arrastrar y soltar, sin instalador. |
+| GUI · Linux | `Relackout-ArtNet2USB-<ver>-<arch>.AppImage` | `chmod +x` y ejecútalo. |
+| CLI · todas las plataformas | `artnet2usb-cli-<ver>-<platform>[.exe]` | Un binario independiente real — no requiere Node.js. Cubre macOS (arm64/x64), Linux (x64/arm64/armv7l — incluyendo Raspberry Pi) y Windows (x64). |
+
+> **Compilaciones sin firmar.** Las versiones publicadas no están firmadas digitalmente. En el primer inicio, macOS requiere *clic derecho → Abrir*, y Windows SmartScreen requiere *Más información → Ejecutar de todos modos*.
+
+## Uso de la CLI
+
+```bash
+npx artnet2usb-cli                 # sin argumentos → asistente de terminal interactivo
+artnet2usb-cli --help              # referencia completa de comandos
+```
+
+| Comando | Qué hace |
+|---|---|
+| `configure` | Asistente interactivo para añadir/eliminar rutas y, opcionalmente, iniciar el puente. |
+| `auto` | Detecta automáticamente un único universo Art-Net y un dispositivo USB, guarda la ruta y la inicia (`--no-start` para omitir el inicio). |
+| `run` | Inicia el puente usando las rutas guardadas y se ejecuta hasta que se detenga (`Ctrl+C`). |
+| `route add` / `route list` / `route remove <id>` | Gestiona las rutas de forma no interactiva — apto para automatizar desde un script de shell o un playbook de Ansible. |
+| `list-ports` | Lista los dispositivos serie USB conectados. |
+| `list-nodes` | Escucha los nodos Art-Net en la red (~3 s) y los lista. |
+| `doctor` | Detecta dispositivos desconectados, rutas en conflicto y ajustes fuera de rango en la configuración guardada. |
+| `install-service` / `uninstall-service` | Genera (e imprime, nunca aplica silenciosamente) una unidad systemd (Linux) o un agente launchd (macOS) para que el puente se reinicie automáticamente tras un reinicio o un fallo. |
+
+Configuración sin interfaz en un solo comando, en una máquina con exactamente un universo Art-Net y una interfaz USB DMX:
+
+```bash
+artnet2usb-cli auto --protocol enttec-pro --hz 40
+```
+
+Todos los comandos aceptan `--config <dir>` para apuntar a un directorio de configuración específico, y `run`/`auto` aceptan `--json` para emitir el estado como JSON delimitado por saltos de línea en lugar de texto legible por personas (útil para supervisar el proceso desde otro script).
+
+## Configuración portátil
+
+La aplicación busca primero `config.json` junto al ejecutable, para poder llevarla en una memoria USB de una máquina a otra. Si ese directorio no es escribible (por ejemplo, por la "app translocation" de Gatekeeper en una app de macOS sin firmar), recurre al directorio de configuración por usuario estándar del sistema operativo. La interfaz gráfica y la CLI comparten exactamente el mismo `config.json` cuando se ejecutan desde la misma carpeta — crea las rutas de forma visual y luego ejecútalas sin interfaz, o viceversa.
+
+## Compilar desde el código fuente
+
+```bash
+npm install
+npm run dev             # GUI, servidor de desarrollo electron-vite
+npm test                # pruebas unitarias (parser, framing, device uid, config)
+npm run typecheck       # tsc --noEmit
+npm run dist             # empaqueta la GUI para la plataforma local (electron-builder)
+npm run dev:cli          # ejecuta la CLI desde el código fuente (tsx)
+npm run build:cli        # compila la CLI en dist-cli/
+```
+
+### Compilaciones independientes de un solo archivo
+
+Toda la salida independiente se genera en `dist-standalone/`; cada artefacto es un único archivo sin nada que instalar:
+
+```bash
+npm run dist:standalone                                   # plataforma local: GUI + CLI
+node scripts/build-standalone.mjs --cli --all-targets     # CLI: todas las plataformas en una sola pasada
+node scripts/build-standalone.mjs --gui --mac --win       # GUI: solo las plataformas seleccionadas
+```
+
+La CLI se empaqueta con `esbuild` y se convierte en binarios reales con [`@yao-pkg/pkg`](https://github.com/yao-pkg/pkg) (no se necesita Node.js para ejecutarlos); la GUI se empaqueta con `electron-builder`.
+
+## Arquitectura
+
+```
+app/                      Proceso principal de Electron
+  artnet.ts                Listener/parser de Art-Net — sin librería de protocolo externa, hecho a mano según la especificación
+  dmxOutput.ts              motor de salida + drivers de protocolo (Enttec Pro, Open DMX), vía `serialport`
+  store.ts                  nombres de dispositivos / rutas / ajustes, con prioridad a la configuración portátil
+  main.ts, preload.ts       ciclo de vida de la app Electron + el puente IPC expuesto al renderer
+
+cli/                       CLI sin interfaz (se compila por separado, ver tsconfig.cli.json)
+  index.ts                  definiciones de comandos (commander) + el asistente interactivo (@clack/prompts)
+  bridge.ts, autoRoute.ts    arranque compartido del puente y lógica de selección automática de universo/dispositivo único
+  routeCommands.ts           `route add/list/remove` — gestión de rutas automatizable
+  serviceInstall.ts          generación de unidades systemd/launchd
+  doctor.ts, configDir.ts    comprobaciones de salud de la configuración + resolución del directorio de configuración
+
+shared/                    Código compartido entre la GUI y la CLI
+  types.ts                  RouteConfig, UsbDevice, y el resto de la superficie de tipos compartida
+  store.ts, portableConfig.ts   el propio archivo de configuración + la regla de directorio portátil frente a por usuario
+
+scripts/build-standalone.mjs   el pipeline de distribución de archivo único (esbuild + @yao-pkg/pkg + electron-builder)
+scripts/embed-win-resources.mjs   incrusta un icono + metadatos de versión en el .exe de la CLI de Windows (mediante resedit)
+src/                       Renderer de la GUI en React + Tailwind, incluyendo src/locales/ para los 5 idiomas soportados
+```
+
+## Contribuir
+
+Los issues y pull requests son bienvenidos. Antes de abrir un PR, asegúrate de que `npm test` y `npm run typecheck` pasen correctamente.
+
+## Licencia
+
+[MIT](LICENSE) © Remana
+
+---
+
+<div align="center">
+
+Parte del ecosistema de control de iluminación [Relackout](https://relackout.com).
+
+</div>

package/README.fr.md

@@ -0,0 +1,149 @@
+<div align="center">
+
+<img src="src/public/logo.svg" alt="Relackout ArtNet 2 USB" width="96" height="96">
+
+# Relackout ArtNet 2 USB
+
+**Un pont Art-Net → USB DMX gratuit et ciblé, avec une interface graphique de bureau et une CLI sans interface.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Platforms](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-informational)](#download)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](package.json)
+
+[Téléchargement](https://relackout.com/usb-dmx) · [Utilisation de la CLI](#cli-usage) · [Compilation depuis les sources](#building-from-source) · [Architecture](#architecture)
+
+[English](README.md) · [Türkçe](README.tr.md) · [Deutsch](README.de.md) · [Español](README.es.md) · **Français** · [Italiano](README.it.md) · [Português](README.pt-BR.md) · [Русский](README.ru.md) · [简体中文](README.zh-Hans.md) · [日本語](README.ja.md)
+
+</div>
+
+---
+
+## Qu'est-ce que c'est ?
+
+La plupart des logiciels d'éclairage communiquent en **Art-Net** sur le réseau, mais de nombreuses interfaces USB DMX — le DMX USB Pro d'Enttec (et ses compatibles), les dongles génériques Open DMX / FTDI — ont encore besoin d'un appareil sur le bureau pour recevoir ce signal réseau et le renvoyer en USB.
+
+**Relackout ArtNet 2 USB** est exactement cela : un petit pont ciblé que vous laissez tourner en arrière-plan. Il ne coûte rien, ne nécessite aucun compte, et a été conçu pour faciliter le travail avec tout l'écosystème Art-Net — y compris les consoles et logiciels qui ne sont pas [Relackout](https://relackout.com).
+
+Il est disponible sous deux formes :
+- **Une interface graphique de bureau** — découverte automatique, aperçu en direct des 512 canaux et table de routage visuelle.
+- **Une CLI sans interface** (`artnet2usb-cli`) — exactement le même moteur de routage, sans aucune interface, conçue pour un Raspberry Pi caché derrière un pont, un serveur en coulisses sans écran, ou pour scripter l'intégralité d'une installation avant un spectacle. Les deux lisent et écrivent le **même fichier de configuration**, ce qui permet de construire des routes dans l'interface graphique et de les exécuter en mode sans interface, ou inversement.
+
+## Fonctionnalités
+
+- **Découverte automatique** — écoute passivement le port UDP 6454 et liste chaque univers Art-Net diffusé sur le réseau, avec l'IP source et un débit d'images en direct ; le balayage de nœuds `ArtPoll`/`ArtPollReply` détecte les appareils qui ne diffusent pas encore de DMX.
+- **Aperçu des canaux en direct** — observez la mise à jour en temps réel des 512 canaux de n'importe quel univers découvert, avant même de router quoi que ce soit.
+- **Table de routage visuelle** — chaque ligne est une règle : univers Art-Net → appareil USB + protocole + fréquence de rafraîchissement (1 à 44 Hz).
+- **Deux protocoles** — Enttec DMX USB Pro (et ses clones compatibles au niveau du firmware) et sortie brute Open DMX / FTDI.
+- **Identité persistante des appareils** — les interfaces USB sont mémorisées par leur identité matérielle (identifiant fournisseur, identifiant produit, numéro de série), et non par leur chemin de port système. Renommez un appareil une seule fois : le nom et ses routes survivent au débranchement et au déplacement vers un autre port.
+- **Décalage de patch de canaux** — compense l'adresse de départ DMX propre à un projecteur ou une numérotation de canaux différente sur une console, par route (`-511..511`). L'univers est décalé **circulairement** au sein de ses 512 canaux — aucune donnée de canal n'est jamais perdue, elle boucle simplement.
+- **Comportement en cas de perte de signal** — choisissez si la sortie conserve la dernière image ou passe au noir lorsque la source Art-Net disparaît.
+- **Configuration portable** — s'exécute depuis une clé USB sans aucune installation ; voir [Configuration portable](#portable-config) ci-dessous.
+- **5 langues dans l'interface graphique** — English, Deutsch, Français, Italiano, Türkçe.
+
+## Téléchargement
+
+Des binaires précompilés, en fichier unique et sans installateur, pour Windows, macOS et Linux (y compris Raspberry Pi pour la CLI) sont disponibles sur **[relackout.com/usb-dmx](https://relackout.com/usb-dmx)** et sur la page des [Releases GitHub](../../releases).
+
+| | Fichier | Remarques |
+|---|---|---|
+| GUI · Windows | `Relackout-ArtNet2USB-<ver>-portable.exe` | Portable — aucun installateur, il suffit de l'exécuter. |
+| GUI · macOS | `Relackout-ArtNet2USB-<ver>-<arch>.dmg` | Glisser-déposer, aucun installateur. |
+| GUI · Linux | `Relackout-ArtNet2USB-<ver>-<arch>.AppImage` | `chmod +x` puis exécuter. |
+| CLI · toutes plateformes | `artnet2usb-cli-<ver>-<platform>[.exe]` | Un véritable binaire autonome — Node.js n'est pas requis. Couvre macOS (arm64/x64), Linux (x64/arm64/armv7l — y compris Raspberry Pi) et Windows (x64). |
+
+> **Binaires non signés.** Les versions publiées ne sont pas signées. Au premier lancement, macOS nécessite un *clic droit → Ouvrir*, et Windows SmartScreen nécessite *Informations complémentaires → Exécuter quand même*.
+
+## Utilisation de la CLI
+
+```bash
+npx artnet2usb-cli                 # no args → interactive terminal wizard
+artnet2usb-cli --help              # full command reference
+```
+
+| Commande | Ce qu'elle fait |
+|---|---|
+| `configure` | Assistant interactif pour ajouter/supprimer des routes et démarrer le pont si besoin. |
+| `auto` | Détecte automatiquement un univers Art-Net et un appareil USB uniques, enregistre la route et la démarre (`--no-start` pour ne pas la démarrer). |
+| `run` | Démarre le pont à partir des routes enregistrées et l'exécute jusqu'à l'arrêt (`Ctrl+C`). |
+| `route add` / `route list` / `route remove <id>` | Gère les routes de façon non interactive — scriptable depuis un script shell ou un playbook Ansible. |
+| `list-ports` | Liste les appareils série USB connectés. |
+| `list-nodes` | Écoute les nœuds Art-Net sur le réseau (~3 s) et les liste. |
+| `doctor` | Signale les appareils déconnectés, les routes en conflit et les réglages hors limites dans la configuration enregistrée. |
+| `install-service` / `uninstall-service` | Génère (et affiche, sans jamais l'appliquer silencieusement) une unité systemd (Linux) ou un agent launchd (macOS) afin que le pont redémarre automatiquement après un redémarrage ou un plantage. |
+
+Configuration sans interface en une seule commande sur une machine disposant d'exactement un univers Art-Net et une interface USB DMX :
+
+```bash
+artnet2usb-cli auto --protocol enttec-pro --hz 40
+```
+
+Chaque commande accepte `--config <dir>` pour pointer vers un répertoire de configuration spécifique, et `run`/`auto` acceptent `--json` pour émettre un statut au format JSON délimité par des retours à la ligne plutôt qu'un texte lisible par un humain (pratique pour superviser le processus depuis un autre script).
+
+## Configuration portable
+
+L'application recherche d'abord `config.json` à côté de l'exécutable, afin de pouvoir voyager sur une clé USB entre plusieurs machines. Si ce répertoire n'est pas accessible en écriture (par exemple à cause de la « translocation d'application » de Gatekeeper pour une app macOS non signée), elle se rabat sur le répertoire de configuration standard par utilisateur du système d'exploitation. L'interface graphique et la CLI partagent exactement le même `config.json` lorsqu'elles sont exécutées depuis le même dossier — construisez des routes visuellement, puis exécutez-les sans interface, ou inversement.
+
+## Compilation depuis les sources
+
+```bash
+npm install
+npm run dev             # GUI, electron-vite dev server
+npm test                # unit tests (parser, framing, device uid, config)
+npm run typecheck       # tsc --noEmit
+npm run dist             # package the GUI for the host platform (electron-builder)
+npm run dev:cli          # run the CLI from source (tsx)
+npm run build:cli        # compile the CLI to dist-cli/
+```
+
+### Compilations autonomes, fichier unique
+
+Toutes les sorties autonomes sont générées dans `dist-standalone/` ; chaque artefact est un fichier unique, sans rien à installer :
+
+```bash
+npm run dist:standalone                                   # host platform: GUI + CLI
+node scripts/build-standalone.mjs --cli --all-targets     # CLI: every platform in one pass
+node scripts/build-standalone.mjs --gui --mac --win       # GUI: selected platforms only
+```
+
+La CLI est empaquetée avec `esbuild` puis transformée en véritables binaires avec [`@yao-pkg/pkg`](https://github.com/yao-pkg/pkg) (aucun Node.js requis pour les exécuter) ; l'interface graphique est empaquetée avec `electron-builder`.
+
+## Architecture
+
+```
+app/                      Electron main process
+  artnet.ts                Art-Net listener/parser — no external protocol library, hand-rolled to spec
+  dmxOutput.ts              output engine + protocol drivers (Enttec Pro, Open DMX), via `serialport`
+  store.ts                  device names / routes / settings, portable-config-first
+  main.ts, preload.ts       Electron app lifecycle + the IPC bridge exposed to the renderer
+
+cli/                       Headless CLI (compiles separately, see tsconfig.cli.json)
+  index.ts                  command definitions (commander) + the interactive wizard (@clack/prompts)
+  bridge.ts, autoRoute.ts    shared bridge start-up and single-universe/device auto-pick logic
+  routeCommands.ts           `route add/list/remove` — scriptable route management
+  serviceInstall.ts          systemd/launchd unit generation
+  doctor.ts, configDir.ts    config health checks + config-directory resolution
+
+shared/                    Code shared between the GUI and the CLI
+  types.ts                  RouteConfig, UsbDevice, and the rest of the shared type surface
+  store.ts, portableConfig.ts   the config file itself + the portable-vs-per-user directory rule
+
+scripts/build-standalone.mjs   the single-file distribution pipeline (esbuild + @yao-pkg/pkg + electron-builder)
+scripts/embed-win-resources.mjs   embeds an icon + version metadata into the Windows CLI .exe (via resedit)
+src/                       React + Tailwind renderer (GUI), including src/locales/ for the 5 supported languages
+```
+
+## Contribution
+
+Les issues et les pull requests sont les bienvenues. Avant d'ouvrir une PR, assurez-vous que `npm test` et `npm run typecheck` passent tous les deux.
+
+## Licence
+
+[MIT](LICENSE) © Remana
+
+---
+
+<div align="center">
+
+Fait partie de l'écosystème de contrôle d'éclairage [Relackout](https://relackout.com).
+
+</div>

package/README.it.md

@@ -0,0 +1,149 @@
+<div align="center">
+
+<img src="src/public/logo.svg" alt="Relackout ArtNet 2 USB" width="96" height="96">
+
+# Relackout ArtNet 2 USB
+
+**Un bridge Art-Net → USB DMX gratuito e mirato, con GUI desktop e CLI headless.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Platforms](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-informational)](#download)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](package.json)
+
+[Download](https://relackout.com/usb-dmx) · [Uso della CLI](#cli-usage) · [Compilazione dai sorgenti](#building-from-source) · [Architettura](#architecture)
+
+[English](README.md) · [Türkçe](README.tr.md) · [Deutsch](README.de.md) · [Español](README.es.md) · [Français](README.fr.md) · **Italiano** · [Português](README.pt-BR.md) · [Русский](README.ru.md) · [简体中文](README.zh-Hans.md) · [日本語](README.ja.md)
+
+</div>
+
+---
+
+## Cos'è
+
+La maggior parte dei software di illuminazione parla **Art-Net** in rete, ma molte interfacce USB DMX — il DMX USB Pro di Enttec (e i suoi compatibili), i dongle generici Open DMX / FTDI — hanno ancora bisogno di qualcosa sulla scrivania che riceva quel segnale di rete e lo inoltri via USB.
+
+**Relackout ArtNet 2 USB** è esattamente questo: un bridge piccolo e mirato che tieni in esecuzione in background. Non costa nulla, non richiede un account, ed è pensato per rendere l'intero ecosistema Art-Net più semplice da usare — comprese le console e i software che non sono [Relackout](https://relackout.com).
+
+Viene distribuito in due modalità:
+- **Una GUI desktop** — auto-discovery, un'anteprima live a 512 canali e una tabella di routing visuale.
+- **Una CLI headless** (`artnet2usb-cli`) — lo stesso identico motore di routing, senza interfaccia grafica, pensata per un Raspberry Pi dietro un traliccio, un server backstage senza monitor, o per scriptare un intero rig prima di uno spettacolo. Entrambe leggono e scrivono lo **stesso file di configurazione**, quindi puoi costruire i routing nella GUI ed eseguirli in headless, o viceversa.
+
+## Funzionalità
+
+- **Auto-discovery** — resta in ascolto passivo su UDP 6454 ed elenca ogni universo Art-Net trasmesso sulla rete, con IP sorgente e frame-rate letto in tempo reale; la scansione dei nodi `ArtPoll`/`ArtPollReply` individua anche i dispositivi che non trasmettono ancora DMX.
+- **Anteprima live dei canali** — osserva in tempo reale tutti i 512 canali di qualsiasi universo rilevato, prima ancora di configurare un routing.
+- **Tabella di routing visuale** — ogni riga è una regola: universo Art-Net → dispositivo USB + protocollo + frequenza di aggiornamento (1–44 Hz).
+- **Due protocolli** — Enttec DMX USB Pro (e i cloni compatibili a livello firmware) e output Open DMX / FTDI grezzo.
+- **Identità persistente del dispositivo** — le interfacce USB vengono riconosciute dalla loro identità hardware (vendor ID, product ID, numero di serie), non dal percorso della porta del sistema operativo. Rinomina un dispositivo una sola volta: il nome e i suoi routing sopravvivono anche se viene scollegato e spostato su un'altra porta.
+- **Offset di patch dei canali** — compensa l'indirizzo DMX iniziale di un fixture o una numerazione dei canali diversa su una console, per ogni singolo routing (`-511..511`). L'universo viene spostato in modo **circolare** all'interno dei suoi 512 canali — nessun dato di canale viene mai perso, semplicemente ricomincia dall'altro capo.
+- **Comportamento in caso di perdita del segnale** — scegli se l'output mantiene l'ultimo frame oppure va a nero quando la sorgente Art-Net scompare.
+- **Configurazione portatile** — funziona da una chiavetta USB senza alcuna installazione; vedi [Configurazione portatile](#portable-config) più sotto.
+- **5 lingue nella GUI** — English, Deutsch, Français, Italiano, Türkçe.
+
+## Download
+
+Binari precompilati, a file singolo e senza installer per Windows, macOS e Linux (incluso Raspberry Pi per la CLI) sono disponibili su **[relackout.com/usb-dmx](https://relackout.com/usb-dmx)** e nella pagina [GitHub Releases](../../releases).
+
+| | File | Note |
+|---|---|---|
+| GUI · Windows | `Relackout-ArtNet2USB-<ver>-portable.exe` | Portabile — nessun installer, basta eseguirlo. |
+| GUI · macOS | `Relackout-ArtNet2USB-<ver>-<arch>.dmg` | Trascina e rilascia, nessun installer. |
+| GUI · Linux | `Relackout-ArtNet2USB-<ver>-<arch>.AppImage` | `chmod +x` ed esegui. |
+| CLI · tutte le piattaforme | `artnet2usb-cli-<ver>-<platform>[.exe]` | Un vero binario standalone — non serve Node.js. Copre macOS (arm64/x64), Linux (x64/arm64/armv7l — incluso Raspberry Pi) e Windows (x64). |
+
+> **Build non firmate.** Le release non sono firmate digitalmente. Al primo avvio, macOS richiede *tasto destro → Apri*, mentre Windows SmartScreen richiede *Ulteriori informazioni → Esegui comunque*.
+
+## Uso della CLI
+
+```bash
+npx artnet2usb-cli                 # nessun argomento → wizard interattivo da terminale
+artnet2usb-cli --help              # riferimento completo dei comandi
+```
+
+| Comando | Cosa fa |
+|---|---|
+| `configure` | Wizard interattivo per aggiungere/rimuovere routing e, facoltativamente, avviare il bridge. |
+| `auto` | Rileva automaticamente un singolo universo Art-Net e dispositivo USB, salva il routing e lo avvia (`--no-start` per non avviarlo). |
+| `run` | Avvia il bridge usando i routing salvati ed esegue finché non viene fermato (`Ctrl+C`). |
+| `route add` / `route list` / `route remove <id>` | Gestisce i routing in modo non interattivo — scriptabile da uno shell script o da un playbook Ansible. |
+| `list-ports` | Elenca i dispositivi seriali USB collegati. |
+| `list-nodes` | Resta in ascolto dei nodi Art-Net sulla rete (~3s) e li elenca. |
+| `doctor` | Segnala dispositivi scollegati, routing in conflitto e impostazioni fuori intervallo nella configurazione salvata. |
+| `install-service` / `uninstall-service` | Genera (e stampa a video, senza mai applicarla in silenzio) un'unità systemd (Linux) o un agente launchd (macOS) in modo che il bridge si riavvii automaticamente dopo un riavvio del sistema o un crash. |
+
+Configurazione headless in un solo comando su una macchina con esattamente un universo Art-Net e un'interfaccia USB DMX:
+
+```bash
+artnet2usb-cli auto --protocol enttec-pro --hz 40
+```
+
+Ogni comando accetta `--config <dir>` per puntare a una specifica directory di configurazione, e `run`/`auto` accettano `--json` per emettere lo stato come JSON delimitato da newline invece che come testo leggibile (comodo per supervisionare il processo da un altro script).
+
+## Configurazione portatile
+
+L'app cerca prima `config.json` accanto all'eseguibile, così può viaggiare su una chiavetta USB tra diverse macchine. Se quella directory non è scrivibile (ad esempio a causa della "app translocation" di Gatekeeper per un'app macOS non firmata), l'app ricade sulla directory di configurazione per-utente standard del sistema operativo. La GUI e la CLI condividono esattamente lo stesso `config.json` quando vengono eseguite dalla stessa cartella — costruisci i routing visualmente, poi eseguili in headless, o viceversa.
+
+## Compilazione dai sorgenti
+
+```bash
+npm install
+npm run dev             # GUI, electron-vite dev server
+npm test                # test unitari (parser, framing, device uid, config)
+npm run typecheck       # tsc --noEmit
+npm run dist             # pacchettizza la GUI per la piattaforma host (electron-builder)
+npm run dev:cli          # esegue la CLI dai sorgenti (tsx)
+npm run build:cli        # compila la CLI in dist-cli/
+```
+
+### Build standalone a file singolo
+
+Tutti gli output standalone finiscono in `dist-standalone/`; ogni artefatto è un unico file, senza nulla da installare:
+
+```bash
+npm run dist:standalone                                   # piattaforma host: GUI + CLI
+node scripts/build-standalone.mjs --cli --all-targets     # CLI: ogni piattaforma in un solo passaggio
+node scripts/build-standalone.mjs --gui --mac --win       # GUI: solo le piattaforme selezionate
+```
+
+La CLI viene impacchettata con `esbuild` e trasformata in binari veri e propri con [`@yao-pkg/pkg`](https://github.com/yao-pkg/pkg) (non serve Node.js per eseguirli); la GUI viene pacchettizzata con `electron-builder`.
+
+## Architettura
+
+```
+app/                      Processo main di Electron
+  artnet.ts                Listener/parser Art-Net — nessuna libreria di protocollo esterna, scritto a mano seguendo la spec
+  dmxOutput.ts              motore di output + driver di protocollo (Enttec Pro, Open DMX), tramite `serialport`
+  store.ts                  nomi dispositivi / routing / impostazioni, con priorità alla configurazione portatile
+  main.ts, preload.ts       ciclo di vita dell'app Electron + il bridge IPC esposto al renderer
+
+cli/                       CLI headless (compilata separatamente, vedi tsconfig.cli.json)
+  index.ts                  definizioni dei comandi (commander) + wizard interattivo (@clack/prompts)
+  bridge.ts, autoRoute.ts    logica condivisa di avvio del bridge e di auto-selezione singolo universo/dispositivo
+  routeCommands.ts           `route add/list/remove` — gestione scriptabile dei routing
+  serviceInstall.ts          generazione dell'unità systemd/launchd
+  doctor.ts, configDir.ts    controlli di salute della configurazione + risoluzione della directory di configurazione
+
+shared/                    Codice condiviso tra GUI e CLI
+  types.ts                  RouteConfig, UsbDevice, e il resto della superficie dei tipi condivisi
+  store.ts, portableConfig.ts   il file di configurazione stesso + la regola portatile-vs-per-utente per la directory
+
+scripts/build-standalone.mjs   la pipeline di distribuzione a file singolo (esbuild + @yao-pkg/pkg + electron-builder)
+scripts/embed-win-resources.mjs   incorpora un'icona + metadati di versione nell'.exe della CLI Windows (tramite resedit)
+src/                       Renderer React + Tailwind (GUI), incluso src/locales/ per le 5 lingue supportate
+```
+
+## Contribuire
+
+Issue e pull request sono benvenute. Prima di aprire una PR, assicurati che `npm test` e `npm run typecheck` passino entrambi.
+
+## Licenza
+
+[MIT](LICENSE) © Remana
+
+---
+
+<div align="center">
+
+Parte dell'ecosistema di controllo luci [Relackout](https://relackout.com).
+
+</div>