node-red-contrib-alice 2.3.6 → 3.0.0

package/nodes/alice-device.html

@@ -17,10 +17,12 @@
                     {
                         options: [
                             { value: "devices.types.light", label: "Light" },
+                            { value: "devices.types.light.lamp", label: "Light Lamp" },
                             { value: "devices.types.light.ceiling", label: "Light Сeiling" },
                             { value: "devices.types.light.strip", label: "Light Strip" },
                             { value: "devices.types.socket", label: "Socket" },
                             { value: "devices.types.switch", label: "Switch" },
+                            { value: "devices.types.switch.relay", label: "Relay" },
                             { value: "devices.types.thermostat", label: "Thermostat"  },
                             { value: "devices.types.thermostat.ac", label: "Air conditioning"  },
                             { value: "devices.types.media_device", label: "Multimedia"  },
@@ -35,6 +37,7 @@
                             { value: "devices.types.openable", label: "Door, gate, window, shutters" },
                             { value: "devices.types.openable.curtain", label: "Curtains, blinds" },
                             { value: "devices.types.openable.valve", label: "Valve (ball valve)" },
+                            { value: "devices.types.openable.door_lock", label: "Door lock" },
                             { value: "devices.types.humidifier", label: "Humidifier" },
                             { value: "devices.types.purifier", label: "Air purifier" },
                             { value: "devices.types.ventilation", label: "Ventilation" },

package/nodes/alice.js

@@ -3,14 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 const axios_1 = __importDefault(require("axios"));
-const mqtt_1 = __importDefault(require("mqtt"));
+const ws_1 = __importDefault(require("ws"));
+const WS_URL = process.env.ALICE_WS_URL || "wss://ws.nodered-home.ru/v1/ws";
+const RECONNECT_MIN_MS = 1000;
+const RECONNECT_MAX_MS = 60000;
+const RECONNECT_JITTER_MS = 10000;
+const WATCHDOG_TIMEOUT_MS = 90000;
+const HANDSHAKE_TIMEOUT_MS = 15000;
+const CLOSE_FAILSAFE_MS = 1500;
 module.exports = (RED) => {
     function AliceService(config) {
         RED.nodes.createNode(this, config);
         this.debug("Starting Alice service... ID: " + this.id);
         const email = this.credentials.email;
-        const login = this.credentials.id;
-        const password = this.credentials.password;
         const token = this.credentials.token;
         const suburl = Buffer.from(email).toString('base64');
         RED.httpAdmin.get("/noderedhome/" + suburl + "/clearalldevice", (_req, res) => {
@@ -55,49 +60,146 @@ module.exports = (RED) => {
             this.error("Authentication is required!!!");
             return;
         }
-        const mqttClient = mqtt_1.default.connect("mqtts://mqtt.cloud.yandex.net", {
-            port: 8883,
-            clientId: login,
-            rejectUnauthorized: false,
-            username: login,
-            password: password,
-            reconnectPeriod: 10000
-        });
-        mqttClient.on("message", (topic, payload) => {
-            const arrTopic = topic.split('/');
-            const data = JSON.parse(payload.toString());
-            this.trace("Incoming:" + topic + " timestamp:" + new Date().getTime());
-            if (payload.length && typeof data === 'object') {
-                if (arrTopic[3] == 'message') {
-                    this.warn(data.text);
+        let accessToken;
+        try {
+            accessToken = JSON.parse(token).access_token;
+            if (!accessToken) {
+                throw new Error("access_token is empty");
+            }
+        }
+        catch (_err) {
+            this.error("Authentication token is corrupted, please re-authenticate in node settings!!!");
+            return;
+        }
+        let ws = null;
+        let closing = false;
+        let reconnectDelay = RECONNECT_MIN_MS;
+        let reconnectTimer = null;
+        let watchdogTimer = null;
+        const stopWatchdog = () => {
+            if (watchdogTimer) {
+                clearTimeout(watchdogTimer);
+                watchdogTimer = null;
+            }
+        };
+        const resetWatchdog = () => {
+            stopWatchdog();
+            watchdogTimer = setTimeout(() => {
+                watchdogTimer = null;
+                this.debug("WS watchdog: no activity for " + WATCHDOG_TIMEOUT_MS + "ms, terminating connection");
+                if (ws) {
+                    ws.terminate();
+                }
+            }, WATCHDOG_TIMEOUT_MS);
+        };
+        const scheduleReconnect = () => {
+            if (closing || reconnectTimer) {
+                return;
+            }
+            const delay = reconnectDelay + Math.floor(Math.random() * RECONNECT_JITTER_MS);
+            reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
+            this.debug("WS reconnect scheduled in " + delay + "ms");
+            reconnectTimer = setTimeout(() => {
+                reconnectTimer = null;
+                connect();
+            }, delay);
+        };
+        const connect = () => {
+            if (closing) {
+                return;
+            }
+            this.debug("Connecting to WS gateway: " + WS_URL);
+            const socket = new ws_1.default(WS_URL, {
+                headers: { Authorization: "Bearer " + accessToken },
+                handshakeTimeout: HANDSHAKE_TIMEOUT_MS
+            });
+            ws = socket;
+            socket.on("open", () => {
+                this.debug("WS connection opened, waiting for hello");
+                resetWatchdog();
+            });
+            socket.on("ping", () => {
+                resetWatchdog();
+            });
+            socket.on("message", (raw) => {
+                resetWatchdog();
+                let frame;
+                try {
+                    frame = JSON.parse(raw.toString());
+                }
+                catch (_err) {
+                    this.warn("WS: invalid JSON frame ignored");
+                    return;
+                }
+                if (!frame || typeof frame !== "object") {
+                    this.warn("WS: unexpected frame ignored");
+                    return;
+                }
+                switch (frame.type) {
+                    case "hello":
+                        this.debug("WS gateway connected (hello received)");
+                        reconnectDelay = RECONNECT_MIN_MS;
+                        this.emit('online');
+                        break;
+                    case "command":
+                        this.trace("Incoming command devId:" + frame.devId + " timestamp:" + new Date().getTime());
+                        if (!Array.isArray(frame.payload)) {
+                            this.warn("WS: command frame without payload array ignored. devId:" + frame.devId);
+                            return;
+                        }
+                        if (frame.devId) {
+                            try {
+                                this.emit(String(frame.devId), frame.payload);
+                            }
+                            catch (err) {
+                                this.warn("WS: command listener error: " + (err instanceof Error ? err.message : String(err)));
+                            }
+                        }
+                        break;
+                    case "message":
+                        if (typeof frame.text === "string") {
+                            this.warn(frame.text);
+                        }
+                        else {
+                            this.trace("WS: message frame without text ignored");
+                        }
+                        break;
+                    default:
+                        this.trace("WS: unknown frame type ignored: " + frame.type);
+                }
+            });
+            socket.on("unexpected-response", (req, res) => {
+                stopWatchdog();
+                if (res.statusCode === 401) {
+                    this.error("WS gateway rejected token (401): токен недействителен, переавторизуйтесь в настройках ноды");
                 }
                 else {
-                    this.emit(arrTopic[3], data);
+                    this.debug("WS unexpected server response: HTTP " + res.statusCode);
                 }
-            }
-        });
-        mqttClient.on("connect", () => {
-            this.debug("Yandex IOT client connected. ");
-            this.emit('online');
-            mqttClient.subscribe("$me/device/commands/+", () => {
-                this.debug("Yandex IOT client subscribed to the command");
+                req.destroy();
+                if (ws === socket) {
+                    ws = null;
+                }
+                this.emit('offline');
+                scheduleReconnect();
             });
-        });
-        mqttClient.on("offline", () => {
-            this.debug("Yandex IOT client offline. ");
-            this.emit('offline');
-        });
-        mqttClient.on("disconnect", () => {
-            this.debug("Yandex IOT client disconnect.");
-            this.emit('offline');
-        });
-        mqttClient.on("reconnect", () => {
-            this.debug("Yandex IOT client reconnecting ...");
-        });
-        mqttClient.on("error", (err) => {
-            this.error("Yandex IOT client Error: " + err.message);
-            this.emit('offline');
-        });
+            socket.on("error", (err) => {
+                this.debug("WS error: " + err.message);
+            });
+            socket.on("close", (code, reason) => {
+                stopWatchdog();
+                if (code === 4429) {
+                    this.warn("WS gateway closed connection (4429): превышен лимит подключений — не более 5 на пользователя");
+                }
+                this.debug("WS connection closed. code:" + code + " reason:" + reason.toString());
+                if (ws === socket) {
+                    ws = null;
+                }
+                this.emit('offline');
+                scheduleReconnect();
+            });
+        };
+        connect();
         this.on('offline', () => {
             this.isOnline = false;
         });
@@ -105,17 +207,60 @@ module.exports = (RED) => {
             this.isOnline = true;
         });
         this.on('close', (done) => {
+            closing = true;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            stopWatchdog();
             this.emit('offline');
+            const socket = ws;
+            ws = null;
+            if (!socket || socket.readyState === ws_1.default.CLOSED) {
+                done();
+                return;
+            }
+            let doneCalled = false;
+            const finish = () => {
+                if (!doneCalled) {
+                    doneCalled = true;
+                    done();
+                }
+            };
+            socket.once('close', finish);
+            try {
+                socket.close(1000);
+            }
+            catch (_err) {
+                socket.terminate();
+            }
             setTimeout(() => {
-                mqttClient.end(false, {}, done);
-            }, 500);
+                if (socket.readyState !== ws_1.default.CLOSED) {
+                    socket.terminate();
+                }
+                finish();
+            }, CLOSE_FAILSAFE_MS).unref();
         });
-        this.send2gate = (path, data, retain) => {
+        this.send2gate = (path, data, _retain) => {
             this.trace("Outgoing: " + path);
-            mqttClient.publish(path, data, { qos: 0, retain: retain });
+            const arrPath = path.split('/');
+            const devId = arrPath[arrPath.length - 1];
+            if (!ws || ws.readyState !== ws_1.default.OPEN) {
+                this.debug("WS not connected, command_result dropped. devId:" + devId);
+                return;
+            }
+            let payload;
+            try {
+                payload = JSON.parse(data);
+            }
+            catch (_err) {
+                this.warn("send2gate: invalid JSON data ignored. devId:" + devId);
+                return;
+            }
+            ws.send(JSON.stringify({ v: 1, type: "command_result", devId: devId, payload: payload }));
         };
         this.getToken = () => {
-            return JSON.parse(token).access_token;
+            return accessToken;
         };
     }
     RED.nodes.registerType("alice-service", AliceService, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-alice",
-  "version": "2.3.6",
+  "version": "3.0.0",
   "description": "",
   "scripts": {
     "start": "npm run build && node-red",
@@ -44,11 +44,12 @@
   "homepage": "https://github.com/efa2000/node-red-contrib-alice#readme",
   "dependencies": {
     "axios": "^1.4.0",
-    "mqtt": "^4.3.8"
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.16",
     "@types/node-red": "^1.3.4",
+    "@types/ws": "^8.5.12",
     "nodemon": "^3.0.3",
     "typescript": "^5.3.3"
   },

package/src/alice-device.html

@@ -17,10 +17,12 @@
                     {
                         options: [
                             { value: "devices.types.light", label: "Light" },
+                            { value: "devices.types.light.lamp", label: "Light Lamp" },
                             { value: "devices.types.light.ceiling", label: "Light Сeiling" },
                             { value: "devices.types.light.strip", label: "Light Strip" },
                             { value: "devices.types.socket", label: "Socket" },
                             { value: "devices.types.switch", label: "Switch" },
+                            { value: "devices.types.switch.relay", label: "Relay" },
                             { value: "devices.types.thermostat", label: "Thermostat"  },
                             { value: "devices.types.thermostat.ac", label: "Air conditioning"  },
                             { value: "devices.types.media_device", label: "Multimedia"  },
@@ -35,6 +37,7 @@
                             { value: "devices.types.openable", label: "Door, gate, window, shutters" },
                             { value: "devices.types.openable.curtain", label: "Curtains, blinds" },
                             { value: "devices.types.openable.valve", label: "Valve (ball valve)" },
+                            { value: "devices.types.openable.door_lock", label: "Door lock" },
                             { value: "devices.types.humidifier", label: "Humidifier" },
                             { value: "devices.types.purifier", label: "Air purifier" },
                             { value: "devices.types.ventilation", label: "Ventilation" },

package/src/alice.ts

@@ -1,16 +1,45 @@
 import { NodeAPI } from "node-red";
 import axios from "axios";
-import mqtt from "mqtt";
+import WebSocket from "ws";
 import { AliceServiceConfig, AliceServiceNode } from "./types.js";
 
+// Адрес WebSocket-шлюза. Для отладки и тестов можно переопределить
+// через переменную окружения ALICE_WS_URL.
+const WS_URL = process.env.ALICE_WS_URL || "wss://ws.nodered-home.ru/v1/ws";
+
+// Реконнект: экспоненциальный backoff от 1 до 60 секунд (×2) + джиттер 0–10 секунд
+const RECONNECT_MIN_MS = 1000;
+const RECONNECT_MAX_MS = 60000;
+const RECONNECT_JITTER_MS = 10000;
+
+// Watchdog: сервер шлёт ping каждые 30 секунд; если ~90 секунд нет ни ping,
+// ни сообщений — считаем соединение мёртвым и рвём его сами
+const WATCHDOG_TIMEOUT_MS = 90000;
+
+// Таймаут WS-хендшейка: если сервер принял TCP, но не ответил на upgrade,
+// библиотека ws сама эмитит error+close — дальше штатный реконнект
+const HANDSHAKE_TIMEOUT_MS = 15000;
+
+// Failsafe при закрытии ноды: если сервер не завершил close-хендшейк
+// за это время — рвём сокет и отпускаем done()
+const CLOSE_FAILSAFE_MS = 1500;
+
+// Кадр протокола WS-шлюза (JSON text frame)
+interface GateFrame {
+  v?: number;
+  type?: string;
+  reqId?: string;
+  devId?: string;
+  payload?: unknown;
+  text?: string;
+}
+
 export = (RED: NodeAPI): void => {
   function AliceService(this: AliceServiceNode, config: AliceServiceConfig): void {
     RED.nodes.createNode(this, config);
     this.debug("Starting Alice service... ID: " + this.id);
 
     const email = this.credentials.email;
-    const login = this.credentials.id;
-    const password = this.credentials.password;
     const token = this.credentials.token;
 
     //вызов для удаления всех устройств
@@ -61,54 +90,166 @@ export = (RED: NodeAPI): void => {
       return;
     }
 
-    const mqttClient = mqtt.connect("mqtts://mqtt.cloud.yandex.net", {
-      port: 8883,
-      clientId: login,
-      rejectUnauthorized: false,
-      username: login,
-      password: password,
-      reconnectPeriod: 10000
-    });
+    // Токен хранится как JSON-строка OAuth-ответа Яндекса
+    let accessToken: string;
+    try {
+      accessToken = JSON.parse(token).access_token;
+      if (!accessToken) {
+        throw new Error("access_token is empty");
+      }
+    } catch (_err) {
+      this.error("Authentication token is corrupted, please re-authenticate in node settings!!!");
+      return;
+    }
 
-    mqttClient.on("message", (topic: string, payload: Buffer) => {
-      const arrTopic = topic.split('/');
-      const data = JSON.parse(payload.toString());
-      this.trace("Incoming:" + topic + " timestamp:" + new Date().getTime());
-      if (payload.length && typeof data === 'object') {
-        if (arrTopic[3] == 'message') {
-          this.warn(data.text);
-        } else {
-          this.emit(arrTopic[3], data);
+    // ---------- WebSocket-транспорт (замена MQTT / Yandex IoT Core) ----------
+
+    let ws: WebSocket | null = null;          // текущее соединение
+    let closing = false;                      // нода закрывается — реконнект запрещён
+    let reconnectDelay = RECONNECT_MIN_MS;    // текущая база backoff
+    let reconnectTimer: NodeJS.Timeout | null = null;
+    let watchdogTimer: NodeJS.Timeout | null = null;
+
+    const stopWatchdog = () => {
+      if (watchdogTimer) {
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+      }
+    };
+
+    // Любая активность от сервера (ping или сообщение) сбрасывает watchdog
+    const resetWatchdog = () => {
+      stopWatchdog();
+      watchdogTimer = setTimeout(() => {
+        watchdogTimer = null;
+        this.debug("WS watchdog: no activity for " + WATCHDOG_TIMEOUT_MS + "ms, terminating connection");
+        if (ws) {
+          ws.terminate(); // событие close запустит обычный реконнект
         }
+      }, WATCHDOG_TIMEOUT_MS);
+    };
+
+    const scheduleReconnect = () => {
+      if (closing || reconnectTimer) {
+        return;
       }
-    });
+      const delay = reconnectDelay + Math.floor(Math.random() * RECONNECT_JITTER_MS);
+      reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
+      this.debug("WS reconnect scheduled in " + delay + "ms");
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        connect();
+      }, delay);
+    };
 
-    mqttClient.on("connect", () => {
-      this.debug("Yandex IOT client connected. ");
-      this.emit('online');
-      mqttClient.subscribe("$me/device/commands/+", () => {
-        this.debug("Yandex IOT client subscribed to the command");
+    const connect = () => {
+      if (closing) {
+        return;
+      }
+      this.debug("Connecting to WS gateway: " + WS_URL);
+      const socket = new WebSocket(WS_URL, {
+        headers: { Authorization: "Bearer " + accessToken },
+        handshakeTimeout: HANDSHAKE_TIMEOUT_MS
       });
-    });
+      ws = socket;
 
-    mqttClient.on("offline", () => {
-      this.debug("Yandex IOT client offline. ");
-      this.emit('offline');
-    });
+      socket.on("open", () => {
+        // online эмитим не здесь, а по кадру hello: сервер может закрыть
+        // уже открытое соединение кодом 4429 (превышен лимит подключений)
+        this.debug("WS connection opened, waiting for hello");
+        resetWatchdog();
+      });
 
-    mqttClient.on("disconnect", () => {
-      this.debug("Yandex IOT client disconnect.");
-      this.emit('offline');
-    });
+      // Стандартный WS ping от сервера (pong библиотека ws шлёт сама)
+      socket.on("ping", () => {
+        resetWatchdog();
+      });
 
-    mqttClient.on("reconnect", () => {
-      this.debug("Yandex IOT client reconnecting ...");
-    });
+      socket.on("message", (raw) => {
+        resetWatchdog();
+        let frame: GateFrame;
+        try {
+          frame = JSON.parse(raw.toString());
+        } catch (_err) {
+          this.warn("WS: invalid JSON frame ignored");
+          return;
+        }
+        if (!frame || typeof frame !== "object") {
+          this.warn("WS: unexpected frame ignored");
+          return;
+        }
+        switch (frame.type) {
+          case "hello":
+            // Подтверждение авторизации — только теперь считаем себя онлайн
+            this.debug("WS gateway connected (hello received)");
+            reconnectDelay = RECONNECT_MIN_MS; // успешный коннект — сбрасываем backoff
+            this.emit('online');
+            break;
+          case "command":
+            // payload — массив capability-объектов, как раньше в MQTT-топике команд
+            this.trace("Incoming command devId:" + frame.devId + " timestamp:" + new Date().getTime());
+            if (!Array.isArray(frame.payload)) {
+              this.warn("WS: command frame without payload array ignored. devId:" + frame.devId);
+              return;
+            }
+            if (frame.devId) {
+              // исключение в слушателе не должно убивать обработку кадров на сокете
+              try {
+                this.emit(String(frame.devId), frame.payload);
+              } catch (err) {
+                this.warn("WS: command listener error: " + (err instanceof Error ? err.message : String(err)));
+              }
+            }
+            break;
+          case "message":
+            // Служебное сообщение от шлюза (замена message-топика)
+            if (typeof frame.text === "string") {
+              this.warn(frame.text);
+            } else {
+              this.trace("WS: message frame without text ignored");
+            }
+            break;
+          default:
+            this.trace("WS: unknown frame type ignored: " + frame.type);
+        }
+      });
 
-    mqttClient.on("error", (err) => {
-      this.error("Yandex IOT client Error: " + err.message);
-      this.emit('offline');
-    });
+      // Сервер отверг подключение на этапе upgrade (не 101)
+      socket.on("unexpected-response", (req, res) => {
+        stopWatchdog();
+        if (res.statusCode === 401) {
+          this.error("WS gateway rejected token (401): токен недействителен, переавторизуйтесь в настройках ноды");
+        } else {
+          this.debug("WS unexpected server response: HTTP " + res.statusCode);
+        }
+        req.destroy();
+        if (ws === socket) {
+          ws = null;
+        }
+        this.emit('offline');
+        scheduleReconnect(); // backoff не сбрасываем — продолжаем попытки
+      });
+
+      socket.on("error", (err) => {
+        // за error всегда следует close — реконнект планируется там
+        this.debug("WS error: " + err.message);
+      });
+
+      socket.on("close", (code, reason) => {
+        stopWatchdog();
+        if (code === 4429) {
+          this.warn("WS gateway closed connection (4429): превышен лимит подключений — не более 5 на пользователя");
+        }
+        this.debug("WS connection closed. code:" + code + " reason:" + reason.toString());
+        if (ws === socket) {
+          ws = null;
+        }
+        this.emit('offline');
+        scheduleReconnect();
+      });
+    };
+
+    connect();
 
     this.on('offline', () => {
       this.isOnline = false;
@@ -119,19 +260,66 @@ export = (RED: NodeAPI): void => {
     });
 
     this.on('close', (done: () => void) => {
+      closing = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      stopWatchdog();
       this.emit('offline');
+      const socket = ws;
+      ws = null;
+      if (!socket || socket.readyState === WebSocket.CLOSED) {
+        done();
+        return;
+      }
+      // done() зовём по фактическому закрытию сокета: иначе при redeploy новая
+      // нода коннектится раньше, чем сервер освободил слот, и ловит 4429
+      let doneCalled = false;
+      const finish = () => {
+        if (!doneCalled) {
+          doneCalled = true;
+          done();
+        }
+      };
+      socket.once('close', finish);
+      try {
+        socket.close(1000);
+      } catch (_err) {
+        socket.terminate();
+      }
+      // страховка: если сервер не завершил close-хендшейк — рвём сокет и отпускаем done
       setTimeout(() => {
-        mqttClient.end(false, {}, done);
-      }, 500);
+        if (socket.readyState !== WebSocket.CLOSED) {
+          socket.terminate();
+        }
+        finish();
+      }, CLOSE_FAILSAFE_MS).unref();
     });
 
-    this.send2gate = (path: string, data: string, retain: boolean) => {
+    // Сигнатура сохранена для совместимости с alice-device:
+    // path — старый MQTT-топик ($me/device/events/{devId}), retain не используется
+    this.send2gate = (path: string, data: string, _retain: boolean) => {
       this.trace("Outgoing: " + path);
-      mqttClient.publish(path, data, { qos: 0, retain: retain });
+      const arrPath = path.split('/');
+      const devId = arrPath[arrPath.length - 1];
+      if (!ws || ws.readyState !== WebSocket.OPEN) {
+        // эквивалент MQTT publish с qos 0 в офлайне — молча дропаем
+        this.debug("WS not connected, command_result dropped. devId:" + devId);
+        return;
+      }
+      let payload: unknown;
+      try {
+        payload = JSON.parse(data);
+      } catch (_err) {
+        this.warn("send2gate: invalid JSON data ignored. devId:" + devId);
+        return;
+      }
+      ws.send(JSON.stringify({ v: 1, type: "command_result", devId: devId, payload: payload }));
     };
 
     this.getToken = () => {
-      return JSON.parse(token).access_token;
+      return accessToken;
     };
   }
 

package/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git remote -v && git config --list --local 2>/dev/null)",
-      "Bash(git config:*)",
-      "Bash(ssh -T git@github.com)",
-      "Bash(git remote:*)",
-      "Bash(git push:*)"
-    ]
-  }
-}

package/CLAUDE.md

@@ -1,54 +0,0 @@
-# CLAUDE.md
-
-Этот файл содержит руководство для Claude Code (claude.ai/code) при работе с кодом в данном репозитории.
-
-## Обзор проекта
-
-Плагин для Node-RED (`node-red-contrib-alice`), интегрирующий IoT-устройства, управляемые через Node-RED, с голосовым помощником Яндекс Алиса для управления умным домом. Опубликован в npm как `node-red-contrib-alice`.
-
-## Команды сборки и разработки
-
-```bash
-npm run build          # Компиляция TypeScript (tsc) + копирование HTML из src/ в nodes/
-npm start              # Сборка и запуск Node-RED
-npm run copy-html      # Копирование src/*.html в nodes/
-```
-
-Все исходники (`.ts` + `.html`) находятся в `src/`. Папка `nodes/` — только скомпилированный вывод (JS + скопированные HTML). При `npm run build` TypeScript компилируется в JS, а HTML копируется в `nodes/`.
-
-Общие типы и интерфейсы вынесены в `src/types.ts`.
-
-## Архитектура
-
-### Паттерн нод Node-RED
-
-Каждый тип ноды состоит из пары файлов: `.ts` (логика) и `.html` (UI конфигурации):
-
-- **Сервисная нода** (`alice.ts`): Центральный узел — управляет OAuth Яндекса, MQTT-подключением к `mqtts://mqtt.cloud.yandex.net:8883`, HTTP-эндпоинтами администрирования, валидацией подписки. Выступает как источник событий для всех нод устройств.
-- **Нода устройства** (`alice-device.ts`): Группирует умения/сенсоры, управляет регистрацией устройства на шлюзе (`api.nodered-home.ru`), дебаунсит обновления состояния (1000мс).
-- **Ноды умений** (`alice-onoff`, `alice-range`, `alice-color`, `alice-mode`, `alice-togle`, `alice-video`): Двунаправленные — принимают голосовые команды от Алисы и отправляют обновления состояния на шлюз.
-- **Нода сенсора** (`alice-sensor`): Передача свойств только для чтения (температура, влажность и т.д.).
-- **Нода событий** (`alice-event`): Обнаруживает изменения состояния и запускает потоки.
-
-### Коммуникация
-
-- **MQTT**: Команды устройствам в реальном времени через Yandex IoT Cloud
-- **HTTP REST**: Конфигурация устройств и синхронизация состояния со шлюзом `api.nodered-home.ru`
-- **OAuth 2.0**: Аутентификация через Яндекс, обмен токенами через `nodered-home.ru/api/v1/getyatoken`
-
-### Структура HTML UI
-
-Каждый `.html` файл содержит два блока скриптов:
-1. `<script>` — клиентская логика (регистрация в редакторе Node-RED, REST-вызовы)
-2. `<script type="text/x-red" data-template-name="...">` — шаблон формы
-
-### Основные зависимости
-
-- `mqtt` — MQTT-клиент для Yandex IoT Cloud
-- `axios` — HTTP-клиент для вызовов API шлюза
-
-## Заметки
-
-- Опечатка `alice-togle` (вместо `toggle`) — намеренная, это зарегистрированное имя типа ноды
-- В проекте отсутствуют тесты
-- Комментарии в коде и строки UI написаны преимущественно на русском языке