@rfranzoi/scrypted-mqtt-securitysystem 1.0.40 → 1.0.42

package/dist/main.nodejs.js

@@ -34024,28 +34024,46 @@ function socketOnError() {
 
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-// --- Preload: silenzia SOLO il warning facoltativo di sdk.json ---
-(() => {
-    const swallow = (orig) => (...args) => {
-        const txt = args.map(a => typeof a === 'string' ? a : (a?.message || '')).join(' ');
-        if (txt.includes('failed to load custom interface descriptors'))
-            return;
-        return orig(...args);
-    };
-    console.error = swallow(console.error.bind(console));
-    console.warn = swallow(console.warn.bind(console));
-})();
-// Carica lo SDK in runtime (evita ESM per garantire l’ordine col preload)
-const sdk = __webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js");
-// Valori runtime (enum, classi, manager)
-const { ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, // enum: valori
-SecuritySystemMode, // enum: valori
-systemManager, } = sdk;
+const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
 const mqtt_1 = __importDefault(__webpack_require__(/*! mqtt */ "./node_modules/mqtt/build/index.js"));
+const { systemManager, deviceManager } = sdk_1.default;
 /** utils */
 function truthy(v) {
     if (!v)
@@ -34059,113 +34077,140 @@ function falsy(v) {
     const s = v.toString().trim().toLowerCase();
     return s === '0' || s === 'false' || s === 'offline' || s === 'no' || s === 'off';
 }
-function normalize(s) { return (s || '').trim().toLowerCase(); }
-function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
-/** Outgoing predefiniti (PAI-like). Chiavi numeriche per compatibilità enum */
+function normalize(s) {
+    return (s || '').trim().toLowerCase();
+}
+function clamp(n, min, max) {
+    return Math.max(min, Math.min(max, n));
+}
+/** SecuritySystem outgoing defaults (PAI-like) */
 const DEFAULT_OUTGOING = {
-    [SecuritySystemMode.Disarmed]: 'disarm',
-    [SecuritySystemMode.HomeArmed]: 'arm_home',
-    [SecuritySystemMode.AwayArmed]: 'arm_away',
-    [SecuritySystemMode.NightArmed]: 'arm_night',
+    [sdk_1.SecuritySystemMode.Disarmed]: 'disarm',
+    [sdk_1.SecuritySystemMode.HomeArmed]: 'arm_home',
+    [sdk_1.SecuritySystemMode.AwayArmed]: 'arm_away',
+    [sdk_1.SecuritySystemMode.NightArmed]: 'arm_night',
 };
-/** Parse incoming payload -> final mode (ignora transitori) */
+/** Parse incoming payload -> final mode (ignore transition states) */
 function payloadToMode(payload) {
     if (payload == null)
         return;
     const p = normalize(payload.toString());
     if (['disarm', 'disarmed', 'off', '0', 'idle', 'ready'].includes(p))
-        return SecuritySystemMode.Disarmed;
+        return sdk_1.SecuritySystemMode.Disarmed;
     if (['arm_home', 'home', 'stay', 'armed_home'].includes(p))
-        return SecuritySystemMode.HomeArmed;
+        return sdk_1.SecuritySystemMode.HomeArmed;
     if (['arm_away', 'away', 'armed_away', 'away_armed'].includes(p))
-        return SecuritySystemMode.AwayArmed;
+        return sdk_1.SecuritySystemMode.AwayArmed;
     if (['arm_night', 'night', 'armed_night', 'sleep', 'arm_sleep', 'armed_sleep'].includes(p))
-        return SecuritySystemMode.NightArmed;
+        return sdk_1.SecuritySystemMode.NightArmed;
+    // transitori: non cambiano il mode
     if (['entry_delay', 'exit_delay', 'pending', 'arming', 'disarming'].includes(p))
         return undefined;
     return undefined;
 }
-class BaseMqttSensor extends ScryptedDeviceBase {
+class BaseMqttSensor extends sdk_1.ScryptedDeviceBase {
     constructor(nativeId, cfg) {
         super(nativeId);
         this.cfg = cfg;
+        // non impostare stati qui: l'annuncio device deve avvenire prima
     }
+    /** Called by parent on each MQTT message */
     handleMqtt(topic, payload) {
         const p = payload?.toString() ?? '';
         const np = normalize(p);
+        // online
         if (topic === this.cfg.topics.online) {
             if (truthy(np) || np === 'online')
                 this.online = true;
             if (falsy(np) || np === 'offline')
                 this.online = false;
         }
+        // tamper
         if (topic === this.cfg.topics.tamper) {
             if (truthy(np) || ['tamper', 'intrusion', 'cover', 'motion', 'magnetic'].includes(np)) {
                 this.tampered = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
             }
-            else if (falsy(np))
+            else if (falsy(np)) {
                 this.tampered = false;
+            }
         }
+        // battery
         if (topic === this.cfg.topics.batteryLevel) {
             const n = clamp(parseFloat(p), 0, 100);
             if (isFinite(n))
                 this.batteryLevel = n;
         }
         else if (topic === this.cfg.topics.lowBattery && !this.cfg.topics.batteryLevel) {
+            // Solo se abbiamo lowBattery (booleano) ma NON batteryLevel:
+            // True  -> 10% (warning)
+            // False -> 100% (ok)
             this.batteryLevel = truthy(np) ? 10 : 100;
         }
+        // primary handled by subclasses
         this.handlePrimary(topic, np, p);
     }
 }
 class ContactMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
-        if (topic === this.cfg.topics.contact)
+    constructor(nativeId, cfg) {
+        super(nativeId, cfg);
+    }
+    handlePrimary(topic, np, _raw) {
+        if (topic === this.cfg.topics.contact) {
             this.entryOpen = truthy(np);
+        }
     }
 }
 class MotionMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
-        if (topic === this.cfg.topics.motion)
+    constructor(nativeId, cfg) {
+        super(nativeId, cfg);
+    }
+    handlePrimary(topic, np, _raw) {
+        if (topic === this.cfg.topics.motion) {
             this.motionDetected = truthy(np);
+        }
     }
 }
 class OccupancyMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
-        if (topic === this.cfg.topics.occupancy)
+    constructor(nativeId, cfg) {
+        super(nativeId, cfg);
+    }
+    handlePrimary(topic, np, _raw) {
+        if (topic === this.cfg.topics.occupancy) {
             this.occupied = truthy(np);
+        }
     }
 }
 /** ----------------- Main Plugin ----------------- */
-class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
+class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
     constructor() {
         super();
+        // sensor management
         this.sensorsCfg = [];
         this.devices = new Map();
-        this.triedDiscoveryOnce = false;
-        // Tipo in UI (best-effort)
+        // (facoltativo) Imposta il device type in UI
         setTimeout(() => {
             try {
-                systemManager.getDeviceById(this.id)?.setType?.(ScryptedDeviceType.SecuritySystem);
+                systemManager.getDeviceById(this.id)?.setType?.(sdk_1.ScryptedDeviceType.SecuritySystem);
             }
             catch { }
         });
-        // Stato di default
+        // Default state
         this.securitySystemState = this.securitySystemState || {
-            mode: SecuritySystemMode.Disarmed,
+            mode: sdk_1.SecuritySystemMode.Disarmed,
             supportedModes: [
-                SecuritySystemMode.Disarmed,
-                SecuritySystemMode.HomeArmed,
-                SecuritySystemMode.AwayArmed,
-                SecuritySystemMode.NightArmed,
+                sdk_1.SecuritySystemMode.Disarmed,
+                sdk_1.SecuritySystemMode.HomeArmed,
+                sdk_1.SecuritySystemMode.AwayArmed,
+                sdk_1.SecuritySystemMode.NightArmed,
             ],
         };
         this.online = this.online ?? false;
-        // Config sensori e announce
+        // Load sensors config and announce devices
         this.loadSensorsFromStorage();
-        this.safeDiscoverSensors(); // non spamma se deviceManager non c'è
-        // Connect MQTT
-        this.connectMqtt().catch((e) => this.console.error('MQTT connect error:', e));
-        // Shutdown pulito
+        this.discoverSensors().catch(e => this.console.error('discoverSensors error', e));
+        // Connect on start
+        this.connectMqtt().catch(e => this.console.error('MQTT connect error:', e));
+        // chiusura pulita del client MQTT ai reload/stop del plugin
         try {
             process.once('SIGTERM', () => { try {
                 this.client?.end(true);
@@ -34182,7 +34227,7 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         }
         catch { }
     }
-    /** ---- Settings ---- */
+    // helpers persistenza
     saveSensorsToStorage() {
         try {
             this.storage.setItem('sensorsJson', JSON.stringify(this.sensorsCfg));
@@ -34191,14 +34236,17 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             this.console.error('saveSensorsToStorage error', e);
         }
     }
+    /** ---- Settings UI ---- */
     async getSettings() {
         const out = [
+            // MQTT Core
             { group: 'MQTT', key: 'brokerUrl', title: 'Broker URL', placeholder: 'mqtt://127.0.0.1:1883', value: this.storage.getItem('brokerUrl') || 'mqtt://127.0.0.1:1883' },
             { group: 'MQTT', key: 'username', title: 'Username', type: 'string', value: this.storage.getItem('username') || '' },
             { group: 'MQTT', key: 'password', title: 'Password', type: 'password', value: this.storage.getItem('password') || '' },
             { group: 'MQTT', key: 'clientId', title: 'Client ID', placeholder: 'scrypted-paradox', value: this.storage.getItem('clientId') || 'scrypted-paradox' },
             { group: 'MQTT', key: 'tls', title: 'Use TLS', type: 'boolean', value: this.storage.getItem('tls') === 'true' },
             { group: 'MQTT', key: 'rejectUnauthorized', title: 'Reject Unauthorized (TLS)', type: 'boolean', value: this.storage.getItem('rejectUnauthorized') !== 'false', description: 'Disattiva solo con broker self-signed.' },
+            // Alarm Topics
             { group: 'Alarm Topics', key: 'topicSetTarget', title: 'Set Target State (publish)', placeholder: 'paradox/control/partitions/Area_1', value: this.storage.getItem('topicSetTarget') || '' },
             { group: 'Alarm Topics', key: 'topicGetTarget', title: 'Get Target State (subscribe)', placeholder: 'paradox/states/partitions/Area_1/target_state', value: this.storage.getItem('topicGetTarget') || '' },
             { group: 'Alarm Topics', key: 'topicGetCurrent', title: 'Get Current State (subscribe)', placeholder: 'paradox/states/partitions/Area_1/current_state', value: this.storage.getItem('topicGetCurrent') || '' },
@@ -34206,69 +34254,32 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             { group: 'Alarm Topics', key: 'topicOnline', title: 'Get Online (subscribe)', placeholder: 'paradox/interface/availability', value: this.storage.getItem('topicOnline') || '' },
             { group: 'Publish Options', key: 'qos', title: 'QoS', type: 'integer', value: parseInt(this.storage.getItem('qos') || '0') },
             { group: 'Publish Options', key: 'retain', title: 'Retain', type: 'boolean', value: this.storage.getItem('retain') === 'true' },
-            // ---- Danger Zone ----
-            { group: 'Danger Zone', key: 'danger.resetSensors', title: 'Reset all sensors (wipe)', type: 'boolean', description: 'Cancella tutti i sensori salvati e rimuove i device annunciati.' },
-            { group: 'Danger Zone', key: 'danger.export', title: 'Export sensors JSON (read-only)', value: JSON.stringify(this.sensorsCfg, null, 2), readonly: true },
-            { group: 'Danger Zone', key: 'danger.import', title: 'Import sensors JSON (paste & Save)', type: 'string', placeholder: '[]', description: 'Incolla JSON valido per sovrascrivere l’elenco sensori.' },
         ];
-        // ---- Add Sensor
-        out.push({ group: 'Add Sensor', key: 'new.id', title: 'New Sensor ID', placeholder: 'porta-sogg', value: this.storage.getItem('new.id') || '' }, { group: 'Add Sensor', key: 'new.name', title: 'Name', placeholder: 'Porta Soggiorno', value: this.storage.getItem('new.name') || '' }, { group: 'Add Sensor', key: 'new.kind', title: 'Type', value: this.storage.getItem('new.kind') || 'contact', choices: ['contact', 'motion', 'occupancy'] }, { group: 'Add Sensor', key: 'new.create', title: 'Create sensor', type: 'boolean', description: 'Toggle ON e Save per creare.' });
-        // ---- Sensors esistenti
+        // ---- UI Add Sensor ----
+        out.push({ group: 'Add Sensor', key: 'new.id', title: 'New Sensor ID', placeholder: 'porta-ingresso', value: this.storage.getItem('new.id') || '' }, { group: 'Add Sensor', key: 'new.name', title: 'Name', placeholder: 'Porta Ingresso', value: this.storage.getItem('new.name') || '' }, { group: 'Add Sensor', key: 'new.kind', title: 'Type', value: this.storage.getItem('new.kind') || 'contact', choices: ['contact', 'motion', 'occupancy'] }, { group: 'Add Sensor', key: 'new.create', title: 'Create sensor', type: 'boolean', description: 'Fill the fields above and toggle this on to create the sensor. After creation, restart this plugin to see the accessory listed below. To show it in HomeKit, restart the HomeKit plugin as well.' });
+        // ---- UI per sensori esistenti ----
         for (const cfg of this.sensorsCfg) {
             const gid = `Sensor: ${cfg.name} [${cfg.id}]`;
-            out.push({ group: gid, key: `sensor.${cfg.id}.id`, title: 'ID (read-only)', value: cfg.id, readonly: true, description: 'L’ID identifica il device. Evita spazi/puntini.' }, { group: gid, key: `sensor.${cfg.id}.name`, title: 'Name', value: cfg.name }, { group: gid, key: `sensor.${cfg.id}.kind`, title: 'Type', value: cfg.kind, choices: ['contact', 'motion', 'occupancy'] }, { group: gid, key: `sensor.${cfg.id}.renameTo`, title: 'Clone/Rename → New ID', placeholder: 'es. porta-sogg', description: 'Compila e Save per clonare con nuovo ID e rimuovere il vecchio.' });
-            if (cfg.kind === 'contact')
-                out.push({ group: gid, key: `sensor.${cfg.id}.topic.contact`, title: 'Contact State Topic', value: cfg.topics.contact || '' });
-            else if (cfg.kind === 'motion')
-                out.push({ group: gid, key: `sensor.${cfg.id}.topic.motion`, title: 'Motion Detected Topic', value: cfg.topics.motion || '' });
-            else
-                out.push({ group: gid, key: `sensor.${cfg.id}.topic.occupancy`, title: 'Occupancy Detected Topic', value: cfg.topics.occupancy || '' });
+            out.push({ group: gid, key: `sensor.${cfg.id}.name`, title: 'Name', value: cfg.name }, { group: gid, key: `sensor.${cfg.id}.kind`, title: 'Type', value: cfg.kind, choices: ['contact', 'motion', 'occupancy'] });
+            // primary per tipo
+            if (cfg.kind === 'contact') {
+                out.push({ group: gid, key: `sensor.${cfg.id}.topic.contact`, title: 'Contact State Topic', value: cfg.topics.contact || '', placeholder: 'paradox/states/zones/XYZ/open' });
+            }
+            else if (cfg.kind === 'motion') {
+                out.push({ group: gid, key: `sensor.${cfg.id}.topic.motion`, title: 'Motion Detected Topic', value: cfg.topics.motion || '', placeholder: 'paradox/states/zones/XYZ/open' });
+            }
+            else {
+                out.push({ group: gid, key: `sensor.${cfg.id}.topic.occupancy`, title: 'Occupancy Detected Topic', value: cfg.topics.occupancy || '', placeholder: 'paradox/states/zones/XYZ/open' });
+            }
+            // extra opzionali
             out.push({ group: gid, key: `sensor.${cfg.id}.topic.batteryLevel`, title: 'Battery Level Topic (0..100)', value: cfg.topics.batteryLevel || '' }, { group: gid, key: `sensor.${cfg.id}.topic.lowBattery`, title: 'Low Battery Topic (bool)', value: cfg.topics.lowBattery || '' }, { group: gid, key: `sensor.${cfg.id}.topic.tamper`, title: 'Tamper Topic', value: cfg.topics.tamper || '' }, { group: gid, key: `sensor.${cfg.id}.topic.online`, title: 'Online Topic', value: cfg.topics.online || '' }, { group: gid, key: `sensor.${cfg.id}.remove`, title: 'Remove sensor', type: 'boolean' });
         }
         return out;
     }
     async putSetting(key, value) {
+        // salva sempre nella storage la value del campo (così resta in UI)
         this.storage.setItem(key, String(value));
-        // ---- Danger Zone: reset all ----
-        if (key === 'danger.resetSensors' && String(value) === 'true') {
-            this.storage.removeItem('danger.resetSensors');
-            // rimuovi device annunciati
-            try {
-                const dm = sdk?.deviceManager;
-                for (const nativeId of Array.from(this.devices.keys())) {
-                    try {
-                        dm?.onDeviceRemoved?.(nativeId);
-                    }
-                    catch { }
-                }
-            }
-            catch { }
-            this.devices.clear();
-            this.sensorsCfg = [];
-            this.saveSensorsToStorage();
-            this.safeDiscoverSensors(true);
-            await this.connectMqtt(true);
-            return;
-        }
-        // ---- Danger Zone: import JSON ----
-        if (key === 'danger.import') {
-            try {
-                const parsed = JSON.parse(String(value) || '[]');
-                if (!Array.isArray(parsed))
-                    throw new Error('JSON non è un array.');
-                // sanifica
-                this.sensorsCfg = (parsed || []).filter(x => x && x.id && x.name && x.kind && x.topics);
-                this.saveSensorsToStorage();
-                this.storage.removeItem('danger.import');
-                this.safeDiscoverSensors(true);
-                await this.connectMqtt(true);
-            }
-            catch (e) {
-                this.console.error('Import JSON error:', e);
-            }
-            return;
-        }
-        // ---- Add Sensor ----
+        // --- Add Sensor workflow ---
         if (key === 'new.create' && String(value) === 'true') {
             const id = (this.storage.getItem('new.id') || '').trim();
             const name = (this.storage.getItem('new.name') || '').trim() || id;
@@ -34283,15 +34294,16 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             }
             this.sensorsCfg.push({ id, name, kind, topics: {} });
             this.saveSensorsToStorage();
+            // pulisci i campi "new.*"
             this.storage.removeItem('new.id');
             this.storage.removeItem('new.name');
             this.storage.removeItem('new.kind');
             this.storage.removeItem('new.create');
-            this.safeDiscoverSensors(true);
+            await this.discoverSensors();
             await this.connectMqtt(true);
             return;
         }
-        // ---- Edit/Remove/Rename sensore ----
+        // --- Edit/Remove sensore esistente ---
         const m = key.match(/^sensor\.([^\.]+)\.(.+)$/);
         if (m) {
             const sid = m[1];
@@ -34301,60 +34313,41 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                 this.console.warn('putSetting: sensor non trovato', sid);
                 return;
             }
-            // rename/clone
-            if (prop === 'renameTo') {
-                const newId = String(value).trim();
-                this.storage.removeItem(key);
-                if (!newId)
-                    return;
-                if (this.sensorsCfg.find(s => s.id === newId)) {
-                    this.console.warn('renameTo: ID già esistente:', newId);
-                    return;
-                }
-                const cloned = { ...cfg, id: newId, name: cfg.name };
-                this.sensorsCfg.push(cloned);
-                // rimuovi vecchio
-                this.sensorsCfg = this.sensorsCfg.filter(s => s !== cfg);
-                try {
-                    sdk?.deviceManager?.onDeviceRemoved?.(`sensor:${sid}`);
-                }
-                catch { }
-                this.saveSensorsToStorage();
-                this.safeDiscoverSensors(true);
-                await this.connectMqtt(true);
-                return;
-            }
-            // remove
             if (prop === 'remove' && String(value) === 'true') {
+                // elimina
                 this.sensorsCfg = this.sensorsCfg.filter(s => s.id !== sid);
                 this.saveSensorsToStorage();
                 try {
-                    sdk?.deviceManager?.onDeviceRemoved?.(`sensor:${sid}`);
+                    this.devices.delete(`sensor:${sid}`);
+                    deviceManager.onDeviceRemoved?.(`sensor:${sid}`);
                 }
                 catch { }
+                // pulisci flag
                 this.storage.removeItem(key);
-                this.safeDiscoverSensors(true);
+                await this.discoverSensors();
                 await this.connectMqtt(true);
                 return;
             }
-            // edit
-            if (prop === 'name')
+            if (prop === 'name') {
                 cfg.name = String(value);
-            else if (prop === 'kind')
+            }
+            else if (prop === 'kind') {
                 cfg.kind = String(value);
+            }
             else if (prop.startsWith('topic.')) {
                 const tk = prop.substring('topic.'.length);
                 cfg.topics[tk] = String(value).trim();
             }
             this.saveSensorsToStorage();
-            this.safeDiscoverSensors(true);
+            await this.discoverSensors();
             await this.connectMqtt(true);
             return;
         }
-        // Altre impostazioni: riconnetti
+        // --- Altro (MQTT / Alarm settings) ---
         if (key === 'sensorsJson') {
+            // non più mostrato, ma se presente da vecchie versioni
             this.loadSensorsFromStorage();
-            this.safeDiscoverSensors(true);
+            await this.discoverSensors();
             await this.connectMqtt(true);
         }
         else {
@@ -34362,14 +34355,17 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         }
     }
     /** ---- DeviceProvider ---- */
-    async getDevice(nativeId) { return this.devices.get(nativeId); }
+    async getDevice(nativeId) {
+        return this.devices.get(nativeId);
+    }
     async releaseDevice(_id, nativeId) {
         try {
             const dev = this.devices.get(nativeId);
-            if (dev)
+            if (dev) {
                 this.devices.delete(nativeId);
+            }
             try {
-                sdk?.deviceManager?.onDeviceRemoved?.(nativeId);
+                deviceManager.onDeviceRemoved?.(nativeId);
             }
             catch { }
         }
@@ -34381,6 +34377,7 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         try {
             const raw = this.storage.getItem('sensorsJson') || '[]';
             const parsed = JSON.parse(raw);
+            // sanitize
             this.sensorsCfg = (parsed || []).filter(x => x && x.id && x.name && x.kind && x.topics);
         }
         catch (e) {
@@ -34388,47 +34385,42 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             this.sensorsCfg = [];
         }
     }
-    /** Annuncia i sensori SOLO se deviceManager è pronto. */
-    safeDiscoverSensors(triggeredByChange = false) {
-        const dmAny = sdk?.deviceManager;
-        if (!dmAny) {
-            if (!this.triedDiscoveryOnce) {
-                this.console.log('Device discovery postponed: deviceManager not ready yet.');
-                this.triedDiscoveryOnce = true;
-            }
-            return;
-        }
-        this.triedDiscoveryOnce = false;
-        this.discoverSensors(dmAny);
-    }
-    /** discoverSensors con deviceManager garantito */
-    discoverSensors(dmAny) {
-        // 1) Manifests
+    /** ===== discoverSensors: annuncia PRIMA, istanzia DOPO ===== */
+    async discoverSensors() {
+        // 1) Prepara i manifest (niente istanze qui)
         const manifests = this.sensorsCfg.map(cfg => {
             const nativeId = `sensor:${cfg.id}`;
             const t = cfg.topics || {};
-            const interfaces = [ScryptedInterface.Online];
+            const interfaces = [sdk_1.ScryptedInterface.Online];
+            // Tamper solo se c'è un topic tamper
             if (t.tamper)
-                interfaces.push(ScryptedInterface.TamperSensor);
+                interfaces.push(sdk_1.ScryptedInterface.TamperSensor);
+            // Interfaccia primaria
             if (cfg.kind === 'contact')
-                interfaces.unshift(ScryptedInterface.EntrySensor);
+                interfaces.unshift(sdk_1.ScryptedInterface.EntrySensor);
             else if (cfg.kind === 'motion')
-                interfaces.unshift(ScryptedInterface.MotionSensor);
+                interfaces.unshift(sdk_1.ScryptedInterface.MotionSensor);
             else
-                interfaces.unshift(ScryptedInterface.OccupancySensor);
-            if (t.batteryLevel || t.lowBattery)
-                interfaces.push(ScryptedInterface.Battery);
-            return { nativeId, name: cfg.name, type: ScryptedDeviceType.Sensor, interfaces };
+                interfaces.unshift(sdk_1.ScryptedInterface.OccupancySensor);
+            // Battery solo se previsto
+            if (t.batteryLevel || t.lowBattery) {
+                interfaces.push(sdk_1.ScryptedInterface.Battery);
+            }
+            return { nativeId, name: cfg.name, type: sdk_1.ScryptedDeviceType.Sensor, interfaces };
         });
         // 2) Annuncio
+        const dmAny = deviceManager;
         if (typeof dmAny.onDevicesChanged === 'function') {
             dmAny.onDevicesChanged({ devices: manifests });
+            this.console.log('Annunciati (batch):', manifests.map(m => m.nativeId).join(', '));
         }
-        else if (typeof dmAny.onDeviceDiscovered === 'function') {
-            for (const m of manifests)
-                dmAny.onDeviceDiscovered(m);
+        else {
+            for (const m of manifests) {
+                deviceManager.onDeviceDiscovered(m);
+                this.console.log('Annunciato:', m.nativeId);
+            }
         }
-        // 3) Istanzia/aggiorna
+        // 3) Istanzia/aggiorna DOPO l’annuncio
         for (const cfg of this.sensorsCfg) {
             const nativeId = `sensor:${cfg.id}`;
             let dev = this.devices.get(nativeId);
@@ -34444,17 +34436,20 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             else {
                 dev.cfg = cfg;
             }
+            // Default “OK” se abbiamo Battery ma nessun valore ancora ricevuto
             const hasBattery = !!(cfg.topics.batteryLevel || cfg.topics.lowBattery);
-            if (hasBattery && dev.batteryLevel === undefined)
+            if (hasBattery && dev.batteryLevel === undefined) {
                 dev.batteryLevel = 100;
+            }
         }
-        // 4) Cleanup
+        // 4) Rimuovi quelli spariti
         const announced = new Set(manifests.map(m => m.nativeId));
         for (const [nativeId] of this.devices) {
             if (!announced.has(nativeId)) {
                 try {
                     this.devices.delete(nativeId);
-                    dmAny.onDeviceRemoved?.(nativeId);
+                    deviceManager.onDeviceRemoved?.(nativeId);
+                    this.console.log('Rimosso:', nativeId);
                 }
                 catch { }
             }
@@ -34468,7 +34463,13 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         const clientId = this.storage.getItem('clientId') || 'scrypted-paradox';
         const tls = this.storage.getItem('tls') === 'true';
         const rejectUnauthorized = this.storage.getItem('rejectUnauthorized') !== 'false';
-        const opts = { clientId, username, password, clean: true, reconnectPeriod: 3000 };
+        const opts = {
+            clientId,
+            username,
+            password,
+            clean: true,
+            reconnectPeriod: 3000,
+        };
         if (tls) {
             opts.protocol = 'mqtts';
             opts.rejectUnauthorized = rejectUnauthorized;
@@ -34477,34 +34478,38 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
     }
     collectAllSubscriptions() {
         const subs = new Set();
+        // alarm
         for (const k of ['topicGetTarget', 'topicGetCurrent', 'topicTamper', 'topicOnline']) {
             const v = this.storage.getItem(k);
             if (v)
                 subs.add(v);
         }
+        // sensors
         for (const s of this.sensorsCfg) {
             const t = s.topics || {};
             [t.contact, t.motion, t.occupancy, t.batteryLevel, t.lowBattery, t.tamper, t.online]
-                .filter(Boolean).forEach(x => subs.add(String(x)));
+                .filter(Boolean)
+                .forEach(x => subs.add(String(x)));
         }
         return Array.from(subs);
     }
     async connectMqtt(_reconnect = false) {
         const subs = this.collectAllSubscriptions();
-        if (!subs.length && !this.storage.getItem('topicSetTarget'))
+        if (!subs.length && !this.storage.getItem('topicSetTarget')) {
             this.console.warn('Configura almeno un topic nelle impostazioni.');
+        }
         if (this.client) {
             try {
                 this.client.end(true);
             }
             catch { }
-            ;
             this.client = undefined;
         }
         const { url, opts } = this.getMqttOptions();
         this.console.log(`Connecting MQTT ${url} ...`);
         const client = mqtt_1.default.connect(url, opts);
         this.client = client;
+        // cache alarm topics for fast compare
         const tTarget = this.storage.getItem('topicGetTarget') || '';
         const tCurrent = this.storage.getItem('topicGetCurrent') || '';
         const tTamper = this.storage.getItem('topicTamper') || '';
@@ -34512,11 +34517,12 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         client.on('connect', () => {
             this.console.log('MQTT connected');
             this.online = true;
-            if (subs.length)
-                client.subscribe(subs, { qos: 0 }, (err) => { if (err)
-                    this.console.error('subscribe error', err); });
-            // Al primo connect riprova ad annunciare i sensori
-            this.safeDiscoverSensors(true);
+            if (subs.length) {
+                client.subscribe(subs, { qos: 0 }, (err) => {
+                    if (err)
+                        this.console.error('subscribe error', err);
+                });
+            }
         });
         client.on('reconnect', () => this.console.log('MQTT reconnecting...'));
         client.on('close', () => { this.console.log('MQTT closed'); this.online = false; });
@@ -34525,6 +34531,7 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             try {
                 const p = payload?.toString() ?? '';
                 const np = normalize(p);
+                // ---- Alarm handling ----
                 if (topic === tOnline) {
                     if (truthy(np) || np === 'online')
                         this.online = true;
@@ -34533,26 +34540,29 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                     return;
                 }
                 if (topic === tTamper) {
-                    if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np))
+                    if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np)) {
                         this.tampered = ['cover', 'intrusion'].find(x => x === np) || true;
-                    else if (falsy(np))
+                    }
+                    else if (falsy(np)) {
                         this.tampered = false;
+                    }
                     return;
                 }
                 if (topic === tCurrent) {
                     const mode = payloadToMode(payload);
                     const isAlarm = ['alarm', 'triggered'].includes(np);
-                    const current = this.securitySystemState || { mode: SecuritySystemMode.Disarmed };
-                    this.securitySystemState = {
+                    const current = this.securitySystemState || { mode: sdk_1.SecuritySystemMode.Disarmed };
+                    const newState = {
                         mode: mode ?? current.mode,
                         supportedModes: current.supportedModes ?? [
-                            SecuritySystemMode.Disarmed,
-                            SecuritySystemMode.HomeArmed,
-                            SecuritySystemMode.AwayArmed,
-                            SecuritySystemMode.NightArmed,
+                            sdk_1.SecuritySystemMode.Disarmed,
+                            sdk_1.SecuritySystemMode.HomeArmed,
+                            sdk_1.SecuritySystemMode.AwayArmed,
+                            sdk_1.SecuritySystemMode.NightArmed,
                         ],
                         triggered: isAlarm || undefined,
                     };
+                    this.securitySystemState = newState;
                     return;
                 }
                 if (topic === tTarget) {
@@ -34560,11 +34570,10 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                     this.console.log('Target state reported:', p, '->', this.pendingTarget);
                     return;
                 }
-                // Dispatch ai sensori + eventuale discover ritardato
-                if (this.triedDiscoveryOnce)
-                    this.safeDiscoverSensors(true);
-                for (const dev of this.devices.values())
+                // ---- Sensor dispatch ----
+                for (const dev of this.devices.values()) {
                     dev.handleMqtt(topic, payload);
+                }
             }
             catch (e) {
                 this.console.error('MQTT message handler error', e);
@@ -34589,21 +34598,21 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
     async armSecuritySystem(mode) {
         const payload = this.getOutgoing(mode);
         this.console.log('armSecuritySystem', mode, '->', payload);
-        this.pendingTarget = mode;
+        this.pendingTarget = mode; // memorizza target, ma NON cambiare il current
         this.publishSetTarget(payload);
     }
     async disarmSecuritySystem() {
-        const payload = this.getOutgoing(SecuritySystemMode.Disarmed);
+        const payload = this.getOutgoing(sdk_1.SecuritySystemMode.Disarmed);
         this.console.log('disarmSecuritySystem ->', payload);
-        this.pendingTarget = SecuritySystemMode.Disarmed;
+        this.pendingTarget = sdk_1.SecuritySystemMode.Disarmed;
         this.publishSetTarget(payload);
     }
     getOutgoing(mode) {
         const map = {
-            [SecuritySystemMode.Disarmed]: this.storage.getItem('payloadDisarm') || DEFAULT_OUTGOING[SecuritySystemMode.Disarmed],
-            [SecuritySystemMode.HomeArmed]: this.storage.getItem('payloadHome') || DEFAULT_OUTGOING[SecuritySystemMode.HomeArmed],
-            [SecuritySystemMode.AwayArmed]: this.storage.getItem('payloadAway') || DEFAULT_OUTGOING[SecuritySystemMode.AwayArmed],
-            [SecuritySystemMode.NightArmed]: this.storage.getItem('payloadNight') || DEFAULT_OUTGOING[SecuritySystemMode.NightArmed],
+            [sdk_1.SecuritySystemMode.Disarmed]: this.storage.getItem('payloadDisarm') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.Disarmed],
+            [sdk_1.SecuritySystemMode.HomeArmed]: this.storage.getItem('payloadHome') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.HomeArmed],
+            [sdk_1.SecuritySystemMode.AwayArmed]: this.storage.getItem('payloadAway') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.AwayArmed],
+            [sdk_1.SecuritySystemMode.NightArmed]: this.storage.getItem('payloadNight') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.NightArmed],
         };
         return map[mode];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfranzoi/scrypted-mqtt-securitysystem",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "description": "Scrypted plugin: Paradox Security System via MQTT (PAI/PAI-MQTT style).",
   "license": "MIT",
   "main": "dist/main.nodejs.js",