@pellebot/homebridge-fritz-platform-hb2 1.2.1 → 1.3.0

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 > **Hinweis zum Format:** Releases ab `v1.0.0` werden unter dem npm-Paket `@pellebot/homebridge-fritz-platform-hb2` veröffentlicht. Die `6.1.0-hb2patch.x` Pre-Releases sind Vorstufen unter dem alten Paketnamen `@pellebot/homebridge-fritz-platform` (deprecated). Die `registerPlatform`-Kennung bleibt durchgängig `homebridge-fritz-platform`, sodass cached Accessories über den Rename hinweg matchen — kein Re-Pairing nötig.
 
+# v1.3.0 — 2026-11-15 (Presence als Opt-in)
+
+**WLAN-Anwesenheit („Presence“) ist als optionale Funktion zurück.** Auf Anfrage aus der Community (Haushalt nur mit Apple-Geräten) zeigt das Plugin wieder an, ob ein Gerät — typisch ein iPhone — im Netz der FRITZ!Box ist. Standardmäßig ist die Funktion aus; sie wirkt nur für `presence`-Einträge mit `active: true`.
+
+## Neuerungen
+
+- **Presence-Sensor je Gerät**: Zuordnung über IPv4- oder MAC-Adresse (Groß-/Kleinschreibung egal), Accessory-Typ `occupancy` (Belegungssensor, Standard) oder `motion` (Bewegungssensor). Grundlage ist der vorhandene Code des Original-Plugins in `src/accessories/presence/`, nach dem Minimal-Patch-Prinzip wieder eingebunden.
+- **Abmeldeverzögerung `offDelay`** (Standard **300 s**): Der Sensor meldet „weg“ erst, wenn das Gerät so lange nicht mehr verbunden war. Verhindert das Springen, wenn ein schlafendes iPhone kurz aus dem WLAN geht. Unter 60 s warnt das Log. `onDelay` (Standard 0 s) für die Anmeldung.
+- **Optional „Anyone“** (jemand ist zu Hause) und **„Guest“** (Gerät im Gast-WLAN) über `options.presence`.
+- **`config.schema.json`**: neuer Abschnitt „Presence (WLAN, optional)“ und `options.presence`.
+- **Setup-Wizard**: Schritt 4 hat einen aufklappbaren Abschnitt „Anwesenheit per WLAN“ (Geräte anlegen, Anyone/Guest). Bestehende `presence`-Einträge werden beim erneuten Speichern übernommen und nicht mehr verworfen.
+- **CI**: Mock-Test `ci/presence-mock-test.cjs` (Opt-in, Verzögerung, MAC-Abgleich, Anyone/Guest) auf Node 22 und 24.
+
+## Korrekturen am übernommenen Code
+
+- MAC-Adressen in Kleinbuchstaben wurden bisher verworfen bzw. nicht gefunden; jetzt werden sie normalisiert und ohne Beachtung der Schreibweise abgeglichen.
+- Fehlt `offDelay`, gilt jetzt 300 s statt 0 s (vorher sprang der Sensor bei jeder kurzen WLAN-Abmeldung). Ein ausdrücklich gesetzter Wert, auch 0, bleibt erhalten.
+- Aufruf von `historyService.getInitialTime()` im Motion-Pfad wird defensiv geprüft (siehe Issue #2).
+- `src/accessories/presence/` ist nicht mehr in `.npmignore` ausgeschlossen (sonst fehlte der Code im npm-Paket).
+
+## Nicht übernommen
+
+Ping-Prüfung (`ping`, `threshold`) und Telegram-Meldungen (`blockTelegram`) des Original-Plugins.
+
+## Breaking Changes
+
+Keine. Ohne `presence`-Konfiguration verhält sich das Plugin wie v1.2.x. Wer aus dem Original-Plugin noch `presence`-Einträge mit `active: true` in der Config hat, bekommt diese Sensoren jetzt wieder angezeigt.
+
+## Getestet
+
+Mock-Test in der CI (Node 22/24) und Hardwaretest am 15.11.2026: Homebridge 2.4.0, FRITZ!Box mit drei FRITZ!Repeatern im Mesh, iPhone mit fester privater WLAN-Adresse. Anmeldung erkannt, 25 min gesperrtes iPhone ohne Fehlwechsel, Abmeldung nach 309 s (300 s Verzögerung + Polling), erneute Anmeldung erkannt. Nicht getestet: Dauerlauf über Nacht, Motion-Typ, Gast-WLAN.
+
+## Bekannte Limitationen
+
+- iPhones mit „private WLAN-Adresse: Rotierend“ wechseln die MAC; für das Heim-WLAN auf „Fest“ stellen (README).
+- Die am iPhone angezeigte WLAN-Adresse kann von der abweichen, die die FRITZ!Box führt (beobachtet mit FRITZ!Repeatern im Mesh). MAC-Adresse aus der FRITZ!Box-Oberfläche nehmen oder besser die IPv4-Adresse dort dauerhaft zuweisen und die IP eintragen.
+- Je Sensor nur eine Adresse.
+- Die FRITZ!Box meldet nur „verbunden“, nicht „Person anwesend“. Erkennung frühestens nach einem Polling-Zyklus (`options.polling.timer`) plus Verzögerung.
+- Jeder Zyklus fragt die Host-Liste der FRITZ!Box ab (zusätzliche Last).
+- Der Bewegungssensor zeigt in der Eve-App keinen Verlauf (fakegato gestubbt).
+- Die Charakteristik „Last Activation“ des Bewegungssensors zählt ab Start der Bridge (fakegato-Stub mit `getInitialTime()` aus v1.2.1).
+
+---
+
 # v1.2.1 — 2026-11-14 (Bugfix: Absturz bei offenem Fenster)
 
 **Behebt #2.** Sobald ein Thermostat ein offenes Fenster meldete (`windowOpen: 1`) oder ein Kontakt-/Fenstersensor öffnete, stürzte die Child-Bridge mit `TypeError: historyService.getInitialTime is not a function` ab. Nach fünf Abstürzen stoppte Homebridge die Child-Bridge, und das ganze Plugin fiel aus, solange das Fenster offen war.
@@ -19,6 +63,8 @@ Der NoOp-Ersatz für fakegato-history in `src/platform.js` bildete nur `addEntry
 
 Keine.
 
+---
+
 # v1.2.0 — 2026-05-14 (Wizard Edit-Mode / Phase G)
 
 **Setup-Wizard erhält Aktualisierungs-Routine.** Beim erneuten Aufruf des Wizards (z.B. um ein weiteres Gerät hinzuzufügen) werden die in `config.json` gespeicherten Einstellungen jetzt vorgeladen statt überschrieben. Damit ist der Hauptschmerz aus v1.1.x adressiert: manuell vergebene Tile-Namen, gewählter `accType` (z.B. `energy-light` statt `energy-temperature`) und Router-Switch-Zustände überleben einen Wizard-Re-Run unverändert.

package/README.md

@@ -27,6 +27,7 @@ Production: läuft produktiv beim Maintainer mit 12 DECT-Thermostaten, 1 DECT-La
 | FRITZ!DECT 200 / 210 (schaltbare Steckdose) | `switch` | An/Aus + optional Energiemessung |
 | FRITZ!Smart Energy 250 (OBIS-Reader, an ISKRA o.ä.) | `energy-temperature` oder `energy-light` | Aktuelle Leistung in W, kumulierte Energie in kWh — entweder als TemperatureSensor (°C-Tile, prominent im Raum) oder LightSensor (lx-Tile, passive Sensor-Anzeige, per Favorit ins Home-Tab holbar) |
 | FRITZ!Box Router (Master) | (via `options`) | Gast-WLAN-Switch, WPS-Switch, optional weitere Toggles |
+| Handy/Tablet im WLAN (optional, seit v1.3.0) | `presence[]` mit `occupancy` oder `motion` | Anwesenheit: Belegungs- oder Bewegungssensor je Gerät, optional „Anyone“ und „Guest“ |
 
 ## Architektur
 
@@ -42,13 +43,14 @@ Das **Router-Accessory** (Master FritzBox) wird per default mit `hide: true` aus
 Aus dem ursprünglichen Code-Baum entfernt oder nicht migriert — wer eine dieser Funktionen braucht, ist hier nicht richtig:
 
 - **Callmonitor** (Anrufüberwachung)
-- **Presence** (WLAN-Anwesenheit)
 - **Network-Watcher**
 - **Wake-on-LAN**
 - **Child Lock** (Internet-Sperren)
 - **Extras-Subsysteme** (DNS-Switch, Fallback-Internet, Phonebook, Telegram-Notifications) — die WiFi/WPS-Switches der Extras-Datei sind ausgenommen und voll funktional
 - **`fakegato-history`** (Eve-App History-Graphen — als No-Op gestubbt weil HAP-v2-inkompatibel)
 
+**Presence** (WLAN-Anwesenheit) war bis v1.2.0 ausgeschlossen und ist seit **v1.3.0 als optionale Funktion** zurück — standardmäßig aus, siehe [Anwesenheit per WLAN](#anwesenheit-per-wlan-optional-seit-v130). Telegram-Meldungen und die Ping-Prüfung des Original-Plugins gehören nicht dazu.
+
 ## Voraussetzungen
 
 - **Homebridge** ≥ 1.8.5 oder ≥ 2.0.0
@@ -191,6 +193,50 @@ Beide werden seit v1.1.1 unterstützt. Standard ist `energy-temperature`. Empfeh
 
 **Richtungs-Trennung:** AVM spiegelt den NET-Power-Wert auf beiden Sub-AINs (gleiche Zahl mit Vorzeichen). Das Plugin trennt das anhand des AIN-Suffixes — `-1` zeigt den Wert nur wenn `power > 0` (Bezug), `-2` zeigt `|power|` nur wenn `power < 0` (Einspeisung). Im Ruhe-/Inverse-Zustand zeigt die jeweils andere Kachel `0`.
 
+### Anwesenheit per WLAN (optional, seit v1.3.0)
+
+Zeigt in HomeKit, ob ein Gerät (typisch: iPhone) im Netz der FRITZ!Box ist — als **Belegungssensor** (`occupancy`, Standard) oder **Bewegungssensor** (`motion`). Damit lassen sich Automationen wie „Letzte Person geht → Heizung runter“ bauen, ohne Standortfreigabe in der Home-App.
+
+Die Funktion ist **Opt-in**: Ohne `presence`-Einträge mit `active: true` passiert nichts. Einrichtung entweder im Setup-Wizard (Schritt 4, Abschnitt „Anwesenheit per WLAN“) oder in der `config.json`:
+
+```json
+{
+  "presence": [
+    {
+      "active": true,
+      "name": "iPhone Anna",
+      "address": "AA:BB:CC:DD:EE:FF",
+      "accType": "occupancy",
+      "offDelay": 300
+    }
+  ],
+  "options": {
+    "presence": { "anyone": true, "guest": false, "accType": "occupancy" }
+  }
+}
+```
+
+| Feld | Bedeutung |
+|---|---|
+| `address` | IPv4- oder MAC-Adresse wie in der FRITZ!Box unter *Heimnetz → Netzwerk* angezeigt (Groß-/Kleinschreibung egal) |
+| `accType` | `occupancy` (Belegung) oder `motion` (Bewegung) |
+| `onDelay` | Sekunden, die das Gerät verbunden sein muss, bevor der Sensor „erkannt“ meldet (Standard 0) |
+| `offDelay` | Sekunden, die das Gerät weg sein muss, bevor der Sensor „nicht erkannt“ meldet (**Standard 300**) |
+| `options.presence.anyone` | zusätzlicher Sensor „Anyone“: erkannt, solange mindestens ein Gerät erkannt ist |
+| `options.presence.guest` | zusätzlicher Sensor „Guest“: erkannt, solange ein Gerät im Gast-WLAN ist |
+
+**Wichtig für iPhone/iPad — private WLAN-Adresse:** iOS nutzt je WLAN eine eigene „private WLAN-Adresse“, die sich je nach Einstellung (*Rotierend*) regelmäßig ändert. Damit die Zuordnung hält:
+
+1. Auf dem iPhone *Einstellungen → WLAN → (i) neben dem Heim-WLAN → Private WLAN-Adresse* auf **Fest** stellen (oder ausschalten). Die neue Adresse gilt erst nach dem nächsten Verbinden: WLAN einmal aus- und wieder einschalten.
+2. In der FRITZ!Box das Gerät öffnen (*Heimnetz → Netzwerk → Gerät → Heimnetz*) und die **MAC-Adresse von dort** übernehmen, **nicht** die am iPhone angezeigte. Beide können abweichen, im Test mit FRITZ!Repeatern im Mesh war das der Fall.
+3. **Besser:** dort **„IPv4-Adresse dauerhaft zuweisen“** aktivieren und diese IP als `address` eintragen. Das ist die robusteste Zuordnung.
+
+Bleibt ein Sensor dauerhaft auf „nicht erkannt“, obwohl das Gerät im WLAN ist: in der FRITZ!Box nachsehen, unter welcher MAC/IP es gerade geführt wird, und die Config anpassen.
+
+**Warum die Abmeldeverzögerung:** Schlafende iPhones trennen sich zum Stromsparen immer wieder kurz vom WLAN. Ohne Verzögerung springt der Sensor ständig zwischen „zu Hause“ und „weg“. `offDelay` unter 60 s erzeugt deshalb eine Warnung im Log; 300 s (5 min) ist ein guter Startwert, bei Fehlalarmen auf 600–900 s erhöhen. Die Erkennung ist so schnell wie das Polling (`options.polling.timer`, Standard 15 s) plus Verzögerung.
+
+**Grenzen:** Die FRITZ!Box meldet nur, ob das Gerät verbunden ist — nicht, ob es wirklich jemand bei sich trägt. Jeder Abfragezyklus fragt die Host-Liste der FRITZ!Box ab (zusätzliche Last bei vielen Geräten oder kurzem Polling-Intervall). Meldet das Log beim Abruf der Host-Liste einen Berechtigungsfehler, dem FRITZ!Box-Benutzer zusätzlich *FRITZ!Box-Einstellungen* geben (wie bei den Router-Switches). Beim Bewegungssensor zeigt die Eve-App keine Verlaufsgrafik (fakegato ist gestubbt).
+
 ## Migration vom Original-Plugin
 
 Wenn du bisher das unmaintained Original `homebridge-fritz-platform@6.0.19` eingesetzt hast:
@@ -199,7 +245,7 @@ Wenn du bisher das unmaintained Original `homebridge-fritz-platform@6.0.19` eing
 2. **Update Homebridge auf 2.x**: `sudo npm install -g homebridge@latest`
 3. **Original-Plugin entfernen**: `sudo npm uninstall -g homebridge-fritz-platform`
 4. **Dieses Plugin installieren**: `sudo npm install -g @pellebot/homebridge-fritz-platform-hb2`
-5. **Config anpassen**: nicht-mehr-unterstützte Subsysteme aus der Config entfernen (`presence`, `callmonitor`, `wol`, `childLock`, `network`, `extras`, `telegram` — werden eh ignoriert, aber sauberer wenn weg).
+5. **Config anpassen**: nicht-mehr-unterstützte Subsysteme aus der Config entfernen (`callmonitor`, `wol`, `childLock`, `network`, `extras`, `telegram` — werden eh ignoriert, aber sauberer wenn weg). Bestehende `presence`-Einträge werden seit v1.3.0 wieder ausgewertet; `offDelay` prüfen (Standard jetzt 300 s), `ping`/`threshold`/`blockTelegram` werden nicht unterstützt.
 6. **Homebridge neu starten**
 
 Accessory-UUIDs basieren auf AIN + Name. Wer Device-Namen unverändert lässt, behält das HomeKit-Pairing bei und muss nichts in der Home-App neu zuordnen.

package/config.schema.json

@@ -708,6 +708,69 @@
         }
       }
     },
+    "presence": {
+      "title": "Presence (WLAN, optional)",
+      "type": "array",
+      "description": "Opt-in since v1.3.0. Exposes an occupancy or motion sensor that shows whether a device (e.g. an iPhone) is connected to the FRITZ!Box network. Off unless an entry is set to active.",
+      "items": {
+        "type": "object",
+        "properties": {
+          "active": {
+            "title": "Active",
+            "type": "boolean",
+            "default": false,
+            "description": "If enabled, the presence sensor will be exposed to HomeKit."
+          },
+          "name": {
+            "title": "Name",
+            "type": "string",
+            "placeholder": "iPhone Andreas",
+            "description": "Name of the sensor in HomeKit. Must be unique and must not be \"Anyone\" or \"Guest\".",
+            "required": true
+          },
+          "address": {
+            "title": "IP or MAC address",
+            "type": "string",
+            "placeholder": "AA:BB:CC:DD:EE:FF",
+            "description": "IPv4 or MAC address of the device as shown in the FRITZ!Box (Heimnetz > Netzwerk). iPhones use a private Wi-Fi address: set it to \"Fixed\" for the home network, reconnect once, then take the MAC address from the FRITZ!Box device details (not the one shown on the phone) or, better, assign a permanent IPv4 address there and use that IP.",
+            "required": true
+          },
+          "accType": {
+            "title": "Accessory Type",
+            "type": "string",
+            "default": "occupancy",
+            "oneOf": [
+              {
+                "title": "Occupancy Sensor",
+                "enum": [
+                  "occupancy"
+                ]
+              },
+              {
+                "title": "Motion Sensor",
+                "enum": [
+                  "motion"
+                ]
+              }
+            ]
+          },
+          "onDelay": {
+            "title": "Arrival delay (seconds)",
+            "type": "integer",
+            "minimum": 0,
+            "placeholder": 0,
+            "description": "Seconds the device must be connected before the sensor switches to detected. Default 0."
+          },
+          "offDelay": {
+            "title": "Leave delay (seconds)",
+            "type": "integer",
+            "minimum": 0,
+            "placeholder": 300,
+            "description": "Seconds the device must be disconnected before the sensor switches to not detected. Default 300. Sleeping iPhones leave the Wi-Fi for short periods; values below 60 make the sensor flap."
+          }
+        }
+      }
+    },
     "options": {
       "titel": "Options",
       "type": "object",
@@ -740,6 +803,43 @@
               }
             }
           }
+        },
+        "presence": {
+          "title": "Presence",
+          "type": "object",
+          "properties": {
+            "anyone": {
+              "title": "\"Anyone\" sensor",
+              "type": "boolean",
+              "default": false,
+              "description": "Additional sensor that is detected as long as at least one active presence device is detected."
+            },
+            "guest": {
+              "title": "\"Guest\" sensor",
+              "type": "boolean",
+              "default": false,
+              "description": "Additional sensor that is detected while at least one device is connected to the guest WLAN."
+            },
+            "accType": {
+              "title": "Accessory Type for Anyone/Guest",
+              "type": "string",
+              "default": "occupancy",
+              "oneOf": [
+                {
+                  "title": "Occupancy Sensor",
+                  "enum": [
+                    "occupancy"
+                  ]
+                },
+                {
+                  "title": "Motion Sensor",
+                  "enum": [
+                    "motion"
+                  ]
+                }
+              ]
+            }
+          }
         }
       }
     }
@@ -902,6 +1002,33 @@
         }
       ]
     },
+    {
+      "title": "Presence (WLAN, optional)",
+      "description": "Opt-in: shows in HomeKit whether a phone is in the home network. Leave empty to keep the feature off.",
+      "expandable": true,
+      "expanded": false,
+      "orderable": false,
+      "type": "section",
+      "items": [
+        {
+          "key": "presence",
+          "type": "array",
+          "orderable": false,
+          "buttonText": "Add Presence Device",
+          "items": [
+            "presence[].active",
+            "presence[].name",
+            "presence[].address",
+            "presence[].accType",
+            "presence[].onDelay",
+            "presence[].offDelay"
+          ]
+        },
+        "options.presence.anyone",
+        "options.presence.guest",
+        "options.presence.accType"
+      ]
+    },
     {
       "title": "Options",
       "orderable": false,

package/homebridge-ui/public/index.html

@@ -307,6 +307,40 @@
         </div>
       </details>
 
+      <!-- v1.3.0: optional WLAN presence (opt-in) -->
+      <details id="presenceDetails" style="margin-top: 1rem;">
+        <summary style="cursor: pointer;"><strong>Anwesenheit per WLAN (optional)</strong> — zeigt in HomeKit, ob ein Handy im Heimnetz ist</summary>
+        <div style="margin-top: 0.5rem; padding: 0.5rem; border-left: 3px solid #339DE0;">
+          <p style="font-size: 0.9rem;">
+            Je Gerät ein Sensor (Belegung oder Bewegung). Zuordnung über die IP- oder MAC-Adresse,
+            wie sie die FRITZ!Box unter <em>Heimnetz → Netzwerk</em> anzeigt.
+            <strong>iPhone/iPad:</strong> In den WLAN-Einstellungen des Geräts für das Heim-WLAN
+            <em>Private WLAN-Adresse → Fest</em> (bzw. „Aus“) wählen, WLAN einmal neu verbinden und dann die
+            MAC-Adresse <strong>aus der FRITZ!Box-Oberfläche</strong> nehmen (nicht die am iPhone angezeigte) oder besser
+            dort die IPv4-Adresse dauerhaft zuweisen und die IP eintragen.
+            Die <em>Abmeldeverzögerung</em> verhindert, dass der Sensor springt, wenn ein schlafendes
+            iPhone kurz aus dem WLAN geht (Standard 300 s).
+          </p>
+          <div id="presenceList"></div>
+          <button id="presenceAdd" type="button" class="btn btn-sm btn-outline-primary">+ Gerät hinzufügen</button>
+          <div style="margin-top: 0.75rem;">
+            <div class="form-check">
+              <input type="checkbox" id="presenceAnyone" class="form-check-input">
+              <label class="form-check-label" for="presenceAnyone">Zusätzlicher Sensor <em>„Anyone“</em> (jemand ist zu Hause)</label>
+            </div>
+            <div class="form-check">
+              <input type="checkbox" id="presenceGuest" class="form-check-input">
+              <label class="form-check-label" for="presenceGuest">Zusätzlicher Sensor <em>„Guest“</em> (Gerät im Gast-WLAN)</label>
+            </div>
+            <label for="presenceAccType" style="font-size: 0.9rem; margin-top: 0.25rem;">Typ für Anyone/Guest:</label>
+            <select id="presenceAccType" class="form-select form-select-sm" style="max-width: 220px; display: inline-block;">
+              <option value="occupancy">Belegungssensor</option>
+              <option value="motion">Bewegungssensor</option>
+            </select>
+          </div>
+        </div>
+      </details>
+
       <div class="wizard-nav">
         <button id="backTo3" class="btn btn-outline-secondary">← Zurück zu Schritt 3</button>
         <button id="goTo5" class="btn btn-primary">Weiter zu Schritt 5 →</button>
@@ -352,7 +386,9 @@
       energyTiles: {},            // { ain: [{ obisChannel, name }, ...] } after step 3
       energyAccType: 'energy-temperature', // 'energy-temperature' | 'energy-light' — chosen in step 3
       routerSwitches: {},         // { wifi_guest: bool, wps: bool, ... } after step 4
-      existingConfig: null,       // Phase G: { master, smarthome[] } from current config.json (null = first run)
+      existingConfig: null,       // Phase G: { master, smarthome[], presence[], presenceOptions } from current config.json (null = first run)
+      presence: null,             // v1.3.0: [{ active, name, address, accType, onDelay?, offDelay }] (null = not touched yet)
+      presenceOptions: null,      // v1.3.0: { anyone, guest, accType }
     };
 
     // ============ DOM References ============
@@ -410,7 +446,10 @@
         if (!fritz) return null;
         const master = (fritz.devices || []).find((d) => d && d.master === true) || null;
         const smarthome = Array.isArray(fritz.smarthome) ? fritz.smarthome : [];
-        return { master, smarthome };
+        // v1.3.0: keep presence entries so a wizard re-run does not drop them
+        const presence = Array.isArray(fritz.presence) ? fritz.presence : [];
+        const presenceOptions = (fritz.options && fritz.options.presence) || null;
+        return { master, smarthome, presence, presenceOptions };
       } catch (err) {
         return null;
       }
@@ -670,17 +709,85 @@
     goTo4.addEventListener('click', () => {
       showStep(4);
       hydrateRouterSwitches();
+      hydratePresence();
     });
     backTo3.addEventListener('click', () => showStep(3));
 
     const goTo5 = document.getElementById('goTo5');
     const backTo4 = document.getElementById('backTo4');
     goTo5.addEventListener('click', () => {
+      collectPresence();
       showStep(5);
       renderSavePreview();
     });
     backTo4.addEventListener('click', () => showStep(4));
 
+    // ============ Step 4b — Presence (optional, v1.3.0) ============
+    const presenceList = document.getElementById('presenceList');
+
+    function presenceRow(entry) {
+      const e = entry || { active: true, name: '', address: '', accType: 'occupancy', offDelay: 300 };
+      const row = document.createElement('div');
+      row.className = 'presence-row device-card';
+      row.style.cssText = 'display:flex; flex-wrap:wrap; gap:0.5rem; align-items:center; margin-bottom:0.5rem;';
+      if (typeof e.onDelay === 'number') row.dataset.onDelay = String(e.onDelay);
+      row.innerHTML = `
+        <input type="checkbox" class="form-check-input p-active" title="Aktiv" ${e.active ? 'checked' : ''}>
+        <input type="text" class="form-control form-control-sm p-name" placeholder="Name, z.B. iPhone Anna" style="max-width:180px;" value="${escapeHtml(e.name || '')}">
+        <input type="text" class="form-control form-control-sm p-address" placeholder="IP oder MAC" style="max-width:170px;" value="${escapeHtml(e.address || '')}">
+        <select class="form-select form-select-sm p-acctype" style="max-width:150px;">
+          <option value="occupancy" ${e.accType !== 'motion' ? 'selected' : ''}>Belegung</option>
+          <option value="motion" ${e.accType === 'motion' ? 'selected' : ''}>Bewegung</option>
+        </select>
+        <label style="font-size:0.8rem;">Abmeldung nach
+          <input type="number" min="0" class="form-control form-control-sm p-offdelay" style="width:80px; display:inline-block;" value="${typeof e.offDelay === 'number' ? e.offDelay : 300}"> s</label>
+        <button type="button" class="btn btn-sm btn-outline-danger p-remove" title="Entfernen">✕</button>
+      `;
+      row.querySelector('.p-remove').addEventListener('click', () => row.remove());
+      presenceList.appendChild(row);
+    }
+
+    function hydratePresence() {
+      if (presenceList.dataset.hydrated) return; // keep user edits when navigating back
+      presenceList.dataset.hydrated = '1';
+      const cfg = wizardState.existingConfig || {};
+      const entries = cfg.presence || [];
+      entries.forEach((e) => presenceRow(e));
+      const opts = cfg.presenceOptions || {};
+      document.getElementById('presenceAnyone').checked = !!opts.anyone;
+      document.getElementById('presenceGuest').checked = !!opts.guest;
+      document.getElementById('presenceAccType').value = opts.accType === 'motion' ? 'motion' : 'occupancy';
+      if (entries.length || opts.anyone || opts.guest) document.getElementById('presenceDetails').open = true;
+    }
+
+    document.getElementById('presenceAdd').addEventListener('click', () => presenceRow(null));
+
+    function collectPresence() {
+      if (!presenceList.dataset.hydrated) return; // step 4 never shown — keep existing as is
+      const entries = [];
+      presenceList.querySelectorAll('.presence-row').forEach((row) => {
+        const name = row.querySelector('.p-name').value.trim();
+        const address = row.querySelector('.p-address').value.trim();
+        if (!name && !address) return;
+        const off = parseInt(row.querySelector('.p-offdelay').value, 10);
+        const entry = {
+          active: row.querySelector('.p-active').checked,
+          name,
+          address,
+          accType: row.querySelector('.p-acctype').value,
+          offDelay: Number.isFinite(off) && off >= 0 ? off : 300,
+        };
+        if (row.dataset.onDelay) entry.onDelay = parseInt(row.dataset.onDelay, 10);
+        entries.push(entry);
+      });
+      wizardState.presence = entries;
+      wizardState.presenceOptions = {
+        anyone: document.getElementById('presenceAnyone').checked,
+        guest: document.getElementById('presenceGuest').checked,
+        accType: document.getElementById('presenceAccType').value,
+      };
+    }
+
     // ============ Step 5 — Build + Save ============
 
     /**
@@ -786,7 +893,7 @@
         }
       }
 
-      return {
+      const config = {
         platform: 'FritzPlatform',
         name: 'FritzBox',
         devices: [master],
@@ -795,6 +902,19 @@
           polling: { timer: 30 },
         },
       };
+
+      // v1.3.0: presence (opt-in). Use the wizard input if step 4 was shown,
+      // otherwise carry over what is already in config.json.
+      const existing = wizardState.existingConfig || {};
+      const presence = wizardState.presence !== null ? wizardState.presence : existing.presence || [];
+      const presenceOptions =
+        wizardState.presenceOptions !== null ? wizardState.presenceOptions : existing.presenceOptions || null;
+      if (presence.length) config.presence = presence;
+      if (presenceOptions && (presenceOptions.anyone || presenceOptions.guest)) {
+        config.options.presence = presenceOptions;
+      }
+
+      return config;
     }
 
     /**
@@ -868,6 +988,13 @@
         lines.push(`Entfernt: <code>${escapeHtml(o.ain)}</code>${chan} — war <em>${escapeHtml(o.accType)}</em> "${escapeHtml(o.name || '')}"`);
       }
 
+      // -- Presence (v1.3.0) --
+      const oldPresence = (existing.presence || []).filter((p) => p && p.active).map((p) => `${p.name}|${p.address}|${p.accType || 'occupancy'}|${p.offDelay}`);
+      const newPresence = (newConfig.presence || []).filter((p) => p && p.active).map((p) => `${p.name}|${p.address}|${p.accType || 'occupancy'}|${p.offDelay}`);
+      if (oldPresence.sort().join(';') !== newPresence.sort().join(';')) {
+        lines.push(`Anwesenheit: ${oldPresence.length} → ${newPresence.length} aktive(r) Sensor(en)`);
+      }
+
       if (lines.length === 0) {
         return `
           <div class="alert alert-secondary">
@@ -911,6 +1038,7 @@
             <li><strong>${nDevices}</strong> Smart-Home-Gerät(e) (Thermostate, Lampen, Sensoren, Schalter)</li>
             <li><strong>${nEnergy}</strong> Energy-Tile(s) für FRITZ!Smart Energy 250 OBIS-Reader</li>
             <li><strong>${nRouter}</strong> Router-Switch(es) als HomeKit-Tiles</li>
+            <li><strong>${(config.presence || []).filter((p) => p.active).length}</strong> Anwesenheitssensor(en) (WLAN, optional)</li>
           </ul>
         </div>
       `;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@pellebot/homebridge-fritz-platform-hb2",
   "displayName": "Homebridge FRITZ!Box Platform (HB2)",
-  "version": "1.2.1",
-  "description": "Homebridge 2.0 plugin for AVM FRITZ!DECT devices (thermostats, lamps, sensors, OBIS smart-meter readers) and FRITZ!Box router switches (Guest WLAN, WPS). Node 22 / 24 ready.",
+  "version": "1.3.0",
+  "description": "Homebridge 2.0 plugin for AVM FRITZ!DECT devices (thermostats, lamps, sensors, OBIS smart-meter readers) FRITZ!Box router switches (Guest WLAN, WPS) and optional WLAN presence sensors. Node 22 / 24 ready.",
   "icon": "https://raw.githubusercontent.com/PelleBot/homebridge-fritz-platform-ng/main/branding/Icon.png",
   "type": "module",
   "main": "index.mjs",
@@ -42,7 +42,8 @@
     "avm",
     "thermostat",
     "fritz-dect",
-    "homebridge-2"
+    "homebridge-2",
+    "presence"
   ],
   "engines": {
     "node": "^22.12.0 || ^24.0.0",

package/src/accessories/presence/motion/motion.accessory.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const moment = require('moment');
+const logger = require('../../../utils/logger');
+const Handler = require('../presence.handler');
+const GuestHandler = require('../presence_guest.handler');
+
+const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
+
+class Accessory {
+  constructor(api, accessory, accessories, meshMaster, HistoryService) {
+    this.api = api;
+    this.accessory = accessory;
+    this.accessories = accessories;
+    this.HistoryService = HistoryService;
+
+    if (accessory.displayName === 'Guest') {
+      this.handler = GuestHandler.configure(api, accessories, accessory.context.config.polling, meshMaster);
+    } else {
+      this.handler = Handler.configure(api, accessories, accessory.context.config.polling, meshMaster);
+    }
+
+    this.getService();
+  }
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+  // Services
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+  async getService() {
+    let service = this.accessory.getService(this.api.hap.Service.MotionSensor);
+    let serviceOld = this.accessory.getService(this.api.hap.Service.OccupancySensor);
+
+    if (serviceOld) {
+      logger.info(
+        'Removing Occupancy service',
+        `${this.accessory.displayName} (${this.accessory.context.config.subtype})`
+      );
+      this.accessory.removeService(serviceOld);
+    }
+
+    if (!service) {
+      logger.info('Adding Motion service', `${this.accessory.displayName} (${this.accessory.context.config.subtype})`);
+      service = this.accessory.addService(
+        this.api.hap.Service.MotionSensor,
+        this.accessory.displayName,
+        this.accessory.context.config.subtype
+      );
+    }
+
+    if (!service.testCharacteristic(this.api.hap.Characteristic.LastActivation)) {
+      service.addCharacteristic(this.api.hap.Characteristic.LastActivation);
+    }
+
+    this.historyService = new this.HistoryService('motion', this.accessory, {
+      storage: 'fs',
+      path: this.api.user.storagePath() + '/fritzbox/',
+      disableTimer: true,
+    });
+
+    await timeout(250); //wait for historyService to load
+
+    service
+      .getCharacteristic(this.api.hap.Characteristic.MotionDetected)
+      .on('change', (context) => this.handler.change(context, this.accessory, null, this.historyService));
+
+    this.refreshHistory(service);
+  }
+
+  async refreshHistory(service) {
+    let state = service.getCharacteristic(this.api.hap.Characteristic.MotionDetected).value;
+
+    this.historyService.addEntry({
+      time: moment().unix(),
+      status: state ? 1 : 0,
+    });
+
+    setTimeout(() => {
+      this.refreshHistory(service);
+    }, 10 * 60 * 1000);
+  }
+}
+
+module.exports = Accessory;

package/src/accessories/presence/occupancy/occupancy.accessory.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const logger = require('../../../utils/logger');
+const Handler = require('../presence.handler');
+const GuestHandler = require('../presence_guest.handler');
+
+class Accessory {
+  constructor(api, accessory, accessories, meshMaster) {
+    this.api = api;
+    this.accessory = accessory;
+
+    if (accessory.displayName === 'Guest') {
+      this.handler = GuestHandler.configure(api, accessories, accessory.context.config.polling, meshMaster);
+    } else {
+      this.handler = Handler.configure(api, accessories, accessory.context.config.polling, meshMaster);
+    }
+
+    this.getService();
+  }
+
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+  // Services
+  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+  async getService() {
+    let service = this.accessory.getService(this.api.hap.Service.OccupancySensor);
+    let serviceOld = this.accessory.getService(this.api.hap.Service.MotionSensor);
+
+    if (serviceOld) {
+      logger.info(
+        'Removing Motion service',
+        `${this.accessory.displayName} (${this.accessory.context.config.subtype})`
+      );
+      this.accessory.removeService(serviceOld);
+    }
+
+    if (!service) {
+      logger.info(
+        'Adding Occupancy service',
+        `${this.accessory.displayName} (${this.accessory.context.config.subtype})`
+      );
+      service = this.accessory.addService(
+        this.api.hap.Service.OccupancySensor,
+        this.accessory.displayName,
+        this.accessory.context.config.subtype
+      );
+    }
+
+    service
+      .getCharacteristic(this.api.hap.Characteristic.OccupancyDetected)
+      .on('change', (context) => this.handler.change(context, this.accessory));
+  }
+}
+
+module.exports = Accessory;

package/src/accessories/presence/presence.config.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { validIP, validMAC } = require('../../utils/utils');
+
+// Default leave delay (seconds). iPhones drop off the WLAN for short periods
+// while asleep; without a delay the sensor would flap between home/away.
+const DEFAULT_OFF_DELAY = 300;
+
+const toInt = (value, fallback) => {
+  const parsed = parseInt(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
+
+const Config = (userConfig) => {
+  const validTypes = ['occupancy', 'motion'];
+  const rawAddress = typeof userConfig.address === 'string' ? userConfig.address.trim() : userConfig.address;
+
+  return {
+    active: userConfig.active || false,
+    name: userConfig.name,
+    // MACs are normalised to upper case (FRITZ!Box host list format)
+    address: validIP(rawAddress) || validMAC(typeof rawAddress === 'string' ? rawAddress.toUpperCase() : rawAddress),
+    type: 'presence',
+    subtype: validTypes.find((el) => el === userConfig.accType) || 'occupancy',
+    blockTelegram: userConfig.blockTelegram || false,
+    // Ping fallback of the original plugin is not supported in this fork
+    // (sleeping iPhones do not answer ICMP either; needs the system ping binary).
+    ping: false,
+    threshold: parseInt(userConfig.threshold) || 0,
+    accType: validTypes.find((el) => el === userConfig.accType) || 'occupancy',
+    onDelay: toInt(userConfig.onDelay, 0),
+    offDelay: toInt(userConfig.offDelay, DEFAULT_OFF_DELAY),
+  };
+};
+
+module.exports = Config;

package/src/accessories/presence/presence.handler.js

@@ -0,0 +1,322 @@
+'use strict';
+
+const moment = require('moment');
+const ping = require('ping');
+const logger = require('../../utils/logger');
+const { validIP } = require('../../utils/utils');
+const Telegram = require('../../lib/telegram');
+
+class Handler {
+  constructor() {
+    this.hosts = [];
+    this.configured = false;
+  }
+
+  configure(api, accessories, polling, meshMaster) {
+    if (this.configured) {
+      return this;
+    }
+
+    this.api = api;
+    this.accessories = accessories;
+    this.polling = polling;
+    this.fritzbox = meshMaster.fritzbox;
+
+    this.configured = true;
+
+    setTimeout(() => this.poll(), 1000);
+
+    return this;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async change(context, accessory, subtype, historyService) {
+    if (context.oldValue !== context.newValue) {
+      if (!this.configured) {
+        logger.debug(
+          'Handler not configured yet. Skipping CHANGE event.',
+          `${accessory.displayName} (${accessory.context.config.subtype})`
+        );
+        return;
+      }
+
+      subtype = subtype || accessory.context.config.subtype;
+
+      // The fakegato stub may not implement getInitialTime() (see issue #2)
+      if (historyService && typeof historyService.getInitialTime === 'function') {
+        const lastActivation = moment().unix() - historyService.getInitialTime();
+
+        accessory
+          .getService(this.api.hap.Service.MotionSensor)
+          .getCharacteristic(this.api.hap.Characteristic.LastActivation)
+          .updateValue(lastActivation);
+
+        historyService.addEntry({ time: moment().unix(), status: context.newValue ? 1 : 0 });
+      }
+
+      if (!accessory.context.config.blockTelegram) {
+        let dest = false;
+
+        if (context.newValue) {
+          dest = accessory.displayName === 'Anyone' ? 'anyone_in' : 'user_in';
+        } else {
+          dest = accessory.displayName === 'Anyone' ? 'anyone_out' : 'user_out';
+        }
+
+        Telegram.send('presence', dest, accessory.displayName === 'Anyone' ? false : accessory.displayName);
+      }
+    }
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async get(accessory, subtype, ownCharacteristic) {
+    if (!this.configured) {
+      logger.debug(
+        'Handler not configured yet. Skipping GET event.',
+        `${accessory.displayName} (${accessory.context.config.subtype})`
+      );
+      return accessory.context.config.subtype === 'motion' ? false : 0;
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    subtype = subtype || accessory.context.config.subtype;
+
+    const service =
+      accessory.context.config.subtype === 'motion'
+        ? this.api.hap.Service.MotionSensor
+        : this.api.hap.Service.OccupancySensor;
+
+    const characteristic =
+      accessory.context.config.subtype === 'motion'
+        ? this.api.hap.Characteristic.MotionDetected
+        : this.api.hap.Characteristic.OccupancyDetected;
+
+    let state = accessory.getService(service).getCharacteristic(characteristic).value;
+
+    if (accessory.displayName === 'Anyone') {
+      const states = this.accessories
+        .filter(
+          (accessory) =>
+            accessory.context.config.type === 'presence' &&
+            accessory.displayName !== 'Anyone' &&
+            accessory.displayName !== 'Guest'
+        )
+        .map((accessory) => {
+          const service2 =
+            accessory.context.config.subtype === 'motion'
+              ? this.api.hap.Service.MotionSensor
+              : this.api.hap.Service.OccupancySensor;
+
+          const characteristic2 =
+            accessory.context.config.subtype === 'motion'
+              ? this.api.hap.Characteristic.MotionDetected
+              : this.api.hap.Characteristic.OccupancyDetected;
+
+          const state = accessory.getService(service2).getCharacteristic(characteristic2).value
+            ? 'detected'
+            : 'not detected';
+
+          return state;
+        });
+
+      state = states.includes('detected');
+    } else {
+      let oldState = accessory.getService(service).getCharacteristic(characteristic).value;
+      let newState = oldState;
+
+      const host = this.hosts.find((host) => this.matchesHost(host, accessory.context.config.address));
+
+      if (host) {
+        logger.debug(host, `${accessory.displayName} (${subtype})`);
+
+        newState = host.active;
+        const address = host.ip;
+        const onDelay = accessory.context.config.onDelay;
+        const offDelay = accessory.context.config.offDelay;
+        const threshold = accessory.context.config.threshold;
+
+        if (newState == state && accessory.context.config.ping) {
+          const res = await ping.promise.probe(address);
+
+          if (res.alive != newState) {
+            logger.debug('Ping and FritzBox states are not equal.', `${accessory.displayName} (${subtype})`);
+
+            if (res.alive) {
+              accessory.context.lastSeen = Date.now();
+              newState = res.alive;
+
+              logger.debug('Taking the value of Ping. (DETECTED)', `${accessory.displayName} (${subtype})`);
+            } else {
+              if (accessory.context.lastSeen) {
+                let lastSeenMoment = moment(accessory.context.lastSeen);
+                let activeThreshold = moment().subtract(threshold, 'm');
+
+                if (lastSeenMoment.isAfter(activeThreshold)) {
+                  newState = true;
+                  accessory.context.lastSeen = false;
+
+                  logger.debug(
+                    'Taking the value of Ping. (DETECTED - THRESHOLD REACHED)',
+                    `${accessory.displayName} (${subtype})`
+                  );
+                } else {
+                  newState = false;
+
+                  logger.debug(
+                    'Taking the value of Ping. (NOT DETECTED - THRESHOLD NOT REACHED)',
+                    `${accessory.displayName} (${subtype})`
+                  );
+                }
+              }
+            }
+          }
+        }
+
+        if (newState != state) {
+          if (accessory.context.changedOn) {
+            let millis = Date.now() - accessory.context.changedOn;
+            let secElapsed = Math.floor(millis / 1000);
+
+            let passed = false;
+
+            if (newState && secElapsed > onDelay) {
+              passed = true;
+            } else if (!newState && secElapsed > offDelay) {
+              passed = true;
+            }
+
+            if (passed) {
+              state = newState;
+              accessory.context.changedOn = false;
+            }
+          } else {
+            accessory.context.changedOn = Date.now();
+
+            logger.info(
+              `Occupancy state changed to ${newState ? 'DETECTED' : 'NOT DETECTED'}`,
+              `${accessory.displayName} (${subtype})`
+            );
+
+            logger.info(
+              `Wait ${newState ? onDelay : offDelay}s before switching state!`,
+              `${accessory.displayName} (${subtype})`
+            );
+          }
+        } else {
+          if (accessory.context.changedOn) {
+            accessory.context.changedOn = false;
+
+            logger.info(
+              `Occupancy state switched back to ${newState ? 'DETECTED' : 'NOT DETECTED'}`,
+              `${accessory.displayName} (${subtype})`
+            );
+          }
+        }
+      }
+    }
+
+    if (state) {
+      state = accessory.context.config.subtype === 'motion' ? true : 1;
+    } else {
+      state = accessory.context.config.subtype === 'motion' ? false : 0;
+    }
+
+    accessory.getService(service).getCharacteristic(characteristic).updateValue(state);
+
+    return state;
+  }
+
+  // IP match, or case-insensitive MAC match (host.mac may be empty)
+  matchesHost(host, address) {
+    if (!host || !address) return false;
+    if (host.ip === address) return true;
+    return typeof host.mac === 'string' && host.mac.toUpperCase() === String(address).toUpperCase();
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async set(state, accessory, subtype, ownCharacteristic) {}
+
+  async poll() {
+    try {
+      this.hosts = await this.fritzbox.getAllHostsV2();
+      //logger.debug(this.hosts, 'Hosts');
+
+      if (this.hosts.length) {
+        const userAccessories = this.accessories.filter(
+          (accessory) =>
+            accessory &&
+            accessory.context &&
+            accessory.context.config.type === 'presence' &&
+            accessory.displayName !== 'Anyone' &&
+            accessory.displayName !== 'Guest'
+        );
+
+        for (const accessory of userAccessories) {
+          const host = this.hosts.find((host) => this.matchesHost(host, accessory.context.config.address));
+
+          if (!host) {
+            logger.debug(
+              'User could not be found in hosts list. Looking for user manually.',
+              `${accessory.displayName} (${accessory.context.config.subtype})`
+            );
+
+            try {
+              const service = validIP(accessory.context.config.address)
+                ? 'X_AVM-DE_GetSpecificHostEntryByIP'
+                : 'GetSpecificHostEntry';
+
+              const input = validIP(accessory.context.config.address)
+                ? { NewIPAddress: accessory.context.config.address }
+                : { NewMACAddress: accessory.context.config.address };
+
+              const user = await this.fritzbox.exec('urn:LanDeviceHosts-com:serviceId:Hosts1', service, input);
+
+              this.hosts.push({
+                mac: user.NewMACAddress,
+                ip: user.NewIPAddress,
+                active: user.NewActive === '1',
+                name: user.NewHostName,
+                interface: user.NewInterfaceType,
+              });
+            } catch (err) {
+              if (err.soap && err.soap.errorDescription === 'NoSuchEntryInArray') {
+                logger.debug(
+                  'User could not be found manually. Setting user to inactive.',
+                  `${accessory.displayName} (${accessory.context.config.subtype})`
+                );
+
+                this.hosts.push({
+                  mac: accessory.context.config.address,
+                  ip: accessory.context.config.address,
+                  active: false,
+                  name: accessory.displayName,
+                  interface: '802.11',
+                });
+              } else {
+                throw new Error(err);
+              }
+            }
+          }
+
+          await this.get(accessory);
+        }
+
+        const anyoneAccessory = this.accessories.find(
+          (accessory) => accessory.context.config.type === 'presence' && accessory.displayName === 'Anyone'
+        );
+
+        if (anyoneAccessory) {
+          await this.get(anyoneAccessory);
+        }
+      }
+    } catch (err) {
+      logger.warn('An error occurred during polling hosts!');
+      logger.error(err);
+    } finally {
+      setTimeout(() => this.poll(), this.polling.timer * 1000);
+    }
+  }
+}
+
+const handler = new Handler();
+module.exports = handler;

package/src/accessories/presence/presence.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = {
+  PresenceMotionAccessory: require('./motion/motion.accessory'),
+  PresenceOccupancyAccessory: require('./occupancy/occupancy.accessory'),
+  PresenceHandler: require('./presence.handler'),
+  PresenceConfig: require('./presence.config'),
+  PresenceSetup: require('./presence.setup'),
+};

package/src/accessories/presence/presence.setup.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const logger = require('../../utils/logger');
+const { UUIDgenerate } = require('../../utils/utils');
+const Config = require('./presence.config');
+
+const Setup = (devices, presenceConfig, presenceOptions) => {
+  let exposed = false;
+
+  presenceConfig.forEach((config) => {
+    let error = false;
+    const user = Config(config);
+
+    if (!user.active) {
+      error = true;
+    } else if (!user.name) {
+      logger.warn('One of the PRESENCE devices has no name configured. This user will be skipped.');
+      error = true;
+    } else if (user.name === 'Anyone') {
+      logger.warn(
+        'One of the PRESENCE devices is called "Anyone". Please change name of this device! This device will be skipped.',
+        user.name
+      );
+      error = true;
+    } else if (!user.address) {
+      logger.warn(
+        'There is no or no valid IP/MAC address configured for this PRESENCE device. This device will be skipped.',
+        user.name
+      );
+      error = true;
+    }
+
+    if (!error && user.offDelay < 60) {
+      logger.warn(
+        `offDelay is ${user.offDelay}s. Sleeping iPhones often leave the WLAN for a few minutes; ` +
+          'values below 60s will make the sensor flap. Recommended: 300s or more.',
+        user.name
+      );
+    }
+
+    if (!error) {
+      const uuid = UUIDgenerate(user.name);
+
+      if (devices.has(uuid)) {
+        logger.warn('Multiple devices are configured with this name. Duplicate devices will be skipped.', user.name);
+      } else {
+        logger.debug('New device added!', user.name);
+        devices.set(uuid, user);
+
+        exposed = true;
+      }
+    }
+  });
+
+  if (presenceOptions.anyone && exposed) {
+    const validTypes = ['occupancy', 'motion'];
+
+    const anyoneConfig = {
+      name: 'Anyone',
+      type: 'presence',
+      subtype: validTypes.find((el) => el === presenceOptions.accType) || 'occupancy',
+      accType: validTypes.find((el) => el === presenceOptions.accType) || 'occupancy',
+    };
+
+    const uuid = UUIDgenerate(anyoneConfig.name);
+
+    if (devices.has(uuid)) {
+      logger.warn(
+        'Multiple devices are configured with this name. Duplicate devices will be skipped.',
+        anyoneConfig.name
+      );
+    } else {
+      logger.debug('New device added!', anyoneConfig.name);
+      devices.set(uuid, anyoneConfig);
+    }
+  }
+
+  if (presenceOptions.guest) {
+    const validTypes = ['occupancy', 'motion'];
+
+    const guestConfig = {
+      name: 'Guest',
+      type: 'presence',
+      subtype: validTypes.find((el) => el === presenceOptions.accType) || 'occupancy',
+      accType: validTypes.find((el) => el === presenceOptions.accType) || 'occupancy',
+    };
+
+    const uuid = UUIDgenerate(guestConfig.name);
+
+    if (devices.has(uuid)) {
+      logger.warn(
+        'Multiple devices are configured with this name. Duplicate devices will be skipped.',
+        guestConfig.name
+      );
+    } else {
+      logger.debug('New device added!', guestConfig.name);
+      devices.set(uuid, guestConfig);
+    }
+  }
+};
+
+module.exports = Setup;

package/src/accessories/presence/presence_guest.handler.js

@@ -0,0 +1,138 @@
+'use strict';
+
+const moment = require('moment');
+const logger = require('../../utils/logger');
+const Telegram = require('../../lib/telegram');
+
+class Handler {
+  constructor() {
+    this.hosts = [];
+    this.configured = false;
+  }
+
+  configure(api, accessories, polling, meshMaster) {
+    if (this.configured) {
+      return this;
+    }
+
+    this.api = api;
+    this.accessories = accessories;
+    this.polling = polling;
+    this.wifiUnitGuest = meshMaster.wifiUnits + 1;
+    this.fritzbox = meshMaster.fritzbox;
+
+    this.configured = true;
+
+    setTimeout(() => this.poll(), 1000);
+
+    return this;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async change(context, accessory, subtype, historyService) {
+    if (context.oldValue !== context.newValue) {
+      if (!this.configured) {
+        logger.debug(
+          'Handler not configured yet. Skipping CHANGE event.',
+          `${accessory.displayName} (${accessory.context.config.subtype})`
+        );
+        return;
+      }
+
+      subtype = subtype || accessory.context.config.subtype;
+
+      // The fakegato stub may not implement getInitialTime() (see issue #2)
+      if (historyService && typeof historyService.getInitialTime === 'function') {
+        const lastActivation = moment().unix() - historyService.getInitialTime();
+
+        accessory
+          .getService(this.api.hap.Service.MotionSensor)
+          .getCharacteristic(this.api.hap.Characteristic.LastActivation)
+          .updateValue(lastActivation);
+
+        historyService.addEntry({ time: moment().unix(), status: context.newValue ? 1 : 0 });
+      }
+
+      let dest = false;
+
+      if (context.newValue) {
+        dest = 'guest_in';
+
+        logger.info(
+          'Someone connected to Guest Wifi',
+          `${accessory.displayName} (${accessory.context.config.subtype})`
+        );
+      } else {
+        dest = 'guest_out';
+
+        logger.info('No one connected to Guest Wifi', `${accessory.displayName} (${accessory.context.config.subtype})`);
+      }
+
+      Telegram.send('presence', dest, false);
+    }
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async get(accessory, subtype, ownCharacteristic) {
+    if (!this.configured) {
+      logger.debug(
+        'Handler not configured yet. Skipping GET event.',
+        `${accessory.displayName} (${accessory.context.config.subtype})`
+      );
+      return accessory.context.config.subtype === 'motion' ? false : 0;
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    subtype = subtype || accessory.context.config.subtype;
+
+    const service =
+      accessory.context.config.subtype === 'motion'
+        ? this.api.hap.Service.MotionSensor
+        : this.api.hap.Service.OccupancySensor;
+
+    const characteristic =
+      accessory.context.config.subtype === 'motion'
+        ? this.api.hap.Characteristic.MotionDetected
+        : this.api.hap.Characteristic.OccupancyDetected;
+
+    let state = accessory.getService(service).getCharacteristic(characteristic).value;
+
+    const response = await this.fritzbox.exec(
+      `urn:WLANConfiguration-com:serviceId:WLANConfiguration${this.wifiUnitGuest}`,
+      'GetTotalAssociations'
+    );
+
+    logger.debug(response, `${accessory.displayName} (${subtype})`);
+
+    const connectedToGuestWifi = parseInt(response.NewTotalAssociations);
+
+    if (connectedToGuestWifi) {
+      state = accessory.context.config.subtype === 'motion' ? true : 1;
+    } else {
+      state = accessory.context.config.subtype === 'motion' ? false : 0;
+    }
+
+    accessory.getService(service).getCharacteristic(characteristic).updateValue(state);
+
+    return state;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async set(state, accessory, subtype, ownCharacteristic) {}
+
+  async poll() {
+    try {
+      const guestAccessory = this.accessories.find((accessory) => accessory && accessory.displayName === 'Guest');
+
+      await this.get(guestAccessory);
+    } catch (err) {
+      logger.warn('An error occurred during polling guest device!');
+      logger.error(err);
+    } finally {
+      setTimeout(() => this.poll(), this.polling.timer * 1000);
+    }
+  }
+}
+
+const handler = new Handler();
+module.exports = handler;

package/src/platform.js

@@ -7,7 +7,7 @@ const { version } = require('../package.json');
 const Telegram = require('./lib/telegram');
 
 // Accessories — DECT-only Minimal-Patch-Fork.
-// Out-of-scope subsystems (callmonitor, presence, network, wol, childlock) are not
+// Out-of-scope subsystems (callmonitor, network, wol, childlock) are not
 // wired in here. Their directories remain in src/accessories/ as dead code — they
 // are intentionally not deleted because router/router.accessory.js still has a
 // top-level require('../extras/extras.handler') that would fail at load time
@@ -42,6 +42,15 @@ const {
   SHSetup,
 } = require('./accessories/smarthome/smarthome');
 
+// Presence (WLAN occupancy/motion sensors) — opt-in since v1.3.0.
+// Only devices with `active: true` in config.presence (plus the optional
+// "Anyone"/"Guest" sensors from options.presence) are exposed.
+const {
+  PresenceMotionAccessory,
+  PresenceOccupancyAccessory,
+  PresenceSetup,
+} = require('./accessories/presence/presence');
+
 //Custom Types
 const CustomTypes = require('./types/custom.types');
 const EveTypes = require('./types/eve.types');
@@ -122,6 +131,10 @@ function FritzPlatform(log, config, api) {
     SHSetup(this.devices, this.config.smarthome);
   }
 
+  if (this.config.presence.length || this.config.options.presence.guest) {
+    PresenceSetup(this.devices, this.config.presence, this.config.options.presence);
+  }
+
   this.api.on('didFinishLaunching', this.didFinishLaunching.bind(this));
 }
 
@@ -233,6 +246,11 @@ FritzPlatform.prototype = {
         else if (device.subtype === 'smarthome-energy-light')
           new SHEnergyLightAccessory(this.api, accessory, this.accessories, this.meshMaster, HistoryService);
         break;
+      case 'presence':
+        if (device.subtype === 'motion')
+          new PresenceMotionAccessory(this.api, accessory, this.accessories, this.meshMaster, HistoryService);
+        else new PresenceOccupancyAccessory(this.api, accessory, this.accessories, this.meshMaster);
+        break;
       default:
         logger.warn(`Can not setup accessory, type (${device.type}) unknown!`, device.name);
         break;