release

alice_plugin.py

@@ -0,0 +1,847 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import argparse
+import asyncio
+import html
+import ipaddress
+import json
+import os
+import platform
+import shutil
+import socket
+import subprocess
+import sys
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+from aiohttp import web
+
+import yastation
+
+BASE_DIR = Path(__file__).resolve().parent
+DATA_DIR = BASE_DIR / "data"
+LOXONE_DIR = BASE_DIR / "loxone"
+STATIONS_PATH = DATA_DIR / "stations.json"
+CONFIG_PATH = DATA_DIR / "config.json"
+TOKEN_PATH = BASE_DIR / "token.txt"
+
+YANDEX_INFO_URL = "https://api.iot.yandex.net/v1.0/user/info"
+
+
+@dataclass
+class StationRecord:
+    name: str
+    station_id: str
+    home: str
+    room: str
+    model: str
+    con_url: str
+    local_id: str
+
+    def selector(self) -> str:
+        host = ""
+        if self.con_url:
+            value = self.con_url.strip()
+            if not value.startswith("http://") and not value.startswith("https://"):
+                value = f"http://{value}"
+            try:
+                from urllib.parse import urlparse
+
+                host = (urlparse(value).hostname or "").strip()
+            except Exception:
+                host = ""
+        return host or self.local_id or self.station_id
+
+
+def ensure_dirs() -> None:
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    LOXONE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def safe_name(value: str, fallback: str) -> str:
+    out = "".join(ch if ch.isalnum() or ch in "._-" else "_" for ch in (value or "").strip())
+    out = out.strip("._-")
+    return out or fallback
+
+
+def load_json(path: Path, default: Any) -> Any:
+    if not path.exists():
+        return default
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def save_json(path: Path, payload: Any) -> None:
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def read_token(cli_token: str) -> str:
+    token = (cli_token or "").strip()
+    if token:
+        return token
+    env_token = os.environ.get("YANDEX_TOKEN", "").strip()
+    if env_token:
+        return env_token
+    if TOKEN_PATH.exists():
+        return TOKEN_PATH.read_text(encoding="utf-8").strip()
+    cfg = load_json(CONFIG_PATH, {})
+    return str(cfg.get("token") or "").strip()
+
+
+def save_token(token: str) -> None:
+    token = token.strip()
+    TOKEN_PATH.write_text(token + "\n", encoding="utf-8")
+    os.chmod(TOKEN_PATH, 0o600)
+    cfg = load_json(CONFIG_PATH, {})
+    cfg["token"] = token
+    save_json(CONFIG_PATH, cfg)
+
+
+def save_controller_host(host: str) -> None:
+    cfg = load_json(CONFIG_PATH, {})
+    cfg["controller_host"] = host.strip()
+    save_json(CONFIG_PATH, cfg)
+
+
+def _is_valid_local_ip(value: str) -> bool:
+    try:
+        ip = ipaddress.ip_address(value)
+    except Exception:
+        return False
+    return bool(ip.version == 4 and not ip.is_loopback and not ip.is_link_local and not ip.is_unspecified)
+
+
+def _is_loopback_host(value: str) -> bool:
+    host = (value or "").strip().lower()
+    if not host:
+        return False
+    if host == "localhost":
+        return True
+    return host.startswith("127.")
+
+
+def _detect_local_ip() -> str:
+    # Best-effort detection of the primary LAN address.
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.connect(("1.1.1.1", 80))
+            ip = str(s.getsockname()[0] or "").strip()
+            if _is_valid_local_ip(ip):
+                return ip
+    except Exception:
+        pass
+
+    try:
+        host = socket.gethostname()
+        for family, _, _, _, sockaddr in socket.getaddrinfo(host, None, socket.AF_INET):
+            if family != socket.AF_INET or not sockaddr:
+                continue
+            ip = str(sockaddr[0] or "").strip()
+            if _is_valid_local_ip(ip):
+                return ip
+    except Exception:
+        pass
+
+    try:
+        _, _, ips = socket.gethostbyname_ex(socket.gethostname())
+        for ip in ips:
+            if _is_valid_local_ip(str(ip).strip()):
+                return str(ip).strip()
+    except Exception:
+        pass
+
+    return "127.0.0.1"
+
+
+def detect_controller_host() -> str:
+    cfg = load_json(CONFIG_PATH, {})
+    cfg_host = str(cfg.get("controller_host") or "").strip()
+    if cfg_host and not _is_loopback_host(cfg_host):
+        return cfg_host
+    env_host = os.environ.get("ALICE_CONTROLLER_HOST", "").strip()
+    if env_host and not _is_loopback_host(env_host):
+        return env_host
+    return _detect_local_ip()
+
+
+def normalize_model(model: str) -> str:
+    value = (model or "").strip()
+    prefix = "devices.types.smart_speaker."
+    if value.lower().startswith(prefix):
+        return value[len(prefix) :]
+    return value
+
+
+async def fetch_cloud_stations(token: str) -> List[Dict[str, Any]]:
+    headers = {"Authorization": f"OAuth {token}"}
+    timeout = aiohttp.ClientTimeout(total=20)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        async with session.get(YANDEX_INFO_URL, headers=headers) as resp:
+            text = await resp.text()
+            if resp.status >= 400:
+                raise RuntimeError(f"Yandex API error {resp.status}: {text[:220]}")
+            try:
+                data = json.loads(text)
+            except Exception as exc:
+                raise RuntimeError(f"Bad Yandex API JSON: {exc}") from exc
+
+    homes: Dict[str, str] = {}
+    for home in data.get("homes") or []:
+        hid = str(home.get("id") or "").strip()
+        if hid:
+            homes[hid] = str(home.get("name") or "").strip()
+    for home in data.get("households") or []:
+        hid = str(home.get("id") or "").strip()
+        if hid and hid not in homes:
+            homes[hid] = str(home.get("name") or "").strip()
+
+    rooms: Dict[str, str] = {}
+    room_home: Dict[str, str] = {}
+    for room in data.get("rooms") or []:
+        rid = str(room.get("id") or "").strip()
+        if not rid:
+            continue
+        rooms[rid] = str(room.get("name") or "").strip()
+        home_id = str(room.get("home_id") or room.get("household_id") or room.get("household") or "").strip()
+        if home_id and home_id in homes:
+            room_home[rid] = homes[home_id]
+
+    def nrm_id(value: str) -> str:
+        return value.strip().lower()
+
+    def extract_match_ids(device: Dict[str, Any]) -> List[str]:
+        candidates = [
+            str(device.get("id") or ""),
+            str(device.get("device_id") or ""),
+            str(device.get("external_id") or ""),
+            str((device.get("quasar_info") or {}).get("device_id") or ""),
+            str((device.get("quasar_info") or {}).get("deviceId") or ""),
+            str((device.get("quasar_info") or {}).get("external_id") or ""),
+            str((device.get("quasar_info") or {}).get("serial") or ""),
+            str(device.get("serial") or ""),
+        ]
+        out: Dict[str, bool] = {}
+        for c in candidates:
+            n = nrm_id(c)
+            if n:
+                out[n] = True
+        return list(out.keys())
+
+    result: List[Dict[str, Any]] = []
+    for dev in data.get("devices") or []:
+        dtype = str(dev.get("type") or "").lower()
+        if "speaker" not in dtype and "smart_speaker" not in dtype:
+            continue
+        room_id = str(dev.get("room") or "").strip()
+        home_id = str(dev.get("home_id") or dev.get("household_id") or dev.get("household") or "").strip()
+        home_name = homes.get(home_id, room_home.get(room_id, ""))
+        result.append(
+            {
+                "name": str(dev.get("name") or "").strip(),
+                "id": str(dev.get("id") or "").strip(),
+                "home": home_name,
+                "room": rooms.get(room_id, ""),
+                "model": normalize_model(str(dev.get("model") or dev.get("type") or "")),
+                "_match_ids": extract_match_ids(dev),
+            }
+        )
+    return result
+
+
+async def discover_local(timeout: float = 3.0) -> List[Dict[str, str]]:
+    items = await yastation.discover(timeout)
+    out: List[Dict[str, str]] = []
+    for st in items:
+        out.append({"id": st.device_id, "name": st.name, "ip": st.host, "platform": st.platform})
+    return out
+
+
+def merge_cloud_with_local(cloud: List[Dict[str, Any]], local: List[Dict[str, str]]) -> List[StationRecord]:
+    def nrm(value: str) -> str:
+        return " ".join((value or "").split()).strip().lower()
+
+    local_by_id: Dict[str, Dict[str, str]] = {}
+    local_by_name: Dict[str, Dict[str, str]] = {}
+    local_name_count: Dict[str, int] = {}
+
+    for row in local:
+        lid = (row.get("id") or "").strip()
+        if lid:
+            local_by_id[lid.lower()] = row
+        name_key = nrm(row.get("name") or "")
+        if name_key:
+            local_name_count[name_key] = local_name_count.get(name_key, 0) + 1
+            local_by_name[name_key] = row
+
+    merged: List[StationRecord] = []
+    for st in cloud:
+        ip = ""
+        local_id = ""
+
+        for candidate in st.get("_match_ids") or []:
+            item = local_by_id.get(str(candidate).strip().lower())
+            if item:
+                ip = str(item.get("ip") or "").strip()
+                local_id = str(item.get("id") or "").strip()
+                break
+
+        if not ip:
+            name_key = nrm(str(st.get("name") or ""))
+            if name_key and local_name_count.get(name_key) == 1:
+                item = local_by_name.get(name_key) or {}
+                ip = str(item.get("ip") or "").strip()
+                local_id = str(item.get("id") or "").strip()
+
+        if not ip and len(local) == 1:
+            ip = str(local[0].get("ip") or "").strip()
+            local_id = str(local[0].get("id") or "").strip()
+
+        con_url = ip if ip else ""
+        merged.append(
+            StationRecord(
+                name=str(st.get("name") or "").strip(),
+                station_id=str(st.get("id") or "").strip(),
+                home=str(st.get("home") or "").strip(),
+                room=str(st.get("room") or "").strip(),
+                model=normalize_model(str(st.get("model") or "")),
+                con_url=con_url,
+                local_id=local_id,
+            )
+        )
+
+    return merged
+
+
+def serialize_stations(stations: List[StationRecord]) -> List[Dict[str, str]]:
+    return [
+        {
+            "name": s.name,
+            "id": s.station_id,
+            "home": s.home,
+            "room": s.room,
+            "model": s.model,
+            "con_url": s.con_url,
+            "ip": s.con_url,
+            "local_id": s.local_id,
+        }
+        for s in stations
+    ]
+
+
+def load_stations_records() -> List[StationRecord]:
+    rows = load_json(STATIONS_PATH, [])
+    out: List[StationRecord] = []
+    for row in rows:
+        out.append(
+            StationRecord(
+                name=str(row.get("name") or "").strip(),
+                station_id=str(row.get("id") or row.get("station_id") or "").strip(),
+                home=str(row.get("home") or "").strip(),
+                room=str(row.get("room") or "").strip(),
+                model=str(row.get("model") or "").strip(),
+                con_url=str(row.get("con_url") or row.get("ip") or "").strip(),
+                local_id=str(row.get("local_id") or "").strip(),
+            )
+        )
+    return [s for s in out if s.station_id]
+
+
+def build_vo_xml(controller_host: str, station_name: str, selector: str) -> str:
+    base = f"http://{controller_host}:9124"
+    from urllib.parse import quote
+
+    qs = quote(selector, safe="")
+
+    def mk(title: str, path: str, analog: bool = False) -> str:
+        analog_val = "true" if analog else "false"
+        return (
+            f'<VirtualOutCmd Title="{html.escape(title)}" Comment="" CmdOnMethod="GET" CmdOffMethod="GET" '
+            f'CmdOn="{html.escape(path)}" CmdOnHTTP="" CmdOnPost="" CmdOff="" CmdOffHTTP="" CmdOffPost="" '
+            f'CmdAnswer="" HintText="" Analog="{analog_val}" Repeat="0" RepeatRate="0"/>'
+        )
+
+    rows = [
+        mk("TTS", f"/api/exec?action=tts&station={qs}&text=<v>&volume=35", True),
+        mk("Command", f"/api/exec?action=command&station={qs}&text=<v>", True),
+        mk("Play", f"/api/exec?action=player&station={qs}&cmd=play"),
+        mk("Pause", f"/api/exec?action=player&station={qs}&cmd=pause"),
+        mk("Stop", f"/api/exec?action=player&station={qs}&cmd=stop"),
+        mk("Next", f"/api/exec?action=player&station={qs}&cmd=next"),
+        mk("Prev", f"/api/exec?action=player&station={qs}&cmd=prev"),
+        mk("Volume", f"/api/exec?action=volume&station={qs}&level=<v>", True),
+        mk("Raw", f"/api/exec?action=raw&station={qs}&payload=<v>", True),
+    ]
+
+    xml = ['<?xml version="1.0" encoding="utf-8"?>']
+    xml.append(
+        f'<VirtualOut Title="{html.escape("Alice - " + station_name)}" Comment="" Address="{html.escape(base)}" '
+        'CmdInit="" HintText="" CloseAfterSend="true" CmdSep=";">'
+    )
+    xml.append('\t<Info templateType="3" minVersion="16000610"/>')
+    xml.extend(["\t" + row for row in rows])
+    xml.append("</VirtualOut>")
+    return "\n".join(xml) + "\n"
+
+
+def build_vi_xml(controller_host: str, station_name: str, selector: str) -> str:
+    from urllib.parse import quote
+
+    addr = f"http://{controller_host}:9124/api/status?station={quote(selector, safe='')}"
+    title = html.escape(f"Alice status - {station_name}")
+    lines = [
+        '<?xml version="1.0" encoding="utf-8"?>',
+        f'<VirtualInHttp Title="{title}" Comment="" Address="{html.escape(addr)}" HintText="" PollingTime="10">',
+        '\t<Info templateType="2" minVersion="16000610"/>',
+        '\t<VirtualInHttpCmd Title="Daemon OK" Comment="" Check="\\i&quot;ok&quot;:\\i\\v" Signed="false" Analog="true" SourceValLow="0" DestValLow="0" SourceValHigh="1" DestValHigh="1" DefVal="0" MinVal="0" MaxVal="1" Unit="&lt;v.0&gt;" HintText=""/>',
+        '\t<VirtualInHttpCmd Title="WS Running" Comment="" Check="\\i&quot;running&quot;:\\i\\v" Signed="false" Analog="true" SourceValLow="0" DestValLow="0" SourceValHigh="1" DestValHigh="1" DefVal="0" MinVal="0" MaxVal="1" Unit="&lt;v.0&gt;" HintText=""/>',
+        '\t<VirtualInHttpCmd Title="Playing" Comment="" Check="\\i&quot;playing&quot;:\\i\\v" Signed="false" Analog="true" SourceValLow="0" DestValLow="0" SourceValHigh="1" DestValHigh="1" DefVal="0" MinVal="0" MaxVal="1" Unit="&lt;v.0&gt;" HintText=""/>',
+        '\t<VirtualInHttpCmd Title="Volume" Comment="" Check="\\i&quot;volume&quot;:\\i\\v" Signed="false" Analog="true" SourceValLow="0" DestValLow="0" SourceValHigh="100" DestValHigh="100" DefVal="0" MinVal="0" MaxVal="100" Unit="&lt;v.0&gt;" HintText=""/>',
+        "</VirtualInHttp>",
+    ]
+    return "\n".join(lines) + "\n"
+
+
+def build_wb_rules_js(controller_host: str, station_name: str, selector: str) -> str:
+    device_id = safe_name(f"alice_station_{station_name}".lower().replace("-", "_"), "alice_station")
+    station_json = json.dumps(selector, ensure_ascii=False)
+    title_json = json.dumps(f"Alice - {station_name}", ensure_ascii=False)
+    base_json = json.dumps(f"http://{controller_host}:9124", ensure_ascii=False)
+    device_json = json.dumps(device_id, ensure_ascii=False)
+    return f"""// Auto-generated template for wb-rules
+// Place this file to /etc/wb-rules/ and restart wb-rules.
+
+var STATION_SELECTOR = {station_json};
+var API_BASE = {base_json};
+var DEVICE_ID = {device_json};
+var DEVICE_TITLE = {title_json};
+
+function _apiGet(path, cb) {{
+  runShellCommand("curl -s '" + API_BASE + path + "'", {{
+    captureOutput: true,
+    exitCallback: function (exitCode, capturedOutput) {{
+      if (exitCode !== 0) return cb({{ ok: false, error: "curl_failed" }});
+      try {{
+        return cb(JSON.parse(capturedOutput || "{{}}"));
+      }} catch (e) {{
+        return cb({{ ok: false, error: "bad_json", raw: capturedOutput }});
+      }}
+    }}
+  }});
+}}
+
+function _enc(v) {{
+  return encodeURIComponent(String(v === undefined || v === null ? "" : v));
+}}
+
+defineVirtualDevice(DEVICE_ID, {{
+  title: DEVICE_TITLE,
+  cells: {{
+    daemon_ok: {{ title: {{ en: "Daemon OK", ru: "Демон OK" }}, type: "switch", value: false, readonly: true, order: 10 }},
+    ws_running: {{ title: {{ en: "WS Running", ru: "WS к колонке" }}, type: "switch", value: false, readonly: true, order: 20 }},
+    playing: {{ title: {{ en: "Playing", ru: "Воспроизведение" }}, type: "switch", value: false, readonly: true, order: 30 }},
+    current_volume: {{ title: {{ en: "Current Volume", ru: "Текущая громкость" }}, type: "value", value: 0, readonly: true, order: 40 }},
+    tts_text: {{ title: {{ en: "TTS Text", ru: "Текст TTS" }}, type: "text", value: "", readonly: false, order: 100 }},
+    tts_send: {{ title: {{ en: "Send TTS", ru: "Отправить TTS" }}, type: "pushbutton", value: false, order: 110 }},
+    command_text: {{ title: {{ en: "Command Text", ru: "Текст команды" }}, type: "text", value: "", readonly: false, order: 120 }},
+    command_send: {{ title: {{ en: "Send Command", ru: "Отправить команду" }}, type: "pushbutton", value: false, order: 130 }},
+    volume: {{ title: {{ en: "Volume", ru: "Громкость" }}, type: "range", value: 35, min: 0, max: 100, order: 200 }},
+    raw_json: {{ title: {{ en: "Raw JSON", ru: "RAW JSON" }}, type: "text", value: "{{\\"command\\":\\"stop\\"}}", readonly: false, order: 220 }},
+    raw_send: {{ title: {{ en: "Send RAW", ru: "Отправить RAW" }}, type: "pushbutton", value: false, order: 230 }},
+    play: {{ title: {{ en: "Play", ru: "Play" }}, type: "pushbutton", value: false, order: 300 }},
+    pause: {{ title: {{ en: "Pause", ru: "Pause" }}, type: "pushbutton", value: false, order: 310 }},
+    stop: {{ title: {{ en: "Stop", ru: "Stop" }}, type: "pushbutton", value: false, order: 320 }},
+    next: {{ title: {{ en: "Next", ru: "Next" }}, type: "pushbutton", value: false, order: 330 }},
+    prev: {{ title: {{ en: "Prev", ru: "Prev" }}, type: "pushbutton", value: false, order: 340 }},
+    status_json: {{ title: {{ en: "Status JSON", ru: "Статус JSON" }}, type: "text", value: "{{}}", readonly: true, order: 400 }}
+  }}
+}});
+
+defineRule(DEVICE_ID + "_tts_send", {{
+  whenChanged: DEVICE_ID + "/tts_send",
+  then: function (newValue) {{
+    if (!newValue) return;
+    var txt = String(dev[DEVICE_ID + "/tts_text"] || "").trim();
+    if (!txt) return;
+    _apiGet("/api/exec?action=tts&station=" + _enc(STATION_SELECTOR) + "&text=" + _enc(txt) + "&volume=35", function(){{}});
+  }}
+}});
+
+defineRule(DEVICE_ID + "_command_send", {{
+  whenChanged: DEVICE_ID + "/command_send",
+  then: function (newValue) {{
+    if (!newValue) return;
+    var txt = String(dev[DEVICE_ID + "/command_text"] || "").trim();
+    if (!txt) return;
+    _apiGet("/api/exec?action=command&station=" + _enc(STATION_SELECTOR) + "&text=" + _enc(txt), function(){{}});
+  }}
+}});
+
+defineRule(DEVICE_ID + "_volume_control", {{
+  whenChanged: DEVICE_ID + "/volume",
+  then: function () {{
+    var level = parseInt(dev[DEVICE_ID + "/volume"], 10);
+    if (isNaN(level)) level = 35;
+    if (level < 0) level = 0;
+    if (level > 100) level = 100;
+    _apiGet("/api/exec?action=volume&station=" + _enc(STATION_SELECTOR) + "&level=" + _enc(level), function(){{}});
+  }}
+}});
+
+function _player(cmd) {{
+  return function (newValue) {{
+    if (!newValue) return;
+    _apiGet("/api/exec?action=player&station=" + _enc(STATION_SELECTOR) + "&cmd=" + _enc(cmd), function(){{}});
+  }};
+}}
+
+defineRule(DEVICE_ID + "_play", {{ whenChanged: DEVICE_ID + "/play", then: _player("play") }});
+defineRule(DEVICE_ID + "_pause", {{ whenChanged: DEVICE_ID + "/pause", then: _player("pause") }});
+defineRule(DEVICE_ID + "_stop", {{ whenChanged: DEVICE_ID + "/stop", then: _player("stop") }});
+defineRule(DEVICE_ID + "_next", {{ whenChanged: DEVICE_ID + "/next", then: _player("next") }});
+defineRule(DEVICE_ID + "_prev", {{ whenChanged: DEVICE_ID + "/prev", then: _player("prev") }});
+
+defineRule(DEVICE_ID + "_raw_send", {{
+  whenChanged: DEVICE_ID + "/raw_send",
+  then: function (newValue) {{
+    if (!newValue) return;
+    var raw = String(dev[DEVICE_ID + "/raw_json"] || "").trim();
+    if (!raw) return;
+    _apiGet("/api/exec?action=raw&station=" + _enc(STATION_SELECTOR) + "&payload=" + _enc(raw), function(){{}});
+  }}
+}});
+
+defineRule(DEVICE_ID + "_status_poll", {{
+  when: cron("@every 10s"),
+  then: function () {{
+    _apiGet("/api/status?station=" + _enc(STATION_SELECTOR), function (j) {{
+      var ok = Number(j && j.ok ? 1 : 0);
+      var running = Number(j && j.running ? 1 : 0);
+      dev[DEVICE_ID + "/daemon_ok"] = !!ok;
+      dev[DEVICE_ID + "/ws_running"] = !!running;
+      if (j && j.playing !== undefined && j.playing !== null) dev[DEVICE_ID + "/playing"] = !!Number(j.playing ? 1 : 0);
+      if (j && j.volume !== undefined && j.volume !== null) dev[DEVICE_ID + "/current_volume"] = Number(j.volume) || 0;
+      dev[DEVICE_ID + "/status_json"] = JSON.stringify(j || {{}});
+    }});
+  }}
+}});
+"""
+
+
+def write_station_templates(station: StationRecord, controller_host: str, target_dir: Path) -> Dict[str, str]:
+    station_folder = target_dir / safe_name(station.name or station.station_id, station.station_id or "station")
+    station_folder.mkdir(parents=True, exist_ok=True)
+    selector = station.selector()
+
+    vo_path = station_folder / "VO.xml"
+    vi_path = station_folder / "VI.xml"
+    wb_path = station_folder / "wb-rules-station.js"
+    readme_path = station_folder / "README.md"
+
+    vo_path.write_text(build_vo_xml(controller_host, station.name or station.station_id, selector), encoding="utf-8")
+    vi_path.write_text(build_vi_xml(controller_host, station.name or station.station_id, selector), encoding="utf-8")
+    wb_path.write_text(build_wb_rules_js(controller_host, station.name or station.station_id, selector), encoding="utf-8")
+    readme_path.write_text(
+        "# Alice templates\n\n"
+        f"- Station: {station.name}\n"
+        f"- Station ID: {station.station_id}\n"
+        f"- Selector: {selector}\n"
+        f"- API: http://{controller_host}:9124\n",
+        encoding="utf-8",
+    )
+
+    return {
+        "station": station.station_id,
+        "name": station.name,
+        "folder": str(station_folder.relative_to(BASE_DIR)),
+        "vo": str(vo_path.relative_to(BASE_DIR)),
+        "vi": str(vi_path.relative_to(BASE_DIR)),
+        "wb": str(wb_path.relative_to(BASE_DIR)),
+    }
+
+
+def generate_templates(template_kind: str, controller_host: str) -> Dict[str, Any]:
+    stations = load_stations_records()
+    if not stations:
+        raise RuntimeError("stations.json is empty, run station refresh first")
+
+    ensure_dirs()
+    result: List[Dict[str, str]] = []
+
+    for station in stations:
+        files = write_station_templates(station, controller_host, LOXONE_DIR)
+        if template_kind == "loxone":
+            files = {k: v for k, v in files.items() if k in {"station", "name", "folder", "vo", "vi"}}
+        elif template_kind == "wb-rules":
+            files = {k: v for k, v in files.items() if k in {"station", "name", "folder", "wb"}}
+        result.append(files)
+
+    zip_name = "loxone_templates.zip" if template_kind == "loxone" else "wb_rules_templates.zip"
+    zip_path = LOXONE_DIR / zip_name
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for station in stations:
+            folder = LOXONE_DIR / safe_name(station.name or station.station_id, station.station_id or "station")
+            if template_kind in ("loxone", "all"):
+                for fn in ["VO.xml", "VI.xml", "README.md"]:
+                    p = folder / fn
+                    if p.exists():
+                        zf.write(p, arcname=f"{folder.name}/{fn}")
+            if template_kind in ("wb-rules", "all"):
+                p = folder / "wb-rules-station.js"
+                if p.exists():
+                    zf.write(p, arcname=f"{folder.name}/wb-rules-station.js")
+
+    return {"ok": True, "templates": result, "zip": str(zip_path.relative_to(BASE_DIR))}
+
+
+def is_wiren_board() -> bool:
+    return Path("/etc/wb-release").exists() or Path("/etc/wb-rules").exists()
+
+
+def install_wb_rules(station_id: Optional[str] = None) -> Dict[str, Any]:
+    target_dir = Path("/etc/wb-rules")
+    if not target_dir.exists():
+        raise RuntimeError("/etc/wb-rules not found")
+
+    stations = load_stations_records()
+    if station_id:
+        stations = [s for s in stations if s.station_id == station_id]
+        if not stations:
+            raise RuntimeError(f"station not found: {station_id}")
+
+    installed: List[str] = []
+    for station in stations:
+        folder = LOXONE_DIR / safe_name(station.name or station.station_id, station.station_id or "station")
+        src = folder / "wb-rules-station.js"
+        if not src.exists():
+            write_station_templates(station, detect_controller_host(), LOXONE_DIR)
+        src = folder / "wb-rules-station.js"
+        dst = target_dir / f"alice_station_{safe_name(station.station_id, 'station')}.js"
+
+        try:
+            shutil.copy2(src, dst)
+        except PermissionError:
+            subprocess.run(["sudo", "-n", "install", "-m", "0644", str(src), str(dst)], check=True)
+
+        installed.append(str(dst))
+
+    try:
+        subprocess.run(["systemctl", "restart", "wb-rules"], check=True)
+    except Exception:
+        subprocess.run(["sudo", "-n", "systemctl", "restart", "wb-rules"], check=True)
+
+    return {"ok": True, "installed": installed}
+
+
+async def refresh_stations(token: str, timeout: float = 3.0) -> Dict[str, Any]:
+    token = token.strip()
+    if not token:
+        raise RuntimeError("token is required")
+
+    cloud = await fetch_cloud_stations(token)
+    local = await discover_local(timeout=timeout)
+    merged = merge_cloud_with_local(cloud, local)
+
+    payload = serialize_stations(merged)
+    save_json(STATIONS_PATH, payload)
+
+    return {"ok": True, "stations": payload, "cloud_total": len(cloud), "local_total": len(local)}
+
+
+async def handle_index(_: web.Request) -> web.Response:
+    return web.FileResponse(BASE_DIR / "web" / "index.html")
+
+
+async def handle_static(request: web.Request) -> web.Response:
+    name = request.match_info.get("name", "")
+    p = BASE_DIR / "web" / name
+    if not p.exists() or not p.is_file():
+        raise web.HTTPNotFound()
+    return web.FileResponse(p)
+
+
+async def api_status(_: web.Request) -> web.Response:
+    stations = load_json(STATIONS_PATH, [])
+    cfg = load_json(CONFIG_PATH, {})
+    return web.json_response(
+        {
+            "ok": True,
+            "token_set": bool(read_token("")),
+            "controller_host": detect_controller_host(),
+            "stations": stations,
+            "is_wiren_board": is_wiren_board(),
+            "platform": platform.platform(),
+            "config": {"controller_host": str(cfg.get("controller_host") or "")},
+        }
+    )
+
+
+async def api_set_token(request: web.Request) -> web.Response:
+    body = await request.json()
+    token = str(body.get("token") or "").strip()
+    if not token:
+        return web.json_response({"ok": False, "error": "token is required"}, status=422)
+    save_token(token)
+    return web.json_response({"ok": True})
+
+
+async def api_set_host(request: web.Request) -> web.Response:
+    body = await request.json()
+    host = str(body.get("controller_host") or "").strip()
+    if not host:
+        return web.json_response({"ok": False, "error": "controller_host is required"}, status=422)
+    save_controller_host(host)
+    return web.json_response({"ok": True, "controller_host": detect_controller_host()})
+
+
+async def api_refresh(_: web.Request) -> web.Response:
+    try:
+        out = await refresh_stations(read_token(""))
+        return web.json_response(out)
+    except Exception as exc:
+        return web.json_response({"ok": False, "error": str(exc)}, status=422)
+
+
+async def api_templates_loxone(_: web.Request) -> web.Response:
+    try:
+        out = generate_templates("loxone", detect_controller_host())
+        return web.json_response(out)
+    except Exception as exc:
+        return web.json_response({"ok": False, "error": str(exc)}, status=422)
+
+
+async def api_templates_wb(_: web.Request) -> web.Response:
+    try:
+        out = generate_templates("wb-rules", detect_controller_host())
+        return web.json_response(out)
+    except Exception as exc:
+        return web.json_response({"ok": False, "error": str(exc)}, status=422)
+
+
+async def api_download(request: web.Request) -> web.StreamResponse:
+    kind = request.match_info.get("kind", "")
+    if kind not in {"loxone", "wb-rules"}:
+        raise web.HTTPNotFound()
+    zip_name = "loxone_templates.zip" if kind == "loxone" else "wb_rules_templates.zip"
+    zip_path = LOXONE_DIR / zip_name
+    if not zip_path.exists():
+        generate_templates(kind, detect_controller_host())
+    return web.FileResponse(zip_path)
+
+
+async def api_install_wb(request: web.Request) -> web.Response:
+    if not is_wiren_board():
+        return web.json_response({"ok": False, "error": "not a Wiren Board environment"}, status=422)
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    station_id = str(body.get("station_id") or "").strip() or None
+    try:
+        out = install_wb_rules(station_id)
+        return web.json_response(out)
+    except Exception as exc:
+        return web.json_response({"ok": False, "error": str(exc)}, status=422)
+
+
+async def run_web(host: str, port: int) -> int:
+    app = web.Application()
+    app.router.add_get("/", handle_index)
+    app.router.add_get("/web/{name}", handle_static)
+
+    app.router.add_get("/api/status", api_status)
+    app.router.add_post("/api/token", api_set_token)
+    app.router.add_post("/api/controller-host", api_set_host)
+    app.router.add_post("/api/stations/refresh", api_refresh)
+    app.router.add_post("/api/templates/loxone", api_templates_loxone)
+    app.router.add_post("/api/templates/wb-rules", api_templates_wb)
+    app.router.add_get("/api/download/{kind}", api_download)
+    app.router.add_post("/api/wb-rules/install", api_install_wb)
+
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, host=host, port=port)
+    await site.start()
+
+    print(f"alice plugin web listening on http://{host}:{port}")
+    while True:
+        await asyncio.sleep(3600)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="Standalone Alice stations plugin")
+    p.add_argument("--token", default="", help="Yandex OAuth token")
+
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sp = sub.add_parser("stations-refresh", help="1) get stations list")
+    sp.add_argument("--timeout", type=float, default=3.0)
+
+    sp = sub.add_parser("templates-loxone", help="2) generate Loxone templates in ./loxone")
+    sp.add_argument("--controller-host", default="")
+
+    sp = sub.add_parser("templates-wb-rules", help="3) generate wb-rules templates in ./loxone")
+    sp.add_argument("--controller-host", default="")
+
+    sp = sub.add_parser("wb-install", help="install wb-rules templates to /etc/wb-rules")
+    sp.add_argument("--station-id", default="")
+
+    sp = sub.add_parser("web", help="run web UI")
+    sp.add_argument("--host", default="0.0.0.0")
+    sp.add_argument("--port", type=int, default=9140)
+
+    return p
+
+
+async def main_async() -> int:
+    ensure_dirs()
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.cmd == "stations-refresh":
+        token = read_token(args.token)
+        out = await refresh_stations(token, timeout=args.timeout)
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+        return 0
+
+    if args.cmd == "templates-loxone":
+        host = (args.controller_host or "").strip() or detect_controller_host()
+        out = generate_templates("loxone", host)
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+        return 0
+
+    if args.cmd == "templates-wb-rules":
+        host = (args.controller_host or "").strip() or detect_controller_host()
+        out = generate_templates("wb-rules", host)
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+        return 0
+
+    if args.cmd == "wb-install":
+        out = install_wb_rules(args.station_id.strip() or None)
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+        return 0
+
+    if args.cmd == "web":
+        token = (args.token or "").strip()
+        if token:
+            save_token(token)
+        return await run_web(args.host, args.port)
+
+    parser.print_help()
+    return 1
+
+
+def main() -> int:
+    try:
+        return asyncio.run(main_async())
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())